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