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 ? 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 {
1194  // look for a codec ID string specific to mkv to use,
1195  // if none are found, use AVI codes
1196  if (par->codec_id != AV_CODEC_ID_RAWVIDEO || par->codec_tag) {
1197  for (j = 0; ff_mkv_codec_tags[j].id != AV_CODEC_ID_NONE; j++) {
1198  if (ff_mkv_codec_tags[j].id == par->codec_id && par->codec_id != AV_CODEC_ID_FFV1) {
1200  native_id = 1;
1201  break;
1202  }
1203  }
1204  } else {
1205  if (mkv->allow_raw_vfw) {
1206  native_id = 0;
1207  } else {
1208  av_log(s, AV_LOG_ERROR, "Raw RGB is not supported Natively in Matroska, you can use AVI or NUT or\n"
1209  "If you would like to store it anyway using VFW mode, enable allow_raw_vfw (-allow_raw_vfw 1)\n");
1210  return AVERROR(EINVAL);
1211  }
1212  }
1213  }
1214 
1215  switch (par->codec_type) {
1216  case AVMEDIA_TYPE_VIDEO:
1217  mkv->have_video = 1;
1219 
1220  if( st->avg_frame_rate.num > 0 && st->avg_frame_rate.den > 0
1221  && av_cmp_q(av_inv_q(st->avg_frame_rate), st->time_base) > 0)
1223  else if( st->r_frame_rate.num > 0 && st->r_frame_rate.den > 0
1224  && av_cmp_q(av_inv_q(st->r_frame_rate), st->time_base) > 0)
1226 
1227  if (!native_id &&
1230  par->codec_id == AV_CODEC_ID_SVQ1 ||
1231  par->codec_id == AV_CODEC_ID_SVQ3 ||
1232  par->codec_id == AV_CODEC_ID_CINEPAK))
1233  qt_id = 1;
1234 
1235  if (qt_id)
1236  put_ebml_string(pb, MATROSKA_ID_CODECID, "V_QUICKTIME");
1237  else if (!native_id) {
1238  // if there is no mkv-specific codec ID, use VFW mode
1239  put_ebml_string(pb, MATROSKA_ID_CODECID, "V_MS/VFW/FOURCC");
1240  track->write_dts = 1;
1242  }
1243 
1244  subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKVIDEO, 0);
1245 
1248 
1249  mkv_write_field_order(pb, mkv->mode, par->field_order);
1250 
1251  // check both side data and metadata for stereo information,
1252  // write the result to the bitstream if any is found
1253  ret = mkv_write_stereo_mode(s, pb, st, mkv->mode,
1254  &display_width_div,
1255  &display_height_div);
1256  if (ret < 0)
1257  return ret;
1258 
1259  if (((tag = av_dict_get(st->metadata, "alpha_mode", NULL, 0)) && atoi(tag->value)) ||
1260  ((tag = av_dict_get( s->metadata, "alpha_mode", NULL, 0)) && atoi(tag->value)) ||
1261  (par->format == AV_PIX_FMT_YUVA420P)) {
1263  }
1264 
1265  // write DisplayWidth and DisplayHeight, they contain the size of
1266  // a single source view and/or the display aspect ratio
1267  if (st->sample_aspect_ratio.num) {
1268  int64_t d_width = av_rescale(par->width, st->sample_aspect_ratio.num, st->sample_aspect_ratio.den);
1269  if (d_width > INT_MAX) {
1270  av_log(s, AV_LOG_ERROR, "Overflow in display width\n");
1271  return AVERROR(EINVAL);
1272  }
1273  if (d_width != par->width || display_width_div != 1 || display_height_div != 1) {
1274  if (mkv->mode == MODE_WEBM || display_width_div != 1 || display_height_div != 1) {
1275  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH , d_width / display_width_div);
1276  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, par->height / display_height_div);
1277  } else {
1278  AVRational display_aspect_ratio;
1279  av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
1280  par->width * (int64_t)st->sample_aspect_ratio.num,
1281  par->height * (int64_t)st->sample_aspect_ratio.den,
1282  1024 * 1024);
1283  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH, display_aspect_ratio.num);
1284  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, display_aspect_ratio.den);
1286  }
1287  }
1288  } else if (display_width_div != 1 || display_height_div != 1) {
1289  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH , par->width / display_width_div);
1290  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, par->height / display_height_div);
1291  } else if (mkv->mode != MODE_WEBM)
1293 
1294  if (par->codec_id == AV_CODEC_ID_RAWVIDEO) {
1295  uint32_t color_space = av_le2ne32(par->codec_tag);
1296  put_ebml_binary(pb, MATROSKA_ID_VIDEOCOLORSPACE, &color_space, sizeof(color_space));
1297  }
1298  mkv_write_video_color(pb, st, par);
1299  mkv_write_video_projection(s, pb, st);
1300 
1301  end_ebml_master(pb, subinfo);
1302  break;
1303 
1304  case AVMEDIA_TYPE_AUDIO:
1305  if (par->initial_padding && par->codec_id == AV_CODEC_ID_OPUS) {
1306  int64_t codecdelay = av_rescale_q(par->initial_padding,
1307  (AVRational){ 1, 48000 },
1308  (AVRational){ 1, 1000000000 });
1309  if (codecdelay < 0) {
1310  av_log(s, AV_LOG_ERROR, "Initial padding is invalid\n");
1311  return AVERROR(EINVAL);
1312  }
1313 // track->ts_offset = av_rescale_q(par->initial_padding,
1314 // (AVRational){ 1, par->sample_rate },
1315 // st->time_base);
1316 
1317  put_ebml_uint(pb, MATROSKA_ID_CODECDELAY, codecdelay);
1318  }
1319  if (par->codec_id == AV_CODEC_ID_OPUS)
1321 
1323 
1324  if (!native_id)
1325  // no mkv-specific ID, use ACM mode
1326  put_ebml_string(pb, MATROSKA_ID_CODECID, "A_MS/ACM");
1327 
1328  subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKAUDIO, 6 + 4 * 9);
1330 
1331  track->sample_rate_offset = avio_tell(pb);
1332  put_ebml_float (pb, MATROSKA_ID_AUDIOSAMPLINGFREQ, sample_rate);
1333  if (output_sample_rate)
1334  put_ebml_float(pb, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate);
1335 
1336  bit_depth = av_get_bits_per_sample(par->codec_id);
1337  if (!bit_depth && par->codec_id != AV_CODEC_ID_ADPCM_G726) {
1338  if (par->bits_per_raw_sample)
1339  bit_depth = par->bits_per_raw_sample;
1340  else
1341  bit_depth = av_get_bytes_per_sample(par->format) << 3;
1342  }
1343  if (!bit_depth)
1344  bit_depth = par->bits_per_coded_sample;
1345  if (bit_depth)
1346  put_ebml_uint(pb, MATROSKA_ID_AUDIOBITDEPTH, bit_depth);
1347  end_ebml_master(pb, subinfo);
1348  break;
1349 
1350  case AVMEDIA_TYPE_SUBTITLE:
1351  if (!native_id) {
1352  av_log(s, AV_LOG_ERROR, "Subtitle codec %d is not supported.\n", par->codec_id);
1353  return AVERROR(ENOSYS);
1354  }
1355 
1356  if (mkv->mode != MODE_WEBM || par->codec_id != AV_CODEC_ID_WEBVTT)
1357  native_id = MATROSKA_TRACK_TYPE_SUBTITLE;
1358 
1359  put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, native_id);
1360  break;
1361  default:
1362  av_log(s, AV_LOG_ERROR, "Only audio, video, and subtitles are supported for Matroska.\n");
1363  return AVERROR(EINVAL);
1364  }
1365 
1366  if (mkv->mode != MODE_WEBM || par->codec_id != AV_CODEC_ID_WEBVTT) {
1367  track->codecpriv_offset = avio_tell(pb);
1368  ret = mkv_write_codecprivate(s, pb, par, native_id, qt_id);
1369  if (ret < 0)
1370  return ret;
1371  }
1372 
1373  end_ebml_master(pb, track_master);
1374 
1375  return 0;
1376 }
1377 
1379 {
1380  MatroskaMuxContext *mkv = s->priv_data;
1381  AVIOContext *pb = s->pb;
1382  int i, ret, video_default_idx, audio_default_idx, subtitle_default_idx;
1383 
1384  if (mkv->nb_attachments == s->nb_streams)
1385  return 0;
1386 
1387  ret = start_ebml_master_crc32(&mkv->track.bc, mkv);
1388  if (ret < 0)
1389  return ret;
1390 
1391  if (mkv->default_mode != DEFAULT_MODE_PASSTHROUGH) {
1392  int video_idx, audio_idx, subtitle_idx;
1393 
1394  video_idx = video_default_idx =
1395  audio_idx = audio_default_idx =
1396  subtitle_idx = subtitle_default_idx = -1;
1397 
1398  for (i = s->nb_streams - 1; i >= 0; i--) {
1399  AVStream *st = s->streams[i];
1400 
1401  switch (st->codecpar->codec_type) {
1402 #define CASE(type, variable) \
1403  case AVMEDIA_TYPE_ ## type: \
1404  variable ## _idx = i; \
1405  if (st->disposition & AV_DISPOSITION_DEFAULT) \
1406  variable ## _default_idx = i; \
1407  break;
1408  CASE(VIDEO, video)
1409  CASE(AUDIO, audio)
1410  CASE(SUBTITLE, subtitle)
1411 #undef CASE
1412  }
1413  }
1414 
1415  video_default_idx = FFMAX(video_default_idx, video_idx);
1416  audio_default_idx = FFMAX(audio_default_idx, audio_idx);
1418  subtitle_default_idx = FFMAX(subtitle_default_idx, subtitle_idx);
1419  }
1420  for (i = 0; i < s->nb_streams; i++) {
1421  AVStream *st = s->streams[i];
1422  int is_default = mkv->default_mode == DEFAULT_MODE_PASSTHROUGH ?
1424  i == video_default_idx || i == audio_default_idx ||
1425  i == subtitle_default_idx;
1426  ret = mkv_write_track(s, mkv, st, &mkv->tracks[i],
1427  mkv->track.bc, is_default);
1428  if (ret < 0)
1429  return ret;
1430  }
1431 
1432  return end_ebml_master_crc32_tentatively(pb, &mkv->track, mkv,
1434 }
1435 
1437 {
1438  uint8_t *key = av_strdup(t->key);
1439  uint8_t *p = key;
1440  const uint8_t *lang = NULL;
1441  ebml_master tag;
1442 
1443  if (!key)
1444  return AVERROR(ENOMEM);
1445 
1446  if ((p = strrchr(p, '-')) &&
1447  (lang = ff_convert_lang_to(p + 1, AV_LANG_ISO639_2_BIBL)))
1448  *p = 0;
1449 
1450  p = key;
1451  while (*p) {
1452  if (*p == ' ')
1453  *p = '_';
1454  else if (*p >= 'a' && *p <= 'z')
1455  *p -= 'a' - 'A';
1456  p++;
1457  }
1458 
1461  if (lang)
1464  end_ebml_master(pb, tag);
1465 
1466  av_freep(&key);
1467  return 0;
1468 }
1469 
1471  ebml_master *tag, uint32_t elementid, uint64_t uid)
1472 {
1474  int ret;
1475 
1476  if (!*pb) {
1477  ret = start_ebml_master_crc32(pb, mkv);
1478  if (ret < 0)
1479  return ret;
1480  }
1481 
1482  *tag = start_ebml_master(*pb, MATROSKA_ID_TAG, 0);
1483  targets = start_ebml_master(*pb, MATROSKA_ID_TAGTARGETS, 4 + 1 + 8);
1484  if (elementid)
1485  put_ebml_uid(*pb, elementid, uid);
1486  end_ebml_master(*pb, targets);
1487  return 0;
1488 }
1489 
1490 static int mkv_check_tag_name(const char *name, uint32_t elementid)
1491 {
1492  return av_strcasecmp(name, "title") &&
1493  av_strcasecmp(name, "stereo_mode") &&
1494  av_strcasecmp(name, "creation_time") &&
1495  av_strcasecmp(name, "encoding_tool") &&
1496  av_strcasecmp(name, "duration") &&
1497  (elementid != MATROSKA_ID_TAGTARGETS_TRACKUID ||
1498  av_strcasecmp(name, "language")) &&
1499  (elementid != MATROSKA_ID_TAGTARGETS_ATTACHUID ||
1500  (av_strcasecmp(name, "filename") &&
1501  av_strcasecmp(name, "mimetype")));
1502 }
1503 
1505  AVIOContext **pb, ebml_master *tag,
1506  uint32_t elementid, uint64_t uid)
1507 {
1508  const AVDictionaryEntry *t = NULL;
1509  ebml_master tag2;
1510  int ret;
1511 
1512  ret = mkv_write_tag_targets(mkv, pb, tag ? tag : &tag2, elementid, uid);
1513  if (ret < 0)
1514  return ret;
1515 
1516  while ((t = av_dict_get(m, "", t, AV_DICT_IGNORE_SUFFIX))) {
1517  if (mkv_check_tag_name(t->key, elementid)) {
1518  ret = mkv_write_simpletag(*pb, t);
1519  if (ret < 0)
1520  return ret;
1521  }
1522  }
1523 
1524  if (!tag)
1525  end_ebml_master(*pb, tag2);
1526 
1527  return 0;
1528 }
1529 
1530 static int mkv_check_tag(const AVDictionary *m, uint32_t elementid)
1531 {
1532  const AVDictionaryEntry *t = NULL;
1533 
1534  while ((t = av_dict_get(m, "", t, AV_DICT_IGNORE_SUFFIX)))
1535  if (mkv_check_tag_name(t->key, elementid))
1536  return 1;
1537 
1538  return 0;
1539 }
1540 
1542 {
1543  MatroskaMuxContext *mkv = s->priv_data;
1544  ebml_master tag, *tagp = IS_SEEKABLE(s->pb, mkv) ? &tag : NULL;
1545  int i, ret;
1546 
1547  mkv->wrote_tags = 1;
1548 
1550 
1551  if (mkv_check_tag(s->metadata, 0)) {
1552  ret = mkv_write_tag(mkv, s->metadata, &mkv->tags.bc, NULL, 0, 0);
1553  if (ret < 0)
1554  return ret;
1555  }
1556 
1557  for (i = 0; i < s->nb_streams; i++) {
1558  const AVStream *st = s->streams[i];
1559  mkv_track *track = &mkv->tracks[i];
1560 
1562  continue;
1563 
1565  continue;
1566 
1567  ret = mkv_write_tag(mkv, st->metadata, &mkv->tags.bc, tagp,
1569  if (ret < 0)
1570  return ret;
1571 
1572  if (tagp) {
1573  AVIOContext *pb = mkv->tags.bc;
1574  ebml_master simpletag;
1575 
1576  simpletag = start_ebml_master(pb, MATROSKA_ID_SIMPLETAG,
1577  2 + 1 + 8 + 23);
1578  put_ebml_string(pb, MATROSKA_ID_TAGNAME, "DURATION");
1579  track->duration_offset = avio_tell(pb);
1580 
1581  // Reserve space to write duration as a 20-byte string.
1582  // 2 (ebml id) + 1 (data size) + 20 (data)
1583  put_ebml_void(pb, 23);
1584  end_ebml_master(pb, simpletag);
1585  end_ebml_master(pb, tag);
1586  }
1587  }
1588 
1589  if (mkv->nb_attachments && mkv->mode != MODE_WEBM) {
1590  for (i = 0; i < s->nb_streams; i++) {
1591  const mkv_track *track = &mkv->tracks[i];
1592  const AVStream *st = s->streams[i];
1593 
1595  continue;
1596 
1598  continue;
1599 
1600  ret = mkv_write_tag(mkv, st->metadata, &mkv->tags.bc, NULL,
1602  if (ret < 0)
1603  return ret;
1604  }
1605  }
1606 
1607  if (mkv->tags.bc) {
1608  return end_ebml_master_crc32_tentatively(s->pb, &mkv->tags, mkv,
1610  }
1611  return 0;
1612 }
1613 
1615 {
1616  MatroskaMuxContext *mkv = s->priv_data;
1617  AVIOContext *dyn_cp = NULL, *dyn_tags = NULL, **tags, *pb = s->pb;
1618  ebml_master editionentry;
1619  uint64_t chapter_id_offset = 0;
1620  AVRational scale = {1, 1E9};
1621  int i, ret;
1622 
1623  if (!s->nb_chapters || mkv->wrote_chapters)
1624  return 0;
1625 
1626  for (i = 0; i < s->nb_chapters; i++)
1627  if (!s->chapters[i]->id) {
1628  chapter_id_offset = 1;
1629  break;
1630  }
1631 
1632  ret = start_ebml_master_crc32(&dyn_cp, mkv);
1633  if (ret < 0)
1634  return ret;
1635 
1636  editionentry = start_ebml_master(dyn_cp, MATROSKA_ID_EDITIONENTRY, 0);
1637  if (mkv->mode != MODE_WEBM) {
1639  /* If mkv_write_tags() has already been called, then any tags
1640  * corresponding to chapters will be put into a new Tags element. */
1641  tags = mkv->wrote_tags ? &dyn_tags : &mkv->tags.bc;
1642  } else
1643  tags = NULL;
1644 
1645  for (i = 0; i < s->nb_chapters; i++) {
1646  ebml_master chapteratom, chapterdisplay;
1647  const AVChapter *c = s->chapters[i];
1648  int64_t chapterstart = av_rescale_q(c->start, c->time_base, scale);
1649  int64_t chapterend = av_rescale_q(c->end, c->time_base, scale);
1650  const AVDictionaryEntry *t;
1651  if (chapterstart < 0 || chapterstart > chapterend || chapterend < 0) {
1652  av_log(s, AV_LOG_ERROR,
1653  "Invalid chapter start (%"PRId64") or end (%"PRId64").\n",
1654  chapterstart, chapterend);
1655  ret = AVERROR_INVALIDDATA;
1656  goto fail;
1657  }
1658 
1659  chapteratom = start_ebml_master(dyn_cp, MATROSKA_ID_CHAPTERATOM, 0);
1661  (uint32_t)c->id + chapter_id_offset);
1662  put_ebml_uint(dyn_cp, MATROSKA_ID_CHAPTERTIMESTART, chapterstart);
1663  put_ebml_uint(dyn_cp, MATROSKA_ID_CHAPTERTIMEEND, chapterend);
1664  if ((t = av_dict_get(c->metadata, "title", NULL, 0))) {
1665  chapterdisplay = start_ebml_master(dyn_cp, MATROSKA_ID_CHAPTERDISPLAY, 0);
1667  put_ebml_string(dyn_cp, MATROSKA_ID_CHAPLANG , "und");
1668  end_ebml_master(dyn_cp, chapterdisplay);
1669  }
1670  end_ebml_master(dyn_cp, chapteratom);
1671 
1673  ret = mkv_write_tag(mkv, c->metadata, tags, NULL,
1675  (uint32_t)c->id + chapter_id_offset);
1676  if (ret < 0)
1677  goto fail;
1678  }
1679  }
1680  end_ebml_master(dyn_cp, editionentry);
1681  mkv->wrote_chapters = 1;
1682 
1683  ret = end_ebml_master_crc32(pb, &dyn_cp, mkv, MATROSKA_ID_CHAPTERS, 0, 0, 1);
1684  if (ret < 0)
1685  goto fail;
1686  if (dyn_tags)
1687  return end_ebml_master_crc32(pb, &dyn_tags, mkv,
1688  MATROSKA_ID_TAGS, 0, 0, 1);
1689  return 0;
1690 
1691 fail:
1692  if (tags) {
1693  /* tags == &mkv->tags.bc can only happen if mkv->tags.bc was
1694  * initially NULL, so we never free older tags. */
1695  ffio_free_dyn_buf(tags);
1696  }
1697  ffio_free_dyn_buf(&dyn_cp);
1698  return ret;
1699 }
1700 
1701 static const char *get_mimetype(const AVStream *st)
1702 {
1703  const AVDictionaryEntry *t;
1704 
1705  if (t = av_dict_get(st->metadata, "mimetype", NULL, 0))
1706  return t->value;
1707  if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
1709  if (desc && desc->mime_types) {
1710  return desc->mime_types[0];
1711  } else if (st->codecpar->codec_id == AV_CODEC_ID_TEXT)
1712  return "text/plain";
1713  }
1714 
1715  return NULL;
1716 }
1717 
1719 {
1720  MatroskaMuxContext *mkv = s->priv_data;
1721  AVIOContext *dyn_cp = NULL, *pb = s->pb;
1722  int i, ret;
1723 
1724  if (!mkv->nb_attachments)
1725  return 0;
1726 
1727  ret = start_ebml_master_crc32(&dyn_cp, mkv);
1728  if (ret < 0)
1729  return ret;
1730 
1731  for (i = 0; i < s->nb_streams; i++) {
1732  const AVStream *st = s->streams[i];
1733  mkv_track *track = &mkv->tracks[i];
1734  ebml_master attached_file;
1735  const AVDictionaryEntry *t;
1736  const char *mimetype;
1737 
1739  continue;
1740 
1741  attached_file = start_ebml_master(dyn_cp, MATROSKA_ID_ATTACHEDFILE, 0);
1742 
1743  if (t = av_dict_get(st->metadata, "title", NULL, 0))
1745  if (!(t = av_dict_get(st->metadata, "filename", NULL, 0))) {
1746  av_log(s, AV_LOG_ERROR, "Attachment stream %d has no filename tag.\n", i);
1747  return AVERROR(EINVAL);
1748  }
1750 
1751  mimetype = get_mimetype(st);
1752  av_assert0(mimetype);
1753  put_ebml_string(dyn_cp, MATROSKA_ID_FILEMIMETYPE, mimetype);
1755  put_ebml_uid(dyn_cp, MATROSKA_ID_FILEUID, track->uid);
1756  end_ebml_master(dyn_cp, attached_file);
1757  }
1758  return end_ebml_master_crc32(pb, &dyn_cp, mkv,
1759  MATROSKA_ID_ATTACHMENTS, 0, 0, 1);
1760 }
1761 
1763 {
1764  const AVDictionaryEntry *duration = av_dict_get(s->metadata, "DURATION",
1765  NULL, 0);
1766  int64_t max = 0;
1767  int64_t us;
1768 
1769  if (duration && (av_parse_time(&us, duration->value, 1) == 0) && us > 0) {
1770  av_log(s, AV_LOG_DEBUG, "get_metadata_duration found duration in context metadata: %" PRId64 "\n", us);
1771  return us;
1772  }
1773 
1774  for (unsigned i = 0; i < s->nb_streams; i++) {
1775  int64_t us;
1776  duration = av_dict_get(s->streams[i]->metadata, "DURATION", NULL, 0);
1777 
1778  if (duration && (av_parse_time(&us, duration->value, 1) == 0))
1779  max = FFMAX(max, us);
1780  }
1781 
1782  av_log(s, AV_LOG_DEBUG, "get_metadata_duration returned: %" PRId64 "\n", max);
1783  return max;
1784 }
1785 
1787 {
1788  MatroskaMuxContext *mkv = s->priv_data;
1789  AVIOContext *pb = s->pb;
1791  const AVDictionaryEntry *tag;
1792  int ret, i, version = 2;
1793  int64_t creation_time;
1794 
1795  if (mkv->mode != MODE_WEBM ||
1796  av_dict_get(s->metadata, "stereo_mode", NULL, 0) ||
1797  av_dict_get(s->metadata, "alpha_mode", NULL, 0))
1798  version = 4;
1799 
1800  for (i = 0; i < s->nb_streams; i++) {
1801  if (s->streams[i]->codecpar->codec_id == AV_CODEC_ID_OPUS ||
1802  av_dict_get(s->streams[i]->metadata, "stereo_mode", NULL, 0) ||
1803  av_dict_get(s->streams[i]->metadata, "alpha_mode", NULL, 0))
1804  version = 4;
1805  }
1806 
1813  put_ebml_uint (pb, EBML_ID_DOCTYPEVERSION , version);
1815  end_ebml_master(pb, ebml_header);
1816 
1818  put_ebml_size_unknown(pb, 8);
1819  mkv->segment_offset = avio_tell(pb);
1820 
1821  // We write a SeekHead at the beginning to point to all other level
1822  // one elements (except Clusters).
1823  mkv_start_seekhead(mkv, pb);
1824 
1825  ret = start_ebml_master_crc32(&mkv->info.bc, mkv);
1826  if (ret < 0)
1827  return ret;
1828  pb = mkv->info.bc;
1829 
1831  if ((tag = av_dict_get(s->metadata, "title", NULL, 0)))
1833  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
1835  if ((tag = av_dict_get(s->metadata, "encoding_tool", NULL, 0)))
1837  else
1839 
1840  if (mkv->mode != MODE_WEBM)
1842  } else {
1843  const char *ident = "Lavf";
1846  }
1847 
1848  if (ff_parse_creation_time_metadata(s, &creation_time, 0) > 0) {
1849  // Adjust time so it's relative to 2001-01-01 and convert to nanoseconds.
1850  int64_t date_utc = (creation_time - 978307200000000LL) * 1000;
1851  uint8_t date_utc_buf[8];
1852  AV_WB64(date_utc_buf, date_utc);
1853  put_ebml_binary(pb, MATROSKA_ID_DATEUTC, date_utc_buf, 8);
1854  }
1855 
1856  // reserve space for the duration
1857  mkv->duration = 0;
1858  mkv->duration_offset = avio_tell(pb);
1859  if (!mkv->is_live) {
1860  int64_t metadata_duration = get_metadata_duration(s);
1861 
1862  if (s->duration > 0) {
1863  int64_t scaledDuration = av_rescale(s->duration, 1000, AV_TIME_BASE);
1864  put_ebml_float(pb, MATROSKA_ID_DURATION, scaledDuration);
1865  av_log(s, AV_LOG_DEBUG, "Write early duration from recording time = %" PRIu64 "\n", scaledDuration);
1866  } else if (metadata_duration > 0) {
1867  int64_t scaledDuration = av_rescale(metadata_duration, 1000, AV_TIME_BASE);
1868  put_ebml_float(pb, MATROSKA_ID_DURATION, scaledDuration);
1869  av_log(s, AV_LOG_DEBUG, "Write early duration from metadata = %" PRIu64 "\n", scaledDuration);
1870  } else if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
1871  put_ebml_void(pb, 11); // assumes double-precision float to be written
1872  }
1873  }
1874  ret = end_ebml_master_crc32_tentatively(s->pb, &mkv->info,
1875  mkv, MATROSKA_ID_INFO);
1876  if (ret < 0)
1877  return ret;
1878  pb = s->pb;
1879 
1880  ret = mkv_write_tracks(s);
1881  if (ret < 0)
1882  return ret;
1883 
1884  ret = mkv_write_chapters(s);
1885  if (ret < 0)
1886  return ret;
1887 
1888  if (mkv->mode != MODE_WEBM) {
1889  ret = mkv_write_attachments(s);
1890  if (ret < 0)
1891  return ret;
1892  }
1893 
1894  /* Must come after mkv_write_chapters() to write chapter tags
1895  * into the same Tags element as the other tags. */
1896  ret = mkv_write_tags(s);
1897  if (ret < 0)
1898  return ret;
1899 
1900  if (!IS_SEEKABLE(pb, mkv)) {
1901  ret = mkv_write_seekhead(pb, mkv, 0, avio_tell(pb));
1902  if (ret < 0)
1903  return ret;
1904  }
1905 
1906  if (s->metadata_header_padding > 0) {
1907  if (s->metadata_header_padding == 1)
1910  }
1911 
1912  if (mkv->reserve_cues_space) {
1913  if (IS_SEEKABLE(pb, mkv)) {
1914  mkv->cues_pos = avio_tell(pb);
1915  if (mkv->reserve_cues_space == 1)
1916  mkv->reserve_cues_space++;
1918  } else
1919  mkv->reserve_cues_space = -1;
1920  }
1921 
1923  mkv->cur_audio_pkt.size = 0;
1924  mkv->cluster_pos = -1;
1925 
1926  // start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or
1927  // after 4k and on a keyframe
1928  if (IS_SEEKABLE(pb, mkv)) {
1929  if (mkv->cluster_time_limit < 0)
1930  mkv->cluster_time_limit = 5000;
1931  if (mkv->cluster_size_limit < 0)
1932  mkv->cluster_size_limit = 5 * 1024 * 1024;
1933  } else {
1934  if (mkv->cluster_time_limit < 0)
1935  mkv->cluster_time_limit = 1000;
1936  if (mkv->cluster_size_limit < 0)
1937  mkv->cluster_size_limit = 32 * 1024;
1938  }
1939 
1940  return 0;
1941 }
1942 
1943 static int mkv_blockgroup_size(int pkt_size, int track_num_size)
1944 {
1945  int size = pkt_size + track_num_size + 3;
1946  size += ebml_length_size(size);
1947  size += 2; // EBML ID for block and block duration
1948  size += 9; // max size of block duration incl. length field
1949  return size;
1950 }
1951 
1952 static int mkv_strip_wavpack(const uint8_t *src, uint8_t **pdst, int *size)
1953 {
1954  uint8_t *dst;
1955  int srclen = *size;
1956  int offset = 0;
1957  int ret;
1958 
1959  dst = av_malloc(srclen);
1960  if (!dst)
1961  return AVERROR(ENOMEM);
1962 
1963  while (srclen >= WV_HEADER_SIZE) {
1964  WvHeader header;
1965 
1966  ret = ff_wv_parse_header(&header, src);
1967  if (ret < 0)
1968  goto fail;
1969  src += WV_HEADER_SIZE;
1970  srclen -= WV_HEADER_SIZE;
1971 
1972  if (srclen < header.blocksize) {
1973  ret = AVERROR_INVALIDDATA;
1974  goto fail;
1975  }
1976 
1977  if (header.initial) {
1978  AV_WL32(dst + offset, header.samples);
1979  offset += 4;
1980  }
1981  AV_WL32(dst + offset, header.flags);
1982  AV_WL32(dst + offset + 4, header.crc);
1983  offset += 8;
1984 
1985  if (!(header.initial && header.final)) {
1986  AV_WL32(dst + offset, header.blocksize);
1987  offset += 4;
1988  }
1989 
1990  memcpy(dst + offset, src, header.blocksize);
1991  src += header.blocksize;
1992  srclen -= header.blocksize;
1993  offset += header.blocksize;
1994  }
1995 
1996  *pdst = dst;
1997  *size = offset;
1998 
1999  return 0;
2000 fail:
2001  av_freep(&dst);
2002  return ret;
2003 }
2004 
2006  uint32_t blockid, const AVPacket *pkt, int keyframe)
2007 {
2008  MatroskaMuxContext *mkv = s->priv_data;
2010  mkv_track *track = &mkv->tracks[pkt->stream_index];
2011  uint8_t *data = NULL, *side_data = NULL;
2012  int err = 0, offset = 0, size = pkt->size, side_data_size;
2013  int64_t ts = track->write_dts ? pkt->dts : pkt->pts;
2014  uint64_t additional_id;
2015  int64_t discard_padding = 0;
2016  unsigned track_number = track->track_num;
2017  ebml_master block_group, block_additions, block_more;
2018 
2019  ts += track->ts_offset;
2020 
2021  /* The following string is identical to the one in mkv_write_vtt_blocks
2022  * so that only one copy needs to exist in binaries. */
2023  av_log(s, AV_LOG_DEBUG,
2024  "Writing block of size %d with pts %" PRId64 ", dts %" PRId64 ", "
2025  "duration %" PRId64 " at relative offset %" PRId64 " in cluster "
2026  "at offset %" PRId64 ". TrackNumber %u, keyframe %d\n",
2027  pkt->size, pkt->pts, pkt->dts, pkt->duration, avio_tell(pb),
2028  mkv->cluster_pos, track_number, keyframe != 0);
2029 
2030  if (par->codec_id == AV_CODEC_ID_H264 && par->extradata_size > 0 &&
2031  (AV_RB24(par->extradata) == 1 || AV_RB32(par->extradata) == 1)) {
2032  err = ff_avc_parse_nal_units_buf(pkt->data, &data, &size);
2033  } else if (par->codec_id == AV_CODEC_ID_HEVC && par->extradata_size > 6 &&
2034  (AV_RB24(par->extradata) == 1 || AV_RB32(par->extradata) == 1)) {
2035  /* extradata is Annex B, assume the bitstream is too and convert it */
2036  err = ff_hevc_annexb2mp4_buf(pkt->data, &data, &size, 0, NULL);
2037  } else if (par->codec_id == AV_CODEC_ID_AV1) {
2038  err = ff_av1_filter_obus_buf(pkt->data, &data, &size, &offset);
2039  } else if (par->codec_id == AV_CODEC_ID_WAVPACK) {
2040  err = mkv_strip_wavpack(pkt->data, &data, &size);
2041  } else
2042  data = pkt->data;
2043 
2044  if (err < 0) {
2045  av_log(s, AV_LOG_ERROR, "Error when reformatting data of "
2046  "a packet from stream %d.\n", pkt->stream_index);
2047  return err;
2048  }
2049 
2050  if (par->codec_id == AV_CODEC_ID_PRORES && size >= 8) {
2051  /* Matroska specification requires to remove the first QuickTime atom
2052  */
2053  size -= 8;
2054  offset = 8;
2055  }
2056 
2057  side_data = av_packet_get_side_data(pkt,
2059  &side_data_size);
2060  if (side_data && side_data_size >= 10) {
2061  discard_padding = av_rescale_q(AV_RL32(side_data + 4),
2062  (AVRational){1, par->sample_rate},
2063  (AVRational){1, 1000000000});
2064  }
2065 
2066  side_data = av_packet_get_side_data(pkt,
2068  &side_data_size);
2069  if (side_data) {
2070  // Only the Codec-specific BlockMore (id == 1) is currently supported.
2071  if (side_data_size < 8 || (additional_id = AV_RB64(side_data)) != 1) {
2072  side_data_size = 0;
2073  } else {
2074  side_data += 8;
2075  side_data_size -= 8;
2076  }
2077  }
2078 
2079  if (side_data_size || discard_padding) {
2080  block_group = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, 0);
2081  blockid = MATROSKA_ID_BLOCK;
2082  }
2083 
2084  put_ebml_id(pb, blockid);
2085  put_ebml_length(pb, size + track->track_num_size + 3, 0);
2086  put_ebml_num(pb, track_number, track->track_num_size);
2087  avio_wb16(pb, ts - mkv->cluster_pts);
2088  avio_w8(pb, (blockid == MATROSKA_ID_SIMPLEBLOCK && keyframe) ? (1 << 7) : 0);
2089  avio_write(pb, data + offset, size);
2090  if (data != pkt->data)
2091  av_free(data);
2092 
2093  if (blockid == MATROSKA_ID_BLOCK && !keyframe)
2095  track->last_timestamp = ts;
2096 
2097  if (discard_padding)
2098  put_ebml_sint(pb, MATROSKA_ID_DISCARDPADDING, discard_padding);
2099 
2100  if (side_data_size) {
2101  block_additions = start_ebml_master(pb, MATROSKA_ID_BLOCKADDITIONS, 0);
2102  block_more = start_ebml_master(pb, MATROSKA_ID_BLOCKMORE, 0);
2103  /* Until dbc50f8a our demuxer used a wrong default value
2104  * of BlockAddID, so we write it unconditionally. */
2105  put_ebml_uint (pb, MATROSKA_ID_BLOCKADDID, additional_id);
2107  side_data, side_data_size);
2108  end_ebml_master(pb, block_more);
2109  end_ebml_master(pb, block_additions);
2110  }
2111  if (side_data_size || discard_padding)
2112  end_ebml_master(pb, block_group);
2113 
2114  return 0;
2115 }
2116 
2118 {
2119  MatroskaMuxContext *mkv = s->priv_data;
2120  mkv_track *track = &mkv->tracks[pkt->stream_index];
2121  ebml_master blockgroup;
2122  int id_size, settings_size, size;
2123  const char *id, *settings;
2124  int64_t ts = track->write_dts ? pkt->dts : pkt->pts;
2125  const int flags = 0;
2126 
2128  &id_size);
2129  id = id ? id : "";
2130 
2132  &settings_size);
2133  settings = settings ? settings : "";
2134 
2135  size = id_size + 1 + settings_size + 1 + pkt->size;
2136 
2137  /* The following string is identical to the one in mkv_write_block so that
2138  * only one copy needs to exist in binaries. */
2139  av_log(s, AV_LOG_DEBUG,
2140  "Writing block of size %d with pts %" PRId64 ", dts %" PRId64 ", "
2141  "duration %" PRId64 " at relative offset %" PRId64 " in cluster "
2142  "at offset %" PRId64 ". TrackNumber %u, keyframe %d\n",
2143  size, pkt->pts, pkt->dts, pkt->duration, avio_tell(pb),
2144  mkv->cluster_pos, track->track_num, 1);
2145 
2146  blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP,
2147  mkv_blockgroup_size(size, track->track_num_size));
2148 
2150  put_ebml_length(pb, size + track->track_num_size + 3, 0);
2151  put_ebml_num(pb, track->track_num, track->track_num_size);
2152  avio_wb16(pb, ts - mkv->cluster_pts);
2153  avio_w8(pb, flags);
2154  avio_printf(pb, "%.*s\n%.*s\n%.*s", id_size, id, settings_size, settings, pkt->size, pkt->data);
2155 
2157  end_ebml_master(pb, blockgroup);
2158 
2159  return pkt->duration;
2160 }
2161 
2163 {
2164  MatroskaMuxContext *mkv = s->priv_data;
2165  int ret;
2166 
2167  if (!mkv->have_video) {
2168  for (unsigned i = 0; i < s->nb_streams; i++)
2169  mkv->tracks[i].has_cue = 0;
2170  }
2171  mkv->cluster_pos = -1;
2172  ret = end_ebml_master_crc32(s->pb, &mkv->cluster_bc, mkv,
2173  MATROSKA_ID_CLUSTER, 0, 1, 0);
2174  if (ret < 0)
2175  return ret;
2176 
2178  return 0;
2179 }
2180 
2182 {
2183  MatroskaMuxContext *mkv = s->priv_data;
2184  mkv_track *track = &mkv->tracks[pkt->stream_index];
2186  uint8_t *side_data;
2187  int side_data_size, ret;
2188 
2190  &side_data_size);
2191 
2192  switch (par->codec_id) {
2193  case AV_CODEC_ID_AAC:
2194  if (side_data_size && mkv->track.bc) {
2195  int filler, output_sample_rate = 0;
2196  ret = get_aac_sample_rates(s, mkv, side_data, side_data_size,
2197  &track->sample_rate, &output_sample_rate);
2198  if (ret < 0)
2199  return ret;
2200  if (!output_sample_rate)
2201  output_sample_rate = track->sample_rate; // Space is already reserved, so it's this or a void element.
2202  ret = ff_alloc_extradata(par, side_data_size);
2203  if (ret < 0)
2204  return ret;
2205  memcpy(par->extradata, side_data, side_data_size);
2206  avio_seek(mkv->track.bc, track->codecpriv_offset, SEEK_SET);
2207  mkv_write_codecprivate(s, mkv->track.bc, par, 1, 0);
2208  filler = MAX_PCE_SIZE + 2 + 4 - (avio_tell(mkv->track.bc) - track->codecpriv_offset);
2209  if (filler)
2210  put_ebml_void(mkv->track.bc, filler);
2211  avio_seek(mkv->track.bc, track->sample_rate_offset, SEEK_SET);
2213  put_ebml_float(mkv->track.bc, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate);
2214  } else if (!par->extradata_size && !track->sample_rate) {
2215  // No extradata (codecpar or packet side data).
2216  av_log(s, AV_LOG_ERROR, "Error parsing AAC extradata, unable to determine samplerate.\n");
2217  return AVERROR(EINVAL);
2218  }
2219  break;
2220  case AV_CODEC_ID_FLAC:
2221  if (side_data_size && mkv->track.bc) {
2222  uint8_t *old_extradata = par->extradata;
2223  if (side_data_size != par->extradata_size) {
2224  av_log(s, AV_LOG_ERROR, "Invalid FLAC STREAMINFO metadata for output stream %d\n",
2225  pkt->stream_index);
2226  return AVERROR(EINVAL);
2227  }
2228  par->extradata = side_data;
2229  avio_seek(mkv->track.bc, track->codecpriv_offset, SEEK_SET);
2230  mkv_write_codecprivate(s, mkv->track.bc, par, 1, 0);
2231  par->extradata = old_extradata;
2232  }
2233  break;
2234  // FIXME: Remove the following once libaom starts propagating extradata during init()
2235  // See https://bugs.chromium.org/p/aomedia/issues/detail?id=2012
2236  case AV_CODEC_ID_AV1:
2237  if (side_data_size && mkv->track.bc && !par->extradata_size) {
2238  AVIOContext *dyn_cp;
2239  uint8_t *codecpriv;
2240  int codecpriv_size;
2241  ret = avio_open_dyn_buf(&dyn_cp);
2242  if (ret < 0)
2243  return ret;
2244  ff_isom_write_av1c(dyn_cp, side_data, side_data_size);
2245  codecpriv_size = avio_get_dyn_buf(dyn_cp, &codecpriv);
2246  if ((ret = dyn_cp->error) < 0 ||
2247  !codecpriv_size && (ret = AVERROR_INVALIDDATA)) {
2248  ffio_free_dyn_buf(&dyn_cp);
2249  return ret;
2250  }
2251  avio_seek(mkv->track.bc, track->codecpriv_offset, SEEK_SET);
2252  // Do not write the OBUs as we don't have space saved for them
2253  put_ebml_binary(mkv->track.bc, MATROSKA_ID_CODECPRIVATE, codecpriv, 4);
2254  ffio_free_dyn_buf(&dyn_cp);
2255  ret = ff_alloc_extradata(par, side_data_size);
2256  if (ret < 0)
2257  return ret;
2258  memcpy(par->extradata, side_data, side_data_size);
2259  } else if (!par->extradata_size)
2260  return AVERROR_INVALIDDATA;
2261  break;
2262  default:
2263  if (side_data_size)
2264  av_log(s, AV_LOG_DEBUG, "Ignoring new extradata in a packet for stream %d.\n", pkt->stream_index);
2265  break;
2266  }
2267 
2268  return 0;
2269 }
2270 
2272 {
2273  MatroskaMuxContext *mkv = s->priv_data;
2274  AVIOContext *pb;
2276  mkv_track *track = &mkv->tracks[pkt->stream_index];
2277  int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
2278  int duration = pkt->duration;
2279  int ret;
2280  int64_t ts = track->write_dts ? pkt->dts : pkt->pts;
2281  int64_t relative_packet_pos;
2282 
2283  if (ts == AV_NOPTS_VALUE) {
2284  av_log(s, AV_LOG_ERROR, "Can't write packet with unknown timestamp\n");
2285  return AVERROR(EINVAL);
2286  }
2287  ts += track->ts_offset;
2288 
2289  if (mkv->cluster_pos != -1) {
2290  int64_t cluster_time = ts - mkv->cluster_pts;
2291  if ((int16_t)cluster_time != cluster_time) {
2292  ret = mkv_end_cluster(s);
2293  if (ret < 0)
2294  return ret;
2295  av_log(s, AV_LOG_WARNING, "Starting new cluster due to timestamp\n");
2296  }
2297  }
2298 
2299  if (mkv->cluster_pos == -1) {
2300  ret = start_ebml_master_crc32(&mkv->cluster_bc, mkv);
2301  if (ret < 0)
2302  return ret;
2303  mkv->cluster_pos = avio_tell(s->pb);
2305  mkv->cluster_pts = FFMAX(0, ts);
2306  av_log(s, AV_LOG_DEBUG,
2307  "Starting new cluster with timestamp "
2308  "%" PRId64 " at offset %" PRId64 " bytes\n",
2309  mkv->cluster_pts, mkv->cluster_pos);
2310  }
2311  pb = mkv->cluster_bc;
2312 
2313  relative_packet_pos = avio_tell(pb);
2314 
2315  if (par->codec_type != AVMEDIA_TYPE_SUBTITLE) {
2316  ret = mkv_write_block(s, pb, MATROSKA_ID_SIMPLEBLOCK, pkt, keyframe);
2317  if (ret < 0)
2318  return ret;
2319  if (keyframe && IS_SEEKABLE(s->pb, mkv) &&
2320  (par->codec_type == AVMEDIA_TYPE_VIDEO || !mkv->have_video && !track->has_cue)) {
2321  ret = mkv_add_cuepoint(mkv, pkt->stream_index, ts,
2322  mkv->cluster_pos, relative_packet_pos, -1);
2323  if (ret < 0)
2324  return ret;
2325  track->has_cue = 1;
2326  }
2327  } else {
2328  if (par->codec_id == AV_CODEC_ID_WEBVTT) {
2329  duration = mkv_write_vtt_blocks(s, pb, pkt);
2330  } else {
2333  track->track_num_size));
2334 
2335 #if FF_API_CONVERGENCE_DURATION
2337  /* For backward compatibility, prefer convergence_duration. */
2338  if (pkt->convergence_duration > 0) {
2339  duration = pkt->convergence_duration;
2340  }
2342 #endif
2343  /* All subtitle blocks are considered to be keyframes. */
2344  mkv_write_block(s, pb, MATROSKA_ID_BLOCK, pkt, 1);
2346  end_ebml_master(pb, blockgroup);
2347  }
2348 
2349  if (IS_SEEKABLE(s->pb, mkv)) {
2350  ret = mkv_add_cuepoint(mkv, pkt->stream_index, ts,
2351  mkv->cluster_pos, relative_packet_pos, duration);
2352  if (ret < 0)
2353  return ret;
2354  }
2355  }
2356 
2357  mkv->duration = FFMAX(mkv->duration, ts + duration);
2358  track->duration = FFMAX(track->duration, ts + duration);
2359 
2360  return 0;
2361 }
2362 
2364 {
2365  MatroskaMuxContext *mkv = s->priv_data;
2367  int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
2368  int cluster_size;
2369  int64_t cluster_time;
2370  int ret;
2371  int start_new_cluster;
2372 
2373  ret = mkv_check_new_extra_data(s, pkt);
2374  if (ret < 0)
2375  return ret;
2376 
2377  if (mkv->cluster_pos != -1) {
2378  if (mkv->tracks[pkt->stream_index].write_dts)
2379  cluster_time = pkt->dts - mkv->cluster_pts;
2380  else
2381  cluster_time = pkt->pts - mkv->cluster_pts;
2382  cluster_time += mkv->tracks[pkt->stream_index].ts_offset;
2383 
2384  cluster_size = avio_tell(mkv->cluster_bc);
2385 
2386  if (mkv->is_dash && codec_type == AVMEDIA_TYPE_VIDEO) {
2387  // WebM DASH specification states that the first block of
2388  // every Cluster has to be a key frame. So for DASH video,
2389  // we only create a Cluster on seeing key frames.
2390  start_new_cluster = keyframe;
2391  } else if (mkv->is_dash && codec_type == AVMEDIA_TYPE_AUDIO &&
2392  cluster_time > mkv->cluster_time_limit) {
2393  // For DASH audio, we create a Cluster based on cluster_time_limit.
2394  start_new_cluster = 1;
2395  } else if (!mkv->is_dash &&
2396  (cluster_size > mkv->cluster_size_limit ||
2397  cluster_time > mkv->cluster_time_limit ||
2398  (codec_type == AVMEDIA_TYPE_VIDEO && keyframe &&
2399  cluster_size > 4 * 1024))) {
2400  start_new_cluster = 1;
2401  } else
2402  start_new_cluster = 0;
2403 
2404  if (start_new_cluster) {
2405  ret = mkv_end_cluster(s);
2406  if (ret < 0)
2407  return ret;
2408  }
2409  }
2410 
2411  if (!mkv->cluster_pos)
2412  avio_write_marker(s->pb,
2415 
2416  // check if we have an audio packet cached
2417  if (mkv->cur_audio_pkt.size > 0) {
2418  ret = mkv_write_packet_internal(s, &mkv->cur_audio_pkt);
2420  if (ret < 0) {
2421  av_log(s, AV_LOG_ERROR,
2422  "Could not write cached audio packet ret:%d\n", ret);
2423  return ret;
2424  }
2425  }
2426 
2427  // buffer an audio packet to ensure the packet containing the video
2428  // keyframe's timecode is contained in the same cluster for WebM
2429  if (codec_type == AVMEDIA_TYPE_AUDIO) {
2430  if (pkt->size > 0)
2431  ret = av_packet_ref(&mkv->cur_audio_pkt, pkt);
2432  } else
2433  ret = mkv_write_packet_internal(s, pkt);
2434  return ret;
2435 }
2436 
2438 {
2439  MatroskaMuxContext *mkv = s->priv_data;
2440 
2441  if (!pkt) {
2442  if (mkv->cluster_pos != -1) {
2443  int ret = mkv_end_cluster(s);
2444  if (ret < 0)
2445  return ret;
2446  av_log(s, AV_LOG_DEBUG,
2447  "Flushing cluster at offset %" PRIu64 " bytes\n",
2448  avio_tell(s->pb));
2449  }
2450  return 1;
2451  }
2452  return mkv_write_packet(s, pkt);
2453 }
2454 
2456 {
2457  MatroskaMuxContext *mkv = s->priv_data;
2458  AVIOContext *pb = s->pb;
2459  int64_t endpos, ret64;
2460  int ret, ret2 = 0;
2461 
2462  // check if we have an audio packet cached
2463  if (mkv->cur_audio_pkt.size > 0) {
2464  ret = mkv_write_packet_internal(s, &mkv->cur_audio_pkt);
2465  if (ret < 0) {
2466  av_log(s, AV_LOG_ERROR,
2467  "Could not write cached audio packet ret:%d\n", ret);
2468  return ret;
2469  }
2470  }
2471 
2472  if (mkv->cluster_pos != -1) {
2473  ret = end_ebml_master_crc32(pb, &mkv->cluster_bc, mkv,
2474  MATROSKA_ID_CLUSTER, 0, 0, 0);
2475  if (ret < 0)
2476  return ret;
2477  }
2478 
2479  ret = mkv_write_chapters(s);
2480  if (ret < 0)
2481  return ret;
2482 
2483  if (!IS_SEEKABLE(pb, mkv))
2484  return 0;
2485 
2486  endpos = avio_tell(pb);
2487 
2488  if (mkv->cues.num_entries && mkv->reserve_cues_space >= 0) {
2489  AVIOContext *cues = NULL;
2490  uint64_t size;
2491  int length_size = 0;
2492 
2493  ret = start_ebml_master_crc32(&cues, mkv);
2494  if (ret < 0)
2495  return ret;
2496 
2497  ret = mkv_assemble_cues(s->streams, cues, &mkv->cues,
2498  mkv->tracks, s->nb_streams);
2499  if (ret < 0) {
2500  ffio_free_dyn_buf(&cues);
2501  return ret;
2502  }
2503 
2504  if (mkv->reserve_cues_space) {
2505  size = avio_tell(cues);
2506  length_size = ebml_length_size(size);
2507  size += 4 + length_size;
2508  if (mkv->reserve_cues_space < size) {
2510  "Insufficient space reserved for Cues: "
2511  "%d < %"PRIu64". No Cues will be output.\n",
2512  mkv->reserve_cues_space, size);
2513  ret2 = AVERROR(EINVAL);
2514  goto after_cues;
2515  } else {
2516  if ((ret64 = avio_seek(pb, mkv->cues_pos, SEEK_SET)) < 0) {
2517  ffio_free_dyn_buf(&cues);
2518  return ret64;
2519  }
2520  if (mkv->reserve_cues_space == size + 1) {
2521  /* There is no way to reserve a single byte because
2522  * the minimal size of an EBML Void element is 2
2523  * (1 byte ID, 1 byte length field). This problem
2524  * is solved by writing the Cues' length field on
2525  * one byte more than necessary. */
2526  length_size++;
2527  size++;
2528  }
2529  }
2530  }
2531  ret = end_ebml_master_crc32(pb, &cues, mkv, MATROSKA_ID_CUES,
2532  length_size, 0, 1);
2533  if (ret < 0)
2534  return ret;
2535  if (mkv->reserve_cues_space) {
2536  if (size < mkv->reserve_cues_space)
2537  put_ebml_void(pb, mkv->reserve_cues_space - size);
2538  } else
2539  endpos = avio_tell(pb);
2540  }
2541 
2542 after_cues:
2543  /* Lengths greater than (1ULL << 56) - 1 can't be represented
2544  * via an EBML number, so leave the unknown length field. */
2545  if (endpos - mkv->segment_offset < (1ULL << 56) - 1) {
2546  if ((ret64 = avio_seek(pb, mkv->segment_offset - 8, SEEK_SET)) < 0)
2547  return ret64;
2548  put_ebml_length(pb, endpos - mkv->segment_offset, 8);
2549  }
2550 
2551  ret = mkv_write_seekhead(pb, mkv, 1, mkv->info.pos);
2552  if (ret < 0)
2553  return ret;
2554 
2555  if (mkv->info.bc) {
2556  // update the duration
2557  av_log(s, AV_LOG_DEBUG, "end duration = %" PRIu64 "\n", mkv->duration);
2558  avio_seek(mkv->info.bc, mkv->duration_offset, SEEK_SET);
2560  ret = end_ebml_master_crc32(pb, &mkv->info.bc, mkv,
2561  MATROSKA_ID_INFO, 0, 0, 0);
2562  if (ret < 0)
2563  return ret;
2564  }
2565 
2566  if (mkv->track.bc) {
2567  // write Tracks master
2568  avio_seek(pb, mkv->track.pos, SEEK_SET);
2569  ret = end_ebml_master_crc32(pb, &mkv->track.bc, mkv,
2570  MATROSKA_ID_TRACKS, 0, 0, 0);
2571  if (ret < 0)
2572  return ret;
2573  }
2574 
2575  // update stream durations
2576  if (mkv->tags.bc) {
2577  int i;
2578  for (i = 0; i < s->nb_streams; ++i) {
2579  const AVStream *st = s->streams[i];
2580  const mkv_track *track = &mkv->tracks[i];
2581 
2582  if (track->duration_offset > 0) {
2583  double duration_sec = track->duration * av_q2d(st->time_base);
2584  char duration_string[20] = "";
2585 
2586  av_log(s, AV_LOG_DEBUG, "stream %d end duration = %" PRIu64 "\n", i,
2587  track->duration);
2588 
2589  avio_seek(mkv->tags.bc, track->duration_offset, SEEK_SET);
2590 
2591  snprintf(duration_string, 20, "%02d:%02d:%012.9f",
2592  (int) duration_sec / 3600, ((int) duration_sec / 60) % 60,
2593  fmod(duration_sec, 60));
2594 
2595  put_ebml_binary(mkv->tags.bc, MATROSKA_ID_TAGSTRING, duration_string, 20);
2596  }
2597  }
2598 
2599  avio_seek(pb, mkv->tags.pos, SEEK_SET);
2600  ret = end_ebml_master_crc32(pb, &mkv->tags.bc, mkv,
2601  MATROSKA_ID_TAGS, 0, 0, 0);
2602  if (ret < 0)
2603  return ret;
2604  }
2605 
2606  avio_seek(pb, endpos, SEEK_SET);
2607 
2608  return ret2;
2609 }
2610 
2611 static int mkv_query_codec(enum AVCodecID codec_id, int std_compliance)
2612 {
2613  int i;
2614  for (i = 0; ff_mkv_codec_tags[i].id != AV_CODEC_ID_NONE; i++)
2615  if (ff_mkv_codec_tags[i].id == codec_id)
2616  return 1;
2617 
2618  if (std_compliance < FF_COMPLIANCE_NORMAL) {
2619  enum AVMediaType type = avcodec_get_type(codec_id);
2620  // mkv theoretically supports any video/audio through VFW/ACM
2621  if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO)
2622  return 1;
2623  }
2624 
2625  return 0;
2626 }
2627 
2628 static int webm_query_codec(enum AVCodecID codec_id, int std_compliance)
2629 {
2630  int i;
2631  for (i = 0; ff_webm_codec_tags[i].id != AV_CODEC_ID_NONE; i++)
2632  if (ff_webm_codec_tags[i].id == codec_id)
2633  return 1;
2634 
2635  return 0;
2636 }
2637 
2638 static uint64_t mkv_get_uid(const mkv_track *tracks, int i, AVLFG *c)
2639 {
2640  while (1) {
2641  uint64_t uid;
2642  int k;
2643  uid = (uint64_t)av_lfg_get(c) << 32;
2644  uid |= av_lfg_get(c);
2645  if (!uid)
2646  continue;
2647  for (k = 0; k < i; k++) {
2648  if (tracks[k].uid == uid)
2649  break;
2650  }
2651  if (k == i)
2652  return uid;
2653  }
2654 }
2655 
2656 static int mkv_init(struct AVFormatContext *s)
2657 {
2658  MatroskaMuxContext *mkv = s->priv_data;
2659  AVLFG c;
2660  unsigned nb_tracks = 0;
2661  int i;
2662 
2663  for (i = 0; i < s->nb_streams; i++) {
2664  if (s->streams[i]->codecpar->codec_id == AV_CODEC_ID_ATRAC3 ||
2670  av_log(s, AV_LOG_ERROR,
2671  "The Matroska muxer does not yet support muxing %s\n",
2673  return AVERROR_PATCHWELCOME;
2674  }
2675  }
2676 
2677  if (s->avoid_negative_ts < 0) {
2678  s->avoid_negative_ts = 1;
2680  }
2681 
2682  if (!strcmp(s->oformat->name, "webm")) {
2683  mkv->mode = MODE_WEBM;
2684  mkv->write_crc = 0;
2685  } else
2686  mkv->mode = MODE_MATROSKAv2;
2687 
2688  mkv->tracks = av_mallocz_array(s->nb_streams, sizeof(*mkv->tracks));
2689  if (!mkv->tracks)
2690  return AVERROR(ENOMEM);
2691 
2692  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
2694 
2695  // Calculate the SegmentUID now in order not to waste our random seed.
2696  for (i = 0; i < 4; i++)
2697  mkv->segment_uid[i] = av_lfg_get(&c);
2698  }
2699 
2700  for (i = 0; i < s->nb_streams; i++) {
2701  AVStream *st = s->streams[i];
2702  mkv_track *track = &mkv->tracks[i];
2703 
2704  if (s->flags & AVFMT_FLAG_BITEXACT) {
2705  track->uid = i + 1;
2706  } else {
2707  track->uid = mkv_get_uid(mkv->tracks, i, &c);
2708  }
2709 
2710  // ms precision is the de-facto standard timescale for mkv files
2711  avpriv_set_pts_info(st, 64, 1, 1000);
2712 
2714  if (mkv->mode == MODE_WEBM) {
2715  av_log(s, AV_LOG_WARNING, "Stream %d will be ignored "
2716  "as WebM doesn't support attachments.\n", i);
2717  } else if (!get_mimetype(st)) {
2718  av_log(s, AV_LOG_ERROR, "Attachment stream %d has no mimetype "
2719  "tag and it cannot be deduced from the codec id.\n", i);
2720  return AVERROR(EINVAL);
2721  }
2722  mkv->nb_attachments++;
2723  continue;
2724  }
2725 
2726  nb_tracks++;
2727  track->track_num = mkv->is_dash ? mkv->dash_track_number : nb_tracks;
2728  track->track_num_size = ebml_num_size(track->track_num);
2729  }
2730 
2731  if (mkv->is_dash && nb_tracks != 1)
2732  return AVERROR(EINVAL);
2733 
2734  return 0;
2735 }
2736 
2737 static int mkv_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
2738 {
2739  int ret = 1;
2740  AVStream *st = s->streams[pkt->stream_index];
2741 
2742  if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
2743  if (pkt->size > 2 && (AV_RB16(pkt->data) & 0xfff0) == 0xfff0)
2744  ret = ff_stream_add_bitstream_filter(st, "aac_adtstoasc", NULL);
2745  } else if (st->codecpar->codec_id == AV_CODEC_ID_VP9) {
2746  ret = ff_stream_add_bitstream_filter(st, "vp9_superframe", NULL);
2747  }
2748 
2749  return ret;
2750 }
2751 
2753  { AV_CODEC_ID_ALAC, 0XFFFFFFFF },
2754  { AV_CODEC_ID_MLP, 0xFFFFFFFF },
2755  { AV_CODEC_ID_OPUS, 0xFFFFFFFF },
2756  { AV_CODEC_ID_PCM_S16BE, 0xFFFFFFFF },
2757  { AV_CODEC_ID_PCM_S24BE, 0xFFFFFFFF },
2758  { AV_CODEC_ID_PCM_S32BE, 0xFFFFFFFF },
2759  { AV_CODEC_ID_QDMC, 0xFFFFFFFF },
2760  { AV_CODEC_ID_QDM2, 0xFFFFFFFF },
2761  { AV_CODEC_ID_RA_144, 0xFFFFFFFF },
2762  { AV_CODEC_ID_RA_288, 0xFFFFFFFF },
2763  { AV_CODEC_ID_COOK, 0xFFFFFFFF },
2764  { AV_CODEC_ID_TRUEHD, 0xFFFFFFFF },
2765  { AV_CODEC_ID_NONE, 0xFFFFFFFF }
2766 };
2767 
2769  { AV_CODEC_ID_RV10, 0xFFFFFFFF },
2770  { AV_CODEC_ID_RV20, 0xFFFFFFFF },
2771  { AV_CODEC_ID_RV30, 0xFFFFFFFF },
2772  { AV_CODEC_ID_NONE, 0xFFFFFFFF }
2773 };
2774 
2776  { AV_CODEC_ID_DVB_SUBTITLE, 0xFFFFFFFF },
2777  { AV_CODEC_ID_DVD_SUBTITLE, 0xFFFFFFFF },
2778  { AV_CODEC_ID_HDMV_PGS_SUBTITLE, 0xFFFFFFFF },
2779  { AV_CODEC_ID_NONE, 0xFFFFFFFF }
2780 };
2781 
2782 #define OFFSET(x) offsetof(MatroskaMuxContext, x)
2783 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM
2784 static const AVOption options[] = {
2785  { "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 },
2786  { "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 },
2787  { "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 },
2788  { "dash", "Create a WebM file conforming to WebM DASH specification", OFFSET(is_dash), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
2789  { "dash_track_number", "Track number for the DASH stream", OFFSET(dash_track_number), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, INT_MAX, FLAGS },
2790  { "live", "Write files assuming it is a live stream.", OFFSET(is_live), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
2791  { "allow_raw_vfw", "allow RAW VFW mode", OFFSET(allow_raw_vfw), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
2792  { "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 },
2793  { "write_crc32", "write a CRC32 element inside every Level 1 element", OFFSET(write_crc), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, FLAGS },
2794  { "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" },
2795  { "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" },
2796  { "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" },
2797  { "passthrough", "Use the disposition flag as-is", 0, AV_OPT_TYPE_CONST, { .i64 = DEFAULT_MODE_PASSTHROUGH }, 0, 0, FLAGS, "default_mode" },
2798  { NULL },
2799 };
2800 
2801 #if CONFIG_MATROSKA_MUXER
2802 static const AVClass matroska_class = {
2803  .class_name = "matroska muxer",
2804  .item_name = av_default_item_name,
2805  .option = options,
2806  .version = LIBAVUTIL_VERSION_INT,
2807 };
2808 
2810  .name = "matroska",
2811  .long_name = NULL_IF_CONFIG_SMALL("Matroska"),
2812  .mime_type = "video/x-matroska",
2813  .extensions = "mkv",
2814  .priv_data_size = sizeof(MatroskaMuxContext),
2815  .audio_codec = CONFIG_LIBVORBIS_ENCODER ?
2817  .video_codec = CONFIG_LIBX264_ENCODER ?
2819  .init = mkv_init,
2820  .deinit = mkv_deinit,
2826  .codec_tag = (const AVCodecTag* const []){
2829  },
2830  .subtitle_codec = AV_CODEC_ID_ASS,
2831  .query_codec = mkv_query_codec,
2832  .check_bitstream = mkv_check_bitstream,
2833  .priv_class = &matroska_class,
2834 };
2835 #endif
2836 
2837 #if CONFIG_WEBM_MUXER
2838 static const AVClass webm_class = {
2839  .class_name = "webm muxer",
2840  .item_name = av_default_item_name,
2841  .option = options,
2842  .version = LIBAVUTIL_VERSION_INT,
2843 };
2844 
2846  .name = "webm",
2847  .long_name = NULL_IF_CONFIG_SMALL("WebM"),
2848  .mime_type = "video/webm",
2849  .extensions = "webm",
2850  .priv_data_size = sizeof(MatroskaMuxContext),
2851  .audio_codec = CONFIG_LIBOPUS_ENCODER ? AV_CODEC_ID_OPUS : AV_CODEC_ID_VORBIS,
2852  .video_codec = CONFIG_LIBVPX_VP9_ENCODER? AV_CODEC_ID_VP9 : AV_CODEC_ID_VP8,
2853  .subtitle_codec = AV_CODEC_ID_WEBVTT,
2854  .init = mkv_init,
2855  .deinit = mkv_deinit,
2863  .priv_class = &webm_class,
2864 };
2865 #endif
2866 
2867 #if CONFIG_MATROSKA_AUDIO_MUXER
2868 static const AVClass mka_class = {
2869  .class_name = "matroska audio muxer",
2870  .item_name = av_default_item_name,
2871  .option = options,
2872  .version = LIBAVUTIL_VERSION_INT,
2873 };
2875  .name = "matroska",
2876  .long_name = NULL_IF_CONFIG_SMALL("Matroska Audio"),
2877  .mime_type = "audio/x-matroska",
2878  .extensions = "mka",
2879  .priv_data_size = sizeof(MatroskaMuxContext),
2880  .audio_codec = CONFIG_LIBVORBIS_ENCODER ?
2882  .video_codec = AV_CODEC_ID_NONE,
2883  .init = mkv_init,
2884  .deinit = mkv_deinit,
2891  .codec_tag = (const AVCodecTag* const []){
2893  },
2894  .priv_class = &mka_class,
2895 };
2896 #endif
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1468
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:159
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:703
enum AVChromaLocation chroma_location
Definition: codec_par.h:150
internal header for HEVC (de)muxer utilities
#define AV_DISPOSITION_METADATA
Definition: avformat.h:862
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:230
#define MATROSKA_ID_TRACKDEFAULTDURATION
Definition: matroska.h:104
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:121
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define MATROSKA_ID_VIDEOCOLOR_GX
Definition: matroska.h:147
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:317
#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:101
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:2363
#define MATROSKA_ID_VIDEODISPLAYHEIGHT
Definition: matroska.h:113
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:2656
#define MAX_SEEKHEAD_ENTRIES
Definition: matroskaenc.c:59
static int mkv_write_packet_internal(AVFormatContext *s, const AVPacket *pkt)
Definition: matroskaenc.c:2271
#define MATROSKA_ID_VIDEOPROJECTIONPOSEROLL
Definition: matroska.h:161
#define MATROSKA_ID_CUETRACKPOSITION
Definition: matroska.h:192
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3097
#define MATROSKA_ID_CODECPRIVATE
Definition: matroska.h:89
AVIOContext * cluster_bc
Definition: matroskaenc.c:130
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:4871
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:35
#define MATROSKA_ID_AUDIOBITDEPTH
Definition: matroska.h:167
#define CASE(type, variable)
#define MATROSKA_ID_TRACKFLAGDEFAULT
Definition: matroska.h:99
static const AVCodecTag additional_subtitle_tags[]
Definition: matroskaenc.c:2775
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:1718
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:942
#define MATROSKA_ID_TAGTARGETS_ATTACHUID
Definition: matroska.h:214
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:246
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:1704
#define EBML_ID_DOCTYPEREADVERSION
Definition: matroska.h:42
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:276
#define MATROSKA_ID_BLOCKREFERENCE
Definition: matroska.h:237
int av_log2(unsigned v)
Definition: intmath.c:26
static int mkv_write_header(AVFormatContext *s)
Definition: matroskaenc.c:1786
#define MATROSKA_ID_TRACKTYPE
Definition: matroska.h:80
enum AVMediaType codec_type
Definition: rtp.c:37
#define MATROSKA_ID_TAGTARGETS_CHAPTERUID
Definition: matroska.h:213
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 MATROSKA_ID_VIDEOCOLOR_RX
Definition: matroska.h:145
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:1504
#define MATROSKA_ID_MUXINGAPP
Definition: matroska.h:70
int64_t cluster_time_limit
Definition: matroskaenc.c:150
#define MATROSKA_ID_AUDIOCHANNELS
Definition: matroska.h:168
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:3087
const char * key
int avoid_negative_ts_use_pts
Definition: internal.h:119
const char * master
Definition: vf_curves.c:117
#define MATROSKA_ID_VIDEOPROJECTIONTYPE
Definition: matroska.h:157
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:196
#define MATROSKA_ID_VIDEOCOLOR_LUMINANCEMAX
Definition: matroska.h:153
#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:1200
#define MATROSKA_ID_VIDEOCOLORCHROMASITINGHORZ
Definition: matroska.h:135
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:260
#define MATROSKA_ID_CLUSTERTIMECODE
Definition: matroska.h:224
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:253
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:301
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:222
#define FLAGS
Definition: matroskaenc.c:2783
#define MATROSKA_ID_FILEDESC
Definition: matroska.h:243
Format I/O context.
Definition: avformat.h:1239
#define EBML_ID_CRC32
Definition: matroska.h:46
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:2165
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:2752
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:149
#define MATROSKA_ID_CHAPLANG
Definition: matroska.h:256
#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
const AVCodecTag ff_codec_movvideo_tags[]
Definition: isom.c:75
#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
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
uint64_t segmentpos
Definition: matroskaenc.c:82
int id
unique ID to identify the chapter
Definition: avformat.h:1197
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:232
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:5431
static int put_xiph_codecpriv(AVFormatContext *s, AVIOContext *pb, const AVCodecParameters *par)
Definition: matroskaenc.c:603
#define MATROSKA_ID_BLOCKMORE
Definition: matroska.h:229
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:1307
int64_t duration
Definition: movenc.c:63
#define MATROSKA_ID_CUERELATIVEPOSITION
Definition: matroska.h:197
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:165
#define MATROSKA_ID_VIDEOCOLOR
Definition: matroska.h:127
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:2628
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:1370
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:112
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:228
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:407
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:1530
#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:152
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:1387
static uint64_t mkv_get_uid(const mkv_track *tracks, int i, AVLFG *c)
Definition: matroskaenc.c:2638
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:860
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:254
#define MATROSKA_ID_VIDEOSTEREOMODE
Definition: matroska.h:123
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:5630
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:1541
#define MATROSKA_ID_VIDEOCOLOR_BY
Definition: matroska.h:150
#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:1600
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1479
int flags
Additional information about the frame packing.
Definition: stereo3d.h:185
#define MATROSKA_ID_BLOCKDURATION
Definition: matroska.h:236
#define EBML_ID_EBMLREADVERSION
Definition: matroska.h:37
#define MATROSKA_ID_VIDEOCOLORMAXCLL
Definition: matroska.h:141
#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:151
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:136
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
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:245
#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:1469
enum AVCodecID id
Definition: matroska.h:355
static int mkv_write_chapters(AVFormatContext *s)
Definition: matroskaenc.c:1614
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:953
const AVCodecTag ff_codec_wav_tags[]
Definition: riff.c:507
#define FFMAX(a, b)
Definition: common.h:94
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:123
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:202
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:837
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1295
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:1436
#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:154
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:3260
#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:209
const AVCodecTag ff_codec_bmp_tags[]
Definition: riff.c:32
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:215
#define MATROSKA_ID_TAGNAME
Definition: matroska.h:204
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:1762
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:203
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:1582
#define MATROSKA_ID_CHAPTERATOM
Definition: matroska.h:251
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:944
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:2181
Opaque data information usually sparse.
Definition: avutil.h:205
#define MATROSKA_ID_VIDEOCOLORSPACE
Definition: matroska.h:126
#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:2782
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:164
ff_const59 struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1258
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1458
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:1751
Stream structure.
Definition: avformat.h:880
#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:1199
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:825
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:129
#define AV_DISPOSITION_DESCRIPTIONS
Definition: avformat.h:861
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:140
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:160
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
#define MATROSKA_ID_SEEKID
Definition: matroska.h:220
AVIOContext * pb
I/O context.
Definition: avformat.h:1281
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:235
#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:212
#define MATROSKA_ID_TAGLANG
Definition: matroska.h:206
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:217
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:250
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:1597
static int mkv_check_tag_name(const char *name, uint32_t elementid)
Definition: matroskaenc.c:1490
#define MATROSKA_ID_BLOCKGROUP
Definition: matroska.h:227
#define MATROSKA_ID_VIDEOPIXELHEIGHT
Definition: matroska.h:115
int32_t roll
Rotation around the forward vector [-180, 180].
Definition: spherical.h:128
static int mkv_write_tracks(AVFormatContext *s)
Definition: matroskaenc.c:1378
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:198
#define MATROSKA_ID_CUETIME
Definition: matroska.h:191
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:138
#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:1952
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:156
#define MATROSKA_ID_VIDEOCOLORMASTERINGMETA
Definition: matroska.h:144
misc parsing utilities
ebml_stored_master tags
Definition: matroskaenc.c:128
#define MATROSKA_ID_VIDEOPROJECTIONPRIVATE
Definition: matroska.h:158
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:560
#define MATROSKA_ID_CHAPTERDISPLAY
Definition: matroska.h:254
static int mkv_end_cluster(AVFormatContext *s)
Definition: matroskaenc.c:2162
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:244
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:231
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:2768
mkv_seekhead_entry entries[MAX_SEEKHEAD_ENTRIES]
Definition: matroskaenc.c:87
#define MATROSKA_ID_VIDEOFIELDORDER
Definition: matroska.h:122
int64_t start
Definition: avformat.h:1199
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:124
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:2455
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:2737
#define MATROSKA_ID_CUETRACK
Definition: matroska.h:195
static int put_wv_codecpriv(AVIOContext *pb, const AVCodecParameters *par)
Definition: matroskaenc.c:633
#define MATROSKA_ID_SEEKPOSITION
Definition: matroska.h:221
#define MATROSKA_ID_CODECDELAY
Definition: matroska.h:94
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
#define MATROSKA_ID_CHAPTERTIMESTART
Definition: matroska.h:252
#define MATROSKA_ID_VIDEOCOLORRANGE
Definition: matroska.h:137
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:1470
raw UTF-8 text
Definition: codec_id.h:519
static int mkv_write_flush_packet(AVFormatContext *s, AVPacket *pkt)
Definition: matroskaenc.c:2437
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:933
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:1198
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:1226
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:2117
#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 av_free(p)
char * value
Definition: dict.h:87
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
#define MATROSKA_ID_POINTENTRY
Definition: matroska.h:188
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:247
int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
Add a bitstream filter to a stream.
Definition: utils.c:5502
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:1267
#define MATROSKA_ID_CHAPTERUID
Definition: matroska.h:262
char str[22]
Definition: matroska.h:354
static int check_bitstream(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:1075
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:3457
static const char * get_mimetype(const AVStream *st)
Definition: matroskaenc.c:1701
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:142
#define MATROSKA_ID_VIDEODISPLAYUNIT
Definition: matroska.h:120
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:2784
#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:3482
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1354
#define MATROSKA_ID_CHAPSTRING
Definition: matroska.h:255
int sample_rate
Definition: matroskaenc.c:111
#define av_freep(p)
#define MATROSKA_ID_TAGSTRING
Definition: matroska.h:205
#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:1045
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:909
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:1022
#define MATROSKA_ID_ATTACHEDFILE
Definition: matroska.h:242
#define MATROSKA_ID_VIDEOCOLOR_GY
Definition: matroska.h:148
static int mkv_write_block(AVFormatContext *s, AVIOContext *pb, uint32_t blockid, const AVPacket *pkt, int keyframe)
Definition: matroskaenc.c:2005
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:146
uint32_t blocksize
Definition: wv.h:35
static int mkv_query_codec(enum AVCodecID codec_id, int std_compliance)
Definition: matroskaenc.c:2611
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:114
static int mkv_blockgroup_size(int pkt_size, int track_num_size)
Definition: matroskaenc.c:1943
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:239
#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:26