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 "subtitles.h"
36 #include "vorbiscomment.h"
37 #include "wv.h"
38 
39 #include "libavutil/avstring.h"
41 #include "libavutil/crc.h"
42 #include "libavutil/dict.h"
43 #include "libavutil/intfloat.h"
44 #include "libavutil/intreadwrite.h"
45 #include "libavutil/lfg.h"
47 #include "libavutil/mathematics.h"
48 #include "libavutil/opt.h"
49 #include "libavutil/parseutils.h"
50 #include "libavutil/random_seed.h"
51 #include "libavutil/rational.h"
52 #include "libavutil/samplefmt.h"
53 #include "libavutil/sha.h"
54 #include "libavutil/stereo3d.h"
55 
56 #include "libavcodec/xiph.h"
57 #include "libavcodec/mpeg4audio.h"
58 #include "libavcodec/internal.h"
59 
60 /* Level 1 elements we create a SeekHead entry for:
61  * Info, Tracks, Chapters, Attachments, Tags and Cues */
62 #define MAX_SEEKHEAD_ENTRIES 6
63 
64 typedef struct ebml_master {
65  int64_t pos; ///< absolute offset in the containing AVIOContext where the master's elements start
66  int sizebytes; ///< how many bytes were reserved for the size
67 } ebml_master;
68 
69 typedef struct mkv_seekhead_entry {
70  uint32_t elementid;
71  uint64_t segmentpos;
73 
74 typedef struct mkv_seekhead {
75  int64_t filepos;
79 } mkv_seekhead;
80 
81 typedef struct mkv_cuepoint {
82  uint64_t pts;
84  int tracknum;
85  int64_t cluster_pos; ///< offset of the cluster containing the block relative to the segment
86  int64_t relative_pos; ///< relative offset from the position of the cluster containing the block
87  int64_t duration; ///< duration of the block according to time base
88 } mkv_cuepoint;
89 
90 typedef struct mkv_cues {
93 } mkv_cues;
94 
95 typedef struct mkv_track {
96  int write_dts;
97  int has_cue;
100  int64_t last_timestamp;
101  int64_t duration;
104  int64_t ts_offset;
105 } mkv_track;
106 
107 typedef struct mkv_attachment {
109  uint32_t fileuid;
111 
112 typedef struct mkv_attachments {
116 
117 #define MODE_MATROSKAv2 0x01
118 #define MODE_WEBM 0x02
119 
120 /** Maximum number of tracks allowed in a Matroska file (with track numbers in
121  * range 1 to 126 (inclusive) */
122 #define MAX_TRACKS 126
123 
124 typedef struct MatroskaMuxContext {
125  const AVClass *class;
126  int mode;
128  int64_t tags_pos;
130  int64_t info_pos;
132  int64_t tracks_pos;
134  int64_t segment_offset;
136  int64_t cluster_pos; ///< file offset of the current cluster
137  int64_t cluster_pts;
139  int64_t duration;
144 
146 
149 
152  int64_t cues_pos;
154  int is_dash;
156  int is_live;
158 
161 
164 
165 /** 2 bytes * 7 for EBML IDs, 7 1-byte EBML lengths, 6 1-byte uint,
166  * 8 byte for "matroska" doctype string */
167 #define MAX_EBML_HEADER_SIZE 35
168 
169 /** 2 bytes * 3 for EBML IDs, 3 1-byte EBML lengths, 8 bytes for 64 bit
170  * offset, 4 bytes for target EBML ID */
171 #define MAX_SEEKENTRY_SIZE 21
172 
173 /** 4 * (1-byte EBML ID, 1-byte EBML size, 8-byte uint max) */
174 #define MAX_CUETRACKPOS_SIZE 40
175 
176 /** Seek preroll value for opus */
177 #define OPUS_SEEK_PREROLL 80000000
178 
179 static int ebml_id_size(uint32_t id)
180 {
181  return (av_log2(id) + 7U) / 8;
182 }
183 
184 static void put_ebml_id(AVIOContext *pb, uint32_t id)
185 {
186  int i = ebml_id_size(id);
187  while (i--)
188  avio_w8(pb, (uint8_t)(id >> (i * 8)));
189 }
190 
191 /**
192  * Write an EBML size meaning "unknown size".
193  *
194  * @param bytes The number of bytes the size should occupy (maximum: 8).
195  */
196 static void put_ebml_size_unknown(AVIOContext *pb, int bytes)
197 {
198  av_assert0(bytes <= 8);
199  avio_w8(pb, 0x1ff >> bytes);
200  ffio_fill(pb, 0xff, bytes - 1);
201 }
202 
203 /**
204  * Calculate how many bytes are needed to represent a given number in EBML.
205  */
206 static int ebml_num_size(uint64_t num)
207 {
208  int bytes = 1;
209  while ((num + 1) >> bytes * 7)
210  bytes++;
211  return bytes;
212 }
213 
214 /**
215  * Write a number in EBML variable length format.
216  *
217  * @param bytes The number of bytes that need to be used to write the number.
218  * If zero, the minimal number of bytes will be used.
219  */
220 static void put_ebml_num(AVIOContext *pb, uint64_t num, int bytes)
221 {
222  int i, needed_bytes = ebml_num_size(num);
223 
224  // sizes larger than this are currently undefined in EBML
225  av_assert0(num < (1ULL << 56) - 1);
226 
227  if (bytes == 0)
228  bytes = needed_bytes;
229  // The bytes needed to write the given size must not exceed
230  // the bytes that we ought to use.
231  av_assert0(bytes >= needed_bytes);
232 
233  num |= 1ULL << bytes * 7;
234  for (i = bytes - 1; i >= 0; i--)
235  avio_w8(pb, (uint8_t)(num >> i * 8));
236 }
237 
238 static void put_ebml_uint(AVIOContext *pb, uint32_t elementid, uint64_t val)
239 {
240  int i, bytes = 1;
241  uint64_t tmp = val;
242  while (tmp >>= 8)
243  bytes++;
244 
245  put_ebml_id(pb, elementid);
246  put_ebml_num(pb, bytes, 0);
247  for (i = bytes - 1; i >= 0; i--)
248  avio_w8(pb, (uint8_t)(val >> i * 8));
249 }
250 
251 static void put_ebml_sint(AVIOContext *pb, uint32_t elementid, int64_t val)
252 {
253  int i, bytes = 1;
254  uint64_t tmp = 2*(val < 0 ? val^-1 : val);
255 
256  while (tmp>>=8) bytes++;
257 
258  put_ebml_id(pb, elementid);
259  put_ebml_num(pb, bytes, 0);
260  for (i = bytes - 1; i >= 0; i--)
261  avio_w8(pb, (uint8_t)(val >> i * 8));
262 }
263 
264 static void put_ebml_float(AVIOContext *pb, uint32_t elementid, double val)
265 {
266  put_ebml_id(pb, elementid);
267  put_ebml_num(pb, 8, 0);
268  avio_wb64(pb, av_double2int(val));
269 }
270 
271 static void put_ebml_binary(AVIOContext *pb, uint32_t elementid,
272  const void *buf, int size)
273 {
274  put_ebml_id(pb, elementid);
275  put_ebml_num(pb, size, 0);
276  avio_write(pb, buf, size);
277 }
278 
279 static void put_ebml_string(AVIOContext *pb, uint32_t elementid,
280  const char *str)
281 {
282  put_ebml_binary(pb, elementid, str, strlen(str));
283 }
284 
285 /**
286  * Write a void element of a given size. Useful for reserving space in
287  * the file to be written to later.
288  *
289  * @param size The number of bytes to reserve, which must be at least 2.
290  */
291 static void put_ebml_void(AVIOContext *pb, int size)
292 {
293  av_assert0(size >= 2);
294 
296  // we need to subtract the length needed to store the size from the
297  // size we need to reserve so 2 cases, we use 8 bytes to store the
298  // size if possible, 1 byte otherwise
299  if (size < 10) {
300  size -= 2;
301  put_ebml_num(pb, size, 0);
302  } else {
303  size -= 9;
304  put_ebml_num(pb, size, 8);
305  }
306  ffio_fill(pb, 0, size);
307 }
308 
309 static ebml_master start_ebml_master(AVIOContext *pb, uint32_t elementid,
310  uint64_t expectedsize)
311 {
312  int bytes = expectedsize ? ebml_num_size(expectedsize) : 8;
313 
314  put_ebml_id(pb, elementid);
315  put_ebml_size_unknown(pb, bytes);
316  return (ebml_master) { avio_tell(pb), bytes };
317 }
318 
320 {
321  int64_t pos = avio_tell(pb);
322 
323  if (avio_seek(pb, master.pos - master.sizebytes, SEEK_SET) < 0)
324  return;
325  put_ebml_num(pb, pos - master.pos, master.sizebytes);
326  avio_seek(pb, pos, SEEK_SET);
327 }
328 
330 {
331  int ret;
332 
333  if (!*dyn_cp && (ret = avio_open_dyn_buf(dyn_cp)) < 0)
334  return ret;
335 
336  if (mkv->write_crc)
337  put_ebml_void(*dyn_cp, 6); /* Reserve space for CRC32 so position/size calculations using avio_tell() take it into account */
338 
339  return 0;
340 }
341 
343  MatroskaMuxContext *mkv, uint32_t id,
344  int length_size, int keep_buffer)
345 {
346  uint8_t *buf, crc[4];
347  int size, skip = 0;
348 
349  put_ebml_id(pb, id);
350  size = avio_get_dyn_buf(*dyn_cp, &buf);
351  put_ebml_num(pb, size, length_size);
352  if (mkv->write_crc) {
353  skip = 6; /* Skip reserved 6-byte long void element from the dynamic buffer. */
354  AV_WL32(crc, av_crc(av_crc_get_table(AV_CRC_32_IEEE_LE), UINT32_MAX, buf + skip, size - skip) ^ UINT32_MAX);
355  put_ebml_binary(pb, EBML_ID_CRC32, crc, sizeof(crc));
356  }
357  avio_write(pb, buf + skip, size - skip);
358 
359  if (keep_buffer) {
360  ffio_reset_dyn_buf(*dyn_cp);
361  } else {
362  ffio_free_dyn_buf(dyn_cp);
363  }
364 }
365 
366 /**
367 * Complete ebml master without destroying the buffer, allowing for later updates
368 */
370  uint32_t id, int64_t *pos)
371 {
372  uint8_t *buf;
373  int size = avio_get_dyn_buf(dyn_cp, &buf);
374 
375  *pos = avio_tell(pb);
376 
377  put_ebml_id(pb, id);
378  put_ebml_num(pb, size, 0);
379  avio_write(pb, buf, size);
380 }
381 
382 static void put_xiph_size(AVIOContext *pb, int size)
383 {
384  ffio_fill(pb, 255, size / 255);
385  avio_w8(pb, size % 255);
386 }
387 
388 /**
389  * Free the members allocated in the mux context.
390  */
392 {
393  MatroskaMuxContext *mkv = s->priv_data;
394 
396 
398  ffio_free_dyn_buf(&mkv->info_bc);
400  ffio_free_dyn_buf(&mkv->tags_bc);
401 
402  av_freep(&mkv->cues.entries);
403  if (mkv->attachments) {
404  av_freep(&mkv->attachments->entries);
405  av_freep(&mkv->attachments);
406  }
407  av_freep(&mkv->tracks);
408 }
409 
410 /**
411  * Initialize the SeekHead element to be ready to index level 1 Matroska
412  * elements. Enough space to write MAX_SEEKHEAD_ENTRIES SeekHead entries
413  * will be reserved at the current file location.
414  */
416 {
417  mkv->seekhead.filepos = avio_tell(pb);
418  // 21 bytes max for a Seek entry, 6 bytes max for the SeekHead ID
419  // and size, 6 bytes for a CRC32 element, and 2 bytes to guarantee
420  // that an EBML void element will fit afterwards
423 }
424 
425 static void mkv_add_seekhead_entry(MatroskaMuxContext *mkv, uint32_t elementid,
426  uint64_t filepos)
427 {
428  mkv_seekhead *seekhead = &mkv->seekhead;
429 
431 
432  seekhead->entries[seekhead->num_entries].elementid = elementid;
433  seekhead->entries[seekhead->num_entries++].segmentpos = filepos - mkv->segment_offset;
434 }
435 
436 /**
437  * Write the SeekHead to the file at the location reserved for it
438  * and seek to destpos afterwards. When error_on_seek_failure
439  * is not set, failure to seek to the position designated for the
440  * SeekHead is not considered an error and it is presumed that
441  * destpos is the current position; failure to seek to destpos
442  * afterwards is always an error.
443  *
444  * @return 0 on success, < 0 on error.
445  */
447  int error_on_seek_failure, int64_t destpos)
448 {
449  AVIOContext *dyn_cp = NULL;
450  mkv_seekhead *seekhead = &mkv->seekhead;
451  int64_t remaining, ret64;
452  int i, ret;
453 
454  if ((ret64 = avio_seek(pb, seekhead->filepos, SEEK_SET)) < 0)
455  return error_on_seek_failure ? ret64 : 0;
456 
457  ret = start_ebml_master_crc32(&dyn_cp, mkv);
458  if (ret < 0)
459  return ret;
460 
461  for (i = 0; i < seekhead->num_entries; i++) {
462  mkv_seekhead_entry *entry = &seekhead->entries[i];
465 
467  put_ebml_num(dyn_cp, ebml_id_size(entry->elementid), 0);
468  put_ebml_id(dyn_cp, entry->elementid);
469 
471  end_ebml_master(dyn_cp, seekentry);
472  }
473  end_ebml_master_crc32(pb, &dyn_cp, mkv, MATROSKA_ID_SEEKHEAD, 0, 0);
474 
475  remaining = seekhead->filepos + seekhead->reserved_size - avio_tell(pb);
476  put_ebml_void(pb, remaining);
477 
478  if ((ret64 = avio_seek(pb, destpos, SEEK_SET)) < 0)
479  return ret64;
480 
481  return 0;
482 }
483 
484 static int mkv_add_cuepoint(MatroskaMuxContext *mkv, int stream, int tracknum, int64_t ts,
485  int64_t cluster_pos, int64_t relative_pos, int64_t duration)
486 {
487  mkv_cues *cues = &mkv->cues;
488  mkv_cuepoint *entries = cues->entries;
489 
490  if (ts < 0)
491  return 0;
492 
493  entries = av_realloc_array(entries, cues->num_entries + 1, sizeof(mkv_cuepoint));
494  if (!entries)
495  return AVERROR(ENOMEM);
496  cues->entries = entries;
497 
498  cues->entries[cues->num_entries].pts = ts;
499  cues->entries[cues->num_entries].stream_idx = stream;
500  cues->entries[cues->num_entries].tracknum = tracknum;
501  cues->entries[cues->num_entries].cluster_pos = cluster_pos - mkv->segment_offset;
502  cues->entries[cues->num_entries].relative_pos = relative_pos;
503  cues->entries[cues->num_entries++].duration = duration;
504 
505  return 0;
506 }
507 
508 static int mkv_assemble_cues(AVStream **streams, AVIOContext *dyn_cp,
509  mkv_cues *cues, mkv_track *tracks, int num_tracks)
510 {
511  AVIOContext *cuepoint;
512  int ret;
513 
514  ret = avio_open_dyn_buf(&cuepoint);
515  if (ret < 0)
516  return ret;
517 
518  for (mkv_cuepoint *entry = cues->entries, *end = entry + cues->num_entries;
519  entry < end;) {
520  uint64_t pts = entry->pts;
521  uint8_t *buf;
522  int size;
523 
524  put_ebml_uint(cuepoint, MATROSKA_ID_CUETIME, pts);
525 
526  // put all the entries from different tracks that have the exact same
527  // timestamp into the same CuePoint
528  for (int j = 0; j < num_tracks; j++)
529  tracks[j].has_cue = 0;
530  do {
531  ebml_master track_positions;
532  int idx = entry->stream_idx;
533 
534  av_assert0(idx >= 0 && idx < num_tracks);
535  if (tracks[idx].has_cue && streams[idx]->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE)
536  continue;
537  tracks[idx].has_cue = 1;
539  put_ebml_uint(cuepoint, MATROSKA_ID_CUETRACK , entry->tracknum );
540  put_ebml_uint(cuepoint, MATROSKA_ID_CUECLUSTERPOSITION , entry->cluster_pos);
541  put_ebml_uint(cuepoint, MATROSKA_ID_CUERELATIVEPOSITION, entry->relative_pos);
542  if (entry->duration != -1)
543  put_ebml_uint(cuepoint, MATROSKA_ID_CUEDURATION , entry->duration);
544  end_ebml_master(cuepoint, track_positions);
545  } while (++entry < end && entry->pts == pts);
546  size = avio_get_dyn_buf(cuepoint, &buf);
547  put_ebml_binary(dyn_cp, MATROSKA_ID_POINTENTRY, buf, size);
548  ffio_reset_dyn_buf(cuepoint);
549  }
550  ffio_free_dyn_buf(&cuepoint);
551 
552  return 0;
553 }
554 
556 {
557  const uint8_t *header_start[3];
558  int header_len[3];
559  int first_header_size;
560  int j;
561 
562  if (par->codec_id == AV_CODEC_ID_VORBIS)
563  first_header_size = 30;
564  else
565  first_header_size = 42;
566 
568  first_header_size, header_start, header_len) < 0) {
569  av_log(s, AV_LOG_ERROR, "Extradata corrupt.\n");
570  return -1;
571  }
572 
573  avio_w8(pb, 2); // number packets - 1
574  for (j = 0; j < 2; j++) {
575  put_xiph_size(pb, header_len[j]);
576  }
577  for (j = 0; j < 3; j++)
578  avio_write(pb, header_start[j], header_len[j]);
579 
580  return 0;
581 }
582 
584 {
585  if (par->extradata && par->extradata_size == 2)
586  avio_write(pb, par->extradata, 2);
587  else
588  avio_wl16(pb, 0x410); // fallback to the most recent version
589  return 0;
590 }
591 
593  AVIOContext *pb, AVCodecParameters *par)
594 {
595  int write_comment = (par->channel_layout &&
596  !(par->channel_layout & ~0x3ffffULL) &&
598  int ret = ff_flac_write_header(pb, par->extradata, par->extradata_size,
599  !write_comment);
600 
601  if (ret < 0)
602  return ret;
603 
604  if (write_comment) {
605  const char *vendor = (s->flags & AVFMT_FLAG_BITEXACT) ?
606  "Lavf" : LIBAVFORMAT_IDENT;
607  AVDictionary *dict = NULL;
608  uint8_t buf[32], *data, *p;
609  int64_t len;
610 
611  snprintf(buf, sizeof(buf), "0x%"PRIx64, par->channel_layout);
612  av_dict_set(&dict, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", buf, 0);
613 
614  len = ff_vorbiscomment_length(dict, vendor, NULL, 0);
615  if (len >= ((1<<24) - 4)) {
616  av_dict_free(&dict);
617  return AVERROR(EINVAL);
618  }
619 
620  data = av_malloc(len + 4);
621  if (!data) {
622  av_dict_free(&dict);
623  return AVERROR(ENOMEM);
624  }
625 
626  data[0] = 0x84;
627  AV_WB24(data + 1, len);
628 
629  p = data + 4;
630  ff_vorbiscomment_write(&p, &dict, vendor, NULL, 0);
631 
632  avio_write(pb, data, len + 4);
633 
634  av_freep(&data);
635  av_dict_free(&dict);
636  }
637 
638  return 0;
639 }
640 
641 static int get_aac_sample_rates(AVFormatContext *s, uint8_t *extradata, int extradata_size,
642  int *sample_rate, int *output_sample_rate)
643 {
644  MPEG4AudioConfig mp4ac;
645  int ret;
646 
647  ret = avpriv_mpeg4audio_get_config2(&mp4ac, extradata, extradata_size, 1, s);
648  /* Don't abort if the failure is because of missing extradata. Assume in that
649  * case a bitstream filter will provide the muxer with the extradata in the
650  * first packet.
651  * Abort however if s->pb is not seekable, as we would not be able to seek back
652  * to write the sample rate elements once the extradata shows up, anyway. */
653  if (ret < 0 && (extradata_size || !(s->pb->seekable & AVIO_SEEKABLE_NORMAL))) {
654  av_log(s, AV_LOG_ERROR,
655  "Error parsing AAC extradata, unable to determine samplerate.\n");
656  return AVERROR(EINVAL);
657  }
658 
659  if (ret < 0) {
660  /* This will only happen when this function is called while writing the
661  * header and no extradata is available. The space for this element has
662  * to be reserved for when this function is called again after the
663  * extradata shows up in the first packet, as there's no way to know if
664  * output_sample_rate will be different than sample_rate or not. */
665  *output_sample_rate = *sample_rate;
666  } else {
667  *sample_rate = mp4ac.sample_rate;
668  *output_sample_rate = mp4ac.ext_sample_rate;
669  }
670  return 0;
671 }
672 
674  AVCodecParameters *par,
675  AVIOContext *dyn_cp)
676 {
677  switch (par->codec_id) {
678  case AV_CODEC_ID_VORBIS:
679  case AV_CODEC_ID_THEORA:
680  return put_xiph_codecpriv(s, dyn_cp, par);
681  case AV_CODEC_ID_FLAC:
682  return put_flac_codecpriv(s, dyn_cp, par);
683  case AV_CODEC_ID_WAVPACK:
684  return put_wv_codecpriv(dyn_cp, par);
685  case AV_CODEC_ID_H264:
686  return ff_isom_write_avcc(dyn_cp, par->extradata,
687  par->extradata_size);
688  case AV_CODEC_ID_HEVC:
689  return ff_isom_write_hvcc(dyn_cp, par->extradata,
690  par->extradata_size, 0);
691  case AV_CODEC_ID_AV1:
692  if (par->extradata_size)
693  return ff_isom_write_av1c(dyn_cp, par->extradata,
694  par->extradata_size);
695  else
696  put_ebml_void(pb, 4 + 3);
697  break;
698  case AV_CODEC_ID_ALAC:
699  if (par->extradata_size < 36) {
700  av_log(s, AV_LOG_ERROR,
701  "Invalid extradata found, ALAC expects a 36-byte "
702  "QuickTime atom.");
703  return AVERROR_INVALIDDATA;
704  } else
705  avio_write(dyn_cp, par->extradata + 12,
706  par->extradata_size - 12);
707  break;
708  case AV_CODEC_ID_AAC:
709  if (par->extradata_size)
710  avio_write(dyn_cp, par->extradata, par->extradata_size);
711  else
712  put_ebml_void(pb, MAX_PCE_SIZE + 2 + 4);
713  break;
714  default:
715  if (par->codec_id == AV_CODEC_ID_PRORES &&
717  avio_wl32(dyn_cp, par->codec_tag);
718  } else if (par->extradata_size && par->codec_id != AV_CODEC_ID_TTA)
719  avio_write(dyn_cp, par->extradata, par->extradata_size);
720  }
721 
722  return 0;
723 }
724 
726  AVCodecParameters *par,
727  int native_id, int qt_id)
728 {
729  AVIOContext *dyn_cp;
730  uint8_t *codecpriv;
731  int ret, codecpriv_size;
732 
733  ret = avio_open_dyn_buf(&dyn_cp);
734  if (ret < 0)
735  return ret;
736 
737  if (native_id) {
738  ret = mkv_write_native_codecprivate(s, pb, par, dyn_cp);
739  } else if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
740  if (qt_id) {
741  if (!par->codec_tag)
743  par->codec_id);
746  ) {
747  int i;
748  avio_wb32(dyn_cp, 0x5a + par->extradata_size);
749  avio_wl32(dyn_cp, par->codec_tag);
750  for(i = 0; i < 0x5a - 8; i++)
751  avio_w8(dyn_cp, 0);
752  }
753  avio_write(dyn_cp, par->extradata, par->extradata_size);
754  } else {
756  av_log(s, AV_LOG_WARNING, "codec %s is not supported by this format\n",
757  avcodec_get_name(par->codec_id));
758 
759  if (!par->codec_tag)
761  par->codec_id);
762  if (!par->codec_tag && par->codec_id != AV_CODEC_ID_RAWVIDEO) {
763  av_log(s, AV_LOG_ERROR, "No bmp codec tag found for codec %s\n",
764  avcodec_get_name(par->codec_id));
765  ret = AVERROR(EINVAL);
766  }
767 
768  ff_put_bmp_header(dyn_cp, par, 0, 0);
769  }
770  } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
771  unsigned int tag;
773  if (!tag) {
774  av_log(s, AV_LOG_ERROR, "No wav codec tag found for codec %s\n",
775  avcodec_get_name(par->codec_id));
776  ret = AVERROR(EINVAL);
777  }
778  if (!par->codec_tag)
779  par->codec_tag = tag;
780 
782  }
783 
784  codecpriv_size = avio_get_dyn_buf(dyn_cp, &codecpriv);
785  if (codecpriv_size)
787  codecpriv_size);
788  ffio_free_dyn_buf(&dyn_cp);
789  return ret;
790 }
791 
793  AVIOContext *dyn_cp;
794  uint8_t *colorinfo_ptr;
795  int side_data_size = 0;
796  int ret, colorinfo_size;
797  const uint8_t *side_data;
798 
799  ret = avio_open_dyn_buf(&dyn_cp);
800  if (ret < 0)
801  return ret;
802 
803  if (par->color_trc != AVCOL_TRC_UNSPECIFIED &&
804  par->color_trc < AVCOL_TRC_NB) {
806  par->color_trc);
807  }
808  if (par->color_space != AVCOL_SPC_UNSPECIFIED &&
809  par->color_space < AVCOL_SPC_NB) {
811  }
813  par->color_primaries < AVCOL_PRI_NB) {
815  }
816  if (par->color_range != AVCOL_RANGE_UNSPECIFIED &&
817  par->color_range < AVCOL_RANGE_NB) {
819  }
822  int xpos, ypos;
823 
824  avcodec_enum_to_chroma_pos(&xpos, &ypos, par->chroma_location);
825  put_ebml_uint(dyn_cp, MATROSKA_ID_VIDEOCOLORCHROMASITINGHORZ, (xpos >> 7) + 1);
826  put_ebml_uint(dyn_cp, MATROSKA_ID_VIDEOCOLORCHROMASITINGVERT, (ypos >> 7) + 1);
827  }
828 
830  &side_data_size);
831  if (side_data_size) {
832  const AVContentLightMetadata *metadata =
833  (const AVContentLightMetadata*)side_data;
836  }
837 
839  &side_data_size);
840  if (side_data_size == sizeof(AVMasteringDisplayMetadata)) {
841  ebml_master meta_element = start_ebml_master(
843  const AVMasteringDisplayMetadata *metadata =
844  (const AVMasteringDisplayMetadata*)side_data;
845  if (metadata->has_primaries) {
847  av_q2d(metadata->display_primaries[0][0]));
849  av_q2d(metadata->display_primaries[0][1]));
851  av_q2d(metadata->display_primaries[1][0]));
853  av_q2d(metadata->display_primaries[1][1]));
855  av_q2d(metadata->display_primaries[2][0]));
857  av_q2d(metadata->display_primaries[2][1]));
859  av_q2d(metadata->white_point[0]));
861  av_q2d(metadata->white_point[1]));
862  }
863  if (metadata->has_luminance) {
865  av_q2d(metadata->max_luminance));
867  av_q2d(metadata->min_luminance));
868  }
869  end_ebml_master(dyn_cp, meta_element);
870  }
871 
872  colorinfo_size = avio_get_dyn_buf(dyn_cp, &colorinfo_ptr);
873  if (colorinfo_size) {
874  ebml_master colorinfo = start_ebml_master(pb, MATROSKA_ID_VIDEOCOLOR, colorinfo_size);
875  avio_write(pb, colorinfo_ptr, colorinfo_size);
876  end_ebml_master(pb, colorinfo);
877  }
878  ffio_free_dyn_buf(&dyn_cp);
879  return 0;
880 }
881 
883  AVStream *st)
884 {
885  ebml_master projection;
886  int side_data_size = 0;
887  uint8_t private[20];
888 
889  const AVSphericalMapping *spherical =
891  &side_data_size);
892 
893  if (!side_data_size)
894  return 0;
895 
896  if (spherical->projection != AV_SPHERICAL_EQUIRECTANGULAR &&
898  spherical->projection != AV_SPHERICAL_CUBEMAP) {
899  av_log(s, AV_LOG_WARNING, "Unknown projection type\n");
900  return 0;
901  }
902 
903  // Maximally 4 8-byte elements with id-length 2 + 1 byte length field
904  // and the private data of the AV_SPHERICAL_EQUIRECTANGULAR_TILE case
906  4 * (2 + 1 + 8) + (2 + 1 + 20));
907 
908  switch (spherical->projection) {
912  break;
916  AV_WB32(private, 0); // version + flags
917  AV_WB32(private + 4, spherical->bound_top);
918  AV_WB32(private + 8, spherical->bound_bottom);
919  AV_WB32(private + 12, spherical->bound_left);
920  AV_WB32(private + 16, spherical->bound_right);
922  private, 20);
923  break;
927  AV_WB32(private, 0); // version + flags
928  AV_WB32(private + 4, 0); // layout
929  AV_WB32(private + 8, spherical->padding);
931  private, 12);
932  break;
933  default:
934  av_assert0(0);
935  }
936 
937  if (spherical->yaw)
939  (double) spherical->yaw / (1 << 16));
940  if (spherical->pitch)
942  (double) spherical->pitch / (1 << 16));
943  if (spherical->roll)
945  (double) spherical->roll / (1 << 16));
946 
947  end_ebml_master(pb, projection);
948 
949  return 0;
950 }
951 
953  enum AVFieldOrder field_order)
954 {
955  switch (field_order) {
956  case AV_FIELD_UNKNOWN:
957  break;
961  break;
962  case AV_FIELD_TT:
963  case AV_FIELD_BB:
964  case AV_FIELD_TB:
965  case AV_FIELD_BT:
968  if (mode != MODE_WEBM) {
969  switch (field_order) {
970  case AV_FIELD_TT:
973  break;
974  case AV_FIELD_BB:
977  break;
978  case AV_FIELD_TB:
981  break;
982  case AV_FIELD_BT:
985  break;
986  }
987  }
988  }
989 }
990 
992  AVStream *st, int mode, int *h_width, int *h_height)
993 {
994  int i;
995  int ret = 0;
998 
999  *h_width = 1;
1000  *h_height = 1;
1001  // convert metadata into proper side data and add it to the stream
1002  if ((tag = av_dict_get(st->metadata, "stereo_mode", NULL, 0)) ||
1003  (tag = av_dict_get( s->metadata, "stereo_mode", NULL, 0))) {
1004  int stereo_mode = atoi(tag->value);
1005 
1006  for (i=0; i<MATROSKA_VIDEO_STEREOMODE_TYPE_NB; i++)
1007  if (!strcmp(tag->value, ff_matroska_video_stereo_mode[i])){
1008  stereo_mode = i;
1009  break;
1010  }
1011 
1012  if (stereo_mode < MATROSKA_VIDEO_STEREOMODE_TYPE_NB &&
1013  stereo_mode != 10 && stereo_mode != 12) {
1014  int ret = ff_mkv_stereo3d_conv(st, stereo_mode);
1015  if (ret < 0)
1016  return ret;
1017  }
1018  }
1019 
1020  // iterate to find the stereo3d side data
1021  for (i = 0; i < st->nb_side_data; i++) {
1022  AVPacketSideData sd = st->side_data[i];
1023  if (sd.type == AV_PKT_DATA_STEREO3D) {
1024  AVStereo3D *stereo = (AVStereo3D *)sd.data;
1025 
1026  switch (stereo->type) {
1027  case AV_STEREO3D_2D:
1029  break;
1031  format = (stereo->flags & AV_STEREO3D_FLAG_INVERT)
1034  *h_width = 2;
1035  break;
1036  case AV_STEREO3D_TOPBOTTOM:
1038  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
1039  format--;
1040  *h_height = 2;
1041  break;
1044  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
1045  format--;
1046  break;
1047  case AV_STEREO3D_LINES:
1049  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
1050  format--;
1051  *h_height = 2;
1052  break;
1053  case AV_STEREO3D_COLUMNS:
1055  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
1056  format--;
1057  *h_width = 2;
1058  break;
1061  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
1062  format++;
1063  break;
1064  }
1065  break;
1066  }
1067  }
1068 
1069  if (format == MATROSKA_VIDEO_STEREOMODE_TYPE_NB)
1070  return ret;
1071 
1072  // if webm, do not write unsupported modes
1073  if ((mode == MODE_WEBM &&
1076  || format >= MATROSKA_VIDEO_STEREOMODE_TYPE_NB) {
1077  av_log(s, AV_LOG_ERROR,
1078  "The specified stereo mode is not valid.\n");
1080  return AVERROR(EINVAL);
1081  }
1082 
1083  // write StereoMode if format is valid
1085 
1086  return ret;
1087 }
1088 
1090  int i, AVIOContext *pb, int default_stream_exists)
1091 {
1092  AVStream *st = s->streams[i];
1093  AVCodecParameters *par = st->codecpar;
1094  ebml_master subinfo, track;
1095  int native_id = 0;
1096  int qt_id = 0;
1097  int bit_depth;
1098  int sample_rate = par->sample_rate;
1099  int output_sample_rate = 0;
1100  int display_width_div = 1;
1101  int display_height_div = 1;
1102  int j, ret;
1104 
1105  if (par->codec_type == AVMEDIA_TYPE_ATTACHMENT) {
1106  mkv->have_attachments = 1;
1107  return 0;
1108  }
1109 
1110  if (par->codec_id == AV_CODEC_ID_AAC) {
1111  ret = get_aac_sample_rates(s, par->extradata, par->extradata_size, &sample_rate,
1112  &output_sample_rate);
1113  if (ret < 0)
1114  return ret;
1115  }
1116 
1117  track = start_ebml_master(pb, MATROSKA_ID_TRACKENTRY, 0);
1119  mkv->is_dash ? mkv->dash_track_number : i + 1);
1121  mkv->is_dash ? mkv->dash_track_number : i + 1);
1122  put_ebml_uint (pb, MATROSKA_ID_TRACKFLAGLACING , 0); // no lacing (yet)
1123 
1124  if ((tag = av_dict_get(st->metadata, "title", NULL, 0)))
1126  tag = av_dict_get(st->metadata, "language", NULL, 0);
1128  tag && tag->value ? tag->value : "und");
1129 
1130  // The default value for TRACKFLAGDEFAULT is 1, so add element
1131  // if we need to clear it.
1132  if (default_stream_exists && !(st->disposition & AV_DISPOSITION_DEFAULT))
1134 
1137 
1138  if (mkv->mode == MODE_WEBM) {
1139  const char *codec_id;
1140  if (par->codec_type != AVMEDIA_TYPE_SUBTITLE) {
1141  for (j = 0; ff_webm_codec_tags[j].id != AV_CODEC_ID_NONE; j++) {
1142  if (ff_webm_codec_tags[j].id == par->codec_id) {
1143  codec_id = ff_webm_codec_tags[j].str;
1144  native_id = 1;
1145  break;
1146  }
1147  }
1148  } else if (par->codec_id == AV_CODEC_ID_WEBVTT) {
1150  codec_id = "D_WEBVTT/CAPTIONS";
1151  native_id = MATROSKA_TRACK_TYPE_SUBTITLE;
1152  } else if (st->disposition & AV_DISPOSITION_DESCRIPTIONS) {
1153  codec_id = "D_WEBVTT/DESCRIPTIONS";
1154  native_id = MATROSKA_TRACK_TYPE_METADATA;
1155  } else if (st->disposition & AV_DISPOSITION_METADATA) {
1156  codec_id = "D_WEBVTT/METADATA";
1157  native_id = MATROSKA_TRACK_TYPE_METADATA;
1158  } else {
1159  codec_id = "D_WEBVTT/SUBTITLES";
1160  native_id = MATROSKA_TRACK_TYPE_SUBTITLE;
1161  }
1162  }
1163 
1164  if (!native_id) {
1165  av_log(s, AV_LOG_ERROR,
1166  "Only VP8 or VP9 or AV1 video and Vorbis or Opus audio and WebVTT subtitles are supported for WebM.\n");
1167  return AVERROR(EINVAL);
1168  }
1169 
1170  put_ebml_string(pb, MATROSKA_ID_CODECID, codec_id);
1171  } else {
1172  // look for a codec ID string specific to mkv to use,
1173  // if none are found, use AVI codes
1174  if (par->codec_id != AV_CODEC_ID_RAWVIDEO || par->codec_tag) {
1175  for (j = 0; ff_mkv_codec_tags[j].id != AV_CODEC_ID_NONE; j++) {
1176  if (ff_mkv_codec_tags[j].id == par->codec_id && par->codec_id != AV_CODEC_ID_FFV1) {
1178  native_id = 1;
1179  break;
1180  }
1181  }
1182  } else {
1183  if (mkv->allow_raw_vfw) {
1184  native_id = 0;
1185  } else {
1186  av_log(s, AV_LOG_ERROR, "Raw RGB is not supported Natively in Matroska, you can use AVI or NUT or\n"
1187  "If you would like to store it anyway using VFW mode, enable allow_raw_vfw (-allow_raw_vfw 1)\n");
1188  return AVERROR(EINVAL);
1189  }
1190  }
1191  }
1192 
1193  switch (par->codec_type) {
1194  case AVMEDIA_TYPE_VIDEO:
1195  mkv->have_video = 1;
1197 
1198  if( st->avg_frame_rate.num > 0 && st->avg_frame_rate.den > 0
1199  && av_cmp_q(av_inv_q(st->avg_frame_rate), st->time_base) > 0)
1201  else if( st->r_frame_rate.num > 0 && st->r_frame_rate.den > 0
1202  && av_cmp_q(av_inv_q(st->r_frame_rate), st->time_base) > 0)
1204 
1205  if (!native_id &&
1208  par->codec_id == AV_CODEC_ID_SVQ1 ||
1209  par->codec_id == AV_CODEC_ID_SVQ3 ||
1210  par->codec_id == AV_CODEC_ID_CINEPAK))
1211  qt_id = 1;
1212 
1213  if (qt_id)
1214  put_ebml_string(pb, MATROSKA_ID_CODECID, "V_QUICKTIME");
1215  else if (!native_id) {
1216  // if there is no mkv-specific codec ID, use VFW mode
1217  put_ebml_string(pb, MATROSKA_ID_CODECID, "V_MS/VFW/FOURCC");
1218  mkv->tracks[i].write_dts = 1;
1220  }
1221 
1222  subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKVIDEO, 0);
1223 
1226 
1227  mkv_write_field_order(pb, mkv->mode, par->field_order);
1228 
1229  // check both side data and metadata for stereo information,
1230  // write the result to the bitstream if any is found
1231  ret = mkv_write_stereo_mode(s, pb, st, mkv->mode,
1232  &display_width_div,
1233  &display_height_div);
1234  if (ret < 0)
1235  return ret;
1236 
1237  if (((tag = av_dict_get(st->metadata, "alpha_mode", NULL, 0)) && atoi(tag->value)) ||
1238  ((tag = av_dict_get( s->metadata, "alpha_mode", NULL, 0)) && atoi(tag->value)) ||
1239  (par->format == AV_PIX_FMT_YUVA420P)) {
1241  }
1242 
1243  // write DisplayWidth and DisplayHeight, they contain the size of
1244  // a single source view and/or the display aspect ratio
1245  if (st->sample_aspect_ratio.num) {
1246  int64_t d_width = av_rescale(par->width, st->sample_aspect_ratio.num, st->sample_aspect_ratio.den);
1247  if (d_width > INT_MAX) {
1248  av_log(s, AV_LOG_ERROR, "Overflow in display width\n");
1249  return AVERROR(EINVAL);
1250  }
1251  if (d_width != par->width || display_width_div != 1 || display_height_div != 1) {
1252  if (mkv->mode == MODE_WEBM || display_width_div != 1 || display_height_div != 1) {
1253  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH , d_width / display_width_div);
1254  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, par->height / display_height_div);
1255  } else {
1256  AVRational display_aspect_ratio;
1257  av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
1258  par->width * (int64_t)st->sample_aspect_ratio.num,
1259  par->height * (int64_t)st->sample_aspect_ratio.den,
1260  1024 * 1024);
1261  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH, display_aspect_ratio.num);
1262  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, display_aspect_ratio.den);
1264  }
1265  }
1266  } else if (display_width_div != 1 || display_height_div != 1) {
1267  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH , par->width / display_width_div);
1268  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, par->height / display_height_div);
1269  } else if (mkv->mode != MODE_WEBM)
1271 
1272  if (par->codec_id == AV_CODEC_ID_RAWVIDEO) {
1273  uint32_t color_space = av_le2ne32(par->codec_tag);
1274  put_ebml_binary(pb, MATROSKA_ID_VIDEOCOLORSPACE, &color_space, sizeof(color_space));
1275  }
1276  ret = mkv_write_video_color(pb, par, st);
1277  if (ret < 0)
1278  return ret;
1279  ret = mkv_write_video_projection(s, pb, st);
1280  if (ret < 0)
1281  return ret;
1282  end_ebml_master(pb, subinfo);
1283  break;
1284 
1285  case AVMEDIA_TYPE_AUDIO:
1286  if (par->initial_padding && par->codec_id == AV_CODEC_ID_OPUS) {
1287  int64_t codecdelay = av_rescale_q(par->initial_padding,
1288  (AVRational){ 1, 48000 },
1289  (AVRational){ 1, 1000000000 });
1290  if (codecdelay < 0) {
1291  av_log(s, AV_LOG_ERROR, "Initial padding is invalid\n");
1292  return AVERROR(EINVAL);
1293  }
1294 // mkv->tracks[i].ts_offset = av_rescale_q(par->initial_padding,
1295 // (AVRational){ 1, par->sample_rate },
1296 // st->time_base);
1297 
1298  put_ebml_uint(pb, MATROSKA_ID_CODECDELAY, codecdelay);
1299  }
1300  if (par->codec_id == AV_CODEC_ID_OPUS)
1302 
1304 
1305  if (!native_id)
1306  // no mkv-specific ID, use ACM mode
1307  put_ebml_string(pb, MATROSKA_ID_CODECID, "A_MS/ACM");
1308 
1309  subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKAUDIO, 0);
1311 
1312  mkv->tracks[i].sample_rate_offset = avio_tell(pb);
1313  put_ebml_float (pb, MATROSKA_ID_AUDIOSAMPLINGFREQ, sample_rate);
1314  if (output_sample_rate)
1315  put_ebml_float(pb, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate);
1316 
1317  bit_depth = av_get_bits_per_sample(par->codec_id);
1318  if (!bit_depth && par->codec_id != AV_CODEC_ID_ADPCM_G726) {
1319  if (par->bits_per_raw_sample)
1320  bit_depth = par->bits_per_raw_sample;
1321  else
1322  bit_depth = av_get_bytes_per_sample(par->format) << 3;
1323  }
1324  if (!bit_depth)
1325  bit_depth = par->bits_per_coded_sample;
1326  if (bit_depth)
1327  put_ebml_uint(pb, MATROSKA_ID_AUDIOBITDEPTH, bit_depth);
1328  end_ebml_master(pb, subinfo);
1329  break;
1330 
1331  case AVMEDIA_TYPE_SUBTITLE:
1332  if (!native_id) {
1333  av_log(s, AV_LOG_ERROR, "Subtitle codec %d is not supported.\n", par->codec_id);
1334  return AVERROR(ENOSYS);
1335  }
1336 
1337  if (mkv->mode != MODE_WEBM || par->codec_id != AV_CODEC_ID_WEBVTT)
1338  native_id = MATROSKA_TRACK_TYPE_SUBTITLE;
1339 
1340  put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, native_id);
1341  break;
1342  default:
1343  av_log(s, AV_LOG_ERROR, "Only audio, video, and subtitles are supported for Matroska.\n");
1344  return AVERROR(EINVAL);
1345  }
1346 
1347  if (mkv->mode != MODE_WEBM || par->codec_id != AV_CODEC_ID_WEBVTT) {
1348  mkv->tracks[i].codecpriv_offset = avio_tell(pb);
1349  ret = mkv_write_codecprivate(s, pb, par, native_id, qt_id);
1350  if (ret < 0)
1351  return ret;
1352  }
1353 
1354  end_ebml_master(pb, track);
1355 
1356  return 0;
1357 }
1358 
1360 {
1361  MatroskaMuxContext *mkv = s->priv_data;
1362  AVIOContext *pb = s->pb;
1363  int i, ret, default_stream_exists = 0;
1364 
1366 
1367  ret = start_ebml_master_crc32(&mkv->tracks_bc, mkv);
1368  if (ret < 0)
1369  return ret;
1370 
1371  for (i = 0; i < s->nb_streams; i++) {
1372  AVStream *st = s->streams[i];
1373  default_stream_exists |= st->disposition & AV_DISPOSITION_DEFAULT;
1374  }
1375  for (i = 0; i < s->nb_streams; i++) {
1376  ret = mkv_write_track(s, mkv, i, mkv->tracks_bc, default_stream_exists);
1377  if (ret < 0)
1378  return ret;
1379  }
1380 
1381  if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live)
1384  else
1385  end_ebml_master_crc32(pb, &mkv->tracks_bc, mkv, MATROSKA_ID_TRACKS, 0, 0);
1386 
1387  return 0;
1388 }
1389 
1391 {
1392  MatroskaMuxContext *mkv = s->priv_data;
1393  AVIOContext *dyn_cp = NULL, *pb = s->pb;
1394  ebml_master editionentry;
1395  AVRational scale = {1, 1E9};
1396  int i, ret;
1397 
1398  if (!s->nb_chapters || mkv->wrote_chapters)
1399  return 0;
1400 
1402 
1403  ret = start_ebml_master_crc32(&dyn_cp, mkv);
1404  if (ret < 0) return ret;
1405 
1406  editionentry = start_ebml_master(dyn_cp, MATROSKA_ID_EDITIONENTRY, 0);
1407  if (mkv->mode != MODE_WEBM) {
1410  }
1411  for (i = 0; i < s->nb_chapters; i++) {
1412  ebml_master chapteratom, chapterdisplay;
1413  AVChapter *c = s->chapters[i];
1414  int64_t chapterstart = av_rescale_q(c->start, c->time_base, scale);
1415  int64_t chapterend = av_rescale_q(c->end, c->time_base, scale);
1416  AVDictionaryEntry *t = NULL;
1417  if (chapterstart < 0 || chapterstart > chapterend || chapterend < 0) {
1418  av_log(s, AV_LOG_ERROR,
1419  "Invalid chapter start (%"PRId64") or end (%"PRId64").\n",
1420  chapterstart, chapterend);
1421  return AVERROR_INVALIDDATA;
1422  }
1423 
1424  chapteratom = start_ebml_master(dyn_cp, MATROSKA_ID_CHAPTERATOM, 0);
1426  put_ebml_uint(dyn_cp, MATROSKA_ID_CHAPTERTIMESTART, chapterstart);
1427  put_ebml_uint(dyn_cp, MATROSKA_ID_CHAPTERTIMEEND, chapterend);
1428  if (mkv->mode != MODE_WEBM) {
1431  }
1432  if ((t = av_dict_get(c->metadata, "title", NULL, 0))) {
1433  chapterdisplay = start_ebml_master(dyn_cp, MATROSKA_ID_CHAPTERDISPLAY, 0);
1435  put_ebml_string(dyn_cp, MATROSKA_ID_CHAPLANG , "und");
1436  end_ebml_master(dyn_cp, chapterdisplay);
1437  }
1438  end_ebml_master(dyn_cp, chapteratom);
1439  }
1440  end_ebml_master(dyn_cp, editionentry);
1441  end_ebml_master_crc32(pb, &dyn_cp, mkv, MATROSKA_ID_CHAPTERS, 0, 0);
1442 
1443  mkv->wrote_chapters = 1;
1444  return 0;
1445 }
1446 
1448 {
1449  uint8_t *key = av_strdup(t->key);
1450  uint8_t *p = key;
1451  const uint8_t *lang = NULL;
1452  ebml_master tag;
1453 
1454  if (!key)
1455  return AVERROR(ENOMEM);
1456 
1457  if ((p = strrchr(p, '-')) &&
1458  (lang = ff_convert_lang_to(p + 1, AV_LANG_ISO639_2_BIBL)))
1459  *p = 0;
1460 
1461  p = key;
1462  while (*p) {
1463  if (*p == ' ')
1464  *p = '_';
1465  else if (*p >= 'a' && *p <= 'z')
1466  *p -= 'a' - 'A';
1467  p++;
1468  }
1469 
1472  if (lang)
1475  end_ebml_master(pb, tag);
1476 
1477  av_freep(&key);
1478  return 0;
1479 }
1480 
1481 static int mkv_write_tag_targets(AVFormatContext *s, uint32_t elementid,
1482  unsigned int uid, ebml_master *tag)
1483 {
1484  AVIOContext *pb;
1485  MatroskaMuxContext *mkv = s->priv_data;
1487  int ret;
1488 
1489  if (!mkv->tags_bc) {
1491 
1492  ret = start_ebml_master_crc32(&mkv->tags_bc, mkv);
1493  if (ret < 0)
1494  return ret;
1495  }
1496  pb = mkv->tags_bc;
1497 
1498  *tag = start_ebml_master(pb, MATROSKA_ID_TAG, 0);
1499  targets = start_ebml_master(pb, MATROSKA_ID_TAGTARGETS, 0);
1500  if (elementid)
1501  put_ebml_uint(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 
1520 static int mkv_write_tag(AVFormatContext *s, AVDictionary *m, uint32_t elementid,
1521  unsigned int uid)
1522 {
1523  MatroskaMuxContext *mkv = s->priv_data;
1524  ebml_master tag;
1525  int ret;
1526  AVDictionaryEntry *t = NULL;
1527 
1528  ret = mkv_write_tag_targets(s, elementid, uid, &tag);
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(mkv->tags_bc, t);
1535  if (ret < 0)
1536  return ret;
1537  }
1538  }
1539 
1540  end_ebml_master(mkv->tags_bc, tag);
1541  return 0;
1542 }
1543 
1544 static int mkv_check_tag(AVDictionary *m, uint32_t elementid)
1545 {
1546  AVDictionaryEntry *t = NULL;
1547 
1548  while ((t = av_dict_get(m, "", t, AV_DICT_IGNORE_SUFFIX)))
1549  if (mkv_check_tag_name(t->key, elementid))
1550  return 1;
1551 
1552  return 0;
1553 }
1554 
1556 {
1557  MatroskaMuxContext *mkv = s->priv_data;
1558  int i, ret;
1559 
1561 
1562  if (mkv_check_tag(s->metadata, 0)) {
1563  ret = mkv_write_tag(s, s->metadata, 0, 0);
1564  if (ret < 0) return ret;
1565  }
1566 
1567  for (i = 0; i < s->nb_streams; i++) {
1568  AVStream *st = s->streams[i];
1569 
1571  continue;
1572 
1574  continue;
1575 
1577  if (ret < 0) return ret;
1578  }
1579 
1580  if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live) {
1581  for (i = 0; i < s->nb_streams; i++) {
1582  AVIOContext *pb;
1583  AVStream *st = s->streams[i];
1584  ebml_master tag_target;
1585  ebml_master tag;
1586 
1588  continue;
1589 
1591  i + 1, &tag_target);
1592  if (ret < 0)
1593  return ret;
1594  pb = mkv->tags_bc;
1595 
1597  put_ebml_string(pb, MATROSKA_ID_TAGNAME, "DURATION");
1598  mkv->tracks[i].duration_offset = avio_tell(pb);
1599 
1600  // Reserve space to write duration as a 20-byte string.
1601  // 2 (ebml id) + 1 (data size) + 20 (data)
1602  put_ebml_void(pb, 23);
1603  end_ebml_master(pb, tag);
1604  end_ebml_master(pb, tag_target);
1605  }
1606  }
1607 
1608  if (mkv->mode != MODE_WEBM) {
1609  for (i = 0; i < s->nb_chapters; i++) {
1610  AVChapter *ch = s->chapters[i];
1611 
1613  continue;
1614 
1616  if (ret < 0)
1617  return ret;
1618  }
1619  }
1620 
1621  if (mkv->have_attachments && mkv->mode != MODE_WEBM) {
1622  for (i = 0; i < mkv->attachments->num_entries; i++) {
1623  mkv_attachment *attachment = &mkv->attachments->entries[i];
1624  AVStream *st = s->streams[attachment->stream_idx];
1625 
1627  continue;
1628 
1629  ret = mkv_write_tag(s, st->metadata, MATROSKA_ID_TAGTARGETS_ATTACHUID, attachment->fileuid);
1630  if (ret < 0)
1631  return ret;
1632  }
1633  }
1634 
1635  if (mkv->tags_bc) {
1636  if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live)
1638  MATROSKA_ID_TAGS, &mkv->tags_pos);
1639  else
1640  end_ebml_master_crc32(s->pb, &mkv->tags_bc, mkv, MATROSKA_ID_TAGS, 0, 0);
1641  }
1642  return 0;
1643 }
1644 
1646 {
1647  MatroskaMuxContext *mkv = s->priv_data;
1648  AVIOContext *dyn_cp = NULL, *pb = s->pb;
1649  AVLFG c;
1650  int i, ret;
1651 
1652  if (!mkv->have_attachments)
1653  return 0;
1654 
1655  mkv->attachments = av_mallocz(sizeof(*mkv->attachments));
1656  if (!mkv->attachments)
1657  return AVERROR(ENOMEM);
1658 
1660 
1662 
1663  ret = start_ebml_master_crc32(&dyn_cp, mkv);
1664  if (ret < 0) return ret;
1665 
1666  for (i = 0; i < s->nb_streams; i++) {
1667  AVStream *st = s->streams[i];
1668  ebml_master attached_file;
1669  mkv_attachment *attachment = mkv->attachments->entries;
1670  AVDictionaryEntry *t;
1671  const char *mimetype = NULL;
1672  uint32_t fileuid;
1673 
1675  continue;
1676 
1677  attachment = av_realloc_array(attachment, mkv->attachments->num_entries + 1, sizeof(mkv_attachment));
1678  if (!attachment)
1679  return AVERROR(ENOMEM);
1680  mkv->attachments->entries = attachment;
1681 
1682  attached_file = start_ebml_master(dyn_cp, MATROSKA_ID_ATTACHEDFILE, 0);
1683 
1684  if (t = av_dict_get(st->metadata, "title", NULL, 0))
1686  if (!(t = av_dict_get(st->metadata, "filename", NULL, 0))) {
1687  av_log(s, AV_LOG_ERROR, "Attachment stream %d has no filename tag.\n", i);
1688  return AVERROR(EINVAL);
1689  }
1691  if (t = av_dict_get(st->metadata, "mimetype", NULL, 0))
1692  mimetype = t->value;
1693  else if (st->codecpar->codec_id != AV_CODEC_ID_NONE ) {
1694  int i;
1695  for (i = 0; ff_mkv_mime_tags[i].id != AV_CODEC_ID_NONE; i++)
1696  if (ff_mkv_mime_tags[i].id == st->codecpar->codec_id) {
1697  mimetype = ff_mkv_mime_tags[i].str;
1698  break;
1699  }
1700  for (i = 0; ff_mkv_image_mime_tags[i].id != AV_CODEC_ID_NONE; i++)
1701  if (ff_mkv_image_mime_tags[i].id == st->codecpar->codec_id) {
1702  mimetype = ff_mkv_image_mime_tags[i].str;
1703  break;
1704  }
1705  }
1706  if (!mimetype) {
1707  av_log(s, AV_LOG_ERROR, "Attachment stream %d has no mimetype tag and "
1708  "it cannot be deduced from the codec id.\n", i);
1709  return AVERROR(EINVAL);
1710  }
1711 
1712  if (s->flags & AVFMT_FLAG_BITEXACT) {
1713  struct AVSHA *sha = av_sha_alloc();
1714  uint8_t digest[20];
1715  if (!sha)
1716  return AVERROR(ENOMEM);
1717  av_sha_init(sha, 160);
1719  av_sha_final(sha, digest);
1720  av_free(sha);
1721  fileuid = AV_RL32(digest);
1722  } else {
1723  fileuid = av_lfg_get(&c);
1724  }
1725  av_log(s, AV_LOG_VERBOSE, "Using %.8"PRIx32" for attachment %d\n",
1726  fileuid, mkv->attachments->num_entries);
1727 
1728  put_ebml_string(dyn_cp, MATROSKA_ID_FILEMIMETYPE, mimetype);
1730  put_ebml_uint(dyn_cp, MATROSKA_ID_FILEUID, fileuid);
1731  end_ebml_master(dyn_cp, attached_file);
1732 
1734  mkv->attachments->entries[mkv->attachments->num_entries++].fileuid = fileuid;
1735  }
1736  end_ebml_master_crc32(pb, &dyn_cp, mkv, MATROSKA_ID_ATTACHMENTS, 0, 0);
1737 
1738  return 0;
1739 }
1740 
1742 {
1743  int i = 0;
1744  int64_t max = 0;
1745  int64_t us;
1746 
1747  AVDictionaryEntry *explicitDuration = av_dict_get(s->metadata, "DURATION", NULL, 0);
1748  if (explicitDuration && (av_parse_time(&us, explicitDuration->value, 1) == 0) && us > 0) {
1749  av_log(s, AV_LOG_DEBUG, "get_metadata_duration found duration in context metadata: %" PRId64 "\n", us);
1750  return us;
1751  }
1752 
1753  for (i = 0; i < s->nb_streams; i++) {
1754  int64_t us;
1755  AVDictionaryEntry *duration = av_dict_get(s->streams[i]->metadata, "DURATION", NULL, 0);
1756 
1757  if (duration && (av_parse_time(&us, duration->value, 1) == 0))
1758  max = FFMAX(max, us);
1759  }
1760 
1761  av_log(s, AV_LOG_DEBUG, "get_metadata_duration returned: %" PRId64 "\n", max);
1762  return max;
1763 }
1764 
1766 {
1767  MatroskaMuxContext *mkv = s->priv_data;
1768  AVIOContext *pb = s->pb;
1771  int ret, i, version = 2;
1772  int64_t creation_time;
1773 
1774  if (!strcmp(s->oformat->name, "webm")) {
1775  mkv->mode = MODE_WEBM;
1776  mkv->write_crc = 0;
1777  } else
1778  mkv->mode = MODE_MATROSKAv2;
1779 
1780  if (mkv->mode != MODE_WEBM ||
1781  av_dict_get(s->metadata, "stereo_mode", NULL, 0) ||
1782  av_dict_get(s->metadata, "alpha_mode", NULL, 0))
1783  version = 4;
1784 
1785  for (i = 0; i < s->nb_streams; i++) {
1786  if (s->streams[i]->codecpar->codec_id == AV_CODEC_ID_OPUS ||
1787  av_dict_get(s->streams[i]->metadata, "stereo_mode", NULL, 0) ||
1788  av_dict_get(s->streams[i]->metadata, "alpha_mode", NULL, 0))
1789  version = 4;
1790  }
1791 
1792  mkv->tracks = av_mallocz_array(s->nb_streams, sizeof(*mkv->tracks));
1793  if (!mkv->tracks) {
1794  return AVERROR(ENOMEM);
1795  }
1802  put_ebml_uint (pb, EBML_ID_DOCTYPEVERSION , version);
1804  end_ebml_master(pb, ebml_header);
1805 
1807  mkv->segment_offset = avio_tell(pb);
1808 
1809  // we write a seek head at the beginning to point to all other level
1810  // one elements (except Clusters).
1811  mkv_start_seekhead(mkv, pb);
1812 
1814 
1815  ret = start_ebml_master_crc32(&mkv->info_bc, mkv);
1816  if (ret < 0)
1817  return ret;
1818  pb = mkv->info_bc;
1819 
1821  if ((tag = av_dict_get(s->metadata, "title", NULL, 0)))
1823  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
1825  if ((tag = av_dict_get(s->metadata, "encoding_tool", NULL, 0)))
1827  else
1829 
1830  if (mkv->mode != MODE_WEBM) {
1831  uint32_t segment_uid[4];
1832  AVLFG lfg;
1833 
1835 
1836  for (i = 0; i < 4; i++)
1837  segment_uid[i] = av_lfg_get(&lfg);
1838 
1839  put_ebml_binary(pb, MATROSKA_ID_SEGMENTUID, segment_uid, 16);
1840  }
1841  } else {
1842  const char *ident = "Lavf";
1845  }
1846 
1847  if (ff_parse_creation_time_metadata(s, &creation_time, 0) > 0) {
1848  // Adjust time so it's relative to 2001-01-01 and convert to nanoseconds.
1849  int64_t date_utc = (creation_time - 978307200000000LL) * 1000;
1850  uint8_t date_utc_buf[8];
1851  AV_WB64(date_utc_buf, date_utc);
1852  put_ebml_binary(pb, MATROSKA_ID_DATEUTC, date_utc_buf, 8);
1853  }
1854 
1855  // reserve space for the duration
1856  mkv->duration = 0;
1857  mkv->duration_offset = avio_tell(pb);
1858  if (!mkv->is_live) {
1859  int64_t metadata_duration = get_metadata_duration(s);
1860 
1861  if (s->duration > 0) {
1862  int64_t scaledDuration = av_rescale(s->duration, 1000, AV_TIME_BASE);
1863  put_ebml_float(pb, MATROSKA_ID_DURATION, scaledDuration);
1864  av_log(s, AV_LOG_DEBUG, "Write early duration from recording time = %" PRIu64 "\n", scaledDuration);
1865  } else if (metadata_duration > 0) {
1866  int64_t scaledDuration = av_rescale(metadata_duration, 1000, AV_TIME_BASE);
1867  put_ebml_float(pb, MATROSKA_ID_DURATION, scaledDuration);
1868  av_log(s, AV_LOG_DEBUG, "Write early duration from metadata = %" PRIu64 "\n", scaledDuration);
1869  } else {
1870  put_ebml_void(pb, 11); // assumes double-precision float to be written
1871  }
1872  }
1873  if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live)
1875  MATROSKA_ID_INFO, &mkv->info_pos);
1876  else
1877  end_ebml_master_crc32(s->pb, &mkv->info_bc, mkv, MATROSKA_ID_INFO, 0, 0);
1878  pb = s->pb;
1879 
1880  ret = mkv_write_tracks(s);
1881  if (ret < 0)
1882  return ret;
1883 
1884  for (i = 0; i < s->nb_chapters; i++)
1885  mkv->chapter_id_offset = FFMAX(mkv->chapter_id_offset, 1LL - s->chapters[i]->id);
1886 
1887  ret = mkv_write_chapters(s);
1888  if (ret < 0)
1889  return ret;
1890 
1891  if (mkv->mode != MODE_WEBM) {
1892  ret = mkv_write_attachments(s);
1893  if (ret < 0)
1894  return ret;
1895  }
1896 
1897  ret = mkv_write_tags(s);
1898  if (ret < 0)
1899  return ret;
1900 
1901  if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live) {
1902  ret = mkv_write_seekhead(pb, mkv, 0, avio_tell(pb));
1903  if (ret < 0)
1904  return ret;
1905  }
1906 
1907  if (s->metadata_header_padding > 0) {
1908  if (s->metadata_header_padding == 1)
1911  }
1912 
1913  if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && mkv->reserve_cues_space) {
1914  mkv->cues_pos = avio_tell(pb);
1915  if (mkv->reserve_cues_space == 1)
1916  mkv->reserve_cues_space++;
1918  }
1919 
1921  mkv->cur_audio_pkt.size = 0;
1922  mkv->cluster_pos = -1;
1923 
1924  // start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or
1925  // after 4k and on a keyframe
1926  if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
1927  if (mkv->cluster_time_limit < 0)
1928  mkv->cluster_time_limit = 5000;
1929  if (mkv->cluster_size_limit < 0)
1930  mkv->cluster_size_limit = 5 * 1024 * 1024;
1931  } else {
1932  if (mkv->cluster_time_limit < 0)
1933  mkv->cluster_time_limit = 1000;
1934  if (mkv->cluster_size_limit < 0)
1935  mkv->cluster_size_limit = 32 * 1024;
1936  }
1937 
1938  return 0;
1939 }
1940 
1941 static int mkv_blockgroup_size(int pkt_size)
1942 {
1943  int size = pkt_size + 4;
1944  size += ebml_num_size(size);
1945  size += 2; // EBML ID for block and block duration
1946  size += 9; // max size of block duration incl. length field
1947  return size;
1948 }
1949 
1950 static int mkv_strip_wavpack(const uint8_t *src, uint8_t **pdst, int *size)
1951 {
1952  uint8_t *dst;
1953  int srclen = *size;
1954  int offset = 0;
1955  int ret;
1956 
1957  dst = av_malloc(srclen);
1958  if (!dst)
1959  return AVERROR(ENOMEM);
1960 
1961  while (srclen >= WV_HEADER_SIZE) {
1962  WvHeader header;
1963 
1964  ret = ff_wv_parse_header(&header, src);
1965  if (ret < 0)
1966  goto fail;
1967  src += WV_HEADER_SIZE;
1968  srclen -= WV_HEADER_SIZE;
1969 
1970  if (srclen < header.blocksize) {
1971  ret = AVERROR_INVALIDDATA;
1972  goto fail;
1973  }
1974 
1975  if (header.initial) {
1976  AV_WL32(dst + offset, header.samples);
1977  offset += 4;
1978  }
1979  AV_WL32(dst + offset, header.flags);
1980  AV_WL32(dst + offset + 4, header.crc);
1981  offset += 8;
1982 
1983  if (!(header.initial && header.final)) {
1984  AV_WL32(dst + offset, header.blocksize);
1985  offset += 4;
1986  }
1987 
1988  memcpy(dst + offset, src, header.blocksize);
1989  src += header.blocksize;
1990  srclen -= header.blocksize;
1991  offset += header.blocksize;
1992  }
1993 
1994  *pdst = dst;
1995  *size = offset;
1996 
1997  return 0;
1998 fail:
1999  av_freep(&dst);
2000  return ret;
2001 }
2002 
2004  uint32_t blockid, AVPacket *pkt, int keyframe)
2005 {
2006  MatroskaMuxContext *mkv = s->priv_data;
2008  mkv_track *track = &mkv->tracks[pkt->stream_index];
2009  uint8_t *data = NULL, *side_data = NULL;
2010  int err = 0, offset = 0, size = pkt->size, side_data_size = 0;
2011  int64_t ts = track->write_dts ? pkt->dts : pkt->pts;
2012  uint64_t additional_id;
2013  int64_t discard_padding = 0;
2014  uint8_t track_number = (mkv->is_dash ? mkv->dash_track_number : (pkt->stream_index + 1));
2015  ebml_master block_group, block_additions, block_more;
2016 
2017  ts += track->ts_offset;
2018 
2019  /* The following string is identical to the one in mkv_write_vtt_blocks
2020  * so that only one copy needs to exist in binaries. */
2021  av_log(s, AV_LOG_DEBUG,
2022  "Writing block of size %d with pts %" PRId64 ", dts %" PRId64 ", "
2023  "duration %" PRId64 " at relative offset %" PRId64 " in cluster "
2024  "at offset %" PRId64 ". TrackNumber %d, keyframe %d\n",
2025  pkt->size, pkt->pts, pkt->dts, pkt->duration, avio_tell(pb),
2026  mkv->cluster_pos, track_number, keyframe != 0);
2027 
2028  if (par->codec_id == AV_CODEC_ID_H264 && par->extradata_size > 0 &&
2029  (AV_RB24(par->extradata) == 1 || AV_RB32(par->extradata) == 1)) {
2030  err = ff_avc_parse_nal_units_buf(pkt->data, &data, &size);
2031  } else if (par->codec_id == AV_CODEC_ID_HEVC && par->extradata_size > 6 &&
2032  (AV_RB24(par->extradata) == 1 || AV_RB32(par->extradata) == 1)) {
2033  /* extradata is Annex B, assume the bitstream is too and convert it */
2034  err = ff_hevc_annexb2mp4_buf(pkt->data, &data, &size, 0, NULL);
2035  } else if (par->codec_id == AV_CODEC_ID_AV1) {
2036  err = ff_av1_filter_obus_buf(pkt->data, &data, &size, &offset);
2037  } else if (par->codec_id == AV_CODEC_ID_WAVPACK) {
2038  err = mkv_strip_wavpack(pkt->data, &data, &size);
2039  } else
2040  data = pkt->data;
2041 
2042  if (err < 0) {
2043  av_log(s, AV_LOG_ERROR, "Error when reformatting data of "
2044  "a packet from stream %d.\n", pkt->stream_index);
2045  return err;
2046  }
2047 
2048  if (par->codec_id == AV_CODEC_ID_PRORES && size >= 8) {
2049  /* Matroska specification requires to remove the first QuickTime atom
2050  */
2051  size -= 8;
2052  offset = 8;
2053  }
2054 
2055  side_data = av_packet_get_side_data(pkt,
2057  &side_data_size);
2058  if (side_data && side_data_size >= 10) {
2059  discard_padding = av_rescale_q(AV_RL32(side_data + 4),
2060  (AVRational){1, par->sample_rate},
2061  (AVRational){1, 1000000000});
2062  }
2063 
2064  side_data = av_packet_get_side_data(pkt,
2066  &side_data_size);
2067  if (side_data) {
2068  // Only the Codec-specific BlockMore (id == 1) is currently supported.
2069  if (side_data_size < 8 || (additional_id = AV_RB64(side_data)) != 1) {
2070  side_data_size = 0;
2071  } else {
2072  side_data += 8;
2073  side_data_size -= 8;
2074  }
2075  }
2076 
2077  if (side_data_size || discard_padding) {
2078  block_group = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, 0);
2079  blockid = MATROSKA_ID_BLOCK;
2080  }
2081 
2082  put_ebml_id(pb, blockid);
2083  put_ebml_num(pb, size + 4, 0);
2084  // this assumes stream_index is less than 126
2085  avio_w8(pb, 0x80 | track_number);
2086  avio_wb16(pb, ts - mkv->cluster_pts);
2087  avio_w8(pb, (blockid == MATROSKA_ID_SIMPLEBLOCK && keyframe) ? (1 << 7) : 0);
2088  avio_write(pb, data + offset, size);
2089  if (data != pkt->data)
2090  av_free(data);
2091 
2092  if (blockid == MATROSKA_ID_BLOCK && !keyframe) {
2094  }
2095  track->last_timestamp = ts;
2096 
2097  if (discard_padding) {
2098  put_ebml_sint(pb, MATROSKA_ID_DISCARDPADDING, discard_padding);
2099  }
2100 
2101  if (side_data_size) {
2102  block_additions = start_ebml_master(pb, MATROSKA_ID_BLOCKADDITIONS, 0);
2103  block_more = start_ebml_master(pb, MATROSKA_ID_BLOCKMORE, 0);
2104  /* Until dbc50f8a our demuxer used a wrong default value
2105  * of BlockAddID, so we write it unconditionally. */
2106  put_ebml_uint (pb, MATROSKA_ID_BLOCKADDID, additional_id);
2108  side_data, side_data_size);
2109  end_ebml_master(pb, block_more);
2110  end_ebml_master(pb, block_additions);
2111  }
2112  if (side_data_size || discard_padding) {
2113  end_ebml_master(pb, block_group);
2114  }
2115 
2116  return 0;
2117 }
2118 
2120 {
2121  MatroskaMuxContext *mkv = s->priv_data;
2122  ebml_master blockgroup;
2123  int id_size, settings_size, size;
2124  uint8_t *id, *settings;
2125  int64_t ts = mkv->tracks[pkt->stream_index].write_dts ? pkt->dts : pkt->pts;
2126  const int flags = 0;
2127 
2128  id_size = 0;
2130  &id_size);
2131 
2132  settings_size = 0;
2134  &settings_size);
2135 
2136  size = id_size + 1 + settings_size + 1 + pkt->size;
2137 
2138  /* The following string is identical to the one in mkv_write_block so that
2139  * only one copy needs to exist in binaries. */
2140  av_log(s, AV_LOG_DEBUG,
2141  "Writing block of size %d with pts %" PRId64 ", dts %" PRId64 ", "
2142  "duration %" PRId64 " at relative offset %" PRId64 " in cluster "
2143  "at offset %" PRId64 ". TrackNumber %d, keyframe %d\n",
2144  size, pkt->pts, pkt->dts, pkt->duration, avio_tell(pb),
2145  mkv->cluster_pos, pkt->stream_index + 1, 1);
2146 
2148 
2150  put_ebml_num(pb, size + 4, 0);
2151  avio_w8(pb, 0x80 | (pkt->stream_index + 1)); // this assumes stream_index is less than 126
2152  avio_wb16(pb, ts - mkv->cluster_pts);
2153  avio_w8(pb, flags);
2154  avio_printf(pb, "%.*s\n%.*s\n%.*s", id_size, id, settings_size, settings, pkt->size, pkt->data);
2155 
2157  end_ebml_master(pb, blockgroup);
2158 
2159  return pkt->duration;
2160 }
2161 
2163 {
2164  MatroskaMuxContext *mkv = s->priv_data;
2165 
2166  end_ebml_master_crc32(s->pb, &mkv->cluster_bc, mkv, MATROSKA_ID_CLUSTER, 0, 1);
2167  mkv->cluster_pos = -1;
2169 }
2170 
2172 {
2173  MatroskaMuxContext *mkv = s->priv_data;
2174  mkv_track *track = &mkv->tracks[pkt->stream_index];
2176  uint8_t *side_data;
2177  int side_data_size = 0, ret;
2178 
2180  &side_data_size);
2181 
2182  switch (par->codec_id) {
2183  case AV_CODEC_ID_AAC:
2184  if (side_data_size && (s->pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live) {
2185  int filler, output_sample_rate = 0;
2186  ret = get_aac_sample_rates(s, side_data, side_data_size, &track->sample_rate,
2187  &output_sample_rate);
2188  if (ret < 0)
2189  return ret;
2190  if (!output_sample_rate)
2191  output_sample_rate = track->sample_rate; // Space is already reserved, so it's this or a void element.
2192  ret = ff_alloc_extradata(par, side_data_size);
2193  if (ret < 0)
2194  return ret;
2195  memcpy(par->extradata, side_data, side_data_size);
2196  avio_seek(mkv->tracks_bc, track->codecpriv_offset, SEEK_SET);
2197  mkv_write_codecprivate(s, mkv->tracks_bc, par, 1, 0);
2198  filler = MAX_PCE_SIZE + 2 + 4 - (avio_tell(mkv->tracks_bc) - track->codecpriv_offset);
2199  if (filler)
2200  put_ebml_void(mkv->tracks_bc, filler);
2201  avio_seek(mkv->tracks_bc, track->sample_rate_offset, SEEK_SET);
2203  put_ebml_float(mkv->tracks_bc, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate);
2204  } else if (!par->extradata_size && !track->sample_rate) {
2205  // No extradata (codecpar or packet side data).
2206  av_log(s, AV_LOG_ERROR, "Error parsing AAC extradata, unable to determine samplerate.\n");
2207  return AVERROR(EINVAL);
2208  }
2209  break;
2210  case AV_CODEC_ID_FLAC:
2211  if (side_data_size && (s->pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live) {
2212  AVCodecParameters *codecpriv_par;
2213  if (side_data_size != par->extradata_size) {
2214  av_log(s, AV_LOG_ERROR, "Invalid FLAC STREAMINFO metadata for output stream %d\n",
2215  pkt->stream_index);
2216  return AVERROR(EINVAL);
2217  }
2218  codecpriv_par = avcodec_parameters_alloc();
2219  if (!codecpriv_par)
2220  return AVERROR(ENOMEM);
2221  ret = avcodec_parameters_copy(codecpriv_par, par);
2222  if (ret < 0) {
2223  avcodec_parameters_free(&codecpriv_par);
2224  return ret;
2225  }
2226  memcpy(codecpriv_par->extradata, side_data, side_data_size);
2227  avio_seek(mkv->tracks_bc, track->codecpriv_offset, SEEK_SET);
2228  mkv_write_codecprivate(s, mkv->tracks_bc, codecpriv_par, 1, 0);
2229  avcodec_parameters_free(&codecpriv_par);
2230  }
2231  break;
2232  // FIXME: Remove the following once libaom starts propagating extradata during init()
2233  // See https://bugs.chromium.org/p/aomedia/issues/detail?id=2012
2234  case AV_CODEC_ID_AV1:
2235  if (side_data_size && (s->pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live &&
2236  !par->extradata_size) {
2237  AVIOContext *dyn_cp;
2238  uint8_t *codecpriv;
2239  int codecpriv_size;
2240  ret = avio_open_dyn_buf(&dyn_cp);
2241  if (ret < 0)
2242  return ret;
2243  ff_isom_write_av1c(dyn_cp, side_data, side_data_size);
2244  codecpriv_size = avio_close_dyn_buf(dyn_cp, &codecpriv);
2245  if (!codecpriv_size) {
2246  av_free(codecpriv);
2247  return AVERROR_INVALIDDATA;
2248  }
2249  avio_seek(mkv->tracks_bc, track->codecpriv_offset, SEEK_SET);
2250  // Do not write the OBUs as we don't have space saved for them
2251  put_ebml_binary(mkv->tracks_bc, MATROSKA_ID_CODECPRIVATE, codecpriv, 4);
2252  av_free(codecpriv);
2253  ret = ff_alloc_extradata(par, side_data_size);
2254  if (ret < 0)
2255  return ret;
2256  memcpy(par->extradata, side_data, side_data_size);
2257  } else if (!par->extradata_size)
2258  return AVERROR_INVALIDDATA;
2259  break;
2260  default:
2261  if (side_data_size)
2262  av_log(s, AV_LOG_DEBUG, "Ignoring new extradata in a packet for stream %d.\n", pkt->stream_index);
2263  break;
2264  }
2265 
2266  return 0;
2267 }
2268 
2270 {
2271  MatroskaMuxContext *mkv = s->priv_data;
2272  AVIOContext *pb;
2274  mkv_track *track = &mkv->tracks[pkt->stream_index];
2275  int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
2276  int duration = pkt->duration;
2277  int ret;
2278  int64_t ts = track->write_dts ? pkt->dts : pkt->pts;
2279  int64_t relative_packet_pos;
2280  int tracknum = mkv->is_dash ? mkv->dash_track_number : pkt->stream_index + 1;
2281 
2282  if (ts == AV_NOPTS_VALUE) {
2283  av_log(s, AV_LOG_ERROR, "Can't write packet with unknown timestamp\n");
2284  return AVERROR(EINVAL);
2285  }
2286  ts += track->ts_offset;
2287 
2288  if (mkv->cluster_pos != -1) {
2289  int64_t cluster_time = ts - mkv->cluster_pts;
2290  if ((int16_t)cluster_time != cluster_time) {
2291  mkv_end_cluster(s);
2292  av_log(s, AV_LOG_WARNING, "Starting new cluster due to timestamp\n");
2293  }
2294  }
2295 
2296  if (mkv->cluster_pos == -1) {
2297  ret = start_ebml_master_crc32(&mkv->cluster_bc, mkv);
2298  if (ret < 0)
2299  return ret;
2300  mkv->cluster_pos = avio_tell(s->pb);
2302  mkv->cluster_pts = FFMAX(0, ts);
2303  av_log(s, AV_LOG_DEBUG,
2304  "Starting new cluster with timestamp "
2305  "%" PRId64 " at offset %" PRId64 " bytes\n",
2306  mkv->cluster_pts, mkv->cluster_pos);
2307  }
2308  pb = mkv->cluster_bc;
2309 
2310  relative_packet_pos = avio_tell(pb);
2311 
2312  if (par->codec_type != AVMEDIA_TYPE_SUBTITLE) {
2313  ret = mkv_write_block(s, pb, MATROSKA_ID_SIMPLEBLOCK, pkt, keyframe);
2314  if (ret < 0)
2315  return ret;
2316  if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) && (par->codec_type == AVMEDIA_TYPE_VIDEO && keyframe || add_cue)) {
2317  ret = mkv_add_cuepoint(mkv, pkt->stream_index, tracknum, ts,
2318  mkv->cluster_pos, relative_packet_pos, -1);
2319  if (ret < 0) return ret;
2320  }
2321  } else {
2322  if (par->codec_id == AV_CODEC_ID_WEBVTT) {
2323  duration = mkv_write_vtt_blocks(s, pb, pkt);
2324  } else {
2326  mkv_blockgroup_size(pkt->size));
2327 
2328 #if FF_API_CONVERGENCE_DURATION
2330  /* For backward compatibility, prefer convergence_duration. */
2331  if (pkt->convergence_duration > 0) {
2332  duration = pkt->convergence_duration;
2333  }
2335 #endif
2336  /* All subtitle blocks are considered to be keyframes. */
2337  mkv_write_block(s, pb, MATROSKA_ID_BLOCK, pkt, 1);
2339  end_ebml_master(pb, blockgroup);
2340  }
2341 
2342  if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
2343  ret = mkv_add_cuepoint(mkv, pkt->stream_index, tracknum, ts,
2344  mkv->cluster_pos, relative_packet_pos, duration);
2345  if (ret < 0)
2346  return ret;
2347  }
2348  }
2349 
2350  mkv->duration = FFMAX(mkv->duration, ts + duration);
2351  track->duration = FFMAX(track->duration, ts + duration);
2352 
2353  return 0;
2354 }
2355 
2357 {
2358  MatroskaMuxContext *mkv = s->priv_data;
2360  int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
2361  int cluster_size;
2362  int64_t cluster_time;
2363  int ret;
2364  int start_new_cluster;
2365 
2366  ret = mkv_check_new_extra_data(s, pkt);
2367  if (ret < 0)
2368  return ret;
2369 
2370  if (mkv->tracks[pkt->stream_index].write_dts)
2371  cluster_time = pkt->dts - mkv->cluster_pts;
2372  else
2373  cluster_time = pkt->pts - mkv->cluster_pts;
2374  cluster_time += mkv->tracks[pkt->stream_index].ts_offset;
2375 
2376  cluster_size = avio_tell(mkv->cluster_bc);
2377 
2378  if (mkv->is_dash && codec_type == AVMEDIA_TYPE_VIDEO) {
2379  // WebM DASH specification states that the first block of every cluster
2380  // has to be a key frame. So for DASH video, we only create a cluster
2381  // on seeing key frames.
2382  start_new_cluster = keyframe;
2383  } else if (mkv->is_dash && codec_type == AVMEDIA_TYPE_AUDIO &&
2384  (mkv->cluster_pos == -1 ||
2385  cluster_time > mkv->cluster_time_limit)) {
2386  // For DASH audio, we create a Cluster based on cluster_time_limit
2387  start_new_cluster = 1;
2388  } else if (!mkv->is_dash &&
2389  (cluster_size > mkv->cluster_size_limit ||
2390  cluster_time > mkv->cluster_time_limit ||
2391  (codec_type == AVMEDIA_TYPE_VIDEO && keyframe &&
2392  cluster_size > 4 * 1024))) {
2393  start_new_cluster = 1;
2394  } else {
2395  start_new_cluster = 0;
2396  }
2397 
2398  if (mkv->cluster_pos != -1 && start_new_cluster) {
2399  mkv_end_cluster(s);
2400  }
2401 
2402  if (!mkv->cluster_pos)
2403  avio_write_marker(s->pb,
2406 
2407  // check if we have an audio packet cached
2408  if (mkv->cur_audio_pkt.size > 0) {
2409  // for DASH audio, a CuePoint has to be added when there is a new cluster.
2411  mkv->is_dash ? start_new_cluster : 0);
2413  if (ret < 0) {
2414  av_log(s, AV_LOG_ERROR,
2415  "Could not write cached audio packet ret:%d\n", ret);
2416  return ret;
2417  }
2418  }
2419 
2420  // buffer an audio packet to ensure the packet containing the video
2421  // keyframe's timecode is contained in the same cluster for WebM
2422  if (codec_type == AVMEDIA_TYPE_AUDIO) {
2423  if (pkt->size > 0)
2424  ret = av_packet_ref(&mkv->cur_audio_pkt, pkt);
2425  } else
2426  ret = mkv_write_packet_internal(s, pkt, 0);
2427  return ret;
2428 }
2429 
2431 {
2432  MatroskaMuxContext *mkv = s->priv_data;
2433 
2434  if (!pkt) {
2435  if (mkv->cluster_pos != -1) {
2436  mkv_end_cluster(s);
2437  av_log(s, AV_LOG_DEBUG,
2438  "Flushing cluster at offset %" PRIu64 " bytes\n",
2439  avio_tell(s->pb));
2440  }
2441  return 1;
2442  }
2443  return mkv_write_packet(s, pkt);
2444 }
2445 
2447 {
2448  MatroskaMuxContext *mkv = s->priv_data;
2449  AVIOContext *pb = s->pb;
2450  int ret;
2451 
2452  // check if we have an audio packet cached
2453  if (mkv->cur_audio_pkt.size > 0) {
2454  ret = mkv_write_packet_internal(s, &mkv->cur_audio_pkt, 0);
2455  if (ret < 0) {
2456  av_log(s, AV_LOG_ERROR,
2457  "Could not write cached audio packet ret:%d\n", ret);
2458  return ret;
2459  }
2460  }
2461 
2462  if (mkv->cluster_bc) {
2463  end_ebml_master_crc32(pb, &mkv->cluster_bc, mkv,
2464  MATROSKA_ID_CLUSTER, 0, 0);
2465  }
2466 
2467  ret = mkv_write_chapters(s);
2468  if (ret < 0)
2469  return ret;
2470 
2471 
2472  if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live) {
2473  int64_t endpos, ret64;
2474 
2475  endpos = avio_tell(pb);
2476 
2477  if (mkv->cues.num_entries) {
2478  AVIOContext *cues = NULL;
2479  uint64_t size;
2480  int64_t cuespos = endpos;
2481  int length_size = 0;
2482 
2483  ret = start_ebml_master_crc32(&cues, mkv);
2484  if (ret < 0)
2485  return ret;
2486 
2487  ret = mkv_assemble_cues(s->streams, cues, &mkv->cues,
2488  mkv->tracks, s->nb_streams);
2489  if (ret < 0) {
2490  ffio_free_dyn_buf(&cues);
2491  return ret;
2492  }
2493 
2494  if (mkv->reserve_cues_space) {
2495  size = avio_tell(cues);
2496  length_size = ebml_num_size(size);
2497  size += 4 + length_size;
2498  if (mkv->reserve_cues_space < size) {
2500  "Insufficient space reserved for Cues: "
2501  "%d < %"PRIu64". No Cues will be output.\n",
2502  mkv->reserve_cues_space, size);
2503  mkv->reserve_cues_space = -1;
2504  ffio_free_dyn_buf(&cues);
2505  goto after_cues;
2506  } else {
2507  cuespos = mkv->cues_pos;
2508  if ((ret64 = avio_seek(pb, mkv->cues_pos, SEEK_SET)) < 0) {
2509  ffio_free_dyn_buf(&cues);
2510  return ret64;
2511  }
2512  if (mkv->reserve_cues_space == size + 1) {
2513  /* There is no way to reserve a single byte because
2514  * the minimal size of an EBML Void element is 2
2515  * (1 byte ID, 1 byte length field). This problem
2516  * is solved by writing the Cues' length field on
2517  * one byte more than necessary. */
2518  length_size++;
2519  size++;
2520  }
2521  }
2522  }
2524  end_ebml_master_crc32(pb, &cues, mkv, MATROSKA_ID_CUES,
2525  length_size, 0);
2526  if (mkv->reserve_cues_space) {
2527  if (size < mkv->reserve_cues_space)
2528  put_ebml_void(pb, mkv->reserve_cues_space - size);
2529  } else
2530  endpos = avio_tell(pb);
2531  }
2532 
2533  after_cues:
2534  ret = mkv_write_seekhead(pb, mkv, 1, mkv->info_pos);
2535  if (ret < 0)
2536  return ret;
2537 
2538  // update the duration
2539  av_log(s, AV_LOG_DEBUG, "end duration = %" PRIu64 "\n", mkv->duration);
2540  avio_seek(mkv->info_bc, mkv->duration_offset, SEEK_SET);
2542  end_ebml_master_crc32(pb, &mkv->info_bc, mkv, MATROSKA_ID_INFO, 0, 0);
2543 
2544  // write tracks master
2545  avio_seek(pb, mkv->tracks_pos, SEEK_SET);
2546  end_ebml_master_crc32(pb, &mkv->tracks_bc, mkv, MATROSKA_ID_TRACKS, 0, 0);
2547 
2548  // update stream durations
2549  if (mkv->tags_bc) {
2550  int i;
2551  for (i = 0; i < s->nb_streams; ++i) {
2552  AVStream *st = s->streams[i];
2553  mkv_track *track = &mkv->tracks[i];
2554 
2555  if (track->duration_offset > 0) {
2556  double duration_sec = track->duration * av_q2d(st->time_base);
2557  char duration_string[20] = "";
2558 
2559  av_log(s, AV_LOG_DEBUG, "stream %d end duration = %" PRIu64 "\n", i,
2560  track->duration);
2561 
2562  avio_seek(mkv->tags_bc, track->duration_offset, SEEK_SET);
2563 
2564  snprintf(duration_string, 20, "%02d:%02d:%012.9f",
2565  (int) duration_sec / 3600, ((int) duration_sec / 60) % 60,
2566  fmod(duration_sec, 60));
2567 
2568  put_ebml_binary(mkv->tags_bc, MATROSKA_ID_TAGSTRING, duration_string, 20);
2569  }
2570  }
2571 
2572  avio_seek(pb, mkv->tags_pos, SEEK_SET);
2573  end_ebml_master_crc32(pb, &mkv->tags_bc, mkv, MATROSKA_ID_TAGS, 0, 0);
2574  }
2575 
2576  avio_seek(pb, endpos, SEEK_SET);
2577  }
2578 
2579  if (!mkv->is_live) {
2580  end_ebml_master(pb, mkv->segment);
2581  }
2582 
2583  return mkv->reserve_cues_space < 0 ? AVERROR(EINVAL) : 0;
2584 }
2585 
2586 static int mkv_query_codec(enum AVCodecID codec_id, int std_compliance)
2587 {
2588  int i;
2589  for (i = 0; ff_mkv_codec_tags[i].id != AV_CODEC_ID_NONE; i++)
2590  if (ff_mkv_codec_tags[i].id == codec_id)
2591  return 1;
2592 
2593  if (std_compliance < FF_COMPLIANCE_NORMAL) {
2594  enum AVMediaType type = avcodec_get_type(codec_id);
2595  // mkv theoretically supports any video/audio through VFW/ACM
2596  if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO)
2597  return 1;
2598  }
2599 
2600  return 0;
2601 }
2602 
2603 static int webm_query_codec(enum AVCodecID codec_id, int std_compliance)
2604 {
2605  int i;
2606  for (i = 0; ff_webm_codec_tags[i].id != AV_CODEC_ID_NONE; i++)
2607  if (ff_webm_codec_tags[i].id == codec_id)
2608  return 1;
2609 
2610  return 0;
2611 }
2612 
2613 static int mkv_init(struct AVFormatContext *s)
2614 {
2615  int i;
2616 
2617  if (s->nb_streams > MAX_TRACKS) {
2618  av_log(s, AV_LOG_ERROR,
2619  "At most %d streams are supported for muxing in Matroska\n",
2620  MAX_TRACKS);
2621  return AVERROR(EINVAL);
2622  }
2623 
2624  for (i = 0; i < s->nb_streams; i++) {
2625  if (s->streams[i]->codecpar->codec_id == AV_CODEC_ID_ATRAC3 ||
2631  av_log(s, AV_LOG_ERROR,
2632  "The Matroska muxer does not yet support muxing %s\n",
2634  return AVERROR_PATCHWELCOME;
2635  }
2636  }
2637 
2638  if (s->avoid_negative_ts < 0) {
2639  s->avoid_negative_ts = 1;
2641  }
2642 
2643  for (i = 0; i < s->nb_streams; i++) {
2644  // ms precision is the de-facto standard timescale for mkv files
2645  avpriv_set_pts_info(s->streams[i], 64, 1, 1000);
2646  }
2647 
2648  return 0;
2649 }
2650 
2651 static int mkv_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
2652 {
2653  int ret = 1;
2654  AVStream *st = s->streams[pkt->stream_index];
2655 
2656  if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
2657  if (pkt->size > 2 && (AV_RB16(pkt->data) & 0xfff0) == 0xfff0)
2658  ret = ff_stream_add_bitstream_filter(st, "aac_adtstoasc", NULL);
2659  } else if (st->codecpar->codec_id == AV_CODEC_ID_VP9) {
2660  ret = ff_stream_add_bitstream_filter(st, "vp9_superframe", NULL);
2661  }
2662 
2663  return ret;
2664 }
2665 
2667  { AV_CODEC_ID_ALAC, 0XFFFFFFFF },
2668  { AV_CODEC_ID_MLP, 0xFFFFFFFF },
2669  { AV_CODEC_ID_OPUS, 0xFFFFFFFF },
2670  { AV_CODEC_ID_PCM_S16BE, 0xFFFFFFFF },
2671  { AV_CODEC_ID_PCM_S24BE, 0xFFFFFFFF },
2672  { AV_CODEC_ID_PCM_S32BE, 0xFFFFFFFF },
2673  { AV_CODEC_ID_QDMC, 0xFFFFFFFF },
2674  { AV_CODEC_ID_QDM2, 0xFFFFFFFF },
2675  { AV_CODEC_ID_RA_144, 0xFFFFFFFF },
2676  { AV_CODEC_ID_RA_288, 0xFFFFFFFF },
2677  { AV_CODEC_ID_COOK, 0xFFFFFFFF },
2678  { AV_CODEC_ID_TRUEHD, 0xFFFFFFFF },
2679  { AV_CODEC_ID_NONE, 0xFFFFFFFF }
2680 };
2681 
2683  { AV_CODEC_ID_RV10, 0xFFFFFFFF },
2684  { AV_CODEC_ID_RV20, 0xFFFFFFFF },
2685  { AV_CODEC_ID_RV30, 0xFFFFFFFF },
2686  { AV_CODEC_ID_NONE, 0xFFFFFFFF }
2687 };
2688 
2690  { AV_CODEC_ID_DVB_SUBTITLE, 0xFFFFFFFF },
2691  { AV_CODEC_ID_DVD_SUBTITLE, 0xFFFFFFFF },
2692  { AV_CODEC_ID_HDMV_PGS_SUBTITLE, 0xFFFFFFFF },
2693  { AV_CODEC_ID_NONE, 0xFFFFFFFF }
2694 };
2695 
2696 #define OFFSET(x) offsetof(MatroskaMuxContext, x)
2697 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM
2698 static const AVOption options[] = {
2699  { "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 },
2700  { "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 },
2701  { "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 },
2702  { "dash", "Create a WebM file conforming to WebM DASH specification", OFFSET(is_dash), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
2703  { "dash_track_number", "Track number for the DASH stream", OFFSET(dash_track_number), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 127, FLAGS },
2704  { "live", "Write files assuming it is a live stream.", OFFSET(is_live), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
2705  { "allow_raw_vfw", "allow RAW VFW mode", OFFSET(allow_raw_vfw), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
2706  { "write_crc32", "write a CRC32 element inside every Level 1 element", OFFSET(write_crc), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, FLAGS },
2707  { NULL },
2708 };
2709 
2710 #if CONFIG_MATROSKA_MUXER
2711 static const AVClass matroska_class = {
2712  .class_name = "matroska muxer",
2713  .item_name = av_default_item_name,
2714  .option = options,
2715  .version = LIBAVUTIL_VERSION_INT,
2716 };
2717 
2719  .name = "matroska",
2720  .long_name = NULL_IF_CONFIG_SMALL("Matroska"),
2721  .mime_type = "video/x-matroska",
2722  .extensions = "mkv",
2723  .priv_data_size = sizeof(MatroskaMuxContext),
2724  .audio_codec = CONFIG_LIBVORBIS_ENCODER ?
2726  .video_codec = CONFIG_LIBX264_ENCODER ?
2728  .init = mkv_init,
2729  .deinit = mkv_deinit,
2735  .codec_tag = (const AVCodecTag* const []){
2738  },
2739  .subtitle_codec = AV_CODEC_ID_ASS,
2740  .query_codec = mkv_query_codec,
2741  .check_bitstream = mkv_check_bitstream,
2742  .priv_class = &matroska_class,
2743 };
2744 #endif
2745 
2746 #if CONFIG_WEBM_MUXER
2747 static const AVClass webm_class = {
2748  .class_name = "webm muxer",
2749  .item_name = av_default_item_name,
2750  .option = options,
2751  .version = LIBAVUTIL_VERSION_INT,
2752 };
2753 
2755  .name = "webm",
2756  .long_name = NULL_IF_CONFIG_SMALL("WebM"),
2757  .mime_type = "video/webm",
2758  .extensions = "webm",
2759  .priv_data_size = sizeof(MatroskaMuxContext),
2760  .audio_codec = CONFIG_LIBOPUS_ENCODER ? AV_CODEC_ID_OPUS : AV_CODEC_ID_VORBIS,
2761  .video_codec = CONFIG_LIBVPX_VP9_ENCODER? AV_CODEC_ID_VP9 : AV_CODEC_ID_VP8,
2762  .subtitle_codec = AV_CODEC_ID_WEBVTT,
2763  .init = mkv_init,
2764  .deinit = mkv_deinit,
2769  .check_bitstream = mkv_check_bitstream,
2772  .priv_class = &webm_class,
2773 };
2774 #endif
2775 
2776 #if CONFIG_MATROSKA_AUDIO_MUXER
2777 static const AVClass mka_class = {
2778  .class_name = "matroska audio muxer",
2779  .item_name = av_default_item_name,
2780  .option = options,
2781  .version = LIBAVUTIL_VERSION_INT,
2782 };
2784  .name = "matroska",
2785  .long_name = NULL_IF_CONFIG_SMALL("Matroska Audio"),
2786  .mime_type = "audio/x-matroska",
2787  .extensions = "mka",
2788  .priv_data_size = sizeof(MatroskaMuxContext),
2789  .audio_codec = CONFIG_LIBVORBIS_ENCODER ?
2791  .video_codec = AV_CODEC_ID_NONE,
2792  .init = mkv_init,
2793  .deinit = mkv_deinit,
2797  .check_bitstream = mkv_check_bitstream,
2800  .codec_tag = (const AVCodecTag* const []){
2802  },
2803  .priv_class = &mka_class,
2804 };
2805 #endif
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1582
static int mkv_write_packet_internal(AVFormatContext *s, AVPacket *pkt, int add_cue)
Definition: matroskaenc.c:2269
int32_t pitch
Rotation around the right vector [-90, 90].
Definition: spherical.h:127
Context structure for the Lagged Fibonacci PRNG.
Definition: lfg.h:33
#define MATROSKA_ID_SEEKPREROLL
Definition: matroska.h:95
void av_sha_final(AVSHA *ctx, uint8_t *digest)
Finish hashing and output digest value.
Definition: sha.c:345
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:167
#define MATROSKA_ID_VIDEOPROJECTIONPOSEYAW
Definition: matroska.h:159
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:698
enum AVChromaLocation chroma_location
Definition: avcodec.h:4126
internal header for HEVC (de)muxer utilities
#define AV_DISPOSITION_METADATA
Definition: avformat.h:858
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:461
#define NULL
Definition: coverity.c:32
static int mkv_write_vtt_blocks(AVFormatContext *s, AVIOContext *pb, AVPacket *pkt)
Definition: matroskaenc.c:2119
#define MATROSKA_ID_BLOCKADDID
Definition: matroska.h:230
#define MATROSKA_ID_TRACKDEFAULTDURATION
Definition: matroska.h:104
enum AVFieldOrder field_order
Video only.
Definition: avcodec.h:4117
void avio_wl16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:467
static void put_ebml_size_unknown(AVIOContext *pb, int bytes)
Write an EBML size meaning "unknown size".
Definition: matroskaenc.c:196
Bytestream IO Context.
Definition: avio.h:161
enum AVColorTransferCharacteristic color_trc
Definition: avcodec.h:4124
#define MATROSKA_ID_VIDEOFLAGINTERLACED
Definition: matroska.h:121
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define MATROSKA_ID_VIDEOCOLOR_GX
Definition: matroska.h:147
static int start_ebml_master_crc32(AVIOContext **dyn_cp, MatroskaMuxContext *mkv)
Definition: matroskaenc.c:329
void ff_metadata_conv_ctx(AVFormatContext *ctx, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)
Definition: metadata.c:59
version
Definition: libkvazaar.c:292
#define MATROSKA_ID_DATEUTC
Definition: matroska.h:71
int sizebytes
how many bytes were reserved for the size
Definition: matroskaenc.c:66
#define MAX_TRACKS
Maximum number of tracks allowed in a Matroska file (with track numbers in range 1 to 126 (inclusive)...
Definition: matroskaenc.c:122
The optional first identifier line of a WebVTT cue.
Definition: avcodec.h:1383
uint32_t samples
Definition: wv.h:39
int initial
Definition: wv.h:43
#define MATROSKA_ID_TRACKFLAGLACING
Definition: matroska.h:101
unsigned MaxCLL
Max content light level (cd/m^2).
#define MATROSKA_ID_TRACKENTRY
Definition: matroska.h:75
#define MATROSKA_ID_VIDEODISPLAYHEIGHT
Definition: matroska.h:113
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1421
AVOption.
Definition: opt.h:246
hash context
Definition: sha.c:34
int64_t cluster_pos
offset of the cluster containing the block relative to the segment
Definition: matroskaenc.c:85
void ff_put_bmp_header(AVIOContext *pb, AVCodecParameters *par, int for_asf, int ignore_extradata)
Definition: riffenc.c:209
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
int ff_put_wav_header(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, int flags)
Write WAVEFORMAT header structure.
Definition: riffenc.c:54
static int mkv_init(struct AVFormatContext *s)
Definition: matroskaenc.c:2613
#define MAX_SEEKHEAD_ENTRIES
Definition: matroskaenc.c:62
#define MATROSKA_ID_VIDEOPROJECTIONPOSEROLL
Definition: matroska.h:161
#define MATROSKA_ID_CUETRACKPOSITION
Definition: matroska.h:192
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3160
#define MATROSKA_ID_CODECPRIVATE
Definition: matroska.h:89
AVIOContext * cluster_bc
Definition: matroskaenc.c:135
av_cold int av_sha_init(AVSHA *ctx, int bits)
Initialize SHA-1 or SHA-2 hashing.
Definition: sha.c:273
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4943
int av_parse_time(int64_t *timeval, const char *timestr, int duration)
Parse timestr and return in *time a corresponding number of microseconds.
Definition: parseutils.c:587
FFmpeg currently uses a custom build this text attempts to document some of its obscure features and options Makefile the full command issued by make and its output will be shown on the screen DBG Preprocess x86 external assembler files to a dbg asm file in the object which then gets compiled Helps in developing those assembler files DESTDIR Destination directory for the install targets
Definition: build_system.txt:1
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
#define MATROSKA_ID_AUDIOBITDEPTH
Definition: matroska.h:167
#define MATROSKA_ID_TRACKFLAGDEFAULT
Definition: matroska.h:99
static const AVCodecTag additional_subtitle_tags[]
Definition: matroskaenc.c:2689
This side data should be associated with a video stream and contains Stereoscopic 3D information in f...
Definition: avcodec.h:1301
static int mkv_write_attachments(AVFormatContext *s)
Definition: matroskaenc.c:1645
uint64_t pts
Definition: matroskaenc.c:82
Video represents a portion of a sphere mapped on a flat surface using equirectangular projection...
Definition: spherical.h:72
static int mkv_write_video_color(AVIOContext *pb, AVCodecParameters *par, AVStream *st)
Definition: matroskaenc.c:792
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:4036
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:938
#define MATROSKA_ID_TAGTARGETS_ATTACHUID
Definition: matroska.h:214
int num
Numerator.
Definition: rational.h:59
int size
Definition: avcodec.h:1534
int ff_hevc_annexb2mp4_buf(const uint8_t *buf_in, uint8_t **buf_out, int *size, int filter_ps, int *ps_count)
Writes Annex B formatted HEVC NAL units to a data buffer.
Definition: hevc.c:1047
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:241
#define MATROSKA_ID_FILEDATA
Definition: matroska.h:246
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1806
#define EBML_ID_DOCTYPEREADVERSION
Definition: matroska.h:42
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:266
#define MATROSKA_ID_BLOCKREFERENCE
Definition: matroska.h:237
int av_log2(unsigned v)
Definition: intmath.c:26
static int mkv_write_header(AVFormatContext *s)
Definition: matroskaenc.c:1765
#define MATROSKA_ID_TRACKTYPE
Definition: matroska.h:80
enum AVMediaType codec_type
Definition: rtp.c:37
#define MATROSKA_ID_TAGTARGETS_CHAPTERUID
Definition: matroska.h:213
int ff_flac_is_native_layout(uint64_t channel_layout)
int64_t duration
duration of the block according to time base
Definition: matroskaenc.c:87
static av_always_inline uint64_t av_double2int(double f)
Reinterpret a double as a 64-bit integer.
Definition: intfloat.h:70
GLint GLenum type
Definition: opengl_enc.c:104
#define MATROSKA_ID_VIDEOCOLOR_RX
Definition: matroska.h:145
Video represents a sphere mapped on a flat surface using equirectangular projection.
Definition: spherical.h:56
#define MATROSKA_ID_MUXINGAPP
Definition: matroska.h:70
int64_t cluster_time_limit
Definition: matroskaenc.c:153
#define MATROSKA_ID_AUDIOCHANNELS
Definition: matroska.h:168
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
Definition: utils.c:3150
const char * key
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
int avoid_negative_ts_use_pts
Definition: internal.h:119
const char * master
Definition: vf_curves.c:117
#define MATROSKA_ID_VIDEOPROJECTIONTYPE
Definition: matroska.h:157
AVPacketSideData * side_data
An array of side data that applies to the whole stream (i.e.
Definition: avformat.h:978
Views are next to each other.
Definition: stereo3d.h:67
static AVPacket pkt
#define av_le2ne32(x)
Definition: bswap.h:96
#define MATROSKA_ID_CUECLUSTERPOSITION
Definition: matroska.h:196
#define MATROSKA_ID_VIDEOCOLOR_LUMINANCEMAX
Definition: matroska.h:153
#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:167
Definition: matroskaenc.c:69
int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos)
Converts AVChromaLocation to swscale x/y chroma position.
Definition: utils.c:353
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:87
AVDictionary * metadata
Definition: avformat.h:1314
#define MATROSKA_ID_VIDEOCOLORCHROMASITINGHORZ
Definition: matroska.h:135
mkv_track * tracks
Definition: matroskaenc.c:142
#define AVFMT_ALLOW_FLUSH
Format allows flushing.
Definition: avformat.h:471
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate.The lists are not just lists
#define MATROSKA_ID_EDITIONFLAGDEFAULT
Definition: matroska.h:260
#define MATROSKA_ID_CLUSTERTIMECODE
Definition: matroska.h:224
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1376
#define EBML_ID_DOCTYPE
Definition: matroska.h:40
int64_t duration_offset
Definition: matroskaenc.c:102
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:472
This struct describes the properties of an encoded stream.
Definition: avcodec.h:4028
#define MATROSKA_ID_CHAPTERTIMEEND
Definition: matroska.h:253
enum AVColorSpace color_space
Definition: avcodec.h:4125
int64_t pos
absolute offset in the containing AVIOContext where the master&#39;s elements start
Definition: matroskaenc.c:65
MatroskaVideoStereoModeType
Definition: matroska.h:301
Mastering display metadata (based on SMPTE-2086:2014).
Definition: avcodec.h:1409
#define FLAGS
Definition: matroskaenc.c:2697
#define MATROSKA_ID_FILEDESC
Definition: matroska.h:243
Format I/O context.
Definition: avformat.h:1353
#define EBML_ID_CRC32
Definition: matroska.h:46
UID uid
Definition: mxfenc.c:2139
static void end_ebml_master_crc32_preliminary(AVIOContext *pb, AVIOContext *dyn_cp, uint32_t id, int64_t *pos)
Complete ebml master without destroying the buffer, allowing for later updates.
Definition: matroskaenc.c:369
char str[32]
Definition: internal.h:48
static int query_codec(enum AVCodecID id, int std_compliance)
Definition: img2enc.c:229
int64_t cluster_pos
file offset of the current cluster
Definition: matroskaenc.c:136
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
#define AV_WB64(p, v)
Definition: intreadwrite.h:433
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
static const AVCodecTag additional_audio_tags[]
Definition: matroskaenc.c:2666
Public dictionary API.
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
void avio_wl32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:367
uint8_t
#define MATROSKA_ID_VIDEOCOLOR_BX
Definition: matroska.h:149
#define MATROSKA_ID_CHAPLANG
Definition: matroska.h:256
#define av_malloc(s)
int avpriv_mpeg4audio_get_config2(MPEG4AudioConfig *c, const uint8_t *buf, int size, int sync_extension, void *logctx)
Parse MPEG-4 systems extradata from a raw buffer to retrieve audio configuration. ...
Definition: mpeg4audio.c:177
int width
Video only.
Definition: avcodec.h:4102
static void mkv_end_cluster(AVFormatContext *s)
Definition: matroskaenc.c:2162
AVOptions.
#define MATROSKA_ID_TRACKLANGUAGE
Definition: matroska.h:97
int64_t duration
Definition: matroskaenc.c:101
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: utils.c:2030
A point in the output bytestream where the underlying AVIOContext might flush the buffer depending on...
Definition: avio.h:146
Stereo 3D type: this structure describes how two videos are packed within a single video surface...
Definition: stereo3d.h:176
const AVCodecTag ff_codec_movvideo_tags[]
Definition: isom.c:75
#define OPUS_SEEK_PREROLL
Seek preroll value for opus.
Definition: matroskaenc.c:177
uint32_t flags
Definition: wv.h:40
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
int ff_mkv_stereo3d_conv(AVStream *st, MatroskaVideoStereoModeType stereo_mode)
Definition: matroska.c:171
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
uint64_t segmentpos
Definition: matroskaenc.c:71
int id
unique ID to identify the chapter
Definition: avformat.h:1311
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1551
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
#define MATROSKA_ID_TIMECODESCALE
Definition: matroska.h:66
static int mkv_write_codecprivate(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, int native_id, int qt_id)
Definition: matroskaenc.c:725
#define MATROSKA_ID_SIMPLEBLOCK
Definition: matroska.h:232
#define MATROSKA_ID_EDITIONFLAGHIDDEN
Definition: matroska.h:259
int nb_side_data
The number of elements in the AVStream.side_data array.
Definition: avformat.h:982
void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type)
Mark the written bytestream as a specific type.
Definition: aviobuf.c:491
uint8_t * av_stream_get_side_data(const AVStream *stream, enum AVPacketSideDataType type, int *size)
Get side information from stream.
Definition: utils.c:5503
#define MATROSKA_ID_BLOCKMORE
Definition: matroska.h:229
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:87
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1421
int64_t duration
Definition: movenc.c:63
#define MATROSKA_ID_CUERELATIVEPOSITION
Definition: matroska.h:197
A point in the output bytestream where a demuxer can start parsing (for non self synchronizing bytest...
Definition: avio.h:128
#define MATROSKA_ID_AUDIOOUTSAMPLINGFREQ
Definition: matroska.h:165
#define MATROSKA_ID_VIDEOCOLOR
Definition: matroska.h:127
Public header for CRC hash function implementation.
int initial_padding
Audio only.
Definition: avcodec.h:4165
static int webm_query_codec(enum AVCodecID codec_id, int std_compliance)
Definition: matroskaenc.c:2603
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1484
uint8_t * data
Definition: avcodec.h:1533
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
#define MATROSKA_ID_VIDEODISPLAYWIDTH
Definition: matroska.h:112
int ff_isom_write_av1c(AVIOContext *pb, const uint8_t *buf, int size)
Writes AV1 extradata (Sequence Header and Metadata OBUs) to the provided AVIOContext.
Definition: av1.c:364
#define MATROSKA_ID_BLOCKADDITIONS
Definition: matroska.h:228
uint32_t tag
Definition: movenc.c:1534
static EbmlSyntax ebml_header[]
Definition: matroskadec.c:404
Not part of ABI.
Definition: pixfmt.h:536
#define WV_HEADER_SIZE
Definition: wavpack.h:30
enum AVCodecID id
Definition: internal.h:49
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
uint8_t * data
Definition: avcodec.h:1477
#define MATROSKA_ID_CUES
Definition: matroska.h:58
int64_t ts_offset
Definition: matroskaenc.c:104
#define max(a, b)
Definition: cuda_runtime.h:33
Video is not stereoscopic (and metadata has to be there).
Definition: stereo3d.h:55
ptrdiff_t size
Definition: opengl_enc.c:100
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
static const uint8_t header[24]
Definition: sdr2.c:67
#define MATROSKA_ID_TRACKNUMBER
Definition: matroska.h:78
#define MATROSKA_ID_VIDEOCOLOR_WHITEY
Definition: matroska.h:152
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:213
Definition: wv.h:34
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1501
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:198
#define MATROSKA_ID_SEGMENTUID
Definition: matroska.h:72
AVOutputFormat ff_webm_muxer
static int mkv_write_block(AVFormatContext *s, AVIOContext *pb, uint32_t blockid, AVPacket *pkt, int keyframe)
Definition: matroskaenc.c:2003
uint64_t channel_layout
Audio only.
Definition: avcodec.h:4138
static void put_ebml_num(AVIOContext *pb, uint64_t num, int bytes)
Write a number in EBML variable length format.
Definition: matroskaenc.c:220
#define av_log(a,...)
int has_cue
Definition: matroskaenc.c:97
#define AV_DISPOSITION_CAPTIONS
To specify text track kind (different from subtitles default).
Definition: avformat.h:856
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: avpacket.c:609
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1565
static void mkv_add_seekhead_entry(MatroskaMuxContext *mkv, uint32_t elementid, uint64_t filepos)
Definition: matroskaenc.c:425
#define MATROSKA_ID_TRACKUID
Definition: matroska.h:79
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
ebml_master segment
Definition: matroskaenc.c:133
static int mkv_write_simpletag(AVIOContext *pb, AVDictionaryEntry *t)
Definition: matroskaenc.c:1447
#define U(x)
Definition: vp56_arith.h:37
#define src
Definition: vp8dsp.c:254
#define MATROSKA_ID_VIDEOSTEREOMODE
Definition: matroska.h:123
uint32_t chapter_id_offset
Definition: matroskaenc.c:159
static void put_ebml_id(AVIOContext *pb, uint32_t id)
Definition: matroskaenc.c:184
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:5709
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
AVPacket cur_audio_pkt
Definition: matroskaenc.c:145
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:217
static int mkv_write_tags(AVFormatContext *s)
Definition: matroskaenc.c:1555
#define MATROSKA_ID_VIDEOCOLOR_BY
Definition: matroska.h:150
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: utils.c:2051
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static void put_ebml_float(AVIOContext *pb, uint32_t elementid, double val)
Definition: matroskaenc.c:264
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1539
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1593
int flags
Additional information about the frame packing.
Definition: stereo3d.h:185
#define MATROSKA_ID_BLOCKDURATION
Definition: matroska.h:236
#define EBML_ID_EBMLREADVERSION
Definition: matroska.h:37
#define MATROSKA_ID_VIDEOCOLORMAXCLL
Definition: matroska.h:141
#define MAX_CUETRACKPOS_SIZE
4 * (1-byte EBML ID, 1-byte EBML size, 8-byte uint max)
Definition: matroskaenc.c:174
#define MATROSKA_ID_VIDEOCOLOR_WHITEX
Definition: matroska.h:151
static int get_aac_sample_rates(AVFormatContext *s, uint8_t *extradata, int extradata_size, int *sample_rate, int *output_sample_rate)
Definition: matroskaenc.c:641
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:350
int reserved_size
Definition: matroskaenc.c:78
#define MATROSKA_ID_CLUSTER
Definition: matroska.h:62
const char * ff_convert_lang_to(const char *lang, enum AVLangCodespace target_codespace)
Convert a language code to a target codespace.
Definition: avlanguage.c:736
#define MATROSKA_ID_VIDEOCOLORCHROMASITINGVERT
Definition: matroska.h:136
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
int ff_av1_filter_obus_buf(const uint8_t *in, uint8_t **out, int *size, int *offset)
Filter out AV1 OBUs not meant to be present in ISOBMFF sample data and return the result in a data bu...
Definition: av1.c:86
Views are packed per line, as if interlaced.
Definition: stereo3d.h:129
enum AVColorPrimaries color_primaries
Definition: avcodec.h:4123
void ffio_reset_dyn_buf(AVIOContext *s)
Reset a dynamic buffer.
Definition: aviobuf.c:1410
#define MATROSKA_ID_FILEMIMETYPE
Definition: matroska.h:245
#define MATROSKA_ID_WRITINGAPP
Definition: matroska.h:69
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
int ff_isom_write_hvcc(AVIOContext *pb, const uint8_t *data, int size, int ps_array_completeness)
Writes HEVC extradata (parameter sets, declarative SEI NAL units) to the provided AVIOContext...
Definition: hevc.c:1068
Not part of ABI.
Definition: pixfmt.h:473
AVIOContext * tracks_bc
Definition: matroskaenc.c:131
const char *const ff_matroska_video_stereo_mode[MATROSKA_VIDEO_STEREOMODE_TYPE_NB]
Definition: matroska.c:147
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
static int mkv_blockgroup_size(int pkt_size)
Definition: matroskaenc.c:1941
static void put_ebml_void(AVIOContext *pb, int size)
Write a void element of a given size.
Definition: matroskaenc.c:291
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:4032
static int ebml_num_size(uint64_t num)
Calculate how many bytes are needed to represent a given number in EBML.
Definition: matroskaenc.c:206
int write_dts
Definition: matroskaenc.c:96
int final
Definition: wv.h:43
AVChapter ** chapters
Definition: avformat.h:1583
int ff_vorbiscomment_write(uint8_t **p, AVDictionary **m, const char *vendor_string, AVChapter **chapters, unsigned int nb_chapters)
Write a VorbisComment into a buffer.
Definition: vorbiscomment.c:65
enum AVCodecID id
Definition: matroska.h:355
enum AVPacketSideDataType type
Definition: avcodec.h:1479
enum AVMediaType avcodec_get_type(enum AVCodecID codec_id)
Get the type of the given codec.
Definition: codec_desc.c:3389
static int mkv_write_chapters(AVFormatContext *s)
Definition: matroskaenc.c:1390
#define EBML_ID_EBMLMAXIDLENGTH
Definition: matroska.h:38
#define MATROSKA_ID_CHAPTERFLAGHIDDEN
Definition: matroska.h:263
uint32_t crc
Definition: wv.h:41
static int mkv_write_seekhead(AVIOContext *pb, MatroskaMuxContext *mkv, int error_on_seek_failure, int64_t destpos)
Write the SeekHead to the file at the location reserved for it and seek to destpos afterwards...
Definition: matroskaenc.c:446
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:949
const AVCodecTag ff_codec_wav_tags[]
Definition: riff.c:504
#define FFMAX(a, b)
Definition: common.h:94
int ff_avc_parse_nal_units_buf(const uint8_t *buf_in, uint8_t **buf, int *size)
Definition: avc.c:95
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
void avcodec_parameters_free(AVCodecParameters **par)
Free an AVCodecParameters instance and everything associated with it and write NULL to the supplied p...
Definition: utils.c:2040
int64_t filepos
Definition: matroskaenc.c:75
#define fail()
Definition: checkasm.h:122
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1539
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:4054
static void end_ebml_master_crc32(AVIOContext *pb, AVIOContext **dyn_cp, MatroskaMuxContext *mkv, uint32_t id, int length_size, int keep_buffer)
Definition: matroskaenc.c:342
const CodecMime ff_mkv_mime_tags[]
Definition: matroska.c:131
#define MATROSKA_ID_TAG
Definition: matroska.h:202
const CodecTags ff_webm_codec_tags[]
Definition: matroska.c:106
Views are alternated temporally.
Definition: stereo3d.h:92
#define AV_DISPOSITION_FORCED
Track should be used during playback by default.
Definition: avformat.h:833
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1409
uint32_t bound_bottom
Distance from the bottom edge.
Definition: spherical.h:170
AVOutputFormat ff_matroska_audio_muxer
#define LIBAVFORMAT_IDENT
Definition: version.h:46
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
Video frame is split into 6 faces of a cube, and arranged on a 3x2 layout.
Definition: spherical.h:65
#define MATROSKA_ID_VIDEOCOLOR_LUMINANCEMIN
Definition: matroska.h:154
audio channel layout utility functions
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0...
Definition: utils.c:3323
#define EBML_ID_EBMLVERSION
Definition: matroska.h:36
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
mkv_cuepoint * entries
Definition: matroskaenc.c:91
void ffio_fill(AVIOContext *s, int b, int count)
Definition: aviobuf.c:199
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
#define MATROSKA_ID_TAGTARGETS
Definition: matroska.h:209
const AVCodecTag ff_codec_bmp_tags[]
Definition: riff.c:32
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:213
#define MATROSKA_ID_TAGNAME
Definition: matroska.h:204
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
static int put_wv_codecpriv(AVIOContext *pb, AVCodecParameters *par)
Definition: matroskaenc.c:583
#define MATROSKA_ID_CHAPTERFLAGENABLED
Definition: matroska.h:264
static int mkv_write_native_codecprivate(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, AVIOContext *dyn_cp)
Definition: matroskaenc.c:673
void av_sha_update(struct AVSHA *ctx, const uint8_t *data, unsigned int len)
Update hash value.
Definition: sha.c:315
static int64_t get_metadata_duration(AVFormatContext *s)
Definition: matroskaenc.c:1741
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:94
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
Definition: af_astats.c:226
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:461
This side data should be associated with a video stream and corresponds to the AVSphericalMapping str...
Definition: avcodec.h:1415
int64_t ff_vorbiscomment_length(AVDictionary *m, const char *vendor_string, AVChapter **chapters, unsigned int nb_chapters)
Calculate the length in bytes of a VorbisComment.
Definition: vorbiscomment.c:41
uint32_t bound_right
Distance from the right edge.
Definition: spherical.h:169
int ff_wv_parse_header(WvHeader *wv, const uint8_t *data)
Parse a WavPack block header.
Definition: wv.c:29
#define MATROSKA_ID_SIMPLETAG
Definition: matroska.h:203
const char * name
Definition: avformat.h:500
internal header for RIFF based (de)muxers do NOT include this in end user applications ...
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:392
#define AV_WB24(p, d)
Definition: intreadwrite.h:450
static int mkv_check_new_extra_data(AVFormatContext *s, AVPacket *pkt)
Definition: matroskaenc.c:2171
#define s(width, name)
Definition: cbs_vp9.c:257
int avoid_negative_ts
Avoid negative timestamps during muxing.
Definition: avformat.h:1684
#define MATROSKA_ID_CHAPTERATOM
Definition: matroska.h:251
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
int32_t yaw
Rotation around the up vector [-180, 180].
Definition: spherical.h:126
AVDictionary * metadata
Definition: avformat.h:940
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
enum AVColorRange color_range
Video only.
Definition: avcodec.h:4122
AVIOContext * info_bc
Definition: matroskaenc.c:129
Opaque data information usually sparse.
Definition: avutil.h:205
static int mkv_add_cuepoint(MatroskaMuxContext *mkv, int stream, int tracknum, int64_t ts, int64_t cluster_pos, int64_t relative_pos, int64_t duration)
Definition: matroskaenc.c:484
#define MATROSKA_ID_VIDEOCOLORSPACE
Definition: matroska.h:126
#define MATROSKA_ID_CHAPTERS
Definition: matroska.h:63
#define EBML_ID_VOID
Definition: matroska.h:45
#define OFFSET(x)
Definition: matroskaenc.c:2696
#define MATROSKA_ID_AUDIOSAMPLINGFREQ
Definition: matroska.h:164
static int mkv_check_tag(AVDictionary *m, uint32_t elementid)
Definition: matroskaenc.c:1544
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:1172
ff_const59 struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1372
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1451
uint32_t padding
Number of pixels to pad from the edge of each cube face.
Definition: spherical.h:182
int metadata_header_padding
Number of bytes to be written as padding in a metadata header.
Definition: avformat.h:1853
Stream structure.
Definition: avformat.h:876
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1313
Content light level (based on CTA-861.3).
Definition: avcodec.h:1422
static int mkv_write_track(AVFormatContext *s, MatroskaMuxContext *mkv, int i, AVIOContext *pb, int default_stream_exists)
Definition: matroskaenc.c:1089
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: avcodec.h:1242
#define AV_DISPOSITION_DEFAULT
Definition: avformat.h:821
sample_rate
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:180
Views are packed in a checkerboard-like structure per pixel.
Definition: stereo3d.h:104
#define MATROSKA_ID_VIDEOCOLORMATRIXCOEFF
Definition: matroska.h:129
#define AV_DISPOSITION_DESCRIPTIONS
Definition: avformat.h:857
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
#define MATROSKA_ID_TRACKFLAGFORCED
Definition: matroska.h:100
#define MATROSKA_ID_TAGS
Definition: matroska.h:59
Views are on top of each other.
Definition: stereo3d.h:79
#define MATROSKA_ID_VIDEOCOLORPRIMARIES
Definition: matroska.h:140
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:87
int64_t sample_rate_offset
Definition: matroskaenc.c:99
#define MATROSKA_ID_VIDEOPROJECTIONPOSEPITCH
Definition: matroska.h:160
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
#define MATROSKA_ID_SEEKID
Definition: matroska.h:220
AVIOContext * pb
I/O context.
Definition: avformat.h:1395
int64_t codecpriv_offset
Definition: matroskaenc.c:103
static void put_ebml_uint(AVIOContext *pb, uint32_t elementid, uint64_t val)
Definition: matroskaenc.c:238
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:191
Public header for SHA-1 & SHA-256 hash function implementations.
#define MATROSKA_ID_BLOCK
Definition: matroska.h:235
#define MATROSKA_ID_INFO
Definition: matroska.h:56
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:600
#define MATROSKA_ID_TAGTARGETS_TRACKUID
Definition: matroska.h:212
mkv_attachment * entries
Definition: matroskaenc.c:113
uint32_t fileuid
Definition: matroskaenc.c:109
#define MATROSKA_ID_TAGLANG
Definition: matroska.h:206
struct AVSHA * av_sha_alloc(void)
Allocate an AVSHA context.
Definition: sha.c:45
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Definition: lfg.h:53
#define MATROSKA_ID_TRACKS
Definition: matroska.h:57
Data found in BlockAdditional element of matroska container.
Definition: avcodec.h:1378
#define MATROSKA_ID_TRACKNAME
Definition: matroska.h:96
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
#define MATROSKA_ID_SEEKENTRY
Definition: matroska.h:217
Describe the class of an AVClass context structure.
Definition: log.h:67
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
#define MATROSKA_ID_EDITIONENTRY
Definition: matroska.h:250
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:2687
static int mkv_check_tag_name(const char *name, uint32_t elementid)
Definition: matroskaenc.c:1506
#define MATROSKA_ID_BLOCKGROUP
Definition: matroska.h:227
#define MATROSKA_ID_VIDEOPIXELHEIGHT
Definition: matroska.h:115
int32_t roll
Rotation around the forward vector [-180, 180].
Definition: spherical.h:128
static int mkv_write_tracks(AVFormatContext *s)
Definition: matroskaenc.c:1359
Rational number (pair of numerator and denominator).
Definition: rational.h:58
Mastering display metadata capable of representing the color volume of the display used to master the...
#define MATROSKA_ID_CUEDURATION
Definition: matroska.h:198
static int mkv_write_tag_targets(AVFormatContext *s, uint32_t elementid, unsigned int uid, ebml_master *tag)
Definition: matroskaenc.c:1481
#define MATROSKA_ID_CUETIME
Definition: matroska.h:191
Not part of ABI.
Definition: pixfmt.h:502
AVFieldOrder
Definition: avcodec.h:1599
Recommmends skipping the specified number of samples.
Definition: avcodec.h:1343
AVMediaType
Definition: avutil.h:199
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:32
int64_t duration_offset
Definition: matroskaenc.c:138
#define MATROSKA_ID_VIDEOCOLORTRANSFERCHARACTERISTICS
Definition: matroska.h:138
#define MATROSKA_ID_TITLE
Definition: matroska.h:68
#define snprintf
Definition: snprintf.h:34
#define MATROSKA_ID_TRACKVIDEO
Definition: matroska.h:81
static int mkv_strip_wavpack(const uint8_t *src, uint8_t **pdst, int *size)
Definition: matroskaenc.c:1950
This structure describes how to handle spherical videos, outlining information about projection...
Definition: spherical.h:82
mkv_seekhead seekhead
Definition: matroskaenc.c:140
#define MATROSKA_ID_VIDEOPROJECTION
Definition: matroska.h:156
#define MATROSKA_ID_VIDEOCOLORMASTERINGMETA
Definition: matroska.h:144
misc parsing utilities
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63)))#define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};static void cpy1(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, len);}static void cpy2(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 2 *len);}static void cpy4(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 4 *len);}static void cpy8(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;}void swri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len){int ch;int off=0;const int os=(out->planar?1:out->ch_count)*out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){int planes=in->planar?in->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){int planes=out->planar?out->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){int planes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
#define MATROSKA_ID_VIDEOPROJECTIONPRIVATE
Definition: matroska.h:158
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
#define MATROSKA_ID_ATTACHMENTS
Definition: matroska.h:61
static int64_t pts
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:473
#define flags(name, subs,...)
Definition: cbs_av1.c:564
#define MATROSKA_ID_CHAPTERDISPLAY
Definition: matroska.h:254
static int put_xiph_codecpriv(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par)
Definition: matroskaenc.c:555
int bits_per_raw_sample
This is the number of valid bits in each output sample.
Definition: avcodec.h:4091
#define MATROSKA_ID_FILENAME
Definition: matroska.h:244
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
#define MATROSKA_ID_BLOCKADDITIONAL
Definition: matroska.h:231
uint32_t bound_top
Distance from the top edge.
Definition: spherical.h:168
const AVMetadataConv ff_mkv_metadata_conv[]
Definition: matroska.c:141
#define MATROSKA_ID_CODECID
Definition: matroska.h:88
static const AVCodecTag additional_video_tags[]
Definition: matroskaenc.c:2682
mkv_seekhead_entry entries[MAX_SEEKHEAD_ENTRIES]
Definition: matroskaenc.c:76
static int put_flac_codecpriv(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par)
Definition: matroskaenc.c:592
#define MATROSKA_ID_VIDEOFIELDORDER
Definition: matroska.h:122
int64_t start
Definition: avformat.h:1313
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
int sample_rate
Audio only.
Definition: avcodec.h:4146
int ff_flac_write_header(AVIOContext *pb, const uint8_t *extradata, int extradata_size, int last_block)
#define MATROSKA_ID_VIDEOALPHAMODE
Definition: matroska.h:124
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
static int mkv_write_trailer(AVFormatContext *s)
Definition: matroskaenc.c:2446
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:87
Main libavformat public API header.
static int mkv_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
Definition: matroskaenc.c:2651
attribute_deprecated int64_t convergence_duration
Definition: avcodec.h:1562
#define MATROSKA_ID_CUETRACK
Definition: matroska.h:195
#define MATROSKA_ID_SEEKPOSITION
Definition: matroska.h:221
#define MATROSKA_ID_CODECDELAY
Definition: matroska.h:94
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
#define MATROSKA_ID_CHAPTERTIMESTART
Definition: matroska.h:252
common internal api header.
#define MATROSKA_ID_VIDEOCOLORRANGE
Definition: matroska.h:137
enum AVSphericalProjection projection
Projection type.
Definition: spherical.h:86
Utilties for rational number calculation.
static int mkv_write_flush_packet(AVFormatContext *s, AVPacket *pkt)
Definition: matroskaenc.c:2430
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:929
static ebml_master start_ebml_master(AVIOContext *pb, uint32_t elementid, uint64_t expectedsize)
Definition: matroskaenc.c:309
int64_t last_timestamp
Definition: matroskaenc.c:100
Stereoscopic video.
Views are packed per column.
Definition: stereo3d.h:141
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1312
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:33
char * key
Definition: dict.h:86
int den
Denominator.
Definition: rational.h:60
#define MATROSKA_ID_SEGMENT
Definition: matroska.h:53
#define MAX_PCE_SIZE
Maximum size of a PCE including the 3-bit ID_PCE.
Definition: mpeg4audio.h:134
The optional settings (rendering instructions) that immediately follow the timestamp specifier of a W...
Definition: avcodec.h:1389
#define MATROSKA_ID_SEEKHEAD
Definition: matroska.h:60
#define EBML_ID_HEADER
Definition: matroska.h:33
uint32_t elementid
Definition: matroskaenc.c:70
A point in the output bytestream where a decoder can start decoding (i.e.
Definition: avio.h:122
mkv_attachments * attachments
Definition: matroskaenc.c:143
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:465
#define av_free(p)
char * value
Definition: dict.h:87
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
#define MATROSKA_ID_POINTENTRY
Definition: matroska.h:188
int len
static int mkv_write_stereo_mode(AVFormatContext *s, AVIOContext *pb, AVStream *st, int mode, int *h_width, int *h_height)
Definition: matroskaenc.c:991
#define MATROSKA_ID_FILEUID
Definition: matroska.h:247
int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
Add a bitstream filter to a stream.
Definition: utils.c:5572
static void put_ebml_binary(AVIOContext *pb, uint32_t elementid, const void *buf, int size)
Definition: matroskaenc.c:271
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:415
void * priv_data
Format private data.
Definition: avformat.h:1381
#define MATROSKA_ID_CHAPTERUID
Definition: matroska.h:262
char str[22]
Definition: matroska.h:354
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:346
uint32_t bound_left
Distance from the left edge.
Definition: spherical.h:167
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:4078
int64_t relative_pos
relative offset from the position of the cluster containing the block
Definition: matroskaenc.c:86
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:4050
#define MATROSKA_ID_VIDEOCOLORMAXFALL
Definition: matroska.h:142
#define MATROSKA_ID_VIDEODISPLAYUNIT
Definition: matroska.h:120
int channels
Audio only.
Definition: avcodec.h:4142
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1532
static const AVOption options[]
Definition: matroskaenc.c:2698
#define EBML_ID_EBMLMAXSIZELENGTH
Definition: matroska.h:39
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:375
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1468
#define MATROSKA_ID_CHAPSTRING
Definition: matroska.h:255
int sample_rate
Definition: matroskaenc.c:98
#define av_freep(p)
#define MATROSKA_ID_TAGSTRING
Definition: matroska.h:205
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:70
#define MODE_MATROSKAv2
Definition: matroskaenc.c:117
uint32_t av_get_random_seed(void)
Get a seed to use in conjunction with random functions.
Definition: random_seed.c:120
static void put_ebml_string(AVIOContext *pb, uint32_t elementid, const char *str)
Definition: matroskaenc.c:279
AVOutputFormat ff_matroska_muxer
const CodecMime ff_mkv_image_mime_tags[]
Definition: matroska.c:122
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1023
static void put_ebml_sint(AVIOContext *pb, uint32_t elementid, int64_t val)
Definition: matroskaenc.c:251
#define MODE_WEBM
Definition: matroskaenc.c:118
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:4040
static int mkv_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: matroskaenc.c:2356
#define MATROSKA_ID_DURATION
Definition: matroska.h:67
#define MAX_SEEKENTRY_SIZE
2 bytes * 3 for EBML IDs, 3 1-byte EBML lengths, 8 bytes for 64 bit offset, 4 bytes for target EBML I...
Definition: matroskaenc.c:171
static void mkv_deinit(AVFormatContext *s)
Free the members allocated in the mux context.
Definition: matroskaenc.c:391
int stream_index
Definition: avcodec.h:1535
int num_entries
Definition: matroskaenc.c:92
#define EBML_ID_DOCTYPEVERSION
Definition: matroska.h:41
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:905
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
static void end_ebml_master(AVIOContext *pb, ebml_master master)
Definition: matroskaenc.c:319
int64_t segment_offset
Definition: matroskaenc.c:134
static int mkv_write_tag(AVFormatContext *s, AVDictionary *m, uint32_t elementid, unsigned int uid)
Definition: matroskaenc.c:1520
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1000
#define MATROSKA_ID_ATTACHEDFILE
Definition: matroska.h:242
#define MATROSKA_ID_VIDEOCOLOR_GY
Definition: matroska.h:148
enum AVCodecID id
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
static double val(void *priv, double ch)
Definition: aeval.c:76
unsigned MaxFALL
Max average light level per frame (cd/m^2).
This structure stores compressed data.
Definition: avcodec.h:1510
static void mkv_write_field_order(AVIOContext *pb, int mode, enum AVFieldOrder field_order)
Definition: matroskaenc.c:952
mode
Use these values in ebur128_init (or&#39;ed).
Definition: ebur128.h:83
#define MATROSKA_ID_VIDEOCOLOR_RY
Definition: matroska.h:146
uint32_t blocksize
Definition: wv.h:35
static int mkv_query_codec(enum AVCodecID codec_id, int std_compliance)
Definition: matroskaenc.c:2586
static void put_xiph_size(AVIOContext *pb, int size)
Definition: matroskaenc.c:382
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1526
Not part of ABI.
Definition: pixfmt.h:526
#define MATROSKA_ID_VIDEOPIXELWIDTH
Definition: matroska.h:114
static int mkv_assemble_cues(AVStream **streams, AVIOContext *dyn_cp, mkv_cues *cues, mkv_track *tracks, int num_tracks)
Definition: matroskaenc.c:508
int ff_isom_write_avcc(AVIOContext *pb, const uint8_t *data, int len)
Definition: avc.c:108
#define MATROSKA_ID_TRACKAUDIO
Definition: matroska.h:82
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
int(* filler)(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:407
AVIOContext * tags_bc
Definition: matroskaenc.c:127
const CodecTags ff_mkv_codec_tags[]
Definition: matroska.c:29
int avio_printf(AVIOContext *s, const char *fmt,...) av_printf_format(2
Writes a formatted string to the context.
static int ebml_id_size(uint32_t id)
Definition: matroskaenc.c:179
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
#define MATROSKA_ID_DISCARDPADDING
Definition: matroska.h:239
#define FF_PUT_WAV_HEADER_FORCE_WAVEFORMATEX
Tell ff_put_wav_header() to use WAVEFORMATEX even for PCM codecs.
Definition: riff.h:54
static int mkv_write_video_projection(AVFormatContext *s, AVIOContext *pb, AVStream *st)
Definition: matroskaenc.c:882
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191
const char * name
Definition: opengl_enc.c:102
int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1388
static uint8_t tmp[11]
Definition: aes_ctr.c:26