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 typedef struct ebml_master {
61  int64_t pos; ///< absolute offset in the containing AVIOContext where the master's elements start
62  int sizebytes; ///< how many bytes were reserved for the size
63 } ebml_master;
64 
65 typedef struct mkv_seekhead_entry {
66  uint32_t elementid;
67  uint64_t segmentpos;
69 
70 typedef struct mkv_seekhead {
71  int64_t filepos;
72  int64_t segment_offset; ///< the file offset to the beginning of the segment
73  int reserved_size; ///< -1 if appending to file
77 } mkv_seekhead;
78 
79 typedef struct mkv_cuepoint {
80  uint64_t pts;
82  int tracknum;
83  int64_t cluster_pos; ///< file offset of the cluster containing the block
84  int64_t relative_pos; ///< relative offset from the position of the cluster containing the block
85  int64_t duration; ///< duration of the block according to time base
86 } mkv_cuepoint;
87 
88 typedef struct mkv_cues {
89  int64_t segment_offset;
92 } mkv_cues;
93 
94 typedef struct mkv_track {
95  int write_dts;
96  int has_cue;
100  int64_t ts_offset;
101 } mkv_track;
102 
103 typedef struct mkv_attachment {
105  uint32_t fileuid;
107 
108 typedef struct mkv_attachments {
112 
113 #define MODE_MATROSKAv2 0x01
114 #define MODE_WEBM 0x02
115 
116 /** Maximum number of tracks allowed in a Matroska file (with track numbers in
117  * range 1 to 126 (inclusive) */
118 #define MAX_TRACKS 126
119 
120 typedef struct MatroskaMuxContext {
121  const AVClass *class;
122  int mode;
124  int64_t tags_pos;
126  int64_t info_pos;
128  int64_t tracks_pos;
130  int64_t segment_offset;
132  int64_t cluster_pos; ///< file offset of the current cluster
133  int64_t cluster_pts;
135  int64_t duration;
140 
142 
145 
148  int64_t cues_pos;
150  int is_dash;
152  int is_live;
154 
157 
158  int64_t last_track_timestamp[MAX_TRACKS];
159 
162 
165 
166 /** 2 bytes * 7 for EBML IDs, 7 1-byte EBML lengths, 6 1-byte uint,
167  * 8 byte for "matroska" doctype string */
168 #define MAX_EBML_HEADER_SIZE 35
169 
170 /** 2 bytes * 3 for EBML IDs, 3 1-byte EBML lengths, 8 bytes for 64 bit
171  * offset, 4 bytes for target EBML ID */
172 #define MAX_SEEKENTRY_SIZE 21
173 
174 /** per-cuepoint-track - 5 1-byte EBML IDs, 5 1-byte EBML sizes, 3 8-byte uint max
175  * and one 1-byte uint for the track number (this assumes MAX_TRACKS to be <= 255) */
176 #define MAX_CUETRACKPOS_SIZE 35
177 
178 /** per-cuepoint - 1 1-byte EBML ID, 1 1-byte EBML size, 8-byte uint max */
179 #define MAX_CUEPOINT_CONTENT_SIZE(num_tracks) 10 + MAX_CUETRACKPOS_SIZE * num_tracks
180 
181 /** Seek preroll value for opus */
182 #define OPUS_SEEK_PREROLL 80000000
183 
184 static int ebml_id_size(uint32_t id)
185 {
186  return (av_log2(id + 1) - 1) / 7 + 1;
187 }
188 
189 static void put_ebml_id(AVIOContext *pb, uint32_t id)
190 {
191  int i = ebml_id_size(id);
192  while (i--)
193  avio_w8(pb, (uint8_t)(id >> (i * 8)));
194 }
195 
196 /**
197  * Write an EBML size meaning "unknown size".
198  *
199  * @param bytes The number of bytes the size should occupy (maximum: 8).
200  */
201 static void put_ebml_size_unknown(AVIOContext *pb, int bytes)
202 {
203  av_assert0(bytes <= 8);
204  avio_w8(pb, 0x1ff >> bytes);
205  ffio_fill(pb, 0xff, bytes - 1);
206 }
207 
208 /**
209  * Calculate how many bytes are needed to represent a given number in EBML.
210  */
211 static int ebml_num_size(uint64_t num)
212 {
213  int bytes = 1;
214  while ((num + 1) >> bytes * 7)
215  bytes++;
216  return bytes;
217 }
218 
219 /**
220  * Write a number in EBML variable length format.
221  *
222  * @param bytes The number of bytes that need to be used to write the number.
223  * If zero, any number of bytes can be used.
224  */
225 static void put_ebml_num(AVIOContext *pb, uint64_t num, int bytes)
226 {
227  int i, needed_bytes = ebml_num_size(num);
228 
229  // sizes larger than this are currently undefined in EBML
230  av_assert0(num < (1ULL << 56) - 1);
231 
232  if (bytes == 0)
233  // don't care how many bytes are used, so use the min
234  bytes = needed_bytes;
235  // the bytes needed to write the given size would exceed the bytes
236  // that we need to use, so write unknown size. This shouldn't happen.
237  av_assert0(bytes >= needed_bytes);
238 
239  num |= 1ULL << bytes * 7;
240  for (i = bytes - 1; i >= 0; i--)
241  avio_w8(pb, (uint8_t)(num >> i * 8));
242 }
243 
244 static void put_ebml_uint(AVIOContext *pb, uint32_t elementid, uint64_t val)
245 {
246  int i, bytes = 1;
247  uint64_t tmp = val;
248  while (tmp >>= 8)
249  bytes++;
250 
251  put_ebml_id(pb, elementid);
252  put_ebml_num(pb, bytes, 0);
253  for (i = bytes - 1; i >= 0; i--)
254  avio_w8(pb, (uint8_t)(val >> i * 8));
255 }
256 
257 static void put_ebml_sint(AVIOContext *pb, uint32_t elementid, int64_t val)
258 {
259  int i, bytes = 1;
260  uint64_t tmp = 2*(val < 0 ? val^-1 : val);
261 
262  while (tmp>>=8) bytes++;
263 
264  put_ebml_id(pb, elementid);
265  put_ebml_num(pb, bytes, 0);
266  for (i = bytes - 1; i >= 0; i--)
267  avio_w8(pb, (uint8_t)(val >> i * 8));
268 }
269 
270 static void put_ebml_float(AVIOContext *pb, uint32_t elementid, double val)
271 {
272  put_ebml_id(pb, elementid);
273  put_ebml_num(pb, 8, 0);
274  avio_wb64(pb, av_double2int(val));
275 }
276 
277 static void put_ebml_binary(AVIOContext *pb, uint32_t elementid,
278  const void *buf, int size)
279 {
280  put_ebml_id(pb, elementid);
281  put_ebml_num(pb, size, 0);
282  avio_write(pb, buf, size);
283 }
284 
285 static void put_ebml_string(AVIOContext *pb, uint32_t elementid,
286  const char *str)
287 {
288  put_ebml_binary(pb, elementid, str, strlen(str));
289 }
290 
291 /**
292  * Write a void element of a given size. Useful for reserving space in
293  * the file to be written to later.
294  *
295  * @param size The number of bytes to reserve, which must be at least 2.
296  */
297 static void put_ebml_void(AVIOContext *pb, uint64_t size)
298 {
299  int64_t currentpos = avio_tell(pb);
300 
301  av_assert0(size >= 2);
302 
304  // we need to subtract the length needed to store the size from the
305  // size we need to reserve so 2 cases, we use 8 bytes to store the
306  // size if possible, 1 byte otherwise
307  if (size < 10)
308  put_ebml_num(pb, size - 2, 0);
309  else
310  put_ebml_num(pb, size - 9, 8);
311  ffio_fill(pb, 0, currentpos + size - avio_tell(pb));
312 }
313 
314 static ebml_master start_ebml_master(AVIOContext *pb, uint32_t elementid,
315  uint64_t expectedsize)
316 {
317  int bytes = expectedsize ? ebml_num_size(expectedsize) : 8;
318 
319  put_ebml_id(pb, elementid);
320  put_ebml_size_unknown(pb, bytes);
321  return (ebml_master) { avio_tell(pb), bytes };
322 }
323 
325 {
326  int64_t pos = avio_tell(pb);
327 
328  if (avio_seek(pb, master.pos - master.sizebytes, SEEK_SET) < 0)
329  return;
330  put_ebml_num(pb, pos - master.pos, master.sizebytes);
331  avio_seek(pb, pos, SEEK_SET);
332 }
333 
335  uint32_t elementid)
336 {
337  int ret;
338 
339  if ((ret = avio_open_dyn_buf(dyn_cp)) < 0)
340  return ret;
341 
342  put_ebml_id(pb, elementid);
343  if (mkv->write_crc)
344  put_ebml_void(*dyn_cp, 6); /* Reserve space for CRC32 so position/size calculations using avio_tell() take it into account */
345 
346  return 0;
347 }
348 
350 {
351  uint8_t *buf, crc[4];
352  int size, skip = 0;
353 
354  size = avio_close_dyn_buf(*dyn_cp, &buf);
355  put_ebml_num(pb, size, 0);
356  if (mkv->write_crc) {
357  skip = 6; /* Skip reserved 6-byte long void element from the dynamic buffer. */
358  AV_WL32(crc, av_crc(av_crc_get_table(AV_CRC_32_IEEE_LE), UINT32_MAX, buf + skip, size - skip) ^ UINT32_MAX);
359  put_ebml_binary(pb, EBML_ID_CRC32, crc, sizeof(crc));
360  }
361  avio_write(pb, buf + skip, size - skip);
362 
363  av_free(buf);
364  *dyn_cp = NULL;
365 }
366 
367 /**
368 * Complete ebml master without destroying the buffer, allowing for later updates
369 */
371  int64_t *pos)
372 {
373  uint8_t *buf;
374  int size = avio_get_dyn_buf(*dyn_cp, &buf);
375 
376  *pos = avio_tell(pb);
377 
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  */
391 static void mkv_free(MatroskaMuxContext *mkv) {
392  uint8_t* buf;
393  if (mkv->cluster_bc) {
394  avio_close_dyn_buf(mkv->cluster_bc, &buf);
395  av_free(buf);
396  }
397  if (mkv->info_bc) {
398  avio_close_dyn_buf(mkv->info_bc, &buf);
399  av_free(buf);
400  }
401  if (mkv->tracks_bc) {
402  avio_close_dyn_buf(mkv->tracks_bc, &buf);
403  av_free(buf);
404  }
405  if (mkv->tags_bc) {
406  avio_close_dyn_buf(mkv->tags_bc, &buf);
407  av_free(buf);
408  }
409  if (mkv->seekhead) {
410  av_freep(&mkv->seekhead->entries);
411  av_freep(&mkv->seekhead);
412  }
413  if (mkv->cues) {
414  av_freep(&mkv->cues->entries);
415  av_freep(&mkv->cues);
416  }
417  if (mkv->attachments) {
418  av_freep(&mkv->attachments->entries);
419  av_freep(&mkv->attachments);
420  }
421  av_freep(&mkv->tracks);
422  av_freep(&mkv->stream_durations);
424 }
425 
426 /**
427  * Initialize a mkv_seekhead element to be ready to index level 1 Matroska
428  * elements. If a maximum number of elements is specified, enough space
429  * will be reserved at the current file location to write a seek head of
430  * that size.
431  *
432  * @param segment_offset The absolute offset to the position in the file
433  * where the segment begins.
434  * @param numelements The maximum number of elements that will be indexed
435  * by this seek head, 0 if unlimited.
436  */
437 static mkv_seekhead *mkv_start_seekhead(AVIOContext *pb, int64_t segment_offset,
438  int numelements)
439 {
440  mkv_seekhead *new_seekhead = av_mallocz(sizeof(mkv_seekhead));
441  if (!new_seekhead)
442  return NULL;
443 
444  new_seekhead->segment_offset = segment_offset;
445 
446  if (numelements > 0) {
447  new_seekhead->filepos = avio_tell(pb);
448  // 21 bytes max for a seek entry, 10 bytes max for the SeekHead ID
449  // and size, 6 bytes for a CRC32 element, and 3 bytes to guarantee
450  // that an EBML void element will fit afterwards
451  new_seekhead->reserved_size = numelements * MAX_SEEKENTRY_SIZE + 19;
452  new_seekhead->max_entries = numelements;
453  put_ebml_void(pb, new_seekhead->reserved_size);
454  }
455  return new_seekhead;
456 }
457 
458 static int mkv_add_seekhead_entry(mkv_seekhead *seekhead, uint32_t elementid, uint64_t filepos)
459 {
460  mkv_seekhead_entry *entries = seekhead->entries;
461 
462  // don't store more elements than we reserved space for
463  if (seekhead->max_entries > 0 && seekhead->max_entries <= seekhead->num_entries)
464  return -1;
465 
466  entries = av_realloc_array(entries, seekhead->num_entries + 1, sizeof(mkv_seekhead_entry));
467  if (!entries)
468  return AVERROR(ENOMEM);
469  seekhead->entries = entries;
470 
471  seekhead->entries[seekhead->num_entries].elementid = elementid;
472  seekhead->entries[seekhead->num_entries++].segmentpos = filepos - seekhead->segment_offset;
473 
474  return 0;
475 }
476 
477 /**
478  * Write the seek head to the file and free it. If a maximum number of
479  * elements was specified to mkv_start_seekhead(), the seek head will
480  * be written at the location reserved for it. Otherwise, it is written
481  * at the current location in the file.
482  *
483  * @return The file offset where the seekhead was written,
484  * -1 if an error occurred.
485  */
487 {
488  AVIOContext *dyn_cp;
489  mkv_seekhead *seekhead = mkv->seekhead;
490  ebml_master seekentry;
491  int64_t currentpos;
492  int i;
493 
494  currentpos = avio_tell(pb);
495 
496  if (seekhead->reserved_size > 0) {
497  if (avio_seek(pb, seekhead->filepos, SEEK_SET) < 0) {
498  currentpos = -1;
499  goto fail;
500  }
501  }
502 
503  if (start_ebml_master_crc32(pb, &dyn_cp, mkv, MATROSKA_ID_SEEKHEAD) < 0) {
504  currentpos = -1;
505  goto fail;
506  }
507 
508  for (i = 0; i < seekhead->num_entries; i++) {
509  mkv_seekhead_entry *entry = &seekhead->entries[i];
510 
512 
514  put_ebml_num(dyn_cp, ebml_id_size(entry->elementid), 0);
515  put_ebml_id(dyn_cp, entry->elementid);
516 
518  end_ebml_master(dyn_cp, seekentry);
519  }
520  end_ebml_master_crc32(pb, &dyn_cp, mkv);
521 
522  if (seekhead->reserved_size > 0) {
523  uint64_t remaining = seekhead->filepos + seekhead->reserved_size - avio_tell(pb);
524  put_ebml_void(pb, remaining);
525  avio_seek(pb, currentpos, SEEK_SET);
526 
527  currentpos = seekhead->filepos;
528  }
529 fail:
530  av_freep(&mkv->seekhead->entries);
531  av_freep(&mkv->seekhead);
532 
533  return currentpos;
534 }
535 
536 static mkv_cues *mkv_start_cues(int64_t segment_offset)
537 {
538  mkv_cues *cues = av_mallocz(sizeof(mkv_cues));
539  if (!cues)
540  return NULL;
541 
542  cues->segment_offset = segment_offset;
543  return cues;
544 }
545 
546 static int mkv_add_cuepoint(mkv_cues *cues, int stream, int tracknum, int64_t ts,
547  int64_t cluster_pos, int64_t relative_pos, int64_t duration)
548 {
549  mkv_cuepoint *entries = cues->entries;
550 
551  if (ts < 0)
552  return 0;
553 
554  entries = av_realloc_array(entries, cues->num_entries + 1, sizeof(mkv_cuepoint));
555  if (!entries)
556  return AVERROR(ENOMEM);
557  cues->entries = entries;
558 
559  cues->entries[cues->num_entries].pts = ts;
560  cues->entries[cues->num_entries].stream_idx = stream;
561  cues->entries[cues->num_entries].tracknum = tracknum;
562  cues->entries[cues->num_entries].cluster_pos = cluster_pos - cues->segment_offset;
563  cues->entries[cues->num_entries].relative_pos = relative_pos;
564  cues->entries[cues->num_entries++].duration = duration;
565 
566  return 0;
567 }
568 
569 static int64_t mkv_write_cues(AVFormatContext *s, mkv_cues *cues, mkv_track *tracks, int num_tracks)
570 {
571  MatroskaMuxContext *mkv = s->priv_data;
572  AVIOContext *dyn_cp, *pb = s->pb;
573  int64_t currentpos;
574  int i, j, ret;
575 
576  currentpos = avio_tell(pb);
577  ret = start_ebml_master_crc32(pb, &dyn_cp, mkv, MATROSKA_ID_CUES);
578  if (ret < 0)
579  return ret;
580 
581  for (i = 0; i < cues->num_entries; i++) {
582  ebml_master cuepoint, track_positions;
583  mkv_cuepoint *entry = &cues->entries[i];
584  uint64_t pts = entry->pts;
585  int ctp_nb = 0;
586 
587  // Calculate the number of entries, so we know the element size
588  for (j = 0; j < num_tracks; j++)
589  tracks[j].has_cue = 0;
590  for (j = 0; j < cues->num_entries - i && entry[j].pts == pts; j++) {
591  int tracknum = entry[j].stream_idx;
592  av_assert0(tracknum>=0 && tracknum<num_tracks);
593  if (tracks[tracknum].has_cue && s->streams[tracknum]->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE)
594  continue;
595  tracks[tracknum].has_cue = 1;
596  ctp_nb ++;
597  }
598 
600  put_ebml_uint(dyn_cp, MATROSKA_ID_CUETIME, pts);
601 
602  // put all the entries from different tracks that have the exact same
603  // timestamp into the same CuePoint
604  for (j = 0; j < num_tracks; j++)
605  tracks[j].has_cue = 0;
606  for (j = 0; j < cues->num_entries - i && entry[j].pts == pts; j++) {
607  int tracknum = entry[j].stream_idx;
608  av_assert0(tracknum>=0 && tracknum<num_tracks);
609  if (tracks[tracknum].has_cue && s->streams[tracknum]->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE)
610  continue;
611  tracks[tracknum].has_cue = 1;
613  put_ebml_uint(dyn_cp, MATROSKA_ID_CUETRACK , entry[j].tracknum );
614  put_ebml_uint(dyn_cp, MATROSKA_ID_CUECLUSTERPOSITION , entry[j].cluster_pos);
615  put_ebml_uint(dyn_cp, MATROSKA_ID_CUERELATIVEPOSITION, entry[j].relative_pos);
616  if (entry[j].duration != -1)
617  put_ebml_uint(dyn_cp, MATROSKA_ID_CUEDURATION , entry[j].duration);
618  end_ebml_master(dyn_cp, track_positions);
619  }
620  i += j - 1;
621  end_ebml_master(dyn_cp, cuepoint);
622  }
623  end_ebml_master_crc32(pb, &dyn_cp, mkv);
624 
625  return currentpos;
626 }
627 
629 {
630  const uint8_t *header_start[3];
631  int header_len[3];
632  int first_header_size;
633  int j;
634 
635  if (par->codec_id == AV_CODEC_ID_VORBIS)
636  first_header_size = 30;
637  else
638  first_header_size = 42;
639 
641  first_header_size, header_start, header_len) < 0) {
642  av_log(s, AV_LOG_ERROR, "Extradata corrupt.\n");
643  return -1;
644  }
645 
646  avio_w8(pb, 2); // number packets - 1
647  for (j = 0; j < 2; j++) {
648  put_xiph_size(pb, header_len[j]);
649  }
650  for (j = 0; j < 3; j++)
651  avio_write(pb, header_start[j], header_len[j]);
652 
653  return 0;
654 }
655 
657 {
658  if (par->extradata && par->extradata_size == 2)
659  avio_write(pb, par->extradata, 2);
660  else
661  avio_wl16(pb, 0x403); // fallback to the version mentioned in matroska specs
662  return 0;
663 }
664 
666  AVIOContext *pb, AVCodecParameters *par)
667 {
668  int write_comment = (par->channel_layout &&
669  !(par->channel_layout & ~0x3ffffULL) &&
671  int ret = ff_flac_write_header(pb, par->extradata, par->extradata_size,
672  !write_comment);
673 
674  if (ret < 0)
675  return ret;
676 
677  if (write_comment) {
678  const char *vendor = (s->flags & AVFMT_FLAG_BITEXACT) ?
679  "Lavf" : LIBAVFORMAT_IDENT;
680  AVDictionary *dict = NULL;
681  uint8_t buf[32], *data, *p;
682  int64_t len;
683 
684  snprintf(buf, sizeof(buf), "0x%"PRIx64, par->channel_layout);
685  av_dict_set(&dict, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", buf, 0);
686 
687  len = ff_vorbiscomment_length(dict, vendor, NULL, 0);
688  if (len >= ((1<<24) - 4)) {
689  av_dict_free(&dict);
690  return AVERROR(EINVAL);
691  }
692 
693  data = av_malloc(len + 4);
694  if (!data) {
695  av_dict_free(&dict);
696  return AVERROR(ENOMEM);
697  }
698 
699  data[0] = 0x84;
700  AV_WB24(data + 1, len);
701 
702  p = data + 4;
703  ff_vorbiscomment_write(&p, &dict, vendor, NULL, 0);
704 
705  avio_write(pb, data, len + 4);
706 
707  av_freep(&data);
708  av_dict_free(&dict);
709  }
710 
711  return 0;
712 }
713 
714 static int get_aac_sample_rates(AVFormatContext *s, uint8_t *extradata, int extradata_size,
715  int *sample_rate, int *output_sample_rate)
716 {
717  MPEG4AudioConfig mp4ac;
718  int ret;
719 
720  ret = avpriv_mpeg4audio_get_config(&mp4ac, extradata,
721  extradata_size * 8, 1);
722  /* Don't abort if the failure is because of missing extradata. Assume in that
723  * case a bitstream filter will provide the muxer with the extradata in the
724  * first packet.
725  * Abort however if s->pb is not seekable, as we would not be able to seek back
726  * to write the sample rate elements once the extradata shows up, anyway. */
727  if (ret < 0 && (extradata_size || !(s->pb->seekable & AVIO_SEEKABLE_NORMAL))) {
728  av_log(s, AV_LOG_ERROR,
729  "Error parsing AAC extradata, unable to determine samplerate.\n");
730  return AVERROR(EINVAL);
731  }
732 
733  if (ret < 0) {
734  /* This will only happen when this function is called while writing the
735  * header and no extradata is available. The space for this element has
736  * to be reserved for when this function is called again after the
737  * extradata shows up in the first packet, as there's no way to know if
738  * output_sample_rate will be different than sample_rate or not. */
739  *output_sample_rate = *sample_rate;
740  } else {
741  *sample_rate = mp4ac.sample_rate;
742  *output_sample_rate = mp4ac.ext_sample_rate;
743  }
744  return 0;
745 }
746 
748  AVCodecParameters *par,
749  AVIOContext *dyn_cp)
750 {
751  switch (par->codec_id) {
752  case AV_CODEC_ID_VORBIS:
753  case AV_CODEC_ID_THEORA:
754  return put_xiph_codecpriv(s, dyn_cp, par);
755  case AV_CODEC_ID_FLAC:
756  return put_flac_codecpriv(s, dyn_cp, par);
757  case AV_CODEC_ID_WAVPACK:
758  return put_wv_codecpriv(dyn_cp, par);
759  case AV_CODEC_ID_H264:
760  return ff_isom_write_avcc(dyn_cp, par->extradata,
761  par->extradata_size);
762  case AV_CODEC_ID_HEVC:
763  ff_isom_write_hvcc(dyn_cp, par->extradata,
764  par->extradata_size, 0);
765  return 0;
766  case AV_CODEC_ID_AV1:
767  if (par->extradata_size)
768  return ff_isom_write_av1c(dyn_cp, par->extradata,
769  par->extradata_size);
770  else
771  put_ebml_void(pb, 4 + 3);
772  break;
773  case AV_CODEC_ID_ALAC:
774  if (par->extradata_size < 36) {
775  av_log(s, AV_LOG_ERROR,
776  "Invalid extradata found, ALAC expects a 36-byte "
777  "QuickTime atom.");
778  return AVERROR_INVALIDDATA;
779  } else
780  avio_write(dyn_cp, par->extradata + 12,
781  par->extradata_size - 12);
782  break;
783  case AV_CODEC_ID_AAC:
784  if (par->extradata_size)
785  avio_write(dyn_cp, par->extradata, par->extradata_size);
786  else
787  put_ebml_void(pb, MAX_PCE_SIZE + 2 + 4);
788  break;
789  default:
790  if (par->codec_id == AV_CODEC_ID_PRORES &&
792  avio_wl32(dyn_cp, par->codec_tag);
793  } else if (par->extradata_size && par->codec_id != AV_CODEC_ID_TTA)
794  avio_write(dyn_cp, par->extradata, par->extradata_size);
795  }
796 
797  return 0;
798 }
799 
801  AVCodecParameters *par,
802  int native_id, int qt_id)
803 {
804  AVIOContext *dyn_cp;
805  uint8_t *codecpriv;
806  int ret, codecpriv_size;
807 
808  ret = avio_open_dyn_buf(&dyn_cp);
809  if (ret < 0)
810  return ret;
811 
812  if (native_id) {
813  ret = mkv_write_native_codecprivate(s, pb, par, dyn_cp);
814  } else if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
815  if (qt_id) {
816  if (!par->codec_tag)
818  par->codec_id);
821  ) {
822  int i;
823  avio_wb32(dyn_cp, 0x5a + par->extradata_size);
824  avio_wl32(dyn_cp, par->codec_tag);
825  for(i = 0; i < 0x5a - 8; i++)
826  avio_w8(dyn_cp, 0);
827  }
828  avio_write(dyn_cp, par->extradata, par->extradata_size);
829  } else {
831  av_log(s, AV_LOG_WARNING, "codec %s is not supported by this format\n",
832  avcodec_get_name(par->codec_id));
833 
834  if (!par->codec_tag)
836  par->codec_id);
837  if (!par->codec_tag && par->codec_id != AV_CODEC_ID_RAWVIDEO) {
838  av_log(s, AV_LOG_ERROR, "No bmp codec tag found for codec %s\n",
839  avcodec_get_name(par->codec_id));
840  ret = AVERROR(EINVAL);
841  }
842 
843  ff_put_bmp_header(dyn_cp, par, 0, 0);
844  }
845  } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
846  unsigned int tag;
848  if (!tag) {
849  av_log(s, AV_LOG_ERROR, "No wav codec tag found for codec %s\n",
850  avcodec_get_name(par->codec_id));
851  ret = AVERROR(EINVAL);
852  }
853  if (!par->codec_tag)
854  par->codec_tag = tag;
855 
857  }
858 
859  codecpriv_size = avio_close_dyn_buf(dyn_cp, &codecpriv);
860  if (codecpriv_size)
862  codecpriv_size);
863  av_free(codecpriv);
864  return ret;
865 }
866 
868  AVIOContext *dyn_cp;
869  uint8_t *colorinfo_ptr;
870  int side_data_size = 0;
871  int ret, colorinfo_size;
872  const uint8_t *side_data;
873 
874  ret = avio_open_dyn_buf(&dyn_cp);
875  if (ret < 0)
876  return ret;
877 
878  if (par->color_trc != AVCOL_TRC_UNSPECIFIED &&
879  par->color_trc < AVCOL_TRC_NB) {
881  par->color_trc);
882  }
883  if (par->color_space != AVCOL_SPC_UNSPECIFIED &&
884  par->color_space < AVCOL_SPC_NB) {
886  }
888  par->color_primaries < AVCOL_PRI_NB) {
890  }
891  if (par->color_range != AVCOL_RANGE_UNSPECIFIED &&
892  par->color_range < AVCOL_RANGE_NB) {
894  }
897  int xpos, ypos;
898 
899  avcodec_enum_to_chroma_pos(&xpos, &ypos, par->chroma_location);
900  put_ebml_uint(dyn_cp, MATROSKA_ID_VIDEOCOLORCHROMASITINGHORZ, (xpos >> 7) + 1);
901  put_ebml_uint(dyn_cp, MATROSKA_ID_VIDEOCOLORCHROMASITINGVERT, (ypos >> 7) + 1);
902  }
903 
905  &side_data_size);
906  if (side_data_size) {
907  const AVContentLightMetadata *metadata =
908  (const AVContentLightMetadata*)side_data;
911  }
912 
914  &side_data_size);
915  if (side_data_size == sizeof(AVMasteringDisplayMetadata)) {
916  ebml_master meta_element = start_ebml_master(
918  const AVMasteringDisplayMetadata *metadata =
919  (const AVMasteringDisplayMetadata*)side_data;
920  if (metadata->has_primaries) {
922  av_q2d(metadata->display_primaries[0][0]));
924  av_q2d(metadata->display_primaries[0][1]));
926  av_q2d(metadata->display_primaries[1][0]));
928  av_q2d(metadata->display_primaries[1][1]));
930  av_q2d(metadata->display_primaries[2][0]));
932  av_q2d(metadata->display_primaries[2][1]));
934  av_q2d(metadata->white_point[0]));
936  av_q2d(metadata->white_point[1]));
937  }
938  if (metadata->has_luminance) {
940  av_q2d(metadata->max_luminance));
942  av_q2d(metadata->min_luminance));
943  }
944  end_ebml_master(dyn_cp, meta_element);
945  }
946 
947  colorinfo_size = avio_close_dyn_buf(dyn_cp, &colorinfo_ptr);
948  if (colorinfo_size) {
949  ebml_master colorinfo = start_ebml_master(pb, MATROSKA_ID_VIDEOCOLOR, colorinfo_size);
950  avio_write(pb, colorinfo_ptr, colorinfo_size);
951  end_ebml_master(pb, colorinfo);
952  }
953  av_free(colorinfo_ptr);
954  return 0;
955 }
956 
958  AVStream *st)
959 {
960  AVIOContext b;
961  AVIOContext *dyn_cp;
962  int side_data_size = 0;
963  int ret, projection_size;
964  uint8_t *projection_ptr;
965  uint8_t private[20];
966 
967  const AVSphericalMapping *spherical =
969  &side_data_size);
970 
971  if (!side_data_size)
972  return 0;
973 
974  ret = avio_open_dyn_buf(&dyn_cp);
975  if (ret < 0)
976  return ret;
977 
978  switch (spherical->projection) {
982  break;
984  ffio_init_context(&b, private, 20, 1, NULL, NULL, NULL, NULL);
987  avio_wb32(&b, 0); // version + flags
988  avio_wb32(&b, spherical->bound_top);
989  avio_wb32(&b, spherical->bound_bottom);
990  avio_wb32(&b, spherical->bound_left);
991  avio_wb32(&b, spherical->bound_right);
993  private, avio_tell(&b));
994  break;
996  ffio_init_context(&b, private, 12, 1, NULL, NULL, NULL, NULL);
999  avio_wb32(&b, 0); // version + flags
1000  avio_wb32(&b, 0); // layout
1001  avio_wb32(&b, spherical->padding);
1003  private, avio_tell(&b));
1004  break;
1005  default:
1006  av_log(s, AV_LOG_WARNING, "Unknown projection type\n");
1007  goto end;
1008  }
1009 
1010  if (spherical->yaw)
1012  (double) spherical->yaw / (1 << 16));
1013  if (spherical->pitch)
1015  (double) spherical->pitch / (1 << 16));
1016  if (spherical->roll)
1018  (double) spherical->roll / (1 << 16));
1019 
1020 end:
1021  projection_size = avio_close_dyn_buf(dyn_cp, &projection_ptr);
1022  if (projection_size) {
1023  ebml_master projection = start_ebml_master(pb,
1025  projection_size);
1026  avio_write(pb, projection_ptr, projection_size);
1027  end_ebml_master(pb, projection);
1028  }
1029  av_freep(&projection_ptr);
1030 
1031  return 0;
1032 }
1033 
1035  enum AVFieldOrder field_order)
1036 {
1037  switch (field_order) {
1038  case AV_FIELD_UNKNOWN:
1039  break;
1040  case AV_FIELD_PROGRESSIVE:
1043  break;
1044  case AV_FIELD_TT:
1045  case AV_FIELD_BB:
1046  case AV_FIELD_TB:
1047  case AV_FIELD_BT:
1050  if (mode != MODE_WEBM) {
1051  switch (field_order) {
1052  case AV_FIELD_TT:
1055  break;
1056  case AV_FIELD_BB:
1059  break;
1060  case AV_FIELD_TB:
1063  break;
1064  case AV_FIELD_BT:
1067  break;
1068  }
1069  }
1070  }
1071 }
1072 
1074  AVStream *st, int mode, int *h_width, int *h_height)
1075 {
1076  int i;
1077  int ret = 0;
1080 
1081  *h_width = 1;
1082  *h_height = 1;
1083  // convert metadata into proper side data and add it to the stream
1084  if ((tag = av_dict_get(st->metadata, "stereo_mode", NULL, 0)) ||
1085  (tag = av_dict_get( s->metadata, "stereo_mode", NULL, 0))) {
1086  int stereo_mode = atoi(tag->value);
1087 
1088  for (i=0; i<MATROSKA_VIDEO_STEREOMODE_TYPE_NB; i++)
1089  if (!strcmp(tag->value, ff_matroska_video_stereo_mode[i])){
1090  stereo_mode = i;
1091  break;
1092  }
1093 
1094  if (stereo_mode < MATROSKA_VIDEO_STEREOMODE_TYPE_NB &&
1095  stereo_mode != 10 && stereo_mode != 12) {
1096  int ret = ff_mkv_stereo3d_conv(st, stereo_mode);
1097  if (ret < 0)
1098  return ret;
1099  }
1100  }
1101 
1102  // iterate to find the stereo3d side data
1103  for (i = 0; i < st->nb_side_data; i++) {
1104  AVPacketSideData sd = st->side_data[i];
1105  if (sd.type == AV_PKT_DATA_STEREO3D) {
1106  AVStereo3D *stereo = (AVStereo3D *)sd.data;
1107 
1108  switch (stereo->type) {
1109  case AV_STEREO3D_2D:
1111  break;
1113  format = (stereo->flags & AV_STEREO3D_FLAG_INVERT)
1116  *h_width = 2;
1117  break;
1118  case AV_STEREO3D_TOPBOTTOM:
1120  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
1121  format--;
1122  *h_height = 2;
1123  break;
1126  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
1127  format--;
1128  break;
1129  case AV_STEREO3D_LINES:
1131  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
1132  format--;
1133  *h_height = 2;
1134  break;
1135  case AV_STEREO3D_COLUMNS:
1137  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
1138  format--;
1139  *h_width = 2;
1140  break;
1143  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
1144  format++;
1145  break;
1146  }
1147  break;
1148  }
1149  }
1150 
1151  if (format == MATROSKA_VIDEO_STEREOMODE_TYPE_NB)
1152  return ret;
1153 
1154  // if webm, do not write unsupported modes
1155  if ((mode == MODE_WEBM &&
1158  || format >= MATROSKA_VIDEO_STEREOMODE_TYPE_NB) {
1159  av_log(s, AV_LOG_ERROR,
1160  "The specified stereo mode is not valid.\n");
1162  return AVERROR(EINVAL);
1163  }
1164 
1165  // write StereoMode if format is valid
1167 
1168  return ret;
1169 }
1170 
1172  int i, AVIOContext *pb, int default_stream_exists)
1173 {
1174  AVStream *st = s->streams[i];
1175  AVCodecParameters *par = st->codecpar;
1176  ebml_master subinfo, track;
1177  int native_id = 0;
1178  int qt_id = 0;
1180  int sample_rate = par->sample_rate;
1181  int output_sample_rate = 0;
1182  int display_width_div = 1;
1183  int display_height_div = 1;
1184  int j, ret;
1186 
1187  if (par->codec_type == AVMEDIA_TYPE_ATTACHMENT) {
1188  mkv->have_attachments = 1;
1189  return 0;
1190  }
1191 
1192  if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
1193  if (!bit_depth && par->codec_id != AV_CODEC_ID_ADPCM_G726) {
1194  if (par->bits_per_raw_sample)
1195  bit_depth = par->bits_per_raw_sample;
1196  else
1197  bit_depth = av_get_bytes_per_sample(par->format) << 3;
1198  }
1199  if (!bit_depth)
1200  bit_depth = par->bits_per_coded_sample;
1201  }
1202 
1203  if (par->codec_id == AV_CODEC_ID_AAC) {
1204  ret = get_aac_sample_rates(s, par->extradata, par->extradata_size, &sample_rate,
1205  &output_sample_rate);
1206  if (ret < 0)
1207  return ret;
1208  }
1209 
1210  track = start_ebml_master(pb, MATROSKA_ID_TRACKENTRY, 0);
1212  mkv->is_dash ? mkv->dash_track_number : i + 1);
1214  mkv->is_dash ? mkv->dash_track_number : i + 1);
1215  put_ebml_uint (pb, MATROSKA_ID_TRACKFLAGLACING , 0); // no lacing (yet)
1216 
1217  if ((tag = av_dict_get(st->metadata, "title", NULL, 0)))
1219  tag = av_dict_get(st->metadata, "language", NULL, 0);
1220  if (mkv->mode != MODE_WEBM || par->codec_id != AV_CODEC_ID_WEBVTT) {
1221  put_ebml_string(pb, MATROSKA_ID_TRACKLANGUAGE, tag && tag->value ? tag->value:"und");
1222  } else if (tag && tag->value) {
1224  }
1225 
1226  // The default value for TRACKFLAGDEFAULT is 1, so add element
1227  // if we need to clear it.
1228  if (default_stream_exists && !(st->disposition & AV_DISPOSITION_DEFAULT))
1230 
1233 
1234  if (mkv->mode == MODE_WEBM) {
1235  const char *codec_id;
1236  if (par->codec_type != AVMEDIA_TYPE_SUBTITLE) {
1237  for (j = 0; ff_webm_codec_tags[j].id != AV_CODEC_ID_NONE; j++) {
1238  if (ff_webm_codec_tags[j].id == par->codec_id) {
1239  codec_id = ff_webm_codec_tags[j].str;
1240  native_id = 1;
1241  break;
1242  }
1243  }
1244  } else if (par->codec_id == AV_CODEC_ID_WEBVTT) {
1246  codec_id = "D_WEBVTT/CAPTIONS";
1247  native_id = MATROSKA_TRACK_TYPE_SUBTITLE;
1248  } else if (st->disposition & AV_DISPOSITION_DESCRIPTIONS) {
1249  codec_id = "D_WEBVTT/DESCRIPTIONS";
1250  native_id = MATROSKA_TRACK_TYPE_METADATA;
1251  } else if (st->disposition & AV_DISPOSITION_METADATA) {
1252  codec_id = "D_WEBVTT/METADATA";
1253  native_id = MATROSKA_TRACK_TYPE_METADATA;
1254  } else {
1255  codec_id = "D_WEBVTT/SUBTITLES";
1256  native_id = MATROSKA_TRACK_TYPE_SUBTITLE;
1257  }
1258  }
1259 
1260  if (!native_id) {
1261  av_log(s, AV_LOG_ERROR,
1262  "Only VP8 or VP9 or AV1 video and Vorbis or Opus audio and WebVTT subtitles are supported for WebM.\n");
1263  return AVERROR(EINVAL);
1264  }
1265 
1266  put_ebml_string(pb, MATROSKA_ID_CODECID, codec_id);
1267  } else {
1268  // look for a codec ID string specific to mkv to use,
1269  // if none are found, use AVI codes
1270  if (par->codec_id != AV_CODEC_ID_RAWVIDEO || par->codec_tag) {
1271  for (j = 0; ff_mkv_codec_tags[j].id != AV_CODEC_ID_NONE; j++) {
1272  if (ff_mkv_codec_tags[j].id == par->codec_id && par->codec_id != AV_CODEC_ID_FFV1) {
1274  native_id = 1;
1275  break;
1276  }
1277  }
1278  } else {
1279  if (mkv->allow_raw_vfw) {
1280  native_id = 0;
1281  } else {
1282  av_log(s, AV_LOG_ERROR, "Raw RGB is not supported Natively in Matroska, you can use AVI or NUT or\n"
1283  "If you would like to store it anyway using VFW mode, enable allow_raw_vfw (-allow_raw_vfw 1)\n");
1284  return AVERROR(EINVAL);
1285  }
1286  }
1287  }
1288 
1289  if (par->codec_type == AVMEDIA_TYPE_AUDIO && par->initial_padding && par->codec_id == AV_CODEC_ID_OPUS) {
1290  int64_t codecdelay = av_rescale_q(par->initial_padding,
1291  (AVRational){ 1, 48000 },
1292  (AVRational){ 1, 1000000000 });
1293  if (codecdelay < 0) {
1294  av_log(s, AV_LOG_ERROR, "Initial padding is invalid\n");
1295  return AVERROR(EINVAL);
1296  }
1297 // mkv->tracks[i].ts_offset = av_rescale_q(par->initial_padding,
1298 // (AVRational){ 1, par->sample_rate },
1299 // st->time_base);
1300 
1301  put_ebml_uint(pb, MATROSKA_ID_CODECDELAY, codecdelay);
1302  }
1303  if (par->codec_id == AV_CODEC_ID_OPUS) {
1305  }
1306 
1307  switch (par->codec_type) {
1308  case AVMEDIA_TYPE_VIDEO:
1309  mkv->have_video = 1;
1311 
1312  if( st->avg_frame_rate.num > 0 && st->avg_frame_rate.den > 0
1313  && av_cmp_q(av_inv_q(st->avg_frame_rate), st->time_base) > 0)
1315 
1316  if (!native_id &&
1319  par->codec_id == AV_CODEC_ID_SVQ1 ||
1320  par->codec_id == AV_CODEC_ID_SVQ3 ||
1321  par->codec_id == AV_CODEC_ID_CINEPAK))
1322  qt_id = 1;
1323 
1324  if (qt_id)
1325  put_ebml_string(pb, MATROSKA_ID_CODECID, "V_QUICKTIME");
1326  else if (!native_id) {
1327  // if there is no mkv-specific codec ID, use VFW mode
1328  put_ebml_string(pb, MATROSKA_ID_CODECID, "V_MS/VFW/FOURCC");
1329  mkv->tracks[i].write_dts = 1;
1331  }
1332 
1333  subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKVIDEO, 0);
1334 
1337 
1338  mkv_write_field_order(pb, mkv->mode, par->field_order);
1339 
1340  // check both side data and metadata for stereo information,
1341  // write the result to the bitstream if any is found
1342  ret = mkv_write_stereo_mode(s, pb, st, mkv->mode,
1343  &display_width_div,
1344  &display_height_div);
1345  if (ret < 0)
1346  return ret;
1347 
1348  if (((tag = av_dict_get(st->metadata, "alpha_mode", NULL, 0)) && atoi(tag->value)) ||
1349  ((tag = av_dict_get( s->metadata, "alpha_mode", NULL, 0)) && atoi(tag->value)) ||
1350  (par->format == AV_PIX_FMT_YUVA420P)) {
1352  }
1353 
1354  // write DisplayWidth and DisplayHeight, they contain the size of
1355  // a single source view and/or the display aspect ratio
1356  if (st->sample_aspect_ratio.num) {
1357  int64_t d_width = av_rescale(par->width, st->sample_aspect_ratio.num, st->sample_aspect_ratio.den);
1358  if (d_width > INT_MAX) {
1359  av_log(s, AV_LOG_ERROR, "Overflow in display width\n");
1360  return AVERROR(EINVAL);
1361  }
1362  if (d_width != par->width || display_width_div != 1 || display_height_div != 1) {
1363  if (mkv->mode == MODE_WEBM || display_width_div != 1 || display_height_div != 1) {
1364  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH , d_width / display_width_div);
1365  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, par->height / display_height_div);
1366  } else {
1367  AVRational display_aspect_ratio;
1368  av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
1369  par->width * (int64_t)st->sample_aspect_ratio.num,
1370  par->height * (int64_t)st->sample_aspect_ratio.den,
1371  1024 * 1024);
1372  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH, display_aspect_ratio.num);
1373  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, display_aspect_ratio.den);
1375  }
1376  }
1377  } else if (display_width_div != 1 || display_height_div != 1) {
1378  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH , par->width / display_width_div);
1379  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, par->height / display_height_div);
1380  } else if (mkv->mode != MODE_WEBM)
1382 
1383  if (par->codec_id == AV_CODEC_ID_RAWVIDEO) {
1384  uint32_t color_space = av_le2ne32(par->codec_tag);
1385  put_ebml_binary(pb, MATROSKA_ID_VIDEOCOLORSPACE, &color_space, sizeof(color_space));
1386  }
1387  ret = mkv_write_video_color(pb, par, st);
1388  if (ret < 0)
1389  return ret;
1390  ret = mkv_write_video_projection(s, pb, st);
1391  if (ret < 0)
1392  return ret;
1393  end_ebml_master(pb, subinfo);
1394  break;
1395 
1396  case AVMEDIA_TYPE_AUDIO:
1398 
1399  if (!native_id)
1400  // no mkv-specific ID, use ACM mode
1401  put_ebml_string(pb, MATROSKA_ID_CODECID, "A_MS/ACM");
1402 
1403  subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKAUDIO, 0);
1405 
1406  mkv->tracks[i].sample_rate_offset = avio_tell(pb);
1407  put_ebml_float (pb, MATROSKA_ID_AUDIOSAMPLINGFREQ, sample_rate);
1408  if (output_sample_rate)
1409  put_ebml_float(pb, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate);
1410  if (bit_depth)
1411  put_ebml_uint(pb, MATROSKA_ID_AUDIOBITDEPTH, bit_depth);
1412  end_ebml_master(pb, subinfo);
1413  break;
1414 
1415  case AVMEDIA_TYPE_SUBTITLE:
1416  if (!native_id) {
1417  av_log(s, AV_LOG_ERROR, "Subtitle codec %d is not supported.\n", par->codec_id);
1418  return AVERROR(ENOSYS);
1419  }
1420 
1421  if (mkv->mode != MODE_WEBM || par->codec_id != AV_CODEC_ID_WEBVTT)
1422  native_id = MATROSKA_TRACK_TYPE_SUBTITLE;
1423 
1424  put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, native_id);
1425  break;
1426  default:
1427  av_log(s, AV_LOG_ERROR, "Only audio, video, and subtitles are supported for Matroska.\n");
1428  return AVERROR(EINVAL);
1429  }
1430 
1431  if (mkv->mode != MODE_WEBM || par->codec_id != AV_CODEC_ID_WEBVTT) {
1432  mkv->tracks[i].codecpriv_offset = avio_tell(pb);
1433  ret = mkv_write_codecprivate(s, pb, par, native_id, qt_id);
1434  if (ret < 0)
1435  return ret;
1436  }
1437 
1438  end_ebml_master(pb, track);
1439 
1440  return 0;
1441 }
1442 
1444 {
1445  MatroskaMuxContext *mkv = s->priv_data;
1446  AVIOContext *pb = s->pb;
1447  int i, ret, default_stream_exists = 0;
1448 
1450  if (ret < 0)
1451  return ret;
1452 
1453  ret = start_ebml_master_crc32(pb, &mkv->tracks_bc, mkv, MATROSKA_ID_TRACKS);
1454  if (ret < 0)
1455  return ret;
1456 
1457  for (i = 0; i < s->nb_streams; i++) {
1458  AVStream *st = s->streams[i];
1459  default_stream_exists |= st->disposition & AV_DISPOSITION_DEFAULT;
1460  }
1461  for (i = 0; i < s->nb_streams; i++) {
1462  ret = mkv_write_track(s, mkv, i, mkv->tracks_bc, default_stream_exists);
1463  if (ret < 0)
1464  return ret;
1465  }
1466 
1467  if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live)
1469  else
1470  end_ebml_master_crc32(pb, &mkv->tracks_bc, mkv);
1471 
1472  return 0;
1473 }
1474 
1476 {
1477  MatroskaMuxContext *mkv = s->priv_data;
1478  AVIOContext *dyn_cp, *pb = s->pb;
1479  ebml_master editionentry;
1480  AVRational scale = {1, 1E9};
1481  int i, ret;
1482 
1483  if (!s->nb_chapters || mkv->wrote_chapters)
1484  return 0;
1485 
1487  if (ret < 0) return ret;
1488 
1489  ret = start_ebml_master_crc32(pb, &dyn_cp, mkv, MATROSKA_ID_CHAPTERS);
1490  if (ret < 0) return ret;
1491 
1492  editionentry = start_ebml_master(dyn_cp, MATROSKA_ID_EDITIONENTRY, 0);
1493  if (mkv->mode != MODE_WEBM) {
1496  }
1497  for (i = 0; i < s->nb_chapters; i++) {
1498  ebml_master chapteratom, chapterdisplay;
1499  AVChapter *c = s->chapters[i];
1500  int64_t chapterstart = av_rescale_q(c->start, c->time_base, scale);
1501  int64_t chapterend = av_rescale_q(c->end, c->time_base, scale);
1502  AVDictionaryEntry *t = NULL;
1503  if (chapterstart < 0 || chapterstart > chapterend || chapterend < 0) {
1504  av_log(s, AV_LOG_ERROR,
1505  "Invalid chapter start (%"PRId64") or end (%"PRId64").\n",
1506  chapterstart, chapterend);
1507  return AVERROR_INVALIDDATA;
1508  }
1509 
1510  chapteratom = start_ebml_master(dyn_cp, MATROSKA_ID_CHAPTERATOM, 0);
1512  put_ebml_uint(dyn_cp, MATROSKA_ID_CHAPTERTIMESTART, chapterstart);
1513  put_ebml_uint(dyn_cp, MATROSKA_ID_CHAPTERTIMEEND, chapterend);
1514  if (mkv->mode != MODE_WEBM) {
1517  }
1518  if ((t = av_dict_get(c->metadata, "title", NULL, 0))) {
1519  chapterdisplay = start_ebml_master(dyn_cp, MATROSKA_ID_CHAPTERDISPLAY, 0);
1521  put_ebml_string(dyn_cp, MATROSKA_ID_CHAPLANG , "und");
1522  end_ebml_master(dyn_cp, chapterdisplay);
1523  }
1524  end_ebml_master(dyn_cp, chapteratom);
1525  }
1526  end_ebml_master(dyn_cp, editionentry);
1527  end_ebml_master_crc32(pb, &dyn_cp, mkv);
1528 
1529  mkv->wrote_chapters = 1;
1530  return 0;
1531 }
1532 
1534 {
1535  uint8_t *key = av_strdup(t->key);
1536  uint8_t *p = key;
1537  const uint8_t *lang = NULL;
1538  ebml_master tag;
1539 
1540  if (!key)
1541  return AVERROR(ENOMEM);
1542 
1543  if ((p = strrchr(p, '-')) &&
1544  (lang = ff_convert_lang_to(p + 1, AV_LANG_ISO639_2_BIBL)))
1545  *p = 0;
1546 
1547  p = key;
1548  while (*p) {
1549  if (*p == ' ')
1550  *p = '_';
1551  else if (*p >= 'a' && *p <= 'z')
1552  *p -= 'a' - 'A';
1553  p++;
1554  }
1555 
1558  if (lang)
1561  end_ebml_master(pb, tag);
1562 
1563  av_freep(&key);
1564  return 0;
1565 }
1566 
1567 static int mkv_write_tag_targets(AVFormatContext *s, uint32_t elementid,
1568  unsigned int uid, ebml_master *tag)
1569 {
1570  AVIOContext *pb;
1571  MatroskaMuxContext *mkv = s->priv_data;
1573  int ret;
1574 
1575  if (!mkv->tags_bc) {
1577  if (ret < 0) return ret;
1578 
1580  }
1581  pb = mkv->tags_bc;
1582 
1583  *tag = start_ebml_master(pb, MATROSKA_ID_TAG, 0);
1584  targets = start_ebml_master(pb, MATROSKA_ID_TAGTARGETS, 0);
1585  if (elementid)
1586  put_ebml_uint(pb, elementid, uid);
1587  end_ebml_master(pb, targets);
1588  return 0;
1589 }
1590 
1591 static int mkv_check_tag_name(const char *name, uint32_t elementid)
1592 {
1593  return av_strcasecmp(name, "title") &&
1594  av_strcasecmp(name, "stereo_mode") &&
1595  av_strcasecmp(name, "creation_time") &&
1596  av_strcasecmp(name, "encoding_tool") &&
1597  av_strcasecmp(name, "duration") &&
1598  (elementid != MATROSKA_ID_TAGTARGETS_TRACKUID ||
1599  av_strcasecmp(name, "language")) &&
1600  (elementid != MATROSKA_ID_TAGTARGETS_ATTACHUID ||
1601  (av_strcasecmp(name, "filename") &&
1602  av_strcasecmp(name, "mimetype")));
1603 }
1604 
1605 static int mkv_write_tag(AVFormatContext *s, AVDictionary *m, uint32_t elementid,
1606  unsigned int uid)
1607 {
1608  MatroskaMuxContext *mkv = s->priv_data;
1609  ebml_master tag;
1610  int ret;
1611  AVDictionaryEntry *t = NULL;
1612 
1613  ret = mkv_write_tag_targets(s, elementid, uid, &tag);
1614  if (ret < 0)
1615  return ret;
1616 
1617  while ((t = av_dict_get(m, "", t, AV_DICT_IGNORE_SUFFIX))) {
1618  if (mkv_check_tag_name(t->key, elementid)) {
1619  ret = mkv_write_simpletag(mkv->tags_bc, t);
1620  if (ret < 0)
1621  return ret;
1622  }
1623  }
1624 
1625  end_ebml_master(mkv->tags_bc, tag);
1626  return 0;
1627 }
1628 
1629 static int mkv_check_tag(AVDictionary *m, uint32_t elementid)
1630 {
1631  AVDictionaryEntry *t = NULL;
1632 
1633  while ((t = av_dict_get(m, "", t, AV_DICT_IGNORE_SUFFIX)))
1634  if (mkv_check_tag_name(t->key, elementid))
1635  return 1;
1636 
1637  return 0;
1638 }
1639 
1641 {
1642  MatroskaMuxContext *mkv = s->priv_data;
1643  int i, ret;
1644 
1646 
1647  if (mkv_check_tag(s->metadata, 0)) {
1648  ret = mkv_write_tag(s, s->metadata, 0, 0);
1649  if (ret < 0) return ret;
1650  }
1651 
1652  for (i = 0; i < s->nb_streams; i++) {
1653  AVStream *st = s->streams[i];
1654 
1656  continue;
1657 
1659  continue;
1660 
1662  if (ret < 0) return ret;
1663  }
1664 
1665  if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live) {
1666  for (i = 0; i < s->nb_streams; i++) {
1667  AVIOContext *pb;
1668  AVStream *st = s->streams[i];
1669  ebml_master tag_target;
1670  ebml_master tag;
1671 
1673  continue;
1674 
1676  pb = mkv->tags_bc;
1677 
1679  put_ebml_string(pb, MATROSKA_ID_TAGNAME, "DURATION");
1680  mkv->stream_duration_offsets[i] = avio_tell(pb);
1681 
1682  // Reserve space to write duration as a 20-byte string.
1683  // 2 (ebml id) + 1 (data size) + 20 (data)
1684  put_ebml_void(pb, 23);
1685  end_ebml_master(pb, tag);
1686  end_ebml_master(pb, tag_target);
1687  }
1688  }
1689 
1690  if (mkv->mode != MODE_WEBM) {
1691  for (i = 0; i < s->nb_chapters; i++) {
1692  AVChapter *ch = s->chapters[i];
1693 
1695  continue;
1696 
1698  if (ret < 0)
1699  return ret;
1700  }
1701  }
1702 
1703  if (mkv->have_attachments && mkv->mode != MODE_WEBM) {
1704  for (i = 0; i < mkv->attachments->num_entries; i++) {
1705  mkv_attachment *attachment = &mkv->attachments->entries[i];
1706  AVStream *st = s->streams[attachment->stream_idx];
1707 
1709  continue;
1710 
1711  ret = mkv_write_tag(s, st->metadata, MATROSKA_ID_TAGTARGETS_ATTACHUID, attachment->fileuid);
1712  if (ret < 0)
1713  return ret;
1714  }
1715  }
1716 
1717  if (mkv->tags_bc) {
1718  if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live)
1719  end_ebml_master_crc32_preliminary(s->pb, &mkv->tags_bc, mkv, &mkv->tags_pos);
1720  else
1721  end_ebml_master_crc32(s->pb, &mkv->tags_bc, mkv);
1722  }
1723  return 0;
1724 }
1725 
1727 {
1728  MatroskaMuxContext *mkv = s->priv_data;
1729  AVIOContext *dyn_cp, *pb = s->pb;
1730  AVLFG c;
1731  int i, ret;
1732 
1733  if (!mkv->have_attachments)
1734  return 0;
1735 
1736  mkv->attachments = av_mallocz(sizeof(*mkv->attachments));
1737  if (!mkv->attachments)
1738  return AVERROR(ENOMEM);
1739 
1741 
1743  if (ret < 0) return ret;
1744 
1745  ret = start_ebml_master_crc32(pb, &dyn_cp, mkv, MATROSKA_ID_ATTACHMENTS);
1746  if (ret < 0) return ret;
1747 
1748  for (i = 0; i < s->nb_streams; i++) {
1749  AVStream *st = s->streams[i];
1750  ebml_master attached_file;
1751  mkv_attachment *attachment = mkv->attachments->entries;
1752  AVDictionaryEntry *t;
1753  const char *mimetype = NULL;
1754  uint32_t fileuid;
1755 
1757  continue;
1758 
1759  attachment = av_realloc_array(attachment, mkv->attachments->num_entries + 1, sizeof(mkv_attachment));
1760  if (!attachment)
1761  return AVERROR(ENOMEM);
1762  mkv->attachments->entries = attachment;
1763 
1764  attached_file = start_ebml_master(dyn_cp, MATROSKA_ID_ATTACHEDFILE, 0);
1765 
1766  if (t = av_dict_get(st->metadata, "title", NULL, 0))
1768  if (!(t = av_dict_get(st->metadata, "filename", NULL, 0))) {
1769  av_log(s, AV_LOG_ERROR, "Attachment stream %d has no filename tag.\n", i);
1770  return AVERROR(EINVAL);
1771  }
1773  if (t = av_dict_get(st->metadata, "mimetype", NULL, 0))
1774  mimetype = t->value;
1775  else if (st->codecpar->codec_id != AV_CODEC_ID_NONE ) {
1776  int i;
1777  for (i = 0; ff_mkv_mime_tags[i].id != AV_CODEC_ID_NONE; i++)
1778  if (ff_mkv_mime_tags[i].id == st->codecpar->codec_id) {
1779  mimetype = ff_mkv_mime_tags[i].str;
1780  break;
1781  }
1782  for (i = 0; ff_mkv_image_mime_tags[i].id != AV_CODEC_ID_NONE; i++)
1783  if (ff_mkv_image_mime_tags[i].id == st->codecpar->codec_id) {
1784  mimetype = ff_mkv_image_mime_tags[i].str;
1785  break;
1786  }
1787  }
1788  if (!mimetype) {
1789  av_log(s, AV_LOG_ERROR, "Attachment stream %d has no mimetype tag and "
1790  "it cannot be deduced from the codec id.\n", i);
1791  return AVERROR(EINVAL);
1792  }
1793 
1794  if (s->flags & AVFMT_FLAG_BITEXACT) {
1795  struct AVSHA *sha = av_sha_alloc();
1796  uint8_t digest[20];
1797  if (!sha)
1798  return AVERROR(ENOMEM);
1799  av_sha_init(sha, 160);
1801  av_sha_final(sha, digest);
1802  av_free(sha);
1803  fileuid = AV_RL32(digest);
1804  } else {
1805  fileuid = av_lfg_get(&c);
1806  }
1807  av_log(s, AV_LOG_VERBOSE, "Using %.8"PRIx32" for attachment %d\n",
1808  fileuid, mkv->attachments->num_entries);
1809 
1810  put_ebml_string(dyn_cp, MATROSKA_ID_FILEMIMETYPE, mimetype);
1812  put_ebml_uint(dyn_cp, MATROSKA_ID_FILEUID, fileuid);
1813  end_ebml_master(dyn_cp, attached_file);
1814 
1816  mkv->attachments->entries[mkv->attachments->num_entries++].fileuid = fileuid;
1817  }
1818  end_ebml_master_crc32(pb, &dyn_cp, mkv);
1819 
1820  return 0;
1821 }
1822 
1824 {
1825  int i = 0;
1826  int64_t max = 0;
1827  int64_t us;
1828 
1829  AVDictionaryEntry *explicitDuration = av_dict_get(s->metadata, "DURATION", NULL, 0);
1830  if (explicitDuration && (av_parse_time(&us, explicitDuration->value, 1) == 0) && us > 0) {
1831  av_log(s, AV_LOG_DEBUG, "get_metadata_duration found duration in context metadata: %" PRId64 "\n", us);
1832  return us;
1833  }
1834 
1835  for (i = 0; i < s->nb_streams; i++) {
1836  int64_t us;
1837  AVDictionaryEntry *duration = av_dict_get(s->streams[i]->metadata, "DURATION", NULL, 0);
1838 
1839  if (duration && (av_parse_time(&us, duration->value, 1) == 0))
1840  max = FFMAX(max, us);
1841  }
1842 
1843  av_log(s, AV_LOG_DEBUG, "get_metadata_duration returned: %" PRId64 "\n", max);
1844  return max;
1845 }
1846 
1848 {
1849  MatroskaMuxContext *mkv = s->priv_data;
1850  AVIOContext *pb = s->pb;
1853  int ret, i, version = 2;
1854  int64_t creation_time;
1855 
1856  if (!strcmp(s->oformat->name, "webm")) {
1857  mkv->mode = MODE_WEBM;
1858  mkv->write_crc = 0;
1859  } else
1860  mkv->mode = MODE_MATROSKAv2;
1861 
1862  if (mkv->mode != MODE_WEBM ||
1863  av_dict_get(s->metadata, "stereo_mode", NULL, 0) ||
1864  av_dict_get(s->metadata, "alpha_mode", NULL, 0))
1865  version = 4;
1866 
1867  for (i = 0; i < s->nb_streams; i++) {
1868  if (s->streams[i]->codecpar->codec_id == AV_CODEC_ID_OPUS ||
1869  av_dict_get(s->streams[i]->metadata, "stereo_mode", NULL, 0) ||
1870  av_dict_get(s->streams[i]->metadata, "alpha_mode", NULL, 0))
1871  version = 4;
1872  }
1873 
1874  mkv->tracks = av_mallocz_array(s->nb_streams, sizeof(*mkv->tracks));
1875  if (!mkv->tracks) {
1876  ret = AVERROR(ENOMEM);
1877  goto fail;
1878  }
1885  put_ebml_uint (pb, EBML_ID_DOCTYPEVERSION , version);
1887  end_ebml_master(pb, ebml_header);
1888 
1890  mkv->segment_offset = avio_tell(pb);
1891 
1892  // we write a seek head at the beginning to point to all other level
1893  // one elements, which aren't more than 10 elements as we write only one
1894  // of every other currently defined level 1 element
1895  mkv->seekhead = mkv_start_seekhead(pb, mkv->segment_offset, 10);
1896  if (!mkv->seekhead) {
1897  ret = AVERROR(ENOMEM);
1898  goto fail;
1899  }
1900 
1902  if (ret < 0) goto fail;
1903 
1904  ret = start_ebml_master_crc32(pb, &mkv->info_bc, mkv, MATROSKA_ID_INFO);
1905  if (ret < 0)
1906  return ret;
1907  pb = mkv->info_bc;
1908 
1910  if ((tag = av_dict_get(s->metadata, "title", NULL, 0)))
1912  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
1914  if ((tag = av_dict_get(s->metadata, "encoding_tool", NULL, 0)))
1916  else
1918 
1919  if (mkv->mode != MODE_WEBM) {
1920  uint32_t segment_uid[4];
1921  AVLFG lfg;
1922 
1924 
1925  for (i = 0; i < 4; i++)
1926  segment_uid[i] = av_lfg_get(&lfg);
1927 
1928  put_ebml_binary(pb, MATROSKA_ID_SEGMENTUID, segment_uid, 16);
1929  }
1930  } else {
1931  const char *ident = "Lavf";
1934  }
1935 
1936  if (ff_parse_creation_time_metadata(s, &creation_time, 0) > 0) {
1937  // Adjust time so it's relative to 2001-01-01 and convert to nanoseconds.
1938  int64_t date_utc = (creation_time - 978307200000000LL) * 1000;
1939  uint8_t date_utc_buf[8];
1940  AV_WB64(date_utc_buf, date_utc);
1941  put_ebml_binary(pb, MATROSKA_ID_DATEUTC, date_utc_buf, 8);
1942  }
1943 
1944  // reserve space for the duration
1945  mkv->duration = 0;
1946  mkv->duration_offset = avio_tell(pb);
1947  if (!mkv->is_live) {
1948  int64_t metadata_duration = get_metadata_duration(s);
1949 
1950  if (s->duration > 0) {
1951  int64_t scaledDuration = av_rescale(s->duration, 1000, AV_TIME_BASE);
1952  put_ebml_float(pb, MATROSKA_ID_DURATION, scaledDuration);
1953  av_log(s, AV_LOG_DEBUG, "Write early duration from recording time = %" PRIu64 "\n", scaledDuration);
1954  } else if (metadata_duration > 0) {
1955  int64_t scaledDuration = av_rescale(metadata_duration, 1000, AV_TIME_BASE);
1956  put_ebml_float(pb, MATROSKA_ID_DURATION, scaledDuration);
1957  av_log(s, AV_LOG_DEBUG, "Write early duration from metadata = %" PRIu64 "\n", scaledDuration);
1958  } else {
1959  put_ebml_void(pb, 11); // assumes double-precision float to be written
1960  }
1961  }
1962  if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live)
1963  end_ebml_master_crc32_preliminary(s->pb, &mkv->info_bc, mkv, &mkv->info_pos);
1964  else
1965  end_ebml_master_crc32(s->pb, &mkv->info_bc, mkv);
1966  pb = s->pb;
1967 
1968  // initialize stream_duration fields
1969  mkv->stream_durations = av_mallocz(s->nb_streams * sizeof(int64_t));
1970  mkv->stream_duration_offsets = av_mallocz(s->nb_streams * sizeof(int64_t));
1971  if (!mkv->stream_durations || !mkv->stream_duration_offsets) {
1972  ret = AVERROR(ENOMEM);
1973  goto fail;
1974  }
1975 
1976  ret = mkv_write_tracks(s);
1977  if (ret < 0)
1978  goto fail;
1979 
1980  for (i = 0; i < s->nb_chapters; i++)
1981  mkv->chapter_id_offset = FFMAX(mkv->chapter_id_offset, 1LL - s->chapters[i]->id);
1982 
1983  ret = mkv_write_chapters(s);
1984  if (ret < 0)
1985  goto fail;
1986 
1987  if (mkv->mode != MODE_WEBM) {
1988  ret = mkv_write_attachments(s);
1989  if (ret < 0)
1990  goto fail;
1991  }
1992 
1993  ret = mkv_write_tags(s);
1994  if (ret < 0)
1995  goto fail;
1996 
1997  if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live)
1998  mkv_write_seekhead(pb, mkv);
1999 
2000  mkv->cues = mkv_start_cues(mkv->segment_offset);
2001  if (!mkv->cues) {
2002  ret = AVERROR(ENOMEM);
2003  goto fail;
2004  }
2005 
2006  if (s->metadata_header_padding > 0) {
2007  if (s->metadata_header_padding == 1)
2010  }
2011 
2012  if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && mkv->reserve_cues_space) {
2013  mkv->cues_pos = avio_tell(pb);
2014  if (mkv->reserve_cues_space == 1)
2015  mkv->reserve_cues_space++;
2017  }
2018 
2020  mkv->cur_audio_pkt.size = 0;
2021  mkv->cluster_pos = -1;
2022 
2023  avio_flush(pb);
2024 
2025  // start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or
2026  // after 4k and on a keyframe
2027  if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
2028  if (mkv->cluster_time_limit < 0)
2029  mkv->cluster_time_limit = 5000;
2030  if (mkv->cluster_size_limit < 0)
2031  mkv->cluster_size_limit = 5 * 1024 * 1024;
2032  } else {
2033  if (mkv->cluster_time_limit < 0)
2034  mkv->cluster_time_limit = 1000;
2035  if (mkv->cluster_size_limit < 0)
2036  mkv->cluster_size_limit = 32 * 1024;
2037  }
2038 
2039  return 0;
2040 fail:
2041  mkv_free(mkv);
2042  return ret;
2043 }
2044 
2045 static int mkv_blockgroup_size(int pkt_size)
2046 {
2047  int size = pkt_size + 4;
2048  size += ebml_num_size(size);
2049  size += 2; // EBML ID for block and block duration
2050  size += 9; // max size of block duration incl. length field
2051  return size;
2052 }
2053 
2054 static int mkv_strip_wavpack(const uint8_t *src, uint8_t **pdst, int *size)
2055 {
2056  uint8_t *dst;
2057  int srclen = *size;
2058  int offset = 0;
2059  int ret;
2060 
2061  dst = av_malloc(srclen);
2062  if (!dst)
2063  return AVERROR(ENOMEM);
2064 
2065  while (srclen >= WV_HEADER_SIZE) {
2066  WvHeader header;
2067 
2068  ret = ff_wv_parse_header(&header, src);
2069  if (ret < 0)
2070  goto fail;
2071  src += WV_HEADER_SIZE;
2072  srclen -= WV_HEADER_SIZE;
2073 
2074  if (srclen < header.blocksize) {
2075  ret = AVERROR_INVALIDDATA;
2076  goto fail;
2077  }
2078 
2079  if (header.initial) {
2080  AV_WL32(dst + offset, header.samples);
2081  offset += 4;
2082  }
2083  AV_WL32(dst + offset, header.flags);
2084  AV_WL32(dst + offset + 4, header.crc);
2085  offset += 8;
2086 
2087  if (!(header.initial && header.final)) {
2088  AV_WL32(dst + offset, header.blocksize);
2089  offset += 4;
2090  }
2091 
2092  memcpy(dst + offset, src, header.blocksize);
2093  src += header.blocksize;
2094  srclen -= header.blocksize;
2095  offset += header.blocksize;
2096  }
2097 
2098  *pdst = dst;
2099  *size = offset;
2100 
2101  return 0;
2102 fail:
2103  av_freep(&dst);
2104  return ret;
2105 }
2106 
2108  uint32_t blockid, AVPacket *pkt, int keyframe)
2109 {
2110  MatroskaMuxContext *mkv = s->priv_data;
2112  uint8_t *data = NULL, *side_data = NULL;
2113  int offset = 0, size = pkt->size, side_data_size = 0;
2114  int64_t ts = mkv->tracks[pkt->stream_index].write_dts ? pkt->dts : pkt->pts;
2115  uint64_t additional_id = 0;
2116  int64_t discard_padding = 0;
2117  uint8_t track_number = (mkv->is_dash ? mkv->dash_track_number : (pkt->stream_index + 1));
2118  ebml_master block_group, block_additions, block_more;
2119 
2120  ts += mkv->tracks[pkt->stream_index].ts_offset;
2121 
2122  /* The following string is identical to the one in mkv_write_vtt_blocks
2123  * so that only one copy needs to exist in binaries. */
2124  av_log(s, AV_LOG_DEBUG,
2125  "Writing block of size %d with pts %" PRId64 ", dts %" PRId64 ", "
2126  "duration %" PRId64 " at relative offset %" PRId64 " in cluster "
2127  "at offset %" PRId64 ". TrackNumber %d, keyframe %d\n",
2128  pkt->size, pkt->pts, pkt->dts, pkt->duration, avio_tell(pb),
2129  mkv->cluster_pos, track_number, keyframe != 0);
2130  if (par->codec_id == AV_CODEC_ID_H264 && par->extradata_size > 0 &&
2131  (AV_RB24(par->extradata) == 1 || AV_RB32(par->extradata) == 1))
2132  ff_avc_parse_nal_units_buf(pkt->data, &data, &size);
2133  else if (par->codec_id == AV_CODEC_ID_HEVC && par->extradata_size > 6 &&
2134  (AV_RB24(par->extradata) == 1 || AV_RB32(par->extradata) == 1))
2135  /* extradata is Annex B, assume the bitstream is too and convert it */
2136  ff_hevc_annexb2mp4_buf(pkt->data, &data, &size, 0, NULL);
2137  else if (par->codec_id == AV_CODEC_ID_AV1)
2138  ff_av1_filter_obus_buf(pkt->data, &data, &size);
2139  else if (par->codec_id == AV_CODEC_ID_WAVPACK) {
2140  int ret = mkv_strip_wavpack(pkt->data, &data, &size);
2141  if (ret < 0) {
2142  av_log(s, AV_LOG_ERROR, "Error stripping a WavPack packet.\n");
2143  return;
2144  }
2145  } else
2146  data = pkt->data;
2147 
2148  if (par->codec_id == AV_CODEC_ID_PRORES && size >= 8) {
2149  /* Matroska specification requires to remove the first QuickTime atom
2150  */
2151  size -= 8;
2152  offset = 8;
2153  }
2154 
2155  side_data = av_packet_get_side_data(pkt,
2157  &side_data_size);
2158 
2159  if (side_data && side_data_size >= 10) {
2160  discard_padding = av_rescale_q(AV_RL32(side_data + 4),
2161  (AVRational){1, par->sample_rate},
2162  (AVRational){1, 1000000000});
2163  }
2164 
2165  side_data = av_packet_get_side_data(pkt,
2167  &side_data_size);
2168  if (side_data) {
2169  additional_id = AV_RB64(side_data);
2170  side_data += 8;
2171  side_data_size -= 8;
2172  }
2173 
2174  if ((side_data_size && additional_id == 1) || discard_padding) {
2175  block_group = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, 0);
2176  blockid = MATROSKA_ID_BLOCK;
2177  }
2178 
2179  put_ebml_id(pb, blockid);
2180  put_ebml_num(pb, size + 4, 0);
2181  // this assumes stream_index is less than 126
2182  avio_w8(pb, 0x80 | track_number);
2183  avio_wb16(pb, ts - mkv->cluster_pts);
2184  avio_w8(pb, (blockid == MATROSKA_ID_SIMPLEBLOCK && keyframe) ? (1 << 7) : 0);
2185  avio_write(pb, data + offset, size);
2186  if (data != pkt->data)
2187  av_free(data);
2188 
2189  if (blockid == MATROSKA_ID_BLOCK && !keyframe) {
2191  mkv->last_track_timestamp[track_number - 1]);
2192  }
2193  mkv->last_track_timestamp[track_number - 1] = ts - mkv->cluster_pts;
2194 
2195  if (discard_padding) {
2196  put_ebml_sint(pb, MATROSKA_ID_DISCARDPADDING, discard_padding);
2197  }
2198 
2199  if (side_data_size && additional_id == 1) {
2200  block_additions = start_ebml_master(pb, MATROSKA_ID_BLOCKADDITIONS, 0);
2201  block_more = start_ebml_master(pb, MATROSKA_ID_BLOCKMORE, 0);
2204  put_ebml_num(pb, side_data_size, 0);
2205  avio_write(pb, side_data, side_data_size);
2206  end_ebml_master(pb, block_more);
2207  end_ebml_master(pb, block_additions);
2208  }
2209  if ((side_data_size && additional_id == 1) || discard_padding) {
2210  end_ebml_master(pb, block_group);
2211  }
2212 }
2213 
2215 {
2216  MatroskaMuxContext *mkv = s->priv_data;
2217  ebml_master blockgroup;
2218  int id_size, settings_size, size;
2219  uint8_t *id, *settings;
2220  int64_t ts = mkv->tracks[pkt->stream_index].write_dts ? pkt->dts : pkt->pts;
2221  const int flags = 0;
2222 
2223  id_size = 0;
2225  &id_size);
2226 
2227  settings_size = 0;
2229  &settings_size);
2230 
2231  size = id_size + 1 + settings_size + 1 + pkt->size;
2232 
2233  /* The following string is identical to the one in mkv_write_block so that
2234  * only one copy needs to exist in binaries. */
2235  av_log(s, AV_LOG_DEBUG,
2236  "Writing block of size %d with pts %" PRId64 ", dts %" PRId64 ", "
2237  "duration %" PRId64 " at relative offset %" PRId64 " in cluster "
2238  "at offset %" PRId64 ". TrackNumber %d, keyframe %d\n",
2239  size, pkt->pts, pkt->dts, pkt->duration, avio_tell(pb),
2240  mkv->cluster_pos, pkt->stream_index + 1, 1);
2241 
2243 
2245  put_ebml_num(pb, size + 4, 0);
2246  avio_w8(pb, 0x80 | (pkt->stream_index + 1)); // this assumes stream_index is less than 126
2247  avio_wb16(pb, ts - mkv->cluster_pts);
2248  avio_w8(pb, flags);
2249  avio_printf(pb, "%.*s\n%.*s\n%.*s", id_size, id, settings_size, settings, pkt->size, pkt->data);
2250 
2252  end_ebml_master(pb, blockgroup);
2253 
2254  return pkt->duration;
2255 }
2256 
2258 {
2259  MatroskaMuxContext *mkv = s->priv_data;
2260 
2261  end_ebml_master_crc32(s->pb, &mkv->cluster_bc, mkv);
2262  mkv->cluster_pos = -1;
2263  av_log(s, AV_LOG_DEBUG,
2264  "Starting new cluster at offset %" PRIu64 " bytes, "
2265  "pts %" PRIu64 ", dts %" PRIu64 "\n",
2266  avio_tell(s->pb), pkt->pts, pkt->dts);
2267  avio_flush(s->pb);
2268 }
2269 
2271 {
2272  MatroskaMuxContext *mkv = s->priv_data;
2273  mkv_track *track = &mkv->tracks[pkt->stream_index];
2275  uint8_t *side_data;
2276  int side_data_size = 0, ret;
2277 
2279  &side_data_size);
2280 
2281  switch (par->codec_id) {
2282  case AV_CODEC_ID_AAC:
2283  if (side_data_size && (s->pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live) {
2284  int filler, output_sample_rate = 0;
2285  int64_t curpos;
2286  ret = get_aac_sample_rates(s, side_data, side_data_size, &track->sample_rate,
2287  &output_sample_rate);
2288  if (ret < 0)
2289  return ret;
2290  if (!output_sample_rate)
2291  output_sample_rate = track->sample_rate; // Space is already reserved, so it's this or a void element.
2292  av_freep(&par->extradata);
2293  ret = ff_alloc_extradata(par, side_data_size);
2294  if (ret < 0)
2295  return ret;
2296  memcpy(par->extradata, side_data, side_data_size);
2297  curpos = avio_tell(mkv->tracks_bc);
2298  avio_seek(mkv->tracks_bc, track->codecpriv_offset, SEEK_SET);
2299  mkv_write_codecprivate(s, mkv->tracks_bc, par, 1, 0);
2300  filler = MAX_PCE_SIZE + 2 + 4 - (avio_tell(mkv->tracks_bc) - track->codecpriv_offset);
2301  if (filler)
2302  put_ebml_void(mkv->tracks_bc, filler);
2303  avio_seek(mkv->tracks_bc, track->sample_rate_offset, SEEK_SET);
2305  put_ebml_float(mkv->tracks_bc, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate);
2306  avio_seek(mkv->tracks_bc, curpos, SEEK_SET);
2307  } else if (!par->extradata_size && !track->sample_rate) {
2308  // No extradata (codecpar or packet side data).
2309  av_log(s, AV_LOG_ERROR, "Error parsing AAC extradata, unable to determine samplerate.\n");
2310  return AVERROR(EINVAL);
2311  }
2312  break;
2313  case AV_CODEC_ID_FLAC:
2314  if (side_data_size && (s->pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live) {
2315  AVCodecParameters *codecpriv_par;
2316  int64_t curpos;
2317  if (side_data_size != par->extradata_size) {
2318  av_log(s, AV_LOG_ERROR, "Invalid FLAC STREAMINFO metadata for output stream %d\n",
2319  pkt->stream_index);
2320  return AVERROR(EINVAL);
2321  }
2322  codecpriv_par = avcodec_parameters_alloc();
2323  if (!codecpriv_par)
2324  return AVERROR(ENOMEM);
2325  ret = avcodec_parameters_copy(codecpriv_par, par);
2326  if (ret < 0) {
2327  avcodec_parameters_free(&codecpriv_par);
2328  return ret;
2329  }
2330  memcpy(codecpriv_par->extradata, side_data, side_data_size);
2331  curpos = avio_tell(mkv->tracks_bc);
2332  avio_seek(mkv->tracks_bc, track->codecpriv_offset, SEEK_SET);
2333  mkv_write_codecprivate(s, mkv->tracks_bc, codecpriv_par, 1, 0);
2334  avio_seek(mkv->tracks_bc, curpos, SEEK_SET);
2335  avcodec_parameters_free(&codecpriv_par);
2336  }
2337  break;
2338  // FIXME: Remove the following once libaom starts propagating extradata during init()
2339  // See https://bugs.chromium.org/p/aomedia/issues/detail?id=2012
2340  case AV_CODEC_ID_AV1:
2341  if (side_data_size && (s->pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live &&
2342  !par->extradata_size) {
2343  AVIOContext *dyn_cp;
2344  uint8_t *codecpriv;
2345  int codecpriv_size;
2346  int64_t curpos;
2347  ret = avio_open_dyn_buf(&dyn_cp);
2348  if (ret < 0)
2349  return ret;
2350  ff_isom_write_av1c(dyn_cp, side_data, side_data_size);
2351  codecpriv_size = avio_close_dyn_buf(dyn_cp, &codecpriv);
2352  if (!codecpriv_size) {
2353  av_free(codecpriv);
2354  return AVERROR_INVALIDDATA;
2355  }
2356  curpos = avio_tell(mkv->tracks_bc);
2357  avio_seek(mkv->tracks_bc, track->codecpriv_offset, SEEK_SET);
2358  // Do not write the OBUs as we don't have space saved for them
2359  put_ebml_binary(mkv->tracks_bc, MATROSKA_ID_CODECPRIVATE, codecpriv, 4);
2360  av_free(codecpriv);
2361  avio_seek(mkv->tracks_bc, curpos, SEEK_SET);
2362  ret = ff_alloc_extradata(par, side_data_size);
2363  if (ret < 0)
2364  return ret;
2365  memcpy(par->extradata, side_data, side_data_size);
2366  } else if (!par->extradata_size)
2367  return AVERROR_INVALIDDATA;
2368  break;
2369  default:
2370  if (side_data_size)
2371  av_log(s, AV_LOG_DEBUG, "Ignoring new extradata in a packet for stream %d.\n", pkt->stream_index);
2372  break;
2373  }
2374 
2375  return 0;
2376 }
2377 
2379 {
2380  MatroskaMuxContext *mkv = s->priv_data;
2381  AVIOContext *pb = s->pb;
2383  int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
2384  int duration = pkt->duration;
2385  int ret;
2386  int64_t ts = mkv->tracks[pkt->stream_index].write_dts ? pkt->dts : pkt->pts;
2387  int64_t relative_packet_pos;
2388  int dash_tracknum = mkv->is_dash ? mkv->dash_track_number : pkt->stream_index + 1;
2389 
2390  if (ts == AV_NOPTS_VALUE) {
2391  av_log(s, AV_LOG_ERROR, "Can't write packet with unknown timestamp\n");
2392  return AVERROR(EINVAL);
2393  }
2394  ts += mkv->tracks[pkt->stream_index].ts_offset;
2395 
2396  if (mkv->cluster_pos != -1) {
2397  int64_t cluster_time = ts - mkv->cluster_pts;
2398  if ((int16_t)cluster_time != cluster_time) {
2399  av_log(s, AV_LOG_WARNING, "Starting new cluster due to timestamp\n");
2400  mkv_start_new_cluster(s, pkt);
2401  }
2402  }
2403 
2404  if (mkv->cluster_pos == -1) {
2405  mkv->cluster_pos = avio_tell(s->pb);
2407  if (ret < 0)
2408  return ret;
2410  mkv->cluster_pts = FFMAX(0, ts);
2411  }
2412  pb = mkv->cluster_bc;
2413 
2414  relative_packet_pos = avio_tell(pb);
2415 
2416  if (par->codec_type != AVMEDIA_TYPE_SUBTITLE) {
2417  mkv_write_block(s, pb, MATROSKA_ID_SIMPLEBLOCK, pkt, keyframe);
2418  if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) && (par->codec_type == AVMEDIA_TYPE_VIDEO && keyframe || add_cue)) {
2419  ret = mkv_add_cuepoint(mkv->cues, pkt->stream_index, dash_tracknum, ts, mkv->cluster_pos, relative_packet_pos, -1);
2420  if (ret < 0) return ret;
2421  }
2422  } else {
2423  if (par->codec_id == AV_CODEC_ID_WEBVTT) {
2424  duration = mkv_write_vtt_blocks(s, pb, pkt);
2425  } else {
2427  mkv_blockgroup_size(pkt->size));
2428 
2429 #if FF_API_CONVERGENCE_DURATION
2431  /* For backward compatibility, prefer convergence_duration. */
2432  if (pkt->convergence_duration > 0) {
2433  duration = pkt->convergence_duration;
2434  }
2436 #endif
2437  /* All subtitle blocks are considered to be keyframes. */
2438  mkv_write_block(s, pb, MATROSKA_ID_BLOCK, pkt, 1);
2440  end_ebml_master(pb, blockgroup);
2441  }
2442 
2443  if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
2444  ret = mkv_add_cuepoint(mkv->cues, pkt->stream_index, dash_tracknum, ts,
2445  mkv->cluster_pos, relative_packet_pos, duration);
2446  if (ret < 0)
2447  return ret;
2448  }
2449  }
2450 
2451  mkv->duration = FFMAX(mkv->duration, ts + duration);
2452 
2453  if (mkv->stream_durations)
2454  mkv->stream_durations[pkt->stream_index] =
2455  FFMAX(mkv->stream_durations[pkt->stream_index], ts + duration);
2456 
2457  return 0;
2458 }
2459 
2461 {
2462  MatroskaMuxContext *mkv = s->priv_data;
2464  int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
2465  int cluster_size;
2466  int64_t cluster_time;
2467  int ret;
2468  int start_new_cluster;
2469 
2470  ret = mkv_check_new_extra_data(s, pkt);
2471  if (ret < 0)
2472  return ret;
2473 
2474  if (mkv->tracks[pkt->stream_index].write_dts)
2475  cluster_time = pkt->dts - mkv->cluster_pts;
2476  else
2477  cluster_time = pkt->pts - mkv->cluster_pts;
2478  cluster_time += mkv->tracks[pkt->stream_index].ts_offset;
2479 
2480  // start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or
2481  // after 4k and on a keyframe
2482  cluster_size = avio_tell(mkv->cluster_bc);
2483 
2484  if (mkv->is_dash && codec_type == AVMEDIA_TYPE_VIDEO) {
2485  // WebM DASH specification states that the first block of every cluster
2486  // has to be a key frame. So for DASH video, we only create a cluster
2487  // on seeing key frames.
2488  start_new_cluster = keyframe;
2489  } else if (mkv->is_dash && codec_type == AVMEDIA_TYPE_AUDIO &&
2490  (mkv->cluster_pos == -1 ||
2491  cluster_time > mkv->cluster_time_limit)) {
2492  // For DASH audio, we create a Cluster based on cluster_time_limit
2493  start_new_cluster = 1;
2494  } else if (!mkv->is_dash &&
2495  (cluster_size > mkv->cluster_size_limit ||
2496  cluster_time > mkv->cluster_time_limit ||
2497  (codec_type == AVMEDIA_TYPE_VIDEO && keyframe &&
2498  cluster_size > 4 * 1024))) {
2499  start_new_cluster = 1;
2500  } else {
2501  start_new_cluster = 0;
2502  }
2503 
2504  if (mkv->cluster_pos != -1 && start_new_cluster) {
2505  mkv_start_new_cluster(s, pkt);
2506  }
2507 
2508  if (!mkv->cluster_pos)
2509  avio_write_marker(s->pb,
2512 
2513  // check if we have an audio packet cached
2514  if (mkv->cur_audio_pkt.size > 0) {
2515  // for DASH audio, a CuePoint has to be added when there is a new cluster.
2517  mkv->is_dash ? start_new_cluster : 0);
2519  if (ret < 0) {
2520  av_log(s, AV_LOG_ERROR,
2521  "Could not write cached audio packet ret:%d\n", ret);
2522  return ret;
2523  }
2524  }
2525 
2526  // buffer an audio packet to ensure the packet containing the video
2527  // keyframe's timecode is contained in the same cluster for WebM
2528  if (codec_type == AVMEDIA_TYPE_AUDIO) {
2529  if (pkt->size > 0)
2530  ret = av_packet_ref(&mkv->cur_audio_pkt, pkt);
2531  } else
2532  ret = mkv_write_packet_internal(s, pkt, 0);
2533  return ret;
2534 }
2535 
2537 {
2538  MatroskaMuxContext *mkv = s->priv_data;
2539 
2540  if (!pkt) {
2541  if (mkv->cluster_pos != -1) {
2542  end_ebml_master_crc32(s->pb, &mkv->cluster_bc, mkv);
2543  mkv->cluster_pos = -1;
2544  av_log(s, AV_LOG_DEBUG,
2545  "Flushing cluster at offset %" PRIu64 " bytes\n",
2546  avio_tell(s->pb));
2547  avio_flush(s->pb);
2548  }
2549  return 1;
2550  }
2551  return mkv_write_packet(s, pkt);
2552 }
2553 
2555 {
2556  MatroskaMuxContext *mkv = s->priv_data;
2557  AVIOContext *pb = s->pb;
2558  int64_t currentpos, cuespos;
2559  int ret;
2560 
2561  // check if we have an audio packet cached
2562  if (mkv->cur_audio_pkt.size > 0) {
2563  ret = mkv_write_packet_internal(s, &mkv->cur_audio_pkt, 0);
2565  if (ret < 0) {
2566  av_log(s, AV_LOG_ERROR,
2567  "Could not write cached audio packet ret:%d\n", ret);
2568  return ret;
2569  }
2570  }
2571 
2572  if (mkv->cluster_bc) {
2573  end_ebml_master_crc32(pb, &mkv->cluster_bc, mkv);
2574  }
2575 
2576  ret = mkv_write_chapters(s);
2577  if (ret < 0)
2578  return ret;
2579 
2580 
2581  if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live) {
2582  if (mkv->cues->num_entries) {
2583  if (mkv->reserve_cues_space) {
2584  int64_t cues_end;
2585 
2586  currentpos = avio_tell(pb);
2587  avio_seek(pb, mkv->cues_pos, SEEK_SET);
2588 
2589  cuespos = mkv_write_cues(s, mkv->cues, mkv->tracks, s->nb_streams);
2590  cues_end = avio_tell(pb);
2591  if (cues_end > cuespos + mkv->reserve_cues_space) {
2592  av_log(s, AV_LOG_ERROR,
2593  "Insufficient space reserved for cues: %d "
2594  "(needed: %" PRId64 ").\n",
2595  mkv->reserve_cues_space, cues_end - cuespos);
2596  return AVERROR(EINVAL);
2597  }
2598 
2599  if (cues_end < cuespos + mkv->reserve_cues_space)
2601  (cues_end - cuespos));
2602 
2603  avio_seek(pb, currentpos, SEEK_SET);
2604  } else {
2605  cuespos = mkv_write_cues(s, mkv->cues, mkv->tracks, s->nb_streams);
2606  }
2607 
2609  cuespos);
2610  if (ret < 0)
2611  return ret;
2612  }
2613 
2614  mkv_write_seekhead(pb, mkv);
2615 
2616  // update the duration
2617  av_log(s, AV_LOG_DEBUG, "end duration = %" PRIu64 "\n", mkv->duration);
2618  currentpos = avio_tell(pb);
2619  avio_seek(mkv->info_bc, mkv->duration_offset, SEEK_SET);
2621  avio_seek(pb, mkv->info_pos, SEEK_SET);
2622  end_ebml_master_crc32(pb, &mkv->info_bc, mkv);
2623 
2624  // write tracks master
2625  avio_seek(pb, mkv->tracks_pos, SEEK_SET);
2626  end_ebml_master_crc32(pb, &mkv->tracks_bc, mkv);
2627 
2628  // update stream durations
2629  if (!mkv->is_live && mkv->stream_durations) {
2630  int i;
2631  int64_t curr = avio_tell(mkv->tags_bc);
2632  for (i = 0; i < s->nb_streams; ++i) {
2633  AVStream *st = s->streams[i];
2634 
2635  if (mkv->stream_duration_offsets[i] > 0) {
2636  double duration_sec = mkv->stream_durations[i] * av_q2d(st->time_base);
2637  char duration_string[20] = "";
2638 
2639  av_log(s, AV_LOG_DEBUG, "stream %d end duration = %" PRIu64 "\n", i,
2640  mkv->stream_durations[i]);
2641 
2642  avio_seek(mkv->tags_bc, mkv->stream_duration_offsets[i], SEEK_SET);
2643 
2644  snprintf(duration_string, 20, "%02d:%02d:%012.9f",
2645  (int) duration_sec / 3600, ((int) duration_sec / 60) % 60,
2646  fmod(duration_sec, 60));
2647 
2648  put_ebml_binary(mkv->tags_bc, MATROSKA_ID_TAGSTRING, duration_string, 20);
2649  }
2650  }
2651  avio_seek(mkv->tags_bc, curr, SEEK_SET);
2652  }
2653  if (mkv->tags_bc && !mkv->is_live) {
2654  avio_seek(pb, mkv->tags_pos, SEEK_SET);
2655  end_ebml_master_crc32(pb, &mkv->tags_bc, mkv);
2656  }
2657 
2658  avio_seek(pb, currentpos, SEEK_SET);
2659  }
2660 
2661  if (!mkv->is_live) {
2662  end_ebml_master(pb, mkv->segment);
2663  }
2664 
2665  mkv_free(mkv);
2666  return 0;
2667 }
2668 
2669 static int mkv_query_codec(enum AVCodecID codec_id, int std_compliance)
2670 {
2671  int i;
2672  for (i = 0; ff_mkv_codec_tags[i].id != AV_CODEC_ID_NONE; i++)
2673  if (ff_mkv_codec_tags[i].id == codec_id)
2674  return 1;
2675 
2676  if (std_compliance < FF_COMPLIANCE_NORMAL) {
2677  enum AVMediaType type = avcodec_get_type(codec_id);
2678  // mkv theoretically supports any video/audio through VFW/ACM
2679  if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO)
2680  return 1;
2681  }
2682 
2683  return 0;
2684 }
2685 
2686 static int webm_query_codec(enum AVCodecID codec_id, int std_compliance)
2687 {
2688  int i;
2689  for (i = 0; ff_webm_codec_tags[i].id != AV_CODEC_ID_NONE; i++)
2690  if (ff_webm_codec_tags[i].id == codec_id)
2691  return 1;
2692 
2693  return 0;
2694 }
2695 
2696 static int mkv_init(struct AVFormatContext *s)
2697 {
2698  int i;
2699 
2700  if (s->nb_streams > MAX_TRACKS) {
2701  av_log(s, AV_LOG_ERROR,
2702  "At most %d streams are supported for muxing in Matroska\n",
2703  MAX_TRACKS);
2704  return AVERROR(EINVAL);
2705  }
2706 
2707  for (i = 0; i < s->nb_streams; i++) {
2708  if (s->streams[i]->codecpar->codec_id == AV_CODEC_ID_ATRAC3 ||
2714  av_log(s, AV_LOG_ERROR,
2715  "The Matroska muxer does not yet support muxing %s\n",
2717  return AVERROR_PATCHWELCOME;
2718  }
2719  }
2720 
2721  if (s->avoid_negative_ts < 0) {
2722  s->avoid_negative_ts = 1;
2724  }
2725 
2726  for (i = 0; i < s->nb_streams; i++) {
2727  // ms precision is the de-facto standard timescale for mkv files
2728  avpriv_set_pts_info(s->streams[i], 64, 1, 1000);
2729  }
2730 
2731  return 0;
2732 }
2733 
2734 static int mkv_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
2735 {
2736  int ret = 1;
2737  AVStream *st = s->streams[pkt->stream_index];
2738 
2739  if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
2740  if (pkt->size > 2 && (AV_RB16(pkt->data) & 0xfff0) == 0xfff0)
2741  ret = ff_stream_add_bitstream_filter(st, "aac_adtstoasc", NULL);
2742  } else if (st->codecpar->codec_id == AV_CODEC_ID_VP9) {
2743  ret = ff_stream_add_bitstream_filter(st, "vp9_superframe", NULL);
2744  }
2745 
2746  return ret;
2747 }
2748 
2750  { AV_CODEC_ID_ALAC, 0XFFFFFFFF },
2751  { AV_CODEC_ID_MLP, 0xFFFFFFFF },
2752  { AV_CODEC_ID_OPUS, 0xFFFFFFFF },
2753  { AV_CODEC_ID_PCM_S16BE, 0xFFFFFFFF },
2754  { AV_CODEC_ID_PCM_S24BE, 0xFFFFFFFF },
2755  { AV_CODEC_ID_PCM_S32BE, 0xFFFFFFFF },
2756  { AV_CODEC_ID_QDMC, 0xFFFFFFFF },
2757  { AV_CODEC_ID_QDM2, 0xFFFFFFFF },
2758  { AV_CODEC_ID_RA_144, 0xFFFFFFFF },
2759  { AV_CODEC_ID_RA_288, 0xFFFFFFFF },
2760  { AV_CODEC_ID_COOK, 0xFFFFFFFF },
2761  { AV_CODEC_ID_TRUEHD, 0xFFFFFFFF },
2762  { AV_CODEC_ID_NONE, 0xFFFFFFFF }
2763 };
2764 
2766  { AV_CODEC_ID_RV10, 0xFFFFFFFF },
2767  { AV_CODEC_ID_RV20, 0xFFFFFFFF },
2768  { AV_CODEC_ID_RV30, 0xFFFFFFFF },
2769  { AV_CODEC_ID_NONE, 0xFFFFFFFF }
2770 };
2771 
2773  { AV_CODEC_ID_DVB_SUBTITLE, 0xFFFFFFFF },
2774  { AV_CODEC_ID_DVD_SUBTITLE, 0xFFFFFFFF },
2775  { AV_CODEC_ID_HDMV_PGS_SUBTITLE, 0xFFFFFFFF },
2776  { AV_CODEC_ID_NONE, 0xFFFFFFFF }
2777 };
2778 
2779 #define OFFSET(x) offsetof(MatroskaMuxContext, x)
2780 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM
2781 static const AVOption options[] = {
2782  { "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 },
2783  { "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 },
2784  { "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 },
2785  { "dash", "Create a WebM file conforming to WebM DASH specification", OFFSET(is_dash), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
2786  { "dash_track_number", "Track number for the DASH stream", OFFSET(dash_track_number), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 127, FLAGS },
2787  { "live", "Write files assuming it is a live stream.", OFFSET(is_live), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
2788  { "allow_raw_vfw", "allow RAW VFW mode", OFFSET(allow_raw_vfw), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
2789  { "write_crc32", "write a CRC32 element inside every Level 1 element", OFFSET(write_crc), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, FLAGS },
2790  { NULL },
2791 };
2792 
2793 #if CONFIG_MATROSKA_MUXER
2794 static const AVClass matroska_class = {
2795  .class_name = "matroska muxer",
2796  .item_name = av_default_item_name,
2797  .option = options,
2798  .version = LIBAVUTIL_VERSION_INT,
2799 };
2800 
2802  .name = "matroska",
2803  .long_name = NULL_IF_CONFIG_SMALL("Matroska"),
2804  .mime_type = "video/x-matroska",
2805  .extensions = "mkv",
2806  .priv_data_size = sizeof(MatroskaMuxContext),
2807  .audio_codec = CONFIG_LIBVORBIS_ENCODER ?
2809  .video_codec = CONFIG_LIBX264_ENCODER ?
2811  .init = mkv_init,
2817  .codec_tag = (const AVCodecTag* const []){
2820  },
2821  .subtitle_codec = AV_CODEC_ID_ASS,
2822  .query_codec = mkv_query_codec,
2823  .check_bitstream = mkv_check_bitstream,
2824  .priv_class = &matroska_class,
2825 };
2826 #endif
2827 
2828 #if CONFIG_WEBM_MUXER
2829 static const AVClass webm_class = {
2830  .class_name = "webm muxer",
2831  .item_name = av_default_item_name,
2832  .option = options,
2833  .version = LIBAVUTIL_VERSION_INT,
2834 };
2835 
2837  .name = "webm",
2838  .long_name = NULL_IF_CONFIG_SMALL("WebM"),
2839  .mime_type = "video/webm",
2840  .extensions = "webm",
2841  .priv_data_size = sizeof(MatroskaMuxContext),
2842  .audio_codec = CONFIG_LIBOPUS_ENCODER ? AV_CODEC_ID_OPUS : AV_CODEC_ID_VORBIS,
2843  .video_codec = CONFIG_LIBVPX_VP9_ENCODER? AV_CODEC_ID_VP9 : AV_CODEC_ID_VP8,
2844  .subtitle_codec = AV_CODEC_ID_WEBVTT,
2845  .init = mkv_init,
2850  .check_bitstream = mkv_check_bitstream,
2853  .priv_class = &webm_class,
2854 };
2855 #endif
2856 
2857 #if CONFIG_MATROSKA_AUDIO_MUXER
2858 static const AVClass mka_class = {
2859  .class_name = "matroska audio muxer",
2860  .item_name = av_default_item_name,
2861  .option = options,
2862  .version = LIBAVUTIL_VERSION_INT,
2863 };
2865  .name = "matroska",
2866  .long_name = NULL_IF_CONFIG_SMALL("Matroska Audio"),
2867  .mime_type = "audio/x-matroska",
2868  .extensions = "mka",
2869  .priv_data_size = sizeof(MatroskaMuxContext),
2870  .audio_codec = CONFIG_LIBVORBIS_ENCODER ?
2872  .video_codec = AV_CODEC_ID_NONE,
2873  .init = mkv_init,
2877  .check_bitstream = mkv_check_bitstream,
2880  .codec_tag = (const AVCodecTag* const []){
2882  },
2883  .priv_class = &mka_class,
2884 };
2885 #endif
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1587
static int mkv_write_packet_internal(AVFormatContext *s, AVPacket *pkt, int add_cue)
Definition: matroskaenc.c:2378
int32_t pitch
Rotation around the right vector [-90, 90].
Definition: spherical.h:127
Definition: lfg.h:27
#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:689
enum AVChromaLocation chroma_location
Definition: avcodec.h:4047
internal header for HEVC (de)muxer utilities
#define AV_DISPOSITION_METADATA
Definition: avformat.h:863
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:463
#define NULL
Definition: coverity.c:32
static int mkv_write_vtt_blocks(AVFormatContext *s, AVIOContext *pb, AVPacket *pkt)
Definition: matroskaenc.c:2214
#define MAX_CUEPOINT_CONTENT_SIZE(num_tracks)
per-cuepoint - 1 1-byte EBML ID, 1 1-byte EBML size, 8-byte uint max
Definition: matroskaenc.c:179
const char const char void * val
Definition: avisynth_c.h:863
#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:4038
void avio_wl16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:469
static void put_ebml_size_unknown(AVIOContext *pb, int bytes)
Write an EBML size meaning "unknown size".
Definition: matroskaenc.c:201
Bytestream IO Context.
Definition: avio.h:161
enum AVColorTransferCharacteristic color_trc
Definition: avcodec.h:4045
#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
void ff_metadata_conv_ctx(AVFormatContext *ctx, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)
Definition: metadata.c:59
#define MATROSKA_ID_DATEUTC
Definition: matroska.h:71
int sizebytes
how many bytes were reserved for the size
Definition: matroskaenc.c:62
#define MAX_TRACKS
Maximum number of tracks allowed in a Matroska file (with track numbers in range 1 to 126 (inclusive)...
Definition: matroskaenc.c:118
The optional first identifier line of a WebVTT cue.
Definition: avcodec.h:1340
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
static void mkv_start_new_cluster(AVFormatContext *s, AVPacket *pkt)
Definition: matroskaenc.c:2257
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1419
AVOption.
Definition: opt.h:246
hash context
Definition: sha.c:34
int64_t cluster_pos
file offset of the cluster containing the block
Definition: matroskaenc.c:83
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:2696
#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:3125
#define MATROSKA_ID_CODECPRIVATE
Definition: matroska.h:89
AVIOContext * cluster_bc
Definition: matroskaenc.c:131
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:4884
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:2772
This side data should be associated with a video stream and contains Stereoscopic 3D information in f...
Definition: avcodec.h:1258
static int mkv_write_attachments(AVFormatContext *s)
Definition: matroskaenc.c:1726
uint64_t pts
Definition: matroskaenc.c:80
enum AVCodecID codec_id
Definition: qsv.c:72
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:867
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:3957
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:943
#define MATROSKA_ID_TAGTARGETS_ATTACHUID
Definition: matroska.h:214
int num
Numerator.
Definition: rational.h:59
int size
Definition: avcodec.h:1478
int ff_hevc_annexb2mp4_buf(const uint8_t *buf_in, uint8_t **buf_out, int *size, int filter_ps, int *ps_count)
Writes Annex B formatted HEVC NAL units to a data buffer.
Definition: hevc.c:1046
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/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(INT64_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 *(INT64_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 *(INT64_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
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
#define MATROSKA_ID_FILEDATA
Definition: matroska.h:246
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1811
#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:1847
#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:85
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:149
#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:3115
int64_t segment_offset
Definition: matroskaenc.c:89
const char * key
int version
Definition: avisynth_c.h:858
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:121
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:983
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:168
Definition: matroskaenc.c:65
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:1319
#define MATROSKA_ID_VIDEOCOLORCHROMASITINGHORZ
Definition: matroska.h:135
mkv_track * tracks
Definition: matroskaenc.c:138
#define src
Definition: vp8dsp.c:254
#define AVFMT_ALLOW_FLUSH
Format allows flushing.
Definition: avformat.h:476
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
static int start_ebml_master_crc32(AVIOContext *pb, AVIOContext **dyn_cp, MatroskaMuxContext *mkv, uint32_t elementid)
Definition: matroskaenc.c:334
#define MATROSKA_ID_CLUSTERTIMECODE
Definition: matroska.h:224
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1390
#define EBML_ID_DOCTYPE
Definition: matroska.h:40
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:477
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3949
#define MATROSKA_ID_CHAPTERTIMEEND
Definition: matroska.h:253
enum AVColorSpace color_space
Definition: avcodec.h:4046
int64_t pos
absolute offset in the containing AVIOContext where the master&#39;s elements start
Definition: matroskaenc.c:61
MatroskaVideoStereoModeType
Definition: matroska.h:300
Mastering display metadata (based on SMPTE-2086:2014).
Definition: avcodec.h:1366
#define FLAGS
Definition: matroskaenc.c:2780
#define MATROSKA_ID_FILEDESC
Definition: matroska.h:243
Format I/O context.
Definition: avformat.h:1358
#define EBML_ID_CRC32
Definition: matroska.h:46
UID uid
Definition: mxfenc.c:2215
static int mkv_add_seekhead_entry(mkv_seekhead *seekhead, uint32_t elementid, uint64_t filepos)
Definition: matroskaenc.c:458
char str[32]
Definition: internal.h:50
static int query_codec(enum AVCodecID id, int std_compliance)
Definition: img2enc.c:199
int64_t cluster_pos
file offset of the current cluster
Definition: matroskaenc.c:132
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:2749
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:369
uint8_t
#define MATROSKA_ID_VIDEOCOLOR_BX
Definition: matroska.h:149
#define MATROSKA_ID_CHAPLANG
Definition: matroska.h:256
#define av_malloc(s)
int width
Video only.
Definition: avcodec.h:4023
AVOptions.
#define MATROSKA_ID_TRACKLANGUAGE
Definition: matroska.h:97
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: utils.c:1999
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:182
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:67
int id
unique ID to identify the chapter
Definition: avformat.h:1316
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1495
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:800
#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:987
void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type)
Mark the written bytestream as a specific type.
Definition: aviobuf.c:493
uint8_t * av_stream_get_side_data(const AVStream *stream, enum AVPacketSideDataType type, int *size)
Get side information from stream.
Definition: utils.c:5445
#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:1426
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:4086
static int webm_query_codec(enum AVCodecID codec_id, int std_compliance)
Definition: matroskaenc.c:2686
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:1489
uint8_t * data
Definition: avcodec.h:1477
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
static int64_t mkv_write_cues(AVFormatContext *s, mkv_cues *cues, mkv_track *tracks, int num_tracks)
Definition: matroskaenc.c:569
#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:300
#define MATROSKA_ID_BLOCKADDITIONS
Definition: matroska.h:228
uint32_t tag
Definition: movenc.c:1496
static EbmlSyntax ebml_header[]
Definition: matroskadec.c:403
Not part of ABI.
Definition: pixfmt.h:523
#define WV_HEADER_SIZE
Definition: wavpack.h:30
enum AVCodecID id
Definition: internal.h:51
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
uint8_t * data
Definition: avcodec.h:1421
#define MATROSKA_ID_CUES
Definition: matroska.h:58
int64_t ts_offset
Definition: matroskaenc.c:100
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:218
Definition: wv.h:34
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1506
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
uint64_t channel_layout
Audio only.
Definition: avcodec.h:4059
static void put_ebml_num(AVIOContext *pb, uint64_t num, int bytes)
Write a number in EBML variable length format.
Definition: matroskaenc.c:225
#define av_log(a,...)
int has_cue
Definition: matroskaenc.c:96
#define AV_DISPOSITION_CAPTIONS
To specify text track kind (different from subtitles default).
Definition: avformat.h:861
int64_t segment_offset
the file offset to the beginning of the segment
Definition: matroskaenc.c:72
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: avpacket.c:608
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1509
#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:129
static int mkv_write_simpletag(AVIOContext *pb, AVDictionaryEntry *t)
Definition: matroskaenc.c:1533
#define MATROSKA_ID_VIDEOSTEREOMODE
Definition: matroska.h:123
uint32_t chapter_id_offset
Definition: matroskaenc.c:155
static void put_ebml_id(AVIOContext *pb, uint32_t id)
Definition: matroskaenc.c:189
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:5651
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
AVPacket cur_audio_pkt
Definition: matroskaenc.c:141
#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:215
static int mkv_write_tags(AVFormatContext *s)
Definition: matroskaenc.c:1640
#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:2020
#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:270
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1513
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1598
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
per-cuepoint-track - 5 1-byte EBML IDs, 5 1-byte EBML sizes, 3 8-byte uint max and one 1-byte uint fo...
Definition: matroskaenc.c:176
#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:714
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
-1 if appending to file
Definition: matroskaenc.c:73
#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
Views are packed per line, as if interlaced.
Definition: stereo3d.h:129
enum AVColorPrimaries color_primaries
Definition: avcodec.h:4044
#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:1062
Not part of ABI.
Definition: pixfmt.h:460
AVIOContext * tracks_bc
Definition: matroskaenc.c:127
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:2045
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3953
static int ebml_num_size(uint64_t num)
Calculate how many bytes are needed to represent a given number in EBML.
Definition: matroskaenc.c:211
int write_dts
Definition: matroskaenc.c:95
int final
Definition: wv.h:43
AVChapter ** chapters
Definition: avformat.h:1588
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:354
enum AVPacketSideDataType type
Definition: avcodec.h:1423
enum AVMediaType avcodec_get_type(enum AVCodecID codec_id)
Get the type of the given codec.
Definition: codec_desc.c:3282
static int mkv_write_chapters(AVFormatContext *s)
Definition: matroskaenc.c:1475
#define EBML_ID_EBMLMAXIDLENGTH
Definition: matroska.h:38
#define MATROSKA_ID_CHAPTERFLAGHIDDEN
Definition: matroska.h:263
uint32_t crc
Definition: wv.h:41
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:954
const AVCodecTag ff_codec_wav_tags[]
Definition: riff.c:494
#define FFMAX(a, b)
Definition: common.h:94
static mkv_seekhead * mkv_start_seekhead(AVIOContext *pb, int64_t segment_offset, int numelements)
Initialize a mkv_seekhead element to be ready to index level 1 Matroska elements. ...
Definition: matroskaenc.c:437
int ff_avc_parse_nal_units_buf(const uint8_t *buf_in, uint8_t **buf, int *size)
Definition: avc.c:94
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:2009
int64_t filepos
Definition: matroskaenc.c:71
#define fail()
Definition: checkasm.h:120
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1483
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3975
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:838
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1414
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
#define b
Definition: input.c:41
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
int void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:238
#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:3288
#define EBML_ID_EBMLVERSION
Definition: matroska.h:36
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:90
void ffio_fill(AVIOContext *s, int b, int count)
Definition: aviobuf.c:204
#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:656
static void end_ebml_master_crc32(AVIOContext *pb, AVIOContext **dyn_cp, MatroskaMuxContext *mkv)
Definition: matroskaenc.c:349
static void mkv_free(MatroskaMuxContext *mkv)
Free the members allocated in the mux context.
Definition: matroskaenc.c:391
#define MATROSKA_ID_CHAPTERFLAGENABLED
Definition: matroska.h:264
static int64_t mkv_write_seekhead(AVIOContext *pb, MatroskaMuxContext *mkv)
Write the seek head to the file and free it.
Definition: matroskaenc.c:486
static int mkv_write_native_codecprivate(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, AVIOContext *dyn_cp)
Definition: matroskaenc.c:747
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:1823
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:466
This side data should be associated with a video stream and corresponds to the AVSphericalMapping str...
Definition: avcodec.h:1372
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:505
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:2270
int ff_flac_write_header(AVIOContext *pb, uint8_t *extradata, int extradata_size, int last_block)
#define s(width, name)
Definition: cbs_vp9.c:257
int avoid_negative_ts
Avoid negative timestamps during muxing.
Definition: avformat.h:1689
#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:945
enum AVColorRange color_range
Video only.
Definition: avcodec.h:4043
AVIOContext * info_bc
Definition: matroskaenc.c:125
Opaque data information usually sparse.
Definition: avutil.h:205
#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:2779
#define MATROSKA_ID_AUDIOSAMPLINGFREQ
Definition: matroska.h:164
static int mkv_check_tag(AVDictionary *m, uint32_t elementid)
Definition: matroskaenc.c:1629
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:1146
ff_const59 struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1377
uint32_t padding
Number of pixels to pad from the edge of each cube face.
Definition: spherical.h:182
static int mkv_add_cuepoint(mkv_cues *cues, int stream, int tracknum, int64_t ts, int64_t cluster_pos, int64_t relative_pos, int64_t duration)
Definition: matroskaenc.c:546
int metadata_header_padding
Number of bytes to be written as padding in a metadata header.
Definition: avformat.h:1858
Stream structure.
Definition: avformat.h:881
#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:1318
Content light level (based on CTA-861.3).
Definition: avcodec.h:1379
static int mkv_write_track(AVFormatContext *s, MatroskaMuxContext *mkv, int i, AVIOContext *pb, int default_stream_exists)
Definition: matroskaenc.c:1171
#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:1199
#define AV_DISPOSITION_DEFAULT
Definition: avformat.h:826
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:862
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:98
#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:1400
int64_t codecpriv_offset
Definition: matroskaenc.c:99
static void put_ebml_uint(AVIOContext *pb, uint32_t elementid, uint64_t val)
Definition: matroskaenc.c:244
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:196
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:599
#define MATROSKA_ID_TAGTARGETS_TRACKUID
Definition: matroska.h:212
mkv_attachment * entries
Definition: matroskaenc.c:109
uint32_t fileuid
Definition: matroskaenc.c:105
#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:47
int ff_av1_filter_obus_buf(const uint8_t *buf, uint8_t **out, int *size)
Filter out AV1 OBUs not meant to be present in ISOBMFF sample data and write the resulting bitstream ...
Definition: av1.c:60
#define MATROSKA_ID_TRACKS
Definition: matroska.h:57
void * buf
Definition: avisynth_c.h:766
Data found in BlockAdditional element of matroska container.
Definition: avcodec.h:1335
#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 MATROSKA_ID_EDITIONENTRY
Definition: matroska.h:250
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:2631
static int mkv_check_tag_name(const char *name, uint32_t elementid)
Definition: matroskaenc.c:1591
#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:1443
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:1567
#define MATROSKA_ID_CUETIME
Definition: matroska.h:191
Not part of ABI.
Definition: pixfmt.h:489
AVFieldOrder
Definition: avcodec.h:1543
Recommmends skipping the specified number of samples.
Definition: avcodec.h:1300
AVMediaType
Definition: avutil.h:199
static void mkv_write_block(AVFormatContext *s, AVIOContext *pb, uint32_t blockid, AVPacket *pkt, int keyframe)
Definition: matroskaenc.c:2107
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:32
int64_t duration_offset
Definition: matroskaenc.c:134
#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:2054
This structure describes how to handle spherical videos, outlining information about projection...
Definition: spherical.h:82
#define MATROSKA_ID_VIDEOPROJECTION
Definition: matroska.h:156
#define MATROSKA_ID_VIDEOCOLORMASTERINGMETA
Definition: matroska.h:144
misc parsing utilities
#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:475
#define flags(name, subs,...)
Definition: cbs_av1.c:561
int64_t * stream_duration_offsets
Definition: matroskaenc.c:161
#define MATROSKA_ID_CHAPTERDISPLAY
Definition: matroska.h:254
static int put_xiph_codecpriv(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par)
Definition: matroskaenc.c:628
int bits_per_raw_sample
This is the number of valid bits in each output sample.
Definition: avcodec.h:4012
#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:2765
static int put_flac_codecpriv(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par)
Definition: matroskaenc.c:665
#define MATROSKA_ID_VIDEOFIELDORDER
Definition: matroska.h:122
int64_t start
Definition: avformat.h:1318
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:4067
#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:2554
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:2734
attribute_deprecated int64_t convergence_duration
Definition: avcodec.h:1506
#define MATROSKA_ID_CUETRACK
Definition: matroska.h:195
#define MATROSKA_ID_SEEKPOSITION
Definition: matroska.h:221
int64_t last_track_timestamp[MAX_TRACKS]
Definition: matroskaenc.c:158
#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.
int ffio_init_context(AVIOContext *s, unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
Definition: aviobuf.c:81
static void end_ebml_master_crc32_preliminary(AVIOContext *pb, AVIOContext **dyn_cp, MatroskaMuxContext *mkv, int64_t *pos)
Complete ebml master without destroying the buffer, allowing for later updates.
Definition: matroskaenc.c:370
static int mkv_write_flush_packet(AVFormatContext *s, AVPacket *pkt)
Definition: matroskaenc.c:2536
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:934
static ebml_master start_ebml_master(AVIOContext *pb, uint32_t elementid, uint64_t expectedsize)
Definition: matroskaenc.c:314
static void put_ebml_void(AVIOContext *pb, uint64_t size)
Write a void element of a given size.
Definition: matroskaenc.c:297
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:1317
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:119
int avpriv_mpeg4audio_get_config(MPEG4AudioConfig *c, const uint8_t *buf, int bit_size, int sync_extension)
Parse MPEG-4 systems extradata from a raw buffer to retrieve audio configuration. ...
Definition: mpeg4audio.c:155
The optional settings (rendering instructions) that immediately follow the timestamp specifier of a W...
Definition: avcodec.h:1346
#define MATROSKA_ID_SEEKHEAD
Definition: matroska.h:60
#define EBML_ID_HEADER
Definition: matroska.h:33
uint32_t elementid
Definition: matroskaenc.c:66
A point in the output bytestream where a decoder can start decoding (i.e.
Definition: avio.h:122
mkv_attachments * attachments
Definition: matroskaenc.c:139
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:470
#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
mkv_seekhead_entry * entries
Definition: matroskaenc.c:75
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:1073
#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:5514
static void put_ebml_binary(AVIOContext *pb, uint32_t elementid, const void *buf, int size)
Definition: matroskaenc.c:277
void * priv_data
Format private data.
Definition: avformat.h:1386
#define MATROSKA_ID_CHAPTERUID
Definition: matroska.h:262
char str[22]
Definition: matroska.h:353
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:337
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:3999
int64_t relative_pos
relative offset from the position of the cluster containing the block
Definition: matroskaenc.c:84
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3971
#define MATROSKA_ID_VIDEOCOLORMAXFALL
Definition: matroska.h:142
#define MATROSKA_ID_VIDEODISPLAYUNIT
Definition: matroska.h:120
int channels
Audio only.
Definition: avcodec.h:4063
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1476
static const AVOption options[]
Definition: matroskaenc.c:2781
#define EBML_ID_EBMLMAXSIZELENGTH
Definition: matroska.h:39
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:377
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1473
#define MATROSKA_ID_CHAPSTRING
Definition: matroska.h:255
int sample_rate
Definition: matroskaenc.c:97
#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:113
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:285
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:1028
static void put_ebml_sint(AVIOContext *pb, uint32_t elementid, int64_t val)
Definition: matroskaenc.c:257
#define MODE_WEBM
Definition: matroskaenc.c:114
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:3961
static int mkv_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: matroskaenc.c:2460
#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:172
static mkv_cues * mkv_start_cues(int64_t segment_offset)
Definition: matroskaenc.c:536
int stream_index
Definition: avcodec.h:1479
int num_entries
Definition: matroskaenc.c:91
#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:910
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:324
int64_t segment_offset
Definition: matroskaenc.c:130
static int mkv_write_tag(AVFormatContext *s, AVDictionary *m, uint32_t elementid, unsigned int uid)
Definition: matroskaenc.c:1605
#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
unsigned MaxFALL
Max average light level per frame (cd/m^2).
This structure stores compressed data.
Definition: avcodec.h:1454
int64_t * stream_durations
Definition: matroskaenc.c:160
static void mkv_write_field_order(AVIOContext *pb, int mode, enum AVFieldOrder field_order)
Definition: matroskaenc.c:1034
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:2669
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:1470
Not part of ABI.
Definition: pixfmt.h:513
#define MATROSKA_ID_VIDEOPIXELWIDTH
Definition: matroska.h:114
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:123
const CodecTags ff_mkv_codec_tags[]
Definition: matroska.c:29
mkv_seekhead * seekhead
Definition: matroskaenc.c:136
int avio_printf(AVIOContext *s, const char *fmt,...) av_printf_format(2
static int ebml_id_size(uint32_t id)
Definition: matroskaenc.c:184
#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:957
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:1402
static uint8_t tmp[11]
Definition: aes_ctr.c:26