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, any number of bytes can 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  // don't care how many bytes are used, so use the min
232  bytes = needed_bytes;
233  // the bytes needed to write the given size would exceed the bytes
234  // that we need to use, so write unknown size. This shouldn't happen.
235  av_assert0(bytes >= needed_bytes);
236 
237  num |= 1ULL << bytes * 7;
238  for (i = bytes - 1; i >= 0; i--)
239  avio_w8(pb, (uint8_t)(num >> i * 8));
240 }
241 
242 static void put_ebml_uint(AVIOContext *pb, uint32_t elementid, uint64_t val)
243 {
244  int i, bytes = 1;
245  uint64_t tmp = val;
246  while (tmp >>= 8)
247  bytes++;
248 
249  put_ebml_id(pb, elementid);
250  put_ebml_num(pb, bytes, 0);
251  for (i = bytes - 1; i >= 0; i--)
252  avio_w8(pb, (uint8_t)(val >> i * 8));
253 }
254 
255 static void put_ebml_sint(AVIOContext *pb, uint32_t elementid, int64_t val)
256 {
257  int i, bytes = 1;
258  uint64_t tmp = 2*(val < 0 ? val^-1 : val);
259 
260  while (tmp>>=8) bytes++;
261 
262  put_ebml_id(pb, elementid);
263  put_ebml_num(pb, bytes, 0);
264  for (i = bytes - 1; i >= 0; i--)
265  avio_w8(pb, (uint8_t)(val >> i * 8));
266 }
267 
268 static void put_ebml_float(AVIOContext *pb, uint32_t elementid, double val)
269 {
270  put_ebml_id(pb, elementid);
271  put_ebml_num(pb, 8, 0);
272  avio_wb64(pb, av_double2int(val));
273 }
274 
275 static void put_ebml_binary(AVIOContext *pb, uint32_t elementid,
276  const void *buf, int size)
277 {
278  put_ebml_id(pb, elementid);
279  put_ebml_num(pb, size, 0);
280  avio_write(pb, buf, size);
281 }
282 
283 static void put_ebml_string(AVIOContext *pb, uint32_t elementid,
284  const char *str)
285 {
286  put_ebml_binary(pb, elementid, str, strlen(str));
287 }
288 
289 /**
290  * Write a void element of a given size. Useful for reserving space in
291  * the file to be written to later.
292  *
293  * @param size The number of bytes to reserve, which must be at least 2.
294  */
295 static void put_ebml_void(AVIOContext *pb, uint64_t size)
296 {
297  int64_t currentpos = avio_tell(pb);
298 
299  av_assert0(size >= 2);
300 
302  // we need to subtract the length needed to store the size from the
303  // size we need to reserve so 2 cases, we use 8 bytes to store the
304  // size if possible, 1 byte otherwise
305  if (size < 10)
306  put_ebml_num(pb, size - 2, 0);
307  else
308  put_ebml_num(pb, size - 9, 8);
309  ffio_fill(pb, 0, currentpos + size - avio_tell(pb));
310 }
311 
312 static ebml_master start_ebml_master(AVIOContext *pb, uint32_t elementid,
313  uint64_t expectedsize)
314 {
315  int bytes = expectedsize ? ebml_num_size(expectedsize) : 8;
316 
317  put_ebml_id(pb, elementid);
318  put_ebml_size_unknown(pb, bytes);
319  return (ebml_master) { avio_tell(pb), bytes };
320 }
321 
323 {
324  int64_t pos = avio_tell(pb);
325 
326  if (avio_seek(pb, master.pos - master.sizebytes, SEEK_SET) < 0)
327  return;
328  put_ebml_num(pb, pos - master.pos, master.sizebytes);
329  avio_seek(pb, pos, SEEK_SET);
330 }
331 
333  uint32_t elementid)
334 {
335  int ret;
336 
337  if ((ret = avio_open_dyn_buf(dyn_cp)) < 0)
338  return ret;
339 
340  put_ebml_id(pb, elementid);
341  if (mkv->write_crc)
342  put_ebml_void(*dyn_cp, 6); /* Reserve space for CRC32 so position/size calculations using avio_tell() take it into account */
343 
344  return 0;
345 }
346 
348 {
349  uint8_t *buf, crc[4];
350  int size, skip = 0;
351 
352  size = avio_close_dyn_buf(*dyn_cp, &buf);
353  put_ebml_num(pb, size, 0);
354  if (mkv->write_crc) {
355  skip = 6; /* Skip reserved 6-byte long void element from the dynamic buffer. */
356  AV_WL32(crc, av_crc(av_crc_get_table(AV_CRC_32_IEEE_LE), UINT32_MAX, buf + skip, size - skip) ^ UINT32_MAX);
357  put_ebml_binary(pb, EBML_ID_CRC32, crc, sizeof(crc));
358  }
359  avio_write(pb, buf + skip, size - skip);
360 
361  av_free(buf);
362  *dyn_cp = NULL;
363 }
364 
365 /**
366 * Complete ebml master without destroying the buffer, allowing for later updates
367 */
369  int64_t *pos)
370 {
371  uint8_t *buf;
372  int size = avio_get_dyn_buf(*dyn_cp, &buf);
373 
374  *pos = avio_tell(pb);
375 
376  put_ebml_num(pb, size, 0);
377  avio_write(pb, buf, size);
378 }
379 
380 static void put_xiph_size(AVIOContext *pb, int size)
381 {
382  ffio_fill(pb, 255, size / 255);
383  avio_w8(pb, size % 255);
384 }
385 
386 /**
387  * Free the members allocated in the mux context.
388  */
390 {
391  MatroskaMuxContext *mkv = s->priv_data;
392 
394  ffio_free_dyn_buf(&mkv->info_bc);
396  ffio_free_dyn_buf(&mkv->tags_bc);
397 
398  if (mkv->seekhead) {
399  av_freep(&mkv->seekhead->entries);
400  av_freep(&mkv->seekhead);
401  }
402  if (mkv->cues) {
403  av_freep(&mkv->cues->entries);
404  av_freep(&mkv->cues);
405  }
406  if (mkv->attachments) {
407  av_freep(&mkv->attachments->entries);
408  av_freep(&mkv->attachments);
409  }
410  av_freep(&mkv->tracks);
411 }
412 
413 /**
414  * Initialize a mkv_seekhead element to be ready to index level 1 Matroska
415  * elements. If a maximum number of elements is specified, enough space
416  * will be reserved at the current file location to write a seek head of
417  * that size.
418  *
419  * @param segment_offset The absolute offset to the position in the file
420  * where the segment begins.
421  * @param numelements The maximum number of elements that will be indexed
422  * by this seek head, 0 if unlimited.
423  */
424 static mkv_seekhead *mkv_start_seekhead(AVIOContext *pb, int64_t segment_offset,
425  int numelements)
426 {
427  mkv_seekhead *new_seekhead = av_mallocz(sizeof(mkv_seekhead));
428  if (!new_seekhead)
429  return NULL;
430 
431  new_seekhead->segment_offset = segment_offset;
432 
433  if (numelements > 0) {
434  new_seekhead->filepos = avio_tell(pb);
435  // 21 bytes max for a seek entry, 10 bytes max for the SeekHead ID
436  // and size, 6 bytes for a CRC32 element, and 3 bytes to guarantee
437  // that an EBML void element will fit afterwards
438  new_seekhead->reserved_size = numelements * MAX_SEEKENTRY_SIZE + 19;
439  new_seekhead->max_entries = numelements;
440  put_ebml_void(pb, new_seekhead->reserved_size);
441  }
442  return new_seekhead;
443 }
444 
445 static int mkv_add_seekhead_entry(mkv_seekhead *seekhead, uint32_t elementid, uint64_t filepos)
446 {
447  mkv_seekhead_entry *entries = seekhead->entries;
448 
449  // don't store more elements than we reserved space for
450  if (seekhead->max_entries > 0 && seekhead->max_entries <= seekhead->num_entries)
451  return -1;
452 
453  entries = av_realloc_array(entries, seekhead->num_entries + 1, sizeof(mkv_seekhead_entry));
454  if (!entries)
455  return AVERROR(ENOMEM);
456  seekhead->entries = entries;
457 
458  seekhead->entries[seekhead->num_entries].elementid = elementid;
459  seekhead->entries[seekhead->num_entries++].segmentpos = filepos - seekhead->segment_offset;
460 
461  return 0;
462 }
463 
464 /**
465  * Write the seek head to the file and free it. If a maximum number of
466  * elements was specified to mkv_start_seekhead(), the seek head will
467  * be written at the location reserved for it. Otherwise, it is written
468  * at the current location in the file.
469  *
470  * @return The file offset where the seekhead was written,
471  * -1 if an error occurred.
472  */
474 {
475  AVIOContext *dyn_cp;
476  mkv_seekhead *seekhead = mkv->seekhead;
477  ebml_master seekentry;
478  int64_t currentpos;
479  int i;
480 
481  currentpos = avio_tell(pb);
482 
483  if (seekhead->reserved_size > 0) {
484  if (avio_seek(pb, seekhead->filepos, SEEK_SET) < 0) {
485  currentpos = -1;
486  goto fail;
487  }
488  }
489 
490  if (start_ebml_master_crc32(pb, &dyn_cp, mkv, MATROSKA_ID_SEEKHEAD) < 0) {
491  currentpos = -1;
492  goto fail;
493  }
494 
495  for (i = 0; i < seekhead->num_entries; i++) {
496  mkv_seekhead_entry *entry = &seekhead->entries[i];
497 
499 
501  put_ebml_num(dyn_cp, ebml_id_size(entry->elementid), 0);
502  put_ebml_id(dyn_cp, entry->elementid);
503 
505  end_ebml_master(dyn_cp, seekentry);
506  }
507  end_ebml_master_crc32(pb, &dyn_cp, mkv);
508 
509  if (seekhead->reserved_size > 0) {
510  uint64_t remaining = seekhead->filepos + seekhead->reserved_size - avio_tell(pb);
511  put_ebml_void(pb, remaining);
512  avio_seek(pb, currentpos, SEEK_SET);
513 
514  currentpos = seekhead->filepos;
515  }
516 fail:
517  av_freep(&mkv->seekhead->entries);
518  av_freep(&mkv->seekhead);
519 
520  return currentpos;
521 }
522 
523 static mkv_cues *mkv_start_cues(int64_t segment_offset)
524 {
525  mkv_cues *cues = av_mallocz(sizeof(mkv_cues));
526  if (!cues)
527  return NULL;
528 
529  cues->segment_offset = segment_offset;
530  return cues;
531 }
532 
533 static int mkv_add_cuepoint(mkv_cues *cues, int stream, int tracknum, int64_t ts,
534  int64_t cluster_pos, int64_t relative_pos, int64_t duration)
535 {
536  mkv_cuepoint *entries = cues->entries;
537 
538  if (ts < 0)
539  return 0;
540 
541  entries = av_realloc_array(entries, cues->num_entries + 1, sizeof(mkv_cuepoint));
542  if (!entries)
543  return AVERROR(ENOMEM);
544  cues->entries = entries;
545 
546  cues->entries[cues->num_entries].pts = ts;
547  cues->entries[cues->num_entries].stream_idx = stream;
548  cues->entries[cues->num_entries].tracknum = tracknum;
549  cues->entries[cues->num_entries].cluster_pos = cluster_pos - cues->segment_offset;
550  cues->entries[cues->num_entries].relative_pos = relative_pos;
551  cues->entries[cues->num_entries++].duration = duration;
552 
553  return 0;
554 }
555 
556 static int64_t mkv_write_cues(AVFormatContext *s, mkv_cues *cues, mkv_track *tracks, int num_tracks)
557 {
558  MatroskaMuxContext *mkv = s->priv_data;
559  AVIOContext *dyn_cp, *pb = s->pb;
560  int64_t currentpos;
561  int i, j, ret;
562 
563  currentpos = avio_tell(pb);
564  ret = start_ebml_master_crc32(pb, &dyn_cp, mkv, MATROSKA_ID_CUES);
565  if (ret < 0)
566  return ret;
567 
568  for (i = 0; i < cues->num_entries; i++) {
569  ebml_master cuepoint, track_positions;
570  mkv_cuepoint *entry = &cues->entries[i];
571  uint64_t pts = entry->pts;
572  int ctp_nb = 0;
573 
574  // Calculate the number of entries, so we know the element size
575  for (j = 0; j < num_tracks; j++)
576  tracks[j].has_cue = 0;
577  for (j = 0; j < cues->num_entries - i && entry[j].pts == pts; j++) {
578  int idx = entry[j].stream_idx;
579 
580  av_assert0(idx >= 0 && idx < num_tracks);
581  if (tracks[idx].has_cue && s->streams[idx]->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE)
582  continue;
583  tracks[idx].has_cue = 1;
584  ctp_nb ++;
585  }
586 
588  put_ebml_uint(dyn_cp, MATROSKA_ID_CUETIME, pts);
589 
590  // put all the entries from different tracks that have the exact same
591  // timestamp into the same CuePoint
592  for (j = 0; j < num_tracks; j++)
593  tracks[j].has_cue = 0;
594  for (j = 0; j < cues->num_entries - i && entry[j].pts == pts; j++) {
595  int idx = entry[j].stream_idx;
596 
597  if (tracks[idx].has_cue && s->streams[idx]->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE)
598  continue;
599  tracks[idx].has_cue = 1;
601  put_ebml_uint(dyn_cp, MATROSKA_ID_CUETRACK , entry[j].tracknum );
602  put_ebml_uint(dyn_cp, MATROSKA_ID_CUECLUSTERPOSITION , entry[j].cluster_pos);
603  put_ebml_uint(dyn_cp, MATROSKA_ID_CUERELATIVEPOSITION, entry[j].relative_pos);
604  if (entry[j].duration != -1)
605  put_ebml_uint(dyn_cp, MATROSKA_ID_CUEDURATION , entry[j].duration);
606  end_ebml_master(dyn_cp, track_positions);
607  }
608  i += j - 1;
609  end_ebml_master(dyn_cp, cuepoint);
610  }
611  end_ebml_master_crc32(pb, &dyn_cp, mkv);
612 
613  return currentpos;
614 }
615 
617 {
618  const uint8_t *header_start[3];
619  int header_len[3];
620  int first_header_size;
621  int j;
622 
623  if (par->codec_id == AV_CODEC_ID_VORBIS)
624  first_header_size = 30;
625  else
626  first_header_size = 42;
627 
629  first_header_size, header_start, header_len) < 0) {
630  av_log(s, AV_LOG_ERROR, "Extradata corrupt.\n");
631  return -1;
632  }
633 
634  avio_w8(pb, 2); // number packets - 1
635  for (j = 0; j < 2; j++) {
636  put_xiph_size(pb, header_len[j]);
637  }
638  for (j = 0; j < 3; j++)
639  avio_write(pb, header_start[j], header_len[j]);
640 
641  return 0;
642 }
643 
645 {
646  if (par->extradata && par->extradata_size == 2)
647  avio_write(pb, par->extradata, 2);
648  else
649  avio_wl16(pb, 0x403); // fallback to the version mentioned in matroska specs
650  return 0;
651 }
652 
654  AVIOContext *pb, AVCodecParameters *par)
655 {
656  int write_comment = (par->channel_layout &&
657  !(par->channel_layout & ~0x3ffffULL) &&
659  int ret = ff_flac_write_header(pb, par->extradata, par->extradata_size,
660  !write_comment);
661 
662  if (ret < 0)
663  return ret;
664 
665  if (write_comment) {
666  const char *vendor = (s->flags & AVFMT_FLAG_BITEXACT) ?
667  "Lavf" : LIBAVFORMAT_IDENT;
668  AVDictionary *dict = NULL;
669  uint8_t buf[32], *data, *p;
670  int64_t len;
671 
672  snprintf(buf, sizeof(buf), "0x%"PRIx64, par->channel_layout);
673  av_dict_set(&dict, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", buf, 0);
674 
675  len = ff_vorbiscomment_length(dict, vendor, NULL, 0);
676  if (len >= ((1<<24) - 4)) {
677  av_dict_free(&dict);
678  return AVERROR(EINVAL);
679  }
680 
681  data = av_malloc(len + 4);
682  if (!data) {
683  av_dict_free(&dict);
684  return AVERROR(ENOMEM);
685  }
686 
687  data[0] = 0x84;
688  AV_WB24(data + 1, len);
689 
690  p = data + 4;
691  ff_vorbiscomment_write(&p, &dict, vendor, NULL, 0);
692 
693  avio_write(pb, data, len + 4);
694 
695  av_freep(&data);
696  av_dict_free(&dict);
697  }
698 
699  return 0;
700 }
701 
702 static int get_aac_sample_rates(AVFormatContext *s, uint8_t *extradata, int extradata_size,
703  int *sample_rate, int *output_sample_rate)
704 {
705  MPEG4AudioConfig mp4ac;
706  int ret;
707 
708  ret = avpriv_mpeg4audio_get_config2(&mp4ac, extradata, extradata_size, 1, s);
709  /* Don't abort if the failure is because of missing extradata. Assume in that
710  * case a bitstream filter will provide the muxer with the extradata in the
711  * first packet.
712  * Abort however if s->pb is not seekable, as we would not be able to seek back
713  * to write the sample rate elements once the extradata shows up, anyway. */
714  if (ret < 0 && (extradata_size || !(s->pb->seekable & AVIO_SEEKABLE_NORMAL))) {
715  av_log(s, AV_LOG_ERROR,
716  "Error parsing AAC extradata, unable to determine samplerate.\n");
717  return AVERROR(EINVAL);
718  }
719 
720  if (ret < 0) {
721  /* This will only happen when this function is called while writing the
722  * header and no extradata is available. The space for this element has
723  * to be reserved for when this function is called again after the
724  * extradata shows up in the first packet, as there's no way to know if
725  * output_sample_rate will be different than sample_rate or not. */
726  *output_sample_rate = *sample_rate;
727  } else {
728  *sample_rate = mp4ac.sample_rate;
729  *output_sample_rate = mp4ac.ext_sample_rate;
730  }
731  return 0;
732 }
733 
735  AVCodecParameters *par,
736  AVIOContext *dyn_cp)
737 {
738  switch (par->codec_id) {
739  case AV_CODEC_ID_VORBIS:
740  case AV_CODEC_ID_THEORA:
741  return put_xiph_codecpriv(s, dyn_cp, par);
742  case AV_CODEC_ID_FLAC:
743  return put_flac_codecpriv(s, dyn_cp, par);
744  case AV_CODEC_ID_WAVPACK:
745  return put_wv_codecpriv(dyn_cp, par);
746  case AV_CODEC_ID_H264:
747  return ff_isom_write_avcc(dyn_cp, par->extradata,
748  par->extradata_size);
749  case AV_CODEC_ID_HEVC:
750  ff_isom_write_hvcc(dyn_cp, par->extradata,
751  par->extradata_size, 0);
752  return 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_close_dyn_buf(dyn_cp, &codecpriv);
847  if (codecpriv_size)
849  codecpriv_size);
850  av_free(codecpriv);
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_close_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  av_free(colorinfo_ptr);
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  avio_flush(pb);
2004 
2005  // start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or
2006  // after 4k and on a keyframe
2007  if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
2008  if (mkv->cluster_time_limit < 0)
2009  mkv->cluster_time_limit = 5000;
2010  if (mkv->cluster_size_limit < 0)
2011  mkv->cluster_size_limit = 5 * 1024 * 1024;
2012  } else {
2013  if (mkv->cluster_time_limit < 0)
2014  mkv->cluster_time_limit = 1000;
2015  if (mkv->cluster_size_limit < 0)
2016  mkv->cluster_size_limit = 32 * 1024;
2017  }
2018 
2019  return 0;
2020 }
2021 
2022 static int mkv_blockgroup_size(int pkt_size)
2023 {
2024  int size = pkt_size + 4;
2025  size += ebml_num_size(size);
2026  size += 2; // EBML ID for block and block duration
2027  size += 9; // max size of block duration incl. length field
2028  return size;
2029 }
2030 
2031 static int mkv_strip_wavpack(const uint8_t *src, uint8_t **pdst, int *size)
2032 {
2033  uint8_t *dst;
2034  int srclen = *size;
2035  int offset = 0;
2036  int ret;
2037 
2038  dst = av_malloc(srclen);
2039  if (!dst)
2040  return AVERROR(ENOMEM);
2041 
2042  while (srclen >= WV_HEADER_SIZE) {
2043  WvHeader header;
2044 
2045  ret = ff_wv_parse_header(&header, src);
2046  if (ret < 0)
2047  goto fail;
2048  src += WV_HEADER_SIZE;
2049  srclen -= WV_HEADER_SIZE;
2050 
2051  if (srclen < header.blocksize) {
2052  ret = AVERROR_INVALIDDATA;
2053  goto fail;
2054  }
2055 
2056  if (header.initial) {
2057  AV_WL32(dst + offset, header.samples);
2058  offset += 4;
2059  }
2060  AV_WL32(dst + offset, header.flags);
2061  AV_WL32(dst + offset + 4, header.crc);
2062  offset += 8;
2063 
2064  if (!(header.initial && header.final)) {
2065  AV_WL32(dst + offset, header.blocksize);
2066  offset += 4;
2067  }
2068 
2069  memcpy(dst + offset, src, header.blocksize);
2070  src += header.blocksize;
2071  srclen -= header.blocksize;
2072  offset += header.blocksize;
2073  }
2074 
2075  *pdst = dst;
2076  *size = offset;
2077 
2078  return 0;
2079 fail:
2080  av_freep(&dst);
2081  return ret;
2082 }
2083 
2085  uint32_t blockid, AVPacket *pkt, int keyframe)
2086 {
2087  MatroskaMuxContext *mkv = s->priv_data;
2089  mkv_track *track = &mkv->tracks[pkt->stream_index];
2090  uint8_t *data = NULL, *side_data = NULL;
2091  int offset = 0, size = pkt->size, side_data_size = 0;
2092  int64_t ts = track->write_dts ? pkt->dts : pkt->pts;
2093  uint64_t additional_id = 0;
2094  int64_t discard_padding = 0;
2095  uint8_t track_number = (mkv->is_dash ? mkv->dash_track_number : (pkt->stream_index + 1));
2096  ebml_master block_group, block_additions, block_more;
2097 
2098  ts += track->ts_offset;
2099 
2100  /* The following string is identical to the one in mkv_write_vtt_blocks
2101  * so that only one copy needs to exist in binaries. */
2102  av_log(s, AV_LOG_DEBUG,
2103  "Writing block of size %d with pts %" PRId64 ", dts %" PRId64 ", "
2104  "duration %" PRId64 " at relative offset %" PRId64 " in cluster "
2105  "at offset %" PRId64 ". TrackNumber %d, keyframe %d\n",
2106  pkt->size, pkt->pts, pkt->dts, pkt->duration, avio_tell(pb),
2107  mkv->cluster_pos, track_number, keyframe != 0);
2108  if (par->codec_id == AV_CODEC_ID_H264 && par->extradata_size > 0 &&
2109  (AV_RB24(par->extradata) == 1 || AV_RB32(par->extradata) == 1))
2110  ff_avc_parse_nal_units_buf(pkt->data, &data, &size);
2111  else if (par->codec_id == AV_CODEC_ID_HEVC && par->extradata_size > 6 &&
2112  (AV_RB24(par->extradata) == 1 || AV_RB32(par->extradata) == 1))
2113  /* extradata is Annex B, assume the bitstream is too and convert it */
2114  ff_hevc_annexb2mp4_buf(pkt->data, &data, &size, 0, NULL);
2115  else if (par->codec_id == AV_CODEC_ID_AV1)
2116  ff_av1_filter_obus_buf(pkt->data, &data, &size);
2117  else if (par->codec_id == AV_CODEC_ID_WAVPACK) {
2118  int ret = mkv_strip_wavpack(pkt->data, &data, &size);
2119  if (ret < 0) {
2120  av_log(s, AV_LOG_ERROR, "Error stripping a WavPack packet.\n");
2121  return;
2122  }
2123  } else
2124  data = pkt->data;
2125 
2126  if (par->codec_id == AV_CODEC_ID_PRORES && size >= 8) {
2127  /* Matroska specification requires to remove the first QuickTime atom
2128  */
2129  size -= 8;
2130  offset = 8;
2131  }
2132 
2133  side_data = av_packet_get_side_data(pkt,
2135  &side_data_size);
2136 
2137  if (side_data && side_data_size >= 10) {
2138  discard_padding = av_rescale_q(AV_RL32(side_data + 4),
2139  (AVRational){1, par->sample_rate},
2140  (AVRational){1, 1000000000});
2141  }
2142 
2143  side_data = av_packet_get_side_data(pkt,
2145  &side_data_size);
2146  if (side_data) {
2147  additional_id = AV_RB64(side_data);
2148  side_data += 8;
2149  side_data_size -= 8;
2150  }
2151 
2152  if ((side_data_size && additional_id == 1) || discard_padding) {
2153  block_group = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, 0);
2154  blockid = MATROSKA_ID_BLOCK;
2155  }
2156 
2157  put_ebml_id(pb, blockid);
2158  put_ebml_num(pb, size + 4, 0);
2159  // this assumes stream_index is less than 126
2160  avio_w8(pb, 0x80 | track_number);
2161  avio_wb16(pb, ts - mkv->cluster_pts);
2162  avio_w8(pb, (blockid == MATROSKA_ID_SIMPLEBLOCK && keyframe) ? (1 << 7) : 0);
2163  avio_write(pb, data + offset, size);
2164  if (data != pkt->data)
2165  av_free(data);
2166 
2167  if (blockid == MATROSKA_ID_BLOCK && !keyframe) {
2169  }
2170  track->last_timestamp = ts - mkv->cluster_pts;
2171 
2172  if (discard_padding) {
2173  put_ebml_sint(pb, MATROSKA_ID_DISCARDPADDING, discard_padding);
2174  }
2175 
2176  if (side_data_size && additional_id == 1) {
2177  block_additions = start_ebml_master(pb, MATROSKA_ID_BLOCKADDITIONS, 0);
2178  block_more = start_ebml_master(pb, MATROSKA_ID_BLOCKMORE, 0);
2181  put_ebml_num(pb, side_data_size, 0);
2182  avio_write(pb, side_data, side_data_size);
2183  end_ebml_master(pb, block_more);
2184  end_ebml_master(pb, block_additions);
2185  }
2186  if ((side_data_size && additional_id == 1) || discard_padding) {
2187  end_ebml_master(pb, block_group);
2188  }
2189 }
2190 
2192 {
2193  MatroskaMuxContext *mkv = s->priv_data;
2194  ebml_master blockgroup;
2195  int id_size, settings_size, size;
2196  uint8_t *id, *settings;
2197  int64_t ts = mkv->tracks[pkt->stream_index].write_dts ? pkt->dts : pkt->pts;
2198  const int flags = 0;
2199 
2200  id_size = 0;
2202  &id_size);
2203 
2204  settings_size = 0;
2206  &settings_size);
2207 
2208  size = id_size + 1 + settings_size + 1 + pkt->size;
2209 
2210  /* The following string is identical to the one in mkv_write_block so that
2211  * only one copy needs to exist in binaries. */
2212  av_log(s, AV_LOG_DEBUG,
2213  "Writing block of size %d with pts %" PRId64 ", dts %" PRId64 ", "
2214  "duration %" PRId64 " at relative offset %" PRId64 " in cluster "
2215  "at offset %" PRId64 ". TrackNumber %d, keyframe %d\n",
2216  size, pkt->pts, pkt->dts, pkt->duration, avio_tell(pb),
2217  mkv->cluster_pos, pkt->stream_index + 1, 1);
2218 
2220 
2222  put_ebml_num(pb, size + 4, 0);
2223  avio_w8(pb, 0x80 | (pkt->stream_index + 1)); // this assumes stream_index is less than 126
2224  avio_wb16(pb, ts - mkv->cluster_pts);
2225  avio_w8(pb, flags);
2226  avio_printf(pb, "%.*s\n%.*s\n%.*s", id_size, id, settings_size, settings, pkt->size, pkt->data);
2227 
2229  end_ebml_master(pb, blockgroup);
2230 
2231  return pkt->duration;
2232 }
2233 
2235 {
2236  MatroskaMuxContext *mkv = s->priv_data;
2237 
2238  end_ebml_master_crc32(s->pb, &mkv->cluster_bc, mkv);
2239  mkv->cluster_pos = -1;
2240  avio_flush(s->pb);
2241 }
2242 
2244 {
2245  MatroskaMuxContext *mkv = s->priv_data;
2246  mkv_track *track = &mkv->tracks[pkt->stream_index];
2248  uint8_t *side_data;
2249  int side_data_size = 0, ret;
2250 
2252  &side_data_size);
2253 
2254  switch (par->codec_id) {
2255  case AV_CODEC_ID_AAC:
2256  if (side_data_size && (s->pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live) {
2257  int filler, output_sample_rate = 0;
2258  int64_t curpos;
2259  ret = get_aac_sample_rates(s, side_data, side_data_size, &track->sample_rate,
2260  &output_sample_rate);
2261  if (ret < 0)
2262  return ret;
2263  if (!output_sample_rate)
2264  output_sample_rate = track->sample_rate; // Space is already reserved, so it's this or a void element.
2265  av_freep(&par->extradata);
2266  ret = ff_alloc_extradata(par, side_data_size);
2267  if (ret < 0)
2268  return ret;
2269  memcpy(par->extradata, side_data, side_data_size);
2270  curpos = avio_tell(mkv->tracks_bc);
2271  avio_seek(mkv->tracks_bc, track->codecpriv_offset, SEEK_SET);
2272  mkv_write_codecprivate(s, mkv->tracks_bc, par, 1, 0);
2273  filler = MAX_PCE_SIZE + 2 + 4 - (avio_tell(mkv->tracks_bc) - track->codecpriv_offset);
2274  if (filler)
2275  put_ebml_void(mkv->tracks_bc, filler);
2276  avio_seek(mkv->tracks_bc, track->sample_rate_offset, SEEK_SET);
2278  put_ebml_float(mkv->tracks_bc, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate);
2279  avio_seek(mkv->tracks_bc, curpos, SEEK_SET);
2280  } else if (!par->extradata_size && !track->sample_rate) {
2281  // No extradata (codecpar or packet side data).
2282  av_log(s, AV_LOG_ERROR, "Error parsing AAC extradata, unable to determine samplerate.\n");
2283  return AVERROR(EINVAL);
2284  }
2285  break;
2286  case AV_CODEC_ID_FLAC:
2287  if (side_data_size && (s->pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live) {
2288  AVCodecParameters *codecpriv_par;
2289  int64_t curpos;
2290  if (side_data_size != par->extradata_size) {
2291  av_log(s, AV_LOG_ERROR, "Invalid FLAC STREAMINFO metadata for output stream %d\n",
2292  pkt->stream_index);
2293  return AVERROR(EINVAL);
2294  }
2295  codecpriv_par = avcodec_parameters_alloc();
2296  if (!codecpriv_par)
2297  return AVERROR(ENOMEM);
2298  ret = avcodec_parameters_copy(codecpriv_par, par);
2299  if (ret < 0) {
2300  avcodec_parameters_free(&codecpriv_par);
2301  return ret;
2302  }
2303  memcpy(codecpriv_par->extradata, side_data, side_data_size);
2304  curpos = avio_tell(mkv->tracks_bc);
2305  avio_seek(mkv->tracks_bc, track->codecpriv_offset, SEEK_SET);
2306  mkv_write_codecprivate(s, mkv->tracks_bc, codecpriv_par, 1, 0);
2307  avio_seek(mkv->tracks_bc, curpos, SEEK_SET);
2308  avcodec_parameters_free(&codecpriv_par);
2309  }
2310  break;
2311  // FIXME: Remove the following once libaom starts propagating extradata during init()
2312  // See https://bugs.chromium.org/p/aomedia/issues/detail?id=2012
2313  case AV_CODEC_ID_AV1:
2314  if (side_data_size && (s->pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live &&
2315  !par->extradata_size) {
2316  AVIOContext *dyn_cp;
2317  uint8_t *codecpriv;
2318  int codecpriv_size;
2319  int64_t curpos;
2320  ret = avio_open_dyn_buf(&dyn_cp);
2321  if (ret < 0)
2322  return ret;
2323  ff_isom_write_av1c(dyn_cp, side_data, side_data_size);
2324  codecpriv_size = avio_close_dyn_buf(dyn_cp, &codecpriv);
2325  if (!codecpriv_size) {
2326  av_free(codecpriv);
2327  return AVERROR_INVALIDDATA;
2328  }
2329  curpos = avio_tell(mkv->tracks_bc);
2330  avio_seek(mkv->tracks_bc, track->codecpriv_offset, SEEK_SET);
2331  // Do not write the OBUs as we don't have space saved for them
2332  put_ebml_binary(mkv->tracks_bc, MATROSKA_ID_CODECPRIVATE, codecpriv, 4);
2333  av_free(codecpriv);
2334  avio_seek(mkv->tracks_bc, curpos, SEEK_SET);
2335  ret = ff_alloc_extradata(par, side_data_size);
2336  if (ret < 0)
2337  return ret;
2338  memcpy(par->extradata, side_data, side_data_size);
2339  } else if (!par->extradata_size)
2340  return AVERROR_INVALIDDATA;
2341  break;
2342  default:
2343  if (side_data_size)
2344  av_log(s, AV_LOG_DEBUG, "Ignoring new extradata in a packet for stream %d.\n", pkt->stream_index);
2345  break;
2346  }
2347 
2348  return 0;
2349 }
2350 
2352 {
2353  MatroskaMuxContext *mkv = s->priv_data;
2354  AVIOContext *pb;
2356  mkv_track *track = &mkv->tracks[pkt->stream_index];
2357  int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
2358  int duration = pkt->duration;
2359  int ret;
2360  int64_t ts = track->write_dts ? pkt->dts : pkt->pts;
2361  int64_t relative_packet_pos;
2362  int tracknum = mkv->is_dash ? mkv->dash_track_number : pkt->stream_index + 1;
2363 
2364  if (ts == AV_NOPTS_VALUE) {
2365  av_log(s, AV_LOG_ERROR, "Can't write packet with unknown timestamp\n");
2366  return AVERROR(EINVAL);
2367  }
2368  ts += track->ts_offset;
2369 
2370  if (mkv->cluster_pos != -1) {
2371  int64_t cluster_time = ts - mkv->cluster_pts;
2372  if ((int16_t)cluster_time != cluster_time) {
2373  mkv_end_cluster(s);
2374  av_log(s, AV_LOG_WARNING, "Starting new cluster due to timestamp\n");
2375  }
2376  }
2377 
2378  if (mkv->cluster_pos == -1) {
2379  mkv->cluster_pos = avio_tell(s->pb);
2381  if (ret < 0)
2382  return ret;
2384  mkv->cluster_pts = FFMAX(0, ts);
2385  av_log(s, AV_LOG_DEBUG,
2386  "Starting new cluster with timestamp "
2387  "%" PRId64 " at offset %" PRId64 " bytes\n",
2388  mkv->cluster_pts, mkv->cluster_pos);
2389  }
2390  pb = mkv->cluster_bc;
2391 
2392  relative_packet_pos = avio_tell(pb);
2393 
2394  if (par->codec_type != AVMEDIA_TYPE_SUBTITLE) {
2395  mkv_write_block(s, pb, MATROSKA_ID_SIMPLEBLOCK, pkt, keyframe);
2396  if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) && (par->codec_type == AVMEDIA_TYPE_VIDEO && keyframe || add_cue)) {
2397  ret = mkv_add_cuepoint(mkv->cues, pkt->stream_index, tracknum, ts, mkv->cluster_pos, relative_packet_pos, -1);
2398  if (ret < 0) return ret;
2399  }
2400  } else {
2401  if (par->codec_id == AV_CODEC_ID_WEBVTT) {
2402  duration = mkv_write_vtt_blocks(s, pb, pkt);
2403  } else {
2405  mkv_blockgroup_size(pkt->size));
2406 
2407 #if FF_API_CONVERGENCE_DURATION
2409  /* For backward compatibility, prefer convergence_duration. */
2410  if (pkt->convergence_duration > 0) {
2411  duration = pkt->convergence_duration;
2412  }
2414 #endif
2415  /* All subtitle blocks are considered to be keyframes. */
2416  mkv_write_block(s, pb, MATROSKA_ID_BLOCK, pkt, 1);
2418  end_ebml_master(pb, blockgroup);
2419  }
2420 
2421  if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
2422  ret = mkv_add_cuepoint(mkv->cues, pkt->stream_index, tracknum, ts,
2423  mkv->cluster_pos, relative_packet_pos, duration);
2424  if (ret < 0)
2425  return ret;
2426  }
2427  }
2428 
2429  mkv->duration = FFMAX(mkv->duration, ts + duration);
2430  track->duration = FFMAX(track->duration, ts + duration);
2431 
2432  return 0;
2433 }
2434 
2436 {
2437  MatroskaMuxContext *mkv = s->priv_data;
2439  int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
2440  int cluster_size;
2441  int64_t cluster_time;
2442  int ret;
2443  int start_new_cluster;
2444 
2445  ret = mkv_check_new_extra_data(s, pkt);
2446  if (ret < 0)
2447  return ret;
2448 
2449  if (mkv->tracks[pkt->stream_index].write_dts)
2450  cluster_time = pkt->dts - mkv->cluster_pts;
2451  else
2452  cluster_time = pkt->pts - mkv->cluster_pts;
2453  cluster_time += mkv->tracks[pkt->stream_index].ts_offset;
2454 
2455  // start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or
2456  // after 4k and on a keyframe
2457  cluster_size = avio_tell(mkv->cluster_bc);
2458 
2459  if (mkv->is_dash && codec_type == AVMEDIA_TYPE_VIDEO) {
2460  // WebM DASH specification states that the first block of every cluster
2461  // has to be a key frame. So for DASH video, we only create a cluster
2462  // on seeing key frames.
2463  start_new_cluster = keyframe;
2464  } else if (mkv->is_dash && codec_type == AVMEDIA_TYPE_AUDIO &&
2465  (mkv->cluster_pos == -1 ||
2466  cluster_time > mkv->cluster_time_limit)) {
2467  // For DASH audio, we create a Cluster based on cluster_time_limit
2468  start_new_cluster = 1;
2469  } else if (!mkv->is_dash &&
2470  (cluster_size > mkv->cluster_size_limit ||
2471  cluster_time > mkv->cluster_time_limit ||
2472  (codec_type == AVMEDIA_TYPE_VIDEO && keyframe &&
2473  cluster_size > 4 * 1024))) {
2474  start_new_cluster = 1;
2475  } else {
2476  start_new_cluster = 0;
2477  }
2478 
2479  if (mkv->cluster_pos != -1 && start_new_cluster) {
2480  mkv_end_cluster(s);
2481  }
2482 
2483  if (!mkv->cluster_pos)
2484  avio_write_marker(s->pb,
2487 
2488  // check if we have an audio packet cached
2489  if (mkv->cur_audio_pkt.size > 0) {
2490  // for DASH audio, a CuePoint has to be added when there is a new cluster.
2492  mkv->is_dash ? start_new_cluster : 0);
2494  if (ret < 0) {
2495  av_log(s, AV_LOG_ERROR,
2496  "Could not write cached audio packet ret:%d\n", ret);
2497  return ret;
2498  }
2499  }
2500 
2501  // buffer an audio packet to ensure the packet containing the video
2502  // keyframe's timecode is contained in the same cluster for WebM
2503  if (codec_type == AVMEDIA_TYPE_AUDIO) {
2504  if (pkt->size > 0)
2505  ret = av_packet_ref(&mkv->cur_audio_pkt, pkt);
2506  } else
2507  ret = mkv_write_packet_internal(s, pkt, 0);
2508  return ret;
2509 }
2510 
2512 {
2513  MatroskaMuxContext *mkv = s->priv_data;
2514 
2515  if (!pkt) {
2516  if (mkv->cluster_pos != -1) {
2517  mkv_end_cluster(s);
2518  av_log(s, AV_LOG_DEBUG,
2519  "Flushing cluster at offset %" PRIu64 " bytes\n",
2520  avio_tell(s->pb));
2521  }
2522  return 1;
2523  }
2524  return mkv_write_packet(s, pkt);
2525 }
2526 
2528 {
2529  MatroskaMuxContext *mkv = s->priv_data;
2530  AVIOContext *pb = s->pb;
2531  int64_t currentpos, cuespos;
2532  int ret;
2533 
2534  // check if we have an audio packet cached
2535  if (mkv->cur_audio_pkt.size > 0) {
2536  ret = mkv_write_packet_internal(s, &mkv->cur_audio_pkt, 0);
2538  if (ret < 0) {
2539  av_log(s, AV_LOG_ERROR,
2540  "Could not write cached audio packet ret:%d\n", ret);
2541  return ret;
2542  }
2543  }
2544 
2545  if (mkv->cluster_bc) {
2546  end_ebml_master_crc32(pb, &mkv->cluster_bc, mkv);
2547  }
2548 
2549  ret = mkv_write_chapters(s);
2550  if (ret < 0)
2551  return ret;
2552 
2553 
2554  if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live) {
2555  if (mkv->cues->num_entries) {
2556  if (mkv->reserve_cues_space) {
2557  int64_t cues_end;
2558 
2559  currentpos = avio_tell(pb);
2560  avio_seek(pb, mkv->cues_pos, SEEK_SET);
2561 
2562  cuespos = mkv_write_cues(s, mkv->cues, mkv->tracks, s->nb_streams);
2563  cues_end = avio_tell(pb);
2564  if (cues_end > cuespos + mkv->reserve_cues_space) {
2565  av_log(s, AV_LOG_ERROR,
2566  "Insufficient space reserved for cues: %d "
2567  "(needed: %" PRId64 ").\n",
2568  mkv->reserve_cues_space, cues_end - cuespos);
2569  return AVERROR(EINVAL);
2570  }
2571 
2572  if (cues_end < cuespos + mkv->reserve_cues_space)
2574  (cues_end - cuespos));
2575 
2576  avio_seek(pb, currentpos, SEEK_SET);
2577  } else {
2578  cuespos = mkv_write_cues(s, mkv->cues, mkv->tracks, s->nb_streams);
2579  }
2580 
2582  cuespos);
2583  if (ret < 0)
2584  return ret;
2585  }
2586 
2587  mkv_write_seekhead(pb, mkv);
2588 
2589  // update the duration
2590  av_log(s, AV_LOG_DEBUG, "end duration = %" PRIu64 "\n", mkv->duration);
2591  currentpos = avio_tell(pb);
2592  avio_seek(mkv->info_bc, mkv->duration_offset, SEEK_SET);
2594  avio_seek(pb, mkv->info_pos, SEEK_SET);
2595  end_ebml_master_crc32(pb, &mkv->info_bc, mkv);
2596 
2597  // write tracks master
2598  avio_seek(pb, mkv->tracks_pos, SEEK_SET);
2599  end_ebml_master_crc32(pb, &mkv->tracks_bc, mkv);
2600 
2601  // update stream durations
2602  if (!mkv->is_live) {
2603  int i;
2604  int64_t curr = avio_tell(mkv->tags_bc);
2605  for (i = 0; i < s->nb_streams; ++i) {
2606  AVStream *st = s->streams[i];
2607  mkv_track *track = &mkv->tracks[i];
2608 
2609  if (track->duration_offset > 0) {
2610  double duration_sec = track->duration * av_q2d(st->time_base);
2611  char duration_string[20] = "";
2612 
2613  av_log(s, AV_LOG_DEBUG, "stream %d end duration = %" PRIu64 "\n", i,
2614  track->duration);
2615 
2616  avio_seek(mkv->tags_bc, track->duration_offset, SEEK_SET);
2617 
2618  snprintf(duration_string, 20, "%02d:%02d:%012.9f",
2619  (int) duration_sec / 3600, ((int) duration_sec / 60) % 60,
2620  fmod(duration_sec, 60));
2621 
2622  put_ebml_binary(mkv->tags_bc, MATROSKA_ID_TAGSTRING, duration_string, 20);
2623  }
2624  }
2625  avio_seek(mkv->tags_bc, curr, SEEK_SET);
2626  }
2627  if (mkv->tags_bc && !mkv->is_live) {
2628  avio_seek(pb, mkv->tags_pos, SEEK_SET);
2629  end_ebml_master_crc32(pb, &mkv->tags_bc, mkv);
2630  }
2631 
2632  avio_seek(pb, currentpos, SEEK_SET);
2633  }
2634 
2635  if (!mkv->is_live) {
2636  end_ebml_master(pb, mkv->segment);
2637  }
2638 
2639  return 0;
2640 }
2641 
2642 static int mkv_query_codec(enum AVCodecID codec_id, int std_compliance)
2643 {
2644  int i;
2645  for (i = 0; ff_mkv_codec_tags[i].id != AV_CODEC_ID_NONE; i++)
2646  if (ff_mkv_codec_tags[i].id == codec_id)
2647  return 1;
2648 
2649  if (std_compliance < FF_COMPLIANCE_NORMAL) {
2650  enum AVMediaType type = avcodec_get_type(codec_id);
2651  // mkv theoretically supports any video/audio through VFW/ACM
2652  if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO)
2653  return 1;
2654  }
2655 
2656  return 0;
2657 }
2658 
2659 static int webm_query_codec(enum AVCodecID codec_id, int std_compliance)
2660 {
2661  int i;
2662  for (i = 0; ff_webm_codec_tags[i].id != AV_CODEC_ID_NONE; i++)
2663  if (ff_webm_codec_tags[i].id == codec_id)
2664  return 1;
2665 
2666  return 0;
2667 }
2668 
2669 static int mkv_init(struct AVFormatContext *s)
2670 {
2671  int i;
2672 
2673  if (s->nb_streams > MAX_TRACKS) {
2674  av_log(s, AV_LOG_ERROR,
2675  "At most %d streams are supported for muxing in Matroska\n",
2676  MAX_TRACKS);
2677  return AVERROR(EINVAL);
2678  }
2679 
2680  for (i = 0; i < s->nb_streams; i++) {
2681  if (s->streams[i]->codecpar->codec_id == AV_CODEC_ID_ATRAC3 ||
2687  av_log(s, AV_LOG_ERROR,
2688  "The Matroska muxer does not yet support muxing %s\n",
2690  return AVERROR_PATCHWELCOME;
2691  }
2692  }
2693 
2694  if (s->avoid_negative_ts < 0) {
2695  s->avoid_negative_ts = 1;
2697  }
2698 
2699  for (i = 0; i < s->nb_streams; i++) {
2700  // ms precision is the de-facto standard timescale for mkv files
2701  avpriv_set_pts_info(s->streams[i], 64, 1, 1000);
2702  }
2703 
2704  return 0;
2705 }
2706 
2707 static int mkv_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
2708 {
2709  int ret = 1;
2710  AVStream *st = s->streams[pkt->stream_index];
2711 
2712  if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
2713  if (pkt->size > 2 && (AV_RB16(pkt->data) & 0xfff0) == 0xfff0)
2714  ret = ff_stream_add_bitstream_filter(st, "aac_adtstoasc", NULL);
2715  } else if (st->codecpar->codec_id == AV_CODEC_ID_VP9) {
2716  ret = ff_stream_add_bitstream_filter(st, "vp9_superframe", NULL);
2717  }
2718 
2719  return ret;
2720 }
2721 
2723  { AV_CODEC_ID_ALAC, 0XFFFFFFFF },
2724  { AV_CODEC_ID_MLP, 0xFFFFFFFF },
2725  { AV_CODEC_ID_OPUS, 0xFFFFFFFF },
2726  { AV_CODEC_ID_PCM_S16BE, 0xFFFFFFFF },
2727  { AV_CODEC_ID_PCM_S24BE, 0xFFFFFFFF },
2728  { AV_CODEC_ID_PCM_S32BE, 0xFFFFFFFF },
2729  { AV_CODEC_ID_QDMC, 0xFFFFFFFF },
2730  { AV_CODEC_ID_QDM2, 0xFFFFFFFF },
2731  { AV_CODEC_ID_RA_144, 0xFFFFFFFF },
2732  { AV_CODEC_ID_RA_288, 0xFFFFFFFF },
2733  { AV_CODEC_ID_COOK, 0xFFFFFFFF },
2734  { AV_CODEC_ID_TRUEHD, 0xFFFFFFFF },
2735  { AV_CODEC_ID_NONE, 0xFFFFFFFF }
2736 };
2737 
2739  { AV_CODEC_ID_RV10, 0xFFFFFFFF },
2740  { AV_CODEC_ID_RV20, 0xFFFFFFFF },
2741  { AV_CODEC_ID_RV30, 0xFFFFFFFF },
2742  { AV_CODEC_ID_NONE, 0xFFFFFFFF }
2743 };
2744 
2746  { AV_CODEC_ID_DVB_SUBTITLE, 0xFFFFFFFF },
2747  { AV_CODEC_ID_DVD_SUBTITLE, 0xFFFFFFFF },
2748  { AV_CODEC_ID_HDMV_PGS_SUBTITLE, 0xFFFFFFFF },
2749  { AV_CODEC_ID_NONE, 0xFFFFFFFF }
2750 };
2751 
2752 #define OFFSET(x) offsetof(MatroskaMuxContext, x)
2753 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM
2754 static const AVOption options[] = {
2755  { "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 },
2756  { "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 },
2757  { "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 },
2758  { "dash", "Create a WebM file conforming to WebM DASH specification", OFFSET(is_dash), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
2759  { "dash_track_number", "Track number for the DASH stream", OFFSET(dash_track_number), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 127, FLAGS },
2760  { "live", "Write files assuming it is a live stream.", OFFSET(is_live), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
2761  { "allow_raw_vfw", "allow RAW VFW mode", OFFSET(allow_raw_vfw), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
2762  { "write_crc32", "write a CRC32 element inside every Level 1 element", OFFSET(write_crc), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, FLAGS },
2763  { NULL },
2764 };
2765 
2766 #if CONFIG_MATROSKA_MUXER
2767 static const AVClass matroska_class = {
2768  .class_name = "matroska muxer",
2769  .item_name = av_default_item_name,
2770  .option = options,
2771  .version = LIBAVUTIL_VERSION_INT,
2772 };
2773 
2775  .name = "matroska",
2776  .long_name = NULL_IF_CONFIG_SMALL("Matroska"),
2777  .mime_type = "video/x-matroska",
2778  .extensions = "mkv",
2779  .priv_data_size = sizeof(MatroskaMuxContext),
2780  .audio_codec = CONFIG_LIBVORBIS_ENCODER ?
2782  .video_codec = CONFIG_LIBX264_ENCODER ?
2784  .init = mkv_init,
2785  .deinit = mkv_deinit,
2791  .codec_tag = (const AVCodecTag* const []){
2794  },
2795  .subtitle_codec = AV_CODEC_ID_ASS,
2796  .query_codec = mkv_query_codec,
2797  .check_bitstream = mkv_check_bitstream,
2798  .priv_class = &matroska_class,
2799 };
2800 #endif
2801 
2802 #if CONFIG_WEBM_MUXER
2803 static const AVClass webm_class = {
2804  .class_name = "webm muxer",
2805  .item_name = av_default_item_name,
2806  .option = options,
2807  .version = LIBAVUTIL_VERSION_INT,
2808 };
2809 
2811  .name = "webm",
2812  .long_name = NULL_IF_CONFIG_SMALL("WebM"),
2813  .mime_type = "video/webm",
2814  .extensions = "webm",
2815  .priv_data_size = sizeof(MatroskaMuxContext),
2816  .audio_codec = CONFIG_LIBOPUS_ENCODER ? AV_CODEC_ID_OPUS : AV_CODEC_ID_VORBIS,
2817  .video_codec = CONFIG_LIBVPX_VP9_ENCODER? AV_CODEC_ID_VP9 : AV_CODEC_ID_VP8,
2818  .subtitle_codec = AV_CODEC_ID_WEBVTT,
2819  .init = mkv_init,
2820  .deinit = mkv_deinit,
2825  .check_bitstream = mkv_check_bitstream,
2828  .priv_class = &webm_class,
2829 };
2830 #endif
2831 
2832 #if CONFIG_MATROSKA_AUDIO_MUXER
2833 static const AVClass mka_class = {
2834  .class_name = "matroska audio muxer",
2835  .item_name = av_default_item_name,
2836  .option = options,
2837  .version = LIBAVUTIL_VERSION_INT,
2838 };
2840  .name = "matroska",
2841  .long_name = NULL_IF_CONFIG_SMALL("Matroska Audio"),
2842  .mime_type = "audio/x-matroska",
2843  .extensions = "mka",
2844  .priv_data_size = sizeof(MatroskaMuxContext),
2845  .audio_codec = CONFIG_LIBVORBIS_ENCODER ?
2847  .video_codec = AV_CODEC_ID_NONE,
2848  .init = mkv_init,
2849  .deinit = mkv_deinit,
2853  .check_bitstream = mkv_check_bitstream,
2856  .codec_tag = (const AVCodecTag* const []){
2858  },
2859  .priv_class = &mka_class,
2860 };
2861 #endif
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1587
static int mkv_write_packet_internal(AVFormatContext *s, AVPacket *pkt, int add_cue)
Definition: matroskaenc.c:2351
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:4058
internal header for HEVC (de)muxer utilities
#define AV_DISPOSITION_METADATA
Definition: avformat.h:863
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:466
#define NULL
Definition: coverity.c:32
static int mkv_write_vtt_blocks(AVFormatContext *s, AVIOContext *pb, AVPacket *pkt)
Definition: matroskaenc.c:2191
#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:4049
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:4056
#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:1343
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:1459
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:2669
#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:3158
#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:4929
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:2745
This side data should be associated with a video stream and contains Stereoscopic 3D information in f...
Definition: avcodec.h:1261
static int mkv_write_attachments(AVFormatContext *s)
Definition: matroskaenc.c:1716
uint64_t pts
Definition: matroskaenc.c:80
enum AVCodecID codec_id
Definition: qsv.c:77
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:3968
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:943
#define MATROSKA_ID_TAGTARGETS_ATTACHUID
Definition: matroska.h:214
int num
Numerator.
Definition: rational.h:59
int size
Definition: avcodec.h:1481
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:1811
#define EBML_ID_DOCTYPEREADVERSION
Definition: matroska.h:42
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:266
#define MATROSKA_ID_BLOCKREFERENCE
Definition: matroska.h:237
int av_log2(unsigned v)
Definition: intmath.c:26
static int mkv_write_header(AVFormatContext *s)
Definition: matroskaenc.c: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:3148
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:983
Views are next to each other.
Definition: stereo3d.h:67
static AVPacket pkt
#define av_le2ne32(x)
Definition: bswap.h:96
#define MATROSKA_ID_CUECLUSTERPOSITION
Definition: matroska.h:196
#define MATROSKA_ID_VIDEOCOLOR_LUMINANCEMAX
Definition: matroska.h:153
#define MAX_EBML_HEADER_SIZE
2 bytes * 7 for EBML IDs, 7 1-byte EBML lengths, 6 1-byte uint, 8 byte for "matroska" doctype string ...
Definition: matroskaenc.c: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:1319
#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:332
#define MATROSKA_ID_CLUSTERTIMECODE
Definition: matroska.h:224
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1430
#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:3960
#define MATROSKA_ID_CHAPTERTIMEEND
Definition: matroska.h:253
enum AVColorSpace color_space
Definition: avcodec.h:4057
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:1369
#define FLAGS
Definition: matroskaenc.c:2753
#define MATROSKA_ID_FILEDESC
Definition: matroska.h:243
Format I/O context.
Definition: avformat.h:1358
#define EBML_ID_CRC32
Definition: matroska.h:46
UID uid
Definition: mxfenc.c:2213
static int mkv_add_seekhead_entry(mkv_seekhead *seekhead, uint32_t elementid, uint64_t filepos)
Definition: matroskaenc.c:445
char str[32]
Definition: internal.h:48
static int query_codec(enum AVCodecID id, int std_compliance)
Definition: img2enc.c:199
int64_t cluster_pos
file offset of the current cluster
Definition: matroskaenc.c: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:2722
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:4034
static void mkv_end_cluster(AVFormatContext *s)
Definition: matroskaenc.c:2234
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:2019
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:1316
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1498
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:987
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:5490
#define MATROSKA_ID_BLOCKMORE
Definition: matroska.h:229
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:87
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1426
int64_t duration
Definition: movenc.c:63
#define MATROSKA_ID_CUERELATIVEPOSITION
Definition: matroska.h:197
A point in the output bytestream where a demuxer can start parsing (for non self synchronizing bytest...
Definition: avio.h:128
#define MATROSKA_ID_AUDIOOUTSAMPLINGFREQ
Definition: matroska.h:165
#define MATROSKA_ID_VIDEOCOLOR
Definition: matroska.h:127
Public header for CRC hash function implementation.
int initial_padding
Audio only.
Definition: avcodec.h:4097
static int webm_query_codec(enum AVCodecID codec_id, int std_compliance)
Definition: matroskaenc.c:2659
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1489
uint8_t * data
Definition: avcodec.h:1480
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:556
#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:320
#define MATROSKA_ID_BLOCKADDITIONS
Definition: matroska.h:228
uint32_t tag
Definition: movenc.c:1531
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:1424
#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:1506
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:198
#define MATROSKA_ID_SEGMENTUID
Definition: matroska.h:72
AVOutputFormat ff_webm_muxer
uint64_t channel_layout
Audio only.
Definition: avcodec.h:4070
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:861
int64_t segment_offset
the file offset to the beginning of the segment
Definition: matroskaenc.c:72
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: avpacket.c:608
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1512
#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:5696
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:2040
#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:268
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1533
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1598
int flags
Additional information about the frame packing.
Definition: stereo3d.h:185
#define MATROSKA_ID_BLOCKDURATION
Definition: matroska.h:236
#define EBML_ID_EBMLREADVERSION
Definition: matroska.h:37
#define MATROSKA_ID_VIDEOCOLORMAXCLL
Definition: matroska.h:141
#define MAX_CUETRACKPOS_SIZE
per-cuepoint-track - 5 1-byte EBML IDs, 5 1-byte EBML sizes, 3 8-byte uint max and one 1-byte uint fo...
Definition: matroskaenc.c: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:702
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:4055
#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:2022
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3964
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:1588
int ff_vorbiscomment_write(uint8_t **p, AVDictionary **m, const char *vendor_string, AVChapter **chapters, unsigned int nb_chapters)
Write a VorbisComment into a buffer.
Definition: vorbiscomment.c:65
enum AVCodecID id
Definition: matroska.h:354
enum AVPacketSideDataType type
Definition: avcodec.h:1426
enum AVMediaType avcodec_get_type(enum AVCodecID codec_id)
Get the type of the given codec.
Definition: codec_desc.c:3301
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:954
const AVCodecTag ff_codec_wav_tags[]
Definition: riff.c:500
#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:424
int ff_avc_parse_nal_units_buf(const uint8_t *buf_in, uint8_t **buf, int *size)
Definition: avc.c:94
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
void avcodec_parameters_free(AVCodecParameters **par)
Free an AVCodecParameters instance and everything associated with it and write NULL to the supplied p...
Definition: utils.c:2029
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:1486
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3986
const CodecMime ff_mkv_mime_tags[]
Definition: matroska.c:131
#define MATROSKA_ID_TAG
Definition: matroska.h:202
const CodecTags ff_webm_codec_tags[]
Definition: matroska.c:106
Views are alternated temporally.
Definition: stereo3d.h:92
#define AV_DISPOSITION_FORCED
Track should be used during playback by default.
Definition: avformat.h:838
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1414
uint32_t bound_bottom
Distance from the bottom edge.
Definition: spherical.h:170
AVOutputFormat ff_matroska_audio_muxer
#define LIBAVFORMAT_IDENT
Definition: version.h:46
#define b
Definition: input.c:41
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
Video frame is split into 6 faces of a cube, and arranged on a 3x2 layout.
Definition: spherical.h:65
#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:3321
#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:644
static void end_ebml_master_crc32(AVIOContext *pb, AVIOContext **dyn_cp, MatroskaMuxContext *mkv)
Definition: matroskaenc.c:347
#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:473
static int mkv_write_native_codecprivate(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, AVIOContext *dyn_cp)
Definition: matroskaenc.c:734
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:1375
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:2243
int ff_flac_write_header(AVIOContext *pb, uint8_t *extradata, int extradata_size, int last_block)
#define s(width, name)
Definition: cbs_vp9.c:257
int avoid_negative_ts
Avoid negative timestamps during muxing.
Definition: avformat.h:1689
#define MATROSKA_ID_CHAPTERATOM
Definition: matroska.h:251
int avpriv_split_xiph_headers(const uint8_t *extradata, int extradata_size, int first_header_size, const uint8_t *header_start[3], int header_len[3])
Split a single extradata buffer into the three headers that most Xiph codecs use. ...
Definition: xiph.c:24
int32_t yaw
Rotation around the up vector [-180, 180].
Definition: spherical.h:126
AVDictionary * metadata
Definition: avformat.h:945
enum AVColorRange color_range
Video only.
Definition: avcodec.h:4054
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:2752
#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:1166
ff_const59 struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1377
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1489
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:533
int metadata_header_padding
Number of bytes to be written as padding in a metadata header.
Definition: avformat.h:1858
Stream structure.
Definition: avformat.h:881
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1318
Content light level (based on CTA-861.3).
Definition: avcodec.h:1382
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:1202
#define AV_DISPOSITION_DEFAULT
Definition: avformat.h:826
sample_rate
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:180
Views are packed in a checkerboard-like structure per pixel.
Definition: stereo3d.h:104
#define MATROSKA_ID_VIDEOCOLORMATRIXCOEFF
Definition: matroska.h:129
#define AV_DISPOSITION_DESCRIPTIONS
Definition: avformat.h:862
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
#define MATROSKA_ID_TRACKFLAGFORCED
Definition: matroska.h:100
#define MATROSKA_ID_TAGS
Definition: matroska.h:59
Views are on top of each other.
Definition: stereo3d.h:79
#define MATROSKA_ID_VIDEOCOLORPRIMARIES
Definition: matroska.h:140
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
Definition: bytestream.h:87
int64_t sample_rate_offset
Definition: matroskaenc.c:98
#define MATROSKA_ID_VIDEOPROJECTIONPOSEPITCH
Definition: matroska.h:160
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
#define MATROSKA_ID_SEEKID
Definition: matroska.h:220
AVIOContext * pb
I/O context.
Definition: avformat.h:1400
int64_t codecpriv_offset
Definition: matroskaenc.c:102
static void put_ebml_uint(AVIOContext *pb, uint32_t elementid, uint64_t val)
Definition: matroskaenc.c:242
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:60
#define MATROSKA_ID_TRACKS
Definition: matroska.h:57
void * buf
Definition: avisynth_c.h:766
Data found in BlockAdditional element of matroska container.
Definition: avcodec.h:1338
#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:2634
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:1546
Recommmends skipping the specified number of samples.
Definition: avcodec.h:1303
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:238
AVMediaType
Definition: avutil.h:199
static void mkv_write_block(AVFormatContext *s, AVIOContext *pb, uint32_t blockid, AVPacket *pkt, int keyframe)
Definition: matroskaenc.c:2084
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:2031
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:561
#define MATROSKA_ID_CHAPTERDISPLAY
Definition: matroska.h:254
static int put_xiph_codecpriv(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par)
Definition: matroskaenc.c:616
int bits_per_raw_sample
This is the number of valid bits in each output sample.
Definition: avcodec.h:4023
#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:2738
static int put_flac_codecpriv(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par)
Definition: matroskaenc.c:653
#define MATROSKA_ID_VIDEOFIELDORDER
Definition: matroska.h:122
int64_t start
Definition: avformat.h:1318
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
int sample_rate
Audio only.
Definition: avcodec.h:4078
#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:2527
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:2707
attribute_deprecated int64_t convergence_duration
Definition: avcodec.h:1509
#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:368
static int mkv_write_flush_packet(AVFormatContext *s, AVPacket *pkt)
Definition: matroskaenc.c:2511
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:934
static ebml_master start_ebml_master(AVIOContext *pb, uint32_t elementid, uint64_t expectedsize)
Definition: matroskaenc.c:312
static void put_ebml_void(AVIOContext *pb, uint64_t size)
Write a void element of a given size.
Definition: matroskaenc.c:295
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:1317
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:33
char * key
Definition: dict.h:86
int den
Denominator.
Definition: rational.h:60
#define MATROSKA_ID_SEGMENT
Definition: matroska.h:53
#define MAX_PCE_SIZE
Maximum size of a PCE including the 3-bit ID_PCE.
Definition: mpeg4audio.h:134
The optional settings (rendering instructions) that immediately follow the timestamp specifier of a W...
Definition: avcodec.h:1349
#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:5559
static void put_ebml_binary(AVIOContext *pb, uint32_t elementid, const void *buf, int size)
Definition: matroskaenc.c:275
void * priv_data
Format private data.
Definition: avformat.h:1386
#define MATROSKA_ID_CHAPTERUID
Definition: matroska.h:262
char str[22]
Definition: matroska.h:353
static void write_header(FFV1Context *f)
Definition: ffv1enc.c: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:4010
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:3982
#define MATROSKA_ID_VIDEOCOLORMAXFALL
Definition: matroska.h:142
#define MATROSKA_ID_VIDEODISPLAYUNIT
Definition: matroska.h:120
int channels
Audio only.
Definition: avcodec.h:4074
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1479
static const AVOption options[]
Definition: matroskaenc.c:2754
#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:1473
#define MATROSKA_ID_CHAPSTRING
Definition: matroska.h:255
int sample_rate
Definition: matroskaenc.c:97
#define av_freep(p)
#define MATROSKA_ID_TAGSTRING
Definition: matroska.h:205
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:70
#define MODE_MATROSKAv2
Definition: matroskaenc.c: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:283
AVOutputFormat ff_matroska_muxer
const CodecMime ff_mkv_image_mime_tags[]
Definition: matroska.c:122
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
static void put_ebml_sint(AVIOContext *pb, uint32_t elementid, int64_t val)
Definition: matroskaenc.c:255
#define MODE_WEBM
Definition: matroskaenc.c:117
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:3972
static int mkv_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: matroskaenc.c:2435
#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:389
static mkv_cues * mkv_start_cues(int64_t segment_offset)
Definition: matroskaenc.c:523
int stream_index
Definition: avcodec.h:1482
int num_entries
Definition: matroskaenc.c:91
#define EBML_ID_DOCTYPEVERSION
Definition: matroska.h:41
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:910
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
static void end_ebml_master(AVIOContext *pb, ebml_master master)
Definition: matroskaenc.c:322
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:1005
#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:1457
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:2642
static void put_xiph_size(AVIOContext *pb, int size)
Definition: matroskaenc.c:380
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1473
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:108
#define MATROSKA_ID_TRACKAUDIO
Definition: matroska.h:82
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
int(* filler)(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:407
AVIOContext * tags_bc
Definition: matroskaenc.c: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:1442
static uint8_t tmp[11]
Definition: aes_ctr.c:26