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