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 "config_components.h"
25 
26 #include "av1.h"
27 #include "avc.h"
28 #include "hevc.h"
29 #include "avformat.h"
30 #include "avio_internal.h"
31 #include "avlanguage.h"
32 #include "dovi_isom.h"
33 #include "flacenc.h"
34 #include "internal.h"
35 #include "isom.h"
36 #include "matroska.h"
37 #include "mux.h"
38 #include "riff.h"
39 #include "version.h"
40 #include "vorbiscomment.h"
41 #include "wv.h"
42 
43 #include "libavutil/avstring.h"
45 #include "libavutil/crc.h"
46 #include "libavutil/dict.h"
48 #include "libavutil/intfloat.h"
49 #include "libavutil/intreadwrite.h"
50 #include "libavutil/lfg.h"
52 #include "libavutil/mathematics.h"
53 #include "libavutil/opt.h"
54 #include "libavutil/parseutils.h"
55 #include "libavutil/pixdesc.h"
56 #include "libavutil/random_seed.h"
57 #include "libavutil/rational.h"
58 #include "libavutil/samplefmt.h"
59 #include "libavutil/stereo3d.h"
60 
61 #include "libavcodec/av1.h"
62 #include "libavcodec/bytestream.h"
63 #include "libavcodec/codec_desc.h"
64 #include "libavcodec/defs.h"
65 #include "libavcodec/xiph.h"
66 #include "libavcodec/mpeg4audio.h"
67 
68 /* Level 1 elements we create a SeekHead entry for:
69  * Info, Tracks, Chapters, Attachments, Tags (potentially twice) and Cues */
70 #define MAX_SEEKHEAD_ENTRIES 7
71 
72 /* Largest known-length EBML length */
73 #define MAX_EBML_LENGTH ((1ULL << 56) - 2)
74 /* The dynamic buffer API we rely upon has a limit of INT_MAX;
75  * and so has avio_write(). */
76 #define MAX_SUPPORTED_EBML_LENGTH FFMIN(MAX_EBML_LENGTH, INT_MAX)
77 
78 #define MODE_MATROSKAv2 0x01
79 #define MODE_WEBM 0x02
80 
81 #define IS_WEBM(mkv) (CONFIG_WEBM_MUXER && CONFIG_MATROSKA_MUXER ? \
82  ((mkv)->mode == MODE_WEBM) : CONFIG_WEBM_MUXER)
83 #define IS_SEEKABLE(pb, mkv) (((pb)->seekable & AVIO_SEEKABLE_NORMAL) && \
84  !(mkv)->is_live)
85 
86 enum {
90 };
91 
92 typedef struct ebml_master {
93  int64_t pos; ///< absolute offset in the containing AVIOContext where the master's elements start
94  int sizebytes; ///< how many bytes were reserved for the size
95 } ebml_master;
96 
97 typedef struct ebml_stored_master {
99  int64_t pos;
101 
102 typedef enum EbmlType {
110  EBML_BLOCK, ///< pseudo-type for writing (Simple)Blocks
112 } EbmlType;
113 
114 typedef struct BlockContext {
115  struct mkv_track *track;
116  const AVPacket *pkt;
117  int16_t rel_ts;
118  uint8_t flags;
120 } BlockContext;
121 
122 typedef struct EbmlMaster {
123  int nb_elements; ///< -1 if not finished
124  int containing_master; ///< -1 if no parent exists
125 } EbmlMaster;
126 
127 typedef struct EbmlElement {
128  uint32_t id;
130  unsigned length_size;
131  uint64_t size; ///< excluding id and length field
132  union {
133  uint64_t uint;
134  int64_t sint;
135  double f;
136  const char *str;
137  const uint8_t *bin;
138  struct MatroskaMuxContext *mkv; ///< used by EBML_BLOCK
140  } priv;
141 } EbmlElement;
142 
143 typedef struct EbmlWriter {
144  unsigned nb_elements;
147 } EbmlWriter;
148 
149 #define EBML_WRITER(max_nb_elems) \
150  EbmlElement elements[max_nb_elems]; \
151  EbmlWriter writer = (EbmlWriter){ .elements = elements, \
152  .current_master_element = -1 }
153 
154 typedef struct mkv_seekhead_entry {
155  uint32_t elementid;
156  uint64_t segmentpos;
158 
159 typedef struct mkv_seekhead {
160  int64_t filepos;
164 } mkv_seekhead;
165 
166 typedef struct mkv_cuepoint {
167  uint64_t pts;
169  int64_t cluster_pos; ///< offset of the cluster containing the block relative to the segment
170  int64_t relative_pos; ///< relative offset from the position of the cluster containing the block
171  int64_t duration; ///< duration of the block according to time base
172 } mkv_cuepoint;
173 
174 typedef struct mkv_cues {
177 } mkv_cues;
178 
179 struct MatroskaMuxContext;
180 
181 typedef struct mkv_track {
183  int has_cue;
184  uint64_t uid;
185  unsigned track_num;
188  unsigned offset;
190  int64_t last_timestamp;
191  int64_t duration;
193  uint64_t max_blockaddid;
196  unsigned codecpriv_size; ///< size reserved for CodecPrivate excluding header+length field
197  int64_t ts_offset;
198  /* This callback will be called twice: First with a NULL AVIOContext
199  * to return the size of the (Simple)Block's data via size
200  * and a second time with the AVIOContext set when the data
201  * shall be written.
202  * The callback shall not return an error on the second call. */
204  const AVPacket *, int *size);
205 } mkv_track;
206 
207 typedef struct MatroskaMuxContext {
208  const AVClass *class;
210 
211  int mode;
215  int64_t segment_offset;
217  int64_t cluster_pos; ///< file offset of the current Cluster
218  int64_t cluster_pts;
220  int64_t duration;
224  int64_t cues_pos;
225 
227 
228  /* Used as temporary buffer to use the minimal amount of bytes
229  * to write the length field of EBML Masters.
230  * Every user has to reset the buffer after using it and
231  * different uses may not overlap. It is currently used in
232  * mkv_write_tag(), in mkv_assemble_cues() as well as in
233  * mkv_update_codecprivate() and mkv_write_track(). */
235 
237 
238  unsigned nb_attachments;
240 
243 
248  int is_live;
249 
250  int is_dash;
256 
257  uint32_t segment_uid[4];
259 
260 /** 2 bytes * 3 for EBML IDs, 3 1-byte EBML lengths, 8 bytes for 64 bit
261  * offset, 4 bytes for target EBML ID */
262 #define MAX_SEEKENTRY_SIZE 21
263 
264 /** 4 * (1-byte EBML ID, 1-byte EBML size, 8-byte uint max) */
265 #define MAX_CUETRACKPOS_SIZE 40
266 
267 /** DURATION_STRING_LENGTH must be <= 112 or the containing
268  * simpletag will need more than one byte for its length field. */
269 #define DURATION_STRING_LENGTH 19
270 
271 /** 2 + 1 Simpletag header, 2 + 1 + 8 Name "DURATION", rest for TagString */
272 #define DURATION_SIMPLETAG_SIZE (2 + 1 + (2 + 1 + 8) + (2 + 1 + DURATION_STRING_LENGTH))
273 
274 /** Seek preroll value for opus */
275 #define OPUS_SEEK_PREROLL 80000000
276 
277 static int ebml_id_size(uint32_t id)
278 {
279  return (av_log2(id) + 7U) / 8;
280 }
281 
282 static void put_ebml_id(AVIOContext *pb, uint32_t id)
283 {
284  int i = ebml_id_size(id);
285  while (i--)
286  avio_w8(pb, (uint8_t)(id >> (i * 8)));
287 }
288 
289 /**
290  * Write an EBML size meaning "unknown size".
291  *
292  * @param bytes The number of bytes the size should occupy (maximum: 8).
293  */
294 static void put_ebml_size_unknown(AVIOContext *pb, int bytes)
295 {
296  av_assert0(bytes <= 8);
297  avio_w8(pb, 0x1ff >> bytes);
298  if (av_builtin_constant_p(bytes) && bytes == 1)
299  return;
300  ffio_fill(pb, 0xff, bytes - 1);
301 }
302 
303 /**
304  * Returns how many bytes are needed to represent a number
305  * as EBML variable length integer.
306  */
307 static int ebml_num_size(uint64_t num)
308 {
309  int bytes = 0;
310  do {
311  bytes++;
312  } while (num >>= 7);
313  return bytes;
314 }
315 
316 /**
317  * Calculate how many bytes are needed to represent the length field
318  * of an EBML element whose payload has a given length.
319  */
320 static int ebml_length_size(uint64_t length)
321 {
322  return ebml_num_size(length + 1);
323 }
324 
325 /**
326  * Write a number as EBML variable length integer on `bytes` bytes.
327  * `bytes` is taken literally without checking.
328  */
329 static void put_ebml_num(AVIOContext *pb, uint64_t num, int bytes)
330 {
331  num |= 1ULL << bytes * 7;
332  for (int i = bytes - 1; i >= 0; i--)
333  avio_w8(pb, (uint8_t)(num >> i * 8));
334 }
335 
336 /**
337  * Write a length as EBML variable length integer.
338  *
339  * @param bytes The number of bytes that need to be used to write the number.
340  * If zero, the minimal number of bytes will be used.
341  */
342 static void put_ebml_length(AVIOContext *pb, uint64_t length, int bytes)
343 {
344  int needed_bytes = ebml_length_size(length);
345 
346  // sizes larger than this are currently undefined in EBML
347  av_assert0(length < (1ULL << 56) - 1);
348 
349  if (bytes == 0)
350  bytes = needed_bytes;
351  // The bytes needed to write the given size must not exceed
352  // the bytes that we ought to use.
353  av_assert0(bytes >= needed_bytes);
354  put_ebml_num(pb, length, bytes);
355 }
356 
357 /**
358  * Write a (random) UID with fixed size to make the output more deterministic
359  */
360 static void put_ebml_uid(AVIOContext *pb, uint32_t elementid, uint64_t uid)
361 {
362  put_ebml_id(pb, elementid);
363  put_ebml_length(pb, 8, 0);
364  avio_wb64(pb, uid);
365 }
366 
367 static void put_ebml_uint(AVIOContext *pb, uint32_t elementid, uint64_t val)
368 {
369  int i, bytes = 1;
370  uint64_t tmp = val;
371  while (tmp >>= 8)
372  bytes++;
373 
374  put_ebml_id(pb, elementid);
375  put_ebml_length(pb, bytes, 0);
376  for (i = bytes - 1; i >= 0; i--)
377  avio_w8(pb, (uint8_t)(val >> i * 8));
378 }
379 
380 static void put_ebml_float(AVIOContext *pb, uint32_t elementid, double val)
381 {
382  put_ebml_id(pb, elementid);
383  put_ebml_length(pb, 8, 0);
385 }
386 
387 static void put_ebml_binary(AVIOContext *pb, uint32_t elementid,
388  const void *buf, int size)
389 {
390  put_ebml_id(pb, elementid);
391  put_ebml_length(pb, size, 0);
392  avio_write(pb, buf, size);
393 }
394 
395 static void put_ebml_string(AVIOContext *pb, uint32_t elementid,
396  const char *str)
397 {
398  put_ebml_binary(pb, elementid, str, strlen(str));
399 }
400 
401 /**
402  * Write a void element of a given size. Useful for reserving space in
403  * the file to be written to later.
404  *
405  * @param size The number of bytes to reserve, which must be at least 2.
406  */
407 static void put_ebml_void(AVIOContext *pb, int size)
408 {
409  av_assert0(size >= 2);
410 
412  // we need to subtract the length needed to store the size from the
413  // size we need to reserve so 2 cases, we use 8 bytes to store the
414  // size if possible, 1 byte otherwise
415  if (size < 10) {
416  size -= 2;
417  put_ebml_length(pb, size, 0);
418  } else {
419  size -= 9;
420  put_ebml_length(pb, size, 8);
421  }
422  ffio_fill(pb, 0, size);
423 }
424 
425 static ebml_master start_ebml_master(AVIOContext *pb, uint32_t elementid,
426  uint64_t expectedsize)
427 {
428  int bytes = expectedsize ? ebml_length_size(expectedsize) : 8;
429 
430  put_ebml_id(pb, elementid);
431  put_ebml_size_unknown(pb, bytes);
432  return (ebml_master) { avio_tell(pb), bytes };
433 }
434 
436 {
437  int64_t pos = avio_tell(pb);
438 
439  if (avio_seek(pb, master.pos - master.sizebytes, SEEK_SET) < 0)
440  return;
441  put_ebml_length(pb, pos - master.pos, master.sizebytes);
442  avio_seek(pb, pos, SEEK_SET);
443 }
444 
446  uint32_t id, EbmlType type)
447 {
448  writer->elements[writer->nb_elements].id = id;
449  writer->elements[writer->nb_elements].type = type;
450  return &writer->elements[writer->nb_elements++];
451 }
452 
453 static void ebml_writer_open_master(EbmlWriter *writer, uint32_t id)
454 {
455  EbmlElement *const elem = ebml_writer_add(writer, id, EBML_MASTER);
456  EbmlMaster *const master = &elem->priv.master;
457 
458  master->containing_master = writer->current_master_element;
459  master->nb_elements = -1;
460 
461  writer->current_master_element = writer->nb_elements - 1;
462 }
463 
465 {
466  EbmlElement *elem;
467  av_assert2(writer->current_master_element >= 0);
468  av_assert2(writer->current_master_element < writer->nb_elements);
469  elem = &writer->elements[writer->current_master_element];
470  av_assert2(elem->type == EBML_MASTER);
471  av_assert2(elem->priv.master.nb_elements < 0); /* means unset */
472  elem->priv.master.nb_elements = writer->nb_elements - writer->current_master_element - 1;
476 }
477 
479 {
480  av_assert2(writer->nb_elements > 0);
481  av_assert2(0 <= writer->current_master_element);
482  av_assert2(writer->current_master_element < writer->nb_elements);
483  if (writer->current_master_element == writer->nb_elements - 1) {
484  const EbmlElement *const elem = &writer->elements[writer->nb_elements - 1];
485  /* The master element has no children. Discard it. */
486  av_assert2(elem->type == EBML_MASTER);
490  writer->nb_elements--;
491  return;
492  }
493  ebml_writer_close_master(writer);
494 }
495 
496 static void ebml_writer_add_string(EbmlWriter *writer, uint32_t id,
497  const char *str)
498 {
499  EbmlElement *const elem = ebml_writer_add(writer, id, EBML_STR);
500 
501  elem->priv.str = str;
502 }
503 
504 static void ebml_writer_add_bin(EbmlWriter *writer, uint32_t id,
505  const uint8_t *data, size_t size)
506 {
507  EbmlElement *const elem = ebml_writer_add(writer, id, EBML_BIN);
508 
509 #if SIZE_MAX > UINT64_MAX
510  size = FFMIN(size, UINT64_MAX);
511 #endif
512  elem->size = size;
513  elem->priv.bin = data;
514 }
515 
516 static void ebml_writer_add_float(EbmlWriter *writer, uint32_t id,
517  double val)
518 {
519  EbmlElement *const elem = ebml_writer_add(writer, id, EBML_FLOAT);
520 
521  elem->priv.f = val;
522 }
523 
524 static void ebml_writer_add_uid(EbmlWriter *writer, uint32_t id,
525  uint64_t val)
526 {
527  EbmlElement *const elem = ebml_writer_add(writer, id, EBML_UID);
528  elem->priv.uint = val;
529 }
530 
531 static void ebml_writer_add_uint(EbmlWriter *writer, uint32_t id,
532  uint64_t val)
533 {
534  EbmlElement *elem = ebml_writer_add(writer, id, EBML_UINT);
535  elem->priv.uint = val;
536 }
537 
538 static void ebml_writer_add_sint(EbmlWriter *writer, uint32_t id,
539  int64_t val)
540 {
541  EbmlElement *elem = ebml_writer_add(writer, id, EBML_SINT);
542  elem->priv.sint = val;
543 }
544 
546 {
548  elem->priv.mkv = mkv;
549 }
550 
552 {
553  size_t len = strlen(elem->priv.str);
554 #if SIZE_MAX > UINT64_MAX
555  len = FF_MIN(len, UINT64_MAX);
556 #endif
557  elem->size = len;
558  return 0;
559 }
560 
561 static av_const int uint_size(uint64_t val)
562 {
563  int bytes = 0;
564  do {
565  bytes++;
566  } while (val >>= 8);
567  return bytes;
568 }
569 
571 {
572  elem->size = uint_size(elem->priv.uint);
573  return 0;
574 }
575 
576 static av_const int sint_size(int64_t val)
577 {
578  uint64_t tmp = 2 * (uint64_t)(val < 0 ? val^-1 : val);
579  return uint_size(tmp);
580 }
581 
583 {
584  elem->size = sint_size(elem->priv.sint);
585  return 0;
586 }
587 
588 static int ebml_writer_elem_len(EbmlWriter *writer, EbmlElement *elem,
589  int remaining_elems);
590 
592  int remaining_elems)
593 {
594  int nb_elems = elem->priv.master.nb_elements >= 0 ? elem->priv.master.nb_elements : remaining_elems - 1;
595  EbmlElement *const master = elem;
596  uint64_t total_size = 0;
597 
598  master->priv.master.nb_elements = nb_elems;
599  for (; elem++, nb_elems > 0;) {
600  int ret = ebml_writer_elem_len(writer, elem, nb_elems);
601  if (ret < 0)
602  return ret;
603  av_assert2(ret < nb_elems);
604  /* No overflow is possible here, as both total_size and elem->size
605  * are bounded by MAX_SUPPORTED_EBML_LENGTH. */
606  total_size += ebml_id_size(elem->id) + elem->length_size + elem->size;
607  if (total_size > MAX_SUPPORTED_EBML_LENGTH)
608  return AVERROR(ERANGE);
609  nb_elems--; /* consume elem */
610  elem += ret, nb_elems -= ret; /* and elem's children */
611  }
612  master->size = total_size;
613 
614  return master->priv.master.nb_elements;
615 }
616 
618 {
619  MatroskaMuxContext *const mkv = elem->priv.mkv;
620  BlockContext *const block = &mkv->cur_block;
621  mkv_track *const track = block->track;
622  const AVPacket *const pkt = block->pkt;
623  int err, size;
624 
625  if (track->reformat) {
626  err = track->reformat(mkv, NULL, pkt, &size);
627  if (err < 0) {
628  av_log(mkv->ctx, AV_LOG_ERROR, "Error when reformatting data of "
629  "a packet from stream %d.\n", pkt->stream_index);
630  return err;
631  }
632  } else {
633  size = pkt->size;
634  if (track->offset <= size)
635  size -= track->offset;
636  }
637  elem->size = track->track_num_size + 3U + size;
638 
639  return 0;
640 }
641 
642 static void ebml_writer_write_block(const EbmlElement *elem, AVIOContext *pb)
643 {
644  MatroskaMuxContext *const mkv = elem->priv.mkv;
645  BlockContext *const block = &mkv->cur_block;
646  mkv_track *const track = block->track;
647  const AVPacket *const pkt = block->pkt;
648 
649  put_ebml_num(pb, track->track_num, track->track_num_size);
650  avio_wb16(pb, block->rel_ts);
651  avio_w8(pb, block->flags);
652 
653  if (track->reformat) {
654  int size;
655  track->reformat(mkv, pb, pkt, &size);
656  } else {
657  const uint8_t *data = pkt->data;
658  unsigned offset = track->offset <= pkt->size ? track->offset : 0;
659  avio_write(pb, data + offset, pkt->size - offset);
660  }
661 }
662 
663 static int ebml_writer_elem_len(EbmlWriter *writer, EbmlElement *elem,
664  int remaining_elems)
665 {
666  int ret = 0;
667 
668  switch (elem->type) {
669  case EBML_FLOAT:
670  case EBML_UID:
671  elem->size = 8;
672  break;
673  case EBML_STR:
674  ret = ebml_writer_str_len(elem);
675  break;
676  case EBML_UINT:
677  ret = ebml_writer_uint_len(elem);
678  break;
679  case EBML_SINT:
680  ret = ebml_writer_sint_len(elem);
681  break;
682  case EBML_BLOCK:
683  ret = ebml_writer_block_len(elem);
684  break;
685  case EBML_MASTER:
686  ret = ebml_writer_master_len(writer, elem, remaining_elems);
687  break;
688  }
689  if (ret < 0)
690  return ret;
691  if (elem->size > MAX_SUPPORTED_EBML_LENGTH)
692  return AVERROR(ERANGE);
693  elem->length_size = ebml_length_size(elem->size);
694  return ret; /* number of elements consumed excluding elem itself */
695 }
696 
697 static int ebml_writer_elem_write(const EbmlElement *elem, AVIOContext *pb)
698 {
699  put_ebml_id(pb, elem->id);
700  put_ebml_num(pb, elem->size, elem->length_size);
701  switch (elem->type) {
702  case EBML_UID:
703  case EBML_FLOAT: {
704  uint64_t val = elem->type == EBML_UID ? elem->priv.uint
705  : av_double2int(elem->priv.f);
706  avio_wb64(pb, val);
707  break;
708  }
709  case EBML_UINT:
710  case EBML_SINT: {
711  uint64_t val = elem->type == EBML_UINT ? elem->priv.uint
712  : elem->priv.sint;
713  for (int i = elem->size; --i >= 0; )
714  avio_w8(pb, (uint8_t)(val >> i * 8));
715  break;
716  }
717  case EBML_STR:
718  case EBML_BIN: {
719  const uint8_t *data = elem->type == EBML_BIN ? elem->priv.bin
720  : (const uint8_t*)elem->priv.str;
721  avio_write(pb, data, elem->size);
722  break;
723  }
724  case EBML_BLOCK:
725  ebml_writer_write_block(elem, pb);
726  break;
727  case EBML_MASTER: {
728  int nb_elems = elem->priv.master.nb_elements;
729 
730  elem++;
731  for (int i = 0; i < nb_elems; i++)
732  i += ebml_writer_elem_write(elem + i, pb);
733 
734  return nb_elems;
735  }
736  }
737  return 0;
738 }
739 
740 static int ebml_writer_write(EbmlWriter *writer, AVIOContext *pb)
741 {
742  int ret = ebml_writer_elem_len(writer, writer->elements,
743  writer->nb_elements);
744  if (ret < 0)
745  return ret;
746  ebml_writer_elem_write(writer->elements, pb);
747  return 0;
748 }
749 
750 static void mkv_add_seekhead_entry(MatroskaMuxContext *mkv, uint32_t elementid,
751  uint64_t filepos)
752 {
753  mkv_seekhead *seekhead = &mkv->seekhead;
754 
756 
757  seekhead->entries[seekhead->num_entries].elementid = elementid;
758  seekhead->entries[seekhead->num_entries++].segmentpos = filepos - mkv->segment_offset;
759 }
760 
762 {
763  int ret;
764 
765  if (!*dyn_cp && (ret = avio_open_dyn_buf(dyn_cp)) < 0)
766  return ret;
767 
768  if (mkv->write_crc)
769  put_ebml_void(*dyn_cp, 6); /* Reserve space for CRC32 so position/size calculations using avio_tell() take it into account */
770 
771  return 0;
772 }
773 
775  MatroskaMuxContext *mkv, uint32_t id,
776  int length_size, int keep_buffer,
777  int add_seekentry)
778 {
779  uint8_t *buf, crc[4];
780  int ret, size, skip = 0;
781 
782  size = avio_get_dyn_buf(*dyn_cp, &buf);
783  if ((ret = (*dyn_cp)->error) < 0)
784  goto fail;
785 
786  if (add_seekentry)
787  mkv_add_seekhead_entry(mkv, id, avio_tell(pb));
788 
789  put_ebml_id(pb, id);
790  put_ebml_length(pb, size, length_size);
791  if (mkv->write_crc) {
792  skip = 6; /* Skip reserved 6-byte long void element from the dynamic buffer. */
793  AV_WL32(crc, av_crc(av_crc_get_table(AV_CRC_32_IEEE_LE), UINT32_MAX, buf + skip, size - skip) ^ UINT32_MAX);
794  put_ebml_binary(pb, EBML_ID_CRC32, crc, sizeof(crc));
795  }
796  avio_write(pb, buf + skip, size - skip);
797 
798 fail:
799  if (keep_buffer) {
800  ffio_reset_dyn_buf(*dyn_cp);
801  } else {
802  ffio_free_dyn_buf(dyn_cp);
803  }
804  return ret;
805 }
806 
807 /**
808  * Output EBML master. Keep the buffer if seekable, allowing for later updates.
809  * Furthermore always add a SeekHead Entry for this element.
810  */
812  ebml_stored_master *elem,
813  MatroskaMuxContext *mkv, uint32_t id)
814 {
815  if (IS_SEEKABLE(pb, mkv)) {
816  uint8_t *buf;
817  int size = avio_get_dyn_buf(elem->bc, &buf);
818 
819  if (elem->bc->error < 0)
820  return elem->bc->error;
821 
822  elem->pos = avio_tell(pb);
823  mkv_add_seekhead_entry(mkv, id, elem->pos);
824 
825  put_ebml_id(pb, id);
826  put_ebml_length(pb, size, 0);
827  avio_write(pb, buf, size);
828 
829  return 0;
830  } else
831  return end_ebml_master_crc32(pb, &elem->bc, mkv, id, 0, 0, 1);
832 }
833 
834 static void put_xiph_size(AVIOContext *pb, int size)
835 {
836  ffio_fill(pb, 255, size / 255);
837  avio_w8(pb, size % 255);
838 }
839 
840 /**
841  * Free the members allocated in the mux context.
842  */
844 {
845  MatroskaMuxContext *mkv = s->priv_data;
846 
848  ffio_free_dyn_buf(&mkv->info.bc);
849  ffio_free_dyn_buf(&mkv->track.bc);
850  ffio_free_dyn_buf(&mkv->tags.bc);
851  ffio_free_dyn_buf(&mkv->tmp_bc);
852 
854  av_freep(&mkv->cues.entries);
855  av_freep(&mkv->tracks);
856 }
857 
858 /**
859  * Initialize the SeekHead element to be ready to index level 1 Matroska
860  * elements. Enough space to write MAX_SEEKHEAD_ENTRIES SeekHead entries
861  * will be reserved at the current file location.
862  */
864 {
865  mkv->seekhead.filepos = avio_tell(pb);
866  // 21 bytes max for a Seek entry, 6 bytes max for the SeekHead ID
867  // and size, 6 bytes for a CRC32 element, and 2 bytes to guarantee
868  // that an EBML void element will fit afterwards
871 }
872 
873 /**
874  * Write the SeekHead to the file at the location reserved for it
875  * and seek to destpos afterwards. When error_on_seek_failure
876  * is not set, failure to seek to the position designated for the
877  * SeekHead is not considered an error and it is presumed that
878  * destpos is the current position; failure to seek to destpos
879  * afterwards is always an error.
880  *
881  * @return 0 on success, < 0 on error.
882  */
884  int error_on_seek_failure, int64_t destpos)
885 {
886  AVIOContext *dyn_cp = NULL;
887  mkv_seekhead *seekhead = &mkv->seekhead;
888  int64_t remaining, ret64;
889  int i, ret;
890 
891  if ((ret64 = avio_seek(pb, seekhead->filepos, SEEK_SET)) < 0)
892  return error_on_seek_failure ? ret64 : 0;
893 
894  ret = start_ebml_master_crc32(&dyn_cp, mkv);
895  if (ret < 0)
896  return ret;
897 
898  for (i = 0; i < seekhead->num_entries; i++) {
899  mkv_seekhead_entry *entry = &seekhead->entries[i];
902 
904  put_ebml_length(dyn_cp, ebml_id_size(entry->elementid), 0);
905  put_ebml_id(dyn_cp, entry->elementid);
906 
908  end_ebml_master(dyn_cp, seekentry);
909  }
910  ret = end_ebml_master_crc32(pb, &dyn_cp, mkv,
911  MATROSKA_ID_SEEKHEAD, 0, 0, 0);
912  if (ret < 0)
913  return ret;
914 
915  remaining = seekhead->filepos + seekhead->reserved_size - avio_tell(pb);
916  put_ebml_void(pb, remaining);
917 
918  if ((ret64 = avio_seek(pb, destpos, SEEK_SET)) < 0)
919  return ret64;
920 
921  return 0;
922 }
923 
924 static int mkv_add_cuepoint(MatroskaMuxContext *mkv, int stream, int64_t ts,
925  int64_t cluster_pos, int64_t relative_pos, int64_t duration)
926 {
927  mkv_cues *cues = &mkv->cues;
928  mkv_cuepoint *entries = cues->entries;
929  unsigned idx = cues->num_entries;
930 
931  if (ts < 0)
932  return 0;
933 
934  entries = av_realloc_array(entries, cues->num_entries + 1, sizeof(mkv_cuepoint));
935  if (!entries)
936  return AVERROR(ENOMEM);
937  cues->entries = entries;
938 
939  /* Make sure the cues entries are sorted by pts. */
940  while (idx > 0 && entries[idx - 1].pts > ts)
941  idx--;
942  memmove(&entries[idx + 1], &entries[idx],
943  (cues->num_entries - idx) * sizeof(entries[0]));
944 
945  entries[idx].pts = ts;
946  entries[idx].stream_idx = stream;
947  entries[idx].cluster_pos = cluster_pos - mkv->segment_offset;
948  entries[idx].relative_pos = relative_pos;
949  entries[idx].duration = duration;
950 
951  cues->num_entries++;
952 
953  return 0;
954 }
955 
956 static int mkv_assemble_cues(AVStream **streams, AVIOContext *dyn_cp, AVIOContext *cuepoint,
957  const mkv_cues *cues, mkv_track *tracks, int num_tracks,
958  uint64_t offset)
959 {
960  for (mkv_cuepoint *entry = cues->entries, *end = entry + cues->num_entries;
961  entry < end;) {
962  uint64_t pts = entry->pts;
963  uint8_t *buf;
964  int size;
965 
967 
968  // put all the entries from different tracks that have the exact same
969  // timestamp into the same CuePoint
970  for (int j = 0; j < num_tracks; j++)
971  tracks[j].has_cue = 0;
972  do {
973  ebml_master track_positions;
974  int idx = entry->stream_idx;
975 
976  av_assert0(idx >= 0 && idx < num_tracks);
977  if (tracks[idx].has_cue && streams[idx]->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE)
978  continue;
979  tracks[idx].has_cue = 1;
981  put_ebml_uint(cuepoint, MATROSKA_ID_CUETRACK , tracks[idx].track_num);
982  put_ebml_uint(cuepoint, MATROSKA_ID_CUECLUSTERPOSITION , entry->cluster_pos + offset);
983  put_ebml_uint(cuepoint, MATROSKA_ID_CUERELATIVEPOSITION, entry->relative_pos);
984  if (entry->duration > 0)
985  put_ebml_uint(cuepoint, MATROSKA_ID_CUEDURATION , entry->duration);
986  end_ebml_master(cuepoint, track_positions);
987  } while (++entry < end && entry->pts == pts);
988  size = avio_get_dyn_buf(cuepoint, &buf);
989  if (cuepoint->error < 0)
990  return cuepoint->error;
992  ffio_reset_dyn_buf(cuepoint);
993  }
994 
995  return 0;
996 }
997 
999  const AVCodecParameters *par,
1000  const uint8_t *extradata, int extradata_size)
1001 {
1002  const uint8_t *header_start[3];
1003  int header_len[3];
1004  int first_header_size;
1005  int err, j;
1006 
1007  if (par->codec_id == AV_CODEC_ID_VORBIS)
1008  first_header_size = 30;
1009  else
1010  first_header_size = 42;
1011 
1012  err = avpriv_split_xiph_headers(extradata, extradata_size,
1013  first_header_size, header_start, header_len);
1014  if (err < 0) {
1015  av_log(s, AV_LOG_ERROR, "Extradata corrupt.\n");
1016  return err;
1017  }
1018 
1019  avio_w8(pb, 2); // number packets - 1
1020  for (j = 0; j < 2; j++) {
1021  put_xiph_size(pb, header_len[j]);
1022  }
1023  for (j = 0; j < 3; j++)
1024  avio_write(pb, header_start[j], header_len[j]);
1025 
1026  return 0;
1027 }
1028 
1029 #if CONFIG_MATROSKA_MUXER
1030 static int put_wv_codecpriv(AVIOContext *pb, const uint8_t *extradata, int extradata_size)
1031 {
1032  if (extradata && extradata_size == 2)
1033  avio_write(pb, extradata, 2);
1034  else
1035  avio_wl16(pb, 0x410); // fallback to the most recent version
1036  return 0;
1037 }
1038 
1039 static int put_flac_codecpriv(AVFormatContext *s, AVIOContext *pb,
1040  const AVCodecParameters *par,
1041  const uint8_t *extradata, int extradata_size)
1042 {
1043  int write_comment = (par->ch_layout.order == AV_CHANNEL_ORDER_NATIVE &&
1044  !(par->ch_layout.u.mask & ~0x3ffffULL) &&
1046  int ret = ff_flac_write_header(pb, extradata, extradata_size,
1047  !write_comment);
1048 
1049  if (ret < 0)
1050  return ret;
1051 
1052  if (write_comment) {
1053  const char *vendor = (s->flags & AVFMT_FLAG_BITEXACT) ?
1054  "Lavf" : LIBAVFORMAT_IDENT;
1055  AVDictionary *dict = NULL;
1056  uint8_t buf[32];
1057  int64_t len;
1058 
1059  snprintf(buf, sizeof(buf), "0x%"PRIx64, par->ch_layout.u.mask);
1060  av_dict_set(&dict, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", buf, 0);
1061 
1062  len = ff_vorbiscomment_length(dict, vendor, NULL, 0);
1063  av_assert1(len < (1 << 24) - 4);
1064 
1065  avio_w8(pb, 0x84);
1066  avio_wb24(pb, len);
1067 
1068  ff_vorbiscomment_write(pb, dict, vendor, NULL, 0);
1069 
1070  av_dict_free(&dict);
1071  }
1072 
1073  return 0;
1074 }
1075 
1076 static int get_aac_sample_rates(AVFormatContext *s, MatroskaMuxContext *mkv,
1077  const uint8_t *extradata, int extradata_size,
1078  int *sample_rate, int *output_sample_rate)
1079 {
1080  MPEG4AudioConfig mp4ac;
1081  int ret;
1082 
1083  ret = avpriv_mpeg4audio_get_config2(&mp4ac, extradata, extradata_size, 1, s);
1084  /* Don't abort if the failure is because of missing extradata. Assume in that
1085  * case a bitstream filter will provide the muxer with the extradata in the
1086  * first packet.
1087  * Abort however if s->pb is not seekable, as we would not be able to seek back
1088  * to write the sample rate elements once the extradata shows up, anyway. */
1089  if (ret < 0 && (extradata_size || !IS_SEEKABLE(s->pb, mkv))) {
1091  "Error parsing AAC extradata, unable to determine samplerate.\n");
1092  return AVERROR(EINVAL);
1093  }
1094 
1095  if (ret < 0) {
1096  /* This will only happen when this function is called while writing the
1097  * header and no extradata is available. The space for this element has
1098  * to be reserved for when this function is called again after the
1099  * extradata shows up in the first packet, as there's no way to know if
1100  * output_sample_rate will be different than sample_rate or not. */
1101  *output_sample_rate = *sample_rate;
1102  } else {
1103  *sample_rate = mp4ac.sample_rate;
1104  *output_sample_rate = mp4ac.ext_sample_rate;
1105  }
1106  return 0;
1107 }
1108 #endif
1109 
1111  const AVCodecParameters *par,
1112  const uint8_t *extradata,
1113  int extradata_size,
1114  unsigned *size_to_reserve)
1115 {
1116  switch (par->codec_id) {
1117  case AV_CODEC_ID_VORBIS:
1118  case AV_CODEC_ID_THEORA:
1119  return put_xiph_codecpriv(s, dyn_cp, par, extradata, extradata_size);
1120  case AV_CODEC_ID_AV1:
1121  if (extradata_size)
1122  return ff_isom_write_av1c(dyn_cp, extradata,
1123  extradata_size, 1);
1124  else
1125  *size_to_reserve = (AV1_SANE_SEQUENCE_HEADER_MAX_BITS + 7) / 8 + 100;
1126  break;
1127 #if CONFIG_MATROSKA_MUXER
1128  case AV_CODEC_ID_FLAC:
1129  return put_flac_codecpriv(s, dyn_cp, par, extradata, extradata_size);
1130  case AV_CODEC_ID_WAVPACK:
1131  return put_wv_codecpriv(dyn_cp, extradata, extradata_size);
1132  case AV_CODEC_ID_H264:
1133  return ff_isom_write_avcc(dyn_cp, extradata,
1134  extradata_size);
1135  case AV_CODEC_ID_HEVC:
1136  return ff_isom_write_hvcc(dyn_cp, extradata,
1137  extradata_size, 0);
1138  case AV_CODEC_ID_ALAC:
1139  if (extradata_size < 36) {
1141  "Invalid extradata found, ALAC expects a 36-byte "
1142  "QuickTime atom.");
1143  return AVERROR_INVALIDDATA;
1144  } else
1145  avio_write(dyn_cp, extradata + 12,
1146  extradata_size - 12);
1147  break;
1148  case AV_CODEC_ID_AAC:
1149  if (extradata_size)
1150  avio_write(dyn_cp, extradata, extradata_size);
1151  else
1152  *size_to_reserve = MAX_PCE_SIZE;
1153  break;
1154  case AV_CODEC_ID_ARIB_CAPTION: {
1155  unsigned stream_identifier, data_component_id;
1156  switch (par->profile) {
1158  stream_identifier = 0x30;
1159  data_component_id = 0x0008;
1160  break;
1162  stream_identifier = 0x87;
1163  data_component_id = 0x0012;
1164  break;
1165  default:
1167  "Unset/unknown ARIB caption profile %d utilized!\n",
1168  par->profile);
1169  return AVERROR_INVALIDDATA;
1170  }
1171  avio_w8(dyn_cp, stream_identifier);
1172  avio_wb16(dyn_cp, data_component_id);
1173  break;
1174  }
1175 #endif
1176  default:
1177  if (CONFIG_MATROSKA_MUXER && par->codec_id == AV_CODEC_ID_PRORES &&
1179  avio_wl32(dyn_cp, par->codec_tag);
1180  } else if (extradata_size && par->codec_id != AV_CODEC_ID_TTA)
1181  avio_write(dyn_cp, extradata, extradata_size);
1182  }
1183 
1184  return 0;
1185 }
1186 
1188  AVCodecParameters *par,
1189  const uint8_t *extradata, int extradata_size,
1190  int native_id, int qt_id,
1191  uint8_t **codecpriv, int *codecpriv_size,
1192  unsigned *max_payload_size)
1193 {
1194  MatroskaMuxContext av_unused *const mkv = s->priv_data;
1195  unsigned size_to_reserve = 0;
1196  int ret;
1197 
1198  if (native_id) {
1199  ret = mkv_assemble_native_codecprivate(s, dyn_cp, par,
1200  extradata, extradata_size,
1201  &size_to_reserve);
1202  if (ret < 0)
1203  return ret;
1204 #if CONFIG_MATROSKA_MUXER
1205  } else if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
1206  if (qt_id) {
1207  if (!par->codec_tag)
1209  par->codec_id);
1211  && (!extradata_size || ff_codec_get_id(ff_codec_movvideo_tags, AV_RL32(extradata + 4)) != par->codec_id)
1212  ) {
1213  avio_wb32(dyn_cp, 0x5a + extradata_size);
1214  avio_wl32(dyn_cp, par->codec_tag);
1215  ffio_fill(dyn_cp, 0, 0x5a - 8);
1216  }
1217  avio_write(dyn_cp, extradata, extradata_size);
1218  } else {
1220  av_log(s, AV_LOG_WARNING, "codec %s is not supported by this format\n",
1221  avcodec_get_name(par->codec_id));
1222 
1223  if (!par->codec_tag)
1225  par->codec_id);
1226  if (!par->codec_tag && par->codec_id != AV_CODEC_ID_RAWVIDEO) {
1227  av_log(s, AV_LOG_ERROR, "No bmp codec tag found for codec %s\n",
1228  avcodec_get_name(par->codec_id));
1229  return AVERROR(EINVAL);
1230  }
1231 
1232  /* If vfw extradata updates are supported, this will have
1233  * to be updated to pass extradata(_size) explicitly. */
1234  ff_put_bmp_header(dyn_cp, par, 0, 0, mkv->flipped_raw_rgb);
1235  }
1236  } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
1237  unsigned int tag;
1239  if (!tag) {
1240  av_log(s, AV_LOG_ERROR, "No wav codec tag found for codec %s\n",
1241  avcodec_get_name(par->codec_id));
1242  return AVERROR(EINVAL);
1243  }
1244  if (!par->codec_tag)
1245  par->codec_tag = tag;
1246 
1247  /* Same comment as for ff_put_bmp_header applies here. */
1249 #endif
1250  }
1251 
1252  *codecpriv_size = avio_get_dyn_buf(dyn_cp, codecpriv);
1253  if (dyn_cp->error < 0)
1254  return dyn_cp->error;
1255  *max_payload_size = *codecpriv_size + size_to_reserve;
1256 
1257  return 0;
1258 }
1259 
1260 static void mkv_put_codecprivate(AVIOContext *pb, unsigned max_payload_size,
1261  const uint8_t *codecpriv, unsigned codecpriv_size)
1262 {
1263  unsigned total_codecpriv_size = 0, total_size;
1264 
1265  av_assert1(codecpriv_size <= max_payload_size);
1266 
1267  if (!max_payload_size)
1268  return;
1269 
1270  total_size = 2 + ebml_length_size(max_payload_size) + max_payload_size;
1271 
1272  if (codecpriv_size) {
1273  unsigned length_size = ebml_length_size(codecpriv_size);
1274 
1275  total_codecpriv_size = 2U + length_size + codecpriv_size;
1276  if (total_codecpriv_size + 1 == total_size) {
1277  /* It is impossible to add one byte of padding via an EBML Void. */
1278  length_size++;
1279  total_codecpriv_size++;
1280  }
1282  put_ebml_length(pb, codecpriv_size, length_size);
1283  avio_write(pb, codecpriv, codecpriv_size);
1284  }
1285  if (total_codecpriv_size < total_size)
1286  put_ebml_void(pb, total_size - total_codecpriv_size);
1287 }
1288 
1290  uint8_t *side_data, int side_data_size,
1291  AVCodecParameters *par, AVIOContext *pb,
1292  mkv_track *track, unsigned alternative_size)
1293 {
1294  AVIOContext *const dyn_bc = mkv->tmp_bc;
1295  uint8_t *codecpriv;
1296  unsigned max_payload_size;
1297  int ret, codecpriv_size;
1298 
1299  ret = mkv_assemble_codecprivate(s, dyn_bc, par,
1300  side_data, side_data_size, 1, 0,
1301  &codecpriv, &codecpriv_size, &max_payload_size);
1302  if (ret < 0)
1303  goto fail;
1304  if (codecpriv_size > track->codecpriv_size && !alternative_size) {
1305  ret = AVERROR(ENOSPC);
1306  goto fail;
1307  } else if (codecpriv_size > track->codecpriv_size) {
1308  av_assert1(alternative_size < track->codecpriv_size);
1309  codecpriv_size = alternative_size;
1310  }
1311  avio_seek(pb, track->codecpriv_offset, SEEK_SET);
1313  codecpriv, codecpriv_size);
1314 
1315  if (!par->extradata_size) {
1316  ret = ff_alloc_extradata(par, side_data_size);
1317  if (ret < 0)
1318  goto fail;
1319  memcpy(par->extradata, side_data, side_data_size);
1320  }
1321 fail:
1322  ffio_reset_dyn_buf(dyn_bc);
1323  return ret;
1324 }
1325 
1326 #define MAX_VIDEO_COLOR_ELEMS 20
1327 static void mkv_write_video_color(EbmlWriter *writer, const AVStream *st,
1328  const AVCodecParameters *par)
1329 {
1330  const void *side_data;
1331 
1333 
1334  if (par->color_trc != AVCOL_TRC_UNSPECIFIED &&
1335  par->color_trc < AVCOL_TRC_NB) {
1337  par->color_trc);
1338  }
1339  if (par->color_space != AVCOL_SPC_UNSPECIFIED &&
1340  par->color_space < AVCOL_SPC_NB) {
1342  par->color_space);
1343  }
1344  if (par->color_primaries != AVCOL_PRI_UNSPECIFIED &&
1345  par->color_primaries < AVCOL_PRI_NB) {
1347  par->color_primaries);
1348  }
1349  if (par->color_range != AVCOL_RANGE_UNSPECIFIED &&
1350  par->color_range < AVCOL_RANGE_NB) {
1352  }
1355  int xpos, ypos;
1356 
1357  av_chroma_location_enum_to_pos(&xpos, &ypos, par->chroma_location);
1359  (xpos >> 7) + 1);
1361  (ypos >> 7) + 1);
1362  }
1363 
1365  NULL);
1366  if (side_data) {
1367  const AVContentLightMetadata *metadata = side_data;
1369  metadata->MaxCLL);
1371  metadata->MaxFALL);
1372  }
1373 
1375  NULL);
1376  if (side_data) {
1377  const AVMasteringDisplayMetadata *metadata = side_data;
1379  if (metadata->has_primaries) {
1381  av_q2d(metadata->display_primaries[0][0]));
1383  av_q2d(metadata->display_primaries[0][1]));
1385  av_q2d(metadata->display_primaries[1][0]));
1387  av_q2d(metadata->display_primaries[1][1]));
1389  av_q2d(metadata->display_primaries[2][0]));
1391  av_q2d(metadata->display_primaries[2][1]));
1393  av_q2d(metadata->white_point[0]));
1395  av_q2d(metadata->white_point[1]));
1396  }
1397  if (metadata->has_luminance) {
1399  av_q2d(metadata->max_luminance));
1401  av_q2d(metadata->min_luminance));
1402  }
1404  }
1405 
1407 }
1408 
1409 #define MAX_VIDEO_PROJECTION_ELEMS 6
1410 static void mkv_handle_rotation(void *logctx, const AVStream *st,
1411  double *yaw, double *roll)
1412 {
1413  const int32_t *matrix =
1415 
1416  if (!matrix)
1417  return;
1418 
1419  /* Check whether this is an affine transformation */
1420  if (matrix[2] || matrix[5])
1421  goto ignore;
1422 
1423  /* This together with the checks below test whether
1424  * the upper-left 2x2 matrix is nonsingular. */
1425  if (!matrix[0] && !matrix[1])
1426  goto ignore;
1427 
1428  /* We ignore the translation part of the matrix (matrix[6] and matrix[7])
1429  * as well as any scaling, i.e. we only look at the upper left 2x2 matrix.
1430  * We only accept matrices that are an exact multiple of an orthogonal one.
1431  * Apart from the multiple, every such matrix can be obtained by
1432  * potentially flipping in the x-direction (corresponding to yaw = 180)
1433  * followed by a rotation of (say) an angle phi in the counterclockwise
1434  * direction. The upper-left 2x2 matrix then looks like this:
1435  * | (+/-)cos(phi) (-/+)sin(phi) |
1436  * scale * | |
1437  * | sin(phi) cos(phi) |
1438  * The first set of signs in the first row apply in case of no flipping,
1439  * the second set applies in case of flipping. */
1440 
1441  /* The casts to int64_t are needed because -INT32_MIN doesn't fit
1442  * in an int32_t. */
1443  if (matrix[0] == matrix[4] && -(int64_t)matrix[1] == matrix[3]) {
1444  /* No flipping case */
1445  *yaw = 0;
1446  } else if (-(int64_t)matrix[0] == matrix[4] && matrix[1] == matrix[3]) {
1447  /* Horizontal flip */
1448  *yaw = 180;
1449  } else {
1450 ignore:
1451  av_log(logctx, AV_LOG_INFO, "Ignoring display matrix indicating "
1452  "non-orthogonal transformation.\n");
1453  return;
1454  }
1455  *roll = 180 / M_PI * atan2(matrix[3], matrix[4]);
1456 
1457  /* We do not write a ProjectionType element indicating "rectangular",
1458  * because this is the default value. */
1459 }
1460 
1461 static int mkv_handle_spherical(void *logctx, EbmlWriter *writer,
1462  const AVStream *st, uint8_t private[],
1463  double *yaw, double *pitch, double *roll)
1464 {
1465  const AVSphericalMapping *spherical =
1467  NULL);
1468 
1469  if (!spherical)
1470  return 0;
1471 
1472  if (spherical->projection != AV_SPHERICAL_EQUIRECTANGULAR &&
1474  spherical->projection != AV_SPHERICAL_CUBEMAP) {
1475  av_log(logctx, AV_LOG_WARNING, "Unknown projection type\n");
1476  return 0;
1477  }
1478 
1479  switch (spherical->projection) {
1484  AV_WB32(private, 0); // version + flags
1485  if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR) {
1486  AV_WB32(private + 4, 0);
1487  AV_WB32(private + 8, 0);
1488  AV_WB32(private + 12, 0);
1489  AV_WB32(private + 16, 0);
1490  } else {
1491  AV_WB32(private + 4, spherical->bound_top);
1492  AV_WB32(private + 8, spherical->bound_bottom);
1493  AV_WB32(private + 12, spherical->bound_left);
1494  AV_WB32(private + 16, spherical->bound_right);
1495  }
1497  private, 20);
1498  break;
1499  case AV_SPHERICAL_CUBEMAP:
1502  AV_WB32(private, 0); // version + flags
1503  AV_WB32(private + 4, 0); // layout
1504  AV_WB32(private + 8, spherical->padding);
1506  private, 12);
1507  break;
1508  default:
1509  av_assert0(0);
1510  }
1511 
1512  *yaw = (double) spherical->yaw / (1 << 16);
1513  *pitch = (double) spherical->pitch / (1 << 16);
1514  *roll = (double) spherical->roll / (1 << 16);
1515 
1516  return 1; /* Projection included */
1517 }
1518 
1519 static void mkv_write_video_projection(void *logctx, EbmlWriter *wr,
1520  const AVStream *st, uint8_t private[])
1521 {
1522  double yaw = 0, pitch = 0, roll = 0;
1523  int ret;
1524 
1526 
1527  ret = mkv_handle_spherical(logctx, wr, st, private, &yaw, &pitch, &roll);
1528  if (!ret)
1529  mkv_handle_rotation(logctx, st, &yaw, &roll);
1530 
1531  if (yaw)
1533  if (pitch)
1535  if (roll)
1537 
1539 }
1540 
1541 #define MAX_FIELD_ORDER_ELEMS 2
1542 static void mkv_write_field_order(EbmlWriter *writer, int is_webm,
1543  enum AVFieldOrder field_order)
1544 {
1545  switch (field_order) {
1546  case AV_FIELD_UNKNOWN:
1547  break;
1548  case AV_FIELD_PROGRESSIVE:
1551  break;
1552  case AV_FIELD_TT:
1553  case AV_FIELD_BB:
1554  case AV_FIELD_TB:
1555  case AV_FIELD_BT:
1558  if (!is_webm) {
1559  switch (field_order) {
1560  case AV_FIELD_TT:
1563  break;
1564  case AV_FIELD_BB:
1567  break;
1568  case AV_FIELD_TB:
1571  break;
1572  case AV_FIELD_BT:
1575  break;
1576  }
1577  }
1578  }
1579 }
1580 
1581 #define MAX_STEREO_MODE_ELEMS 1
1583  const AVStream *st, int is_webm,
1584  int *h_width, int *h_height)
1585 {
1586  const char *error_message_addendum = "";
1587  const AVDictionaryEntry *tag;
1589 
1590  /* The following macros create bitfields where the ith bit
1591  * indicates whether the MatroskaVideoStereoModeType with that value
1592  * uses double width/height or is WebM compatible. */
1593 #define FLAG(STEREOMODETYPE, BOOL) | (BOOL) << (STEREOMODETYPE)
1594 #define WDIV1(STEREOMODETYPE, STEREO3DTYPE, FLAGS, WDIV, HDIV, WEBM) \
1595  FLAG(STEREOMODETYPE, WDIV)
1596 #define WDIV2(STEREOMODETYPE, WDIV, HDIV, WEBM) \
1597  FLAG(STEREOMODETYPE, WDIV)
1598  // The zero in the following line consumes the first '|'.
1599  const unsigned width_bitfield = 0 STEREOMODE_STEREO3D_MAPPING(WDIV1, WDIV2);
1600 
1601 #define HDIV1(STEREOMODETYPE, STEREO3DTYPE, FLAGS, WDIV, HDIV, WEBM) \
1602  FLAG(STEREOMODETYPE, HDIV)
1603 #define HDIV2(STEREOMODETYPE, WDIV, HDIV, WEBM) \
1604  FLAG(STEREOMODETYPE, HDIV)
1605  const unsigned height_bitfield = 0 STEREOMODE_STEREO3D_MAPPING(HDIV1, HDIV2);
1606 
1607 #define WEBM1(STEREOMODETYPE, STEREO3DTYPE, FLAGS, WDIV, HDIV, WEBM) \
1608  FLAG(STEREOMODETYPE, WEBM)
1609 #define WEBM2(STEREOMODETYPE, WDIV, HDIV, WEBM) \
1610  FLAG(STEREOMODETYPE, WEBM)
1611  const unsigned webm_bitfield = 0 STEREOMODE_STEREO3D_MAPPING(WEBM1, WEBM2);
1612 
1613  *h_width = 1;
1614  *h_height = 1;
1615 
1616  if ((tag = av_dict_get(st->metadata, "stereo_mode", NULL, 0)) ||
1617  (tag = av_dict_get( s->metadata, "stereo_mode", NULL, 0))) {
1618 
1619  for (int i = 0; i < MATROSKA_VIDEO_STEREOMODE_TYPE_NB; i++)
1620  if (!strcmp(tag->value, ff_matroska_video_stereo_mode[i])){
1621  format = i;
1622  break;
1623  }
1625  long stereo_mode = strtol(tag->value, NULL, 0);
1626  if ((unsigned long)stereo_mode >= MATROSKA_VIDEO_STEREOMODE_TYPE_NB)
1627  goto fail;
1628  format = stereo_mode;
1629  }
1630  } else {
1631  const AVStereo3D *stereo;
1632  /* The following macro presumes all MATROSKA_VIDEO_STEREOMODE_TYPE_*
1633  * values to be in the range 0..254. */
1634 #define STEREOMODE(STEREOMODETYPE, STEREO3DTYPE, FLAGS, WDIV, HDIV, WEBM) \
1635  [(STEREO3DTYPE)][!!((FLAGS) & AV_STEREO3D_FLAG_INVERT)] = (STEREOMODETYPE) + 1,
1636 #define NOTHING(STEREOMODETYPE, WDIV, HDIV, WEBM)
1637  static const unsigned char conversion_table[][2] = {
1639  };
1640  int fmt;
1641 
1643  NULL);
1644  if (!stereo)
1645  return 0;
1646 
1647  /* A garbage AVStereo3D or something with no Matroska analogon. */
1648  if ((unsigned)stereo->type >= FF_ARRAY_ELEMS(conversion_table))
1649  return 0;
1650 
1651  fmt = conversion_table[stereo->type][!!(stereo->flags & AV_STEREO3D_FLAG_INVERT)];
1652  /* Format with no Matroska analogon; ignore it */
1653  if (!fmt)
1654  return 0;
1655  format = fmt - 1;
1656  }
1657 
1658  // if webm, do not write unsupported modes
1659  if (is_webm && !(webm_bitfield >> format)) {
1660  error_message_addendum = " for WebM";
1661  goto fail;
1662  }
1663 
1664  *h_width = 1 << ((width_bitfield >> format) & 1);
1665  *h_height = 1 << ((height_bitfield >> format) & 1);
1666 
1667  // write StereoMode if format is valid
1669 
1670  return 0;
1671 fail:
1673  "The specified stereo mode is not valid%s.\n",
1674  error_message_addendum);
1675  return AVERROR(EINVAL);
1676 }
1677 
1679  const AVCodecParameters *par, AVIOContext *pb,
1680  mkv_track *track, const AVStream *st)
1681 {
1682 #if CONFIG_MATROSKA_MUXER
1684 
1685  if (IS_SEEKABLE(s->pb, mkv)) {
1687  // We can't know at this point if there will be a block with BlockAdditions, so
1688  // we either write the default value here, or a void element. Either of them will
1689  // be overwritten when finishing the track.
1691  if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
1692  // Similarly, reserve space for an eventual
1693  // HDR10+ ITU T.35 metadata BlockAdditionMapping.
1694  put_ebml_void(pb, 3 /* BlockAdditionMapping */
1695  + 4 /* BlockAddIDValue */
1696  + 4 /* BlockAddIDType */);
1697  }
1698  }
1699 
1700  dovi = (const AVDOVIDecoderConfigurationRecord *)
1702  if (dovi && dovi->dv_profile <= 10) {
1703  ebml_master mapping;
1704  uint8_t buf[ISOM_DVCC_DVVC_SIZE];
1705  uint32_t type;
1706 
1707  uint64_t expected_size = (2 + 1 + (sizeof(DVCC_DVVC_BLOCK_TYPE_NAME) - 1))
1708  + (2 + 1 + 4) + (2 + 1 + ISOM_DVCC_DVVC_SIZE);
1709 
1710  if (dovi->dv_profile > 7) {
1712  } else {
1714  }
1715 
1716  ff_isom_put_dvcc_dvvc(s, buf, dovi);
1717 
1718  mapping = start_ebml_master(pb, MATROSKA_ID_TRACKBLKADDMAPPING, expected_size);
1719 
1722  put_ebml_binary(pb, MATROSKA_ID_BLKADDIDEXTRADATA, buf, sizeof(buf));
1723 
1724  end_ebml_master(pb, mapping);
1725  }
1726 #endif
1727 }
1728 
1730  const AVStream *st, const AVCodecParameters *par,
1731  AVIOContext *pb)
1732 {
1733  const AVDictionaryEntry *tag;
1734  int display_width_div = 1, display_height_div = 1;
1735  uint8_t color_space[4], projection_private[20];
1738  int ret;
1739 
1741 
1744 
1745  mkv_write_field_order(&writer, IS_WEBM(mkv), par->field_order);
1746 
1747  // check both side data and metadata for stereo information,
1748  // write the result to the bitstream if any is found
1749  ret = mkv_write_stereo_mode(s, &writer, st, IS_WEBM(mkv),
1750  &display_width_div,
1751  &display_height_div);
1752  if (ret < 0)
1753  return ret;
1754 
1755  if (par->format == AV_PIX_FMT_YUVA420P ||
1756  ((tag = av_dict_get(st->metadata, "alpha_mode", NULL, 0)) ||
1757  (tag = av_dict_get( s->metadata, "alpha_mode", NULL, 0))) && strtol(tag->value, NULL, 0))
1759 
1760  // write DisplayWidth and DisplayHeight, they contain the size of
1761  // a single source view and/or the display aspect ratio
1762  if (st->sample_aspect_ratio.num) {
1763  int64_t d_width = av_rescale(par->width, st->sample_aspect_ratio.num, st->sample_aspect_ratio.den);
1764  if (d_width > INT_MAX) {
1765  av_log(s, AV_LOG_ERROR, "Overflow in display width\n");
1766  return AVERROR(EINVAL);
1767  }
1768  if (d_width != par->width || display_width_div != 1 || display_height_div != 1) {
1769  if (IS_WEBM(mkv) || display_width_div != 1 || display_height_div != 1) {
1771  d_width / display_width_div);
1773  par->height / display_height_div);
1774  } else {
1775  AVRational display_aspect_ratio;
1776  av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
1777  par->width * (int64_t)st->sample_aspect_ratio.num,
1778  par->height * (int64_t)st->sample_aspect_ratio.den,
1779  1024 * 1024);
1781  display_aspect_ratio.num);
1783  display_aspect_ratio.den);
1786  }
1787  }
1788  } else if (display_width_div != 1 || display_height_div != 1) {
1790  par->width / display_width_div);
1792  par->height / display_height_div);
1793  } else if (!IS_WEBM(mkv))
1796 
1797  if (par->codec_id == AV_CODEC_ID_RAWVIDEO) {
1798  AV_WL32(color_space, par->codec_tag);
1800  color_space, sizeof(color_space));
1801  }
1802  mkv_write_video_color(&writer, st, par);
1803  mkv_write_video_projection(s, &writer, st, projection_private);
1804 
1805  return ebml_writer_write(&writer, pb);
1806 }
1807 
1809  AVStream *st, mkv_track *track, AVIOContext *pb,
1810  int is_default)
1811 {
1812  AVCodecParameters *par = st->codecpar;
1813  ebml_master subinfo, track_master;
1814  int native_id = 0;
1815  int qt_id = 0;
1816  int bit_depth;
1817  int sample_rate = par->sample_rate;
1818  int output_sample_rate = 0;
1819  int j, ret;
1820  const AVDictionaryEntry *tag;
1821 
1822  if (par->codec_type == AVMEDIA_TYPE_ATTACHMENT)
1823  return 0;
1824 
1825  track_master = start_ebml_master(pb, MATROSKA_ID_TRACKENTRY, 0);
1827  put_ebml_uid (pb, MATROSKA_ID_TRACKUID, track->uid);
1828  put_ebml_uint(pb, MATROSKA_ID_TRACKFLAGLACING, 0); // no lacing (yet)
1829 
1830  if ((tag = av_dict_get(st->metadata, "title", NULL, 0)))
1832  tag = av_dict_get(st->metadata, "language", NULL, 0);
1834  tag && tag->value[0] ? tag->value : "und");
1835 
1836  // The default value for TRACKFLAGDEFAULT is 1, so add element
1837  // if we need to clear it.
1838  if (!is_default)
1840 
1843 
1844  if (IS_WEBM(mkv)) {
1845  const char *codec_id;
1846  if (par->codec_id != AV_CODEC_ID_WEBVTT) {
1847  for (j = 0; ff_webm_codec_tags[j].id != AV_CODEC_ID_NONE; j++) {
1848  if (ff_webm_codec_tags[j].id == par->codec_id) {
1850  native_id = 1;
1851  break;
1852  }
1853  }
1854  } else {
1856  codec_id = "D_WEBVTT/CAPTIONS";
1857  native_id = MATROSKA_TRACK_TYPE_SUBTITLE;
1858  } else if (st->disposition & AV_DISPOSITION_DESCRIPTIONS) {
1859  codec_id = "D_WEBVTT/DESCRIPTIONS";
1860  native_id = MATROSKA_TRACK_TYPE_METADATA;
1861  } else if (st->disposition & AV_DISPOSITION_METADATA) {
1862  codec_id = "D_WEBVTT/METADATA";
1863  native_id = MATROSKA_TRACK_TYPE_METADATA;
1864  } else {
1865  codec_id = "D_WEBVTT/SUBTITLES";
1866  native_id = MATROSKA_TRACK_TYPE_SUBTITLE;
1867  }
1868  }
1869 
1870  if (!native_id) {
1872  "Only VP8 or VP9 or AV1 video and Vorbis or Opus audio and WebVTT subtitles are supported for WebM.\n");
1873  return AVERROR(EINVAL);
1874  }
1875 
1877  } else {
1889 
1890  // look for a codec ID string specific to mkv to use,
1891  // if none are found, use AVI codes
1892  if (par->codec_id == AV_CODEC_ID_FFV1) {
1893  /* FFV1 is actually supported natively in Matroska,
1894  * yet we use the VfW way to mux it for compatibility
1895  * with old demuxers. (FIXME: Are they really important?) */
1896  } else if (par->codec_id != AV_CODEC_ID_RAWVIDEO || par->codec_tag) {
1897  for (j = 0; ff_mkv_codec_tags[j].id != AV_CODEC_ID_NONE; j++) {
1898  if (ff_mkv_codec_tags[j].id == par->codec_id) {
1900  native_id = 1;
1901  break;
1902  }
1903  }
1904  } else {
1905  if (mkv->allow_raw_vfw) {
1906  native_id = 0;
1907  } else {
1908  av_log(s, AV_LOG_ERROR, "Raw RGB is not supported Natively in Matroska, you can use AVI or NUT or\n"
1909  "If you would like to store it anyway using VFW mode, enable allow_raw_vfw (-allow_raw_vfw 1)\n");
1910  return AVERROR(EINVAL);
1911  }
1912  }
1913  }
1914 
1915  switch (par->codec_type) {
1916  case AVMEDIA_TYPE_VIDEO:
1917  mkv->have_video = 1;
1919 
1920  if( st->avg_frame_rate.num > 0 && st->avg_frame_rate.den > 0
1921  && av_cmp_q(av_inv_q(st->avg_frame_rate), st->time_base) > 0)
1923  else if( st->r_frame_rate.num > 0 && st->r_frame_rate.den > 0
1924  && av_cmp_q(av_inv_q(st->r_frame_rate), st->time_base) > 0)
1926 
1927  if (CONFIG_MATROSKA_MUXER && !native_id &&
1930  par->codec_id == AV_CODEC_ID_SVQ1 ||
1931  par->codec_id == AV_CODEC_ID_SVQ3 ||
1932  par->codec_id == AV_CODEC_ID_CINEPAK))
1933  qt_id = 1;
1934 
1935  if (qt_id)
1936  put_ebml_string(pb, MATROSKA_ID_CODECID, "V_QUICKTIME");
1937  else if (!native_id) {
1938  // if there is no mkv-specific codec ID, use VFW mode
1939  put_ebml_string(pb, MATROSKA_ID_CODECID, "V_MS/VFW/FOURCC");
1940  track->write_dts = 1;
1942  }
1943 
1944  ret = mkv_write_track_video(s, mkv, st, par, pb);
1945  if (ret < 0)
1946  return ret;
1947 
1948  break;
1949 
1950  case AVMEDIA_TYPE_AUDIO:
1951  if (par->initial_padding) {
1952  int64_t codecdelay = av_rescale_q(par->initial_padding,
1953  (AVRational){ 1, par->sample_rate },
1954  (AVRational){ 1, 1000000000 });
1955  if (codecdelay < 0) {
1956  av_log(s, AV_LOG_ERROR, "Initial padding is invalid\n");
1957  return AVERROR(EINVAL);
1958  }
1959  put_ebml_uint(pb, MATROSKA_ID_CODECDELAY, codecdelay);
1960 
1961  track->ts_offset = av_rescale_q(par->initial_padding,
1962  (AVRational){ 1, par->sample_rate },
1963  st->time_base);
1964  ffstream(st)->lowest_ts_allowed = -track->ts_offset;
1965  }
1966  if (par->codec_id == AV_CODEC_ID_OPUS)
1968 #if CONFIG_MATROSKA_MUXER
1969  else if (par->codec_id == AV_CODEC_ID_AAC) {
1970  ret = get_aac_sample_rates(s, mkv, par->extradata, par->extradata_size,
1971  &sample_rate, &output_sample_rate);
1972  if (ret < 0)
1973  return ret;
1974  }
1975 #endif
1976 
1978 
1979  if (!native_id)
1980  // no mkv-specific ID, use ACM mode
1981  put_ebml_string(pb, MATROSKA_ID_CODECID, "A_MS/ACM");
1982 
1983  subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKAUDIO, 6 + 4 * 9);
1985 
1986  track->sample_rate_offset = avio_tell(pb);
1988  if (output_sample_rate)
1989  put_ebml_float(pb, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate);
1990 
1992  if (!bit_depth && par->codec_id != AV_CODEC_ID_ADPCM_G726) {
1993  if (par->bits_per_raw_sample)
1995  else
1997  }
1998  if (!bit_depth)
2000  if (bit_depth)
2002  end_ebml_master(pb, subinfo);
2003  break;
2004 
2005  case AVMEDIA_TYPE_SUBTITLE:
2006  if (!native_id) {
2007  av_log(s, AV_LOG_ERROR, "Subtitle codec %d is not supported.\n", par->codec_id);
2008  return AVERROR(ENOSYS);
2009  }
2010  if (!IS_WEBM(mkv) && st->disposition & AV_DISPOSITION_DESCRIPTIONS)
2012 
2013  if (!IS_WEBM(mkv) || par->codec_id != AV_CODEC_ID_WEBVTT)
2014  native_id = MATROSKA_TRACK_TYPE_SUBTITLE;
2015 
2016  put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, native_id);
2017  break;
2018  default:
2019  av_log(s, AV_LOG_ERROR, "Only audio, video, and subtitles are supported for Matroska.\n");
2020  return AVERROR(EINVAL);
2021  }
2022 
2023  if (!IS_WEBM(mkv))
2024  mkv_write_blockadditionmapping(s, mkv, par, pb, track, st);
2025 
2026  if (!IS_WEBM(mkv) || par->codec_id != AV_CODEC_ID_WEBVTT) {
2027  uint8_t *codecpriv;
2028  int codecpriv_size, max_payload_size;
2029  track->codecpriv_offset = avio_tell(pb);
2030  ret = mkv_assemble_codecprivate(s, mkv->tmp_bc, par,
2031  par->extradata, par->extradata_size,
2032  native_id, qt_id,
2033  &codecpriv, &codecpriv_size, &max_payload_size);
2034  if (ret < 0)
2035  goto fail;
2036  mkv_put_codecprivate(pb, max_payload_size, codecpriv, codecpriv_size);
2037  track->codecpriv_size = max_payload_size;
2038  }
2039 
2040  end_ebml_master(pb, track_master);
2041  ret = 0;
2042 fail:
2043  ffio_reset_dyn_buf(mkv->tmp_bc);
2044 
2045  return ret;
2046 }
2047 
2049 {
2050  MatroskaMuxContext *mkv = s->priv_data;
2051  AVIOContext *pb = s->pb;
2052  int video_default_idx = -1, audio_default_idx = -1, subtitle_default_idx = -1;
2053  int i, ret;
2054 
2055  if (mkv->nb_attachments == s->nb_streams)
2056  return 0;
2057 
2058  ret = start_ebml_master_crc32(&mkv->track.bc, mkv);
2059  if (ret < 0)
2060  return ret;
2061 
2062  if (mkv->default_mode != DEFAULT_MODE_PASSTHROUGH) {
2063  int video_idx = -1, audio_idx = -1, subtitle_idx = -1;
2064 
2065  for (i = s->nb_streams - 1; i >= 0; i--) {
2066  AVStream *st = s->streams[i];
2067 
2068  switch (st->codecpar->codec_type) {
2069 #define CASE(type, variable) \
2070  case AVMEDIA_TYPE_ ## type: \
2071  variable ## _idx = i; \
2072  if (st->disposition & AV_DISPOSITION_DEFAULT) \
2073  variable ## _default_idx = i; \
2074  break;
2075  CASE(VIDEO, video)
2076  CASE(AUDIO, audio)
2077  CASE(SUBTITLE, subtitle)
2078 #undef CASE
2079  }
2080  }
2081 
2082  video_default_idx = FFMAX(video_default_idx, video_idx);
2083  audio_default_idx = FFMAX(audio_default_idx, audio_idx);
2085  subtitle_default_idx = FFMAX(subtitle_default_idx, subtitle_idx);
2086  }
2087  for (i = 0; i < s->nb_streams; i++) {
2088  AVStream *st = s->streams[i];
2089  int is_default = st->disposition & AV_DISPOSITION_DEFAULT ||
2090  i == video_default_idx || i == audio_default_idx ||
2091  i == subtitle_default_idx;
2092  ret = mkv_write_track(s, mkv, st, &mkv->tracks[i],
2093  mkv->track.bc, is_default);
2094  if (ret < 0)
2095  return ret;
2096  }
2097 
2098  return end_ebml_master_crc32_tentatively(pb, &mkv->track, mkv,
2100 }
2101 
2103 {
2104  EBML_WRITER(4);
2105  uint8_t *key = av_strdup(t->key);
2106  uint8_t *p = key;
2107  const uint8_t *lang = NULL;
2108  int ret;
2109 
2110  if (!key)
2111  return AVERROR(ENOMEM);
2112 
2113  if ((p = strrchr(p, '-')) &&
2114  (lang = ff_convert_lang_to(p + 1, AV_LANG_ISO639_2_BIBL)))
2115  *p = 0;
2116 
2117  p = key;
2118  while (*p) {
2119  if (*p == ' ')
2120  *p = '_';
2121  else if (*p >= 'a' && *p <= 'z')
2122  *p -= 'a' - 'A';
2123  p++;
2124  }
2125 
2128  if (lang)
2131  ret = ebml_writer_write(&writer, pb);
2132 
2133  av_freep(&key);
2134  return ret;
2135 }
2136 
2138  uint32_t elementid, uint64_t uid)
2139 {
2141  4 + 1 + 8);
2142  if (elementid)
2143  put_ebml_uid(pb, elementid, uid);
2144  end_ebml_master(pb, targets);
2145 }
2146 
2147 static int mkv_check_tag_name(const char *name, uint32_t elementid)
2148 {
2149  return av_strcasecmp(name, "title") &&
2150  av_strcasecmp(name, "stereo_mode") &&
2151  av_strcasecmp(name, "creation_time") &&
2152  av_strcasecmp(name, "encoding_tool") &&
2153  av_strcasecmp(name, "duration") &&
2154  (elementid != MATROSKA_ID_TAGTARGETS_TRACKUID ||
2155  av_strcasecmp(name, "language")) &&
2156  (elementid != MATROSKA_ID_TAGTARGETS_ATTACHUID ||
2157  (av_strcasecmp(name, "filename") &&
2158  av_strcasecmp(name, "mimetype")));
2159 }
2160 
2162  AVIOContext **pb, unsigned reserved_size,
2163  uint32_t elementid, uint64_t uid)
2164 {
2165  const AVDictionaryEntry *t = NULL;
2166  AVIOContext *const tmp_bc = mkv->tmp_bc;
2167  uint8_t *buf;
2168  int ret = 0, size, tag_written = 0;
2169 
2170  mkv_write_tag_targets(mkv, tmp_bc, elementid, uid);
2171 
2172  while ((t = av_dict_iterate(m, t))) {
2173  if (mkv_check_tag_name(t->key, elementid)) {
2174  ret = mkv_write_simpletag(tmp_bc, t);
2175  if (ret < 0)
2176  goto end;
2177  tag_written = 1;
2178  }
2179  }
2180  if (reserved_size)
2181  put_ebml_void(tmp_bc, reserved_size);
2182  else if (!tag_written)
2183  goto end;
2184 
2185  size = avio_get_dyn_buf(tmp_bc, &buf);
2186  if (tmp_bc->error) {
2187  ret = tmp_bc->error;
2188  goto end;
2189  }
2190  if (!*pb) {
2191  ret = start_ebml_master_crc32(pb, mkv);
2192  if (ret < 0)
2193  goto end;
2194  }
2195  put_ebml_binary(*pb, MATROSKA_ID_TAG, buf, size);
2196 
2197 end:
2198  ffio_reset_dyn_buf(tmp_bc);
2199  return ret;
2200 }
2201 
2203 {
2204  MatroskaMuxContext *mkv = s->priv_data;
2205  int i, ret, seekable = IS_SEEKABLE(s->pb, mkv);
2206 
2207  mkv->wrote_tags = 1;
2208 
2210 
2211  ret = mkv_write_tag(mkv, s->metadata, &mkv->tags.bc, 0, 0, 0);
2212  if (ret < 0)
2213  return ret;
2214 
2215  for (i = 0; i < s->nb_streams; i++) {
2216  const AVStream *st = s->streams[i];
2217  mkv_track *track = &mkv->tracks[i];
2218 
2220  continue;
2221 
2222  ret = mkv_write_tag(mkv, st->metadata, &mkv->tags.bc,
2223  seekable ? DURATION_SIMPLETAG_SIZE : 0,
2225  if (ret < 0)
2226  return ret;
2227  if (seekable)
2229  }
2230 
2231  if (mkv->nb_attachments && !IS_WEBM(mkv)) {
2232  for (i = 0; i < s->nb_streams; i++) {
2233  const mkv_track *track = &mkv->tracks[i];
2234  const AVStream *st = s->streams[i];
2235 
2237  continue;
2238 
2239  ret = mkv_write_tag(mkv, st->metadata, &mkv->tags.bc, 0,
2241  if (ret < 0)
2242  return ret;
2243  }
2244  }
2245 
2246  if (mkv->tags.bc) {
2247  return end_ebml_master_crc32_tentatively(s->pb, &mkv->tags, mkv,
2249  }
2250  return 0;
2251 }
2252 
2254 {
2255  for (unsigned i = 0; i < s->nb_chapters; i++) {
2256  if (!s->chapters[i]->id)
2257  return 1;
2258  for (unsigned j = 0; j < i; j++)
2259  if (s->chapters[j]->id == s->chapters[i]->id)
2260  return 1;
2261  }
2262  return 0;
2263 }
2264 
2266 {
2267  MatroskaMuxContext *mkv = s->priv_data;
2268  AVIOContext *dyn_cp = NULL, *dyn_tags = NULL, **tags, *pb = s->pb;
2269  ebml_master editionentry;
2270  AVRational scale = {1, 1E9};
2271  int ret, create_new_ids;
2272 
2273  if (!s->nb_chapters || mkv->wrote_chapters)
2274  return 0;
2275 
2276  ret = start_ebml_master_crc32(&dyn_cp, mkv);
2277  if (ret < 0)
2278  return ret;
2279 
2280  editionentry = start_ebml_master(dyn_cp, MATROSKA_ID_EDITIONENTRY, 0);
2281  if (!IS_WEBM(mkv)) {
2283  /* If mkv_write_tags() has already been called, then any tags
2284  * corresponding to chapters will be put into a new Tags element. */
2285  tags = mkv->wrote_tags ? &dyn_tags : &mkv->tags.bc;
2286  } else
2287  tags = NULL;
2288 
2289  create_new_ids = mkv_new_chapter_ids_needed(s);
2290 
2291  for (unsigned i = 0; i < s->nb_chapters; i++) {
2292  AVChapter *const c = s->chapters[i];
2293  int64_t chapterstart = av_rescale_q(c->start, c->time_base, scale);
2294  int64_t chapterend = av_rescale_q(c->end, c->time_base, scale);
2295  const AVDictionaryEntry *t;
2296  uint64_t uid = create_new_ids ? i + 1ULL : c->id;
2297  EBML_WRITER(7);
2298 
2299  if (chapterstart < 0 || chapterstart > chapterend || chapterend < 0) {
2301  "Invalid chapter start (%"PRId64") or end (%"PRId64").\n",
2302  chapterstart, chapterend);
2304  goto fail;
2305  }
2306 
2309  ebml_writer_add_uint(&writer, MATROSKA_ID_CHAPTERTIMESTART, chapterstart);
2310  ebml_writer_add_uint(&writer, MATROSKA_ID_CHAPTERTIMEEND, chapterend);
2311  if ((t = av_dict_get(c->metadata, "title", NULL, 0))) {
2314  ebml_writer_add_string(&writer, MATROSKA_ID_CHAPLANG , "und");
2315  }
2316  ret = ebml_writer_write(&writer, dyn_cp);
2317  if (ret < 0)
2318  goto fail;
2319 
2320  if (tags) {
2322 
2323  ret = mkv_write_tag(mkv, c->metadata, tags, 0,
2325  if (ret < 0)
2326  goto fail;
2327  }
2328  }
2329  end_ebml_master(dyn_cp, editionentry);
2330  mkv->wrote_chapters = 1;
2331 
2332  ret = end_ebml_master_crc32(pb, &dyn_cp, mkv, MATROSKA_ID_CHAPTERS, 0, 0, 1);
2333  if (ret < 0)
2334  goto fail;
2335  if (dyn_tags)
2336  return end_ebml_master_crc32(pb, &dyn_tags, mkv,
2337  MATROSKA_ID_TAGS, 0, 0, 1);
2338  return 0;
2339 
2340 fail:
2341  if (tags) {
2342  /* tags == &mkv->tags.bc can only happen if mkv->tags.bc was
2343  * initially NULL, so we never free older tags. */
2344  ffio_free_dyn_buf(tags);
2345  }
2346  ffio_free_dyn_buf(&dyn_cp);
2347  return ret;
2348 }
2349 
2350 static const char *get_mimetype(const AVStream *st)
2351 {
2352  const AVDictionaryEntry *t;
2353 
2354  if (t = av_dict_get(st->metadata, "mimetype", NULL, 0))
2355  return t->value;
2356  if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
2358  if (desc && desc->mime_types) {
2359  return desc->mime_types[0];
2360  } else if (st->codecpar->codec_id == AV_CODEC_ID_TEXT)
2361  return "text/plain";
2362  }
2363 
2364  return NULL;
2365 }
2366 
2368 {
2369  MatroskaMuxContext *mkv = s->priv_data;
2370  AVIOContext *dyn_cp = NULL, *pb = s->pb;
2371  int i, ret;
2372 
2373  if (!mkv->nb_attachments)
2374  return 0;
2375 
2376  ret = start_ebml_master_crc32(&dyn_cp, mkv);
2377  if (ret < 0)
2378  return ret;
2379 
2380  for (i = 0; i < s->nb_streams; i++) {
2381  const AVStream *st = s->streams[i];
2382  mkv_track *track = &mkv->tracks[i];
2383  EBML_WRITER(6);
2384  const AVDictionaryEntry *t;
2385  const char *mimetype;
2386 
2388  continue;
2389 
2391 
2392  if (t = av_dict_get(st->metadata, "title", NULL, 0))
2394  if (!(t = av_dict_get(st->metadata, "filename", NULL, 0))) {
2395  av_log(s, AV_LOG_ERROR, "Attachment stream %d has no filename tag.\n", i);
2396  ffio_free_dyn_buf(&dyn_cp);
2397  return AVERROR(EINVAL);
2398  }
2400 
2401  mimetype = get_mimetype(st);
2402  av_assert0(mimetype);
2406  ebml_writer_add_uid(&writer, MATROSKA_ID_FILEUID, track->uid);
2407  ret = ebml_writer_write(&writer, dyn_cp);
2408  if (ret < 0) {
2409  ffio_free_dyn_buf(&dyn_cp);
2410  return ret;
2411  }
2412  }
2413  return end_ebml_master_crc32(pb, &dyn_cp, mkv,
2414  MATROSKA_ID_ATTACHMENTS, 0, 0, 1);
2415 }
2416 
2418 {
2419  const AVDictionaryEntry *duration = av_dict_get(s->metadata, "DURATION",
2420  NULL, 0);
2421  int64_t max = 0;
2422  int64_t us;
2423 
2424  if (duration && (av_parse_time(&us, duration->value, 1) == 0) && us > 0) {
2425  av_log(s, AV_LOG_DEBUG, "get_metadata_duration found duration in context metadata: %" PRId64 "\n", us);
2426  return us;
2427  }
2428 
2429  for (unsigned i = 0; i < s->nb_streams; i++) {
2430  int64_t us;
2431  duration = av_dict_get(s->streams[i]->metadata, "DURATION", NULL, 0);
2432 
2433  if (duration && (av_parse_time(&us, duration->value, 1) == 0))
2434  max = FFMAX(max, us);
2435  }
2436 
2437  av_log(s, AV_LOG_DEBUG, "get_metadata_duration returned: %" PRId64 "\n", max);
2438  return max;
2439 }
2440 
2442  const char *doctype, int version)
2443 {
2444  EBML_WRITER(8);
2450  ebml_writer_add_string(&writer, EBML_ID_DOCTYPE, doctype);
2453  /* The size is bounded, so no need to check this. */
2454  ebml_writer_write(&writer, pb);
2455 }
2456 
2458 {
2459  MatroskaMuxContext *mkv = s->priv_data;
2460  const AVDictionaryEntry *tag;
2461  int64_t creation_time;
2462  AVIOContext *pb;
2463  int ret = start_ebml_master_crc32(&mkv->info.bc, mkv);
2464  if (ret < 0)
2465  return ret;
2466  pb = mkv->info.bc;
2467 
2469  if ((tag = av_dict_get(s->metadata, "title", NULL, 0)))
2470  put_ebml_string(pb, MATROSKA_ID_TITLE, tag->value);
2471  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
2473  if ((tag = av_dict_get(s->metadata, "encoding_tool", NULL, 0)))
2475  else
2477 
2478  if (!IS_WEBM(mkv))
2480  } else {
2481  const char *ident = "Lavf";
2484  }
2485 
2486  if (ff_parse_creation_time_metadata(s, &creation_time, 0) > 0) {
2487  // Adjust time so it's relative to 2001-01-01 and convert to nanoseconds.
2488  int64_t date_utc = (creation_time - 978307200000000LL) * 1000;
2489  uint8_t date_utc_buf[8];
2490  AV_WB64(date_utc_buf, date_utc);
2491  put_ebml_binary(pb, MATROSKA_ID_DATEUTC, date_utc_buf, 8);
2492  }
2493 
2494  // reserve space for the duration
2495  mkv->duration = 0;
2496  mkv->duration_offset = avio_tell(pb);
2497  if (!mkv->is_live) {
2498  int64_t metadata_duration = get_metadata_duration(s);
2499 
2500  if (s->duration > 0) {
2501  int64_t scaledDuration = av_rescale(s->duration, 1000, AV_TIME_BASE);
2502  put_ebml_float(pb, MATROSKA_ID_DURATION, scaledDuration);
2503  av_log(s, AV_LOG_DEBUG, "Write early duration from recording time = %" PRIu64 "\n", scaledDuration);
2504  } else if (metadata_duration > 0) {
2505  int64_t scaledDuration = av_rescale(metadata_duration, 1000, AV_TIME_BASE);
2506  put_ebml_float(pb, MATROSKA_ID_DURATION, scaledDuration);
2507  av_log(s, AV_LOG_DEBUG, "Write early duration from metadata = %" PRIu64 "\n", scaledDuration);
2508  } else if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
2509  put_ebml_void(pb, 11); // assumes double-precision float to be written
2510  }
2511  }
2512  return end_ebml_master_crc32_tentatively(s->pb, &mkv->info,
2513  mkv, MATROSKA_ID_INFO);
2514 }
2515 
2517 {
2518  MatroskaMuxContext *mkv = s->priv_data;
2519  AVIOContext *pb = s->pb;
2520  int ret, version = 2;
2521 
2522  ret = avio_open_dyn_buf(&mkv->tmp_bc);
2523  if (ret < 0)
2524  return ret;
2525 
2526  if (!IS_WEBM(mkv) ||
2527  av_dict_get(s->metadata, "stereo_mode", NULL, 0) ||
2528  av_dict_get(s->metadata, "alpha_mode", NULL, 0))
2529  version = 4;
2530 
2531  for (unsigned i = 0; i < s->nb_streams; i++) {
2532  if (s->streams[i]->codecpar->codec_id == AV_CODEC_ID_OPUS ||
2533  av_dict_get(s->streams[i]->metadata, "stereo_mode", NULL, 0) ||
2534  av_dict_get(s->streams[i]->metadata, "alpha_mode", NULL, 0))
2535  version = 4;
2536  }
2537 
2538  ebml_write_header(pb, s->oformat->name, version);
2540  put_ebml_size_unknown(pb, 8);
2541  mkv->segment_offset = avio_tell(pb);
2542 
2543  // We write a SeekHead at the beginning to point to all other level
2544  // one elements (except Clusters).
2545  mkv_start_seekhead(mkv, pb);
2546 
2547  ret = mkv_write_info(s);
2548  if (ret < 0)
2549  return ret;
2550 
2551  ret = mkv_write_tracks(s);
2552  if (ret < 0)
2553  return ret;
2554 
2556  if (ret < 0)
2557  return ret;
2558 
2559  if (!IS_WEBM(mkv)) {
2561  if (ret < 0)
2562  return ret;
2563  }
2564 
2565  /* Must come after mkv_write_chapters() to write chapter tags
2566  * into the same Tags element as the other tags. */
2567  ret = mkv_write_tags(s);
2568  if (ret < 0)
2569  return ret;
2570 
2571  if (!IS_SEEKABLE(pb, mkv)) {
2572  ret = mkv_write_seekhead(pb, mkv, 0, avio_tell(pb));
2573  if (ret < 0)
2574  return ret;
2575  }
2576 
2577  if (s->metadata_header_padding > 0) {
2578  if (s->metadata_header_padding == 1)
2579  s->metadata_header_padding++;
2580  put_ebml_void(pb, s->metadata_header_padding);
2581  }
2582 
2583  if (mkv->reserve_cues_space || mkv->move_cues_to_front) {
2584  if (IS_SEEKABLE(pb, mkv)) {
2585  mkv->cues_pos = avio_tell(pb);
2586  if (mkv->reserve_cues_space >= 1) {
2587  if (mkv->reserve_cues_space == 1)
2588  mkv->reserve_cues_space++;
2590  }
2591  } else
2592  mkv->reserve_cues_space = -1;
2593  }
2594 
2595  mkv->cluster_pos = -1;
2596 
2597  // start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or
2598  // after 4k and on a keyframe
2599  if (IS_SEEKABLE(pb, mkv)) {
2600  if (mkv->cluster_time_limit < 0)
2601  mkv->cluster_time_limit = 5000;
2602  if (mkv->cluster_size_limit < 0)
2603  mkv->cluster_size_limit = 5 * 1024 * 1024;
2604  } else {
2605  if (mkv->cluster_time_limit < 0)
2606  mkv->cluster_time_limit = 1000;
2607  if (mkv->cluster_size_limit < 0)
2608  mkv->cluster_size_limit = 32 * 1024;
2609  }
2610 
2611  return 0;
2612 }
2613 
2614 #if CONFIG_MATROSKA_MUXER
2615 static int mkv_reformat_h2645(MatroskaMuxContext *mkv, AVIOContext *pb,
2616  const AVPacket *pkt, int *size)
2617 {
2618  int ret;
2619  if (pb) {
2621  } else {
2623  if (ret < 0)
2624  return ret;
2625  *size = ret;
2626  }
2627  return 0;
2628 }
2629 
2630 static int mkv_reformat_wavpack(MatroskaMuxContext *mkv, AVIOContext *pb,
2631  const AVPacket *pkt, int *size)
2632 {
2633  const uint8_t *src = pkt->data;
2634  int srclen = pkt->size;
2635  int offset = 0;
2636  int ret;
2637 
2638  while (srclen >= WV_HEADER_SIZE) {
2639  WvHeader header;
2640 
2642  if (ret < 0)
2643  return ret;
2644  src += WV_HEADER_SIZE;
2645  srclen -= WV_HEADER_SIZE;
2646 
2647  if (srclen < header.blocksize)
2648  return AVERROR_INVALIDDATA;
2649 
2650  offset += 4 * !!header.initial + 8 + 4 * !(header.initial && header.final);
2651  if (pb) {
2652  if (header.initial)
2653  avio_wl32(pb, header.samples);
2654  avio_wl32(pb, header.flags);
2655  avio_wl32(pb, header.crc);
2656 
2657  if (!(header.initial && header.final))
2658  avio_wl32(pb, header.blocksize);
2659 
2660  avio_write(pb, src, header.blocksize);
2661  }
2662  src += header.blocksize;
2663  srclen -= header.blocksize;
2664  offset += header.blocksize;
2665  }
2666  *size = offset;
2667 
2668  return 0;
2669 }
2670 #endif
2671 
2673  const AVPacket *pkt, int *size)
2674 {
2675  int ret = ff_av1_filter_obus(pb, pkt->data, pkt->size);
2676  if (ret < 0)
2677  return ret;
2678  *size = ret;
2679  return 0;
2680 }
2681 
2683  const AVPacket *pkt, int *size)
2684 {
2685  const uint8_t *id, *settings;
2686  size_t id_size, settings_size;
2687  unsigned total = pkt->size + 2U;
2688 
2689  if (total > INT_MAX)
2690  return AVERROR(ERANGE);
2691 
2693  &id_size);
2695  &settings_size);
2696  if (id_size > INT_MAX - total || settings_size > INT_MAX - (total += id_size))
2697  return AVERROR(ERANGE);
2698  *size = total += settings_size;
2699  if (pb) {
2700  avio_write(pb, id, id_size);
2701  avio_w8(pb, '\n');
2702  avio_write(pb, settings, settings_size);
2703  avio_w8(pb, '\n');
2704  avio_write(pb, pkt->data, pkt->size);
2705  }
2706  return 0;
2707 }
2708 
2709 static void mkv_write_blockadditional(EbmlWriter *writer, const uint8_t *buf,
2710  size_t size, uint64_t additional_id)
2711 {
2713  ebml_writer_add_uint(writer, MATROSKA_ID_BLOCKADDID, additional_id);
2715  ebml_writer_close_master(writer);
2716 }
2717 
2718 static int mkv_write_block(void *logctx, MatroskaMuxContext *mkv,
2719  AVIOContext *pb, const AVCodecParameters *par,
2720  mkv_track *track, const AVPacket *pkt,
2721  int keyframe, int64_t ts, uint64_t duration,
2722  int force_blockgroup, int64_t relative_packet_pos)
2723 {
2724  uint8_t t35_buf[6 + AV_HDR_PLUS_MAX_PAYLOAD_SIZE];
2725  uint8_t *side_data;
2726  size_t side_data_size;
2727  uint64_t additional_id;
2728  unsigned track_number = track->track_num;
2729  EBML_WRITER(12);
2730  int ret;
2731 
2732  mkv->cur_block.track = track;
2733  mkv->cur_block.pkt = pkt;
2734  mkv->cur_block.rel_ts = ts - mkv->cluster_pts;
2735  mkv->cur_block.flags = 0;
2736 
2737  /* Open a BlockGroup with a Block now; it will later be converted
2738  * to a SimpleBlock if possible. */
2740  ebml_writer_add_block(&writer, mkv);
2741 
2742  if (duration)
2744 
2745  av_log(logctx, AV_LOG_DEBUG,
2746  "Writing block of size %d with pts %" PRId64 ", dts %" PRId64 ", "
2747  "duration %" PRId64 " at relative offset %" PRId64 " in cluster "
2748  "at offset %" PRId64 ". TrackNumber %u, keyframe %d\n",
2749  pkt->size, pkt->pts, pkt->dts, pkt->duration, relative_packet_pos,
2750  mkv->cluster_pos, track_number, keyframe != 0);
2751 
2752  side_data = av_packet_get_side_data(pkt,
2754  &side_data_size);
2755  if (side_data && side_data_size >= 10) {
2756  int64_t discard_padding = AV_RL32(side_data + 4);
2757  if (discard_padding) {
2758  discard_padding = av_rescale_q(discard_padding,
2759  (AVRational){1, par->sample_rate},
2760  (AVRational){1, 1000000000});
2761  ebml_writer_add_sint(&writer, MATROSKA_ID_DISCARDPADDING, discard_padding);
2762  }
2763  }
2764 
2766  side_data = av_packet_get_side_data(pkt,
2768  &side_data_size);
2769  if (side_data && side_data_size >= 8 &&
2770  // Only the Codec-specific BlockMore (id == 1) is currently supported.
2771  (additional_id = AV_RB64(side_data)) == MATROSKA_BLOCK_ADD_ID_TYPE_OPAQUE) {
2772  mkv_write_blockadditional(&writer, side_data + 8, side_data_size - 8,
2773  additional_id);
2774  track->max_blockaddid = FFMAX(track->max_blockaddid, additional_id);
2775  }
2776 
2777  if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
2778  side_data = av_packet_get_side_data(pkt,
2780  &side_data_size);
2781  if (side_data && side_data_size) {
2782  uint8_t *payload = t35_buf;
2783  size_t payload_size = sizeof(t35_buf) - 6;
2784 
2785  bytestream_put_byte(&payload, 0xB5); // country_code
2786  bytestream_put_be16(&payload, 0x3C); // provider_code
2787  bytestream_put_be16(&payload, 0x01); // provider_oriented_code
2788  bytestream_put_byte(&payload, 0x04); // application_identifier
2789 
2790  ret = av_dynamic_hdr_plus_to_t35((AVDynamicHDRPlus *)side_data, &payload,
2791  &payload_size);
2792  if (ret < 0)
2793  return ret;
2794 
2795  mkv_write_blockadditional(&writer, t35_buf, payload_size + 6,
2797  track->max_blockaddid = FFMAX(track->max_blockaddid,
2799  }
2800  }
2801 
2803 
2804  if (!force_blockgroup && writer.nb_elements == 2) {
2805  /* Nothing except the BlockGroup + Block. Can use a SimpleBlock. */
2806  writer.elements++; // Skip the BlockGroup.
2807  writer.nb_elements--;
2808  av_assert2(writer.elements[0].id == MATROSKA_ID_BLOCK);
2809  writer.elements[0].id = MATROSKA_ID_SIMPLEBLOCK;
2810  if (keyframe)
2811  mkv->cur_block.flags |= 1 << 7;
2812  } else if (!keyframe)
2814  track->last_timestamp - ts);
2815 
2816  return ebml_writer_write(&writer, pb);
2817 }
2818 
2820 {
2821  MatroskaMuxContext *mkv = s->priv_data;
2822  int ret;
2823 
2824  if (!mkv->have_video) {
2825  for (unsigned i = 0; i < s->nb_streams; i++)
2826  mkv->tracks[i].has_cue = 0;
2827  }
2828  mkv->cluster_pos = -1;
2829  ret = end_ebml_master_crc32(s->pb, &mkv->cluster_bc, mkv,
2830  MATROSKA_ID_CLUSTER, 0, 1, 0);
2831  if (ret < 0)
2832  return ret;
2833 
2835  return 0;
2836 }
2837 
2839 {
2840  MatroskaMuxContext *mkv = s->priv_data;
2841  mkv_track *track = &mkv->tracks[pkt->stream_index];
2842  AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
2843  uint8_t *side_data;
2844  size_t side_data_size;
2845  int ret;
2846 
2848  &side_data_size);
2849 
2850  switch (par->codec_id) {
2851 #if CONFIG_MATROSKA_MUXER
2852  case AV_CODEC_ID_AAC:
2853  if (side_data_size && mkv->track.bc) {
2854  int output_sample_rate = 0;
2855  ret = get_aac_sample_rates(s, mkv, side_data, side_data_size,
2856  &track->sample_rate, &output_sample_rate);
2857  if (ret < 0)
2858  return ret;
2859  if (!output_sample_rate)
2860  output_sample_rate = track->sample_rate; // Space is already reserved, so it's this or a void element.
2861  ret = mkv_update_codecprivate(s, mkv, side_data, side_data_size,
2862  par, mkv->track.bc, track, 0);
2863  if (ret < 0)
2864  return ret;
2865  avio_seek(mkv->track.bc, track->sample_rate_offset, SEEK_SET);
2867  put_ebml_float(mkv->track.bc, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate);
2868  } else if (!par->extradata_size && !track->sample_rate) {
2869  // No extradata (codecpar or packet side data).
2870  av_log(s, AV_LOG_ERROR, "Error parsing AAC extradata, unable to determine samplerate.\n");
2871  return AVERROR(EINVAL);
2872  }
2873  break;
2874  case AV_CODEC_ID_FLAC:
2875  if (side_data_size && mkv->track.bc) {
2876  if (side_data_size != par->extradata_size) {
2877  av_log(s, AV_LOG_ERROR, "Invalid FLAC STREAMINFO metadata for output stream %d\n",
2878  pkt->stream_index);
2879  return AVERROR(EINVAL);
2880  }
2881  ret = mkv_update_codecprivate(s, mkv, side_data, side_data_size,
2882  par, mkv->track.bc, track, 0);
2883  if (ret < 0)
2884  return ret;
2885  }
2886  break;
2887 #endif
2888  // FIXME: Remove the following once libaom starts propagating proper extradata during init()
2889  // See https://bugs.chromium.org/p/aomedia/issues/detail?id=2208
2890  case AV_CODEC_ID_AV1:
2891  if (side_data_size && mkv->track.bc && !par->extradata_size) {
2892  // If the reserved space doesn't suffice, only write
2893  // the first four bytes of the av1C.
2894  ret = mkv_update_codecprivate(s, mkv, side_data, side_data_size,
2895  par, mkv->track.bc, track, 4);
2896  if (ret < 0)
2897  return ret;
2898  } else if (!par->extradata_size)
2899  return AVERROR_INVALIDDATA;
2900  break;
2901  default:
2902  if (side_data_size)
2903  av_log(s, AV_LOG_DEBUG, "Ignoring new extradata in a packet for stream %d.\n", pkt->stream_index);
2904  break;
2905  }
2906 
2907  return 0;
2908 }
2909 
2911 {
2912  MatroskaMuxContext *mkv = s->priv_data;
2913  AVIOContext *pb;
2914  AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
2915  mkv_track *track = &mkv->tracks[pkt->stream_index];
2916  int is_sub = par->codec_type == AVMEDIA_TYPE_SUBTITLE;
2917  /* All subtitle blocks are considered to be keyframes. */
2918  int keyframe = is_sub || !!(pkt->flags & AV_PKT_FLAG_KEY);
2919  int64_t duration = FFMAX(pkt->duration, 0);
2920  int64_t write_duration = is_sub ? duration : 0;
2921  int ret;
2922  int64_t ts = track->write_dts ? pkt->dts : pkt->pts;
2923  int64_t relative_packet_pos;
2924 
2925  if (ts == AV_NOPTS_VALUE) {
2926  av_log(s, AV_LOG_ERROR, "Can't write packet with unknown timestamp\n");
2927  return AVERROR(EINVAL);
2928  }
2929  ts += track->ts_offset;
2930 
2931  if (mkv->cluster_pos != -1) {
2932  int64_t cluster_time = ts - mkv->cluster_pts;
2933  if ((int16_t)cluster_time != cluster_time) {
2934  ret = mkv_end_cluster(s);
2935  if (ret < 0)
2936  return ret;
2937  av_log(s, AV_LOG_WARNING, "Starting new cluster due to timestamp\n");
2938  }
2939  }
2940 
2941  if (mkv->cluster_pos == -1) {
2942  ret = start_ebml_master_crc32(&mkv->cluster_bc, mkv);
2943  if (ret < 0)
2944  return ret;
2945  mkv->cluster_bc->direct = 1;
2946  mkv->cluster_pos = avio_tell(s->pb);
2948  mkv->cluster_pts = FFMAX(0, ts);
2950  "Starting new cluster with timestamp "
2951  "%" PRId64 " at offset %" PRId64 " bytes\n",
2952  mkv->cluster_pts, mkv->cluster_pos);
2953  }
2954  pb = mkv->cluster_bc;
2955 
2956  relative_packet_pos = avio_tell(pb);
2957 
2958  /* The WebM spec requires WebVTT to be muxed in BlockGroups;
2959  * so we force it even for packets without duration. */
2960  ret = mkv_write_block(s, mkv, pb, par, track, pkt,
2961  keyframe, ts, write_duration,
2962  par->codec_id == AV_CODEC_ID_WEBVTT,
2963  relative_packet_pos);
2964  if (ret < 0)
2965  return ret;
2966  if (keyframe && IS_SEEKABLE(s->pb, mkv) &&
2967  (par->codec_type == AVMEDIA_TYPE_VIDEO ||
2969  !mkv->have_video && !track->has_cue)) {
2970  ret = mkv_add_cuepoint(mkv, pkt->stream_index, ts,
2971  mkv->cluster_pos, relative_packet_pos,
2972  write_duration);
2973  if (ret < 0)
2974  return ret;
2975  track->has_cue = 1;
2976  }
2977 
2978  track->last_timestamp = ts;
2979  mkv->duration = FFMAX(mkv->duration, ts + duration);
2980  track->duration = FFMAX(track->duration, ts + duration);
2981 
2982  return 0;
2983 }
2984 
2986 {
2987  MatroskaMuxContext *mkv = s->priv_data;
2988  int codec_type = s->streams[pkt->stream_index]->codecpar->codec_type;
2989  int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
2990  int cluster_size;
2991  int64_t cluster_time;
2992  int ret;
2993  int start_new_cluster;
2994 
2996  if (ret < 0)
2997  return ret;
2998 
2999  if (mkv->cluster_pos != -1) {
3000  if (mkv->tracks[pkt->stream_index].write_dts)
3001  cluster_time = pkt->dts - mkv->cluster_pts;
3002  else
3003  cluster_time = pkt->pts - mkv->cluster_pts;
3004  cluster_time += mkv->tracks[pkt->stream_index].ts_offset;
3005 
3006  cluster_size = avio_tell(mkv->cluster_bc);
3007 
3008  if (mkv->is_dash && codec_type == AVMEDIA_TYPE_VIDEO) {
3009  // WebM DASH specification states that the first block of
3010  // every Cluster has to be a key frame. So for DASH video,
3011  // we only create a Cluster on seeing key frames.
3012  start_new_cluster = keyframe;
3013  } else if (mkv->is_dash && codec_type == AVMEDIA_TYPE_AUDIO &&
3014  cluster_time > mkv->cluster_time_limit) {
3015  // For DASH audio, we create a Cluster based on cluster_time_limit.
3016  start_new_cluster = 1;
3017  } else if (!mkv->is_dash &&
3018  (cluster_size > mkv->cluster_size_limit ||
3019  cluster_time > mkv->cluster_time_limit ||
3020  (codec_type == AVMEDIA_TYPE_VIDEO && keyframe &&
3021  cluster_size > 4 * 1024))) {
3022  start_new_cluster = 1;
3023  } else
3024  start_new_cluster = 0;
3025 
3026  if (start_new_cluster) {
3027  ret = mkv_end_cluster(s);
3028  if (ret < 0)
3029  return ret;
3030  }
3031  }
3032 
3033  if (mkv->cluster_pos == -1)
3034  avio_write_marker(s->pb,
3035  av_rescale_q(pkt->dts, s->streams[pkt->stream_index]->time_base, AV_TIME_BASE_Q),
3037 
3038  // check if we have an audio packet cached
3039  if (mkv->cur_audio_pkt->size > 0) {
3042  if (ret < 0) {
3044  "Could not write cached audio packet ret:%d\n", ret);
3045  return ret;
3046  }
3047  }
3048 
3049  // buffer an audio packet to ensure the packet containing the video
3050  // keyframe's timecode is contained in the same cluster for WebM
3051  if (codec_type == AVMEDIA_TYPE_AUDIO) {
3052  if (pkt->size > 0)
3054  } else
3056  return ret;
3057 }
3058 
3060 {
3061  MatroskaMuxContext *mkv = s->priv_data;
3062 
3063  if (!pkt) {
3064  if (mkv->cluster_pos != -1) {
3065  int ret = mkv_end_cluster(s);
3066  if (ret < 0)
3067  return ret;
3069  "Flushing cluster at offset %" PRIu64 " bytes\n",
3070  avio_tell(s->pb));
3071  }
3072  return 1;
3073  }
3074  return mkv_write_packet(s, pkt);
3075 }
3076 
3078 {
3079  MatroskaMuxContext *mkv = s->priv_data;
3080  AVIOContext *pb = s->pb;
3081  int64_t endpos, ret64;
3082  int ret, ret2 = 0;
3083 
3084  // check if we have an audio packet cached
3085  if (mkv->cur_audio_pkt->size > 0) {
3087  if (ret < 0) {
3089  "Could not write cached audio packet ret:%d\n", ret);
3090  return ret;
3091  }
3092  }
3093 
3094  if (mkv->cluster_pos != -1) {
3095  ret = end_ebml_master_crc32(pb, &mkv->cluster_bc, mkv,
3096  MATROSKA_ID_CLUSTER, 0, 0, 0);
3097  if (ret < 0)
3098  return ret;
3099  }
3100 
3102  if (ret < 0)
3103  return ret;
3104 
3105  if (!IS_SEEKABLE(pb, mkv))
3106  return 0;
3107 
3108  endpos = avio_tell(pb);
3109 
3110  if (mkv->cues.num_entries && mkv->reserve_cues_space >= 0) {
3111  AVIOContext *cues = NULL;
3112  uint64_t size, offset = 0;
3113  int length_size = 0;
3114 
3115 redo_cues:
3116  ret = start_ebml_master_crc32(&cues, mkv);
3117  if (ret < 0)
3118  return ret;
3119 
3120  ret = mkv_assemble_cues(s->streams, cues, mkv->tmp_bc, &mkv->cues,
3121  mkv->tracks, s->nb_streams, offset);
3122  if (ret < 0) {
3123  ffio_free_dyn_buf(&cues);
3124  return ret;
3125  }
3126 
3127  if (mkv->reserve_cues_space || mkv->move_cues_to_front) {
3128  size = avio_tell(cues);
3129  length_size = ebml_length_size(size);
3130  size += 4 + length_size;
3131  if (offset + mkv->reserve_cues_space < size) {
3132  if (mkv->move_cues_to_front) {
3133  offset = size - mkv->reserve_cues_space;
3134  ffio_reset_dyn_buf(cues);
3135  goto redo_cues;
3136  }
3138  "Insufficient space reserved for Cues: "
3139  "%d < %"PRIu64". No Cues will be output.\n",
3140  mkv->reserve_cues_space, size);
3141  ret2 = AVERROR(EINVAL);
3142  goto after_cues;
3143  } else {
3144  if (offset) {
3146  offset);
3147  if (ret < 0) {
3148  ffio_free_dyn_buf(&cues);
3149  return ret;
3150  }
3151  endpos += offset;
3152  }
3153  if ((ret64 = avio_seek(pb, mkv->cues_pos, SEEK_SET)) < 0) {
3154  ffio_free_dyn_buf(&cues);
3155  return ret64;
3156  }
3157  if (mkv->reserve_cues_space == size + 1) {
3158  /* There is no way to reserve a single byte because
3159  * the minimal size of an EBML Void element is 2
3160  * (1 byte ID, 1 byte length field). This problem
3161  * is solved by writing the Cues' length field on
3162  * one byte more than necessary. */
3163  length_size++;
3164  size++;
3165  }
3166  }
3167  }
3168  ret = end_ebml_master_crc32(pb, &cues, mkv, MATROSKA_ID_CUES,
3169  length_size, 0, 1);
3170  if (ret < 0)
3171  return ret;
3172  if (mkv->reserve_cues_space) {
3173  if (size < mkv->reserve_cues_space)
3175  } else if (!mkv->move_cues_to_front)
3176  endpos = avio_tell(pb);
3177  }
3178 
3179 after_cues:
3180  /* Lengths greater than (1ULL << 56) - 1 can't be represented
3181  * via an EBML number, so leave the unknown length field. */
3182  if (endpos - mkv->segment_offset < (1ULL << 56) - 1) {
3183  if ((ret64 = avio_seek(pb, mkv->segment_offset - 8, SEEK_SET)) < 0)
3184  return ret64;
3185  put_ebml_length(pb, endpos - mkv->segment_offset, 8);
3186  }
3187 
3188  ret = mkv_write_seekhead(pb, mkv, 1, mkv->info.pos);
3189  if (ret < 0)
3190  return ret;
3191 
3192  if (mkv->info.bc) {
3193  // update the duration
3194  av_log(s, AV_LOG_DEBUG, "end duration = %" PRIu64 "\n", mkv->duration);
3195  avio_seek(mkv->info.bc, mkv->duration_offset, SEEK_SET);
3197  ret = end_ebml_master_crc32(pb, &mkv->info.bc, mkv,
3198  MATROSKA_ID_INFO, 0, 0, 0);
3199  if (ret < 0)
3200  return ret;
3201  }
3202 
3203  if (mkv->track.bc) {
3204  // write Tracks master
3205  if (!IS_WEBM(mkv)) {
3206  AVIOContext *track_bc = mkv->track.bc;
3207 
3208  for (unsigned i = 0; i < s->nb_streams; i++) {
3209  const mkv_track *track = &mkv->tracks[i];
3210 
3211  if (!track->max_blockaddid)
3212  continue;
3213 
3214  // We reserved a single byte to write this value.
3215  av_assert0(track->max_blockaddid <= 0xFF);
3216 
3217  avio_seek(track_bc, track->blockadditionmapping_offset, SEEK_SET);
3218 
3220  track->max_blockaddid);
3222  ebml_master mapping_master = start_ebml_master(track_bc, MATROSKA_ID_TRACKBLKADDMAPPING, 8);
3227  end_ebml_master(track_bc, mapping_master);
3228  }
3229  }
3230  }
3231 
3232  avio_seek(pb, mkv->track.pos, SEEK_SET);
3233  ret = end_ebml_master_crc32(pb, &mkv->track.bc, mkv,
3234  MATROSKA_ID_TRACKS, 0, 0, 0);
3235  if (ret < 0)
3236  return ret;
3237  }
3238 
3239  // update stream durations
3240  if (mkv->tags.bc) {
3241  AVIOContext *tags_bc = mkv->tags.bc;
3242  int i;
3243  for (i = 0; i < s->nb_streams; ++i) {
3244  const AVStream *st = s->streams[i];
3245  const mkv_track *track = &mkv->tracks[i];
3246 
3247  if (track->duration_offset > 0) {
3248  double duration_sec = track->duration * av_q2d(st->time_base);
3249  char duration_string[DURATION_STRING_LENGTH + 1] = "";
3250  ebml_master simpletag;
3251 
3252  av_log(s, AV_LOG_DEBUG, "stream %d end duration = %" PRIu64 "\n", i,
3253  track->duration);
3254 
3255  avio_seek(tags_bc, track->duration_offset, SEEK_SET);
3256  simpletag = start_ebml_master(tags_bc, MATROSKA_ID_SIMPLETAG,
3257  2 + 1 + 8 + 23);
3258  put_ebml_string(tags_bc, MATROSKA_ID_TAGNAME, "DURATION");
3259 
3260  snprintf(duration_string, sizeof(duration_string), "%02d:%02d:%012.9f",
3261  (int) duration_sec / 3600, ((int) duration_sec / 60) % 60,
3262  fmod(duration_sec, 60));
3263 
3265  duration_string, DURATION_STRING_LENGTH);
3266  end_ebml_master(tags_bc, simpletag);
3267  }
3268  }
3269 
3270  avio_seek(pb, mkv->tags.pos, SEEK_SET);
3271  ret = end_ebml_master_crc32(pb, &mkv->tags.bc, mkv,
3272  MATROSKA_ID_TAGS, 0, 0, 0);
3273  if (ret < 0)
3274  return ret;
3275  }
3276 
3277  avio_seek(pb, endpos, SEEK_SET);
3278 
3279  return ret2;
3280 }
3281 
3282 static uint64_t mkv_get_uid(const mkv_track *tracks, int i, AVLFG *c)
3283 {
3284  while (1) {
3285  uint64_t uid;
3286  int k;
3287  uid = (uint64_t)av_lfg_get(c) << 32;
3288  uid |= av_lfg_get(c);
3289  if (!uid)
3290  continue;
3291  for (k = 0; k < i; k++) {
3292  if (tracks[k].uid == uid)
3293  break;
3294  }
3295  if (k == i)
3296  return uid;
3297  }
3298 }
3299 
3300 static int mkv_init(struct AVFormatContext *s)
3301 {
3302  FFFormatContext *const si = ffformatcontext(s);
3303  MatroskaMuxContext *mkv = s->priv_data;
3304  AVLFG c;
3305  unsigned nb_tracks = 0;
3306  int i;
3307 
3308  mkv->ctx = s;
3309 
3310  for (i = 0; i < s->nb_streams; i++) {
3311  if (s->streams[i]->codecpar->codec_id == AV_CODEC_ID_ATRAC3 ||
3312  s->streams[i]->codecpar->codec_id == AV_CODEC_ID_COOK ||
3313  s->streams[i]->codecpar->codec_id == AV_CODEC_ID_RA_288 ||
3314  s->streams[i]->codecpar->codec_id == AV_CODEC_ID_SIPR ||
3315  s->streams[i]->codecpar->codec_id == AV_CODEC_ID_RV10 ||
3316  s->streams[i]->codecpar->codec_id == AV_CODEC_ID_RV20 ||
3317  s->streams[i]->codecpar->codec_id == AV_CODEC_ID_RV30) {
3319  "The Matroska muxer does not yet support muxing %s\n",
3320  avcodec_get_name(s->streams[i]->codecpar->codec_id));
3321  return AVERROR_PATCHWELCOME;
3322  }
3323  }
3324 
3325  if (s->avoid_negative_ts < 0) {
3326  s->avoid_negative_ts = 1;
3327  si->avoid_negative_ts_use_pts = 1;
3328  }
3329 
3330  if (!CONFIG_MATROSKA_MUXER ||
3331  (CONFIG_WEBM_MUXER && !strcmp(s->oformat->name, "webm"))) {
3332  mkv->mode = MODE_WEBM;
3333  mkv->write_crc = 0;
3334  } else
3335  mkv->mode = MODE_MATROSKAv2;
3336 
3338 
3339  mkv->tracks = av_calloc(s->nb_streams, sizeof(*mkv->tracks));
3340  if (!mkv->tracks)
3341  return AVERROR(ENOMEM);
3342 
3343  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
3345 
3346  // Calculate the SegmentUID now in order not to waste our random seed.
3347  for (i = 0; i < 4; i++)
3348  mkv->segment_uid[i] = av_lfg_get(&c);
3349  }
3350 
3351  for (i = 0; i < s->nb_streams; i++) {
3352  AVStream *st = s->streams[i];
3353  const AVCodecParameters *const par = st->codecpar;
3354  mkv_track *track = &mkv->tracks[i];
3355 
3356  switch (par->codec_id) {
3357 #if CONFIG_MATROSKA_MUXER
3358  case AV_CODEC_ID_WAVPACK:
3359  track->reformat = mkv_reformat_wavpack;
3360  break;
3361  case AV_CODEC_ID_H264:
3362  case AV_CODEC_ID_HEVC:
3363  if ((par->codec_id == AV_CODEC_ID_H264 && par->extradata_size > 0 ||
3364  par->codec_id == AV_CODEC_ID_HEVC && par->extradata_size > 6) &&
3365  (AV_RB24(par->extradata) == 1 || AV_RB32(par->extradata) == 1))
3366  track->reformat = mkv_reformat_h2645;
3367  break;
3368  case AV_CODEC_ID_PRORES:
3369  /* Matroska specification requires to remove
3370  * the first QuickTime atom. */
3371  track->offset = 8;
3372  break;
3373 #endif
3374  case AV_CODEC_ID_AV1:
3375  track->reformat = mkv_reformat_av1;
3376  break;
3377  case AV_CODEC_ID_WEBVTT:
3378  track->reformat = webm_reformat_vtt;
3379  break;
3380  }
3381 
3382  if (s->flags & AVFMT_FLAG_BITEXACT) {
3383  track->uid = i + 1;
3384  } else {
3385  track->uid = mkv_get_uid(mkv->tracks, i, &c);
3386  }
3387 
3388  // ms precision is the de-facto standard timescale for mkv files
3389  avpriv_set_pts_info(st, 64, 1, 1000);
3390 
3392  if (IS_WEBM(mkv)) {
3393  av_log(s, AV_LOG_WARNING, "Stream %d will be ignored "
3394  "as WebM doesn't support attachments.\n", i);
3395  } else if (!get_mimetype(st)) {
3396  av_log(s, AV_LOG_ERROR, "Attachment stream %d has no mimetype "
3397  "tag and it cannot be deduced from the codec id.\n", i);
3398  return AVERROR(EINVAL);
3399  }
3400  mkv->nb_attachments++;
3401  continue;
3402  }
3403 
3404  nb_tracks++;
3405  track->track_num = mkv->is_dash ? mkv->dash_track_number : nb_tracks;
3406  track->track_num_size = ebml_num_size(track->track_num);
3407  }
3408 
3409  if (mkv->is_dash && nb_tracks != 1)
3410  return AVERROR(EINVAL);
3411 
3412  return 0;
3413 }
3414 
3416  const AVPacket *pkt)
3417 {
3418  int ret = 1;
3419 
3420  if (CONFIG_MATROSKA_MUXER && st->codecpar->codec_id == AV_CODEC_ID_AAC) {
3421  if (pkt->size > 2 && (AV_RB16(pkt->data) & 0xfff0) == 0xfff0)
3422  ret = ff_stream_add_bitstream_filter(st, "aac_adtstoasc", NULL);
3423  } else if (st->codecpar->codec_id == AV_CODEC_ID_VP9) {
3424  ret = ff_stream_add_bitstream_filter(st, "vp9_superframe", NULL);
3425  } else if (CONFIG_MATROSKA_MUXER &&
3427  ret = ff_stream_add_bitstream_filter(st, "pgs_frame_merge", NULL);
3428  }
3429 
3430  return ret;
3431 }
3432 
3434  { AV_CODEC_ID_ALAC, 0XFFFFFFFF },
3435  { AV_CODEC_ID_MLP, 0xFFFFFFFF },
3436  { AV_CODEC_ID_OPUS, 0xFFFFFFFF },
3437  { AV_CODEC_ID_PCM_S16BE, 0xFFFFFFFF },
3438  { AV_CODEC_ID_PCM_S24BE, 0xFFFFFFFF },
3439  { AV_CODEC_ID_PCM_S32BE, 0xFFFFFFFF },
3440  { AV_CODEC_ID_QDMC, 0xFFFFFFFF },
3441  { AV_CODEC_ID_QDM2, 0xFFFFFFFF },
3442  { AV_CODEC_ID_RA_144, 0xFFFFFFFF },
3443  { AV_CODEC_ID_TRUEHD, 0xFFFFFFFF },
3444  { AV_CODEC_ID_NONE, 0xFFFFFFFF }
3445 };
3446 
3448  { AV_CODEC_ID_DVB_SUBTITLE, 0xFFFFFFFF },
3449  { AV_CODEC_ID_DVD_SUBTITLE, 0xFFFFFFFF },
3450  { AV_CODEC_ID_HDMV_PGS_SUBTITLE, 0xFFFFFFFF },
3451  { AV_CODEC_ID_ARIB_CAPTION, 0xFFFFFFFF },
3452  { AV_CODEC_ID_NONE, 0xFFFFFFFF }
3453 };
3454 
3455 #define OFFSET(x) offsetof(MatroskaMuxContext, x)
3456 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM
3457 static const AVOption options[] = {
3458  { "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 },
3459  { "cues_to_front", "Move Cues (the index) to the front by shifting data if necessary", OFFSET(move_cues_to_front), AV_OPT_TYPE_BOOL, { .i64 = 0}, 0, 1, FLAGS },
3460  { "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 },
3461  { "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 },
3462  { "dash", "Create a WebM file conforming to WebM DASH specification", OFFSET(is_dash), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
3463  { "dash_track_number", "Track number for the DASH stream", OFFSET(dash_track_number), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, INT_MAX, FLAGS },
3464  { "live", "Write files assuming it is a live stream.", OFFSET(is_live), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
3465  { "allow_raw_vfw", "allow RAW VFW mode", OFFSET(allow_raw_vfw), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
3466  { "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 },
3467  { "write_crc32", "write a CRC32 element inside every Level 1 element", OFFSET(write_crc), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, FLAGS },
3468  { "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" },
3469  { "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" },
3470  { "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" },
3471  { "passthrough", "Use the disposition flag as-is", 0, AV_OPT_TYPE_CONST, { .i64 = DEFAULT_MODE_PASSTHROUGH }, 0, 0, FLAGS, "default_mode" },
3472  { NULL },
3473 };
3474 
3476  .class_name = "matroska/webm muxer",
3477  .item_name = av_default_item_name,
3478  .option = options,
3479  .version = LIBAVUTIL_VERSION_INT,
3480 };
3481 
3482 #if CONFIG_MATROSKA_MUXER
3483 static int mkv_query_codec(enum AVCodecID codec_id, int std_compliance)
3484 {
3485  for (int i = 0; ff_mkv_codec_tags[i].id != AV_CODEC_ID_NONE; i++)
3486  if (ff_mkv_codec_tags[i].id == codec_id)
3487  return 1;
3488 
3489  if (std_compliance < FF_COMPLIANCE_NORMAL) {
3491  // mkv theoretically supports any video/audio through VFW/ACM
3493  return 1;
3494  }
3495 
3496  return 0;
3497 }
3498 
3500  .p.name = "matroska",
3501  .p.long_name = NULL_IF_CONFIG_SMALL("Matroska"),
3502  .p.mime_type = "video/x-matroska",
3503  .p.extensions = "mkv",
3504  .priv_data_size = sizeof(MatroskaMuxContext),
3505  .p.audio_codec = CONFIG_LIBVORBIS_ENCODER ?
3507  .p.video_codec = CONFIG_LIBX264_ENCODER ?
3509  .init = mkv_init,
3510  .deinit = mkv_deinit,
3511  .write_header = mkv_write_header,
3512  .write_packet = mkv_write_flush_packet,
3513  .write_trailer = mkv_write_trailer,
3514  .p.flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS |
3516  .p.codec_tag = (const AVCodecTag* const []){
3519  },
3520  .p.subtitle_codec = AV_CODEC_ID_ASS,
3521  .query_codec = mkv_query_codec,
3522  .check_bitstream = mkv_check_bitstream,
3523  .p.priv_class = &matroska_webm_class,
3524 };
3525 #endif
3526 
3527 #if CONFIG_WEBM_MUXER
3528 static int webm_query_codec(enum AVCodecID codec_id, int std_compliance)
3529 {
3530  for (int i = 0; ff_webm_codec_tags[i].id != AV_CODEC_ID_NONE; i++)
3531  if (ff_webm_codec_tags[i].id == codec_id)
3532  return 1;
3533 
3534  return 0;
3535 }
3536 
3537 const FFOutputFormat ff_webm_muxer = {
3538  .p.name = "webm",
3539  .p.long_name = NULL_IF_CONFIG_SMALL("WebM"),
3540  .p.mime_type = "video/webm",
3541  .p.extensions = "webm",
3542  .priv_data_size = sizeof(MatroskaMuxContext),
3543  .p.audio_codec = CONFIG_LIBOPUS_ENCODER ? AV_CODEC_ID_OPUS : AV_CODEC_ID_VORBIS,
3544  .p.video_codec = CONFIG_LIBVPX_VP9_ENCODER? AV_CODEC_ID_VP9 : AV_CODEC_ID_VP8,
3545  .p.subtitle_codec = AV_CODEC_ID_WEBVTT,
3546  .init = mkv_init,
3547  .deinit = mkv_deinit,
3548  .write_header = mkv_write_header,
3549  .write_packet = mkv_write_flush_packet,
3550  .write_trailer = mkv_write_trailer,
3551  .query_codec = webm_query_codec,
3552  .check_bitstream = mkv_check_bitstream,
3553  .p.flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS |
3555  .p.priv_class = &matroska_webm_class,
3556 };
3557 #endif
3558 
3559 #if CONFIG_MATROSKA_AUDIO_MUXER
3561  .p.name = "matroska",
3562  .p.long_name = NULL_IF_CONFIG_SMALL("Matroska Audio"),
3563  .p.mime_type = "audio/x-matroska",
3564  .p.extensions = "mka",
3565  .priv_data_size = sizeof(MatroskaMuxContext),
3566  .p.audio_codec = CONFIG_LIBVORBIS_ENCODER ?
3568  .p.video_codec = AV_CODEC_ID_NONE,
3569  .init = mkv_init,
3570  .deinit = mkv_deinit,
3571  .write_header = mkv_write_header,
3572  .write_packet = mkv_write_flush_packet,
3573  .write_trailer = mkv_write_trailer,
3574  .check_bitstream = mkv_check_bitstream,
3575  .p.flags = AVFMT_GLOBALHEADER | AVFMT_TS_NONSTRICT |
3577  .p.codec_tag = (const AVCodecTag* const []){
3579  },
3580  .p.priv_class = &matroska_webm_class,
3581 };
3582 #endif
MatroskaMuxContext::reserve_cues_space
int reserve_cues_space
Definition: matroskaenc.c:244
MATROSKA_ID_TAGTARGETS_ATTACHUID
#define MATROSKA_ID_TAGTARGETS_ATTACHUID
Definition: matroska.h:225
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:423
MATROSKA_ID_VIDEODISPLAYUNIT
#define MATROSKA_ID_VIDEODISPLAYUNIT
Definition: matroska.h:125
MATROSKA_ID_CODECPRIVATE
#define MATROSKA_ID_CODECPRIVATE
Definition: matroska.h:88
MATROSKA_ID_TRACKNUMBER
#define MATROSKA_ID_TRACKNUMBER
Definition: matroska.h:77
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
EBML_BIN
@ EBML_BIN
Definition: matroskaenc.c:109
MATROSKA_ID_TRACKFLAGVISUALIMPAIRED
#define MATROSKA_ID_TRACKFLAGVISUALIMPAIRED
Definition: matroska.h:101
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:250
MATROSKA_ID_CHAPSTRING
#define MATROSKA_ID_CHAPSTRING
Definition: matroska.h:266
IS_SEEKABLE
#define IS_SEEKABLE(pb, mkv)
Definition: matroskaenc.c:83
mkv_init
static int mkv_init(struct AVFormatContext *s)
Definition: matroskaenc.c:3300
MATROSKA_ID_TAGTARGETS
#define MATROSKA_ID_TAGTARGETS
Definition: matroska.h:220
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:76
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:235
LIBAVFORMAT_IDENT
#define LIBAVFORMAT_IDENT
Definition: version.h:45
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: codec_par.h:40
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:307
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:445
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:133
mkv_write_packet
static int mkv_write_packet(AVFormatContext *s, const AVPacket *pkt)
Definition: matroskaenc.c:2985
AVOutputFormat::name
const char * name
Definition: avformat.h:509
MATROSKA_ID_TITLE
#define MATROSKA_ID_TITLE
Definition: matroska.h:67
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:2306
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:294
ebml_writer_add_string
static void ebml_writer_add_string(EbmlWriter *writer, uint32_t id, const char *str)
Definition: matroskaenc.c:496
mkv_write_packet_internal
static int mkv_write_packet_internal(AVFormatContext *s, const AVPacket *pkt)
Definition: matroskaenc.c:2910
MatroskaMuxContext::allow_raw_vfw
int allow_raw_vfw
Definition: matroskaenc.c:252
ebml_writer_add_float
static void ebml_writer_add_float(EbmlWriter *writer, uint32_t id, double val)
Definition: matroskaenc.c:516
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:58
AVSphericalMapping::projection
enum AVSphericalProjection projection
Projection type.
Definition: spherical.h:82
AV1_SANE_SEQUENCE_HEADER_MAX_BITS
#define AV1_SANE_SEQUENCE_HEADER_MAX_BITS
Definition: av1.h:189
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:424
hevc.h
AVSphericalMapping::bound_bottom
uint32_t bound_bottom
Distance from the bottom edge.
Definition: spherical.h:166
MATROSKA_ID_VIDEOCOLORMASTERINGMETA
#define MATROSKA_ID_VIDEOCOLORMASTERINGMETA
Definition: matroska.h:149
ebml_writer_master_len
static int ebml_writer_master_len(EbmlWriter *writer, EbmlElement *elem, int remaining_elems)
Definition: matroskaenc.c:591
MatroskaMuxContext::segment_offset
int64_t segment_offset
Definition: matroskaenc.c:215
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:221
mkv_handle_spherical
static int mkv_handle_spherical(void *logctx, EbmlWriter *writer, const AVStream *st, uint8_t private[], double *yaw, double *pitch, double *roll)
Definition: matroskaenc.c:1461
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:54
EBML_ID_EBMLMAXSIZELENGTH
#define EBML_ID_EBMLMAXSIZELENGTH
Definition: matroska.h:38
ffformatcontext
static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)
Definition: internal.h:192
mkv_new_chapter_ids_needed
static int mkv_new_chapter_ids_needed(const AVFormatContext *s)
Definition: matroskaenc.c:2253
AVCodecParameters::color_space
enum AVColorSpace color_space
Definition: codec_par.h:151
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:774
MATROSKA_ID_TRACKFLAGTEXTDESCRIPTIONS
#define MATROSKA_ID_TRACKFLAGTEXTDESCRIPTIONS
Definition: matroska.h:102
AVFMT_VARIABLE_FPS
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:483
avcodec_get_type
enum AVMediaType avcodec_get_type(enum AVCodecID codec_id)
Get the type of the given codec.
Definition: codec_desc.c:3747
MATROSKA_ID_VIDEOPIXELWIDTH
#define MATROSKA_ID_VIDEOPIXELWIDTH
Definition: matroska.h:119
EbmlMaster::containing_master
int containing_master
-1 if no parent exists
Definition: matroskaenc.c:124
mkv_track::duration
int64_t duration
Definition: matroskaenc.c:191
MATROSKA_ID_AUDIOSAMPLINGFREQ
#define MATROSKA_ID_AUDIOSAMPLINGFREQ
Definition: matroska.h:169
MatroskaMuxContext::cluster_bc
AVIOContext * cluster_bc
Definition: matroskaenc.c:216
OPUS_SEEK_PREROLL
#define OPUS_SEEK_PREROLL
Seek preroll value for opus.
Definition: matroskaenc.c:275
matrix
Definition: vc1dsp.c:42
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
EbmlElement
Definition: matroskaenc.c:127
MODE_MATROSKAv2
#define MODE_MATROSKAv2
Definition: matroskaenc.c:78
ff_nal_units_create_list
int ff_nal_units_create_list(NALUList *list, const uint8_t *buf, int size)
Definition: avc.c:114
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:215
rational.h
MATROSKA_ID_DISCARDPADDING
#define MATROSKA_ID_DISCARDPADDING
Definition: matroska.h:250
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
MATROSKA_VIDEO_FIELDORDER_BB
@ MATROSKA_VIDEO_FIELDORDER_BB
Definition: matroska.h:307
ebml_writer_add_uint
static void ebml_writer_add_uint(EbmlWriter *writer, uint32_t id, uint64_t val)
Definition: matroskaenc.c:531
MATROSKA_ID_DURATION
#define MATROSKA_ID_DURATION
Definition: matroska.h:66
MATROSKA_ID_VIDEOCOLORCHROMASITINGVERT
#define MATROSKA_ID_VIDEOCOLORCHROMASITINGVERT
Definition: matroska.h:141
BlockContext::pkt
const AVPacket * pkt
Definition: matroskaenc.c:116
AVChannelLayout::u
union AVChannelLayout::@330 u
Details about which channels are present in this layout.
avlanguage.h
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:207
MATROSKA_ID_VIDEOCOLORPRIMARIES
#define MATROSKA_ID_VIDEOCOLORPRIMARIES
Definition: matroska.h:145
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:65
av_unused
#define av_unused
Definition: attributes.h:131
MATROSKA_ID_SEGMENT
#define MATROSKA_ID_SEGMENT
Definition: matroska.h:52
AV_DISPOSITION_DEFAULT
#define AV_DISPOSITION_DEFAULT
The stream should be chosen by default among other streams of the same type, unless the user has expl...
Definition: avformat.h:717
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
MATROSKA_ID_BLKADDIDTYPE
#define MATROSKA_ID_BLKADDIDTYPE
Definition: matroska.h:195
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:251
AV_CODEC_ID_RA_144
@ AV_CODEC_ID_RA_144
Definition: codec_id.h:427
ff_metadata_conv
void ff_metadata_conv(AVDictionary **pm, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)
Definition: metadata.c:26
ebml_writer_write
static int ebml_writer_write(EbmlWriter *writer, AVIOContext *pb)
Definition: matroskaenc.c:740
MATROSKA_ID_CHAPTERS
#define MATROSKA_ID_CHAPTERS
Definition: matroska.h:62
AVCOL_TRC_NB
@ AVCOL_TRC_NB
Not part of ABI.
Definition: pixfmt.h:592
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
ebml_writer_elem_write
static int ebml_writer_elem_write(const EbmlElement *elem, AVIOContext *pb)
Definition: matroskaenc.c:697
MATROSKA_ID_VIDEOCOLOR_BY
#define MATROSKA_ID_VIDEOCOLOR_BY
Definition: matroska.h:155
pixdesc.h
MATROSKA_ID_BLOCKDURATION
#define MATROSKA_ID_BLOCKDURATION
Definition: matroska.h:247
MATROSKA_ID_VIDEOCOLORRANGE
#define MATROSKA_ID_VIDEOCOLORRANGE
Definition: matroska.h:142
MATROSKA_ID_BLOCK
#define MATROSKA_ID_BLOCK
Definition: matroska.h:246
av_dynamic_hdr_plus_to_t35
int av_dynamic_hdr_plus_to_t35(const AVDynamicHDRPlus *s, uint8_t **data, size_t *size)
Serialize dynamic HDR10+ metadata to a user data registered ITU-T T.35 buffer, excluding the first 48...
Definition: hdr_dynamic_metadata.c:239
AVPacket::data
uint8_t * data
Definition: packet.h:374
MATROSKA_ID_TRACKDEFAULTDURATION
#define MATROSKA_ID_TRACKDEFAULTDURATION
Definition: matroska.h:108
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
av_const
#define av_const
Definition: attributes.h:84
put_xiph_size
static void put_xiph_size(AVIOContext *pb, int size)
Definition: matroskaenc.c:834
AVOption
AVOption.
Definition: opt.h:251
AVCOL_SPC_NB
@ AVCOL_SPC_NB
Not part of ABI.
Definition: pixfmt.h:616
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:573
MatroskaMuxContext::mode
int mode
Definition: matroskaenc.c:211
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:928
mkv_track::duration_offset
int64_t duration_offset
Definition: matroskaenc.c:192
data
const char data[16]
Definition: mxf.c:148
MATROSKA_VIDEO_INTERLACE_FLAG_INTERLACED
@ MATROSKA_VIDEO_INTERLACE_FLAG_INTERLACED
Definition: matroska.h:299
MatroskaMuxContext::cluster_pts
int64_t cluster_pts
Definition: matroskaenc.c:218
mkv_write_attachments
static int mkv_write_attachments(AVFormatContext *s)
Definition: matroskaenc.c:2367
AV_CODEC_ID_ALAC
@ AV_CODEC_ID_ALAC
Definition: codec_id.h:458
MATROSKA_ID_DATEUTC
#define MATROSKA_ID_DATEUTC
Definition: matroska.h:70
ebml_id_size
static int ebml_id_size(uint32_t id)
Definition: matroskaenc.c:277
flacenc.h
AVIOContext::error
int error
contains the error code or 0 if no error happened
Definition: avio.h:249
MatroskaMuxContext::tags
ebml_stored_master tags
Definition: matroskaenc.c:214
EBML_UID
@ EBML_UID
Definition: matroskaenc.c:106
matroska.h
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: mux_utils.c:126
ff_codec_wav_tags
const AVCodecTag ff_codec_wav_tags[]
Definition: riff.c:517
mkv_track::ts_offset
int64_t ts_offset
Definition: matroskaenc.c:197
put_ebml_binary
static void put_ebml_binary(AVIOContext *pb, uint32_t elementid, const void *buf, int size)
Definition: matroskaenc.c:387
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:392
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:66
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:68
MAX_VIDEO_COLOR_ELEMS
#define MAX_VIDEO_COLOR_ELEMS
Definition: matroskaenc.c:1326
max
#define max(a, b)
Definition: cuda_runtime.h:33
BlockContext
Definition: matroskaenc.c:114
mathematics.h
MATROSKA_ID_CUES
#define MATROSKA_ID_CUES
Definition: matroska.h:57
AVDictionary
Definition: dict.c:34
AV_CODEC_ID_FLAC
@ AV_CODEC_ID_FLAC
Definition: codec_id.h:454
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:306
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
MATROSKA_ID_CUETIME
#define MATROSKA_ID_CUETIME
Definition: matroska.h:202
IS_WEBM
#define IS_WEBM(mkv)
Definition: matroskaenc.c:81
AV_PROFILE_ARIB_PROFILE_C
#define AV_PROFILE_ARIB_PROFILE_C
Definition: defs.h:187
AVChannelLayout::mask
uint64_t mask
This member must be used for AV_CHANNEL_ORDER_NATIVE, and may be used for AV_CHANNEL_ORDER_AMBISONIC ...
Definition: channel_layout.h:333
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:229
MATROSKA_ID_CUERELATIVEPOSITION
#define MATROSKA_ID_CUERELATIVEPOSITION
Definition: matroska.h:208
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:311
MAX_PCE_SIZE
#define MAX_PCE_SIZE
Maximum size of a PCE including the 3-bit ID_PCE.
Definition: mpeg4audio.h:117
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:556
bit_depth
static void bit_depth(AudioStatsContext *s, const uint64_t *const mask, uint8_t *depth)
Definition: af_astats.c:245
AV_SPHERICAL_EQUIRECTANGULAR
@ AV_SPHERICAL_EQUIRECTANGULAR
Video represents a sphere mapped on a flat surface using equirectangular projection.
Definition: spherical.h:52
intfloat.h
codec_type
enum AVMediaType codec_type
Definition: rtp.c:37
MatroskaMuxContext::flipped_raw_rgb
int flipped_raw_rgb
Definition: matroskaenc.c:253
MATROSKA_ID_CHAPLANG
#define MATROSKA_ID_CHAPLANG
Definition: matroska.h:267
AV_CODEC_ID_TRUEHD
@ AV_CODEC_ID_TRUEHD
Definition: codec_id.h:486
MATROSKA_ID_CUEDURATION
#define MATROSKA_ID_CUEDURATION
Definition: matroska.h:209
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:1519
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:429
sample_rate
sample_rate
Definition: ffmpeg_filter.c:331
AV_WB64
#define AV_WB64(p, v)
Definition: intreadwrite.h:431
FFOutputFormat::p
AVOutputFormat p
The public AVOutputFormat.
Definition: mux.h:34
MatroskaMuxContext::cues_pos
int64_t cues_pos
Definition: matroskaenc.c:224
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:167
xiph.h
MatroskaMuxContext::cluster_size_limit
int cluster_size_limit
Definition: matroskaenc.c:245
MATROSKA_VIDEO_DISPLAYUNIT_UNKNOWN
@ MATROSKA_VIDEO_DISPLAYUNIT_UNKNOWN
Definition: matroska.h:336
mkv_track::codecpriv_offset
int codecpriv_offset
Definition: matroskaenc.c:195
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:29
crc.h
avio_wl16
void avio_wl16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:484
AVCodecParameters::color_primaries
enum AVColorPrimaries color_primaries
Definition: codec_par.h:149
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:508
MATROSKA_ID_VIDEOCOLOR_WHITEY
#define MATROSKA_ID_VIDEOCOLOR_WHITEY
Definition: matroska.h:157
NOTHING
#define NOTHING(STEREOMODETYPE, WDIV, HDIV, WEBM)
AV_PROFILE_ARIB_PROFILE_A
#define AV_PROFILE_ARIB_PROFILE_A
Definition: defs.h:186
HDIV1
#define HDIV1(STEREOMODETYPE, STEREO3DTYPE, FLAGS, WDIV, HDIV, WEBM)
start_ebml_master
static ebml_master start_ebml_master(AVIOContext *pb, uint32_t elementid, uint64_t expectedsize)
Definition: matroskaenc.c:425
DVCC_DVVC_BLOCK_TYPE_NAME
#define DVCC_DVVC_BLOCK_TYPE_NAME
Definition: matroska.h:439
AV_CODEC_ID_ASS
@ AV_CODEC_ID_ASS
Definition: codec_id.h:572
MATROSKA_ID_AUDIOOUTSAMPLINGFREQ
#define MATROSKA_ID_AUDIOOUTSAMPLINGFREQ
Definition: matroska.h:170
MAX_SUPPORTED_EBML_LENGTH
#define MAX_SUPPORTED_EBML_LENGTH
Definition: matroskaenc.c:76
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: avformat.c:787
mpeg4audio.h
MATROSKA_ID_VIDEOPROJECTIONPRIVATE
#define MATROSKA_ID_VIDEOPROJECTIONPRIVATE
Definition: matroska.h:163
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:416
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:331
mkv_cues
Definition: matroskaenc.c:174
MatroskaMuxContext::move_cues_to_front
int move_cues_to_front
Definition: matroskaenc.c:255
fail
#define fail()
Definition: checkasm.h:138
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:117
ebml_writer_sint_len
static int ebml_writer_sint_len(EbmlElement *elem)
Definition: matroskaenc.c:582
EbmlElement::sint
int64_t sint
Definition: matroskaenc.c:134
MATROSKA_ID_CHAPTERDISPLAY
#define MATROSKA_ID_CHAPTERDISPLAY
Definition: matroska.h:265
MATROSKA_ID_TRACKUID
#define MATROSKA_ID_TRACKUID
Definition: matroska.h:78
samplefmt.h
EBML_ID_DOCTYPEVERSION
#define EBML_ID_DOCTYPEVERSION
Definition: matroska.h:40
AVCOL_RANGE_NB
@ AVCOL_RANGE_NB
Not part of ABI.
Definition: pixfmt.h:674
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:367
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:513
ff_matroska_video_stereo_mode
const char *const ff_matroska_video_stereo_mode[MATROSKA_VIDEO_STEREOMODE_TYPE_NB]
Definition: matroska.c:129
AVChapter
Definition: avformat.h:1064
AV_DISPOSITION_FORCED
#define AV_DISPOSITION_FORCED
Track should be used during playback by default.
Definition: avformat.h:750
val
static double val(void *priv, double ch)
Definition: aeval.c:78
MATROSKA_BLOCK_ADD_ID_TYPE_ITU_T_T35
@ MATROSKA_BLOCK_ADD_ID_TYPE_ITU_T_T35
Definition: matroska.h:363
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
AV_FIELD_UNKNOWN
@ AV_FIELD_UNKNOWN
Definition: codec_par.h:39
MATROSKA_ID_VIDEOALPHAMODE
#define MATROSKA_ID_VIDEOALPHAMODE
Definition: matroska.h:129
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
pts
static int64_t pts
Definition: transcode_aac.c:643
us
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:251
AV_PKT_DATA_DISPLAYMATRIX
@ AV_PKT_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: packet.h:109
EBML_ID_DOCTYPE
#define EBML_ID_DOCTYPE
Definition: matroska.h:39
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
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:287
AV_CODEC_ID_ATRAC3
@ AV_CODEC_ID_ATRAC3
Definition: codec_id.h:473
mkv_track::max_blockaddid
uint64_t max_blockaddid
Definition: matroskaenc.c:193
MATROSKA_VIDEO_FIELDORDER_TT
@ MATROSKA_VIDEO_FIELDORDER_TT
Definition: matroska.h:305
AV_CODEC_ID_DVB_SUBTITLE
@ AV_CODEC_ID_DVB_SUBTITLE
Definition: codec_id.h:551
MatroskaVideoStereoModeType
MatroskaVideoStereoModeType
Definition: matroska.h:312
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:555
AV_CODEC_ID_SIPR
@ AV_CODEC_ID_SIPR
Definition: codec_id.h:483
AVCodecParameters::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: codec_par.h:150
MATROSKA_ID_BLKADDIDNAME
#define MATROSKA_ID_BLKADDIDNAME
Definition: matroska.h:194
mkv_write_tracks
static int mkv_write_tracks(AVFormatContext *s)
Definition: matroskaenc.c:2048
MatroskaMuxContext::ctx
AVFormatContext * ctx
Definition: matroskaenc.c:209
mkv_seekhead_entry
Definition: matroskaenc.c:154
MATROSKA_ID_BLOCKADDITIONAL
#define MATROSKA_ID_BLOCKADDITIONAL
Definition: matroska.h:242
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:203
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
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
EBML_ID_VOID
#define EBML_ID_VOID
Definition: matroska.h:44
MATROSKA_ID_VIDEOFIELDORDER
#define MATROSKA_ID_VIDEOFIELDORDER
Definition: matroska.h:127
AVCodecTag
Definition: internal.h:48
MATROSKA_ID_TAGS
#define MATROSKA_ID_TAGS
Definition: matroska.h:58
AV_CODEC_ID_TTA
@ AV_CODEC_ID_TTA
Definition: codec_id.h:464
options
static const AVOption options[]
Definition: matroskaenc.c:3457
duration
int64_t duration
Definition: movenc.c:64
put_ebml_id
static void put_ebml_id(AVIOContext *pb, uint32_t id)
Definition: matroskaenc.c:282
EBML_ID_EBMLMAXIDLENGTH
#define EBML_ID_EBMLMAXIDLENGTH
Definition: matroska.h:37
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:62
avio_open_dyn_buf
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1507
mkv_cuepoint::relative_pos
int64_t relative_pos
relative offset from the position of the cluster containing the block
Definition: matroskaenc.c:170
mkv_update_codecprivate
static int mkv_update_codecprivate(AVFormatContext *s, MatroskaMuxContext *mkv, uint8_t *side_data, int side_data_size, AVCodecParameters *par, AVIOContext *pb, mkv_track *track, unsigned alternative_size)
Definition: matroskaenc.c:1289
AV_CODEC_ID_ADPCM_G726
@ AV_CODEC_ID_ADPCM_G726
Definition: codec_id.h:380
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:165
ebml_writer_block_len
static int ebml_writer_block_len(EbmlElement *elem)
Definition: matroskaenc.c:617
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:435
MATROSKA_ID_FILEUID
#define MATROSKA_ID_FILEUID
Definition: matroska.h:258
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVCHROMA_LOC_TOP
@ AVCHROMA_LOC_TOP
Definition: pixfmt.h:697
MATROSKA_VIDEO_INTERLACE_FLAG_PROGRESSIVE
@ MATROSKA_VIDEO_INTERLACE_FLAG_PROGRESSIVE
Definition: matroska.h:300
EbmlElement::bin
const uint8_t * bin
Definition: matroskaenc.c:137
av_chroma_location_enum_to_pos
int av_chroma_location_enum_to_pos(int *xpos, int *ypos, enum AVChromaLocation pos)
Converts AVChromaLocation to swscale x/y chroma position.
Definition: pixdesc.c:3382
NALUList::nalus
NALU * nalus
Definition: avc.h:35
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:115
AVCOL_PRI_NB
@ AVCOL_PRI_NB
Not part of ABI.
Definition: pixfmt.h:563
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:182
mkv_write_stereo_mode
static int mkv_write_stereo_mode(AVFormatContext *s, EbmlWriter *writer, const AVStream *st, int is_webm, int *h_width, int *h_height)
Definition: matroskaenc.c:1582
CodecTags::str
char str[22]
Definition: matroska.h:376
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
AVFieldOrder
AVFieldOrder
Definition: codec_par.h:38
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:215
AV_PKT_DATA_MASTERING_DISPLAY_METADATA
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:223
format
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
mkv_write_flush_packet
static int mkv_write_flush_packet(AVFormatContext *s, AVPacket *pkt)
Definition: matroskaenc.c:3059
ebml_writer_add_block
static void ebml_writer_add_block(EbmlWriter *writer, MatroskaMuxContext *mkv)
Definition: matroskaenc.c:545
MATROSKA_VIDEO_FIELDORDER_BT
@ MATROSKA_VIDEO_FIELDORDER_BT
Definition: matroska.h:309
MatroskaMuxContext::cluster_pos
int64_t cluster_pos
file offset of the current Cluster
Definition: matroskaenc.c:217
AVDictionaryEntry::key
char * key
Definition: dict.h:90
MATROSKA_ID_TAGNAME
#define MATROSKA_ID_TAGNAME
Definition: matroska.h:215
AVSphericalMapping::bound_top
uint32_t bound_top
Distance from the top edge.
Definition: spherical.h:164
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:220
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:128
ebml_writer_open_master
static void ebml_writer_open_master(EbmlWriter *writer, uint32_t id)
Definition: matroskaenc.c:453
MATROSKA_ID_TAG
#define MATROSKA_ID_TAG
Definition: matroska.h:213
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
ebml_writer_add_uid
static void ebml_writer_add_uid(EbmlWriter *writer, uint32_t id, uint64_t val)
Definition: matroskaenc.c:524
MATROSKA_ID_TIMECODESCALE
#define MATROSKA_ID_TIMECODESCALE
Definition: matroska.h:65
lfg.h
MatroskaMuxContext::tmp_bc
AVIOContext * tmp_bc
Definition: matroskaenc.c:234
get_mimetype
static const char * get_mimetype(const AVStream *st)
Definition: matroskaenc.c:2350
ebml_writer_add_sint
static void ebml_writer_add_sint(EbmlWriter *writer, uint32_t id, int64_t val)
Definition: matroskaenc.c:538
MatroskaMuxContext::write_crc
int write_crc
Definition: matroskaenc.c:247
matroska_webm_class
static const AVClass matroska_webm_class
Definition: matroskaenc.c:3475
AV_OPT_TYPE_INT64
@ AV_OPT_TYPE_INT64
Definition: opt.h:226
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
MATROSKA_ID_CUETRACKPOSITION
#define MATROSKA_ID_CUETRACKPOSITION
Definition: matroska.h:203
additional_audio_tags
static const AVCodecTag additional_audio_tags[]
Definition: matroskaenc.c:3433
MATROSKA_ID_SEEKENTRY
#define MATROSKA_ID_SEEKENTRY
Definition: matroska.h:228
ff_isom_put_dvcc_dvvc
void ff_isom_put_dvcc_dvvc(void *logctx, uint8_t out[ISOM_DVCC_DVVC_SIZE], const AVDOVIDecoderConfigurationRecord *dovi)
Definition: dovi_isom.c:86
mkv_track::track_num
unsigned track_num
Definition: matroskaenc.c:185
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:79
ebml_writer_close_master
static void ebml_writer_close_master(EbmlWriter *writer)
Definition: matroskaenc.c:464
AVDOVIDecoderConfigurationRecord::dv_profile
uint8_t dv_profile
Definition: dovi_meta.h:55
MATROSKA_ID_SEGMENTUID
#define MATROSKA_ID_SEGMENTUID
Definition: matroska.h:71
EbmlType
EbmlType
Definition: matroskadec.c:87
MATROSKA_ID_TRACKBLKADDMAPPING
#define MATROSKA_ID_TRACKBLKADDMAPPING
Definition: matroska.h:113
AV_PKT_DATA_DYNAMIC_HDR10_PLUS
@ AV_PKT_DATA_DYNAMIC_HDR10_PLUS
HDR10+ dynamic metadata associated with a video frame.
Definition: packet.h:300
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:142
sint_size
static av_const int sint_size(int64_t val)
Definition: matroskaenc.c:576
MatroskaMuxContext::cluster_time_limit
int64_t cluster_time_limit
Definition: matroskaenc.c:246
EbmlElement::type
EbmlType type
Definition: matroskaenc.c:129
EbmlElement::f
double f
Definition: matroskaenc.c:135
MATROSKA_ID_INFO
#define MATROSKA_ID_INFO
Definition: matroska.h:55
MatroskaMuxContext::have_video
int have_video
Definition: matroskaenc.c:239
MATROSKA_ID_AUDIOCHANNELS
#define MATROSKA_ID_AUDIOCHANNELS
Definition: matroska.h:173
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:388
MATROSKA_ID_BLKADDIDVALUE
#define MATROSKA_ID_BLKADDIDVALUE
Definition: matroska.h:193
AV_CODEC_ID_SVQ3
@ AV_CODEC_ID_SVQ3
Definition: codec_id.h:75
EbmlType
EbmlType
Definition: matroskaenc.c:102
key
const char * key
Definition: hwcontext_opencl.c:174
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:548
ff_format_shift_data
int ff_format_shift_data(AVFormatContext *s, int64_t read_start, int shift_size)
Make shift_size amount of space at read_start by shifting data in the output at read_start until the ...
Definition: mux_utils.c:60
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
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:863
ff_webm_codec_tags
const CodecTags ff_webm_codec_tags[]
Definition: matroska.c:107
mkv_track::uid
uint64_t uid
Definition: matroskaenc.c:184
HDIV2
#define HDIV2(STEREOMODETYPE, WDIV, HDIV, WEBM)
AV_CODEC_ID_ARIB_CAPTION
@ AV_CODEC_ID_ARIB_CAPTION
Definition: codec_id.h:575
AVStereo3D::flags
int flags
Additional information about the frame packing.
Definition: stereo3d.h:182
MATROSKA_ID_VIDEOCOLORSPACE
#define MATROSKA_ID_VIDEOCOLORSPACE
Definition: matroska.h:131
MATROSKA_ID_TRACKNAME
#define MATROSKA_ID_TRACKNAME
Definition: matroska.h:95
FFFormatContext
Definition: internal.h:70
BlockContext::track
struct mkv_track * track
Definition: matroskaenc.c:115
AV_CODEC_ID_WEBVTT
@ AV_CODEC_ID_WEBVTT
Definition: codec_id.h:568
EBML_ID_DOCTYPEREADVERSION
#define EBML_ID_DOCTYPEREADVERSION
Definition: matroska.h:41
mkv_cues::entries
mkv_cuepoint * entries
Definition: matroskaenc.c:175
AVFormatContext
Format I/O context.
Definition: avformat.h:1105
internal.h
MATROSKA_ID_TRACKFLAGHEARINGIMPAIRED
#define MATROSKA_ID_TRACKFLAGHEARINGIMPAIRED
Definition: matroska.h:100
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:862
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
MATROSKA_ID_BLOCKGROUP
#define MATROSKA_ID_BLOCKGROUP
Definition: matroska.h:238
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
EbmlWriter
Definition: matroskaenc.c:143
mkv_assemble_codecprivate
static int mkv_assemble_codecprivate(AVFormatContext *s, AVIOContext *dyn_cp, AVCodecParameters *par, const uint8_t *extradata, int extradata_size, int native_id, int qt_id, uint8_t **codecpriv, int *codecpriv_size, unsigned *max_payload_size)
Definition: matroskaenc.c:1187
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:878
NULL
#define NULL
Definition: coverity.c:32
MATROSKA_ID_ATTACHMENTS
#define MATROSKA_ID_ATTACHMENTS
Definition: matroska.h:60
STEREOMODE_STEREO3D_MAPPING
#define STEREOMODE_STEREO3D_MAPPING(MAP, MKV_ONLY)
Definition: matroska.h:401
ff_put_wav_header
int ff_put_wav_header(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, int flags)
Write WAVEFORMAT header structure.
Definition: riffenc.c:54
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:262
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:283
MATROSKA_TRACK_TYPE_AUDIO
@ MATROSKA_TRACK_TYPE_AUDIO
Definition: matroska.h:281
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:320
STEREOMODE
#define STEREOMODE(STEREOMODETYPE, STEREO3DTYPE, FLAGS, WDIV, HDIV, WEBM)
isom.h
MATROSKA_ID_TRACKFLAGORIGINAL
#define MATROSKA_ID_TRACKFLAGORIGINAL
Definition: matroska.h:103
MATROSKA_VIDEO_DISPLAYUNIT_DAR
@ MATROSKA_VIDEO_DISPLAYUNIT_DAR
Definition: matroska.h:335
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
MATROSKA_ID_WRITINGAPP
#define MATROSKA_ID_WRITINGAPP
Definition: matroska.h:68
WV_HEADER_SIZE
#define WV_HEADER_SIZE
Definition: wavpack.h:33
MatroskaMuxContext::info
ebml_stored_master info
Definition: matroskaenc.c:212
AV_DISPOSITION_COMMENT
#define AV_DISPOSITION_COMMENT
The stream is a commentary track.
Definition: avformat.h:735
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:95
AV_CODEC_ID_DVD_SUBTITLE
@ AV_CODEC_ID_DVD_SUBTITLE
Definition: codec_id.h:550
MAX_VIDEO_PROJECTION_ELEMS
#define MAX_VIDEO_PROJECTION_ELEMS
Definition: matroskaenc.c:1409
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
avc.h
parseutils.h
MATROSKA_ID_SIMPLETAG
#define MATROSKA_ID_SIMPLETAG
Definition: matroska.h:214
MATROSKA_ID_VIDEOPROJECTION
#define MATROSKA_ID_VIDEOPROJECTION
Definition: matroska.h:161
mkv_assemble_native_codecprivate
static int mkv_assemble_native_codecprivate(AVFormatContext *s, AVIOContext *dyn_cp, const AVCodecParameters *par, const uint8_t *extradata, int extradata_size, unsigned *size_to_reserve)
Definition: matroskaenc.c:1110
MatroskaMuxContext::segment_uid
uint32_t segment_uid[4]
Definition: matroskaenc.c:257
MatroskaMuxContext::cur_block
BlockContext cur_block
Definition: matroskaenc.c:226
put_xiph_codecpriv
static int put_xiph_codecpriv(AVFormatContext *s, AVIOContext *pb, const AVCodecParameters *par, const uint8_t *extradata, int extradata_size)
Definition: matroskaenc.c:998
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:919
MATROSKA_ID_SEEKID
#define MATROSKA_ID_SEEKID
Definition: matroska.h:231
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:329
FFOutputFormat
Definition: mux.h:30
AV_DISPOSITION_METADATA
#define AV_DISPOSITION_METADATA
The subtitle stream contains time-aligned metadata that is not intended to be directly presented to t...
Definition: avformat.h:799
EBML_STR
@ EBML_STR
Definition: matroskaenc.c:107
double
double
Definition: af_crystalizer.c:131
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:589
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:226
MATROSKA_ID_CHAPTERTIMESTART
#define MATROSKA_ID_CHAPTERTIMESTART
Definition: matroska.h:263
ff_codec_movvideo_tags
const AVCodecTag ff_codec_movvideo_tags[]
Definition: isom_tags.c:29
ffio_fill
void ffio_fill(AVIOContext *s, int b, int64_t count)
Definition: aviobuf.c:234
mkv_add_seekhead_entry
static void mkv_add_seekhead_entry(MatroskaMuxContext *mkv, uint32_t elementid, uint64_t filepos)
Definition: matroskaenc.c:750
AV_DISPOSITION_ORIGINAL
#define AV_DISPOSITION_ORIGINAL
The stream is in original language.
Definition: avformat.h:731
mkv_track::sample_rate_offset
int64_t sample_rate_offset
Definition: matroskaenc.c:189
AV_CODEC_ID_QDM2
@ AV_CODEC_ID_QDM2
Definition: codec_id.h:461
mkv_get_uid
static uint64_t mkv_get_uid(const mkv_track *tracks, int i, AVLFG *c)
Definition: matroskaenc.c:3282
MATROSKA_TRACK_TYPE_VIDEO
@ MATROSKA_TRACK_TYPE_VIDEO
Definition: matroska.h:280
ebml_writer_add
static EbmlElement * ebml_writer_add(EbmlWriter *writer, uint32_t id, EbmlType type)
Definition: matroskaenc.c:445
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:431
get_metadata_duration
static int64_t get_metadata_duration(AVFormatContext *s)
Definition: matroskaenc.c:2417
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:213
mkv_track::has_cue
int has_cue
Definition: matroskaenc.c:183
MATROSKA_ID_FILEMIMETYPE
#define MATROSKA_ID_FILEMIMETYPE
Definition: matroska.h:256
MATROSKA_ID_VIDEODISPLAYHEIGHT
#define MATROSKA_ID_VIDEODISPLAYHEIGHT
Definition: matroska.h:118
WDIV1
#define WDIV1(STEREOMODETYPE, STEREO3DTYPE, FLAGS, WDIV, HDIV, WEBM)
EbmlWriter::elements
EbmlElement * elements
Definition: matroskaenc.c:146
ff_matroska_audio_muxer
const FFOutputFormat ff_matroska_audio_muxer
DURATION_STRING_LENGTH
#define DURATION_STRING_LENGTH
DURATION_STRING_LENGTH must be <= 112 or the containing simpletag will need more than one byte for it...
Definition: matroskaenc.c:269
MATROSKA_ID_TRACKAUDIO
#define MATROSKA_ID_TRACKAUDIO
Definition: matroska.h:81
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:639
EbmlElement::str
const char * str
Definition: matroskaenc.c:136
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:238
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:178
put_ebml_float
static void put_ebml_float(AVIOContext *pb, uint32_t elementid, double val)
Definition: matroskaenc.c:380
uint_size
static av_const int uint_size(uint64_t val)
Definition: matroskaenc.c:561
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
MATROSKA_ID_VIDEOCOLORMAXCLL
#define MATROSKA_ID_VIDEOCOLORMAXCLL
Definition: matroska.h:146
MATROSKA_ID_TRACKENTRY
#define MATROSKA_ID_TRACKENTRY
Definition: matroska.h:74
ebml_stored_master
Definition: matroskaenc.c:97
WDIV2
#define WDIV2(STEREOMODETYPE, WDIV, HDIV, WEBM)
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:80
AV_WB32
#define AV_WB32(p, v)
Definition: intreadwrite.h:417
ff_wv_parse_header
int ff_wv_parse_header(WvHeader *wv, const uint8_t *data)
Parse a WavPack block header.
Definition: wv.c:30
mkv_put_codecprivate
static void mkv_put_codecprivate(AVIOContext *pb, unsigned max_payload_size, const uint8_t *codecpriv, unsigned codecpriv_size)
Definition: matroskaenc.c:1260
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:444
mkv_write_header
static int mkv_write_header(AVFormatContext *s)
Definition: matroskaenc.c:2516
MatroskaMuxContext
Definition: matroskaenc.c:207
mkv_cuepoint::duration
int64_t duration
duration of the block according to time base
Definition: matroskaenc.c:171
ff_nal_units_write_list
void ff_nal_units_write_list(const NALUList *list, AVIOContext *pb, const uint8_t *buf)
Definition: avc.c:120
EbmlMaster::nb_elements
int nb_elements
-1 if not finished
Definition: matroskaenc.c:123
ebml_writer_add_bin
static void ebml_writer_add_bin(EbmlWriter *writer, uint32_t id, const uint8_t *data, size_t size)
Definition: matroskaenc.c:504
AV_DISPOSITION_CAPTIONS
#define AV_DISPOSITION_CAPTIONS
The subtitle stream contains captions, providing a transcription and possibly a translation of audio.
Definition: avformat.h:788
mkv_track::blockadditionmapping_offset
int64_t blockadditionmapping_offset
Definition: matroskaenc.c:194
MATROSKA_ID_AUDIOBITDEPTH
#define MATROSKA_ID_AUDIOBITDEPTH
Definition: matroska.h:172
AV_CODEC_ID_FFV1
@ AV_CODEC_ID_FFV1
Definition: codec_id.h:85
AVLFG
Context structure for the Lagged Fibonacci PRNG.
Definition: lfg.h:33
mkv_track::offset
unsigned offset
Definition: matroskaenc.c:188
MATROSKA_ID_TRACKFLAGDEFAULT
#define MATROSKA_ID_TRACKFLAGDEFAULT
Definition: matroska.h:98
AVIOContext
Bytestream IO Context.
Definition: avio.h:166
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:61
MATROSKA_ID_TRACKFLAGCOMMENTARY
#define MATROSKA_ID_TRACKFLAGCOMMENTARY
Definition: matroska.h:104
ffio_reset_dyn_buf
void ffio_reset_dyn_buf(AVIOContext *s)
Reset a dynamic buffer.
Definition: aviobuf.c:1541
AVMediaType
AVMediaType
Definition: avutil.h:199
MATROSKA_ID_TRACKFLAGLACING
#define MATROSKA_ID_TRACKFLAGLACING
Definition: matroska.h:105
AVPacket::size
int size
Definition: packet.h:375
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:106
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:145
master
const char * master
Definition: vf_curves.c:129
ff_isom_write_avcc
int ff_isom_write_avcc(AVIOContext *pb, const uint8_t *data, int len)
Definition: avc.c:142
AVSphericalMapping::bound_right
uint32_t bound_right
Distance from the right edge.
Definition: spherical.h:165
mkv_write_field_order
static void mkv_write_field_order(EbmlWriter *writer, int is_webm, enum AVFieldOrder field_order)
Definition: matroskaenc.c:1542
EBML_FLOAT
@ EBML_FLOAT
Definition: matroskaenc.c:105
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:735
MATROSKA_ID_FILEDATA
#define MATROSKA_ID_FILEDATA
Definition: matroska.h:257
ebml_master::sizebytes
int sizebytes
how many bytes were reserved for the size
Definition: matroskaenc.c:94
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:240
MAX_SEEKHEAD_ENTRIES
#define MAX_SEEKHEAD_ENTRIES
Definition: matroskaenc.c:70
mkv_handle_rotation
static void mkv_handle_rotation(void *logctx, const AVStream *st, double *yaw, double *roll)
Definition: matroskaenc.c:1410
MATROSKA_BLOCK_ADD_ID_TYPE_OPAQUE
@ MATROSKA_BLOCK_ADD_ID_TYPE_OPAQUE
Definition: matroska.h:362
mkv_cuepoint::pts
uint64_t pts
Definition: matroskaenc.c:167
ebml_stored_master::bc
AVIOContext * bc
Definition: matroskaenc.c:98
EbmlWriter::current_master_element
int current_master_element
Definition: matroskaenc.c:145
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:492
put_ebml_void
static void put_ebml_void(AVIOContext *pb, int size)
Write a void element of a given size.
Definition: matroskaenc.c:407
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
EbmlElement::size
uint64_t size
excluding id and length field
Definition: matroskaenc.c:131
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:489
AVCodecParameters::profile
int profile
Codec-specific bitstream restrictions that the stream conforms to.
Definition: codec_par.h:122
AV_CODEC_ID_OPUS
@ AV_CODEC_ID_OPUS
Definition: codec_id.h:502
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:693
AV_DISPOSITION_DUB
#define AV_DISPOSITION_DUB
The stream is not in original language.
Definition: avformat.h:725
MatroskaMuxContext::cur_audio_pkt
AVPacket * cur_audio_pkt
Definition: matroskaenc.c:236
EBML_UINT
@ EBML_UINT
Definition: matroskaenc.c:103
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:917
av1.h
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:127
mkv_track::codecpriv_size
unsigned codecpriv_size
size reserved for CodecPrivate excluding header+length field
Definition: matroskaenc.c:196
start_ebml_master_crc32
static int start_ebml_master_crc32(AVIOContext **dyn_cp, MatroskaMuxContext *mkv)
Definition: matroskaenc.c:761
MATROSKA_ID_POINTENTRY
#define MATROSKA_ID_POINTENTRY
Definition: matroska.h:199
dovi_isom.h
header
static const uint8_t header[24]
Definition: sdr2.c:67
AV_DISPOSITION_HEARING_IMPAIRED
#define AV_DISPOSITION_HEARING_IMPAIRED
The stream is intended for hearing impaired audiences.
Definition: avformat.h:754
MATROSKA_ID_BLKADDIDEXTRADATA
#define MATROSKA_ID_BLKADDIDEXTRADATA
Definition: matroska.h:196
CASE
#define CASE(type, variable)
ff_isom_write_av1c
int ff_isom_write_av1c(AVIOContext *pb, const uint8_t *buf, int size, int write_seq_header)
Writes AV1 extradata (Sequence Header and Metadata OBUs) to the provided AVIOContext.
Definition: av1.c:398
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:373
MAX_FIELD_ORDER_ELEMS
#define MAX_FIELD_ORDER_ELEMS
Definition: matroskaenc.c:1541
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:248
avio_wb32
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:412
FF_COMPLIANCE_NORMAL
#define FF_COMPLIANCE_NORMAL
Definition: defs.h:60
AVSphericalMapping::padding
uint32_t padding
Number of pixels to pad from the edge of each cube face.
Definition: spherical.h:178
additional_subtitle_tags
static const AVCodecTag additional_subtitle_tags[]
Definition: matroskaenc.c:3447
EbmlElement::mkv
struct MatroskaMuxContext * mkv
used by EBML_BLOCK
Definition: matroskaenc.c:138
avio_wl32
void avio_wl32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:404
mkv_write_blockadditional
static void mkv_write_blockadditional(EbmlWriter *writer, const uint8_t *buf, size_t size, uint64_t additional_id)
Definition: matroskaenc.c:2709
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
AV_FIELD_TT
@ AV_FIELD_TT
Top coded_first, top displayed first.
Definition: codec_par.h:41
AV_CODEC_ID_RV30
@ AV_CODEC_ID_RV30
Definition: codec_id.h:120
mkv_write_video_projection
static void mkv_write_video_projection(void *logctx, EbmlWriter *wr, const AVStream *st, uint8_t private[])
Definition: matroskaenc.c:1519
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
mkv_write_tag_targets
static void mkv_write_tag_targets(MatroskaMuxContext *mkv, AVIOContext *pb, uint32_t elementid, uint64_t uid)
Definition: matroskaenc.c:2137
AV_PKT_DATA_CONTENT_LIGHT_LEVEL
@ AV_PKT_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: packet.h:236
BlockContext::flags
uint8_t flags
Definition: matroskaenc.c:118
AV_CHANNEL_ORDER_NATIVE
@ AV_CHANNEL_ORDER_NATIVE
The native channel order, i.e.
Definition: channel_layout.h:118
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:380
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:225
version
version
Definition: libkvazaar.c:314
mkv_write_trailer
static int mkv_write_trailer(AVFormatContext *s)
Definition: matroskaenc.c:3077
AV_STEREO3D_FLAG_INVERT
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:164
MATROSKA_ID_VIDEOPIXELHEIGHT
#define MATROSKA_ID_VIDEOPIXELHEIGHT
Definition: matroska.h:120
mkv_write_tags
static int mkv_write_tags(AVFormatContext *s)
Definition: matroskaenc.c:2202
AV_CODEC_ID_SVQ1
@ AV_CODEC_ID_SVQ1
Definition: codec_id.h:74
M_PI
#define M_PI
Definition: mathematics.h:67
mkv_cuepoint::stream_idx
int stream_idx
Definition: matroskaenc.c:168
EBML_MASTER
@ EBML_MASTER
Definition: matroskaenc.c:111
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
MATROSKA_ID_MUXINGAPP
#define MATROSKA_ID_MUXINGAPP
Definition: matroska.h:69
mkv_write_video_color
static void mkv_write_video_color(EbmlWriter *writer, const AVStream *st, const AVCodecParameters *par)
Definition: matroskaenc.c:1327
MatroskaMuxContext::duration
int64_t duration
Definition: matroskaenc.c:220
MATROSKA_ID_EDITIONFLAGDEFAULT
#define MATROSKA_ID_EDITIONFLAGDEFAULT
Definition: matroska.h:271
MATROSKA_ID_FILEDESC
#define MATROSKA_ID_FILEDESC
Definition: matroska.h:254
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:414
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:262
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:1