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 > 0)
589  put_ebml_uint(cuepoint, MATROSKA_ID_CUEDURATION , entry->duration);
590  end_ebml_master(cuepoint, track_positions);
591  } while (++entry < end && entry->pts == pts);
592  size = avio_get_dyn_buf(cuepoint, &buf);
593  if ((ret = cuepoint->error) < 0)
594  break;
595  put_ebml_binary(dyn_cp, MATROSKA_ID_POINTENTRY, buf, size);
596  ffio_reset_dyn_buf(cuepoint);
597  }
598  ffio_free_dyn_buf(&cuepoint);
599 
600  return ret;
601 }
602 
604  const AVCodecParameters *par)
605 {
606  const uint8_t *header_start[3];
607  int header_len[3];
608  int first_header_size;
609  int err, j;
610 
611  if (par->codec_id == AV_CODEC_ID_VORBIS)
612  first_header_size = 30;
613  else
614  first_header_size = 42;
615 
617  first_header_size, header_start, header_len);
618  if (err < 0) {
619  av_log(s, AV_LOG_ERROR, "Extradata corrupt.\n");
620  return err;
621  }
622 
623  avio_w8(pb, 2); // number packets - 1
624  for (j = 0; j < 2; j++) {
625  put_xiph_size(pb, header_len[j]);
626  }
627  for (j = 0; j < 3; j++)
628  avio_write(pb, header_start[j], header_len[j]);
629 
630  return 0;
631 }
632 
633 static int put_wv_codecpriv(AVIOContext *pb, const AVCodecParameters *par)
634 {
635  if (par->extradata && par->extradata_size == 2)
636  avio_write(pb, par->extradata, 2);
637  else
638  avio_wl16(pb, 0x410); // fallback to the most recent version
639  return 0;
640 }
641 
643  const AVCodecParameters *par)
644 {
645  int write_comment = (par->channel_layout &&
646  !(par->channel_layout & ~0x3ffffULL) &&
648  int ret = ff_flac_write_header(pb, par->extradata, par->extradata_size,
649  !write_comment);
650 
651  if (ret < 0)
652  return ret;
653 
654  if (write_comment) {
655  const char *vendor = (s->flags & AVFMT_FLAG_BITEXACT) ?
656  "Lavf" : LIBAVFORMAT_IDENT;
657  AVDictionary *dict = NULL;
658  uint8_t buf[32];
659  int64_t len;
660 
661  snprintf(buf, sizeof(buf), "0x%"PRIx64, par->channel_layout);
662  av_dict_set(&dict, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", buf, 0);
663 
664  len = ff_vorbiscomment_length(dict, vendor, NULL, 0);
665  av_assert1(len < (1 << 24) - 4);
666 
667  avio_w8(pb, 0x84);
668  avio_wb24(pb, len);
669 
670  ff_vorbiscomment_write(pb, dict, vendor, NULL, 0);
671 
672  av_dict_free(&dict);
673  }
674 
675  return 0;
676 }
677 
679  const uint8_t *extradata, int extradata_size,
680  int *sample_rate, int *output_sample_rate)
681 {
682  MPEG4AudioConfig mp4ac;
683  int ret;
684 
685  ret = avpriv_mpeg4audio_get_config2(&mp4ac, extradata, extradata_size, 1, s);
686  /* Don't abort if the failure is because of missing extradata. Assume in that
687  * case a bitstream filter will provide the muxer with the extradata in the
688  * first packet.
689  * Abort however if s->pb is not seekable, as we would not be able to seek back
690  * to write the sample rate elements once the extradata shows up, anyway. */
691  if (ret < 0 && (extradata_size || !IS_SEEKABLE(s->pb, mkv))) {
692  av_log(s, AV_LOG_ERROR,
693  "Error parsing AAC extradata, unable to determine samplerate.\n");
694  return AVERROR(EINVAL);
695  }
696 
697  if (ret < 0) {
698  /* This will only happen when this function is called while writing the
699  * header and no extradata is available. The space for this element has
700  * to be reserved for when this function is called again after the
701  * extradata shows up in the first packet, as there's no way to know if
702  * output_sample_rate will be different than sample_rate or not. */
703  *output_sample_rate = *sample_rate;
704  } else {
705  *sample_rate = mp4ac.sample_rate;
706  *output_sample_rate = mp4ac.ext_sample_rate;
707  }
708  return 0;
709 }
710 
712  const AVCodecParameters *par,
713  AVIOContext *dyn_cp)
714 {
715  switch (par->codec_id) {
716  case AV_CODEC_ID_VORBIS:
717  case AV_CODEC_ID_THEORA:
718  return put_xiph_codecpriv(s, dyn_cp, par);
719  case AV_CODEC_ID_FLAC:
720  return put_flac_codecpriv(s, dyn_cp, par);
721  case AV_CODEC_ID_WAVPACK:
722  return put_wv_codecpriv(dyn_cp, par);
723  case AV_CODEC_ID_H264:
724  return ff_isom_write_avcc(dyn_cp, par->extradata,
725  par->extradata_size);
726  case AV_CODEC_ID_HEVC:
727  return ff_isom_write_hvcc(dyn_cp, par->extradata,
728  par->extradata_size, 0);
729  case AV_CODEC_ID_AV1:
730  if (par->extradata_size)
731  return ff_isom_write_av1c(dyn_cp, par->extradata,
732  par->extradata_size);
733  else
734  put_ebml_void(pb, 4 + 3);
735  break;
736  case AV_CODEC_ID_ALAC:
737  if (par->extradata_size < 36) {
738  av_log(s, AV_LOG_ERROR,
739  "Invalid extradata found, ALAC expects a 36-byte "
740  "QuickTime atom.");
741  return AVERROR_INVALIDDATA;
742  } else
743  avio_write(dyn_cp, par->extradata + 12,
744  par->extradata_size - 12);
745  break;
746  case AV_CODEC_ID_AAC:
747  if (par->extradata_size)
748  avio_write(dyn_cp, par->extradata, par->extradata_size);
749  else
750  put_ebml_void(pb, MAX_PCE_SIZE + 2 + 4);
751  break;
752  default:
753  if (par->codec_id == AV_CODEC_ID_PRORES &&
755  avio_wl32(dyn_cp, par->codec_tag);
756  } else if (par->extradata_size && par->codec_id != AV_CODEC_ID_TTA)
757  avio_write(dyn_cp, par->extradata, par->extradata_size);
758  }
759 
760  return 0;
761 }
762 
764  AVCodecParameters *par,
765  int native_id, int qt_id)
766 {
767  AVIOContext *dyn_cp;
768  MatroskaMuxContext *mkv = s->priv_data;
769  uint8_t *codecpriv;
770  int ret, codecpriv_size;
771 
772  ret = avio_open_dyn_buf(&dyn_cp);
773  if (ret < 0)
774  return ret;
775 
776  if (native_id) {
777  ret = mkv_write_native_codecprivate(s, pb, par, dyn_cp);
778  } else if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
779  if (qt_id) {
780  if (!par->codec_tag)
782  par->codec_id);
785  ) {
786  int i;
787  avio_wb32(dyn_cp, 0x5a + par->extradata_size);
788  avio_wl32(dyn_cp, par->codec_tag);
789  for(i = 0; i < 0x5a - 8; i++)
790  avio_w8(dyn_cp, 0);
791  }
792  avio_write(dyn_cp, par->extradata, par->extradata_size);
793  } else {
795  av_log(s, AV_LOG_WARNING, "codec %s is not supported by this format\n",
796  avcodec_get_name(par->codec_id));
797 
798  if (!par->codec_tag)
800  par->codec_id);
801  if (!par->codec_tag && par->codec_id != AV_CODEC_ID_RAWVIDEO) {
802  av_log(s, AV_LOG_ERROR, "No bmp codec tag found for codec %s\n",
803  avcodec_get_name(par->codec_id));
804  ret = AVERROR(EINVAL);
805  }
806 
807  ff_put_bmp_header(dyn_cp, par, 0, 0, mkv->flipped_raw_rgb);
808  }
809  } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
810  unsigned int tag;
812  if (!tag) {
813  av_log(s, AV_LOG_ERROR, "No wav codec tag found for codec %s\n",
814  avcodec_get_name(par->codec_id));
815  ret = AVERROR(EINVAL);
816  }
817  if (!par->codec_tag)
818  par->codec_tag = tag;
819 
821  }
822 
823  if (ret >= 0) {
824  codecpriv_size = avio_get_dyn_buf(dyn_cp, &codecpriv);
825  if ((ret = dyn_cp->error) >= 0 && codecpriv_size)
827  codecpriv_size);
828  }
829  ffio_free_dyn_buf(&dyn_cp);
830  return ret;
831 }
832 
833 static void mkv_write_video_color(AVIOContext *pb, const AVStream *st,
834  const AVCodecParameters *par)
835 {
836  /* 18 Elements with two bytes ID, one byte length field, 8 bytes payload
837  * a master element with two bytes ID and one byte length field
838  * plus another byte to stay clear of the end. */
839  uint8_t colour[(2 + 1 + 8) * 18 + (2 + 1) + 1];
840  AVIOContext buf, *dyn_cp = &buf;
841  int colorinfo_size;
842  const void *side_data;
843 
844  ffio_init_context(dyn_cp, colour, sizeof(colour), 1, NULL, NULL, NULL, NULL);
845 
846  if (par->color_trc != AVCOL_TRC_UNSPECIFIED &&
847  par->color_trc < AVCOL_TRC_NB) {
849  par->color_trc);
850  }
851  if (par->color_space != AVCOL_SPC_UNSPECIFIED &&
852  par->color_space < AVCOL_SPC_NB) {
854  }
856  par->color_primaries < AVCOL_PRI_NB) {
858  }
859  if (par->color_range != AVCOL_RANGE_UNSPECIFIED &&
860  par->color_range < AVCOL_RANGE_NB) {
862  }
865  int xpos, ypos;
866 
867  avcodec_enum_to_chroma_pos(&xpos, &ypos, par->chroma_location);
868  put_ebml_uint(dyn_cp, MATROSKA_ID_VIDEOCOLORCHROMASITINGHORZ, (xpos >> 7) + 1);
869  put_ebml_uint(dyn_cp, MATROSKA_ID_VIDEOCOLORCHROMASITINGVERT, (ypos >> 7) + 1);
870  }
871 
873  NULL);
874  if (side_data) {
875  const AVContentLightMetadata *metadata = side_data;
878  }
879 
881  NULL);
882  if (side_data) {
883  ebml_master meta_element = start_ebml_master(
884  dyn_cp, MATROSKA_ID_VIDEOCOLORMASTERINGMETA, 10 * (2 + 1 + 8));
885  const AVMasteringDisplayMetadata *metadata = side_data;
886  if (metadata->has_primaries) {
888  av_q2d(metadata->display_primaries[0][0]));
890  av_q2d(metadata->display_primaries[0][1]));
892  av_q2d(metadata->display_primaries[1][0]));
894  av_q2d(metadata->display_primaries[1][1]));
896  av_q2d(metadata->display_primaries[2][0]));
898  av_q2d(metadata->display_primaries[2][1]));
900  av_q2d(metadata->white_point[0]));
902  av_q2d(metadata->white_point[1]));
903  }
904  if (metadata->has_luminance) {
906  av_q2d(metadata->max_luminance));
908  av_q2d(metadata->min_luminance));
909  }
910  end_ebml_master(dyn_cp, meta_element);
911  }
912 
913  colorinfo_size = avio_tell(dyn_cp);
914  if (colorinfo_size)
915  put_ebml_binary(pb, MATROSKA_ID_VIDEOCOLOR, colour, colorinfo_size);
916 }
917 
919  const AVStream *st)
920 {
921  ebml_master projection;
922  uint8_t private[20];
923 
924  const AVSphericalMapping *spherical =
926  NULL);
927 
928  if (!spherical)
929  return;
930 
931  if (spherical->projection != AV_SPHERICAL_EQUIRECTANGULAR &&
933  spherical->projection != AV_SPHERICAL_CUBEMAP) {
934  av_log(s, AV_LOG_WARNING, "Unknown projection type\n");
935  return;
936  }
937 
938  // Maximally 4 8-byte elements with id-length 2 + 1 byte length field
939  // and the private data of the AV_SPHERICAL_EQUIRECTANGULAR_TILE case
941  4 * (2 + 1 + 8) + (2 + 1 + 20));
942 
943  switch (spherical->projection) {
947  break;
951  AV_WB32(private, 0); // version + flags
952  AV_WB32(private + 4, spherical->bound_top);
953  AV_WB32(private + 8, spherical->bound_bottom);
954  AV_WB32(private + 12, spherical->bound_left);
955  AV_WB32(private + 16, spherical->bound_right);
957  private, 20);
958  break;
962  AV_WB32(private, 0); // version + flags
963  AV_WB32(private + 4, 0); // layout
964  AV_WB32(private + 8, spherical->padding);
966  private, 12);
967  break;
968  default:
969  av_assert0(0);
970  }
971 
972  if (spherical->yaw)
974  (double) spherical->yaw / (1 << 16));
975  if (spherical->pitch)
977  (double) spherical->pitch / (1 << 16));
978  if (spherical->roll)
980  (double) spherical->roll / (1 << 16));
981 
982  end_ebml_master(pb, projection);
983 }
984 
986  enum AVFieldOrder field_order)
987 {
988  switch (field_order) {
989  case AV_FIELD_UNKNOWN:
990  break;
994  break;
995  case AV_FIELD_TT:
996  case AV_FIELD_BB:
997  case AV_FIELD_TB:
998  case AV_FIELD_BT:
1001  if (mode != MODE_WEBM) {
1002  switch (field_order) {
1003  case AV_FIELD_TT:
1006  break;
1007  case AV_FIELD_BB:
1010  break;
1011  case AV_FIELD_TB:
1014  break;
1015  case AV_FIELD_BT:
1018  break;
1019  }
1020  }
1021  }
1022 }
1023 
1025  AVStream *st, int mode, int *h_width, int *h_height)
1026 {
1027  const AVDictionaryEntry *tag;
1029  const AVStereo3D *stereo;
1030 
1031  *h_width = 1;
1032  *h_height = 1;
1033  // convert metadata into proper side data and add it to the stream
1034  if ((tag = av_dict_get(st->metadata, "stereo_mode", NULL, 0)) ||
1035  (tag = av_dict_get( s->metadata, "stereo_mode", NULL, 0))) {
1036  int stereo_mode = atoi(tag->value);
1037 
1038  for (int i = 0; i < MATROSKA_VIDEO_STEREOMODE_TYPE_NB; i++)
1039  if (!strcmp(tag->value, ff_matroska_video_stereo_mode[i])){
1040  stereo_mode = i;
1041  break;
1042  }
1043 
1044  if (stereo_mode < MATROSKA_VIDEO_STEREOMODE_TYPE_NB &&
1045  stereo_mode != 10 && stereo_mode != 12) {
1046  int ret = ff_mkv_stereo3d_conv(st, stereo_mode);
1047  if (ret < 0)
1048  return ret;
1049  }
1050  }
1051 
1053  NULL);
1054  if (stereo) {
1055  switch (stereo->type) {
1056  case AV_STEREO3D_2D:
1058  break;
1060  format = (stereo->flags & AV_STEREO3D_FLAG_INVERT)
1063  *h_width = 2;
1064  break;
1065  case AV_STEREO3D_TOPBOTTOM:
1067  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
1068  format--;
1069  *h_height = 2;
1070  break;
1073  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
1074  format--;
1075  break;
1076  case AV_STEREO3D_LINES:
1078  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
1079  format--;
1080  *h_height = 2;
1081  break;
1082  case AV_STEREO3D_COLUMNS:
1084  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
1085  format--;
1086  *h_width = 2;
1087  break;
1090  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
1091  format++;
1092  break;
1093  }
1094  }
1095 
1096  if (format == MATROSKA_VIDEO_STEREOMODE_TYPE_NB)
1097  return 0;
1098 
1099  // if webm, do not write unsupported modes
1100  if ((mode == MODE_WEBM &&
1103  || format >= MATROSKA_VIDEO_STEREOMODE_TYPE_NB) {
1104  av_log(s, AV_LOG_ERROR,
1105  "The specified stereo mode is not valid.\n");
1106  return AVERROR(EINVAL);
1107  }
1108 
1109  // write StereoMode if format is valid
1111 
1112  return 0;
1113 }
1114 
1116  AVStream *st, mkv_track *track, AVIOContext *pb,
1117  int is_default)
1118 {
1119  AVCodecParameters *par = st->codecpar;
1120  ebml_master subinfo, track_master;
1121  int native_id = 0;
1122  int qt_id = 0;
1123  int bit_depth;
1124  int sample_rate = par->sample_rate;
1125  int output_sample_rate = 0;
1126  int display_width_div = 1;
1127  int display_height_div = 1;
1128  int j, ret;
1129  const AVDictionaryEntry *tag;
1130 
1131  if (par->codec_type == AVMEDIA_TYPE_ATTACHMENT)
1132  return 0;
1133 
1134  if (par->codec_id == AV_CODEC_ID_AAC) {
1135  ret = get_aac_sample_rates(s, mkv, par->extradata, par->extradata_size,
1136  &sample_rate, &output_sample_rate);
1137  if (ret < 0)
1138  return ret;
1139  }
1140 
1141  track_master = start_ebml_master(pb, MATROSKA_ID_TRACKENTRY, 0);
1143  put_ebml_uid (pb, MATROSKA_ID_TRACKUID, track->uid);
1144  put_ebml_uint(pb, MATROSKA_ID_TRACKFLAGLACING, 0); // no lacing (yet)
1145 
1146  if ((tag = av_dict_get(st->metadata, "title", NULL, 0)))
1148  tag = av_dict_get(st->metadata, "language", NULL, 0);
1150  tag && tag->value[0] ? tag->value : "und");
1151 
1152  // The default value for TRACKFLAGDEFAULT is 1, so add element
1153  // if we need to clear it.
1154  if (!is_default)
1156 
1159 
1160  if (mkv->mode == MODE_WEBM) {
1161  const char *codec_id;
1162  if (par->codec_type != AVMEDIA_TYPE_SUBTITLE) {
1163  for (j = 0; ff_webm_codec_tags[j].id != AV_CODEC_ID_NONE; j++) {
1164  if (ff_webm_codec_tags[j].id == par->codec_id) {
1165  codec_id = ff_webm_codec_tags[j].str;
1166  native_id = 1;
1167  break;
1168  }
1169  }
1170  } else if (par->codec_id == AV_CODEC_ID_WEBVTT) {
1172  codec_id = "D_WEBVTT/CAPTIONS";
1173  native_id = MATROSKA_TRACK_TYPE_SUBTITLE;
1174  } else if (st->disposition & AV_DISPOSITION_DESCRIPTIONS) {
1175  codec_id = "D_WEBVTT/DESCRIPTIONS";
1176  native_id = MATROSKA_TRACK_TYPE_METADATA;
1177  } else if (st->disposition & AV_DISPOSITION_METADATA) {
1178  codec_id = "D_WEBVTT/METADATA";
1179  native_id = MATROSKA_TRACK_TYPE_METADATA;
1180  } else {
1181  codec_id = "D_WEBVTT/SUBTITLES";
1182  native_id = MATROSKA_TRACK_TYPE_SUBTITLE;
1183  }
1184  }
1185 
1186  if (!native_id) {
1187  av_log(s, AV_LOG_ERROR,
1188  "Only VP8 or VP9 or AV1 video and Vorbis or Opus audio and WebVTT subtitles are supported for WebM.\n");
1189  return AVERROR(EINVAL);
1190  }
1191 
1192  put_ebml_string(pb, MATROSKA_ID_CODECID, codec_id);
1193  } else {
1205 
1206  // look for a codec ID string specific to mkv to use,
1207  // if none are found, use AVI codes
1208  if (par->codec_id != AV_CODEC_ID_RAWVIDEO || par->codec_tag) {
1209  for (j = 0; ff_mkv_codec_tags[j].id != AV_CODEC_ID_NONE; j++) {
1210  if (ff_mkv_codec_tags[j].id == par->codec_id && par->codec_id != AV_CODEC_ID_FFV1) {
1212  native_id = 1;
1213  break;
1214  }
1215  }
1216  } else {
1217  if (mkv->allow_raw_vfw) {
1218  native_id = 0;
1219  } else {
1220  av_log(s, AV_LOG_ERROR, "Raw RGB is not supported Natively in Matroska, you can use AVI or NUT or\n"
1221  "If you would like to store it anyway using VFW mode, enable allow_raw_vfw (-allow_raw_vfw 1)\n");
1222  return AVERROR(EINVAL);
1223  }
1224  }
1225  }
1226 
1227  switch (par->codec_type) {
1228  case AVMEDIA_TYPE_VIDEO:
1229  mkv->have_video = 1;
1231 
1232  if( st->avg_frame_rate.num > 0 && st->avg_frame_rate.den > 0
1233  && av_cmp_q(av_inv_q(st->avg_frame_rate), st->time_base) > 0)
1235  else if( st->r_frame_rate.num > 0 && st->r_frame_rate.den > 0
1236  && av_cmp_q(av_inv_q(st->r_frame_rate), st->time_base) > 0)
1238 
1239  if (!native_id &&
1242  par->codec_id == AV_CODEC_ID_SVQ1 ||
1243  par->codec_id == AV_CODEC_ID_SVQ3 ||
1244  par->codec_id == AV_CODEC_ID_CINEPAK))
1245  qt_id = 1;
1246 
1247  if (qt_id)
1248  put_ebml_string(pb, MATROSKA_ID_CODECID, "V_QUICKTIME");
1249  else if (!native_id) {
1250  // if there is no mkv-specific codec ID, use VFW mode
1251  put_ebml_string(pb, MATROSKA_ID_CODECID, "V_MS/VFW/FOURCC");
1252  track->write_dts = 1;
1254  }
1255 
1256  subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKVIDEO, 0);
1257 
1260 
1261  mkv_write_field_order(pb, mkv->mode, par->field_order);
1262 
1263  // check both side data and metadata for stereo information,
1264  // write the result to the bitstream if any is found
1265  ret = mkv_write_stereo_mode(s, pb, st, mkv->mode,
1266  &display_width_div,
1267  &display_height_div);
1268  if (ret < 0)
1269  return ret;
1270 
1271  if (((tag = av_dict_get(st->metadata, "alpha_mode", NULL, 0)) && atoi(tag->value)) ||
1272  ((tag = av_dict_get( s->metadata, "alpha_mode", NULL, 0)) && atoi(tag->value)) ||
1273  (par->format == AV_PIX_FMT_YUVA420P)) {
1275  }
1276 
1277  // write DisplayWidth and DisplayHeight, they contain the size of
1278  // a single source view and/or the display aspect ratio
1279  if (st->sample_aspect_ratio.num) {
1280  int64_t d_width = av_rescale(par->width, st->sample_aspect_ratio.num, st->sample_aspect_ratio.den);
1281  if (d_width > INT_MAX) {
1282  av_log(s, AV_LOG_ERROR, "Overflow in display width\n");
1283  return AVERROR(EINVAL);
1284  }
1285  if (d_width != par->width || display_width_div != 1 || display_height_div != 1) {
1286  if (mkv->mode == MODE_WEBM || display_width_div != 1 || display_height_div != 1) {
1287  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH , d_width / display_width_div);
1288  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, par->height / display_height_div);
1289  } else {
1290  AVRational display_aspect_ratio;
1291  av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
1292  par->width * (int64_t)st->sample_aspect_ratio.num,
1293  par->height * (int64_t)st->sample_aspect_ratio.den,
1294  1024 * 1024);
1295  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH, display_aspect_ratio.num);
1296  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, display_aspect_ratio.den);
1298  }
1299  }
1300  } else if (display_width_div != 1 || display_height_div != 1) {
1301  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH , par->width / display_width_div);
1302  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, par->height / display_height_div);
1303  } else if (mkv->mode != MODE_WEBM)
1305 
1306  if (par->codec_id == AV_CODEC_ID_RAWVIDEO) {
1307  uint32_t color_space = av_le2ne32(par->codec_tag);
1308  put_ebml_binary(pb, MATROSKA_ID_VIDEOCOLORSPACE, &color_space, sizeof(color_space));
1309  }
1310  mkv_write_video_color(pb, st, par);
1311  mkv_write_video_projection(s, pb, st);
1312 
1313  end_ebml_master(pb, subinfo);
1314  break;
1315 
1316  case AVMEDIA_TYPE_AUDIO:
1317  if (par->initial_padding && par->codec_id == AV_CODEC_ID_OPUS) {
1318  int64_t codecdelay = av_rescale_q(par->initial_padding,
1319  (AVRational){ 1, 48000 },
1320  (AVRational){ 1, 1000000000 });
1321  if (codecdelay < 0) {
1322  av_log(s, AV_LOG_ERROR, "Initial padding is invalid\n");
1323  return AVERROR(EINVAL);
1324  }
1325 // track->ts_offset = av_rescale_q(par->initial_padding,
1326 // (AVRational){ 1, par->sample_rate },
1327 // st->time_base);
1328 
1329  put_ebml_uint(pb, MATROSKA_ID_CODECDELAY, codecdelay);
1330  }
1331  if (par->codec_id == AV_CODEC_ID_OPUS)
1333 
1335 
1336  if (!native_id)
1337  // no mkv-specific ID, use ACM mode
1338  put_ebml_string(pb, MATROSKA_ID_CODECID, "A_MS/ACM");
1339 
1340  subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKAUDIO, 6 + 4 * 9);
1342 
1343  track->sample_rate_offset = avio_tell(pb);
1344  put_ebml_float (pb, MATROSKA_ID_AUDIOSAMPLINGFREQ, sample_rate);
1345  if (output_sample_rate)
1346  put_ebml_float(pb, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate);
1347 
1348  bit_depth = av_get_bits_per_sample(par->codec_id);
1349  if (!bit_depth && par->codec_id != AV_CODEC_ID_ADPCM_G726) {
1350  if (par->bits_per_raw_sample)
1351  bit_depth = par->bits_per_raw_sample;
1352  else
1353  bit_depth = av_get_bytes_per_sample(par->format) << 3;
1354  }
1355  if (!bit_depth)
1356  bit_depth = par->bits_per_coded_sample;
1357  if (bit_depth)
1358  put_ebml_uint(pb, MATROSKA_ID_AUDIOBITDEPTH, bit_depth);
1359  end_ebml_master(pb, subinfo);
1360  break;
1361 
1362  case AVMEDIA_TYPE_SUBTITLE:
1363  if (!native_id) {
1364  av_log(s, AV_LOG_ERROR, "Subtitle codec %d is not supported.\n", par->codec_id);
1365  return AVERROR(ENOSYS);
1366  }
1369 
1370  if (mkv->mode != MODE_WEBM || par->codec_id != AV_CODEC_ID_WEBVTT)
1371  native_id = MATROSKA_TRACK_TYPE_SUBTITLE;
1372 
1373  put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, native_id);
1374  break;
1375  default:
1376  av_log(s, AV_LOG_ERROR, "Only audio, video, and subtitles are supported for Matroska.\n");
1377  return AVERROR(EINVAL);
1378  }
1379 
1380  if (mkv->mode != MODE_WEBM || par->codec_id != AV_CODEC_ID_WEBVTT) {
1381  track->codecpriv_offset = avio_tell(pb);
1382  ret = mkv_write_codecprivate(s, pb, par, native_id, qt_id);
1383  if (ret < 0)
1384  return ret;
1385  }
1386 
1387  end_ebml_master(pb, track_master);
1388 
1389  return 0;
1390 }
1391 
1393 {
1394  MatroskaMuxContext *mkv = s->priv_data;
1395  AVIOContext *pb = s->pb;
1396  int i, ret, video_default_idx, audio_default_idx, subtitle_default_idx;
1397 
1398  if (mkv->nb_attachments == s->nb_streams)
1399  return 0;
1400 
1401  ret = start_ebml_master_crc32(&mkv->track.bc, mkv);
1402  if (ret < 0)
1403  return ret;
1404 
1405  if (mkv->default_mode != DEFAULT_MODE_PASSTHROUGH) {
1406  int video_idx, audio_idx, subtitle_idx;
1407 
1408  video_idx = video_default_idx =
1409  audio_idx = audio_default_idx =
1410  subtitle_idx = subtitle_default_idx = -1;
1411 
1412  for (i = s->nb_streams - 1; i >= 0; i--) {
1413  AVStream *st = s->streams[i];
1414 
1415  switch (st->codecpar->codec_type) {
1416 #define CASE(type, variable) \
1417  case AVMEDIA_TYPE_ ## type: \
1418  variable ## _idx = i; \
1419  if (st->disposition & AV_DISPOSITION_DEFAULT) \
1420  variable ## _default_idx = i; \
1421  break;
1422  CASE(VIDEO, video)
1423  CASE(AUDIO, audio)
1424  CASE(SUBTITLE, subtitle)
1425 #undef CASE
1426  }
1427  }
1428 
1429  video_default_idx = FFMAX(video_default_idx, video_idx);
1430  audio_default_idx = FFMAX(audio_default_idx, audio_idx);
1432  subtitle_default_idx = FFMAX(subtitle_default_idx, subtitle_idx);
1433  }
1434  for (i = 0; i < s->nb_streams; i++) {
1435  AVStream *st = s->streams[i];
1436  int is_default = mkv->default_mode == DEFAULT_MODE_PASSTHROUGH ?
1438  i == video_default_idx || i == audio_default_idx ||
1439  i == subtitle_default_idx;
1440  ret = mkv_write_track(s, mkv, st, &mkv->tracks[i],
1441  mkv->track.bc, is_default);
1442  if (ret < 0)
1443  return ret;
1444  }
1445 
1446  return end_ebml_master_crc32_tentatively(pb, &mkv->track, mkv,
1448 }
1449 
1451 {
1452  uint8_t *key = av_strdup(t->key);
1453  uint8_t *p = key;
1454  const uint8_t *lang = NULL;
1455  ebml_master tag;
1456 
1457  if (!key)
1458  return AVERROR(ENOMEM);
1459 
1460  if ((p = strrchr(p, '-')) &&
1461  (lang = ff_convert_lang_to(p + 1, AV_LANG_ISO639_2_BIBL)))
1462  *p = 0;
1463 
1464  p = key;
1465  while (*p) {
1466  if (*p == ' ')
1467  *p = '_';
1468  else if (*p >= 'a' && *p <= 'z')
1469  *p -= 'a' - 'A';
1470  p++;
1471  }
1472 
1475  if (lang)
1478  end_ebml_master(pb, tag);
1479 
1480  av_freep(&key);
1481  return 0;
1482 }
1483 
1485  ebml_master *tag, uint32_t elementid, uint64_t uid)
1486 {
1488  int ret;
1489 
1490  if (!*pb) {
1491  ret = start_ebml_master_crc32(pb, mkv);
1492  if (ret < 0)
1493  return ret;
1494  }
1495 
1496  *tag = start_ebml_master(*pb, MATROSKA_ID_TAG, 0);
1497  targets = start_ebml_master(*pb, MATROSKA_ID_TAGTARGETS, 4 + 1 + 8);
1498  if (elementid)
1499  put_ebml_uid(*pb, elementid, uid);
1500  end_ebml_master(*pb, targets);
1501  return 0;
1502 }
1503 
1504 static int mkv_check_tag_name(const char *name, uint32_t elementid)
1505 {
1506  return av_strcasecmp(name, "title") &&
1507  av_strcasecmp(name, "stereo_mode") &&
1508  av_strcasecmp(name, "creation_time") &&
1509  av_strcasecmp(name, "encoding_tool") &&
1510  av_strcasecmp(name, "duration") &&
1511  (elementid != MATROSKA_ID_TAGTARGETS_TRACKUID ||
1512  av_strcasecmp(name, "language")) &&
1513  (elementid != MATROSKA_ID_TAGTARGETS_ATTACHUID ||
1514  (av_strcasecmp(name, "filename") &&
1515  av_strcasecmp(name, "mimetype")));
1516 }
1517 
1519  AVIOContext **pb, ebml_master *tag,
1520  uint32_t elementid, uint64_t uid)
1521 {
1522  const AVDictionaryEntry *t = NULL;
1523  ebml_master tag2;
1524  int ret;
1525 
1526  ret = mkv_write_tag_targets(mkv, pb, tag ? tag : &tag2, elementid, uid);
1527  if (ret < 0)
1528  return ret;
1529 
1530  while ((t = av_dict_get(m, "", t, AV_DICT_IGNORE_SUFFIX))) {
1531  if (mkv_check_tag_name(t->key, elementid)) {
1532  ret = mkv_write_simpletag(*pb, t);
1533  if (ret < 0)
1534  return ret;
1535  }
1536  }
1537 
1538  if (!tag)
1539  end_ebml_master(*pb, tag2);
1540 
1541  return 0;
1542 }
1543 
1544 static int mkv_check_tag(const AVDictionary *m, uint32_t elementid)
1545 {
1546  const AVDictionaryEntry *t = NULL;
1547 
1548  while ((t = av_dict_get(m, "", t, AV_DICT_IGNORE_SUFFIX)))
1549  if (mkv_check_tag_name(t->key, elementid))
1550  return 1;
1551 
1552  return 0;
1553 }
1554 
1556 {
1557  MatroskaMuxContext *mkv = s->priv_data;
1558  ebml_master tag, *tagp = IS_SEEKABLE(s->pb, mkv) ? &tag : NULL;
1559  int i, ret;
1560 
1561  mkv->wrote_tags = 1;
1562 
1564 
1565  if (mkv_check_tag(s->metadata, 0)) {
1566  ret = mkv_write_tag(mkv, s->metadata, &mkv->tags.bc, NULL, 0, 0);
1567  if (ret < 0)
1568  return ret;
1569  }
1570 
1571  for (i = 0; i < s->nb_streams; i++) {
1572  const AVStream *st = s->streams[i];
1573  mkv_track *track = &mkv->tracks[i];
1574 
1576  continue;
1577 
1579  continue;
1580 
1581  ret = mkv_write_tag(mkv, st->metadata, &mkv->tags.bc, tagp,
1583  if (ret < 0)
1584  return ret;
1585 
1586  if (tagp) {
1587  AVIOContext *pb = mkv->tags.bc;
1588  ebml_master simpletag;
1589 
1590  simpletag = start_ebml_master(pb, MATROSKA_ID_SIMPLETAG,
1591  2 + 1 + 8 + 23);
1592  put_ebml_string(pb, MATROSKA_ID_TAGNAME, "DURATION");
1593  track->duration_offset = avio_tell(pb);
1594 
1595  // Reserve space to write duration as a 20-byte string.
1596  // 2 (ebml id) + 1 (data size) + 20 (data)
1597  put_ebml_void(pb, 23);
1598  end_ebml_master(pb, simpletag);
1599  end_ebml_master(pb, tag);
1600  }
1601  }
1602 
1603  if (mkv->nb_attachments && mkv->mode != MODE_WEBM) {
1604  for (i = 0; i < s->nb_streams; i++) {
1605  const mkv_track *track = &mkv->tracks[i];
1606  const AVStream *st = s->streams[i];
1607 
1609  continue;
1610 
1612  continue;
1613 
1614  ret = mkv_write_tag(mkv, st->metadata, &mkv->tags.bc, NULL,
1616  if (ret < 0)
1617  return ret;
1618  }
1619  }
1620 
1621  if (mkv->tags.bc) {
1622  return end_ebml_master_crc32_tentatively(s->pb, &mkv->tags, mkv,
1624  }
1625  return 0;
1626 }
1627 
1629 {
1630  for (unsigned i = 0; i < s->nb_chapters; i++) {
1631  if (!s->chapters[i]->id)
1632  return 1;
1633  for (unsigned j = 0; j < i; j++)
1634  if (s->chapters[j]->id == s->chapters[i]->id)
1635  return 1;
1636  }
1637  return 0;
1638 }
1639 
1641 {
1642  MatroskaMuxContext *mkv = s->priv_data;
1643  AVIOContext *dyn_cp = NULL, *dyn_tags = NULL, **tags, *pb = s->pb;
1644  ebml_master editionentry;
1645  AVRational scale = {1, 1E9};
1646  int ret, create_new_ids;
1647 
1648  if (!s->nb_chapters || mkv->wrote_chapters)
1649  return 0;
1650 
1651  ret = start_ebml_master_crc32(&dyn_cp, mkv);
1652  if (ret < 0)
1653  return ret;
1654 
1655  editionentry = start_ebml_master(dyn_cp, MATROSKA_ID_EDITIONENTRY, 0);
1656  if (mkv->mode != MODE_WEBM) {
1658  /* If mkv_write_tags() has already been called, then any tags
1659  * corresponding to chapters will be put into a new Tags element. */
1660  tags = mkv->wrote_tags ? &dyn_tags : &mkv->tags.bc;
1661  } else
1662  tags = NULL;
1663 
1664  create_new_ids = mkv_new_chapter_ids_needed(s);
1665 
1666  for (unsigned i = 0; i < s->nb_chapters; i++) {
1667  ebml_master chapteratom, chapterdisplay;
1668  const AVChapter *c = s->chapters[i];
1669  int64_t chapterstart = av_rescale_q(c->start, c->time_base, scale);
1670  int64_t chapterend = av_rescale_q(c->end, c->time_base, scale);
1671  const AVDictionaryEntry *t;
1672 #if FF_API_CHAPTER_ID_INT
1673  uint64_t uid = create_new_ids ? i + 1ULL : (uint32_t)c->id;
1674 #else
1675  uint64_t uid = create_new_ids ? i + 1ULL : c->id;
1676 #endif
1677  if (chapterstart < 0 || chapterstart > chapterend || chapterend < 0) {
1678  av_log(s, AV_LOG_ERROR,
1679  "Invalid chapter start (%"PRId64") or end (%"PRId64").\n",
1680  chapterstart, chapterend);
1681  ret = AVERROR_INVALIDDATA;
1682  goto fail;
1683  }
1684 
1685  chapteratom = start_ebml_master(dyn_cp, MATROSKA_ID_CHAPTERATOM, 0);
1686  put_ebml_uint(dyn_cp, MATROSKA_ID_CHAPTERUID, uid);
1687  put_ebml_uint(dyn_cp, MATROSKA_ID_CHAPTERTIMESTART, chapterstart);
1688  put_ebml_uint(dyn_cp, MATROSKA_ID_CHAPTERTIMEEND, chapterend);
1689  if ((t = av_dict_get(c->metadata, "title", NULL, 0))) {
1690  chapterdisplay = start_ebml_master(dyn_cp, MATROSKA_ID_CHAPTERDISPLAY, 0);
1692  put_ebml_string(dyn_cp, MATROSKA_ID_CHAPLANG , "und");
1693  end_ebml_master(dyn_cp, chapterdisplay);
1694  }
1695  end_ebml_master(dyn_cp, chapteratom);
1696 
1698  ret = mkv_write_tag(mkv, c->metadata, tags, NULL,
1700  if (ret < 0)
1701  goto fail;
1702  }
1703  }
1704  end_ebml_master(dyn_cp, editionentry);
1705  mkv->wrote_chapters = 1;
1706 
1707  ret = end_ebml_master_crc32(pb, &dyn_cp, mkv, MATROSKA_ID_CHAPTERS, 0, 0, 1);
1708  if (ret < 0)
1709  goto fail;
1710  if (dyn_tags)
1711  return end_ebml_master_crc32(pb, &dyn_tags, mkv,
1712  MATROSKA_ID_TAGS, 0, 0, 1);
1713  return 0;
1714 
1715 fail:
1716  if (tags) {
1717  /* tags == &mkv->tags.bc can only happen if mkv->tags.bc was
1718  * initially NULL, so we never free older tags. */
1719  ffio_free_dyn_buf(tags);
1720  }
1721  ffio_free_dyn_buf(&dyn_cp);
1722  return ret;
1723 }
1724 
1725 static const char *get_mimetype(const AVStream *st)
1726 {
1727  const AVDictionaryEntry *t;
1728 
1729  if (t = av_dict_get(st->metadata, "mimetype", NULL, 0))
1730  return t->value;
1731  if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
1733  if (desc && desc->mime_types) {
1734  return desc->mime_types[0];
1735  } else if (st->codecpar->codec_id == AV_CODEC_ID_TEXT)
1736  return "text/plain";
1737  }
1738 
1739  return NULL;
1740 }
1741 
1743 {
1744  MatroskaMuxContext *mkv = s->priv_data;
1745  AVIOContext *dyn_cp = NULL, *pb = s->pb;
1746  int i, ret;
1747 
1748  if (!mkv->nb_attachments)
1749  return 0;
1750 
1751  ret = start_ebml_master_crc32(&dyn_cp, mkv);
1752  if (ret < 0)
1753  return ret;
1754 
1755  for (i = 0; i < s->nb_streams; i++) {
1756  const AVStream *st = s->streams[i];
1757  mkv_track *track = &mkv->tracks[i];
1758  ebml_master attached_file;
1759  const AVDictionaryEntry *t;
1760  const char *mimetype;
1761 
1763  continue;
1764 
1765  attached_file = start_ebml_master(dyn_cp, MATROSKA_ID_ATTACHEDFILE, 0);
1766 
1767  if (t = av_dict_get(st->metadata, "title", NULL, 0))
1769  if (!(t = av_dict_get(st->metadata, "filename", NULL, 0))) {
1770  av_log(s, AV_LOG_ERROR, "Attachment stream %d has no filename tag.\n", i);
1771  ffio_free_dyn_buf(&dyn_cp);
1772  return AVERROR(EINVAL);
1773  }
1775 
1776  mimetype = get_mimetype(st);
1777  av_assert0(mimetype);
1778  put_ebml_string(dyn_cp, MATROSKA_ID_FILEMIMETYPE, mimetype);
1780  put_ebml_uid(dyn_cp, MATROSKA_ID_FILEUID, track->uid);
1781  end_ebml_master(dyn_cp, attached_file);
1782  }
1783  return end_ebml_master_crc32(pb, &dyn_cp, mkv,
1784  MATROSKA_ID_ATTACHMENTS, 0, 0, 1);
1785 }
1786 
1788 {
1789  const AVDictionaryEntry *duration = av_dict_get(s->metadata, "DURATION",
1790  NULL, 0);
1791  int64_t max = 0;
1792  int64_t us;
1793 
1794  if (duration && (av_parse_time(&us, duration->value, 1) == 0) && us > 0) {
1795  av_log(s, AV_LOG_DEBUG, "get_metadata_duration found duration in context metadata: %" PRId64 "\n", us);
1796  return us;
1797  }
1798 
1799  for (unsigned i = 0; i < s->nb_streams; i++) {
1800  int64_t us;
1801  duration = av_dict_get(s->streams[i]->metadata, "DURATION", NULL, 0);
1802 
1803  if (duration && (av_parse_time(&us, duration->value, 1) == 0))
1804  max = FFMAX(max, us);
1805  }
1806 
1807  av_log(s, AV_LOG_DEBUG, "get_metadata_duration returned: %" PRId64 "\n", max);
1808  return max;
1809 }
1810 
1812 {
1813  MatroskaMuxContext *mkv = s->priv_data;
1814  AVIOContext *pb = s->pb;
1816  const AVDictionaryEntry *tag;
1817  int ret, i, version = 2;
1818  int64_t creation_time;
1819 
1820  if (mkv->mode != MODE_WEBM ||
1821  av_dict_get(s->metadata, "stereo_mode", NULL, 0) ||
1822  av_dict_get(s->metadata, "alpha_mode", NULL, 0))
1823  version = 4;
1824 
1825  for (i = 0; i < s->nb_streams; i++) {
1826  if (s->streams[i]->codecpar->codec_id == AV_CODEC_ID_OPUS ||
1827  av_dict_get(s->streams[i]->metadata, "stereo_mode", NULL, 0) ||
1828  av_dict_get(s->streams[i]->metadata, "alpha_mode", NULL, 0))
1829  version = 4;
1830  }
1831 
1838  put_ebml_uint (pb, EBML_ID_DOCTYPEVERSION , version);
1840  end_ebml_master(pb, ebml_header);
1841 
1843  put_ebml_size_unknown(pb, 8);
1844  mkv->segment_offset = avio_tell(pb);
1845 
1846  // We write a SeekHead at the beginning to point to all other level
1847  // one elements (except Clusters).
1848  mkv_start_seekhead(mkv, pb);
1849 
1850  ret = start_ebml_master_crc32(&mkv->info.bc, mkv);
1851  if (ret < 0)
1852  return ret;
1853  pb = mkv->info.bc;
1854 
1856  if ((tag = av_dict_get(s->metadata, "title", NULL, 0)))
1858  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
1860  if ((tag = av_dict_get(s->metadata, "encoding_tool", NULL, 0)))
1862  else
1864 
1865  if (mkv->mode != MODE_WEBM)
1867  } else {
1868  const char *ident = "Lavf";
1871  }
1872 
1873  if (ff_parse_creation_time_metadata(s, &creation_time, 0) > 0) {
1874  // Adjust time so it's relative to 2001-01-01 and convert to nanoseconds.
1875  int64_t date_utc = (creation_time - 978307200000000LL) * 1000;
1876  uint8_t date_utc_buf[8];
1877  AV_WB64(date_utc_buf, date_utc);
1878  put_ebml_binary(pb, MATROSKA_ID_DATEUTC, date_utc_buf, 8);
1879  }
1880 
1881  // reserve space for the duration
1882  mkv->duration = 0;
1883  mkv->duration_offset = avio_tell(pb);
1884  if (!mkv->is_live) {
1885  int64_t metadata_duration = get_metadata_duration(s);
1886 
1887  if (s->duration > 0) {
1888  int64_t scaledDuration = av_rescale(s->duration, 1000, AV_TIME_BASE);
1889  put_ebml_float(pb, MATROSKA_ID_DURATION, scaledDuration);
1890  av_log(s, AV_LOG_DEBUG, "Write early duration from recording time = %" PRIu64 "\n", scaledDuration);
1891  } else if (metadata_duration > 0) {
1892  int64_t scaledDuration = av_rescale(metadata_duration, 1000, AV_TIME_BASE);
1893  put_ebml_float(pb, MATROSKA_ID_DURATION, scaledDuration);
1894  av_log(s, AV_LOG_DEBUG, "Write early duration from metadata = %" PRIu64 "\n", scaledDuration);
1895  } else if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
1896  put_ebml_void(pb, 11); // assumes double-precision float to be written
1897  }
1898  }
1899  ret = end_ebml_master_crc32_tentatively(s->pb, &mkv->info,
1900  mkv, MATROSKA_ID_INFO);
1901  if (ret < 0)
1902  return ret;
1903  pb = s->pb;
1904 
1905  ret = mkv_write_tracks(s);
1906  if (ret < 0)
1907  return ret;
1908 
1909  ret = mkv_write_chapters(s);
1910  if (ret < 0)
1911  return ret;
1912 
1913  if (mkv->mode != MODE_WEBM) {
1914  ret = mkv_write_attachments(s);
1915  if (ret < 0)
1916  return ret;
1917  }
1918 
1919  /* Must come after mkv_write_chapters() to write chapter tags
1920  * into the same Tags element as the other tags. */
1921  ret = mkv_write_tags(s);
1922  if (ret < 0)
1923  return ret;
1924 
1925  if (!IS_SEEKABLE(pb, mkv)) {
1926  ret = mkv_write_seekhead(pb, mkv, 0, avio_tell(pb));
1927  if (ret < 0)
1928  return ret;
1929  }
1930 
1931  if (s->metadata_header_padding > 0) {
1932  if (s->metadata_header_padding == 1)
1935  }
1936 
1937  if (mkv->reserve_cues_space) {
1938  if (IS_SEEKABLE(pb, mkv)) {
1939  mkv->cues_pos = avio_tell(pb);
1940  if (mkv->reserve_cues_space == 1)
1941  mkv->reserve_cues_space++;
1943  } else
1944  mkv->reserve_cues_space = -1;
1945  }
1946 
1947  mkv->cluster_pos = -1;
1948 
1949  // start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or
1950  // after 4k and on a keyframe
1951  if (IS_SEEKABLE(pb, mkv)) {
1952  if (mkv->cluster_time_limit < 0)
1953  mkv->cluster_time_limit = 5000;
1954  if (mkv->cluster_size_limit < 0)
1955  mkv->cluster_size_limit = 5 * 1024 * 1024;
1956  } else {
1957  if (mkv->cluster_time_limit < 0)
1958  mkv->cluster_time_limit = 1000;
1959  if (mkv->cluster_size_limit < 0)
1960  mkv->cluster_size_limit = 32 * 1024;
1961  }
1962 
1963  return 0;
1964 }
1965 
1966 static int mkv_blockgroup_size(int pkt_size, int track_num_size)
1967 {
1968  int size = pkt_size + track_num_size + 3;
1969  size += ebml_length_size(size);
1970  size += 2; // EBML ID for block and block duration
1971  size += 9; // max size of block duration incl. length field
1972  return size;
1973 }
1974 
1975 static int mkv_strip_wavpack(const uint8_t *src, uint8_t **pdst, int *size)
1976 {
1977  uint8_t *dst;
1978  int srclen = *size;
1979  int offset = 0;
1980  int ret;
1981 
1982  dst = av_malloc(srclen);
1983  if (!dst)
1984  return AVERROR(ENOMEM);
1985 
1986  while (srclen >= WV_HEADER_SIZE) {
1987  WvHeader header;
1988 
1989  ret = ff_wv_parse_header(&header, src);
1990  if (ret < 0)
1991  goto fail;
1992  src += WV_HEADER_SIZE;
1993  srclen -= WV_HEADER_SIZE;
1994 
1995  if (srclen < header.blocksize) {
1996  ret = AVERROR_INVALIDDATA;
1997  goto fail;
1998  }
1999 
2000  if (header.initial) {
2001  AV_WL32(dst + offset, header.samples);
2002  offset += 4;
2003  }
2004  AV_WL32(dst + offset, header.flags);
2005  AV_WL32(dst + offset + 4, header.crc);
2006  offset += 8;
2007 
2008  if (!(header.initial && header.final)) {
2009  AV_WL32(dst + offset, header.blocksize);
2010  offset += 4;
2011  }
2012 
2013  memcpy(dst + offset, src, header.blocksize);
2014  src += header.blocksize;
2015  srclen -= header.blocksize;
2016  offset += header.blocksize;
2017  }
2018 
2019  *pdst = dst;
2020  *size = offset;
2021 
2022  return 0;
2023 fail:
2024  av_freep(&dst);
2025  return ret;
2026 }
2027 
2029  uint32_t blockid, const AVPacket *pkt, int keyframe)
2030 {
2031  MatroskaMuxContext *mkv = s->priv_data;
2033  mkv_track *track = &mkv->tracks[pkt->stream_index];
2034  uint8_t *data = NULL, *side_data = NULL;
2035  buffer_size_t side_data_size;
2036  int err = 0, offset = 0, size = pkt->size;
2037  int64_t ts = track->write_dts ? pkt->dts : pkt->pts;
2038  uint64_t additional_id;
2039  int64_t discard_padding = 0;
2040  unsigned track_number = track->track_num;
2041  ebml_master block_group, block_additions, block_more;
2042 
2043  ts += track->ts_offset;
2044 
2045  /* The following string is identical to the one in mkv_write_vtt_blocks
2046  * so that only one copy needs to exist in binaries. */
2047  av_log(s, AV_LOG_DEBUG,
2048  "Writing block of size %d with pts %" PRId64 ", dts %" PRId64 ", "
2049  "duration %" PRId64 " at relative offset %" PRId64 " in cluster "
2050  "at offset %" PRId64 ". TrackNumber %u, keyframe %d\n",
2051  pkt->size, pkt->pts, pkt->dts, pkt->duration, avio_tell(pb),
2052  mkv->cluster_pos, track_number, keyframe != 0);
2053 
2054  if (par->codec_id == AV_CODEC_ID_H264 && par->extradata_size > 0 &&
2055  (AV_RB24(par->extradata) == 1 || AV_RB32(par->extradata) == 1)) {
2056  err = ff_avc_parse_nal_units_buf(pkt->data, &data, &size);
2057  } else if (par->codec_id == AV_CODEC_ID_HEVC && par->extradata_size > 6 &&
2058  (AV_RB24(par->extradata) == 1 || AV_RB32(par->extradata) == 1)) {
2059  /* extradata is Annex B, assume the bitstream is too and convert it */
2060  err = ff_hevc_annexb2mp4_buf(pkt->data, &data, &size, 0, NULL);
2061  } else if (par->codec_id == AV_CODEC_ID_AV1) {
2062  err = ff_av1_filter_obus_buf(pkt->data, &data, &size, &offset);
2063  } else if (par->codec_id == AV_CODEC_ID_WAVPACK) {
2064  err = mkv_strip_wavpack(pkt->data, &data, &size);
2065  } else
2066  data = pkt->data;
2067 
2068  if (err < 0) {
2069  av_log(s, AV_LOG_ERROR, "Error when reformatting data of "
2070  "a packet from stream %d.\n", pkt->stream_index);
2071  return err;
2072  }
2073 
2074  if (par->codec_id == AV_CODEC_ID_PRORES && size >= 8) {
2075  /* Matroska specification requires to remove the first QuickTime atom
2076  */
2077  size -= 8;
2078  offset = 8;
2079  }
2080 
2081  side_data = av_packet_get_side_data(pkt,
2083  &side_data_size);
2084  if (side_data && side_data_size >= 10) {
2085  discard_padding = av_rescale_q(AV_RL32(side_data + 4),
2086  (AVRational){1, par->sample_rate},
2087  (AVRational){1, 1000000000});
2088  }
2089 
2090  side_data = av_packet_get_side_data(pkt,
2092  &side_data_size);
2093  if (side_data) {
2094  // Only the Codec-specific BlockMore (id == 1) is currently supported.
2095  if (side_data_size < 8 || (additional_id = AV_RB64(side_data)) != 1) {
2096  side_data_size = 0;
2097  } else {
2098  side_data += 8;
2099  side_data_size -= 8;
2100  }
2101  }
2102 
2103  if (side_data_size || discard_padding) {
2104  block_group = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, 0);
2105  blockid = MATROSKA_ID_BLOCK;
2106  }
2107 
2108  put_ebml_id(pb, blockid);
2109  put_ebml_length(pb, size + track->track_num_size + 3, 0);
2110  put_ebml_num(pb, track_number, track->track_num_size);
2111  avio_wb16(pb, ts - mkv->cluster_pts);
2112  avio_w8(pb, (blockid == MATROSKA_ID_SIMPLEBLOCK && keyframe) ? (1 << 7) : 0);
2113  avio_write(pb, data + offset, size);
2114  if (data != pkt->data)
2115  av_free(data);
2116 
2117  if (blockid == MATROSKA_ID_BLOCK && !keyframe)
2119  track->last_timestamp = ts;
2120 
2121  if (discard_padding)
2122  put_ebml_sint(pb, MATROSKA_ID_DISCARDPADDING, discard_padding);
2123 
2124  if (side_data_size) {
2125  block_additions = start_ebml_master(pb, MATROSKA_ID_BLOCKADDITIONS, 0);
2126  block_more = start_ebml_master(pb, MATROSKA_ID_BLOCKMORE, 0);
2127  /* Until dbc50f8a our demuxer used a wrong default value
2128  * of BlockAddID, so we write it unconditionally. */
2129  put_ebml_uint (pb, MATROSKA_ID_BLOCKADDID, additional_id);
2131  side_data, side_data_size);
2132  end_ebml_master(pb, block_more);
2133  end_ebml_master(pb, block_additions);
2134  }
2135  if (side_data_size || discard_padding)
2136  end_ebml_master(pb, block_group);
2137 
2138  return 0;
2139 }
2140 
2142 {
2143  MatroskaMuxContext *mkv = s->priv_data;
2144  mkv_track *track = &mkv->tracks[pkt->stream_index];
2145  ebml_master blockgroup;
2146  buffer_size_t id_size, settings_size;
2147  int size, id_size_int, settings_size_int;
2148  const char *id, *settings;
2149  int64_t ts = track->write_dts ? pkt->dts : pkt->pts;
2150  const int flags = 0;
2151 
2153  &id_size);
2154  id = id ? id : "";
2155 
2157  &settings_size);
2158  settings = settings ? settings : "";
2159 
2160  if (id_size > INT_MAX - 2 || settings_size > INT_MAX - id_size - 2 ||
2161  pkt->size > INT_MAX - settings_size - id_size - 2)
2162  return AVERROR(EINVAL);
2163 
2164  size = id_size + 1 + settings_size + 1 + pkt->size;
2165 
2166  /* The following string is identical to the one in mkv_write_block so that
2167  * only one copy needs to exist in binaries. */
2168  av_log(s, AV_LOG_DEBUG,
2169  "Writing block of size %d with pts %" PRId64 ", dts %" PRId64 ", "
2170  "duration %" PRId64 " at relative offset %" PRId64 " in cluster "
2171  "at offset %" PRId64 ". TrackNumber %u, keyframe %d\n",
2172  size, pkt->pts, pkt->dts, pkt->duration, avio_tell(pb),
2173  mkv->cluster_pos, track->track_num, 1);
2174 
2175  blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP,
2176  mkv_blockgroup_size(size, track->track_num_size));
2177 
2179  put_ebml_length(pb, size + track->track_num_size + 3, 0);
2180  put_ebml_num(pb, track->track_num, track->track_num_size);
2181  avio_wb16(pb, ts - mkv->cluster_pts);
2182  avio_w8(pb, flags);
2183 
2184  id_size_int = id_size;
2185  settings_size_int = settings_size;
2186  avio_printf(pb, "%.*s\n%.*s\n%.*s", id_size_int, id, settings_size_int, settings, pkt->size, pkt->data);
2187 
2189  end_ebml_master(pb, blockgroup);
2190 
2191  return 0;
2192 }
2193 
2195 {
2196  MatroskaMuxContext *mkv = s->priv_data;
2197  int ret;
2198 
2199  if (!mkv->have_video) {
2200  for (unsigned i = 0; i < s->nb_streams; i++)
2201  mkv->tracks[i].has_cue = 0;
2202  }
2203  mkv->cluster_pos = -1;
2204  ret = end_ebml_master_crc32(s->pb, &mkv->cluster_bc, mkv,
2205  MATROSKA_ID_CLUSTER, 0, 1, 0);
2206  if (ret < 0)
2207  return ret;
2208 
2210  return 0;
2211 }
2212 
2214 {
2215  MatroskaMuxContext *mkv = s->priv_data;
2216  mkv_track *track = &mkv->tracks[pkt->stream_index];
2218  uint8_t *side_data;
2219  buffer_size_t side_data_size;
2220  int ret;
2221 
2223  &side_data_size);
2224 
2225  switch (par->codec_id) {
2226  case AV_CODEC_ID_AAC:
2227  if (side_data_size && mkv->track.bc) {
2228  int filler, output_sample_rate = 0;
2229  ret = get_aac_sample_rates(s, mkv, side_data, side_data_size,
2230  &track->sample_rate, &output_sample_rate);
2231  if (ret < 0)
2232  return ret;
2233  if (!output_sample_rate)
2234  output_sample_rate = track->sample_rate; // Space is already reserved, so it's this or a void element.
2235  ret = ff_alloc_extradata(par, side_data_size);
2236  if (ret < 0)
2237  return ret;
2238  memcpy(par->extradata, side_data, side_data_size);
2239  avio_seek(mkv->track.bc, track->codecpriv_offset, SEEK_SET);
2240  mkv_write_codecprivate(s, mkv->track.bc, par, 1, 0);
2241  filler = MAX_PCE_SIZE + 2 + 4 - (avio_tell(mkv->track.bc) - track->codecpriv_offset);
2242  if (filler)
2243  put_ebml_void(mkv->track.bc, filler);
2244  avio_seek(mkv->track.bc, track->sample_rate_offset, SEEK_SET);
2246  put_ebml_float(mkv->track.bc, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate);
2247  } else if (!par->extradata_size && !track->sample_rate) {
2248  // No extradata (codecpar or packet side data).
2249  av_log(s, AV_LOG_ERROR, "Error parsing AAC extradata, unable to determine samplerate.\n");
2250  return AVERROR(EINVAL);
2251  }
2252  break;
2253  case AV_CODEC_ID_FLAC:
2254  if (side_data_size && mkv->track.bc) {
2255  uint8_t *old_extradata = par->extradata;
2256  if (side_data_size != par->extradata_size) {
2257  av_log(s, AV_LOG_ERROR, "Invalid FLAC STREAMINFO metadata for output stream %d\n",
2258  pkt->stream_index);
2259  return AVERROR(EINVAL);
2260  }
2261  par->extradata = side_data;
2262  avio_seek(mkv->track.bc, track->codecpriv_offset, SEEK_SET);
2263  mkv_write_codecprivate(s, mkv->track.bc, par, 1, 0);
2264  par->extradata = old_extradata;
2265  }
2266  break;
2267  // FIXME: Remove the following once libaom starts propagating extradata during init()
2268  // See https://bugs.chromium.org/p/aomedia/issues/detail?id=2012
2269  case AV_CODEC_ID_AV1:
2270  if (side_data_size && mkv->track.bc && !par->extradata_size) {
2271  AVIOContext *dyn_cp;
2272  uint8_t *codecpriv;
2273  int codecpriv_size;
2274  ret = avio_open_dyn_buf(&dyn_cp);
2275  if (ret < 0)
2276  return ret;
2277  ff_isom_write_av1c(dyn_cp, side_data, side_data_size);
2278  codecpriv_size = avio_get_dyn_buf(dyn_cp, &codecpriv);
2279  if ((ret = dyn_cp->error) < 0 ||
2280  !codecpriv_size && (ret = AVERROR_INVALIDDATA)) {
2281  ffio_free_dyn_buf(&dyn_cp);
2282  return ret;
2283  }
2284  avio_seek(mkv->track.bc, track->codecpriv_offset, SEEK_SET);
2285  // Do not write the OBUs as we don't have space saved for them
2286  put_ebml_binary(mkv->track.bc, MATROSKA_ID_CODECPRIVATE, codecpriv, 4);
2287  ffio_free_dyn_buf(&dyn_cp);
2288  ret = ff_alloc_extradata(par, side_data_size);
2289  if (ret < 0)
2290  return ret;
2291  memcpy(par->extradata, side_data, side_data_size);
2292  } else if (!par->extradata_size)
2293  return AVERROR_INVALIDDATA;
2294  break;
2295  default:
2296  if (side_data_size)
2297  av_log(s, AV_LOG_DEBUG, "Ignoring new extradata in a packet for stream %d.\n", pkt->stream_index);
2298  break;
2299  }
2300 
2301  return 0;
2302 }
2303 
2305 {
2306  MatroskaMuxContext *mkv = s->priv_data;
2307  AVIOContext *pb;
2309  mkv_track *track = &mkv->tracks[pkt->stream_index];
2310  int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
2311  int64_t duration = pkt->duration;
2312  int ret;
2313  int64_t ts = track->write_dts ? pkt->dts : pkt->pts;
2314  int64_t relative_packet_pos;
2315 
2316  if (ts == AV_NOPTS_VALUE) {
2317  av_log(s, AV_LOG_ERROR, "Can't write packet with unknown timestamp\n");
2318  return AVERROR(EINVAL);
2319  }
2320  ts += track->ts_offset;
2321 
2322  if (mkv->cluster_pos != -1) {
2323  int64_t cluster_time = ts - mkv->cluster_pts;
2324  if ((int16_t)cluster_time != cluster_time) {
2325  ret = mkv_end_cluster(s);
2326  if (ret < 0)
2327  return ret;
2328  av_log(s, AV_LOG_WARNING, "Starting new cluster due to timestamp\n");
2329  }
2330  }
2331 
2332  if (mkv->cluster_pos == -1) {
2333  ret = start_ebml_master_crc32(&mkv->cluster_bc, mkv);
2334  if (ret < 0)
2335  return ret;
2336  mkv->cluster_pos = avio_tell(s->pb);
2338  mkv->cluster_pts = FFMAX(0, ts);
2339  av_log(s, AV_LOG_DEBUG,
2340  "Starting new cluster with timestamp "
2341  "%" PRId64 " at offset %" PRId64 " bytes\n",
2342  mkv->cluster_pts, mkv->cluster_pos);
2343  }
2344  pb = mkv->cluster_bc;
2345 
2346  relative_packet_pos = avio_tell(pb);
2347 
2348  if (par->codec_type != AVMEDIA_TYPE_SUBTITLE ||
2349  (par->codec_id != AV_CODEC_ID_WEBVTT && duration <= 0)) {
2350  ret = mkv_write_block(s, pb, MATROSKA_ID_SIMPLEBLOCK, pkt, keyframe);
2351  if (ret < 0)
2352  return ret;
2353  if (keyframe && IS_SEEKABLE(s->pb, mkv) &&
2354  (par->codec_type == AVMEDIA_TYPE_VIDEO ||
2356  !mkv->have_video && !track->has_cue)) {
2357  ret = mkv_add_cuepoint(mkv, pkt->stream_index, ts,
2358  mkv->cluster_pos, relative_packet_pos, 0);
2359  if (ret < 0)
2360  return ret;
2361  track->has_cue = 1;
2362  }
2363  } else {
2364  if (par->codec_id == AV_CODEC_ID_WEBVTT) {
2365  ret = mkv_write_vtt_blocks(s, pb, pkt);
2366  if (ret < 0)
2367  return ret;
2368  } else {
2371  track->track_num_size));
2372 
2373 #if FF_API_CONVERGENCE_DURATION
2375  /* For backward compatibility, prefer convergence_duration. */
2376  if (pkt->convergence_duration > 0) {
2377  duration = pkt->convergence_duration;
2378  }
2380 #endif
2381  /* All subtitle blocks are considered to be keyframes. */
2382  mkv_write_block(s, pb, MATROSKA_ID_BLOCK, pkt, 1);
2384  end_ebml_master(pb, blockgroup);
2385  }
2386 
2387  if (IS_SEEKABLE(s->pb, mkv)) {
2388  ret = mkv_add_cuepoint(mkv, pkt->stream_index, ts,
2389  mkv->cluster_pos, relative_packet_pos, duration);
2390  if (ret < 0)
2391  return ret;
2392  }
2393  }
2394 
2395  mkv->duration = FFMAX(mkv->duration, ts + duration);
2396  track->duration = FFMAX(track->duration, ts + duration);
2397 
2398  return 0;
2399 }
2400 
2402 {
2403  MatroskaMuxContext *mkv = s->priv_data;
2405  int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
2406  int cluster_size;
2407  int64_t cluster_time;
2408  int ret;
2409  int start_new_cluster;
2410 
2411  ret = mkv_check_new_extra_data(s, pkt);
2412  if (ret < 0)
2413  return ret;
2414 
2415  if (mkv->cluster_pos != -1) {
2416  if (mkv->tracks[pkt->stream_index].write_dts)
2417  cluster_time = pkt->dts - mkv->cluster_pts;
2418  else
2419  cluster_time = pkt->pts - mkv->cluster_pts;
2420  cluster_time += mkv->tracks[pkt->stream_index].ts_offset;
2421 
2422  cluster_size = avio_tell(mkv->cluster_bc);
2423 
2424  if (mkv->is_dash && codec_type == AVMEDIA_TYPE_VIDEO) {
2425  // WebM DASH specification states that the first block of
2426  // every Cluster has to be a key frame. So for DASH video,
2427  // we only create a Cluster on seeing key frames.
2428  start_new_cluster = keyframe;
2429  } else if (mkv->is_dash && codec_type == AVMEDIA_TYPE_AUDIO &&
2430  cluster_time > mkv->cluster_time_limit) {
2431  // For DASH audio, we create a Cluster based on cluster_time_limit.
2432  start_new_cluster = 1;
2433  } else if (!mkv->is_dash &&
2434  (cluster_size > mkv->cluster_size_limit ||
2435  cluster_time > mkv->cluster_time_limit ||
2436  (codec_type == AVMEDIA_TYPE_VIDEO && keyframe &&
2437  cluster_size > 4 * 1024))) {
2438  start_new_cluster = 1;
2439  } else
2440  start_new_cluster = 0;
2441 
2442  if (start_new_cluster) {
2443  ret = mkv_end_cluster(s);
2444  if (ret < 0)
2445  return ret;
2446  }
2447  }
2448 
2449  if (!mkv->cluster_pos)
2450  avio_write_marker(s->pb,
2453 
2454  // check if we have an audio packet cached
2455  if (mkv->cur_audio_pkt->size > 0) {
2458  if (ret < 0) {
2459  av_log(s, AV_LOG_ERROR,
2460  "Could not write cached audio packet ret:%d\n", ret);
2461  return ret;
2462  }
2463  }
2464 
2465  // buffer an audio packet to ensure the packet containing the video
2466  // keyframe's timecode is contained in the same cluster for WebM
2467  if (codec_type == AVMEDIA_TYPE_AUDIO) {
2468  if (pkt->size > 0)
2469  ret = av_packet_ref(mkv->cur_audio_pkt, pkt);
2470  } else
2471  ret = mkv_write_packet_internal(s, pkt);
2472  return ret;
2473 }
2474 
2476 {
2477  MatroskaMuxContext *mkv = s->priv_data;
2478 
2479  if (!pkt) {
2480  if (mkv->cluster_pos != -1) {
2481  int ret = mkv_end_cluster(s);
2482  if (ret < 0)
2483  return ret;
2484  av_log(s, AV_LOG_DEBUG,
2485  "Flushing cluster at offset %" PRIu64 " bytes\n",
2486  avio_tell(s->pb));
2487  }
2488  return 1;
2489  }
2490  return mkv_write_packet(s, pkt);
2491 }
2492 
2494 {
2495  MatroskaMuxContext *mkv = s->priv_data;
2496  AVIOContext *pb = s->pb;
2497  int64_t endpos, ret64;
2498  int ret, ret2 = 0;
2499 
2500  // check if we have an audio packet cached
2501  if (mkv->cur_audio_pkt->size > 0) {
2503  if (ret < 0) {
2504  av_log(s, AV_LOG_ERROR,
2505  "Could not write cached audio packet ret:%d\n", ret);
2506  return ret;
2507  }
2508  }
2509 
2510  if (mkv->cluster_pos != -1) {
2511  ret = end_ebml_master_crc32(pb, &mkv->cluster_bc, mkv,
2512  MATROSKA_ID_CLUSTER, 0, 0, 0);
2513  if (ret < 0)
2514  return ret;
2515  }
2516 
2517  ret = mkv_write_chapters(s);
2518  if (ret < 0)
2519  return ret;
2520 
2521  if (!IS_SEEKABLE(pb, mkv))
2522  return 0;
2523 
2524  endpos = avio_tell(pb);
2525 
2526  if (mkv->cues.num_entries && mkv->reserve_cues_space >= 0) {
2527  AVIOContext *cues = NULL;
2528  uint64_t size;
2529  int length_size = 0;
2530 
2531  ret = start_ebml_master_crc32(&cues, mkv);
2532  if (ret < 0)
2533  return ret;
2534 
2535  ret = mkv_assemble_cues(s->streams, cues, &mkv->cues,
2536  mkv->tracks, s->nb_streams);
2537  if (ret < 0) {
2538  ffio_free_dyn_buf(&cues);
2539  return ret;
2540  }
2541 
2542  if (mkv->reserve_cues_space) {
2543  size = avio_tell(cues);
2544  length_size = ebml_length_size(size);
2545  size += 4 + length_size;
2546  if (mkv->reserve_cues_space < size) {
2548  "Insufficient space reserved for Cues: "
2549  "%d < %"PRIu64". No Cues will be output.\n",
2550  mkv->reserve_cues_space, size);
2551  ret2 = AVERROR(EINVAL);
2552  goto after_cues;
2553  } else {
2554  if ((ret64 = avio_seek(pb, mkv->cues_pos, SEEK_SET)) < 0) {
2555  ffio_free_dyn_buf(&cues);
2556  return ret64;
2557  }
2558  if (mkv->reserve_cues_space == size + 1) {
2559  /* There is no way to reserve a single byte because
2560  * the minimal size of an EBML Void element is 2
2561  * (1 byte ID, 1 byte length field). This problem
2562  * is solved by writing the Cues' length field on
2563  * one byte more than necessary. */
2564  length_size++;
2565  size++;
2566  }
2567  }
2568  }
2569  ret = end_ebml_master_crc32(pb, &cues, mkv, MATROSKA_ID_CUES,
2570  length_size, 0, 1);
2571  if (ret < 0)
2572  return ret;
2573  if (mkv->reserve_cues_space) {
2574  if (size < mkv->reserve_cues_space)
2575  put_ebml_void(pb, mkv->reserve_cues_space - size);
2576  } else
2577  endpos = avio_tell(pb);
2578  }
2579 
2580 after_cues:
2581  /* Lengths greater than (1ULL << 56) - 1 can't be represented
2582  * via an EBML number, so leave the unknown length field. */
2583  if (endpos - mkv->segment_offset < (1ULL << 56) - 1) {
2584  if ((ret64 = avio_seek(pb, mkv->segment_offset - 8, SEEK_SET)) < 0)
2585  return ret64;
2586  put_ebml_length(pb, endpos - mkv->segment_offset, 8);
2587  }
2588 
2589  ret = mkv_write_seekhead(pb, mkv, 1, mkv->info.pos);
2590  if (ret < 0)
2591  return ret;
2592 
2593  if (mkv->info.bc) {
2594  // update the duration
2595  av_log(s, AV_LOG_DEBUG, "end duration = %" PRIu64 "\n", mkv->duration);
2596  avio_seek(mkv->info.bc, mkv->duration_offset, SEEK_SET);
2598  ret = end_ebml_master_crc32(pb, &mkv->info.bc, mkv,
2599  MATROSKA_ID_INFO, 0, 0, 0);
2600  if (ret < 0)
2601  return ret;
2602  }
2603 
2604  if (mkv->track.bc) {
2605  // write Tracks master
2606  avio_seek(pb, mkv->track.pos, SEEK_SET);
2607  ret = end_ebml_master_crc32(pb, &mkv->track.bc, mkv,
2608  MATROSKA_ID_TRACKS, 0, 0, 0);
2609  if (ret < 0)
2610  return ret;
2611  }
2612 
2613  // update stream durations
2614  if (mkv->tags.bc) {
2615  int i;
2616  for (i = 0; i < s->nb_streams; ++i) {
2617  const AVStream *st = s->streams[i];
2618  const mkv_track *track = &mkv->tracks[i];
2619 
2620  if (track->duration_offset > 0) {
2621  double duration_sec = track->duration * av_q2d(st->time_base);
2622  char duration_string[20] = "";
2623 
2624  av_log(s, AV_LOG_DEBUG, "stream %d end duration = %" PRIu64 "\n", i,
2625  track->duration);
2626 
2627  avio_seek(mkv->tags.bc, track->duration_offset, SEEK_SET);
2628 
2629  snprintf(duration_string, 20, "%02d:%02d:%012.9f",
2630  (int) duration_sec / 3600, ((int) duration_sec / 60) % 60,
2631  fmod(duration_sec, 60));
2632 
2633  put_ebml_binary(mkv->tags.bc, MATROSKA_ID_TAGSTRING, duration_string, 20);
2634  }
2635  }
2636 
2637  avio_seek(pb, mkv->tags.pos, SEEK_SET);
2638  ret = end_ebml_master_crc32(pb, &mkv->tags.bc, mkv,
2639  MATROSKA_ID_TAGS, 0, 0, 0);
2640  if (ret < 0)
2641  return ret;
2642  }
2643 
2644  avio_seek(pb, endpos, SEEK_SET);
2645 
2646  return ret2;
2647 }
2648 
2649 static int mkv_query_codec(enum AVCodecID codec_id, int std_compliance)
2650 {
2651  int i;
2652  for (i = 0; ff_mkv_codec_tags[i].id != AV_CODEC_ID_NONE; i++)
2653  if (ff_mkv_codec_tags[i].id == codec_id)
2654  return 1;
2655 
2656  if (std_compliance < FF_COMPLIANCE_NORMAL) {
2657  enum AVMediaType type = avcodec_get_type(codec_id);
2658  // mkv theoretically supports any video/audio through VFW/ACM
2659  if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO)
2660  return 1;
2661  }
2662 
2663  return 0;
2664 }
2665 
2666 static int webm_query_codec(enum AVCodecID codec_id, int std_compliance)
2667 {
2668  int i;
2669  for (i = 0; ff_webm_codec_tags[i].id != AV_CODEC_ID_NONE; i++)
2670  if (ff_webm_codec_tags[i].id == codec_id)
2671  return 1;
2672 
2673  return 0;
2674 }
2675 
2676 static uint64_t mkv_get_uid(const mkv_track *tracks, int i, AVLFG *c)
2677 {
2678  while (1) {
2679  uint64_t uid;
2680  int k;
2681  uid = (uint64_t)av_lfg_get(c) << 32;
2682  uid |= av_lfg_get(c);
2683  if (!uid)
2684  continue;
2685  for (k = 0; k < i; k++) {
2686  if (tracks[k].uid == uid)
2687  break;
2688  }
2689  if (k == i)
2690  return uid;
2691  }
2692 }
2693 
2694 static int mkv_init(struct AVFormatContext *s)
2695 {
2696  MatroskaMuxContext *mkv = s->priv_data;
2697  AVLFG c;
2698  unsigned nb_tracks = 0;
2699  int i;
2700 
2701  for (i = 0; i < s->nb_streams; i++) {
2702  if (s->streams[i]->codecpar->codec_id == AV_CODEC_ID_ATRAC3 ||
2708  av_log(s, AV_LOG_ERROR,
2709  "The Matroska muxer does not yet support muxing %s\n",
2711  return AVERROR_PATCHWELCOME;
2712  }
2713  }
2714 
2715  if (s->avoid_negative_ts < 0) {
2716  s->avoid_negative_ts = 1;
2718  }
2719 
2720  if (!strcmp(s->oformat->name, "webm")) {
2721  mkv->mode = MODE_WEBM;
2722  mkv->write_crc = 0;
2723  } else
2724  mkv->mode = MODE_MATROSKAv2;
2725 
2726  mkv->cur_audio_pkt = av_packet_alloc();
2727  if (!mkv->cur_audio_pkt)
2728  return AVERROR(ENOMEM);
2729  mkv->tracks = av_mallocz_array(s->nb_streams, sizeof(*mkv->tracks));
2730  if (!mkv->tracks)
2731  return AVERROR(ENOMEM);
2732 
2733  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
2735 
2736  // Calculate the SegmentUID now in order not to waste our random seed.
2737  for (i = 0; i < 4; i++)
2738  mkv->segment_uid[i] = av_lfg_get(&c);
2739  }
2740 
2741  for (i = 0; i < s->nb_streams; i++) {
2742  AVStream *st = s->streams[i];
2743  mkv_track *track = &mkv->tracks[i];
2744 
2745  if (s->flags & AVFMT_FLAG_BITEXACT) {
2746  track->uid = i + 1;
2747  } else {
2748  track->uid = mkv_get_uid(mkv->tracks, i, &c);
2749  }
2750 
2751  // ms precision is the de-facto standard timescale for mkv files
2752  avpriv_set_pts_info(st, 64, 1, 1000);
2753 
2755  if (mkv->mode == MODE_WEBM) {
2756  av_log(s, AV_LOG_WARNING, "Stream %d will be ignored "
2757  "as WebM doesn't support attachments.\n", i);
2758  } else if (!get_mimetype(st)) {
2759  av_log(s, AV_LOG_ERROR, "Attachment stream %d has no mimetype "
2760  "tag and it cannot be deduced from the codec id.\n", i);
2761  return AVERROR(EINVAL);
2762  }
2763  mkv->nb_attachments++;
2764  continue;
2765  }
2766 
2767  nb_tracks++;
2768  track->track_num = mkv->is_dash ? mkv->dash_track_number : nb_tracks;
2769  track->track_num_size = ebml_num_size(track->track_num);
2770  }
2771 
2772  if (mkv->is_dash && nb_tracks != 1)
2773  return AVERROR(EINVAL);
2774 
2775  return 0;
2776 }
2777 
2778 static int mkv_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
2779 {
2780  int ret = 1;
2781  AVStream *st = s->streams[pkt->stream_index];
2782 
2783  if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
2784  if (pkt->size > 2 && (AV_RB16(pkt->data) & 0xfff0) == 0xfff0)
2785  ret = ff_stream_add_bitstream_filter(st, "aac_adtstoasc", NULL);
2786  } else if (st->codecpar->codec_id == AV_CODEC_ID_VP9) {
2787  ret = ff_stream_add_bitstream_filter(st, "vp9_superframe", NULL);
2788  }
2789 
2790  return ret;
2791 }
2792 
2794  { AV_CODEC_ID_ALAC, 0XFFFFFFFF },
2795  { AV_CODEC_ID_MLP, 0xFFFFFFFF },
2796  { AV_CODEC_ID_OPUS, 0xFFFFFFFF },
2797  { AV_CODEC_ID_PCM_S16BE, 0xFFFFFFFF },
2798  { AV_CODEC_ID_PCM_S24BE, 0xFFFFFFFF },
2799  { AV_CODEC_ID_PCM_S32BE, 0xFFFFFFFF },
2800  { AV_CODEC_ID_QDMC, 0xFFFFFFFF },
2801  { AV_CODEC_ID_QDM2, 0xFFFFFFFF },
2802  { AV_CODEC_ID_RA_144, 0xFFFFFFFF },
2803  { AV_CODEC_ID_RA_288, 0xFFFFFFFF },
2804  { AV_CODEC_ID_COOK, 0xFFFFFFFF },
2805  { AV_CODEC_ID_TRUEHD, 0xFFFFFFFF },
2806  { AV_CODEC_ID_NONE, 0xFFFFFFFF }
2807 };
2808 
2810  { AV_CODEC_ID_RV10, 0xFFFFFFFF },
2811  { AV_CODEC_ID_RV20, 0xFFFFFFFF },
2812  { AV_CODEC_ID_RV30, 0xFFFFFFFF },
2813  { AV_CODEC_ID_NONE, 0xFFFFFFFF }
2814 };
2815 
2817  { AV_CODEC_ID_DVB_SUBTITLE, 0xFFFFFFFF },
2818  { AV_CODEC_ID_DVD_SUBTITLE, 0xFFFFFFFF },
2819  { AV_CODEC_ID_HDMV_PGS_SUBTITLE, 0xFFFFFFFF },
2820  { AV_CODEC_ID_NONE, 0xFFFFFFFF }
2821 };
2822 
2823 #define OFFSET(x) offsetof(MatroskaMuxContext, x)
2824 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM
2825 static const AVOption options[] = {
2826  { "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 },
2827  { "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 },
2828  { "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 },
2829  { "dash", "Create a WebM file conforming to WebM DASH specification", OFFSET(is_dash), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
2830  { "dash_track_number", "Track number for the DASH stream", OFFSET(dash_track_number), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, INT_MAX, FLAGS },
2831  { "live", "Write files assuming it is a live stream.", OFFSET(is_live), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
2832  { "allow_raw_vfw", "allow RAW VFW mode", OFFSET(allow_raw_vfw), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
2833  { "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 },
2834  { "write_crc32", "write a CRC32 element inside every Level 1 element", OFFSET(write_crc), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, FLAGS },
2835  { "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" },
2836  { "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" },
2837  { "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" },
2838  { "passthrough", "Use the disposition flag as-is", 0, AV_OPT_TYPE_CONST, { .i64 = DEFAULT_MODE_PASSTHROUGH }, 0, 0, FLAGS, "default_mode" },
2839  { NULL },
2840 };
2841 
2842 #if CONFIG_MATROSKA_MUXER
2843 static const AVClass matroska_class = {
2844  .class_name = "matroska muxer",
2845  .item_name = av_default_item_name,
2846  .option = options,
2847  .version = LIBAVUTIL_VERSION_INT,
2848 };
2849 
2851  .name = "matroska",
2852  .long_name = NULL_IF_CONFIG_SMALL("Matroska"),
2853  .mime_type = "video/x-matroska",
2854  .extensions = "mkv",
2855  .priv_data_size = sizeof(MatroskaMuxContext),
2856  .audio_codec = CONFIG_LIBVORBIS_ENCODER ?
2858  .video_codec = CONFIG_LIBX264_ENCODER ?
2860  .init = mkv_init,
2861  .deinit = mkv_deinit,
2867  .codec_tag = (const AVCodecTag* const []){
2870  },
2871  .subtitle_codec = AV_CODEC_ID_ASS,
2872  .query_codec = mkv_query_codec,
2873  .check_bitstream = mkv_check_bitstream,
2874  .priv_class = &matroska_class,
2875 };
2876 #endif
2877 
2878 #if CONFIG_WEBM_MUXER
2879 static const AVClass webm_class = {
2880  .class_name = "webm muxer",
2881  .item_name = av_default_item_name,
2882  .option = options,
2883  .version = LIBAVUTIL_VERSION_INT,
2884 };
2885 
2887  .name = "webm",
2888  .long_name = NULL_IF_CONFIG_SMALL("WebM"),
2889  .mime_type = "video/webm",
2890  .extensions = "webm",
2891  .priv_data_size = sizeof(MatroskaMuxContext),
2892  .audio_codec = CONFIG_LIBOPUS_ENCODER ? AV_CODEC_ID_OPUS : AV_CODEC_ID_VORBIS,
2893  .video_codec = CONFIG_LIBVPX_VP9_ENCODER? AV_CODEC_ID_VP9 : AV_CODEC_ID_VP8,
2894  .subtitle_codec = AV_CODEC_ID_WEBVTT,
2895  .init = mkv_init,
2896  .deinit = mkv_deinit,
2904  .priv_class = &webm_class,
2905 };
2906 #endif
2907 
2908 #if CONFIG_MATROSKA_AUDIO_MUXER
2909 static const AVClass mka_class = {
2910  .class_name = "matroska audio muxer",
2911  .item_name = av_default_item_name,
2912  .option = options,
2913  .version = LIBAVUTIL_VERSION_INT,
2914 };
2916  .name = "matroska",
2917  .long_name = NULL_IF_CONFIG_SMALL("Matroska Audio"),
2918  .mime_type = "audio/x-matroska",
2919  .extensions = "mka",
2920  .priv_data_size = sizeof(MatroskaMuxContext),
2921  .audio_codec = CONFIG_LIBVORBIS_ENCODER ?
2923  .video_codec = AV_CODEC_ID_NONE,
2924  .init = mkv_init,
2925  .deinit = mkv_deinit,
2932  .codec_tag = (const AVCodecTag* const []){
2934  },
2935  .priv_class = &mka_class,
2936 };
2937 #endif
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1478
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:164
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:729
enum AVChromaLocation chroma_location
Definition: codec_par.h:150
fg outputs[0] format
internal header for HEVC (de)muxer utilities
#define AV_DISPOSITION_METADATA
Definition: avformat.h:866
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:449
#define NULL
Definition: coverity.c:32
#define MATROSKA_ID_BLOCKADDID
Definition: matroska.h:235
#define MATROSKA_ID_TRACKDEFAULTDURATION
Definition: matroska.h:109
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:141
void avio_wl16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:455
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:126
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define MATROSKA_ID_VIDEOCOLOR_GX
Definition: matroska.h:152
static int start_ebml_master_crc32(AVIOContext **dyn_cp, MatroskaMuxContext *mkv)
Definition: matroskaenc.c:368
void ff_metadata_conv_ctx(AVFormatContext *ctx, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)
Definition: metadata.c:59
version
Definition: libkvazaar.c:320
#define MATROSKA_ID_DATEUTC
Definition: matroska.h:71
int sizebytes
how many bytes were reserved for the size
Definition: matroskaenc.c:72
The optional first identifier line of a WebVTT cue.
Definition: packet.h:196
uint32_t samples
Definition: wv.h:39
int initial
Definition: wv.h:43
#define MATROSKA_ID_TRACKFLAGLACING
Definition: matroska.h:106
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:2401
#define MATROSKA_ID_VIDEODISPLAYHEIGHT
Definition: matroska.h:118
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:2694
#define MAX_SEEKHEAD_ENTRIES
Definition: matroskaenc.c:59
static int mkv_write_packet_internal(AVFormatContext *s, const AVPacket *pkt)
Definition: matroskaenc.c:2304
#define MATROSKA_ID_VIDEOPROJECTIONPOSEROLL
Definition: matroska.h:166
#define MATROSKA_ID_CUETRACKPOSITION
Definition: matroska.h:197
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3185
#define MATROSKA_ID_CODECPRIVATE
Definition: matroska.h:89
AVIOContext * cluster_bc
Definition: matroskaenc.c:130
#define MATROSKA_ID_TRACKFLAGVISUALIMPAIRED
Definition: matroska.h:102
const char * desc
Definition: libsvtav1.c:79
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4999
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 int mkv_new_chapter_ids_needed(const AVFormatContext *s)
Definition: matroskaenc.c:1628
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
#define MATROSKA_ID_AUDIOBITDEPTH
Definition: matroska.h:172
#define CASE(type, variable)
#define MATROSKA_ID_TRACKFLAGDEFAULT
Definition: matroska.h:99
static const AVCodecTag additional_subtitle_tags[]
Definition: matroskaenc.c:2816
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:1742
uint64_t pts
Definition: matroskaenc.c:93
Video represents a portion of a sphere mapped on a flat surface using equirectangular projection...
Definition: spherical.h:72
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:946
#define MATROSKA_ID_TAGTARGETS_ATTACHUID
Definition: matroska.h:219
int num
Numerator.
Definition: rational.h:59
int size
Definition: packet.h:370
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:251
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:1714
#define EBML_ID_DOCTYPEREADVERSION
Definition: matroska.h:42
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:278
#define MATROSKA_ID_BLOCKREFERENCE
Definition: matroska.h:242
int av_log2(unsigned v)
Definition: intmath.c:26
static int mkv_write_header(AVFormatContext *s)
Definition: matroskaenc.c:1811
#define MATROSKA_ID_TRACKTYPE
Definition: matroska.h:80
#define AV_DISPOSITION_DUB
Definition: avformat.h:830
enum AVMediaType codec_type
Definition: rtp.c:37
#define MATROSKA_ID_TAGTARGETS_CHAPTERUID
Definition: matroska.h:218
int ff_flac_is_native_layout(uint64_t channel_layout)
int64_t duration
duration of the block according to time base
Definition: matroskaenc.c:97
static av_always_inline uint64_t av_double2int(double f)
Reinterpret a double as a 64-bit integer.
Definition: intfloat.h:70
GLint GLenum type
Definition: opengl_enc.c:104
#define AV_DISPOSITION_HEARING_IMPAIRED
stream for hearing impaired audiences
Definition: avformat.h:842
#define MATROSKA_ID_VIDEOCOLOR_RX
Definition: matroska.h:150
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:1518
#define MATROSKA_ID_MUXINGAPP
Definition: matroska.h:70
int64_t cluster_time_limit
Definition: matroskaenc.c:150
#define MATROSKA_ID_AUDIOCHANNELS
Definition: matroska.h:173
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:3175
const char * key
int avoid_negative_ts_use_pts
Definition: internal.h:137
const char * master
Definition: vf_curves.c:119
#define MATROSKA_ID_VIDEOPROJECTIONTYPE
Definition: matroska.h:162
Views are next to each other.
Definition: stereo3d.h:67
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:201
#define MATROSKA_ID_VIDEOCOLOR_LUMINANCEMAX
Definition: matroska.h:158
#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
AVPacket * pkt
Definition: movenc.c:59
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:333
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:1208
#define MATROSKA_ID_VIDEOCOLORCHROMASITINGHORZ
Definition: matroska.h:140
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
#define MATROSKA_ID_EDITIONFLAGDEFAULT
Definition: matroska.h:265
#define MATROSKA_ID_CLUSTERTIMECODE
Definition: matroska.h:229
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1379
#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:258
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:306
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:222
#define FLAGS
Definition: matroskaenc.c:2824
#define MATROSKA_ID_FILEDESC
Definition: matroska.h:248
Format I/O context.
Definition: avformat.h:1247
#define EBML_ID_CRC32
Definition: matroska.h:46
const AVCodecTag ff_codec_movvideo_tags[]
Definition: isom_tags.c:29
int ff_vorbiscomment_write(AVIOContext *pb, const AVDictionary *m, const char *vendor_string, AVChapter **chapters, unsigned int nb_chapters)
Write a VorbisComment into an AVIOContext.
Definition: vorbiscomment.c:65
UID uid
Definition: mxfenc.c:2205
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:2793
Public dictionary API.
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:75
void avio_wl32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:375
uint8_t
#define MATROSKA_ID_VIDEOCOLOR_BX
Definition: matroska.h:154
#define MATROSKA_ID_CHAPLANG
Definition: matroska.h:261
#define av_malloc(s)
int avpriv_mpeg4audio_get_config2(MPEG4AudioConfig *c, const uint8_t *buf, int size, int sync_extension, void *logctx)
Parse MPEG-4 systems extradata from a raw buffer to retrieve audio configuration. ...
Definition: mpeg4audio.c:190
int width
Video only.
Definition: codec_par.h:126
uint64_t uid
Definition: matroskaenc.c:108
unsigned track_num
Definition: matroskaenc.c:109
AVOptions.
#define MATROSKA_ID_TRACKLANGUAGE
Definition: matroska.h:97
int64_t duration
Definition: matroskaenc.c:114
A point in the output bytestream where the underlying AVIOContext might flush the buffer depending on...
Definition: avio.h:146
Stereo 3D type: this structure describes how two videos are packed within a single video surface...
Definition: stereo3d.h:176
#define OPUS_SEEK_PREROLL
Seek preroll value for opus.
Definition: matroskaenc.c:175
uint32_t flags
Definition: wv.h:40
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
int ff_mkv_stereo3d_conv(AVStream *st, MatroskaVideoStereoModeType stereo_mode)
Definition: matroska.c:152
uint64_t segmentpos
Definition: matroskaenc.c:82
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:387
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:237
void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type)
Mark the written bytestream as a specific type.
Definition: aviobuf.c:479
static int put_xiph_codecpriv(AVFormatContext *s, AVIOContext *pb, const AVCodecParameters *par)
Definition: matroskaenc.c:603
#define MATROSKA_ID_BLOCKMORE
Definition: matroska.h:234
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:1315
int64_t duration
Definition: movenc.c:64
#define MATROSKA_ID_CUERELATIVEPOSITION
Definition: matroska.h:202
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:170
#define MATROSKA_ID_VIDEOCOLOR
Definition: matroska.h:132
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:2666
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:1378
uint8_t * data
Definition: packet.h:369
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
#define MATROSKA_ID_VIDEODISPLAYWIDTH
Definition: matroska.h:117
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_TRACKFLAGORIGINAL
Definition: matroska.h:104
#define MATROSKA_ID_BLOCKADDITIONS
Definition: matroska.h:233
uint32_t tag
Definition: movenc.c:1600
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:427
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:1544
#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:157
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:1395
uint8_t * av_stream_get_side_data(const AVStream *stream, enum AVPacketSideDataType type, size_t *size)
Get side information from stream.
static uint64_t mkv_get_uid(const mkv_track *tracks, int i, AVLFG *c)
Definition: matroskaenc.c:2676
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:198
#define MATROSKA_ID_SEGMENTUID
Definition: matroska.h:72
static int mkv_write_track(AVFormatContext *s, MatroskaMuxContext *mkv, AVStream *st, mkv_track *track, AVIOContext *pb, int is_default)
Definition: matroskaenc.c:1115
AVOutputFormat ff_webm_muxer
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
static void put_ebml_num(AVIOContext *pb, uint64_t num, int bytes)
Write a number as EBML variable length integer on bytes bytes.
Definition: matroskaenc.c:227
#define av_log(a,...)
#define AV_DISPOSITION_CAPTIONS
To specify text track kind (different from subtitles default).
Definition: avformat.h:864
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: avpacket.c:641
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:410
static void mkv_add_seekhead_entry(MatroskaMuxContext *mkv, uint32_t elementid, uint64_t filepos)
Definition: matroskaenc.c:357
#define MATROSKA_ID_TRACKUID
Definition: matroska.h:79
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
#define U(x)
Definition: vp56_arith.h:37
#define src
Definition: vp8dsp.c:255
#define MATROSKA_ID_VIDEOSTEREOMODE
Definition: matroska.h:128
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:5758
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
static int mkv_write_tags(AVFormatContext *s)
Definition: matroskaenc.c:1555
#define MATROSKA_ID_VIDEOCOLOR_BY
Definition: matroska.h:155
#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:613
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1489
int flags
Additional information about the frame packing.
Definition: stereo3d.h:185
#define MATROSKA_ID_BLOCKDURATION
Definition: matroska.h:241
#define EBML_ID_EBMLREADVERSION
Definition: matroska.h:37
#define MATROSKA_ID_VIDEOCOLORMAXCLL
Definition: matroska.h:146
#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:156
int buffer_size_t
Definition: internal.h:306
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:141
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:117
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:1413
#define MATROSKA_ID_FILEMIMETYPE
Definition: matroska.h:250
#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:1479
int64_t id
unique ID to identify the chapter
Definition: avformat.h:1204
enum AVCodecID id
Definition: matroska.h:360
static int mkv_write_chapters(AVFormatContext *s)
Definition: matroskaenc.c:1640
GLsizei GLsizei * length
Definition: opengl_enc.c:114
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, buffer_size_t *size)
Definition: avpacket.c:368
#define EBML_ID_EBMLMAXIDLENGTH
Definition: matroska.h:38
AVIOContext * bc
Definition: matroskaenc.c:76
uint32_t crc
Definition: wv.h:41
static int mkv_write_seekhead(AVIOContext *pb, MatroskaMuxContext *mkv, int error_on_seek_failure, int64_t destpos)
Write the SeekHead to the file at the location reserved for it and seek to destpos afterwards...
Definition: matroskaenc.c:490
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:957
const AVCodecTag ff_codec_wav_tags[]
Definition: riff.c:508
#define FFMAX(a, b)
Definition: common.h:103
int ff_avc_parse_nal_units_buf(const uint8_t *buf_in, uint8_t **buf, int *size)
Definition: avc.c:95
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
int64_t filepos
Definition: matroskaenc.c:86
#define fail()
Definition: checkasm.h:133
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:375
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
#define MATROSKA_ID_TAG
Definition: matroska.h:207
const CodecTags ff_webm_codec_tags[]
Definition: matroska.c:106
Views are alternated temporally.
Definition: stereo3d.h:92
#define AV_DISPOSITION_FORCED
Track should be used during playback by default.
Definition: avformat.h:841
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1303
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:1450
#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:159
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:3368
#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:214
const AVCodecTag ff_codec_bmp_tags[]
Definition: riff.c:33
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:215
#define MATROSKA_ID_TAGNAME
Definition: matroska.h:209
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:1787
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:473
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:208
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:1592
#define MATROSKA_ID_CHAPTERATOM
Definition: matroska.h:256
int avpriv_split_xiph_headers(const uint8_t *extradata, int extradata_size, int first_header_size, const uint8_t *header_start[3], int header_len[3])
Split a single extradata buffer into the three headers that most Xiph codecs use. ...
Definition: xiph.c:24
static int mkv_write_native_codecprivate(AVFormatContext *s, AVIOContext *pb, const AVCodecParameters *par, AVIOContext *dyn_cp)
Definition: matroskaenc.c:711
int32_t yaw
Rotation around the up vector [-180, 180].
Definition: spherical.h:126
static int get_aac_sample_rates(AVFormatContext *s, MatroskaMuxContext *mkv, const uint8_t *extradata, int extradata_size, int *sample_rate, int *output_sample_rate)
Definition: matroskaenc.c:678
AVDictionary * metadata
Definition: avformat.h:948
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
enum AVColorRange color_range
Video only.
Definition: codec_par.h:146
static int mkv_check_new_extra_data(AVFormatContext *s, const AVPacket *pkt)
Definition: matroskaenc.c:2213
Opaque data information usually sparse.
Definition: avutil.h:205
#define MATROSKA_ID_VIDEOCOLORSPACE
Definition: matroska.h:131
#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:2823
#define MATROSKA_ID_TRACKFLAGHEARINGIMPAIRED
Definition: matroska.h:101
#define MATROSKA_ID_TRACKFLAGTEXTDESCRIPTIONS
Definition: matroska.h:103
int64_t ff_vorbiscomment_length(const AVDictionary *m, const char *vendor_string, AVChapter **chapters, unsigned int nb_chapters)
Calculate the length in bytes of a VorbisComment.
Definition: vorbiscomment.c:41
#define MATROSKA_ID_AUDIOSAMPLINGFREQ
Definition: matroska.h:169
ff_const59 struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1266
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1454
if(ret)
#define AV_DISPOSITION_VISUAL_IMPAIRED
stream for visual impaired audiences
Definition: avformat.h:843
uint32_t padding
Number of pixels to pad from the edge of each cube face.
Definition: spherical.h:182
int metadata_header_padding
Number of bytes to be written as padding in a metadata header.
Definition: avformat.h:1761
Stream structure.
Definition: avformat.h:884
#define IS_SEEKABLE(pb, mkv)
Definition: matroskaenc.c:61
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1207
Content light level (based on CTA-861.3).
Definition: packet.h:235
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:55
#define AV_DISPOSITION_DEFAULT
Definition: avformat.h:829
sample_rate
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:180
Views are packed in a checkerboard-like structure per pixel.
Definition: stereo3d.h:104
#define MATROSKA_ID_VIDEOCOLORMATRIXCOEFF
Definition: matroska.h:134
#define AV_DISPOSITION_DESCRIPTIONS
Definition: avformat.h:865
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
#define MATROSKA_ID_TRACKFLAGFORCED
Definition: matroska.h:100
#define MATROSKA_ID_TAGS
Definition: matroska.h:59
Views are on top of each other.
Definition: stereo3d.h:79
#define MATROSKA_ID_VIDEOCOLORPRIMARIES
Definition: matroska.h:145
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:165
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
#define MATROSKA_ID_SEEKID
Definition: matroska.h:225
AVIOContext * pb
I/O context.
Definition: avformat.h:1289
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:240
#define MATROSKA_ID_INFO
Definition: matroska.h:56
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:634
#define MATROSKA_ID_TAGTARGETS_TRACKUID
Definition: matroska.h:217
#define MATROSKA_ID_TAGLANG
Definition: matroska.h:211
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:222
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:255
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:1604
static int mkv_check_tag_name(const char *name, uint32_t elementid)
Definition: matroskaenc.c:1504
#define MATROSKA_ID_BLOCKGROUP
Definition: matroska.h:232
#define MATROSKA_ID_VIDEOPIXELHEIGHT
Definition: matroska.h:120
int32_t roll
Rotation around the forward vector [-180, 180].
Definition: spherical.h:128
static int mkv_write_tracks(AVFormatContext *s)
Definition: matroskaenc.c:1392
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:203
#define MATROSKA_ID_CUETIME
Definition: matroska.h:196
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:143
#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:1975
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:161
#define MATROSKA_ID_VIDEOCOLORMASTERINGMETA
Definition: matroska.h:149
misc parsing utilities
ebml_stored_master tags
Definition: matroskaenc.c:128
#define MATROSKA_ID_VIDEOPROJECTIONPRIVATE
Definition: matroska.h:163
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:461
#define flags(name, subs,...)
Definition: cbs_av1.c:561
#define MATROSKA_ID_CHAPTERDISPLAY
Definition: matroska.h:259
static int mkv_end_cluster(AVFormatContext *s)
Definition: matroskaenc.c:2194
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:249
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:236
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:2809
mkv_seekhead_entry entries[MAX_SEEKHEAD_ENTRIES]
Definition: matroskaenc.c:87
#define MATROSKA_ID_VIDEOFIELDORDER
Definition: matroska.h:127
int64_t start
Definition: avformat.h:1207
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:129
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:2493
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:2778
#define MATROSKA_ID_CUETRACK
Definition: matroska.h:200
static int put_wv_codecpriv(AVIOContext *pb, const AVCodecParameters *par)
Definition: matroskaenc.c:633
#define MATROSKA_ID_SEEKPOSITION
Definition: matroska.h:226
#define MATROSKA_ID_CODECDELAY
Definition: matroska.h:94
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
#define MATROSKA_ID_CHAPTERTIMESTART
Definition: matroska.h:257
#define MATROSKA_ID_VIDEOCOLORRANGE
Definition: matroska.h:142
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:1484
raw UTF-8 text
Definition: codec_id.h:525
static int mkv_write_flush_packet(AVFormatContext *s, AVPacket *pkt)
Definition: matroskaenc.c:2475
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:937
static ebml_master start_ebml_master(AVIOContext *pb, uint32_t elementid, uint64_t expectedsize)
Definition: matroskaenc.c:337
int64_t last_timestamp
Definition: matroskaenc.c:113
void ff_put_bmp_header(AVIOContext *pb, AVCodecParameters *par, int for_asf, int ignore_extradata, int rgb_frame_is_flipped)
Definition: riffenc.c:215
Stereoscopic video.
Views are packed per column.
Definition: stereo3d.h:141
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1206
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:454
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:2141
#define MATROSKA_ID_SEGMENT
Definition: matroska.h:53
#define MAX_PCE_SIZE
Maximum size of a PCE including the 3-bit ID_PCE.
Definition: mpeg4audio.h:134
static void mkv_write_video_projection(AVFormatContext *s, AVIOContext *pb, const AVStream *st)
Definition: matroskaenc.c:918
The optional settings (rendering instructions) that immediately follow the timestamp specifier of a W...
Definition: packet.h:202
#define MATROSKA_ID_SEEKHEAD
Definition: matroska.h:60
#define EBML_ID_HEADER
Definition: matroska.h:33
uint32_t elementid
Definition: matroskaenc.c:81
A point in the output bytestream where a decoder can start decoding (i.e.
Definition: avio.h:122
A Quick Description Of Rate Distortion Theory We want to encode a video
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:465
#define MATROSKA_ID_TRACKFLAGCOMMENTARY
Definition: matroska.h:105
#define av_free(p)
char * value
Definition: dict.h:87
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
#define MATROSKA_ID_POINTENTRY
Definition: matroska.h:193
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:252
int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
Add a bitstream filter to a stream.
Definition: utils.c:5630
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:1275
#define MATROSKA_ID_CHAPTERUID
Definition: matroska.h:267
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:64
AVPacket * cur_audio_pkt
Definition: matroskaenc.c:140
char str[22]
Definition: matroska.h:359
static int check_bitstream(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:1095
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:346
uint32_t bound_left
Distance from the left edge.
Definition: spherical.h:167
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3501
static const char * get_mimetype(const AVStream *st)
Definition: matroskaenc.c:1725
#define AV_DISPOSITION_COMMENT
Definition: avformat.h:832
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
int64_t relative_pos
relative offset from the position of the cluster containing the block
Definition: matroskaenc.c:96
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
#define MATROSKA_ID_VIDEOCOLORMAXFALL
Definition: matroska.h:147
#define MATROSKA_ID_VIDEODISPLAYUNIT
Definition: matroska.h:125
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:368
static const AVOption options[]
Definition: matroskaenc.c:2825
#define EBML_ID_EBMLMAXSIZELENGTH
Definition: matroska.h:39
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:383
enum AVMediaType avcodec_get_type(enum AVCodecID codec_id)
Get the type of the given codec.
Definition: codec_desc.c:3526
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1362
#define MATROSKA_ID_CHAPSTRING
Definition: matroska.h:260
int sample_rate
Definition: matroskaenc.c:111
#define av_freep(p)
#define MATROSKA_ID_TAGSTRING
Definition: matroska.h:210
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:70
#define MODE_MATROSKAv2
Definition: matroskaenc.c:120
uint32_t av_get_random_seed(void)
Get a seed to use in conjunction with random functions.
Definition: random_seed.c:120
static void put_ebml_string(AVIOContext *pb, uint32_t elementid, const char *str)
Definition: matroskaenc.c:307
AVOutputFormat ff_matroska_muxer
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1049
static void put_ebml_sint(AVIOContext *pb, uint32_t elementid, int64_t val)
Definition: matroskaenc.c:278
#define MODE_WEBM
Definition: matroskaenc.c:121
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
#define MATROSKA_ID_DURATION
Definition: matroska.h:67
#define MAX_SEEKENTRY_SIZE
2 bytes * 3 for EBML IDs, 3 1-byte EBML lengths, 8 bytes for 64 bit offset, 4 bytes for target EBML I...
Definition: matroskaenc.c:169
static void mkv_deinit(AVFormatContext *s)
Free the members allocated in the mux context.
Definition: matroskaenc.c:450
int stream_index
Definition: packet.h:371
int num_entries
Definition: matroskaenc.c:102
#define EBML_ID_DOCTYPEVERSION
Definition: matroska.h:41
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:913
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
static void end_ebml_master(AVIOContext *pb, ebml_master master)
Definition: matroskaenc.c:347
const char *const * mime_types
MIME type(s) associated with the codec.
Definition: codec_desc.h:60
int64_t segment_offset
Definition: matroskaenc.c:129
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1026
#define MATROSKA_ID_ATTACHEDFILE
Definition: matroska.h:247
#define MATROSKA_ID_VIDEOCOLOR_GY
Definition: matroska.h:153
static int mkv_write_block(AVFormatContext *s, AVIOContext *pb, uint32_t blockid, const AVPacket *pkt, int keyframe)
Definition: matroskaenc.c:2028
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:346
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:151
uint32_t blocksize
Definition: wv.h:35
static int mkv_query_codec(enum AVCodecID codec_id, int std_compliance)
Definition: matroskaenc.c:2649
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:362
Not part of ABI.
Definition: pixfmt.h:529
#define MATROSKA_ID_VIDEOPIXELWIDTH
Definition: matroska.h:119
static int mkv_blockgroup_size(int pkt_size, int track_num_size)
Definition: matroskaenc.c:1966
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
#define AV_DISPOSITION_ORIGINAL
Definition: avformat.h:831
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:244
#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:1391
static uint8_t tmp[11]
Definition: aes_ctr.c:27