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