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