FFmpeg
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 "av1.h"
25 #include "avc.h"
26 #include "hevc.h"
27 #include "avformat.h"
28 #include "avio_internal.h"
29 #include "avlanguage.h"
30 #include "flacenc.h"
31 #include "internal.h"
32 #include "isom.h"
33 #include "matroska.h"
34 #include "riff.h"
35 #include "vorbiscomment.h"
36 #include "wv.h"
37 
38 #include "libavutil/avstring.h"
40 #include "libavutil/crc.h"
41 #include "libavutil/dict.h"
42 #include "libavutil/intfloat.h"
43 #include "libavutil/intreadwrite.h"
44 #include "libavutil/lfg.h"
46 #include "libavutil/mathematics.h"
47 #include "libavutil/opt.h"
48 #include "libavutil/parseutils.h"
49 #include "libavutil/random_seed.h"
50 #include "libavutil/rational.h"
51 #include "libavutil/samplefmt.h"
52 #include "libavutil/stereo3d.h"
53 
54 #include "libavcodec/xiph.h"
55 #include "libavcodec/mpeg4audio.h"
56 
57 /* Level 1 elements we create a SeekHead entry for:
58  * Info, Tracks, Chapters, Attachments, Tags (potentially twice) and Cues */
59 #define MAX_SEEKHEAD_ENTRIES 7
60 
61 #define IS_SEEKABLE(pb, mkv) (((pb)->seekable & AVIO_SEEKABLE_NORMAL) && \
62  !(mkv)->is_live)
63 
64 enum {
68 };
69 
70 typedef struct ebml_master {
71  int64_t pos; ///< absolute offset in the containing AVIOContext where the master's elements start
72  int sizebytes; ///< how many bytes were reserved for the size
73 } ebml_master;
74 
75 typedef struct ebml_stored_master {
77  int64_t pos;
79 
80 typedef struct mkv_seekhead_entry {
81  uint32_t elementid;
82  uint64_t segmentpos;
84 
85 typedef struct mkv_seekhead {
86  int64_t filepos;
90 } mkv_seekhead;
91 
92 typedef struct mkv_cuepoint {
93  uint64_t pts;
95  int64_t cluster_pos; ///< offset of the cluster containing the block relative to the segment
96  int64_t relative_pos; ///< relative offset from the position of the cluster containing the block
97  int64_t duration; ///< duration of the block according to time base
98 } mkv_cuepoint;
99 
100 typedef struct mkv_cues {
103 } mkv_cues;
104 
105 typedef struct mkv_track {
107  int has_cue;
108  uint64_t uid;
109  unsigned track_num;
113  int64_t last_timestamp;
114  int64_t duration;
117  int64_t ts_offset;
118 } mkv_track;
119 
120 #define MODE_MATROSKAv2 0x01
121 #define MODE_WEBM 0x02
122 
123 typedef struct MatroskaMuxContext {
124  const AVClass *class;
125  int mode;
129  int64_t segment_offset;
131  int64_t cluster_pos; ///< file offset of the current Cluster
132  int64_t cluster_pts;
134  int64_t duration;
138  int64_t cues_pos;
139 
141 
142  unsigned nb_attachments;
144 
147 
152  int is_live;
153 
154  int is_dash;
159 
160  uint32_t segment_uid[4];
162 
163 /** 2 bytes * 7 for EBML IDs, 7 1-byte EBML lengths, 6 1-byte uint,
164  * 8 byte for "matroska" doctype string */
165 #define MAX_EBML_HEADER_SIZE 35
166 
167 /** 2 bytes * 3 for EBML IDs, 3 1-byte EBML lengths, 8 bytes for 64 bit
168  * offset, 4 bytes for target EBML ID */
169 #define MAX_SEEKENTRY_SIZE 21
170 
171 /** 4 * (1-byte EBML ID, 1-byte EBML size, 8-byte uint max) */
172 #define MAX_CUETRACKPOS_SIZE 40
173 
174 /** Seek preroll value for opus */
175 #define OPUS_SEEK_PREROLL 80000000
176 
177 static int ebml_id_size(uint32_t id)
178 {
179  return (av_log2(id) + 7U) / 8;
180 }
181 
182 static void put_ebml_id(AVIOContext *pb, uint32_t id)
183 {
184  int i = ebml_id_size(id);
185  while (i--)
186  avio_w8(pb, (uint8_t)(id >> (i * 8)));
187 }
188 
189 /**
190  * Write an EBML size meaning "unknown size".
191  *
192  * @param bytes The number of bytes the size should occupy (maximum: 8).
193  */
194 static void put_ebml_size_unknown(AVIOContext *pb, int bytes)
195 {
196  av_assert0(bytes <= 8);
197  avio_w8(pb, 0x1ff >> bytes);
198  ffio_fill(pb, 0xff, bytes - 1);
199 }
200 
201 /**
202  * Returns how many bytes are needed to represent a number
203  * as EBML variable length integer.
204  */
205 static int ebml_num_size(uint64_t num)
206 {
207  int bytes = 0;
208  do {
209  bytes++;
210  } while (num >>= 7);
211  return bytes;
212 }
213 
214 /**
215  * Calculate how many bytes are needed to represent the length field
216  * of an EBML element whose payload has a given length.
217  */
218 static int ebml_length_size(uint64_t length)
219 {
220  return ebml_num_size(length + 1);
221 }
222 
223 /**
224  * Write a number as EBML variable length integer on `bytes` bytes.
225  * `bytes` is taken literally without checking.
226  */
227 static void put_ebml_num(AVIOContext *pb, uint64_t num, int bytes)
228 {
229  num |= 1ULL << bytes * 7;
230  for (int i = bytes - 1; i >= 0; i--)
231  avio_w8(pb, (uint8_t)(num >> i * 8));
232 }
233 
234 /**
235  * Write a length as EBML variable length integer.
236  *
237  * @param bytes The number of bytes that need to be used to write the number.
238  * If zero, the minimal number of bytes will be used.
239  */
240 static void put_ebml_length(AVIOContext *pb, uint64_t length, int bytes)
241 {
242  int needed_bytes = ebml_length_size(length);
243 
244  // sizes larger than this are currently undefined in EBML
245  av_assert0(length < (1ULL << 56) - 1);
246 
247  if (bytes == 0)
248  bytes = needed_bytes;
249  // The bytes needed to write the given size must not exceed
250  // the bytes that we ought to use.
251  av_assert0(bytes >= needed_bytes);
252  put_ebml_num(pb, length, bytes);
253 }
254 
255 /**
256  * Write a (random) UID with fixed size to make the output more deterministic
257  */
258 static void put_ebml_uid(AVIOContext *pb, uint32_t elementid, uint64_t uid)
259 {
260  put_ebml_id(pb, elementid);
261  put_ebml_length(pb, 8, 0);
262  avio_wb64(pb, uid);
263 }
264 
265 static void put_ebml_uint(AVIOContext *pb, uint32_t elementid, uint64_t val)
266 {
267  int i, bytes = 1;
268  uint64_t tmp = val;
269  while (tmp >>= 8)
270  bytes++;
271 
272  put_ebml_id(pb, elementid);
273  put_ebml_length(pb, bytes, 0);
274  for (i = bytes - 1; i >= 0; i--)
275  avio_w8(pb, (uint8_t)(val >> i * 8));
276 }
277 
278 static void put_ebml_sint(AVIOContext *pb, uint32_t elementid, int64_t val)
279 {
280  int i, bytes = 1;
281  uint64_t tmp = 2*(val < 0 ? val^-1 : val);
282 
283  while (tmp >>= 8)
284  bytes++;
285 
286  put_ebml_id(pb, elementid);
287  put_ebml_length(pb, bytes, 0);
288  for (i = bytes - 1; i >= 0; i--)
289  avio_w8(pb, (uint8_t)(val >> i * 8));
290 }
291 
292 static void put_ebml_float(AVIOContext *pb, uint32_t elementid, double val)
293 {
294  put_ebml_id(pb, elementid);
295  put_ebml_length(pb, 8, 0);
296  avio_wb64(pb, av_double2int(val));
297 }
298 
299 static void put_ebml_binary(AVIOContext *pb, uint32_t elementid,
300  const void *buf, int size)
301 {
302  put_ebml_id(pb, elementid);
303  put_ebml_length(pb, size, 0);
304  avio_write(pb, buf, size);
305 }
306 
307 static void put_ebml_string(AVIOContext *pb, uint32_t elementid,
308  const char *str)
309 {
310  put_ebml_binary(pb, elementid, str, strlen(str));
311 }
312 
313 /**
314  * Write a void element of a given size. Useful for reserving space in
315  * the file to be written to later.
316  *
317  * @param size The number of bytes to reserve, which must be at least 2.
318  */
319 static void put_ebml_void(AVIOContext *pb, int size)
320 {
321  av_assert0(size >= 2);
322 
324  // we need to subtract the length needed to store the size from the
325  // size we need to reserve so 2 cases, we use 8 bytes to store the
326  // size if possible, 1 byte otherwise
327  if (size < 10) {
328  size -= 2;
329  put_ebml_length(pb, size, 0);
330  } else {
331  size -= 9;
332  put_ebml_length(pb, size, 8);
333  }
334  ffio_fill(pb, 0, size);
335 }
336 
337 static ebml_master start_ebml_master(AVIOContext *pb, uint32_t elementid,
338  uint64_t expectedsize)
339 {
340  int bytes = expectedsize ? ebml_length_size(expectedsize) : 8;
341 
342  put_ebml_id(pb, elementid);
343  put_ebml_size_unknown(pb, bytes);
344  return (ebml_master) { avio_tell(pb), bytes };
345 }
346 
348 {
349  int64_t pos = avio_tell(pb);
350 
351  if (avio_seek(pb, master.pos - master.sizebytes, SEEK_SET) < 0)
352  return;
353  put_ebml_length(pb, pos - master.pos, master.sizebytes);
354  avio_seek(pb, pos, SEEK_SET);
355 }
356 
357 static void mkv_add_seekhead_entry(MatroskaMuxContext *mkv, uint32_t elementid,
358  uint64_t filepos)
359 {
360  mkv_seekhead *seekhead = &mkv->seekhead;
361 
363 
364  seekhead->entries[seekhead->num_entries].elementid = elementid;
365  seekhead->entries[seekhead->num_entries++].segmentpos = filepos - mkv->segment_offset;
366 }
367 
369 {
370  int ret;
371 
372  if (!*dyn_cp && (ret = avio_open_dyn_buf(dyn_cp)) < 0)
373  return ret;
374 
375  if (mkv->write_crc)
376  put_ebml_void(*dyn_cp, 6); /* Reserve space for CRC32 so position/size calculations using avio_tell() take it into account */
377 
378  return 0;
379 }
380 
382  MatroskaMuxContext *mkv, uint32_t id,
383  int length_size, int keep_buffer,
384  int add_seekentry)
385 {
386  uint8_t *buf, crc[4];
387  int ret, size, skip = 0;
388 
389  size = avio_get_dyn_buf(*dyn_cp, &buf);
390  if ((ret = (*dyn_cp)->error) < 0)
391  goto fail;
392 
393  if (add_seekentry)
394  mkv_add_seekhead_entry(mkv, id, avio_tell(pb));
395 
396  put_ebml_id(pb, id);
397  put_ebml_length(pb, size, length_size);
398  if (mkv->write_crc) {
399  skip = 6; /* Skip reserved 6-byte long void element from the dynamic buffer. */
400  AV_WL32(crc, av_crc(av_crc_get_table(AV_CRC_32_IEEE_LE), UINT32_MAX, buf + skip, size - skip) ^ UINT32_MAX);
401  put_ebml_binary(pb, EBML_ID_CRC32, crc, sizeof(crc));
402  }
403  avio_write(pb, buf + skip, size - skip);
404 
405 fail:
406  if (keep_buffer) {
407  ffio_reset_dyn_buf(*dyn_cp);
408  } else {
409  ffio_free_dyn_buf(dyn_cp);
410  }
411  return ret;
412 }
413 
414 /**
415  * Output EBML master. Keep the buffer if seekable, allowing for later updates.
416  * Furthermore always add a SeekHead Entry for this element.
417  */
419  ebml_stored_master *elem,
420  MatroskaMuxContext *mkv, uint32_t id)
421 {
422  if (IS_SEEKABLE(pb, mkv)) {
423  uint8_t *buf;
424  int size = avio_get_dyn_buf(elem->bc, &buf);
425 
426  if (elem->bc->error < 0)
427  return elem->bc->error;
428 
429  elem->pos = avio_tell(pb);
430  mkv_add_seekhead_entry(mkv, id, elem->pos);
431 
432  put_ebml_id(pb, id);
433  put_ebml_length(pb, size, 0);
434  avio_write(pb, buf, size);
435 
436  return 0;
437  } else
438  return end_ebml_master_crc32(pb, &elem->bc, mkv, id, 0, 0, 1);
439 }
440 
441 static void put_xiph_size(AVIOContext *pb, int size)
442 {
443  ffio_fill(pb, 255, size / 255);
444  avio_w8(pb, size % 255);
445 }
446 
447 /**
448  * Free the members allocated in the mux context.
449  */
451 {
452  MatroskaMuxContext *mkv = s->priv_data;
453 
455 
457  ffio_free_dyn_buf(&mkv->info.bc);
458  ffio_free_dyn_buf(&mkv->track.bc);
459  ffio_free_dyn_buf(&mkv->tags.bc);
460 
461  av_freep(&mkv->cues.entries);
462  av_freep(&mkv->tracks);
463 }
464 
465 /**
466  * Initialize the SeekHead element to be ready to index level 1 Matroska
467  * elements. Enough space to write MAX_SEEKHEAD_ENTRIES SeekHead entries
468  * will be reserved at the current file location.
469  */
471 {
472  mkv->seekhead.filepos = avio_tell(pb);
473  // 21 bytes max for a Seek entry, 6 bytes max for the SeekHead ID
474  // and size, 6 bytes for a CRC32 element, and 2 bytes to guarantee
475  // that an EBML void element will fit afterwards
478 }
479 
480 /**
481  * Write the SeekHead to the file at the location reserved for it
482  * and seek to destpos afterwards. When error_on_seek_failure
483  * is not set, failure to seek to the position designated for the
484  * SeekHead is not considered an error and it is presumed that
485  * destpos is the current position; failure to seek to destpos
486  * afterwards is always an error.
487  *
488  * @return 0 on success, < 0 on error.
489  */
491  int error_on_seek_failure, int64_t destpos)
492 {
493  AVIOContext *dyn_cp = NULL;
494  mkv_seekhead *seekhead = &mkv->seekhead;
495  int64_t remaining, ret64;
496  int i, ret;
497 
498  if ((ret64 = avio_seek(pb, seekhead->filepos, SEEK_SET)) < 0)
499  return error_on_seek_failure ? ret64 : 0;
500 
501  ret = start_ebml_master_crc32(&dyn_cp, mkv);
502  if (ret < 0)
503  return ret;
504 
505  for (i = 0; i < seekhead->num_entries; i++) {
506  mkv_seekhead_entry *entry = &seekhead->entries[i];
509 
511  put_ebml_length(dyn_cp, ebml_id_size(entry->elementid), 0);
512  put_ebml_id(dyn_cp, entry->elementid);
513 
515  end_ebml_master(dyn_cp, seekentry);
516  }
517  ret = end_ebml_master_crc32(pb, &dyn_cp, mkv,
518  MATROSKA_ID_SEEKHEAD, 0, 0, 0);
519  if (ret < 0)
520  return ret;
521 
522  remaining = seekhead->filepos + seekhead->reserved_size - avio_tell(pb);
523  put_ebml_void(pb, remaining);
524 
525  if ((ret64 = avio_seek(pb, destpos, SEEK_SET)) < 0)
526  return ret64;
527 
528  return 0;
529 }
530 
531 static int mkv_add_cuepoint(MatroskaMuxContext *mkv, int stream, int64_t ts,
532  int64_t cluster_pos, int64_t relative_pos, int64_t duration)
533 {
534  mkv_cues *cues = &mkv->cues;
535  mkv_cuepoint *entries = cues->entries;
536 
537  if (ts < 0)
538  return 0;
539 
540  entries = av_realloc_array(entries, cues->num_entries + 1, sizeof(mkv_cuepoint));
541  if (!entries)
542  return AVERROR(ENOMEM);
543  cues->entries = entries;
544 
545  cues->entries[cues->num_entries].pts = ts;
546  cues->entries[cues->num_entries].stream_idx = stream;
547  cues->entries[cues->num_entries].cluster_pos = cluster_pos - mkv->segment_offset;
548  cues->entries[cues->num_entries].relative_pos = relative_pos;
549  cues->entries[cues->num_entries++].duration = duration;
550 
551  return 0;
552 }
553 
554 static int mkv_assemble_cues(AVStream **streams, AVIOContext *dyn_cp,
555  mkv_cues *cues, mkv_track *tracks, int num_tracks)
556 {
557  AVIOContext *cuepoint;
558  int ret;
559 
560  ret = avio_open_dyn_buf(&cuepoint);
561  if (ret < 0)
562  return ret;
563 
564  for (mkv_cuepoint *entry = cues->entries, *end = entry + cues->num_entries;
565  entry < end;) {
566  uint64_t pts = entry->pts;
567  uint8_t *buf;
568  int size;
569 
570  put_ebml_uint(cuepoint, MATROSKA_ID_CUETIME, pts);
571 
572  // put all the entries from different tracks that have the exact same
573  // timestamp into the same CuePoint
574  for (int j = 0; j < num_tracks; j++)
575  tracks[j].has_cue = 0;
576  do {
577  ebml_master track_positions;
578  int idx = entry->stream_idx;
579 
580  av_assert0(idx >= 0 && idx < num_tracks);
581  if (tracks[idx].has_cue && streams[idx]->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE)
582  continue;
583  tracks[idx].has_cue = 1;
585  put_ebml_uint(cuepoint, MATROSKA_ID_CUETRACK , tracks[idx].track_num);
586  put_ebml_uint(cuepoint, MATROSKA_ID_CUECLUSTERPOSITION , entry->cluster_pos);
587  put_ebml_uint(cuepoint, MATROSKA_ID_CUERELATIVEPOSITION, entry->relative_pos);
588  if (entry->duration != -1)
589  put_ebml_uint(cuepoint, MATROSKA_ID_CUEDURATION , entry->duration);
590  end_ebml_master(cuepoint, track_positions);
591  } while (++entry < end && entry->pts == pts);
592  size = avio_get_dyn_buf(cuepoint, &buf);
593  if ((ret = cuepoint->error) < 0)
594  break;
595  put_ebml_binary(dyn_cp, MATROSKA_ID_POINTENTRY, buf, size);
596  ffio_reset_dyn_buf(cuepoint);
597  }
598  ffio_free_dyn_buf(&cuepoint);
599 
600  return ret;
601 }
602 
604  const AVCodecParameters *par)
605 {
606  const uint8_t *header_start[3];
607  int header_len[3];
608  int first_header_size;
609  int err, j;
610 
611  if (par->codec_id == AV_CODEC_ID_VORBIS)
612  first_header_size = 30;
613  else
614  first_header_size = 42;
615 
617  first_header_size, header_start, header_len);
618  if (err < 0) {
619  av_log(s, AV_LOG_ERROR, "Extradata corrupt.\n");
620  return err;
621  }
622 
623  avio_w8(pb, 2); // number packets - 1
624  for (j = 0; j < 2; j++) {
625  put_xiph_size(pb, header_len[j]);
626  }
627  for (j = 0; j < 3; j++)
628  avio_write(pb, header_start[j], header_len[j]);
629 
630  return 0;
631 }
632 
633 static int put_wv_codecpriv(AVIOContext *pb, const AVCodecParameters *par)
634 {
635  if (par->extradata && par->extradata_size == 2)
636  avio_write(pb, par->extradata, 2);
637  else
638  avio_wl16(pb, 0x410); // fallback to the most recent version
639  return 0;
640 }
641 
643  const AVCodecParameters *par)
644 {
645  int write_comment = (par->channel_layout &&
646  !(par->channel_layout & ~0x3ffffULL) &&
648  int ret = ff_flac_write_header(pb, par->extradata, par->extradata_size,
649  !write_comment);
650 
651  if (ret < 0)
652  return ret;
653 
654  if (write_comment) {
655  const char *vendor = (s->flags & AVFMT_FLAG_BITEXACT) ?
656  "Lavf" : LIBAVFORMAT_IDENT;
657  AVDictionary *dict = NULL;
658  uint8_t buf[32];
659  int64_t len;
660 
661  snprintf(buf, sizeof(buf), "0x%"PRIx64, par->channel_layout);
662  av_dict_set(&dict, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", buf, 0);
663 
664  len = ff_vorbiscomment_length(dict, vendor, NULL, 0);
665  av_assert1(len < (1 << 24) - 4);
666 
667  avio_w8(pb, 0x84);
668  avio_wb24(pb, len);
669 
670  ff_vorbiscomment_write(pb, dict, vendor, NULL, 0);
671 
672  av_dict_free(&dict);
673  }
674 
675  return 0;
676 }
677 
679  const uint8_t *extradata, int extradata_size,
680  int *sample_rate, int *output_sample_rate)
681 {
682  MPEG4AudioConfig mp4ac;
683  int ret;
684 
685  ret = avpriv_mpeg4audio_get_config2(&mp4ac, extradata, extradata_size, 1, s);
686  /* Don't abort if the failure is because of missing extradata. Assume in that
687  * case a bitstream filter will provide the muxer with the extradata in the
688  * first packet.
689  * Abort however if s->pb is not seekable, as we would not be able to seek back
690  * to write the sample rate elements once the extradata shows up, anyway. */
691  if (ret < 0 && (extradata_size || !IS_SEEKABLE(s->pb, mkv))) {
692  av_log(s, AV_LOG_ERROR,
693  "Error parsing AAC extradata, unable to determine samplerate.\n");
694  return AVERROR(EINVAL);
695  }
696 
697  if (ret < 0) {
698  /* This will only happen when this function is called while writing the
699  * header and no extradata is available. The space for this element has
700  * to be reserved for when this function is called again after the
701  * extradata shows up in the first packet, as there's no way to know if
702  * output_sample_rate will be different than sample_rate or not. */
703  *output_sample_rate = *sample_rate;
704  } else {
705  *sample_rate = mp4ac.sample_rate;
706  *output_sample_rate = mp4ac.ext_sample_rate;
707  }
708  return 0;
709 }
710 
712  const AVCodecParameters *par,
713  AVIOContext *dyn_cp)
714 {
715  switch (par->codec_id) {
716  case AV_CODEC_ID_VORBIS:
717  case AV_CODEC_ID_THEORA:
718  return put_xiph_codecpriv(s, dyn_cp, par);
719  case AV_CODEC_ID_FLAC:
720  return put_flac_codecpriv(s, dyn_cp, par);
721  case AV_CODEC_ID_WAVPACK:
722  return put_wv_codecpriv(dyn_cp, par);
723  case AV_CODEC_ID_H264:
724  return ff_isom_write_avcc(dyn_cp, par->extradata,
725  par->extradata_size);
726  case AV_CODEC_ID_HEVC:
727  return ff_isom_write_hvcc(dyn_cp, par->extradata,
728  par->extradata_size, 0);
729  case AV_CODEC_ID_AV1:
730  if (par->extradata_size)
731  return ff_isom_write_av1c(dyn_cp, par->extradata,
732  par->extradata_size);
733  else
734  put_ebml_void(pb, 4 + 3);
735  break;
736  case AV_CODEC_ID_ALAC:
737  if (par->extradata_size < 36) {
738  av_log(s, AV_LOG_ERROR,
739  "Invalid extradata found, ALAC expects a 36-byte "
740  "QuickTime atom.");
741  return AVERROR_INVALIDDATA;
742  } else
743  avio_write(dyn_cp, par->extradata + 12,
744  par->extradata_size - 12);
745  break;
746  case AV_CODEC_ID_AAC:
747  if (par->extradata_size)
748  avio_write(dyn_cp, par->extradata, par->extradata_size);
749  else
750  put_ebml_void(pb, MAX_PCE_SIZE + 2 + 4);
751  break;
752  default:
753  if (par->codec_id == AV_CODEC_ID_PRORES &&
755  avio_wl32(dyn_cp, par->codec_tag);
756  } else if (par->extradata_size && par->codec_id != AV_CODEC_ID_TTA)
757  avio_write(dyn_cp, par->extradata, par->extradata_size);
758  }
759 
760  return 0;
761 }
762 
764  AVCodecParameters *par,
765  int native_id, int qt_id)
766 {
767  AVIOContext *dyn_cp;
768  MatroskaMuxContext *mkv = s->priv_data;
769  uint8_t *codecpriv;
770  int ret, codecpriv_size;
771 
772  ret = avio_open_dyn_buf(&dyn_cp);
773  if (ret < 0)
774  return ret;
775 
776  if (native_id) {
777  ret = mkv_write_native_codecprivate(s, pb, par, dyn_cp);
778  } else if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
779  if (qt_id) {
780  if (!par->codec_tag)
782  par->codec_id);
785  ) {
786  int i;
787  avio_wb32(dyn_cp, 0x5a + par->extradata_size);
788  avio_wl32(dyn_cp, par->codec_tag);
789  for(i = 0; i < 0x5a - 8; i++)
790  avio_w8(dyn_cp, 0);
791  }
792  avio_write(dyn_cp, par->extradata, par->extradata_size);
793  } else {
795  av_log(s, AV_LOG_WARNING, "codec %s is not supported by this format\n",
796  avcodec_get_name(par->codec_id));
797 
798  if (!par->codec_tag)
800  par->codec_id);
801  if (!par->codec_tag && par->codec_id != AV_CODEC_ID_RAWVIDEO) {
802  av_log(s, AV_LOG_ERROR, "No bmp codec tag found for codec %s\n",
803  avcodec_get_name(par->codec_id));
804  ret = AVERROR(EINVAL);
805  }
806 
807  ff_put_bmp_header(dyn_cp, par, 0, 0, mkv->flipped_raw_rgb);
808  }
809  } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
810  unsigned int tag;
812  if (!tag) {
813  av_log(s, AV_LOG_ERROR, "No wav codec tag found for codec %s\n",
814  avcodec_get_name(par->codec_id));
815  ret = AVERROR(EINVAL);
816  }
817  if (!par->codec_tag)
818  par->codec_tag = tag;
819 
821  }
822 
823  if (ret >= 0) {
824  codecpriv_size = avio_get_dyn_buf(dyn_cp, &codecpriv);
825  if ((ret = dyn_cp->error) >= 0 && codecpriv_size)
827  codecpriv_size);
828  }
829  ffio_free_dyn_buf(&dyn_cp);
830  return ret;
831 }
832 
833 static void mkv_write_video_color(AVIOContext *pb, const AVStream *st,
834  const AVCodecParameters *par)
835 {
836  /* 18 Elements with two bytes ID, one byte length field, 8 bytes payload
837  * a master element with two bytes ID and one byte length field
838  * plus another byte to stay clear of the end. */
839  uint8_t colour[(2 + 1 + 8) * 18 + (2 + 1) + 1];
840  AVIOContext buf, *dyn_cp = &buf;
841  int colorinfo_size;
842  const void *side_data;
843 
844  ffio_init_context(dyn_cp, colour, sizeof(colour), 1, NULL, NULL, NULL, NULL);
845 
846  if (par->color_trc != AVCOL_TRC_UNSPECIFIED &&
847  par->color_trc < AVCOL_TRC_NB) {
849  par->color_trc);
850  }
851  if (par->color_space != AVCOL_SPC_UNSPECIFIED &&
852  par->color_space < AVCOL_SPC_NB) {
854  }
856  par->color_primaries < AVCOL_PRI_NB) {
858  }
859  if (par->color_range != AVCOL_RANGE_UNSPECIFIED &&
860  par->color_range < AVCOL_RANGE_NB) {
862  }
865  int xpos, ypos;
866 
867  avcodec_enum_to_chroma_pos(&xpos, &ypos, par->chroma_location);
868  put_ebml_uint(dyn_cp, MATROSKA_ID_VIDEOCOLORCHROMASITINGHORZ, (xpos >> 7) + 1);
869  put_ebml_uint(dyn_cp, MATROSKA_ID_VIDEOCOLORCHROMASITINGVERT, (ypos >> 7) + 1);
870  }
871 
873  NULL);
874  if (side_data) {
875  const AVContentLightMetadata *metadata = side_data;
878  }
879 
881  NULL);
882  if (side_data) {
883  ebml_master meta_element = start_ebml_master(
884  dyn_cp, MATROSKA_ID_VIDEOCOLORMASTERINGMETA, 10 * (2 + 1 + 8));
885  const AVMasteringDisplayMetadata *metadata = side_data;
886  if (metadata->has_primaries) {
888  av_q2d(metadata->display_primaries[0][0]));
890  av_q2d(metadata->display_primaries[0][1]));
892  av_q2d(metadata->display_primaries[1][0]));
894  av_q2d(metadata->display_primaries[1][1]));
896  av_q2d(metadata->display_primaries[2][0]));
898  av_q2d(metadata->display_primaries[2][1]));
900  av_q2d(metadata->white_point[0]));
902  av_q2d(metadata->white_point[1]));
903  }
904  if (metadata->has_luminance) {
906  av_q2d(metadata->max_luminance));
908  av_q2d(metadata->min_luminance));
909  }
910  end_ebml_master(dyn_cp, meta_element);
911  }
912 
913  colorinfo_size = avio_tell(dyn_cp);
914  if (colorinfo_size)
915  put_ebml_binary(pb, MATROSKA_ID_VIDEOCOLOR, colour, colorinfo_size);
916 }
917 
919  const AVStream *st)
920 {
921  ebml_master projection;
922  uint8_t private[20];
923 
924  const AVSphericalMapping *spherical =
926  NULL);
927 
928  if (!spherical)
929  return;
930 
931  if (spherical->projection != AV_SPHERICAL_EQUIRECTANGULAR &&
933  spherical->projection != AV_SPHERICAL_CUBEMAP) {
934  av_log(s, AV_LOG_WARNING, "Unknown projection type\n");
935  return;
936  }
937 
938  // Maximally 4 8-byte elements with id-length 2 + 1 byte length field
939  // and the private data of the AV_SPHERICAL_EQUIRECTANGULAR_TILE case
941  4 * (2 + 1 + 8) + (2 + 1 + 20));
942 
943  switch (spherical->projection) {
947  break;
951  AV_WB32(private, 0); // version + flags
952  AV_WB32(private + 4, spherical->bound_top);
953  AV_WB32(private + 8, spherical->bound_bottom);
954  AV_WB32(private + 12, spherical->bound_left);
955  AV_WB32(private + 16, spherical->bound_right);
957  private, 20);
958  break;
962  AV_WB32(private, 0); // version + flags
963  AV_WB32(private + 4, 0); // layout
964  AV_WB32(private + 8, spherical->padding);
966  private, 12);
967  break;
968  default:
969  av_assert0(0);
970  }
971 
972  if (spherical->yaw)
974  (double) spherical->yaw / (1 << 16));
975  if (spherical->pitch)
977  (double) spherical->pitch / (1 << 16));
978  if (spherical->roll)
980  (double) spherical->roll / (1 << 16));
981 
982  end_ebml_master(pb, projection);
983 }
984 
986  enum AVFieldOrder field_order)
987 {
988  switch (field_order) {
989  case AV_FIELD_UNKNOWN:
990  break;
994  break;
995  case AV_FIELD_TT:
996  case AV_FIELD_BB:
997  case AV_FIELD_TB:
998  case AV_FIELD_BT:
1001  if (mode != MODE_WEBM) {
1002  switch (field_order) {
1003  case AV_FIELD_TT:
1006  break;
1007  case AV_FIELD_BB:
1010  break;
1011  case AV_FIELD_TB:
1014  break;
1015  case AV_FIELD_BT:
1018  break;
1019  }
1020  }
1021  }
1022 }
1023 
1025  AVStream *st, int mode, int *h_width, int *h_height)
1026 {
1027  const AVDictionaryEntry *tag;
1029  const AVStereo3D *stereo;
1030 
1031  *h_width = 1;
1032  *h_height = 1;
1033  // convert metadata into proper side data and add it to the stream
1034  if ((tag = av_dict_get(st->metadata, "stereo_mode", NULL, 0)) ||
1035  (tag = av_dict_get( s->metadata, "stereo_mode", NULL, 0))) {
1036  int stereo_mode = atoi(tag->value);
1037 
1038  for (int i = 0; i < MATROSKA_VIDEO_STEREOMODE_TYPE_NB; i++)
1039  if (!strcmp(tag->value, ff_matroska_video_stereo_mode[i])){
1040  stereo_mode = i;
1041  break;
1042  }
1043 
1044  if (stereo_mode < MATROSKA_VIDEO_STEREOMODE_TYPE_NB &&
1045  stereo_mode != 10 && stereo_mode != 12) {
1046  int ret = ff_mkv_stereo3d_conv(st, stereo_mode);
1047  if (ret < 0)
1048  return ret;
1049  }
1050  }
1051 
1053  NULL);
1054  if (stereo) {
1055  switch (stereo->type) {
1056  case AV_STEREO3D_2D:
1058  break;
1060  format = (stereo->flags & AV_STEREO3D_FLAG_INVERT)
1063  *h_width = 2;
1064  break;
1065  case AV_STEREO3D_TOPBOTTOM:
1067  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
1068  format--;
1069  *h_height = 2;
1070  break;
1073  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
1074  format--;
1075  break;
1076  case AV_STEREO3D_LINES:
1078  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
1079  format--;
1080  *h_height = 2;
1081  break;
1082  case AV_STEREO3D_COLUMNS:
1084  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
1085  format--;
1086  *h_width = 2;
1087  break;
1090  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
1091  format++;
1092  break;
1093  }
1094  }
1095 
1096  if (format == MATROSKA_VIDEO_STEREOMODE_TYPE_NB)
1097  return 0;
1098 
1099  // if webm, do not write unsupported modes
1100  if ((mode == MODE_WEBM &&
1103  || format >= MATROSKA_VIDEO_STEREOMODE_TYPE_NB) {
1104  av_log(s, AV_LOG_ERROR,
1105  "The specified stereo mode is not valid.\n");
1106  return AVERROR(EINVAL);
1107  }
1108 
1109  // write StereoMode if format is valid
1111 
1112  return 0;
1113 }
1114 
1116  AVStream *st, mkv_track *track, AVIOContext *pb,
1117  int is_default)
1118 {
1119  AVCodecParameters *par = st->codecpar;
1120  ebml_master subinfo, track_master;
1121  int native_id = 0;
1122  int qt_id = 0;
1123  int bit_depth;
1124  int sample_rate = par->sample_rate;
1125  int output_sample_rate = 0;
1126  int display_width_div = 1;
1127  int display_height_div = 1;
1128  int j, ret;
1129  const AVDictionaryEntry *tag;
1130 
1131  if (par->codec_type == AVMEDIA_TYPE_ATTACHMENT)
1132  return 0;
1133 
1134  if (par->codec_id == AV_CODEC_ID_AAC) {
1135  ret = get_aac_sample_rates(s, mkv, par->extradata, par->extradata_size,
1136  &sample_rate, &output_sample_rate);
1137  if (ret < 0)
1138  return ret;
1139  }
1140 
1141  track_master = start_ebml_master(pb, MATROSKA_ID_TRACKENTRY, 0);
1143  put_ebml_uid (pb, MATROSKA_ID_TRACKUID, track->uid);
1144  put_ebml_uint(pb, MATROSKA_ID_TRACKFLAGLACING, 0); // no lacing (yet)
1145 
1146  if ((tag = av_dict_get(st->metadata, "title", NULL, 0)))
1148  tag = av_dict_get(st->metadata, "language", NULL, 0);
1150  tag && tag->value[0] ? tag->value : "und");
1151 
1152  // The default value for TRACKFLAGDEFAULT is 1, so add element
1153  // if we need to clear it.
1154  if (!is_default)
1156 
1159 
1160  if (mkv->mode == MODE_WEBM) {
1161  const char *codec_id;
1162  if (par->codec_type != AVMEDIA_TYPE_SUBTITLE) {
1163  for (j = 0; ff_webm_codec_tags[j].id != AV_CODEC_ID_NONE; j++) {
1164  if (ff_webm_codec_tags[j].id == par->codec_id) {
1165  codec_id = ff_webm_codec_tags[j].str;
1166  native_id = 1;
1167  break;
1168  }
1169  }
1170  } else if (par->codec_id == AV_CODEC_ID_WEBVTT) {
1172  codec_id = "D_WEBVTT/CAPTIONS";
1173  native_id = MATROSKA_TRACK_TYPE_SUBTITLE;
1174  } else if (st->disposition & AV_DISPOSITION_DESCRIPTIONS) {
1175  codec_id = "D_WEBVTT/DESCRIPTIONS";
1176  native_id = MATROSKA_TRACK_TYPE_METADATA;
1177  } else if (st->disposition & AV_DISPOSITION_METADATA) {
1178  codec_id = "D_WEBVTT/METADATA";
1179  native_id = MATROSKA_TRACK_TYPE_METADATA;
1180  } else {
1181  codec_id = "D_WEBVTT/SUBTITLES";
1182  native_id = MATROSKA_TRACK_TYPE_SUBTITLE;
1183  }
1184  }
1185 
1186  if (!native_id) {
1187  av_log(s, AV_LOG_ERROR,
1188  "Only VP8 or VP9 or AV1 video and Vorbis or Opus audio and WebVTT subtitles are supported for WebM.\n");
1189  return AVERROR(EINVAL);
1190  }
1191 
1192  put_ebml_string(pb, MATROSKA_ID_CODECID, codec_id);
1193  } else {
1200 
1201  // look for a codec ID string specific to mkv to use,
1202  // if none are found, use AVI codes
1203  if (par->codec_id != AV_CODEC_ID_RAWVIDEO || par->codec_tag) {
1204  for (j = 0; ff_mkv_codec_tags[j].id != AV_CODEC_ID_NONE; j++) {
1205  if (ff_mkv_codec_tags[j].id == par->codec_id && par->codec_id != AV_CODEC_ID_FFV1) {
1207  native_id = 1;
1208  break;
1209  }
1210  }
1211  } else {
1212  if (mkv->allow_raw_vfw) {
1213  native_id = 0;
1214  } else {
1215  av_log(s, AV_LOG_ERROR, "Raw RGB is not supported Natively in Matroska, you can use AVI or NUT or\n"
1216  "If you would like to store it anyway using VFW mode, enable allow_raw_vfw (-allow_raw_vfw 1)\n");
1217  return AVERROR(EINVAL);
1218  }
1219  }
1220  }
1221 
1222  switch (par->codec_type) {
1223  case AVMEDIA_TYPE_VIDEO:
1224  mkv->have_video = 1;
1226 
1227  if( st->avg_frame_rate.num > 0 && st->avg_frame_rate.den > 0
1228  && av_cmp_q(av_inv_q(st->avg_frame_rate), st->time_base) > 0)
1230  else if( st->r_frame_rate.num > 0 && st->r_frame_rate.den > 0
1231  && av_cmp_q(av_inv_q(st->r_frame_rate), st->time_base) > 0)
1233 
1234  if (!native_id &&
1237  par->codec_id == AV_CODEC_ID_SVQ1 ||
1238  par->codec_id == AV_CODEC_ID_SVQ3 ||
1239  par->codec_id == AV_CODEC_ID_CINEPAK))
1240  qt_id = 1;
1241 
1242  if (qt_id)
1243  put_ebml_string(pb, MATROSKA_ID_CODECID, "V_QUICKTIME");
1244  else if (!native_id) {
1245  // if there is no mkv-specific codec ID, use VFW mode
1246  put_ebml_string(pb, MATROSKA_ID_CODECID, "V_MS/VFW/FOURCC");
1247  track->write_dts = 1;
1249  }
1250 
1251  subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKVIDEO, 0);
1252 
1255 
1256  mkv_write_field_order(pb, mkv->mode, par->field_order);
1257 
1258  // check both side data and metadata for stereo information,
1259  // write the result to the bitstream if any is found
1260  ret = mkv_write_stereo_mode(s, pb, st, mkv->mode,
1261  &display_width_div,
1262  &display_height_div);
1263  if (ret < 0)
1264  return ret;
1265 
1266  if (((tag = av_dict_get(st->metadata, "alpha_mode", NULL, 0)) && atoi(tag->value)) ||
1267  ((tag = av_dict_get( s->metadata, "alpha_mode", NULL, 0)) && atoi(tag->value)) ||
1268  (par->format == AV_PIX_FMT_YUVA420P)) {
1270  }
1271 
1272  // write DisplayWidth and DisplayHeight, they contain the size of
1273  // a single source view and/or the display aspect ratio
1274  if (st->sample_aspect_ratio.num) {
1275  int64_t d_width = av_rescale(par->width, st->sample_aspect_ratio.num, st->sample_aspect_ratio.den);
1276  if (d_width > INT_MAX) {
1277  av_log(s, AV_LOG_ERROR, "Overflow in display width\n");
1278  return AVERROR(EINVAL);
1279  }
1280  if (d_width != par->width || display_width_div != 1 || display_height_div != 1) {
1281  if (mkv->mode == MODE_WEBM || display_width_div != 1 || display_height_div != 1) {
1282  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH , d_width / display_width_div);
1283  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, par->height / display_height_div);
1284  } else {
1285  AVRational display_aspect_ratio;
1286  av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
1287  par->width * (int64_t)st->sample_aspect_ratio.num,
1288  par->height * (int64_t)st->sample_aspect_ratio.den,
1289  1024 * 1024);
1290  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH, display_aspect_ratio.num);
1291  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, display_aspect_ratio.den);
1293  }
1294  }
1295  } else if (display_width_div != 1 || display_height_div != 1) {
1296  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH , par->width / display_width_div);
1297  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, par->height / display_height_div);
1298  } else if (mkv->mode != MODE_WEBM)
1300 
1301  if (par->codec_id == AV_CODEC_ID_RAWVIDEO) {
1302  uint32_t color_space = av_le2ne32(par->codec_tag);
1303  put_ebml_binary(pb, MATROSKA_ID_VIDEOCOLORSPACE, &color_space, sizeof(color_space));
1304  }
1305  mkv_write_video_color(pb, st, par);
1306  mkv_write_video_projection(s, pb, st);
1307 
1308  end_ebml_master(pb, subinfo);
1309  break;
1310 
1311  case AVMEDIA_TYPE_AUDIO:
1312  if (par->initial_padding && par->codec_id == AV_CODEC_ID_OPUS) {
1313  int64_t codecdelay = av_rescale_q(par->initial_padding,
1314  (AVRational){ 1, 48000 },
1315  (AVRational){ 1, 1000000000 });
1316  if (codecdelay < 0) {
1317  av_log(s, AV_LOG_ERROR, "Initial padding is invalid\n");
1318  return AVERROR(EINVAL);
1319  }
1320 // track->ts_offset = av_rescale_q(par->initial_padding,
1321 // (AVRational){ 1, par->sample_rate },
1322 // st->time_base);
1323 
1324  put_ebml_uint(pb, MATROSKA_ID_CODECDELAY, codecdelay);
1325  }
1326  if (par->codec_id == AV_CODEC_ID_OPUS)
1328 
1330 
1331  if (!native_id)
1332  // no mkv-specific ID, use ACM mode
1333  put_ebml_string(pb, MATROSKA_ID_CODECID, "A_MS/ACM");
1334 
1335  subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKAUDIO, 6 + 4 * 9);
1337 
1338  track->sample_rate_offset = avio_tell(pb);
1339  put_ebml_float (pb, MATROSKA_ID_AUDIOSAMPLINGFREQ, sample_rate);
1340  if (output_sample_rate)
1341  put_ebml_float(pb, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate);
1342 
1343  bit_depth = av_get_bits_per_sample(par->codec_id);
1344  if (!bit_depth && par->codec_id != AV_CODEC_ID_ADPCM_G726) {
1345  if (par->bits_per_raw_sample)
1346  bit_depth = par->bits_per_raw_sample;
1347  else
1348  bit_depth = av_get_bytes_per_sample(par->format) << 3;
1349  }
1350  if (!bit_depth)
1351  bit_depth = par->bits_per_coded_sample;
1352  if (bit_depth)
1353  put_ebml_uint(pb, MATROSKA_ID_AUDIOBITDEPTH, bit_depth);
1354  end_ebml_master(pb, subinfo);
1355  break;
1356 
1357  case AVMEDIA_TYPE_SUBTITLE:
1358  if (!native_id) {
1359  av_log(s, AV_LOG_ERROR, "Subtitle codec %d is not supported.\n", par->codec_id);
1360  return AVERROR(ENOSYS);
1361  }
1364 
1365  if (mkv->mode != MODE_WEBM || par->codec_id != AV_CODEC_ID_WEBVTT)
1366  native_id = MATROSKA_TRACK_TYPE_SUBTITLE;
1367 
1368  put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, native_id);
1369  break;
1370  default:
1371  av_log(s, AV_LOG_ERROR, "Only audio, video, and subtitles are supported for Matroska.\n");
1372  return AVERROR(EINVAL);
1373  }
1374 
1375  if (mkv->mode != MODE_WEBM || par->codec_id != AV_CODEC_ID_WEBVTT) {
1376  track->codecpriv_offset = avio_tell(pb);
1377  ret = mkv_write_codecprivate(s, pb, par, native_id, qt_id);
1378  if (ret < 0)
1379  return ret;
1380  }
1381 
1382  end_ebml_master(pb, track_master);
1383 
1384  return 0;
1385 }
1386 
1388 {
1389  MatroskaMuxContext *mkv = s->priv_data;
1390  AVIOContext *pb = s->pb;
1391  int i, ret, video_default_idx, audio_default_idx, subtitle_default_idx;
1392 
1393  if (mkv->nb_attachments == s->nb_streams)
1394  return 0;
1395 
1396  ret = start_ebml_master_crc32(&mkv->track.bc, mkv);
1397  if (ret < 0)
1398  return ret;
1399 
1400  if (mkv->default_mode != DEFAULT_MODE_PASSTHROUGH) {
1401  int video_idx, audio_idx, subtitle_idx;
1402 
1403  video_idx = video_default_idx =
1404  audio_idx = audio_default_idx =
1405  subtitle_idx = subtitle_default_idx = -1;
1406 
1407  for (i = s->nb_streams - 1; i >= 0; i--) {
1408  AVStream *st = s->streams[i];
1409 
1410  switch (st->codecpar->codec_type) {
1411 #define CASE(type, variable) \
1412  case AVMEDIA_TYPE_ ## type: \
1413  variable ## _idx = i; \
1414  if (st->disposition & AV_DISPOSITION_DEFAULT) \
1415  variable ## _default_idx = i; \
1416  break;
1417  CASE(VIDEO, video)
1418  CASE(AUDIO, audio)
1419  CASE(SUBTITLE, subtitle)
1420 #undef CASE
1421  }
1422  }
1423 
1424  video_default_idx = FFMAX(video_default_idx, video_idx);
1425  audio_default_idx = FFMAX(audio_default_idx, audio_idx);
1427  subtitle_default_idx = FFMAX(subtitle_default_idx, subtitle_idx);
1428  }
1429  for (i = 0; i < s->nb_streams; i++) {
1430  AVStream *st = s->streams[i];
1431  int is_default = mkv->default_mode == DEFAULT_MODE_PASSTHROUGH ?
1433  i == video_default_idx || i == audio_default_idx ||
1434  i == subtitle_default_idx;
1435  ret = mkv_write_track(s, mkv, st, &mkv->tracks[i],
1436  mkv->track.bc, is_default);
1437  if (ret < 0)
1438  return ret;
1439  }
1440 
1441  return end_ebml_master_crc32_tentatively(pb, &mkv->track, mkv,
1443 }
1444 
1446 {
1447  uint8_t *key = av_strdup(t->key);
1448  uint8_t *p = key;
1449  const uint8_t *lang = NULL;
1450  ebml_master tag;
1451 
1452  if (!key)
1453  return AVERROR(ENOMEM);
1454 
1455  if ((p = strrchr(p, '-')) &&
1456  (lang = ff_convert_lang_to(p + 1, AV_LANG_ISO639_2_BIBL)))
1457  *p = 0;
1458 
1459  p = key;
1460  while (*p) {
1461  if (*p == ' ')
1462  *p = '_';
1463  else if (*p >= 'a' && *p <= 'z')
1464  *p -= 'a' - 'A';
1465  p++;
1466  }
1467 
1470  if (lang)
1473  end_ebml_master(pb, tag);
1474 
1475  av_freep(&key);
1476  return 0;
1477 }
1478 
1480  ebml_master *tag, uint32_t elementid, uint64_t uid)
1481 {
1483  int ret;
1484 
1485  if (!*pb) {
1486  ret = start_ebml_master_crc32(pb, mkv);
1487  if (ret < 0)
1488  return ret;
1489  }
1490 
1491  *tag = start_ebml_master(*pb, MATROSKA_ID_TAG, 0);
1492  targets = start_ebml_master(*pb, MATROSKA_ID_TAGTARGETS, 4 + 1 + 8);
1493  if (elementid)
1494  put_ebml_uid(*pb, elementid, uid);
1495  end_ebml_master(*pb, targets);
1496  return 0;
1497 }
1498 
1499 static int mkv_check_tag_name(const char *name, uint32_t elementid)
1500 {
1501  return av_strcasecmp(name, "title") &&
1502  av_strcasecmp(name, "stereo_mode") &&
1503  av_strcasecmp(name, "creation_time") &&
1504  av_strcasecmp(name, "encoding_tool") &&
1505  av_strcasecmp(name, "duration") &&
1506  (elementid != MATROSKA_ID_TAGTARGETS_TRACKUID ||
1507  av_strcasecmp(name, "language")) &&
1508  (elementid != MATROSKA_ID_TAGTARGETS_ATTACHUID ||
1509  (av_strcasecmp(name, "filename") &&
1510  av_strcasecmp(name, "mimetype")));
1511 }
1512 
1514  AVIOContext **pb, ebml_master *tag,
1515  uint32_t elementid, uint64_t uid)
1516 {
1517  const AVDictionaryEntry *t = NULL;
1518  ebml_master tag2;
1519  int ret;
1520 
1521  ret = mkv_write_tag_targets(mkv, pb, tag ? tag : &tag2, elementid, uid);
1522  if (ret < 0)
1523  return ret;
1524 
1525  while ((t = av_dict_get(m, "", t, AV_DICT_IGNORE_SUFFIX))) {
1526  if (mkv_check_tag_name(t->key, elementid)) {
1527  ret = mkv_write_simpletag(*pb, t);
1528  if (ret < 0)
1529  return ret;
1530  }
1531  }
1532 
1533  if (!tag)
1534  end_ebml_master(*pb, tag2);
1535 
1536  return 0;
1537 }
1538 
1539 static int mkv_check_tag(const AVDictionary *m, uint32_t elementid)
1540 {
1541  const AVDictionaryEntry *t = NULL;
1542 
1543  while ((t = av_dict_get(m, "", t, AV_DICT_IGNORE_SUFFIX)))
1544  if (mkv_check_tag_name(t->key, elementid))
1545  return 1;
1546 
1547  return 0;
1548 }
1549 
1551 {
1552  MatroskaMuxContext *mkv = s->priv_data;
1553  ebml_master tag, *tagp = IS_SEEKABLE(s->pb, mkv) ? &tag : NULL;
1554  int i, ret;
1555 
1556  mkv->wrote_tags = 1;
1557 
1559 
1560  if (mkv_check_tag(s->metadata, 0)) {
1561  ret = mkv_write_tag(mkv, s->metadata, &mkv->tags.bc, NULL, 0, 0);
1562  if (ret < 0)
1563  return ret;
1564  }
1565 
1566  for (i = 0; i < s->nb_streams; i++) {
1567  const AVStream *st = s->streams[i];
1568  mkv_track *track = &mkv->tracks[i];
1569 
1571  continue;
1572 
1574  continue;
1575 
1576  ret = mkv_write_tag(mkv, st->metadata, &mkv->tags.bc, tagp,
1578  if (ret < 0)
1579  return ret;
1580 
1581  if (tagp) {
1582  AVIOContext *pb = mkv->tags.bc;
1583  ebml_master simpletag;
1584 
1585  simpletag = start_ebml_master(pb, MATROSKA_ID_SIMPLETAG,
1586  2 + 1 + 8 + 23);
1587  put_ebml_string(pb, MATROSKA_ID_TAGNAME, "DURATION");
1588  track->duration_offset = avio_tell(pb);
1589 
1590  // Reserve space to write duration as a 20-byte string.
1591  // 2 (ebml id) + 1 (data size) + 20 (data)
1592  put_ebml_void(pb, 23);
1593  end_ebml_master(pb, simpletag);
1594  end_ebml_master(pb, tag);
1595  }
1596  }
1597 
1598  if (mkv->nb_attachments && mkv->mode != MODE_WEBM) {
1599  for (i = 0; i < s->nb_streams; i++) {
1600  const mkv_track *track = &mkv->tracks[i];
1601  const AVStream *st = s->streams[i];
1602 
1604  continue;
1605 
1607  continue;
1608 
1609  ret = mkv_write_tag(mkv, st->metadata, &mkv->tags.bc, NULL,
1611  if (ret < 0)
1612  return ret;
1613  }
1614  }
1615 
1616  if (mkv->tags.bc) {
1617  return end_ebml_master_crc32_tentatively(s->pb, &mkv->tags, mkv,
1619  }
1620  return 0;
1621 }
1622 
1624 {
1625  MatroskaMuxContext *mkv = s->priv_data;
1626  AVIOContext *dyn_cp = NULL, *dyn_tags = NULL, **tags, *pb = s->pb;
1627  ebml_master editionentry;
1628  uint64_t chapter_id_offset = 0;
1629  AVRational scale = {1, 1E9};
1630  int i, ret;
1631 
1632  if (!s->nb_chapters || mkv->wrote_chapters)
1633  return 0;
1634 
1635  for (i = 0; i < s->nb_chapters; i++)
1636  if (!s->chapters[i]->id) {
1637  chapter_id_offset = 1;
1638  break;
1639  }
1640 
1641  ret = start_ebml_master_crc32(&dyn_cp, mkv);
1642  if (ret < 0)
1643  return ret;
1644 
1645  editionentry = start_ebml_master(dyn_cp, MATROSKA_ID_EDITIONENTRY, 0);
1646  if (mkv->mode != MODE_WEBM) {
1648  /* If mkv_write_tags() has already been called, then any tags
1649  * corresponding to chapters will be put into a new Tags element. */
1650  tags = mkv->wrote_tags ? &dyn_tags : &mkv->tags.bc;
1651  } else
1652  tags = NULL;
1653 
1654  for (i = 0; i < s->nb_chapters; i++) {
1655  ebml_master chapteratom, chapterdisplay;
1656  const AVChapter *c = s->chapters[i];
1657  int64_t chapterstart = av_rescale_q(c->start, c->time_base, scale);
1658  int64_t chapterend = av_rescale_q(c->end, c->time_base, scale);
1659  const AVDictionaryEntry *t;
1660  if (chapterstart < 0 || chapterstart > chapterend || chapterend < 0) {
1661  av_log(s, AV_LOG_ERROR,
1662  "Invalid chapter start (%"PRId64") or end (%"PRId64").\n",
1663  chapterstart, chapterend);
1664  ret = AVERROR_INVALIDDATA;
1665  goto fail;
1666  }
1667 
1668  chapteratom = start_ebml_master(dyn_cp, MATROSKA_ID_CHAPTERATOM, 0);
1670  (uint32_t)c->id + chapter_id_offset);
1671  put_ebml_uint(dyn_cp, MATROSKA_ID_CHAPTERTIMESTART, chapterstart);
1672  put_ebml_uint(dyn_cp, MATROSKA_ID_CHAPTERTIMEEND, chapterend);
1673  if ((t = av_dict_get(c->metadata, "title", NULL, 0))) {
1674  chapterdisplay = start_ebml_master(dyn_cp, MATROSKA_ID_CHAPTERDISPLAY, 0);
1676  put_ebml_string(dyn_cp, MATROSKA_ID_CHAPLANG , "und");
1677  end_ebml_master(dyn_cp, chapterdisplay);
1678  }
1679  end_ebml_master(dyn_cp, chapteratom);
1680 
1682  ret = mkv_write_tag(mkv, c->metadata, tags, NULL,
1684  (uint32_t)c->id + chapter_id_offset);
1685  if (ret < 0)
1686  goto fail;
1687  }
1688  }
1689  end_ebml_master(dyn_cp, editionentry);
1690  mkv->wrote_chapters = 1;
1691 
1692  ret = end_ebml_master_crc32(pb, &dyn_cp, mkv, MATROSKA_ID_CHAPTERS, 0, 0, 1);
1693  if (ret < 0)
1694  goto fail;
1695  if (dyn_tags)
1696  return end_ebml_master_crc32(pb, &dyn_tags, mkv,
1697  MATROSKA_ID_TAGS, 0, 0, 1);
1698  return 0;
1699 
1700 fail:
1701  if (tags) {
1702  /* tags == &mkv->tags.bc can only happen if mkv->tags.bc was
1703  * initially NULL, so we never free older tags. */
1704  ffio_free_dyn_buf(tags);
1705  }
1706  ffio_free_dyn_buf(&dyn_cp);
1707  return ret;
1708 }
1709 
1710 static const char *get_mimetype(const AVStream *st)
1711 {
1712  const AVDictionaryEntry *t;
1713 
1714  if (t = av_dict_get(st->metadata, "mimetype", NULL, 0))
1715  return t->value;
1716  if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
1718  if (desc && desc->mime_types) {
1719  return desc->mime_types[0];
1720  } else if (st->codecpar->codec_id == AV_CODEC_ID_TEXT)
1721  return "text/plain";
1722  }
1723 
1724  return NULL;
1725 }
1726 
1728 {
1729  MatroskaMuxContext *mkv = s->priv_data;
1730  AVIOContext *dyn_cp = NULL, *pb = s->pb;
1731  int i, ret;
1732 
1733  if (!mkv->nb_attachments)
1734  return 0;
1735 
1736  ret = start_ebml_master_crc32(&dyn_cp, mkv);
1737  if (ret < 0)
1738  return ret;
1739 
1740  for (i = 0; i < s->nb_streams; i++) {
1741  const AVStream *st = s->streams[i];
1742  mkv_track *track = &mkv->tracks[i];
1743  ebml_master attached_file;
1744  const AVDictionaryEntry *t;
1745  const char *mimetype;
1746 
1748  continue;
1749 
1750  attached_file = start_ebml_master(dyn_cp, MATROSKA_ID_ATTACHEDFILE, 0);
1751 
1752  if (t = av_dict_get(st->metadata, "title", NULL, 0))
1754  if (!(t = av_dict_get(st->metadata, "filename", NULL, 0))) {
1755  av_log(s, AV_LOG_ERROR, "Attachment stream %d has no filename tag.\n", i);
1756  return AVERROR(EINVAL);
1757  }
1759 
1760  mimetype = get_mimetype(st);
1761  av_assert0(mimetype);
1762  put_ebml_string(dyn_cp, MATROSKA_ID_FILEMIMETYPE, mimetype);
1764  put_ebml_uid(dyn_cp, MATROSKA_ID_FILEUID, track->uid);
1765  end_ebml_master(dyn_cp, attached_file);
1766  }
1767  return end_ebml_master_crc32(pb, &dyn_cp, mkv,
1768  MATROSKA_ID_ATTACHMENTS, 0, 0, 1);
1769 }
1770 
1772 {
1773  const AVDictionaryEntry *duration = av_dict_get(s->metadata, "DURATION",
1774  NULL, 0);
1775  int64_t max = 0;
1776  int64_t us;
1777 
1778  if (duration && (av_parse_time(&us, duration->value, 1) == 0) && us > 0) {
1779  av_log(s, AV_LOG_DEBUG, "get_metadata_duration found duration in context metadata: %" PRId64 "\n", us);
1780  return us;
1781  }
1782 
1783  for (unsigned i = 0; i < s->nb_streams; i++) {
1784  int64_t us;
1785  duration = av_dict_get(s->streams[i]->metadata, "DURATION", NULL, 0);
1786 
1787  if (duration && (av_parse_time(&us, duration->value, 1) == 0))
1788  max = FFMAX(max, us);
1789  }
1790 
1791  av_log(s, AV_LOG_DEBUG, "get_metadata_duration returned: %" PRId64 "\n", max);
1792  return max;
1793 }
1794 
1796 {
1797  MatroskaMuxContext *mkv = s->priv_data;
1798  AVIOContext *pb = s->pb;
1800  const AVDictionaryEntry *tag;
1801  int ret, i, version = 2;
1802  int64_t creation_time;
1803 
1804  if (mkv->mode != MODE_WEBM ||
1805  av_dict_get(s->metadata, "stereo_mode", NULL, 0) ||
1806  av_dict_get(s->metadata, "alpha_mode", NULL, 0))
1807  version = 4;
1808 
1809  for (i = 0; i < s->nb_streams; i++) {
1810  if (s->streams[i]->codecpar->codec_id == AV_CODEC_ID_OPUS ||
1811  av_dict_get(s->streams[i]->metadata, "stereo_mode", NULL, 0) ||
1812  av_dict_get(s->streams[i]->metadata, "alpha_mode", NULL, 0))
1813  version = 4;
1814  }
1815 
1822  put_ebml_uint (pb, EBML_ID_DOCTYPEVERSION , version);
1824  end_ebml_master(pb, ebml_header);
1825 
1827  put_ebml_size_unknown(pb, 8);
1828  mkv->segment_offset = avio_tell(pb);
1829 
1830  // We write a SeekHead at the beginning to point to all other level
1831  // one elements (except Clusters).
1832  mkv_start_seekhead(mkv, pb);
1833 
1834  ret = start_ebml_master_crc32(&mkv->info.bc, mkv);
1835  if (ret < 0)
1836  return ret;
1837  pb = mkv->info.bc;
1838 
1840  if ((tag = av_dict_get(s->metadata, "title", NULL, 0)))
1842  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
1844  if ((tag = av_dict_get(s->metadata, "encoding_tool", NULL, 0)))
1846  else
1848 
1849  if (mkv->mode != MODE_WEBM)
1851  } else {
1852  const char *ident = "Lavf";
1855  }
1856 
1857  if (ff_parse_creation_time_metadata(s, &creation_time, 0) > 0) {
1858  // Adjust time so it's relative to 2001-01-01 and convert to nanoseconds.
1859  int64_t date_utc = (creation_time - 978307200000000LL) * 1000;
1860  uint8_t date_utc_buf[8];
1861  AV_WB64(date_utc_buf, date_utc);
1862  put_ebml_binary(pb, MATROSKA_ID_DATEUTC, date_utc_buf, 8);
1863  }
1864 
1865  // reserve space for the duration
1866  mkv->duration = 0;
1867  mkv->duration_offset = avio_tell(pb);
1868  if (!mkv->is_live) {
1869  int64_t metadata_duration = get_metadata_duration(s);
1870 
1871  if (s->duration > 0) {
1872  int64_t scaledDuration = av_rescale(s->duration, 1000, AV_TIME_BASE);
1873  put_ebml_float(pb, MATROSKA_ID_DURATION, scaledDuration);
1874  av_log(s, AV_LOG_DEBUG, "Write early duration from recording time = %" PRIu64 "\n", scaledDuration);
1875  } else if (metadata_duration > 0) {
1876  int64_t scaledDuration = av_rescale(metadata_duration, 1000, AV_TIME_BASE);
1877  put_ebml_float(pb, MATROSKA_ID_DURATION, scaledDuration);
1878  av_log(s, AV_LOG_DEBUG, "Write early duration from metadata = %" PRIu64 "\n", scaledDuration);
1879  } else if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
1880  put_ebml_void(pb, 11); // assumes double-precision float to be written
1881  }
1882  }
1883  ret = end_ebml_master_crc32_tentatively(s->pb, &mkv->info,
1884  mkv, MATROSKA_ID_INFO);
1885  if (ret < 0)
1886  return ret;
1887  pb = s->pb;
1888 
1889  ret = mkv_write_tracks(s);
1890  if (ret < 0)
1891  return ret;
1892 
1893  ret = mkv_write_chapters(s);
1894  if (ret < 0)
1895  return ret;
1896 
1897  if (mkv->mode != MODE_WEBM) {
1898  ret = mkv_write_attachments(s);
1899  if (ret < 0)
1900  return ret;
1901  }
1902 
1903  /* Must come after mkv_write_chapters() to write chapter tags
1904  * into the same Tags element as the other tags. */
1905  ret = mkv_write_tags(s);
1906  if (ret < 0)
1907  return ret;
1908 
1909  if (!IS_SEEKABLE(pb, mkv)) {
1910  ret = mkv_write_seekhead(pb, mkv, 0, avio_tell(pb));
1911  if (ret < 0)
1912  return ret;
1913  }
1914 
1915  if (s->metadata_header_padding > 0) {
1916  if (s->metadata_header_padding == 1)
1919  }
1920 
1921  if (mkv->reserve_cues_space) {
1922  if (IS_SEEKABLE(pb, mkv)) {
1923  mkv->cues_pos = avio_tell(pb);
1924  if (mkv->reserve_cues_space == 1)
1925  mkv->reserve_cues_space++;
1927  } else
1928  mkv->reserve_cues_space = -1;
1929  }
1930 
1932  mkv->cur_audio_pkt.size = 0;
1933  mkv->cluster_pos = -1;
1934 
1935  // start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or
1936  // after 4k and on a keyframe
1937  if (IS_SEEKABLE(pb, mkv)) {
1938  if (mkv->cluster_time_limit < 0)
1939  mkv->cluster_time_limit = 5000;
1940  if (mkv->cluster_size_limit < 0)
1941  mkv->cluster_size_limit = 5 * 1024 * 1024;
1942  } else {
1943  if (mkv->cluster_time_limit < 0)
1944  mkv->cluster_time_limit = 1000;
1945  if (mkv->cluster_size_limit < 0)
1946  mkv->cluster_size_limit = 32 * 1024;
1947  }
1948 
1949  return 0;
1950 }
1951 
1952 static int mkv_blockgroup_size(int pkt_size, int track_num_size)
1953 {
1954  int size = pkt_size + track_num_size + 3;
1955  size += ebml_length_size(size);
1956  size += 2; // EBML ID for block and block duration
1957  size += 9; // max size of block duration incl. length field
1958  return size;
1959 }
1960 
1961 static int mkv_strip_wavpack(const uint8_t *src, uint8_t **pdst, int *size)
1962 {
1963  uint8_t *dst;
1964  int srclen = *size;
1965  int offset = 0;
1966  int ret;
1967 
1968  dst = av_malloc(srclen);
1969  if (!dst)
1970  return AVERROR(ENOMEM);
1971 
1972  while (srclen >= WV_HEADER_SIZE) {
1973  WvHeader header;
1974 
1975  ret = ff_wv_parse_header(&header, src);
1976  if (ret < 0)
1977  goto fail;
1978  src += WV_HEADER_SIZE;
1979  srclen -= WV_HEADER_SIZE;
1980 
1981  if (srclen < header.blocksize) {
1982  ret = AVERROR_INVALIDDATA;
1983  goto fail;
1984  }
1985 
1986  if (header.initial) {
1987  AV_WL32(dst + offset, header.samples);
1988  offset += 4;
1989  }
1990  AV_WL32(dst + offset, header.flags);
1991  AV_WL32(dst + offset + 4, header.crc);
1992  offset += 8;
1993 
1994  if (!(header.initial && header.final)) {
1995  AV_WL32(dst + offset, header.blocksize);
1996  offset += 4;
1997  }
1998 
1999  memcpy(dst + offset, src, header.blocksize);
2000  src += header.blocksize;
2001  srclen -= header.blocksize;
2002  offset += header.blocksize;
2003  }
2004 
2005  *pdst = dst;
2006  *size = offset;
2007 
2008  return 0;
2009 fail:
2010  av_freep(&dst);
2011  return ret;
2012 }
2013 
2015  uint32_t blockid, const AVPacket *pkt, int keyframe)
2016 {
2017  MatroskaMuxContext *mkv = s->priv_data;
2019  mkv_track *track = &mkv->tracks[pkt->stream_index];
2020  uint8_t *data = NULL, *side_data = NULL;
2021  int err = 0, offset = 0, size = pkt->size, side_data_size;
2022  int64_t ts = track->write_dts ? pkt->dts : pkt->pts;
2023  uint64_t additional_id;
2024  int64_t discard_padding = 0;
2025  unsigned track_number = track->track_num;
2026  ebml_master block_group, block_additions, block_more;
2027 
2028  ts += track->ts_offset;
2029 
2030  /* The following string is identical to the one in mkv_write_vtt_blocks
2031  * so that only one copy needs to exist in binaries. */
2032  av_log(s, AV_LOG_DEBUG,
2033  "Writing block of size %d with pts %" PRId64 ", dts %" PRId64 ", "
2034  "duration %" PRId64 " at relative offset %" PRId64 " in cluster "
2035  "at offset %" PRId64 ". TrackNumber %u, keyframe %d\n",
2036  pkt->size, pkt->pts, pkt->dts, pkt->duration, avio_tell(pb),
2037  mkv->cluster_pos, track_number, keyframe != 0);
2038 
2039  if (par->codec_id == AV_CODEC_ID_H264 && par->extradata_size > 0 &&
2040  (AV_RB24(par->extradata) == 1 || AV_RB32(par->extradata) == 1)) {
2041  err = ff_avc_parse_nal_units_buf(pkt->data, &data, &size);
2042  } else if (par->codec_id == AV_CODEC_ID_HEVC && par->extradata_size > 6 &&
2043  (AV_RB24(par->extradata) == 1 || AV_RB32(par->extradata) == 1)) {
2044  /* extradata is Annex B, assume the bitstream is too and convert it */
2045  err = ff_hevc_annexb2mp4_buf(pkt->data, &data, &size, 0, NULL);
2046  } else if (par->codec_id == AV_CODEC_ID_AV1) {
2047  err = ff_av1_filter_obus_buf(pkt->data, &data, &size, &offset);
2048  } else if (par->codec_id == AV_CODEC_ID_WAVPACK) {
2049  err = mkv_strip_wavpack(pkt->data, &data, &size);
2050  } else
2051  data = pkt->data;
2052 
2053  if (err < 0) {
2054  av_log(s, AV_LOG_ERROR, "Error when reformatting data of "
2055  "a packet from stream %d.\n", pkt->stream_index);
2056  return err;
2057  }
2058 
2059  if (par->codec_id == AV_CODEC_ID_PRORES && size >= 8) {
2060  /* Matroska specification requires to remove the first QuickTime atom
2061  */
2062  size -= 8;
2063  offset = 8;
2064  }
2065 
2066  side_data = av_packet_get_side_data(pkt,
2068  &side_data_size);
2069  if (side_data && side_data_size >= 10) {
2070  discard_padding = av_rescale_q(AV_RL32(side_data + 4),
2071  (AVRational){1, par->sample_rate},
2072  (AVRational){1, 1000000000});
2073  }
2074 
2075  side_data = av_packet_get_side_data(pkt,
2077  &side_data_size);
2078  if (side_data) {
2079  // Only the Codec-specific BlockMore (id == 1) is currently supported.
2080  if (side_data_size < 8 || (additional_id = AV_RB64(side_data)) != 1) {
2081  side_data_size = 0;
2082  } else {
2083  side_data += 8;
2084  side_data_size -= 8;
2085  }
2086  }
2087 
2088  if (side_data_size || discard_padding) {
2089  block_group = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, 0);
2090  blockid = MATROSKA_ID_BLOCK;
2091  }
2092 
2093  put_ebml_id(pb, blockid);
2094  put_ebml_length(pb, size + track->track_num_size + 3, 0);
2095  put_ebml_num(pb, track_number, track->track_num_size);
2096  avio_wb16(pb, ts - mkv->cluster_pts);
2097  avio_w8(pb, (blockid == MATROSKA_ID_SIMPLEBLOCK && keyframe) ? (1 << 7) : 0);
2098  avio_write(pb, data + offset, size);
2099  if (data != pkt->data)
2100  av_free(data);
2101 
2102  if (blockid == MATROSKA_ID_BLOCK && !keyframe)
2104  track->last_timestamp = ts;
2105 
2106  if (discard_padding)
2107  put_ebml_sint(pb, MATROSKA_ID_DISCARDPADDING, discard_padding);
2108 
2109  if (side_data_size) {
2110  block_additions = start_ebml_master(pb, MATROSKA_ID_BLOCKADDITIONS, 0);
2111  block_more = start_ebml_master(pb, MATROSKA_ID_BLOCKMORE, 0);
2112  /* Until dbc50f8a our demuxer used a wrong default value
2113  * of BlockAddID, so we write it unconditionally. */
2114  put_ebml_uint (pb, MATROSKA_ID_BLOCKADDID, additional_id);
2116  side_data, side_data_size);
2117  end_ebml_master(pb, block_more);
2118  end_ebml_master(pb, block_additions);
2119  }
2120  if (side_data_size || discard_padding)
2121  end_ebml_master(pb, block_group);
2122 
2123  return 0;
2124 }
2125 
2127 {
2128  MatroskaMuxContext *mkv = s->priv_data;
2129  mkv_track *track = &mkv->tracks[pkt->stream_index];
2130  ebml_master blockgroup;
2131  int id_size, settings_size, size;
2132  const char *id, *settings;
2133  int64_t ts = track->write_dts ? pkt->dts : pkt->pts;
2134  const int flags = 0;
2135 
2137  &id_size);
2138  id = id ? id : "";
2139 
2141  &settings_size);
2142  settings = settings ? settings : "";
2143 
2144  size = id_size + 1 + settings_size + 1 + pkt->size;
2145 
2146  /* The following string is identical to the one in mkv_write_block so that
2147  * only one copy needs to exist in binaries. */
2148  av_log(s, AV_LOG_DEBUG,
2149  "Writing block of size %d with pts %" PRId64 ", dts %" PRId64 ", "
2150  "duration %" PRId64 " at relative offset %" PRId64 " in cluster "
2151  "at offset %" PRId64 ". TrackNumber %u, keyframe %d\n",
2152  size, pkt->pts, pkt->dts, pkt->duration, avio_tell(pb),
2153  mkv->cluster_pos, track->track_num, 1);
2154 
2155  blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP,
2156  mkv_blockgroup_size(size, track->track_num_size));
2157 
2159  put_ebml_length(pb, size + track->track_num_size + 3, 0);
2160  put_ebml_num(pb, track->track_num, track->track_num_size);
2161  avio_wb16(pb, ts - mkv->cluster_pts);
2162  avio_w8(pb, flags);
2163  avio_printf(pb, "%.*s\n%.*s\n%.*s", id_size, id, settings_size, settings, pkt->size, pkt->data);
2164 
2166  end_ebml_master(pb, blockgroup);
2167 
2168  return pkt->duration;
2169 }
2170 
2172 {
2173  MatroskaMuxContext *mkv = s->priv_data;
2174  int ret;
2175 
2176  if (!mkv->have_video) {
2177  for (unsigned i = 0; i < s->nb_streams; i++)
2178  mkv->tracks[i].has_cue = 0;
2179  }
2180  mkv->cluster_pos = -1;
2181  ret = end_ebml_master_crc32(s->pb, &mkv->cluster_bc, mkv,
2182  MATROSKA_ID_CLUSTER, 0, 1, 0);
2183  if (ret < 0)
2184  return ret;
2185 
2187  return 0;
2188 }
2189 
2191 {
2192  MatroskaMuxContext *mkv = s->priv_data;
2193  mkv_track *track = &mkv->tracks[pkt->stream_index];
2195  uint8_t *side_data;
2196  int side_data_size, ret;
2197 
2199  &side_data_size);
2200 
2201  switch (par->codec_id) {
2202  case AV_CODEC_ID_AAC:
2203  if (side_data_size && mkv->track.bc) {
2204  int filler, output_sample_rate = 0;
2205  ret = get_aac_sample_rates(s, mkv, side_data, side_data_size,
2206  &track->sample_rate, &output_sample_rate);
2207  if (ret < 0)
2208  return ret;
2209  if (!output_sample_rate)
2210  output_sample_rate = track->sample_rate; // Space is already reserved, so it's this or a void element.
2211  ret = ff_alloc_extradata(par, side_data_size);
2212  if (ret < 0)
2213  return ret;
2214  memcpy(par->extradata, side_data, side_data_size);
2215  avio_seek(mkv->track.bc, track->codecpriv_offset, SEEK_SET);
2216  mkv_write_codecprivate(s, mkv->track.bc, par, 1, 0);
2217  filler = MAX_PCE_SIZE + 2 + 4 - (avio_tell(mkv->track.bc) - track->codecpriv_offset);
2218  if (filler)
2219  put_ebml_void(mkv->track.bc, filler);
2220  avio_seek(mkv->track.bc, track->sample_rate_offset, SEEK_SET);
2222  put_ebml_float(mkv->track.bc, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate);
2223  } else if (!par->extradata_size && !track->sample_rate) {
2224  // No extradata (codecpar or packet side data).
2225  av_log(s, AV_LOG_ERROR, "Error parsing AAC extradata, unable to determine samplerate.\n");
2226  return AVERROR(EINVAL);
2227  }
2228  break;
2229  case AV_CODEC_ID_FLAC:
2230  if (side_data_size && mkv->track.bc) {
2231  uint8_t *old_extradata = par->extradata;
2232  if (side_data_size != par->extradata_size) {
2233  av_log(s, AV_LOG_ERROR, "Invalid FLAC STREAMINFO metadata for output stream %d\n",
2234  pkt->stream_index);
2235  return AVERROR(EINVAL);
2236  }
2237  par->extradata = side_data;
2238  avio_seek(mkv->track.bc, track->codecpriv_offset, SEEK_SET);
2239  mkv_write_codecprivate(s, mkv->track.bc, par, 1, 0);
2240  par->extradata = old_extradata;
2241  }
2242  break;
2243  // FIXME: Remove the following once libaom starts propagating extradata during init()
2244  // See https://bugs.chromium.org/p/aomedia/issues/detail?id=2012
2245  case AV_CODEC_ID_AV1:
2246  if (side_data_size && mkv->track.bc && !par->extradata_size) {
2247  AVIOContext *dyn_cp;
2248  uint8_t *codecpriv;
2249  int codecpriv_size;
2250  ret = avio_open_dyn_buf(&dyn_cp);
2251  if (ret < 0)
2252  return ret;
2253  ff_isom_write_av1c(dyn_cp, side_data, side_data_size);
2254  codecpriv_size = avio_get_dyn_buf(dyn_cp, &codecpriv);
2255  if ((ret = dyn_cp->error) < 0 ||
2256  !codecpriv_size && (ret = AVERROR_INVALIDDATA)) {
2257  ffio_free_dyn_buf(&dyn_cp);
2258  return ret;
2259  }
2260  avio_seek(mkv->track.bc, track->codecpriv_offset, SEEK_SET);
2261  // Do not write the OBUs as we don't have space saved for them
2262  put_ebml_binary(mkv->track.bc, MATROSKA_ID_CODECPRIVATE, codecpriv, 4);
2263  ffio_free_dyn_buf(&dyn_cp);
2264  ret = ff_alloc_extradata(par, side_data_size);
2265  if (ret < 0)
2266  return ret;
2267  memcpy(par->extradata, side_data, side_data_size);
2268  } else if (!par->extradata_size)
2269  return AVERROR_INVALIDDATA;
2270  break;
2271  default:
2272  if (side_data_size)
2273  av_log(s, AV_LOG_DEBUG, "Ignoring new extradata in a packet for stream %d.\n", pkt->stream_index);
2274  break;
2275  }
2276 
2277  return 0;
2278 }
2279 
2281 {
2282  MatroskaMuxContext *mkv = s->priv_data;
2283  AVIOContext *pb;
2285  mkv_track *track = &mkv->tracks[pkt->stream_index];
2286  int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
2287  int duration = pkt->duration;
2288  int ret;
2289  int64_t ts = track->write_dts ? pkt->dts : pkt->pts;
2290  int64_t relative_packet_pos;
2291 
2292  if (ts == AV_NOPTS_VALUE) {
2293  av_log(s, AV_LOG_ERROR, "Can't write packet with unknown timestamp\n");
2294  return AVERROR(EINVAL);
2295  }
2296  ts += track->ts_offset;
2297 
2298  if (mkv->cluster_pos != -1) {
2299  int64_t cluster_time = ts - mkv->cluster_pts;
2300  if ((int16_t)cluster_time != cluster_time) {
2301  ret = mkv_end_cluster(s);
2302  if (ret < 0)
2303  return ret;
2304  av_log(s, AV_LOG_WARNING, "Starting new cluster due to timestamp\n");
2305  }
2306  }
2307 
2308  if (mkv->cluster_pos == -1) {
2309  ret = start_ebml_master_crc32(&mkv->cluster_bc, mkv);
2310  if (ret < 0)
2311  return ret;
2312  mkv->cluster_pos = avio_tell(s->pb);
2314  mkv->cluster_pts = FFMAX(0, ts);
2315  av_log(s, AV_LOG_DEBUG,
2316  "Starting new cluster with timestamp "
2317  "%" PRId64 " at offset %" PRId64 " bytes\n",
2318  mkv->cluster_pts, mkv->cluster_pos);
2319  }
2320  pb = mkv->cluster_bc;
2321 
2322  relative_packet_pos = avio_tell(pb);
2323 
2324  if (par->codec_type != AVMEDIA_TYPE_SUBTITLE) {
2325  ret = mkv_write_block(s, pb, MATROSKA_ID_SIMPLEBLOCK, pkt, keyframe);
2326  if (ret < 0)
2327  return ret;
2328  if (keyframe && IS_SEEKABLE(s->pb, mkv) &&
2329  (par->codec_type == AVMEDIA_TYPE_VIDEO || !mkv->have_video && !track->has_cue)) {
2330  ret = mkv_add_cuepoint(mkv, pkt->stream_index, ts,
2331  mkv->cluster_pos, relative_packet_pos, -1);
2332  if (ret < 0)
2333  return ret;
2334  track->has_cue = 1;
2335  }
2336  } else {
2337  if (par->codec_id == AV_CODEC_ID_WEBVTT) {
2338  duration = mkv_write_vtt_blocks(s, pb, pkt);
2339  } else {
2342  track->track_num_size));
2343 
2344 #if FF_API_CONVERGENCE_DURATION
2346  /* For backward compatibility, prefer convergence_duration. */
2347  if (pkt->convergence_duration > 0) {
2348  duration = pkt->convergence_duration;
2349  }
2351 #endif
2352  /* All subtitle blocks are considered to be keyframes. */
2353  mkv_write_block(s, pb, MATROSKA_ID_BLOCK, pkt, 1);
2355  end_ebml_master(pb, blockgroup);
2356  }
2357 
2358  if (IS_SEEKABLE(s->pb, mkv)) {
2359  ret = mkv_add_cuepoint(mkv, pkt->stream_index, ts,
2360  mkv->cluster_pos, relative_packet_pos, duration);
2361  if (ret < 0)
2362  return ret;
2363  }
2364  }
2365 
2366  mkv->duration = FFMAX(mkv->duration, ts + duration);
2367  track->duration = FFMAX(track->duration, ts + duration);
2368 
2369  return 0;
2370 }
2371 
2373 {
2374  MatroskaMuxContext *mkv = s->priv_data;
2376  int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
2377  int cluster_size;
2378  int64_t cluster_time;
2379  int ret;
2380  int start_new_cluster;
2381 
2382  ret = mkv_check_new_extra_data(s, pkt);
2383  if (ret < 0)
2384  return ret;
2385 
2386  if (mkv->cluster_pos != -1) {
2387  if (mkv->tracks[pkt->stream_index].write_dts)
2388  cluster_time = pkt->dts - mkv->cluster_pts;
2389  else
2390  cluster_time = pkt->pts - mkv->cluster_pts;
2391  cluster_time += mkv->tracks[pkt->stream_index].ts_offset;
2392 
2393  cluster_size = avio_tell(mkv->cluster_bc);
2394 
2395  if (mkv->is_dash && codec_type == AVMEDIA_TYPE_VIDEO) {
2396  // WebM DASH specification states that the first block of
2397  // every Cluster has to be a key frame. So for DASH video,
2398  // we only create a Cluster on seeing key frames.
2399  start_new_cluster = keyframe;
2400  } else if (mkv->is_dash && codec_type == AVMEDIA_TYPE_AUDIO &&
2401  cluster_time > mkv->cluster_time_limit) {
2402  // For DASH audio, we create a Cluster based on cluster_time_limit.
2403  start_new_cluster = 1;
2404  } else if (!mkv->is_dash &&
2405  (cluster_size > mkv->cluster_size_limit ||
2406  cluster_time > mkv->cluster_time_limit ||
2407  (codec_type == AVMEDIA_TYPE_VIDEO && keyframe &&
2408  cluster_size > 4 * 1024))) {
2409  start_new_cluster = 1;
2410  } else
2411  start_new_cluster = 0;
2412 
2413  if (start_new_cluster) {
2414  ret = mkv_end_cluster(s);
2415  if (ret < 0)
2416  return ret;
2417  }
2418  }
2419 
2420  if (!mkv->cluster_pos)
2421  avio_write_marker(s->pb,
2424 
2425  // check if we have an audio packet cached
2426  if (mkv->cur_audio_pkt.size > 0) {
2427  ret = mkv_write_packet_internal(s, &mkv->cur_audio_pkt);
2429  if (ret < 0) {
2430  av_log(s, AV_LOG_ERROR,
2431  "Could not write cached audio packet ret:%d\n", ret);
2432  return ret;
2433  }
2434  }
2435 
2436  // buffer an audio packet to ensure the packet containing the video
2437  // keyframe's timecode is contained in the same cluster for WebM
2438  if (codec_type == AVMEDIA_TYPE_AUDIO) {
2439  if (pkt->size > 0)
2440  ret = av_packet_ref(&mkv->cur_audio_pkt, pkt);
2441  } else
2442  ret = mkv_write_packet_internal(s, pkt);
2443  return ret;
2444 }
2445 
2447 {
2448  MatroskaMuxContext *mkv = s->priv_data;
2449 
2450  if (!pkt) {
2451  if (mkv->cluster_pos != -1) {
2452  int ret = mkv_end_cluster(s);
2453  if (ret < 0)
2454  return ret;
2455  av_log(s, AV_LOG_DEBUG,
2456  "Flushing cluster at offset %" PRIu64 " bytes\n",
2457  avio_tell(s->pb));
2458  }
2459  return 1;
2460  }
2461  return mkv_write_packet(s, pkt);
2462 }
2463 
2465 {
2466  MatroskaMuxContext *mkv = s->priv_data;
2467  AVIOContext *pb = s->pb;
2468  int64_t endpos, ret64;
2469  int ret, ret2 = 0;
2470 
2471  // check if we have an audio packet cached
2472  if (mkv->cur_audio_pkt.size > 0) {
2473  ret = mkv_write_packet_internal(s, &mkv->cur_audio_pkt);
2474  if (ret < 0) {
2475  av_log(s, AV_LOG_ERROR,
2476  "Could not write cached audio packet ret:%d\n", ret);
2477  return ret;
2478  }
2479  }
2480 
2481  if (mkv->cluster_pos != -1) {
2482  ret = end_ebml_master_crc32(pb, &mkv->cluster_bc, mkv,
2483  MATROSKA_ID_CLUSTER, 0, 0, 0);
2484  if (ret < 0)
2485  return ret;
2486  }
2487 
2488  ret = mkv_write_chapters(s);
2489  if (ret < 0)
2490  return ret;
2491 
2492  if (!IS_SEEKABLE(pb, mkv))
2493  return 0;
2494 
2495  endpos = avio_tell(pb);
2496 
2497  if (mkv->cues.num_entries && mkv->reserve_cues_space >= 0) {
2498  AVIOContext *cues = NULL;
2499  uint64_t size;
2500  int length_size = 0;
2501 
2502  ret = start_ebml_master_crc32(&cues, mkv);
2503  if (ret < 0)
2504  return ret;
2505 
2506  ret = mkv_assemble_cues(s->streams, cues, &mkv->cues,
2507  mkv->tracks, s->nb_streams);
2508  if (ret < 0) {
2509  ffio_free_dyn_buf(&cues);
2510  return ret;
2511  }
2512 
2513  if (mkv->reserve_cues_space) {
2514  size = avio_tell(cues);
2515  length_size = ebml_length_size(size);
2516  size += 4 + length_size;
2517  if (mkv->reserve_cues_space < size) {
2519  "Insufficient space reserved for Cues: "
2520  "%d < %"PRIu64". No Cues will be output.\n",
2521  mkv->reserve_cues_space, size);
2522  ret2 = AVERROR(EINVAL);
2523  goto after_cues;
2524  } else {
2525  if ((ret64 = avio_seek(pb, mkv->cues_pos, SEEK_SET)) < 0) {
2526  ffio_free_dyn_buf(&cues);
2527  return ret64;
2528  }
2529  if (mkv->reserve_cues_space == size + 1) {
2530  /* There is no way to reserve a single byte because
2531  * the minimal size of an EBML Void element is 2
2532  * (1 byte ID, 1 byte length field). This problem
2533  * is solved by writing the Cues' length field on
2534  * one byte more than necessary. */
2535  length_size++;
2536  size++;
2537  }
2538  }
2539  }
2540  ret = end_ebml_master_crc32(pb, &cues, mkv, MATROSKA_ID_CUES,
2541  length_size, 0, 1);
2542  if (ret < 0)
2543  return ret;
2544  if (mkv->reserve_cues_space) {
2545  if (size < mkv->reserve_cues_space)
2546  put_ebml_void(pb, mkv->reserve_cues_space - size);
2547  } else
2548  endpos = avio_tell(pb);
2549  }
2550 
2551 after_cues:
2552  /* Lengths greater than (1ULL << 56) - 1 can't be represented
2553  * via an EBML number, so leave the unknown length field. */
2554  if (endpos - mkv->segment_offset < (1ULL << 56) - 1) {
2555  if ((ret64 = avio_seek(pb, mkv->segment_offset - 8, SEEK_SET)) < 0)
2556  return ret64;
2557  put_ebml_length(pb, endpos - mkv->segment_offset, 8);
2558  }
2559 
2560  ret = mkv_write_seekhead(pb, mkv, 1, mkv->info.pos);
2561  if (ret < 0)
2562  return ret;
2563 
2564  if (mkv->info.bc) {
2565  // update the duration
2566  av_log(s, AV_LOG_DEBUG, "end duration = %" PRIu64 "\n", mkv->duration);
2567  avio_seek(mkv->info.bc, mkv->duration_offset, SEEK_SET);
2569  ret = end_ebml_master_crc32(pb, &mkv->info.bc, mkv,
2570  MATROSKA_ID_INFO, 0, 0, 0);
2571  if (ret < 0)
2572  return ret;
2573  }
2574 
2575  if (mkv->track.bc) {
2576  // write Tracks master
2577  avio_seek(pb, mkv->track.pos, SEEK_SET);
2578  ret = end_ebml_master_crc32(pb, &mkv->track.bc, mkv,
2579  MATROSKA_ID_TRACKS, 0, 0, 0);
2580  if (ret < 0)
2581  return ret;
2582  }
2583 
2584  // update stream durations
2585  if (mkv->tags.bc) {
2586  int i;
2587  for (i = 0; i < s->nb_streams; ++i) {
2588  const AVStream *st = s->streams[i];
2589  const mkv_track *track = &mkv->tracks[i];
2590 
2591  if (track->duration_offset > 0) {
2592  double duration_sec = track->duration * av_q2d(st->time_base);
2593  char duration_string[20] = "";
2594 
2595  av_log(s, AV_LOG_DEBUG, "stream %d end duration = %" PRIu64 "\n", i,
2596  track->duration);
2597 
2598  avio_seek(mkv->tags.bc, track->duration_offset, SEEK_SET);
2599 
2600  snprintf(duration_string, 20, "%02d:%02d:%012.9f",
2601  (int) duration_sec / 3600, ((int) duration_sec / 60) % 60,
2602  fmod(duration_sec, 60));
2603 
2604  put_ebml_binary(mkv->tags.bc, MATROSKA_ID_TAGSTRING, duration_string, 20);
2605  }
2606  }
2607 
2608  avio_seek(pb, mkv->tags.pos, SEEK_SET);
2609  ret = end_ebml_master_crc32(pb, &mkv->tags.bc, mkv,
2610  MATROSKA_ID_TAGS, 0, 0, 0);
2611  if (ret < 0)
2612  return ret;
2613  }
2614 
2615  avio_seek(pb, endpos, SEEK_SET);
2616 
2617  return ret2;
2618 }
2619 
2620 static int mkv_query_codec(enum AVCodecID codec_id, int std_compliance)
2621 {
2622  int i;
2623  for (i = 0; ff_mkv_codec_tags[i].id != AV_CODEC_ID_NONE; i++)
2624  if (ff_mkv_codec_tags[i].id == codec_id)
2625  return 1;
2626 
2627  if (std_compliance < FF_COMPLIANCE_NORMAL) {
2628  enum AVMediaType type = avcodec_get_type(codec_id);
2629  // mkv theoretically supports any video/audio through VFW/ACM
2630  if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO)
2631  return 1;
2632  }
2633 
2634  return 0;
2635 }
2636 
2637 static int webm_query_codec(enum AVCodecID codec_id, int std_compliance)
2638 {
2639  int i;
2640  for (i = 0; ff_webm_codec_tags[i].id != AV_CODEC_ID_NONE; i++)
2641  if (ff_webm_codec_tags[i].id == codec_id)
2642  return 1;
2643 
2644  return 0;
2645 }
2646 
2647 static uint64_t mkv_get_uid(const mkv_track *tracks, int i, AVLFG *c)
2648 {
2649  while (1) {
2650  uint64_t uid;
2651  int k;
2652  uid = (uint64_t)av_lfg_get(c) << 32;
2653  uid |= av_lfg_get(c);
2654  if (!uid)
2655  continue;
2656  for (k = 0; k < i; k++) {
2657  if (tracks[k].uid == uid)
2658  break;
2659  }
2660  if (k == i)
2661  return uid;
2662  }
2663 }
2664 
2665 static int mkv_init(struct AVFormatContext *s)
2666 {
2667  MatroskaMuxContext *mkv = s->priv_data;
2668  AVLFG c;
2669  unsigned nb_tracks = 0;
2670  int i;
2671 
2672  for (i = 0; i < s->nb_streams; i++) {
2673  if (s->streams[i]->codecpar->codec_id == AV_CODEC_ID_ATRAC3 ||
2679  av_log(s, AV_LOG_ERROR,
2680  "The Matroska muxer does not yet support muxing %s\n",
2682  return AVERROR_PATCHWELCOME;
2683  }
2684  }
2685 
2686  if (s->avoid_negative_ts < 0) {
2687  s->avoid_negative_ts = 1;
2689  }
2690 
2691  if (!strcmp(s->oformat->name, "webm")) {
2692  mkv->mode = MODE_WEBM;
2693  mkv->write_crc = 0;
2694  } else
2695  mkv->mode = MODE_MATROSKAv2;
2696 
2697  mkv->tracks = av_mallocz_array(s->nb_streams, sizeof(*mkv->tracks));
2698  if (!mkv->tracks)
2699  return AVERROR(ENOMEM);
2700 
2701  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
2703 
2704  // Calculate the SegmentUID now in order not to waste our random seed.
2705  for (i = 0; i < 4; i++)
2706  mkv->segment_uid[i] = av_lfg_get(&c);
2707  }
2708 
2709  for (i = 0; i < s->nb_streams; i++) {
2710  AVStream *st = s->streams[i];
2711  mkv_track *track = &mkv->tracks[i];
2712 
2713  if (s->flags & AVFMT_FLAG_BITEXACT) {
2714  track->uid = i + 1;
2715  } else {
2716  track->uid = mkv_get_uid(mkv->tracks, i, &c);
2717  }
2718 
2719  // ms precision is the de-facto standard timescale for mkv files
2720  avpriv_set_pts_info(st, 64, 1, 1000);
2721 
2723  if (mkv->mode == MODE_WEBM) {
2724  av_log(s, AV_LOG_WARNING, "Stream %d will be ignored "
2725  "as WebM doesn't support attachments.\n", i);
2726  } else if (!get_mimetype(st)) {
2727  av_log(s, AV_LOG_ERROR, "Attachment stream %d has no mimetype "
2728  "tag and it cannot be deduced from the codec id.\n", i);
2729  return AVERROR(EINVAL);
2730  }
2731  mkv->nb_attachments++;
2732  continue;
2733  }
2734 
2735  nb_tracks++;
2736  track->track_num = mkv->is_dash ? mkv->dash_track_number : nb_tracks;
2737  track->track_num_size = ebml_num_size(track->track_num);
2738  }
2739 
2740  if (mkv->is_dash && nb_tracks != 1)
2741  return AVERROR(EINVAL);
2742 
2743  return 0;
2744 }
2745 
2746 static int mkv_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
2747 {
2748  int ret = 1;
2749  AVStream *st = s->streams[pkt->stream_index];
2750 
2751  if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
2752  if (pkt->size > 2 && (AV_RB16(pkt->data) & 0xfff0) == 0xfff0)
2753  ret = ff_stream_add_bitstream_filter(st, "aac_adtstoasc", NULL);
2754  } else if (st->codecpar->codec_id == AV_CODEC_ID_VP9) {
2755  ret = ff_stream_add_bitstream_filter(st, "vp9_superframe", NULL);
2756  }
2757 
2758  return ret;
2759 }
2760 
2762  { AV_CODEC_ID_ALAC, 0XFFFFFFFF },
2763  { AV_CODEC_ID_MLP, 0xFFFFFFFF },
2764  { AV_CODEC_ID_OPUS, 0xFFFFFFFF },
2765  { AV_CODEC_ID_PCM_S16BE, 0xFFFFFFFF },
2766  { AV_CODEC_ID_PCM_S24BE, 0xFFFFFFFF },
2767  { AV_CODEC_ID_PCM_S32BE, 0xFFFFFFFF },
2768  { AV_CODEC_ID_QDMC, 0xFFFFFFFF },
2769  { AV_CODEC_ID_QDM2, 0xFFFFFFFF },
2770  { AV_CODEC_ID_RA_144, 0xFFFFFFFF },
2771  { AV_CODEC_ID_RA_288, 0xFFFFFFFF },
2772  { AV_CODEC_ID_COOK, 0xFFFFFFFF },
2773  { AV_CODEC_ID_TRUEHD, 0xFFFFFFFF },
2774  { AV_CODEC_ID_NONE, 0xFFFFFFFF }
2775 };
2776 
2778  { AV_CODEC_ID_RV10, 0xFFFFFFFF },
2779  { AV_CODEC_ID_RV20, 0xFFFFFFFF },
2780  { AV_CODEC_ID_RV30, 0xFFFFFFFF },
2781  { AV_CODEC_ID_NONE, 0xFFFFFFFF }
2782 };
2783 
2785  { AV_CODEC_ID_DVB_SUBTITLE, 0xFFFFFFFF },
2786  { AV_CODEC_ID_DVD_SUBTITLE, 0xFFFFFFFF },
2787  { AV_CODEC_ID_HDMV_PGS_SUBTITLE, 0xFFFFFFFF },
2788  { AV_CODEC_ID_NONE, 0xFFFFFFFF }
2789 };
2790 
2791 #define OFFSET(x) offsetof(MatroskaMuxContext, x)
2792 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM
2793 static const AVOption options[] = {
2794  { "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 },
2795  { "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 },
2796  { "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 },
2797  { "dash", "Create a WebM file conforming to WebM DASH specification", OFFSET(is_dash), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
2798  { "dash_track_number", "Track number for the DASH stream", OFFSET(dash_track_number), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, INT_MAX, FLAGS },
2799  { "live", "Write files assuming it is a live stream.", OFFSET(is_live), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
2800  { "allow_raw_vfw", "allow RAW VFW mode", OFFSET(allow_raw_vfw), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
2801  { "flipped_raw_rgb", "Raw RGB bitmaps in VFW mode are stored bottom-up", OFFSET(flipped_raw_rgb), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
2802  { "write_crc32", "write a CRC32 element inside every Level 1 element", OFFSET(write_crc), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, FLAGS },
2803  { "default_mode", "Controls how a track's FlagDefault is inferred", OFFSET(default_mode), AV_OPT_TYPE_INT, { .i64 = DEFAULT_MODE_INFER }, DEFAULT_MODE_INFER, DEFAULT_MODE_PASSTHROUGH, FLAGS, "default_mode" },
2804  { "infer", "For each track type, mark the first track of disposition default as default; if none exists, mark the first track as default.", 0, AV_OPT_TYPE_CONST, { .i64 = DEFAULT_MODE_INFER }, 0, 0, FLAGS, "default_mode" },
2805  { "infer_no_subs", "For each track type, mark the first track of disposition default as default; for audio and video: if none exists, mark the first track as default.", 0, AV_OPT_TYPE_CONST, { .i64 = DEFAULT_MODE_INFER_NO_SUBS }, 0, 0, FLAGS, "default_mode" },
2806  { "passthrough", "Use the disposition flag as-is", 0, AV_OPT_TYPE_CONST, { .i64 = DEFAULT_MODE_PASSTHROUGH }, 0, 0, FLAGS, "default_mode" },
2807  { NULL },
2808 };
2809 
2810 #if CONFIG_MATROSKA_MUXER
2811 static const AVClass matroska_class = {
2812  .class_name = "matroska muxer",
2813  .item_name = av_default_item_name,
2814  .option = options,
2815  .version = LIBAVUTIL_VERSION_INT,
2816 };
2817 
2819  .name = "matroska",
2820  .long_name = NULL_IF_CONFIG_SMALL("Matroska"),
2821  .mime_type = "video/x-matroska",
2822  .extensions = "mkv",
2823  .priv_data_size = sizeof(MatroskaMuxContext),
2824  .audio_codec = CONFIG_LIBVORBIS_ENCODER ?
2826  .video_codec = CONFIG_LIBX264_ENCODER ?
2828  .init = mkv_init,
2829  .deinit = mkv_deinit,
2835  .codec_tag = (const AVCodecTag* const []){
2838  },
2839  .subtitle_codec = AV_CODEC_ID_ASS,
2840  .query_codec = mkv_query_codec,
2841  .check_bitstream = mkv_check_bitstream,
2842  .priv_class = &matroska_class,
2843 };
2844 #endif
2845 
2846 #if CONFIG_WEBM_MUXER
2847 static const AVClass webm_class = {
2848  .class_name = "webm muxer",
2849  .item_name = av_default_item_name,
2850  .option = options,
2851  .version = LIBAVUTIL_VERSION_INT,
2852 };
2853 
2855  .name = "webm",
2856  .long_name = NULL_IF_CONFIG_SMALL("WebM"),
2857  .mime_type = "video/webm",
2858  .extensions = "webm",
2859  .priv_data_size = sizeof(MatroskaMuxContext),
2860  .audio_codec = CONFIG_LIBOPUS_ENCODER ? AV_CODEC_ID_OPUS : AV_CODEC_ID_VORBIS,
2861  .video_codec = CONFIG_LIBVPX_VP9_ENCODER? AV_CODEC_ID_VP9 : AV_CODEC_ID_VP8,
2862  .subtitle_codec = AV_CODEC_ID_WEBVTT,
2863  .init = mkv_init,
2864  .deinit = mkv_deinit,
2872  .priv_class = &webm_class,
2873 };
2874 #endif
2875 
2876 #if CONFIG_MATROSKA_AUDIO_MUXER
2877 static const AVClass mka_class = {
2878  .class_name = "matroska audio muxer",
2879  .item_name = av_default_item_name,
2880  .option = options,
2881  .version = LIBAVUTIL_VERSION_INT,
2882 };
2884  .name = "matroska",
2885  .long_name = NULL_IF_CONFIG_SMALL("Matroska Audio"),
2886  .mime_type = "audio/x-matroska",
2887  .extensions = "mka",
2888  .priv_data_size = sizeof(MatroskaMuxContext),
2889  .audio_codec = CONFIG_LIBVORBIS_ENCODER ?
2891  .video_codec = AV_CODEC_ID_NONE,
2892  .init = mkv_init,
2893  .deinit = mkv_deinit,
2900  .codec_tag = (const AVCodecTag* const []){
2902  },
2903  .priv_class = &mka_class,
2904 };
2905 #endif
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1472
int32_t pitch
Rotation around the right vector [-90, 90].
Definition: spherical.h:127
Context structure for the Lagged Fibonacci PRNG.
Definition: lfg.h:33
#define MATROSKA_ID_SEEKPREROLL
Definition: matroska.h:95
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:167
int track_num_size
Definition: matroskaenc.c:110
#define MATROSKA_ID_VIDEOPROJECTIONPOSEYAW
Definition: matroska.h:163
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:726
enum AVChromaLocation chroma_location
Definition: codec_par.h:150
internal header for HEVC (de)muxer utilities
#define AV_DISPOSITION_METADATA
Definition: avformat.h:866
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:453
#define NULL
Definition: coverity.c:32
#define MATROSKA_ID_BLOCKADDID
Definition: matroska.h:234
#define MATROSKA_ID_TRACKDEFAULTDURATION
Definition: matroska.h:108
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:141
void avio_wl16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:459
static void put_ebml_size_unknown(AVIOContext *pb, int bytes)
Write an EBML size meaning "unknown size".
Definition: matroskaenc.c:194
Bytestream IO Context.
Definition: avio.h:161
enum AVColorTransferCharacteristic color_trc
Definition: codec_par.h:148
#define MATROSKA_ID_VIDEOFLAGINTERLACED
Definition: matroska.h:125
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define MATROSKA_ID_VIDEOCOLOR_GX
Definition: matroska.h:151
static int start_ebml_master_crc32(AVIOContext **dyn_cp, MatroskaMuxContext *mkv)
Definition: matroskaenc.c:368
void ff_metadata_conv_ctx(AVFormatContext *ctx, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)
Definition: metadata.c:59
version
Definition: libkvazaar.c:320
#define MATROSKA_ID_DATEUTC
Definition: matroska.h:71
int sizebytes
how many bytes were reserved for the size
Definition: matroskaenc.c:72
The optional first identifier line of a WebVTT cue.
Definition: packet.h:196
uint32_t samples
Definition: wv.h:39
int initial
Definition: wv.h:43
#define MATROSKA_ID_TRACKFLAGLACING
Definition: matroska.h:105
unsigned MaxCLL
Max content light level (cd/m^2).
#define MATROSKA_ID_TRACKENTRY
Definition: matroska.h:75
static int mkv_write_packet(AVFormatContext *s, const AVPacket *pkt)
Definition: matroskaenc.c:2372
#define MATROSKA_ID_VIDEODISPLAYHEIGHT
Definition: matroska.h:117
AVOption.
Definition: opt.h:248
int64_t cluster_pos
offset of the cluster containing the block relative to the segment
Definition: matroskaenc.c:95
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
int ff_put_wav_header(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, int flags)
Write WAVEFORMAT header structure.
Definition: riffenc.c:54
static int mkv_init(struct AVFormatContext *s)
Definition: matroskaenc.c:2665
#define MAX_SEEKHEAD_ENTRIES
Definition: matroskaenc.c:59
static int mkv_write_packet_internal(AVFormatContext *s, const AVPacket *pkt)
Definition: matroskaenc.c:2280
#define MATROSKA_ID_VIDEOPROJECTIONPOSEROLL
Definition: matroska.h:165
#define MATROSKA_ID_CUETRACKPOSITION
Definition: matroska.h:196
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3108
#define MATROSKA_ID_CODECPRIVATE
Definition: matroska.h:89
AVIOContext * cluster_bc
Definition: matroskaenc.c:130
#define MATROSKA_ID_TRACKFLAGVISUALIMPAIRED
Definition: matroska.h:102
const char * desc
Definition: libsvtav1.c:79
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
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:4905
int av_parse_time(int64_t *timeval, const char *timestr, int duration)
Parse timestr and return in *time a corresponding number of microseconds.
Definition: parseutils.c:587
FFmpeg currently uses a custom build this text attempts to document some of its obscure features and options Makefile the full command issued by make and its output will be shown on the screen DBG Preprocess x86 external assembler files to a dbg asm file in the object which then gets compiled Helps in developing those assembler files DESTDIR Destination directory for the install targets
Definition: build_system.txt:1
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
#define MATROSKA_ID_AUDIOBITDEPTH
Definition: matroska.h:171
#define CASE(type, variable)
#define MATROSKA_ID_TRACKFLAGDEFAULT
Definition: matroska.h:99
static const AVCodecTag additional_subtitle_tags[]
Definition: matroskaenc.c:2784
This side data should be associated with a video stream and contains Stereoscopic 3D information in f...
Definition: packet.h:114
static int mkv_write_attachments(AVFormatContext *s)
Definition: matroskaenc.c:1727
uint64_t pts
Definition: matroskaenc.c:93
Video represents a portion of a sphere mapped on a flat surface using equirectangular projection...
Definition: spherical.h:72
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:946
#define MATROSKA_ID_TAGTARGETS_ATTACHUID
Definition: matroska.h:218
int num
Numerator.
Definition: rational.h:59
int size
Definition: packet.h:364
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:1047
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:253
#define MATROSKA_ID_FILEDATA
Definition: matroska.h:250
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1708
#define EBML_ID_DOCTYPEREADVERSION
Definition: matroska.h:42
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:278
#define MATROSKA_ID_BLOCKREFERENCE
Definition: matroska.h:241
int av_log2(unsigned v)
Definition: intmath.c:26
static int mkv_write_header(AVFormatContext *s)
Definition: matroskaenc.c:1795
#define MATROSKA_ID_TRACKTYPE
Definition: matroska.h:80
enum AVMediaType codec_type
Definition: rtp.c:37
#define MATROSKA_ID_TAGTARGETS_CHAPTERUID
Definition: matroska.h:217
int ff_flac_is_native_layout(uint64_t channel_layout)
int64_t duration
duration of the block according to time base
Definition: matroskaenc.c:97
static av_always_inline uint64_t av_double2int(double f)
Reinterpret a double as a 64-bit integer.
Definition: intfloat.h:70
GLint GLenum type
Definition: opengl_enc.c:104
#define AV_DISPOSITION_HEARING_IMPAIRED
stream for hearing impaired audiences
Definition: avformat.h:842
#define MATROSKA_ID_VIDEOCOLOR_RX
Definition: matroska.h:149
Video represents a sphere mapped on a flat surface using equirectangular projection.
Definition: spherical.h:56
static int mkv_write_tag(MatroskaMuxContext *mkv, const AVDictionary *m, AVIOContext **pb, ebml_master *tag, uint32_t elementid, uint64_t uid)
Definition: matroskaenc.c:1513
#define MATROSKA_ID_MUXINGAPP
Definition: matroska.h:70
int64_t cluster_time_limit
Definition: matroskaenc.c:150
#define MATROSKA_ID_AUDIOCHANNELS
Definition: matroska.h:172
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
Definition: utils.c:3098
const char * key
int avoid_negative_ts_use_pts
Definition: internal.h:119
const char * master
Definition: vf_curves.c:119
#define MATROSKA_ID_VIDEOPROJECTIONTYPE
Definition: matroska.h:161
Views are next to each other.
Definition: stereo3d.h:67
static AVPacket pkt
static void put_ebml_length(AVIOContext *pb, uint64_t length, int bytes)
Write a length as EBML variable length integer.
Definition: matroskaenc.c:240
#define av_le2ne32(x)
Definition: bswap.h:96
#define MATROSKA_ID_CUECLUSTERPOSITION
Definition: matroska.h:200
#define MATROSKA_ID_VIDEOCOLOR_LUMINANCEMAX
Definition: matroska.h:157
#define MAX_EBML_HEADER_SIZE
2 bytes * 7 for EBML IDs, 7 1-byte EBML lengths, 6 1-byte uint, 8 byte for "matroska" doctype string ...
Definition: matroskaenc.c:165
Definition: matroskaenc.c:80
int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos)
Converts AVChromaLocation to swscale x/y chroma position.
Definition: utils.c:355
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:91
AVDictionary * metadata
Definition: avformat.h:1204
#define MATROSKA_ID_VIDEOCOLORCHROMASITINGHORZ
Definition: matroska.h:139
mkv_track * tracks
Definition: matroskaenc.c:135
ebml_stored_master track
Definition: matroskaenc.c:127
#define AVFMT_ALLOW_FLUSH
Format allows flushing.
Definition: avformat.h:471
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate.The lists are not just lists
#define MATROSKA_ID_EDITIONFLAGDEFAULT
Definition: matroska.h:264
#define MATROSKA_ID_CLUSTERTIMECODE
Definition: matroska.h:228
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1383
#define EBML_ID_DOCTYPE
Definition: matroska.h:40
int64_t duration_offset
Definition: matroskaenc.c:115
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:472
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
#define MATROSKA_ID_CHAPTERTIMEEND
Definition: matroska.h:257
enum AVColorSpace color_space
Definition: codec_par.h:149
int64_t pos
absolute offset in the containing AVIOContext where the master&#39;s elements start
Definition: matroskaenc.c:71
MatroskaVideoStereoModeType
Definition: matroska.h:305
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:222
#define FLAGS
Definition: matroskaenc.c:2792
#define MATROSKA_ID_FILEDESC
Definition: matroska.h:247
Format I/O context.
Definition: avformat.h:1243
#define EBML_ID_CRC32
Definition: matroska.h:46
const AVCodecTag ff_codec_movvideo_tags[]
Definition: isom_tags.c:29
int ff_vorbiscomment_write(AVIOContext *pb, const AVDictionary *m, const char *vendor_string, AVChapter **chapters, unsigned int nb_chapters)
Write a VorbisComment into an AVIOContext.
Definition: vorbiscomment.c:65
UID uid
Definition: mxfenc.c:2204
static int query_codec(enum AVCodecID id, int std_compliance)
Definition: img2enc.c:229
int64_t cluster_pos
file offset of the current Cluster
Definition: matroskaenc.c:131
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:2761
Public dictionary API.
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
void avio_wl32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:379
uint8_t
#define MATROSKA_ID_VIDEOCOLOR_BX
Definition: matroska.h:153
#define MATROSKA_ID_CHAPLANG
Definition: matroska.h:260
#define av_malloc(s)
int avpriv_mpeg4audio_get_config2(MPEG4AudioConfig *c, const uint8_t *buf, int size, int sync_extension, void *logctx)
Parse MPEG-4 systems extradata from a raw buffer to retrieve audio configuration. ...
Definition: mpeg4audio.c:190
int width
Video only.
Definition: codec_par.h:126
uint64_t uid
Definition: matroskaenc.c:108
unsigned track_num
Definition: matroskaenc.c:109
AVOptions.
#define MATROSKA_ID_TRACKLANGUAGE
Definition: matroska.h:97
int64_t duration
Definition: matroskaenc.c:114
A point in the output bytestream where the underlying AVIOContext might flush the buffer depending on...
Definition: avio.h:146
Stereo 3D type: this structure describes how two videos are packed within a single video surface...
Definition: stereo3d.h:176
#define OPUS_SEEK_PREROLL
Seek preroll value for opus.
Definition: matroskaenc.c:175
uint32_t flags
Definition: wv.h:40
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
int ff_mkv_stereo3d_conv(AVStream *st, MatroskaVideoStereoModeType stereo_mode)
Definition: matroska.c:152
uint64_t segmentpos
Definition: matroskaenc.c:82
int id
unique ID to identify the chapter
Definition: avformat.h:1201
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:381
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
#define MATROSKA_ID_TIMECODESCALE
Definition: matroska.h:66
static int mkv_write_codecprivate(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, int native_id, int qt_id)
Definition: matroskaenc.c:763
#define MATROSKA_ID_SIMPLEBLOCK
Definition: matroska.h:236
void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type)
Mark the written bytestream as a specific type.
Definition: aviobuf.c:483
uint8_t * av_stream_get_side_data(const AVStream *stream, enum AVPacketSideDataType type, int *size)
Get side information from stream.
Definition: utils.c:5465
static int put_xiph_codecpriv(AVFormatContext *s, AVIOContext *pb, const AVCodecParameters *par)
Definition: matroskaenc.c:603
#define MATROSKA_ID_BLOCKMORE
Definition: matroska.h:233
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:91
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1311
int64_t duration
Definition: movenc.c:63
#define MATROSKA_ID_CUERELATIVEPOSITION
Definition: matroska.h:201
A point in the output bytestream where a demuxer can start parsing (for non self synchronizing bytest...
Definition: avio.h:128
#define MATROSKA_ID_AUDIOOUTSAMPLINGFREQ
Definition: matroska.h:169
#define MATROSKA_ID_VIDEOCOLOR
Definition: matroska.h:131
Public header for CRC hash function implementation.
int initial_padding
Audio only.
Definition: codec_par.h:189
static int webm_query_codec(enum AVCodecID codec_id, int std_compliance)
Definition: matroskaenc.c:2637
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1374
uint8_t * data
Definition: packet.h:363
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
#define MATROSKA_ID_VIDEODISPLAYWIDTH
Definition: matroska.h:116
int ff_isom_write_av1c(AVIOContext *pb, const uint8_t *buf, int size)
Writes AV1 extradata (Sequence Header and Metadata OBUs) to the provided AVIOContext.
Definition: av1.c:364
#define MATROSKA_ID_BLOCKADDITIONS
Definition: matroska.h:232
uint32_t tag
Definition: movenc.c:1597
static int mkv_add_cuepoint(MatroskaMuxContext *mkv, int stream, int64_t ts, int64_t cluster_pos, int64_t relative_pos, int64_t duration)
Definition: matroskaenc.c:531
static EbmlSyntax ebml_header[]
Definition: matroskadec.c:422
Not part of ABI.
Definition: pixfmt.h:587
#define WV_HEADER_SIZE
Definition: wavpack.h:30
static int mkv_check_tag(const AVDictionary *m, uint32_t elementid)
Definition: matroskaenc.c:1539
#define MATROSKA_ID_CUES
Definition: matroska.h:58
int64_t ts_offset
Definition: matroskaenc.c:117
#define max(a, b)
Definition: cuda_runtime.h:33
Video is not stereoscopic (and metadata has to be there).
Definition: stereo3d.h:55
ptrdiff_t size
Definition: opengl_enc.c:100
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
static const uint8_t header[24]
Definition: sdr2.c:67
#define MATROSKA_ID_TRACKNUMBER
Definition: matroska.h:78
#define MATROSKA_ID_VIDEOCOLOR_WHITEY
Definition: matroska.h:156
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:225
Definition: wv.h:34
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1391
static uint64_t mkv_get_uid(const mkv_track *tracks, int i, AVLFG *c)
Definition: matroskaenc.c:2647
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:198
#define MATROSKA_ID_SEGMENTUID
Definition: matroska.h:72
static int mkv_write_track(AVFormatContext *s, MatroskaMuxContext *mkv, AVStream *st, mkv_track *track, AVIOContext *pb, int is_default)
Definition: matroskaenc.c:1115
AVOutputFormat ff_webm_muxer
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
static void put_ebml_num(AVIOContext *pb, uint64_t num, int bytes)
Write a number as EBML variable length integer on bytes bytes.
Definition: matroskaenc.c:227
#define av_log(a,...)
#define AV_DISPOSITION_CAPTIONS
To specify text track kind (different from subtitles default).
Definition: avformat.h:864
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: avpacket.c:615
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
static void mkv_add_seekhead_entry(MatroskaMuxContext *mkv, uint32_t elementid, uint64_t filepos)
Definition: matroskaenc.c:357
#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:142
#define U(x)
Definition: vp56_arith.h:37
#define src
Definition: vp8dsp.c:255
#define MATROSKA_ID_VIDEOSTEREOMODE
Definition: matroska.h:127
static void put_ebml_id(AVIOContext *pb, uint32_t id)
Definition: matroskaenc.c:182
int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
Parse creation_time in AVFormatContext metadata if exists and warn if the parsing fails...
Definition: utils.c:5664
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
AVPacket cur_audio_pkt
Definition: matroskaenc.c:140
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
static int mkv_write_tags(AVFormatContext *s)
Definition: matroskaenc.c:1550
#define MATROSKA_ID_VIDEOCOLOR_BY
Definition: matroska.h:154
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
static void put_ebml_float(AVIOContext *pb, uint32_t elementid, double val)
Definition: matroskaenc.c:292
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1611
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1483
int flags
Additional information about the frame packing.
Definition: stereo3d.h:185
#define MATROSKA_ID_BLOCKDURATION
Definition: matroska.h:240
#define EBML_ID_EBMLREADVERSION
Definition: matroska.h:37
#define MATROSKA_ID_VIDEOCOLORMAXCLL
Definition: matroska.h:145
#define MAX_CUETRACKPOS_SIZE
4 * (1-byte EBML ID, 1-byte EBML size, 8-byte uint max)
Definition: matroskaenc.c:172
#define MATROSKA_ID_VIDEOCOLOR_WHITEX
Definition: matroska.h:155
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:353
int reserved_size
Definition: matroskaenc.c:89
#define MATROSKA_ID_CLUSTER
Definition: matroska.h:62
const char * ff_convert_lang_to(const char *lang, enum AVLangCodespace target_codespace)
Convert a language code to a target codespace.
Definition: avlanguage.c:736
#define MATROSKA_ID_VIDEOCOLORCHROMASITINGVERT
Definition: matroska.h:140
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:115
int ff_av1_filter_obus_buf(const uint8_t *in, uint8_t **out, int *size, int *offset)
Filter out AV1 OBUs not meant to be present in ISOBMFF sample data and return the result in a data bu...
Definition: av1.c:86
Views are packed per line, as if interlaced.
Definition: stereo3d.h:129
enum AVColorPrimaries color_primaries
Definition: codec_par.h:147
void ffio_reset_dyn_buf(AVIOContext *s)
Reset a dynamic buffer.
Definition: aviobuf.c:1417
#define MATROSKA_ID_FILEMIMETYPE
Definition: matroska.h:249
#define MATROSKA_ID_WRITINGAPP
Definition: matroska.h:69
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
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:1068
Not part of ABI.
Definition: pixfmt.h:476
const char *const ff_matroska_video_stereo_mode[MATROSKA_VIDEO_STEREOMODE_TYPE_NB]
Definition: matroska.c:128
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
static void put_ebml_void(AVIOContext *pb, int size)
Write a void element of a given size.
Definition: matroskaenc.c:319
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
static int ebml_num_size(uint64_t num)
Returns how many bytes are needed to represent a number as EBML variable length integer.
Definition: matroskaenc.c:205
int write_dts
Definition: matroskaenc.c:106
int final
Definition: wv.h:43
AVChapter ** chapters
Definition: avformat.h:1473
enum AVCodecID id
Definition: matroska.h:359
static int mkv_write_chapters(AVFormatContext *s)
Definition: matroskaenc.c:1623
GLsizei GLsizei * length
Definition: opengl_enc.c:114
#define EBML_ID_EBMLMAXIDLENGTH
Definition: matroska.h:38
AVIOContext * bc
Definition: matroskaenc.c:76
uint32_t crc
Definition: wv.h:41
static int mkv_write_seekhead(AVIOContext *pb, MatroskaMuxContext *mkv, int error_on_seek_failure, int64_t destpos)
Write the SeekHead to the file at the location reserved for it and seek to destpos afterwards...
Definition: matroskaenc.c:490
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:957
const AVCodecTag ff_codec_wav_tags[]
Definition: riff.c:508
#define FFMAX(a, b)
Definition: common.h:103
int ff_avc_parse_nal_units_buf(const uint8_t *buf_in, uint8_t **buf, int *size)
Definition: avc.c:95
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
int64_t filepos
Definition: matroskaenc.c:86
#define fail()
Definition: checkasm.h:133
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
#define MATROSKA_ID_TAG
Definition: matroska.h:206
const CodecTags ff_webm_codec_tags[]
Definition: matroska.c:106
Views are alternated temporally.
Definition: stereo3d.h:92
#define AV_DISPOSITION_FORCED
Track should be used during playback by default.
Definition: avformat.h:841
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1299
uint32_t bound_bottom
Distance from the bottom edge.
Definition: spherical.h:170
static int end_ebml_master_crc32(AVIOContext *pb, AVIOContext **dyn_cp, MatroskaMuxContext *mkv, uint32_t id, int length_size, int keep_buffer, int add_seekentry)
Definition: matroskaenc.c:381
AVOutputFormat ff_matroska_audio_muxer
static int mkv_write_simpletag(AVIOContext *pb, const AVDictionaryEntry *t)
Definition: matroskaenc.c:1445
#define LIBAVFORMAT_IDENT
Definition: version.h:46
static int ebml_length_size(uint64_t length)
Calculate how many bytes are needed to represent the length field of an EBML element whose payload ha...
Definition: matroskaenc.c:218
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
Video frame is split into 6 faces of a cube, and arranged on a 3x2 layout.
Definition: spherical.h:65
#define MATROSKA_ID_VIDEOCOLOR_LUMINANCEMIN
Definition: matroska.h:158
audio channel layout utility functions
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0...
Definition: utils.c:3291
#define EBML_ID_EBMLVERSION
Definition: matroska.h:36
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
mkv_cuepoint * entries
Definition: matroskaenc.c:101
void ffio_fill(AVIOContext *s, int b, int count)
Definition: aviobuf.c:211
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
#define MATROSKA_ID_TAGTARGETS
Definition: matroska.h:213
const AVCodecTag ff_codec_bmp_tags[]
Definition: riff.c:33
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:215
#define MATROSKA_ID_TAGNAME
Definition: matroska.h:208
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
uint32_t segment_uid[4]
Definition: matroskaenc.c:160
static int64_t get_metadata_duration(AVFormatContext *s)
Definition: matroskaenc.c:1771
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:98
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
Definition: af_astats.c:254
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:461
void avio_wb24(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:477
This side data should be associated with a video stream and corresponds to the AVSphericalMapping str...
Definition: packet.h:228
uint32_t bound_right
Distance from the right edge.
Definition: spherical.h:169
int ff_wv_parse_header(WvHeader *wv, const uint8_t *data)
Parse a WavPack block header.
Definition: wv.c:29
#define MATROSKA_ID_SIMPLETAG
Definition: matroska.h:207
const char * name
Definition: avformat.h:500
internal header for RIFF based (de)muxers do NOT include this in end user applications ...
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:392
#define s(width, name)
Definition: cbs_vp9.c:257
static int end_ebml_master_crc32_tentatively(AVIOContext *pb, ebml_stored_master *elem, MatroskaMuxContext *mkv, uint32_t id)
Output EBML master.
Definition: matroskaenc.c:418
int avoid_negative_ts
Avoid negative timestamps during muxing.
Definition: avformat.h:1586
#define MATROSKA_ID_CHAPTERATOM
Definition: matroska.h:255
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
static int mkv_write_native_codecprivate(AVFormatContext *s, AVIOContext *pb, const AVCodecParameters *par, AVIOContext *dyn_cp)
Definition: matroskaenc.c:711
int32_t yaw
Rotation around the up vector [-180, 180].
Definition: spherical.h:126
static int get_aac_sample_rates(AVFormatContext *s, MatroskaMuxContext *mkv, const uint8_t *extradata, int extradata_size, int *sample_rate, int *output_sample_rate)
Definition: matroskaenc.c:678
AVDictionary * metadata
Definition: avformat.h:948
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
enum AVColorRange color_range
Video only.
Definition: codec_par.h:146
static int mkv_check_new_extra_data(AVFormatContext *s, const AVPacket *pkt)
Definition: matroskaenc.c:2190
Opaque data information usually sparse.
Definition: avutil.h:205
#define MATROSKA_ID_VIDEOCOLORSPACE
Definition: matroska.h:130
#define MATROSKA_ID_CHAPTERS
Definition: matroska.h:63
ebml_stored_master info
Definition: matroskaenc.c:126
#define EBML_ID_VOID
Definition: matroska.h:45
#define OFFSET(x)
Definition: matroskaenc.c:2791
#define MATROSKA_ID_TRACKFLAGHEARINGIMPAIRED
Definition: matroska.h:101
#define MATROSKA_ID_TRACKFLAGTEXTDESCRIPTIONS
Definition: matroska.h:103
int64_t ff_vorbiscomment_length(const AVDictionary *m, const char *vendor_string, AVChapter **chapters, unsigned int nb_chapters)
Calculate the length in bytes of a VorbisComment.
Definition: vorbiscomment.c:41
#define MATROSKA_ID_AUDIOSAMPLINGFREQ
Definition: matroska.h:168
ff_const59 struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1262
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1458
#define AV_DISPOSITION_VISUAL_IMPAIRED
stream for visual impaired audiences
Definition: avformat.h:843
uint32_t padding
Number of pixels to pad from the edge of each cube face.
Definition: spherical.h:182
int metadata_header_padding
Number of bytes to be written as padding in a metadata header.
Definition: avformat.h:1755
Stream structure.
Definition: avformat.h:884
#define IS_SEEKABLE(pb, mkv)
Definition: matroskaenc.c:61
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1203
Content light level (based on CTA-861.3).
Definition: packet.h:235
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:55
#define AV_DISPOSITION_DEFAULT
Definition: avformat.h:829
sample_rate
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:180
Views are packed in a checkerboard-like structure per pixel.
Definition: stereo3d.h:104
#define MATROSKA_ID_VIDEOCOLORMATRIXCOEFF
Definition: matroska.h:133
#define AV_DISPOSITION_DESCRIPTIONS
Definition: avformat.h:865
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
#define MATROSKA_ID_TRACKFLAGFORCED
Definition: matroska.h:100
#define MATROSKA_ID_TAGS
Definition: matroska.h:59
Views are on top of each other.
Definition: stereo3d.h:79
#define MATROSKA_ID_VIDEOCOLORPRIMARIES
Definition: matroska.h:144
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:91
int64_t sample_rate_offset
Definition: matroskaenc.c:112
#define MATROSKA_ID_VIDEOPROJECTIONPOSEPITCH
Definition: matroska.h:164
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
#define MATROSKA_ID_SEEKID
Definition: matroska.h:224
AVIOContext * pb
I/O context.
Definition: avformat.h:1285
int64_t codecpriv_offset
Definition: matroskaenc.c:116
static void put_ebml_uint(AVIOContext *pb, uint32_t elementid, uint64_t val)
Definition: matroskaenc.c:265
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:203
#define MATROSKA_ID_BLOCK
Definition: matroska.h:239
#define MATROSKA_ID_INFO
Definition: matroska.h:56
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:606
#define MATROSKA_ID_TAGTARGETS_TRACKUID
Definition: matroska.h:216
#define MATROSKA_ID_TAGLANG
Definition: matroska.h:210
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Definition: lfg.h:53
#define MATROSKA_ID_TRACKS
Definition: matroska.h:57
Data found in BlockAdditional element of matroska container.
Definition: packet.h:191
#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:70
static void mkv_write_video_color(AVIOContext *pb, const AVStream *st, const AVCodecParameters *par)
Definition: matroskaenc.c:833
#define MATROSKA_ID_SEEKENTRY
Definition: matroska.h:221
static void put_ebml_uid(AVIOContext *pb, uint32_t elementid, uint64_t uid)
Write a (random) UID with fixed size to make the output more deterministic.
Definition: matroskaenc.c:258
Describe the class of an AVClass context structure.
Definition: log.h:67
unsigned nb_attachments
Definition: matroskaenc.c:142
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
#define MATROSKA_ID_EDITIONENTRY
Definition: matroska.h:254
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:1599
static int mkv_check_tag_name(const char *name, uint32_t elementid)
Definition: matroskaenc.c:1499
#define MATROSKA_ID_BLOCKGROUP
Definition: matroska.h:231
#define MATROSKA_ID_VIDEOPIXELHEIGHT
Definition: matroska.h:119
int32_t roll
Rotation around the forward vector [-180, 180].
Definition: spherical.h:128
static int mkv_write_tracks(AVFormatContext *s)
Definition: matroskaenc.c:1387
Rational number (pair of numerator and denominator).
Definition: rational.h:58
Mastering display metadata capable of representing the color volume of the display used to master the...
#define MATROSKA_ID_CUEDURATION
Definition: matroska.h:202
#define MATROSKA_ID_CUETIME
Definition: matroska.h:195
Not part of ABI.
Definition: pixfmt.h:505
Recommmends skipping the specified number of samples.
Definition: packet.h:156
AVMediaType
Definition: avutil.h:199
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:32
int64_t duration_offset
Definition: matroskaenc.c:133
#define MATROSKA_ID_VIDEOCOLORTRANSFERCHARACTERISTICS
Definition: matroska.h:142
#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:1961
This structure describes how to handle spherical videos, outlining information about projection...
Definition: spherical.h:82
int error
contains the error code or 0 if no error happened
Definition: avio.h:245
mkv_seekhead seekhead
Definition: matroskaenc.c:136
#define MATROSKA_ID_VIDEOPROJECTION
Definition: matroska.h:160
#define MATROSKA_ID_VIDEOCOLORMASTERINGMETA
Definition: matroska.h:148
misc parsing utilities
ebml_stored_master tags
Definition: matroskaenc.c:128
#define MATROSKA_ID_VIDEOPROJECTIONPRIVATE
Definition: matroska.h:162
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: codec_desc.h:38
#define MATROSKA_ID_ATTACHMENTS
Definition: matroska.h:61
static int64_t pts
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:465
#define flags(name, subs,...)
Definition: cbs_av1.c:561
#define MATROSKA_ID_CHAPTERDISPLAY
Definition: matroska.h:258
static int mkv_end_cluster(AVFormatContext *s)
Definition: matroskaenc.c:2171
int bits_per_raw_sample
This is the number of valid bits in each output sample.
Definition: codec_par.h:115
#define MATROSKA_ID_FILENAME
Definition: matroska.h:248
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
#define MATROSKA_ID_BLOCKADDITIONAL
Definition: matroska.h:235
AVFieldOrder
Definition: codec_par.h:36
uint32_t bound_top
Distance from the top edge.
Definition: spherical.h:168
const AVMetadataConv ff_mkv_metadata_conv[]
Definition: matroska.c:122
#define MATROSKA_ID_CODECID
Definition: matroska.h:88
static const AVCodecTag additional_video_tags[]
Definition: matroskaenc.c:2777
mkv_seekhead_entry entries[MAX_SEEKHEAD_ENTRIES]
Definition: matroskaenc.c:87
#define MATROSKA_ID_VIDEOFIELDORDER
Definition: matroska.h:126
int64_t start
Definition: avformat.h:1203
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
int sample_rate
Audio only.
Definition: codec_par.h:170
int ff_flac_write_header(AVIOContext *pb, const uint8_t *extradata, int extradata_size, int last_block)
#define MATROSKA_ID_VIDEOALPHAMODE
Definition: matroska.h:128
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
static int mkv_write_trailer(AVFormatContext *s)
Definition: matroskaenc.c:2464
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_RB64
Definition: bytestream.h:91
Main libavformat public API header.
static int put_flac_codecpriv(AVFormatContext *s, AVIOContext *pb, const AVCodecParameters *par)
Definition: matroskaenc.c:642
static int mkv_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
Definition: matroskaenc.c:2746
#define MATROSKA_ID_CUETRACK
Definition: matroska.h:199
static int put_wv_codecpriv(AVIOContext *pb, const AVCodecParameters *par)
Definition: matroskaenc.c:633
#define MATROSKA_ID_SEEKPOSITION
Definition: matroska.h:225
#define MATROSKA_ID_CODECDELAY
Definition: matroska.h:94
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
#define MATROSKA_ID_CHAPTERTIMESTART
Definition: matroska.h:256
#define MATROSKA_ID_VIDEOCOLORRANGE
Definition: matroska.h:141
enum AVSphericalProjection projection
Projection type.
Definition: spherical.h:86
Utilties for rational number calculation.
int ffio_init_context(AVIOContext *s, unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
Definition: aviobuf.c:88
static int mkv_write_tag_targets(MatroskaMuxContext *mkv, AVIOContext **pb, ebml_master *tag, uint32_t elementid, uint64_t uid)
Definition: matroskaenc.c:1479
raw UTF-8 text
Definition: codec_id.h:525
static int mkv_write_flush_packet(AVFormatContext *s, AVPacket *pkt)
Definition: matroskaenc.c:2446
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:937
static ebml_master start_ebml_master(AVIOContext *pb, uint32_t elementid, uint64_t expectedsize)
Definition: matroskaenc.c:337
int64_t last_timestamp
Definition: matroskaenc.c:113
void ff_put_bmp_header(AVIOContext *pb, AVCodecParameters *par, int for_asf, int ignore_extradata, int rgb_frame_is_flipped)
Definition: riffenc.c:215
Stereoscopic video.
Views are packed per column.
Definition: stereo3d.h:141
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1202
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:1236
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:35
char * key
Definition: dict.h:86
int den
Denominator.
Definition: rational.h:60
static int mkv_write_vtt_blocks(AVFormatContext *s, AVIOContext *pb, const AVPacket *pkt)
Definition: matroskaenc.c:2126
#define MATROSKA_ID_SEGMENT
Definition: matroska.h:53
#define MAX_PCE_SIZE
Maximum size of a PCE including the 3-bit ID_PCE.
Definition: mpeg4audio.h:134
static void mkv_write_video_projection(AVFormatContext *s, AVIOContext *pb, const AVStream *st)
Definition: matroskaenc.c:918
The optional settings (rendering instructions) that immediately follow the timestamp specifier of a W...
Definition: packet.h:202
#define MATROSKA_ID_SEEKHEAD
Definition: matroska.h:60
#define EBML_ID_HEADER
Definition: matroska.h:33
uint32_t elementid
Definition: matroskaenc.c:81
A point in the output bytestream where a decoder can start decoding (i.e.
Definition: avio.h:122
A Quick Description Of Rate Distortion Theory We want to encode a video
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:465
#define MATROSKA_ID_TRACKFLAGCOMMENTARY
Definition: matroska.h:104
#define av_free(p)
char * value
Definition: dict.h:87
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
#define MATROSKA_ID_POINTENTRY
Definition: matroska.h:192
int len
static int mkv_write_stereo_mode(AVFormatContext *s, AVIOContext *pb, AVStream *st, int mode, int *h_width, int *h_height)
Definition: matroskaenc.c:1024
#define MATROSKA_ID_FILEUID
Definition: matroska.h:251
int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
Add a bitstream filter to a stream.
Definition: utils.c:5536
static void put_ebml_binary(AVIOContext *pb, uint32_t elementid, const void *buf, int size)
Definition: matroskaenc.c:299
static void mkv_start_seekhead(MatroskaMuxContext *mkv, AVIOContext *pb)
Initialize the SeekHead element to be ready to index level 1 Matroska elements.
Definition: matroskaenc.c:470
void * priv_data
Format private data.
Definition: avformat.h:1271
#define MATROSKA_ID_CHAPTERUID
Definition: matroska.h:266
char str[22]
Definition: matroska.h:358
static int check_bitstream(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:1094
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:346
uint32_t bound_left
Distance from the left edge.
Definition: spherical.h:167
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3501
static const char * get_mimetype(const AVStream *st)
Definition: matroskaenc.c:1710
#define AV_DISPOSITION_COMMENT
Definition: avformat.h:832
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
int64_t relative_pos
relative offset from the position of the cluster containing the block
Definition: matroskaenc.c:96
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
#define MATROSKA_ID_VIDEOCOLORMAXFALL
Definition: matroska.h:146
#define MATROSKA_ID_VIDEODISPLAYUNIT
Definition: matroska.h:124
int channels
Audio only.
Definition: codec_par.h:166
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: packet.h:362
static const AVOption options[]
Definition: matroskaenc.c:2793
#define EBML_ID_EBMLMAXSIZELENGTH
Definition: matroska.h:39
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:387
enum AVMediaType avcodec_get_type(enum AVCodecID codec_id)
Get the type of the given codec.
Definition: codec_desc.c:3526
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1358
#define MATROSKA_ID_CHAPSTRING
Definition: matroska.h:259
int sample_rate
Definition: matroskaenc.c:111
#define av_freep(p)
#define MATROSKA_ID_TAGSTRING
Definition: matroska.h:209
#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:70
#define MODE_MATROSKAv2
Definition: matroskaenc.c:120
uint32_t av_get_random_seed(void)
Get a seed to use in conjunction with random functions.
Definition: random_seed.c:120
static void put_ebml_string(AVIOContext *pb, uint32_t elementid, const char *str)
Definition: matroskaenc.c:307
AVOutputFormat ff_matroska_muxer
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1049
static void put_ebml_sint(AVIOContext *pb, uint32_t elementid, int64_t val)
Definition: matroskaenc.c:278
#define MODE_WEBM
Definition: matroskaenc.c:121
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
#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:169
static void mkv_deinit(AVFormatContext *s)
Free the members allocated in the mux context.
Definition: matroskaenc.c:450
int stream_index
Definition: packet.h:365
int num_entries
Definition: matroskaenc.c:102
#define EBML_ID_DOCTYPEVERSION
Definition: matroska.h:41
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:913
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
static void end_ebml_master(AVIOContext *pb, ebml_master master)
Definition: matroskaenc.c:347
const char *const * mime_types
MIME type(s) associated with the codec.
Definition: codec_desc.h:60
int64_t segment_offset
Definition: matroskaenc.c:129
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1026
#define MATROSKA_ID_ATTACHEDFILE
Definition: matroska.h:246
#define MATROSKA_ID_VIDEOCOLOR_GY
Definition: matroska.h:152
static int mkv_write_block(AVFormatContext *s, AVIOContext *pb, uint32_t blockid, const AVPacket *pkt, int keyframe)
Definition: matroskaenc.c:2014
enum AVCodecID id
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:91
static double val(void *priv, double ch)
Definition: aeval.c:76
unsigned MaxFALL
Max average light level per frame (cd/m^2).
This structure stores compressed data.
Definition: packet.h:340
static void mkv_write_field_order(AVIOContext *pb, int mode, enum AVFieldOrder field_order)
Definition: matroskaenc.c:985
mode
Use these values in ebur128_init (or&#39;ed).
Definition: ebur128.h:83
#define MATROSKA_ID_VIDEOCOLOR_RY
Definition: matroska.h:150
uint32_t blocksize
Definition: wv.h:35
static int mkv_query_codec(enum AVCodecID codec_id, int std_compliance)
Definition: matroskaenc.c:2620
static void put_xiph_size(AVIOContext *pb, int size)
Definition: matroskaenc.c:441
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:356
Not part of ABI.
Definition: pixfmt.h:529
#define MATROSKA_ID_VIDEOPIXELWIDTH
Definition: matroska.h:118
static int mkv_blockgroup_size(int pkt_size, int track_num_size)
Definition: matroskaenc.c:1952
static int mkv_assemble_cues(AVStream **streams, AVIOContext *dyn_cp, mkv_cues *cues, mkv_track *tracks, int num_tracks)
Definition: matroskaenc.c:554
int ff_isom_write_avcc(AVIOContext *pb, const uint8_t *data, int len)
Definition: avc.c:108
#define MATROSKA_ID_TRACKAUDIO
Definition: matroska.h:82
int i
Definition: input.c:407
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
int(* filler)(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:407
const CodecTags ff_mkv_codec_tags[]
Definition: matroska.c:29
int avio_printf(AVIOContext *s, const char *fmt,...) av_printf_format(2
Writes a formatted string to the context.
static int ebml_id_size(uint32_t id)
Definition: matroskaenc.c:177
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
#define MATROSKA_ID_DISCARDPADDING
Definition: matroska.h:243
#define FF_PUT_WAV_HEADER_FORCE_WAVEFORMATEX
Tell ff_put_wav_header() to use WAVEFORMATEX even for PCM codecs.
Definition: riff.h:54
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
const char * name
Definition: opengl_enc.c:102
int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1395
static uint8_t tmp[11]
Definition: aes_ctr.c:27