3 * Copyright (c) 2007 David Conrad
5 * This file is part of FFmpeg.
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.
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.
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
27 #include "avio_internal.h"
28 #include "avlanguage.h"
34 #include "subtitles.h"
35 #include "vorbiscomment.h"
38 #include "libavutil/avstring.h"
39 #include "libavutil/channel_layout.h"
40 #include "libavutil/dict.h"
41 #include "libavutil/intfloat.h"
42 #include "libavutil/intreadwrite.h"
43 #include "libavutil/lfg.h"
44 #include "libavutil/mathematics.h"
45 #include "libavutil/opt.h"
46 #include "libavutil/random_seed.h"
47 #include "libavutil/samplefmt.h"
48 #include "libavutil/sha.h"
49 #include "libavutil/stereo3d.h"
51 #include "libavcodec/xiph.h"
52 #include "libavcodec/mpeg4audio.h"
53 #include "libavcodec/internal.h"
55 typedef struct ebml_master
{
56 int64_t pos
; ///< absolute offset in the file where the master's elements start
57 int sizebytes
; ///< how many bytes were reserved for the size
60 typedef struct mkv_seekhead_entry
{
61 unsigned int elementid
;
65 typedef struct mkv_seekhead
{
67 int64_t segment_offset
; ///< the file offset to the beginning of the segment
68 int reserved_size
; ///< -1 if appending to file
70 mkv_seekhead_entry
*entries
;
78 int64_t cluster_pos
; ///< file offset of the cluster containing the block
79 int64_t relative_pos
; ///< relative offset from the position of the cluster containing the block
80 int64_t duration
; ///< duration of the block according to time base
84 int64_t segment_offset
;
85 mkv_cuepoint
*entries
;
95 #define MODE_MATROSKAv2 0x01
96 #define MODE_WEBM 0x02
98 typedef struct MatroskaMuxContext
{
103 int64_t segment_offset
;
105 int64_t cluster_pos
; ///< file offset of the current cluster
107 int64_t duration_offset
;
109 mkv_seekhead
*main_seekhead
;
113 AVPacket cur_audio_pkt
;
115 int have_attachments
;
117 int reserve_cues_space
;
118 int cluster_size_limit
;
120 int64_t cluster_time_limit
;
122 int dash_track_number
;
124 uint32_t chapter_id_offset
;
126 } MatroskaMuxContext
;
129 /** 2 bytes * 3 for EBML IDs, 3 1-byte EBML lengths, 8 bytes for 64 bit
130 * offset, 4 bytes for target EBML ID */
131 #define MAX_SEEKENTRY_SIZE 21
133 /** per-cuepoint-track - 5 1-byte EBML IDs, 5 1-byte EBML sizes, 4
135 #define MAX_CUETRACKPOS_SIZE 42
137 /** per-cuepoint - 2 1-byte EBML IDs, 2 1-byte EBML sizes, 8-byte uint max */
138 #define MAX_CUEPOINT_SIZE(num_tracks) 12 + MAX_CUETRACKPOS_SIZE * num_tracks
140 /** Seek preroll value for opus */
141 #define OPUS_SEEK_PREROLL 80000000
143 static int ebml_id_size(unsigned int id
)
145 return (av_log2(id
+ 1) - 1) / 7 + 1;
148 static void put_ebml_id(AVIOContext
*pb
, unsigned int id
)
150 int i
= ebml_id_size(id
);
152 avio_w8(pb
, (uint8_t)(id
>> (i
* 8)));
156 * Write an EBML size meaning "unknown size".
158 * @param bytes The number of bytes the size should occupy (maximum: 8).
160 static void put_ebml_size_unknown(AVIOContext
*pb
, int bytes
)
162 av_assert0(bytes
<= 8);
163 avio_w8(pb
, 0x1ff >> bytes
);
164 ffio_fill(pb
, 0xff, bytes
- 1);
168 * Calculate how many bytes are needed to represent a given number in EBML.
170 static int ebml_num_size(uint64_t num
)
173 while ((num
+ 1) >> bytes
* 7)
179 * Write a number in EBML variable length format.
181 * @param bytes The number of bytes that need to be used to write the number.
182 * If zero, any number of bytes can be used.
184 static void put_ebml_num(AVIOContext
*pb
, uint64_t num
, int bytes
)
186 int i
, needed_bytes
= ebml_num_size(num
);
188 // sizes larger than this are currently undefined in EBML
189 av_assert0(num
< (1ULL << 56) - 1);
192 // don't care how many bytes are used, so use the min
193 bytes
= needed_bytes
;
194 // the bytes needed to write the given size would exceed the bytes
195 // that we need to use, so write unknown size. This shouldn't happen.
196 av_assert0(bytes
>= needed_bytes
);
198 num
|= 1ULL << bytes
* 7;
199 for (i
= bytes
- 1; i
>= 0; i
--)
200 avio_w8(pb
, (uint8_t)(num
>> i
* 8));
203 static void put_ebml_uint(AVIOContext
*pb
, unsigned int elementid
, uint64_t val
)
210 put_ebml_id(pb
, elementid
);
211 put_ebml_num(pb
, bytes
, 0);
212 for (i
= bytes
- 1; i
>= 0; i
--)
213 avio_w8(pb
, (uint8_t)(val
>> i
* 8));
216 static void put_ebml_sint(AVIOContext
*pb
, unsigned int elementid
, int64_t val
)
219 uint64_t tmp
= 2*(val
< 0 ? val
^-1 : val
);
221 while (tmp
>>=8) bytes
++;
223 put_ebml_id(pb
, elementid
);
224 put_ebml_num(pb
, bytes
, 0);
225 for (i
= bytes
- 1; i
>= 0; i
--)
226 avio_w8(pb
, (uint8_t)(val
>> i
* 8));
229 static void put_ebml_float(AVIOContext
*pb
, unsigned int elementid
, double val
)
231 put_ebml_id(pb
, elementid
);
232 put_ebml_num(pb
, 8, 0);
233 avio_wb64(pb
, av_double2int(val
));
236 static void put_ebml_binary(AVIOContext
*pb
, unsigned int elementid
,
237 const void *buf
, int size
)
239 put_ebml_id(pb
, elementid
);
240 put_ebml_num(pb
, size
, 0);
241 avio_write(pb
, buf
, size
);
244 static void put_ebml_string(AVIOContext
*pb
, unsigned int elementid
,
247 put_ebml_binary(pb
, elementid
, str
, strlen(str
));
251 * Write a void element of a given size. Useful for reserving space in
252 * the file to be written to later.
254 * @param size The number of bytes to reserve, which must be at least 2.
256 static void put_ebml_void(AVIOContext
*pb
, uint64_t size
)
258 int64_t currentpos
= avio_tell(pb
);
260 av_assert0(size
>= 2);
262 put_ebml_id(pb
, EBML_ID_VOID
);
263 // we need to subtract the length needed to store the size from the
264 // size we need to reserve so 2 cases, we use 8 bytes to store the
265 // size if possible, 1 byte otherwise
267 put_ebml_num(pb
, size
- 1, 0);
269 put_ebml_num(pb
, size
- 9, 8);
270 ffio_fill(pb
, 0, currentpos
+ size
- avio_tell(pb
));
273 static ebml_master
start_ebml_master(AVIOContext
*pb
, unsigned int elementid
,
274 uint64_t expectedsize
)
276 int bytes
= expectedsize
? ebml_num_size(expectedsize
) : 8;
277 put_ebml_id(pb
, elementid
);
278 put_ebml_size_unknown(pb
, bytes
);
279 return (ebml_master
) {avio_tell(pb
), bytes
};
282 static void end_ebml_master(AVIOContext
*pb
, ebml_master master
)
284 int64_t pos
= avio_tell(pb
);
286 if (avio_seek(pb
, master
.pos
- master
.sizebytes
, SEEK_SET
) < 0)
288 put_ebml_num(pb
, pos
- master
.pos
, master
.sizebytes
);
289 avio_seek(pb
, pos
, SEEK_SET
);
292 static void put_xiph_size(AVIOContext
*pb
, int size
)
294 ffio_fill(pb
, 255, size
/ 255);
295 avio_w8(pb
, size
% 255);
299 * Initialize a mkv_seekhead element to be ready to index level 1 Matroska
300 * elements. If a maximum number of elements is specified, enough space
301 * will be reserved at the current file location to write a seek head of
304 * @param segment_offset The absolute offset to the position in the file
305 * where the segment begins.
306 * @param numelements The maximum number of elements that will be indexed
307 * by this seek head, 0 if unlimited.
309 static mkv_seekhead
*mkv_start_seekhead(AVIOContext
*pb
, int64_t segment_offset
,
312 mkv_seekhead
*new_seekhead
= av_mallocz(sizeof(mkv_seekhead
));
316 new_seekhead
->segment_offset
= segment_offset
;
318 if (numelements
> 0) {
319 new_seekhead
->filepos
= avio_tell(pb
);
320 // 21 bytes max for a seek entry, 10 bytes max for the SeekHead ID
321 // and size, and 3 bytes to guarantee that an EBML void element
322 // will fit afterwards
323 new_seekhead
->reserved_size
= numelements
* MAX_SEEKENTRY_SIZE
+ 13;
324 new_seekhead
->max_entries
= numelements
;
325 put_ebml_void(pb
, new_seekhead
->reserved_size
);
330 static int mkv_add_seekhead_entry(mkv_seekhead
*seekhead
, unsigned int elementid
, uint64_t filepos
)
332 mkv_seekhead_entry
*entries
= seekhead
->entries
;
334 // don't store more elements than we reserved space for
335 if (seekhead
->max_entries
> 0 && seekhead
->max_entries
<= seekhead
->num_entries
)
338 entries
= av_realloc_array(entries
, seekhead
->num_entries
+ 1, sizeof(mkv_seekhead_entry
));
340 return AVERROR(ENOMEM
);
341 seekhead
->entries
= entries
;
343 seekhead
->entries
[seekhead
->num_entries
].elementid
= elementid
;
344 seekhead
->entries
[seekhead
->num_entries
++].segmentpos
= filepos
- seekhead
->segment_offset
;
350 * Write the seek head to the file and free it. If a maximum number of
351 * elements was specified to mkv_start_seekhead(), the seek head will
352 * be written at the location reserved for it. Otherwise, it is written
353 * at the current location in the file.
355 * @return The file offset where the seekhead was written,
356 * -1 if an error occurred.
358 static int64_t mkv_write_seekhead(AVIOContext
*pb
, mkv_seekhead
*seekhead
)
360 ebml_master metaseek
, seekentry
;
364 currentpos
= avio_tell(pb
);
366 if (seekhead
->reserved_size
> 0) {
367 if (avio_seek(pb
, seekhead
->filepos
, SEEK_SET
) < 0) {
373 metaseek
= start_ebml_master(pb
, MATROSKA_ID_SEEKHEAD
, seekhead
->reserved_size
);
374 for (i
= 0; i
< seekhead
->num_entries
; i
++) {
375 mkv_seekhead_entry
*entry
= &seekhead
->entries
[i
];
377 seekentry
= start_ebml_master(pb
, MATROSKA_ID_SEEKENTRY
, MAX_SEEKENTRY_SIZE
);
379 put_ebml_id(pb
, MATROSKA_ID_SEEKID
);
380 put_ebml_num(pb
, ebml_id_size(entry
->elementid
), 0);
381 put_ebml_id(pb
, entry
->elementid
);
383 put_ebml_uint(pb
, MATROSKA_ID_SEEKPOSITION
, entry
->segmentpos
);
384 end_ebml_master(pb
, seekentry
);
386 end_ebml_master(pb
, metaseek
);
388 if (seekhead
->reserved_size
> 0) {
389 uint64_t remaining
= seekhead
->filepos
+ seekhead
->reserved_size
- avio_tell(pb
);
390 put_ebml_void(pb
, remaining
);
391 avio_seek(pb
, currentpos
, SEEK_SET
);
393 currentpos
= seekhead
->filepos
;
396 av_freep(&seekhead
->entries
);
402 static mkv_cues
*mkv_start_cues(int64_t segment_offset
)
404 mkv_cues
*cues
= av_mallocz(sizeof(mkv_cues
));
408 cues
->segment_offset
= segment_offset
;
412 static int mkv_add_cuepoint(mkv_cues
*cues
, int stream
, int tracknum
, int64_t ts
,
413 int64_t cluster_pos
, int64_t relative_pos
, int64_t duration
)
415 mkv_cuepoint
*entries
= cues
->entries
;
420 entries
= av_realloc_array(entries
, cues
->num_entries
+ 1, sizeof(mkv_cuepoint
));
422 return AVERROR(ENOMEM
);
423 cues
->entries
= entries
;
425 cues
->entries
[cues
->num_entries
].pts
= ts
;
426 cues
->entries
[cues
->num_entries
].stream_idx
= stream
;
427 cues
->entries
[cues
->num_entries
].tracknum
= tracknum
;
428 cues
->entries
[cues
->num_entries
].cluster_pos
= cluster_pos
- cues
->segment_offset
;
429 cues
->entries
[cues
->num_entries
].relative_pos
= relative_pos
;
430 cues
->entries
[cues
->num_entries
++].duration
= duration
;
435 static int64_t mkv_write_cues(AVFormatContext
*s
, mkv_cues
*cues
, mkv_track
*tracks
, int num_tracks
)
437 AVIOContext
*pb
= s
->pb
;
438 ebml_master cues_element
;
442 currentpos
= avio_tell(pb
);
443 cues_element
= start_ebml_master(pb
, MATROSKA_ID_CUES
, 0);
445 for (i
= 0; i
< cues
->num_entries
; i
++) {
446 ebml_master cuepoint
, track_positions
;
447 mkv_cuepoint
*entry
= &cues
->entries
[i
];
448 uint64_t pts
= entry
->pts
;
451 // Calculate the number of entries, so we know the element size
452 for (j
= 0; j
< num_tracks
; j
++)
453 tracks
[j
].has_cue
= 0;
454 for (j
= 0; j
< cues
->num_entries
- i
&& entry
[j
].pts
== pts
; j
++) {
455 int tracknum
= entry
[j
].stream_idx
;
456 av_assert0(tracknum
>=0 && tracknum
<num_tracks
);
457 if (tracks
[tracknum
].has_cue
&& s
->streams
[tracknum
]->codec
->codec_type
!= AVMEDIA_TYPE_SUBTITLE
)
459 tracks
[tracknum
].has_cue
= 1;
463 cuepoint
= start_ebml_master(pb
, MATROSKA_ID_POINTENTRY
, MAX_CUEPOINT_SIZE(ctp_nb
));
464 put_ebml_uint(pb
, MATROSKA_ID_CUETIME
, pts
);
466 // put all the entries from different tracks that have the exact same
467 // timestamp into the same CuePoint
468 for (j
= 0; j
< num_tracks
; j
++)
469 tracks
[j
].has_cue
= 0;
470 for (j
= 0; j
< cues
->num_entries
- i
&& entry
[j
].pts
== pts
; j
++) {
471 int tracknum
= entry
[j
].stream_idx
;
472 av_assert0(tracknum
>=0 && tracknum
<num_tracks
);
473 if (tracks
[tracknum
].has_cue
&& s
->streams
[tracknum
]->codec
->codec_type
!= AVMEDIA_TYPE_SUBTITLE
)
475 tracks
[tracknum
].has_cue
= 1;
476 track_positions
= start_ebml_master(pb
, MATROSKA_ID_CUETRACKPOSITION
, MAX_CUETRACKPOS_SIZE
);
477 put_ebml_uint(pb
, MATROSKA_ID_CUETRACK
, entry
[j
].tracknum
);
478 put_ebml_uint(pb
, MATROSKA_ID_CUECLUSTERPOSITION
, entry
[j
].cluster_pos
);
479 put_ebml_uint(pb
, MATROSKA_ID_CUERELATIVEPOSITION
, entry
[j
].relative_pos
);
480 if (entry
[j
].duration
!= -1)
481 put_ebml_uint(pb
, MATROSKA_ID_CUEDURATION
, entry
[j
].duration
);
482 end_ebml_master(pb
, track_positions
);
485 end_ebml_master(pb
, cuepoint
);
487 end_ebml_master(pb
, cues_element
);
492 static int put_xiph_codecpriv(AVFormatContext
*s
, AVIOContext
*pb
, AVCodecContext
*codec
)
494 uint8_t *header_start
[3];
496 int first_header_size
;
499 if (codec
->codec_id
== AV_CODEC_ID_VORBIS
)
500 first_header_size
= 30;
502 first_header_size
= 42;
504 if (avpriv_split_xiph_headers(codec
->extradata
, codec
->extradata_size
,
505 first_header_size
, header_start
, header_len
) < 0) {
506 av_log(s
, AV_LOG_ERROR
, "Extradata corrupt.\n");
510 avio_w8(pb
, 2); // number packets - 1
511 for (j
= 0; j
< 2; j
++) {
512 put_xiph_size(pb
, header_len
[j
]);
514 for (j
= 0; j
< 3; j
++)
515 avio_write(pb
, header_start
[j
], header_len
[j
]);
520 static int put_wv_codecpriv(AVIOContext
*pb
, AVCodecContext
*codec
)
522 if (codec
->extradata
&& codec
->extradata_size
== 2)
523 avio_write(pb
, codec
->extradata
, 2);
525 avio_wl16(pb
, 0x403); // fallback to the version mentioned in matroska specs
529 static int put_flac_codecpriv(AVFormatContext
*s
,
530 AVIOContext
*pb
, AVCodecContext
*codec
)
532 int write_comment
= (codec
->channel_layout
&&
533 !(codec
->channel_layout
& ~0x3ffffULL
) &&
534 !ff_flac_is_native_layout(codec
->channel_layout
));
535 int ret
= ff_flac_write_header(pb
, codec
->extradata
, codec
->extradata_size
,
542 const char *vendor
= (s
->flags
& AVFMT_FLAG_BITEXACT
) ?
543 "Lavf" : LIBAVFORMAT_IDENT
;
544 AVDictionary
*dict
= NULL
;
545 uint8_t buf
[32], *data
, *p
;
548 snprintf(buf
, sizeof(buf
), "0x%"PRIx64
, codec
->channel_layout
);
549 av_dict_set(&dict
, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", buf
, 0);
551 len
= ff_vorbiscomment_length(dict
, vendor
);
552 data
= av_malloc(len
+ 4);
555 return AVERROR(ENOMEM
);
559 AV_WB24(data
+ 1, len
);
562 ff_vorbiscomment_write(&p
, &dict
, vendor
);
564 avio_write(pb
, data
, len
+ 4);
573 static void get_aac_sample_rates(AVFormatContext
*s
, AVCodecContext
*codec
,
574 int *sample_rate
, int *output_sample_rate
)
576 MPEG4AudioConfig mp4ac
;
578 if (avpriv_mpeg4audio_get_config(&mp4ac
, codec
->extradata
,
579 codec
->extradata_size
* 8, 1) < 0) {
580 av_log(s
, AV_LOG_WARNING
,
581 "Error parsing AAC extradata, unable to determine samplerate.\n");
585 *sample_rate
= mp4ac
.sample_rate
;
586 *output_sample_rate
= mp4ac
.ext_sample_rate
;
589 static int mkv_write_native_codecprivate(AVFormatContext
*s
,
590 AVCodecContext
*codec
,
593 switch (codec
->codec_id
) {
594 case AV_CODEC_ID_VORBIS
:
595 case AV_CODEC_ID_THEORA
:
596 return put_xiph_codecpriv(s
, dyn_cp
, codec
);
597 case AV_CODEC_ID_FLAC
:
598 return put_flac_codecpriv(s
, dyn_cp
, codec
);
599 case AV_CODEC_ID_WAVPACK
:
600 return put_wv_codecpriv(dyn_cp
, codec
);
601 case AV_CODEC_ID_H264
:
602 return ff_isom_write_avcc(dyn_cp
, codec
->extradata
,
603 codec
->extradata_size
);
604 case AV_CODEC_ID_HEVC
:
605 return ff_isom_write_hvcc(dyn_cp
, codec
->extradata
,
606 codec
->extradata_size
, 0);
607 case AV_CODEC_ID_ALAC
:
608 if (codec
->extradata_size
< 36) {
609 av_log(s
, AV_LOG_ERROR
,
610 "Invalid extradata found, ALAC expects a 36-byte "
612 return AVERROR_INVALIDDATA
;
614 avio_write(dyn_cp
, codec
->extradata
+ 12,
615 codec
->extradata_size
- 12);
618 if (codec
->codec_id
== AV_CODEC_ID_PRORES
&&
619 ff_codec_get_id(ff_codec_movvideo_tags
, codec
->codec_tag
) == AV_CODEC_ID_PRORES
) {
620 avio_wl32(dyn_cp
, codec
->codec_tag
);
621 } else if (codec
->extradata_size
&& codec
->codec_id
!= AV_CODEC_ID_TTA
)
622 avio_write(dyn_cp
, codec
->extradata
, codec
->extradata_size
);
628 static int mkv_write_codecprivate(AVFormatContext
*s
, AVIOContext
*pb
,
629 AVCodecContext
*codec
, int native_id
,
634 int ret
, codecpriv_size
;
636 ret
= avio_open_dyn_buf(&dyn_cp
);
641 ret
= mkv_write_native_codecprivate(s
, codec
, dyn_cp
);
642 } else if (codec
->codec_type
== AVMEDIA_TYPE_VIDEO
) {
644 if (!codec
->codec_tag
)
645 codec
->codec_tag
= ff_codec_get_tag(ff_codec_movvideo_tags
,
647 if (codec
->extradata_size
) {
648 if ( ff_codec_get_id(ff_codec_movvideo_tags
, codec
->codec_tag
) == codec
->codec_id
649 && ff_codec_get_id(ff_codec_movvideo_tags
, AV_RL32(codec
->extradata
+ 4)) != codec
->codec_id
652 avio_wb32(dyn_cp
, 0x5a + codec
->extradata_size
);
653 avio_wl32(dyn_cp
, codec
->codec_tag
);
654 for(i
= 0; i
< 0x5a - 8; i
++)
657 avio_write(dyn_cp
, codec
->extradata
, codec
->extradata_size
);
660 if (!ff_codec_get_tag(ff_codec_bmp_tags
, codec
->codec_id
))
661 av_log(s
, AV_LOG_WARNING
, "codec %s is not supported by this format\n",
662 avcodec_get_name(codec
->codec_id
));
664 if (!codec
->codec_tag
)
665 codec
->codec_tag
= ff_codec_get_tag(ff_codec_bmp_tags
,
667 if (!codec
->codec_tag
) {
668 av_log(s
, AV_LOG_ERROR
, "No bmp codec tag found for codec %s\n",
669 avcodec_get_name(codec
->codec_id
));
670 ret
= AVERROR(EINVAL
);
673 ff_put_bmp_header(dyn_cp
, codec
, ff_codec_bmp_tags
, 0, 0);
675 } else if (codec
->codec_type
== AVMEDIA_TYPE_AUDIO
) {
677 tag
= ff_codec_get_tag(ff_codec_wav_tags
, codec
->codec_id
);
679 av_log(s
, AV_LOG_ERROR
, "No wav codec tag found for codec %s\n",
680 avcodec_get_name(codec
->codec_id
));
681 ret
= AVERROR(EINVAL
);
683 if (!codec
->codec_tag
)
684 codec
->codec_tag
= tag
;
686 ff_put_wav_header(dyn_cp
, codec
, FF_PUT_WAV_HEADER_FORCE_WAVEFORMATEX
);
689 codecpriv_size
= avio_close_dyn_buf(dyn_cp
, &codecpriv
);
691 put_ebml_binary(pb
, MATROSKA_ID_CODECPRIVATE
, codecpriv
,
698 static int mkv_write_stereo_mode(AVFormatContext
*s
, AVIOContext
*pb
,
699 AVStream
*st
, int mode
, int *h_width
, int *h_height
)
703 AVDictionaryEntry
*tag
;
704 MatroskaVideoStereoModeType format
= MATROSKA_VIDEO_STEREOMODE_TYPE_NB
;
708 // convert metadata into proper side data and add it to the stream
709 if ((tag
= av_dict_get(st
->metadata
, "stereo_mode", NULL
, 0)) ||
710 (tag
= av_dict_get( s
->metadata
, "stereo_mode", NULL
, 0))) {
711 int stereo_mode
= atoi(tag
->value
);
713 for (i
=0; i
<MATROSKA_VIDEO_STEREOMODE_TYPE_NB
; i
++)
714 if (!strcmp(tag
->value
, ff_matroska_video_stereo_mode
[i
])){
719 if (stereo_mode
< MATROSKA_VIDEO_STEREOMODE_TYPE_NB
&&
720 stereo_mode
!= 10 && stereo_mode
!= 12) {
721 int ret
= ff_mkv_stereo3d_conv(st
, stereo_mode
);
727 // iterate to find the stereo3d side data
728 for (i
= 0; i
< st
->nb_side_data
; i
++) {
729 AVPacketSideData sd
= st
->side_data
[i
];
730 if (sd
.type
== AV_PKT_DATA_STEREO3D
) {
731 AVStereo3D
*stereo
= (AVStereo3D
*)sd
.data
;
733 switch (stereo
->type
) {
735 format
= MATROSKA_VIDEO_STEREOMODE_TYPE_MONO
;
737 case AV_STEREO3D_SIDEBYSIDE
:
738 format
= (stereo
->flags
& AV_STEREO3D_FLAG_INVERT
)
739 ? MATROSKA_VIDEO_STEREOMODE_TYPE_RIGHT_LEFT
740 : MATROSKA_VIDEO_STEREOMODE_TYPE_LEFT_RIGHT
;
743 case AV_STEREO3D_TOPBOTTOM
:
744 format
= MATROSKA_VIDEO_STEREOMODE_TYPE_TOP_BOTTOM
;
745 if (stereo
->flags
& AV_STEREO3D_FLAG_INVERT
)
749 case AV_STEREO3D_CHECKERBOARD
:
750 format
= MATROSKA_VIDEO_STEREOMODE_TYPE_CHECKERBOARD_LR
;
751 if (stereo
->flags
& AV_STEREO3D_FLAG_INVERT
)
754 case AV_STEREO3D_LINES
:
755 format
= MATROSKA_VIDEO_STEREOMODE_TYPE_ROW_INTERLEAVED_LR
;
756 if (stereo
->flags
& AV_STEREO3D_FLAG_INVERT
)
760 case AV_STEREO3D_COLUMNS
:
761 format
= MATROSKA_VIDEO_STEREOMODE_TYPE_COL_INTERLEAVED_LR
;
762 if (stereo
->flags
& AV_STEREO3D_FLAG_INVERT
)
766 case AV_STEREO3D_FRAMESEQUENCE
:
767 format
= MATROSKA_VIDEO_STEREOMODE_TYPE_BOTH_EYES_BLOCK_LR
;
768 if (stereo
->flags
& AV_STEREO3D_FLAG_INVERT
)
776 if (format
== MATROSKA_VIDEO_STEREOMODE_TYPE_NB
)
779 // if webm, do not write unsupported modes
780 if ((mode
== MODE_WEBM
&&
781 format
> MATROSKA_VIDEO_STEREOMODE_TYPE_TOP_BOTTOM
&&
782 format
!= MATROSKA_VIDEO_STEREOMODE_TYPE_RIGHT_LEFT
)
783 || format
>= MATROSKA_VIDEO_STEREOMODE_TYPE_NB
) {
784 av_log(s
, AV_LOG_ERROR
,
785 "The specified stereo mode is not valid.\n");
786 format
= MATROSKA_VIDEO_STEREOMODE_TYPE_NB
;
787 return AVERROR(EINVAL
);
790 // write StereoMode if format is valid
791 put_ebml_uint(pb
, MATROSKA_ID_VIDEOSTEREOMODE
, format
);
796 static int mkv_write_track(AVFormatContext
*s
, MatroskaMuxContext
*mkv
,
797 int i
, AVIOContext
*pb
, int default_stream_exists
)
799 AVStream
*st
= s
->streams
[i
];
800 AVCodecContext
*codec
= st
->codec
;
801 ebml_master subinfo
, track
;
804 int bit_depth
= av_get_bits_per_sample(codec
->codec_id
);
805 int sample_rate
= codec
->sample_rate
;
806 int output_sample_rate
= 0;
807 int display_width_div
= 1;
808 int display_height_div
= 1;
810 AVDictionaryEntry
*tag
;
812 // ms precision is the de-facto standard timescale for mkv files
813 avpriv_set_pts_info(st
, 64, 1, 1000);
815 if (codec
->codec_type
== AVMEDIA_TYPE_ATTACHMENT
) {
816 mkv
->have_attachments
= 1;
820 if (!bit_depth
&& codec
->codec_id
!= AV_CODEC_ID_ADPCM_G726
)
821 bit_depth
= av_get_bytes_per_sample(codec
->sample_fmt
) << 3;
823 bit_depth
= codec
->bits_per_coded_sample
;
825 if (codec
->codec_id
== AV_CODEC_ID_AAC
)
826 get_aac_sample_rates(s
, codec
, &sample_rate
, &output_sample_rate
);
828 track
= start_ebml_master(pb
, MATROSKA_ID_TRACKENTRY
, 0);
829 put_ebml_uint (pb
, MATROSKA_ID_TRACKNUMBER
,
830 mkv
->is_dash
? mkv
->dash_track_number
: i
+ 1);
831 put_ebml_uint (pb
, MATROSKA_ID_TRACKUID
,
832 mkv
->is_dash
? mkv
->dash_track_number
: i
+ 1);
833 put_ebml_uint (pb
, MATROSKA_ID_TRACKFLAGLACING
, 0); // no lacing (yet)
835 if ((tag
= av_dict_get(st
->metadata
, "title", NULL
, 0)))
836 put_ebml_string(pb
, MATROSKA_ID_TRACKNAME
, tag
->value
);
837 tag
= av_dict_get(st
->metadata
, "language", NULL
, 0);
838 if (mkv
->mode
!= MODE_WEBM
|| codec
->codec_id
!= AV_CODEC_ID_WEBVTT
) {
839 put_ebml_string(pb
, MATROSKA_ID_TRACKLANGUAGE
, tag
&& tag
->value
? tag
->value
:"und");
840 } else if (tag
&& tag
->value
) {
841 put_ebml_string(pb
, MATROSKA_ID_TRACKLANGUAGE
, tag
->value
);
844 // The default value for TRACKFLAGDEFAULT is 1, so add element
845 // if we need to clear it.
846 if (default_stream_exists
&& !(st
->disposition
& AV_DISPOSITION_DEFAULT
))
847 put_ebml_uint(pb
, MATROSKA_ID_TRACKFLAGDEFAULT
, !!(st
->disposition
& AV_DISPOSITION_DEFAULT
));
849 if (st
->disposition
& AV_DISPOSITION_FORCED
)
850 put_ebml_uint(pb
, MATROSKA_ID_TRACKFLAGFORCED
, 1);
852 if (mkv
->mode
== MODE_WEBM
&& codec
->codec_id
== AV_CODEC_ID_WEBVTT
) {
853 const char *codec_id
;
854 if (st
->disposition
& AV_DISPOSITION_CAPTIONS
) {
855 codec_id
= "D_WEBVTT/CAPTIONS";
856 native_id
= MATROSKA_TRACK_TYPE_SUBTITLE
;
857 } else if (st
->disposition
& AV_DISPOSITION_DESCRIPTIONS
) {
858 codec_id
= "D_WEBVTT/DESCRIPTIONS";
859 native_id
= MATROSKA_TRACK_TYPE_METADATA
;
860 } else if (st
->disposition
& AV_DISPOSITION_METADATA
) {
861 codec_id
= "D_WEBVTT/METADATA";
862 native_id
= MATROSKA_TRACK_TYPE_METADATA
;
864 codec_id
= "D_WEBVTT/SUBTITLES";
865 native_id
= MATROSKA_TRACK_TYPE_SUBTITLE
;
867 put_ebml_string(pb
, MATROSKA_ID_CODECID
, codec_id
);
869 // look for a codec ID string specific to mkv to use,
870 // if none are found, use AVI codes
871 for (j
= 0; ff_mkv_codec_tags
[j
].id
!= AV_CODEC_ID_NONE
; j
++) {
872 if (ff_mkv_codec_tags
[j
].id
== codec
->codec_id
) {
873 put_ebml_string(pb
, MATROSKA_ID_CODECID
, ff_mkv_codec_tags
[j
].str
);
880 if (codec
->codec_type
== AVMEDIA_TYPE_AUDIO
&& codec
->initial_padding
&& codec
->codec_id
== AV_CODEC_ID_OPUS
) {
881 // mkv->tracks[i].ts_offset = av_rescale_q(codec->initial_padding,
882 // (AVRational){ 1, codec->sample_rate },
885 put_ebml_uint(pb
, MATROSKA_ID_CODECDELAY
,
886 av_rescale_q(codec
->initial_padding
,
887 (AVRational
){ 1, codec
->sample_rate
},
888 (AVRational
){ 1, 1000000000 }));
890 if (codec
->codec_id
== AV_CODEC_ID_OPUS
) {
891 put_ebml_uint(pb
, MATROSKA_ID_SEEKPREROLL
, OPUS_SEEK_PREROLL
);
894 if (mkv
->mode
== MODE_WEBM
&& !(codec
->codec_id
== AV_CODEC_ID_VP8
||
895 codec
->codec_id
== AV_CODEC_ID_VP9
||
896 codec
->codec_id
== AV_CODEC_ID_OPUS
||
897 codec
->codec_id
== AV_CODEC_ID_VORBIS
||
898 codec
->codec_id
== AV_CODEC_ID_WEBVTT
)) {
899 av_log(s
, AV_LOG_ERROR
,
900 "Only VP8 or VP9 video and Vorbis or Opus audio and WebVTT subtitles are supported for WebM.\n");
901 return AVERROR(EINVAL
);
904 switch (codec
->codec_type
) {
905 case AVMEDIA_TYPE_VIDEO
:
906 put_ebml_uint(pb
, MATROSKA_ID_TRACKTYPE
, MATROSKA_TRACK_TYPE_VIDEO
);
908 if( st
->avg_frame_rate
.num
> 0 && st
->avg_frame_rate
.den
> 0
909 && 1.0/av_q2d(st
->avg_frame_rate
) > av_q2d(codec
->time_base
))
910 put_ebml_uint(pb
, MATROSKA_ID_TRACKDEFAULTDURATION
, 1E9
/ av_q2d(st
->avg_frame_rate
));
912 put_ebml_uint(pb
, MATROSKA_ID_TRACKDEFAULTDURATION
, av_q2d(codec
->time_base
)*1E9
);
915 ff_codec_get_tag(ff_codec_movvideo_tags
, codec
->codec_id
) &&
916 (!ff_codec_get_tag(ff_codec_bmp_tags
, codec
->codec_id
) ||
917 codec
->codec_id
== AV_CODEC_ID_SVQ1
||
918 codec
->codec_id
== AV_CODEC_ID_SVQ3
||
919 codec
->codec_id
== AV_CODEC_ID_CINEPAK
))
923 put_ebml_string(pb
, MATROSKA_ID_CODECID
, "V_QUICKTIME");
924 else if (!native_id
) {
925 // if there is no mkv-specific codec ID, use VFW mode
926 put_ebml_string(pb
, MATROSKA_ID_CODECID
, "V_MS/VFW/FOURCC");
927 mkv
->tracks
[i
].write_dts
= 1;
930 subinfo
= start_ebml_master(pb
, MATROSKA_ID_TRACKVIDEO
, 0);
931 // XXX: interlace flag?
932 put_ebml_uint (pb
, MATROSKA_ID_VIDEOPIXELWIDTH
, codec
->width
);
933 put_ebml_uint (pb
, MATROSKA_ID_VIDEOPIXELHEIGHT
, codec
->height
);
935 // check both side data and metadata for stereo information,
936 // write the result to the bitstream if any is found
937 ret
= mkv_write_stereo_mode(s
, pb
, st
, mkv
->mode
,
939 &display_height_div
);
943 if (((tag
= av_dict_get(st
->metadata
, "alpha_mode", NULL
, 0)) && atoi(tag
->value
)) ||
944 ((tag
= av_dict_get( s
->metadata
, "alpha_mode", NULL
, 0)) && atoi(tag
->value
)) ||
945 (codec
->pix_fmt
== AV_PIX_FMT_YUVA420P
)) {
946 put_ebml_uint(pb
, MATROSKA_ID_VIDEOALPHAMODE
, 1);
949 // write DisplayWidth and DisplayHeight, they contain the size of
950 // a single source view and/or the display aspect ratio
951 if (st
->sample_aspect_ratio
.num
) {
952 int64_t d_width
= av_rescale(codec
->width
, st
->sample_aspect_ratio
.num
, st
->sample_aspect_ratio
.den
);
953 if (d_width
> INT_MAX
) {
954 av_log(s
, AV_LOG_ERROR
, "Overflow in display width\n");
955 return AVERROR(EINVAL
);
957 put_ebml_uint(pb
, MATROSKA_ID_VIDEODISPLAYWIDTH
, d_width
/ display_width_div
);
958 put_ebml_uint(pb
, MATROSKA_ID_VIDEODISPLAYHEIGHT
, codec
->height
/ display_height_div
);
959 } else if (display_width_div
!= 1 || display_height_div
!= 1) {
960 put_ebml_uint(pb
, MATROSKA_ID_VIDEODISPLAYWIDTH
, codec
->width
/ display_width_div
);
961 put_ebml_uint(pb
, MATROSKA_ID_VIDEODISPLAYHEIGHT
, codec
->height
/ display_height_div
);
964 if (codec
->codec_id
== AV_CODEC_ID_RAWVIDEO
) {
965 uint32_t color_space
= av_le2ne32(codec
->codec_tag
);
966 put_ebml_binary(pb
, MATROSKA_ID_VIDEOCOLORSPACE
, &color_space
, sizeof(color_space
));
969 end_ebml_master(pb
, subinfo
);
972 case AVMEDIA_TYPE_AUDIO
:
973 put_ebml_uint(pb
, MATROSKA_ID_TRACKTYPE
, MATROSKA_TRACK_TYPE_AUDIO
);
976 // no mkv-specific ID, use ACM mode
977 put_ebml_string(pb
, MATROSKA_ID_CODECID
, "A_MS/ACM");
979 subinfo
= start_ebml_master(pb
, MATROSKA_ID_TRACKAUDIO
, 0);
980 put_ebml_uint (pb
, MATROSKA_ID_AUDIOCHANNELS
, codec
->channels
);
981 put_ebml_float (pb
, MATROSKA_ID_AUDIOSAMPLINGFREQ
, sample_rate
);
982 if (output_sample_rate
)
983 put_ebml_float(pb
, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ
, output_sample_rate
);
985 put_ebml_uint(pb
, MATROSKA_ID_AUDIOBITDEPTH
, bit_depth
);
986 end_ebml_master(pb
, subinfo
);
989 case AVMEDIA_TYPE_SUBTITLE
:
991 av_log(s
, AV_LOG_ERROR
, "Subtitle codec %d is not supported.\n", codec
->codec_id
);
992 return AVERROR(ENOSYS
);
995 if (mkv
->mode
!= MODE_WEBM
|| codec
->codec_id
!= AV_CODEC_ID_WEBVTT
)
996 native_id
= MATROSKA_TRACK_TYPE_SUBTITLE
;
998 put_ebml_uint(pb
, MATROSKA_ID_TRACKTYPE
, native_id
);
1001 av_log(s
, AV_LOG_ERROR
, "Only audio, video, and subtitles are supported for Matroska.\n");
1002 return AVERROR(EINVAL
);
1005 if (mkv
->mode
!= MODE_WEBM
|| codec
->codec_id
!= AV_CODEC_ID_WEBVTT
) {
1006 ret
= mkv_write_codecprivate(s
, pb
, codec
, native_id
, qt_id
);
1011 end_ebml_master(pb
, track
);
1016 static int mkv_write_tracks(AVFormatContext
*s
)
1018 MatroskaMuxContext
*mkv
= s
->priv_data
;
1019 AVIOContext
*pb
= s
->pb
;
1021 int i
, ret
, default_stream_exists
= 0;
1023 ret
= mkv_add_seekhead_entry(mkv
->main_seekhead
, MATROSKA_ID_TRACKS
, avio_tell(pb
));
1027 tracks
= start_ebml_master(pb
, MATROSKA_ID_TRACKS
, 0);
1028 for (i
= 0; i
< s
->nb_streams
; i
++) {
1029 AVStream
*st
= s
->streams
[i
];
1030 default_stream_exists
|= st
->disposition
& AV_DISPOSITION_DEFAULT
;
1032 for (i
= 0; i
< s
->nb_streams
; i
++) {
1033 ret
= mkv_write_track(s
, mkv
, i
, pb
, default_stream_exists
);
1037 end_ebml_master(pb
, tracks
);
1041 static int mkv_write_chapters(AVFormatContext
*s
)
1043 MatroskaMuxContext
*mkv
= s
->priv_data
;
1044 AVIOContext
*pb
= s
->pb
;
1045 ebml_master chapters
, editionentry
;
1046 AVRational scale
= {1, 1E9
};
1049 if (!s
->nb_chapters
|| mkv
->wrote_chapters
)
1052 ret
= mkv_add_seekhead_entry(mkv
->main_seekhead
, MATROSKA_ID_CHAPTERS
, avio_tell(pb
));
1053 if (ret
< 0) return ret
;
1055 chapters
= start_ebml_master(pb
, MATROSKA_ID_CHAPTERS
, 0);
1056 editionentry
= start_ebml_master(pb
, MATROSKA_ID_EDITIONENTRY
, 0);
1057 put_ebml_uint(pb
, MATROSKA_ID_EDITIONFLAGDEFAULT
, 1);
1058 put_ebml_uint(pb
, MATROSKA_ID_EDITIONFLAGHIDDEN
, 0);
1059 for (i
= 0; i
< s
->nb_chapters
; i
++) {
1060 ebml_master chapteratom
, chapterdisplay
;
1061 AVChapter
*c
= s
->chapters
[i
];
1062 AVDictionaryEntry
*t
= NULL
;
1064 chapteratom
= start_ebml_master(pb
, MATROSKA_ID_CHAPTERATOM
, 0);
1065 put_ebml_uint(pb
, MATROSKA_ID_CHAPTERUID
, c
->id
+ mkv
->chapter_id_offset
);
1066 put_ebml_uint(pb
, MATROSKA_ID_CHAPTERTIMESTART
,
1067 av_rescale_q(c
->start
, c
->time_base
, scale
));
1068 put_ebml_uint(pb
, MATROSKA_ID_CHAPTERTIMEEND
,
1069 av_rescale_q(c
->end
, c
->time_base
, scale
));
1070 put_ebml_uint(pb
, MATROSKA_ID_CHAPTERFLAGHIDDEN
, 0);
1071 put_ebml_uint(pb
, MATROSKA_ID_CHAPTERFLAGENABLED
, 1);
1072 if ((t
= av_dict_get(c
->metadata
, "title", NULL
, 0))) {
1073 chapterdisplay
= start_ebml_master(pb
, MATROSKA_ID_CHAPTERDISPLAY
, 0);
1074 put_ebml_string(pb
, MATROSKA_ID_CHAPSTRING
, t
->value
);
1075 put_ebml_string(pb
, MATROSKA_ID_CHAPLANG
, "und");
1076 end_ebml_master(pb
, chapterdisplay
);
1078 end_ebml_master(pb
, chapteratom
);
1080 end_ebml_master(pb
, editionentry
);
1081 end_ebml_master(pb
, chapters
);
1083 mkv
->wrote_chapters
= 1;
1087 static void mkv_write_simpletag(AVIOContext
*pb
, AVDictionaryEntry
*t
)
1089 uint8_t *key
= av_strdup(t
->key
);
1091 const uint8_t *lang
= NULL
;
1094 if ((p
= strrchr(p
, '-')) &&
1095 (lang
= av_convert_lang_to(p
+ 1, AV_LANG_ISO639_2_BIBL
)))
1102 else if (*p
>= 'a' && *p
<= 'z')
1107 tag
= start_ebml_master(pb
, MATROSKA_ID_SIMPLETAG
, 0);
1108 put_ebml_string(pb
, MATROSKA_ID_TAGNAME
, key
);
1110 put_ebml_string(pb
, MATROSKA_ID_TAGLANG
, lang
);
1111 put_ebml_string(pb
, MATROSKA_ID_TAGSTRING
, t
->value
);
1112 end_ebml_master(pb
, tag
);
1117 static int mkv_write_tag(AVFormatContext
*s
, AVDictionary
*m
, unsigned int elementid
,
1118 unsigned int uid
, ebml_master
*tags
)
1120 MatroskaMuxContext
*mkv
= s
->priv_data
;
1121 ebml_master tag
, targets
;
1122 AVDictionaryEntry
*t
= NULL
;
1126 ret
= mkv_add_seekhead_entry(mkv
->main_seekhead
, MATROSKA_ID_TAGS
, avio_tell(s
->pb
));
1127 if (ret
< 0) return ret
;
1129 *tags
= start_ebml_master(s
->pb
, MATROSKA_ID_TAGS
, 0);
1132 tag
= start_ebml_master(s
->pb
, MATROSKA_ID_TAG
, 0);
1133 targets
= start_ebml_master(s
->pb
, MATROSKA_ID_TAGTARGETS
, 0);
1135 put_ebml_uint(s
->pb
, elementid
, uid
);
1136 end_ebml_master(s
->pb
, targets
);
1138 while ((t
= av_dict_get(m
, "", t
, AV_DICT_IGNORE_SUFFIX
)))
1139 if (av_strcasecmp(t
->key
, "title") &&
1140 av_strcasecmp(t
->key
, "stereo_mode") &&
1141 av_strcasecmp(t
->key
, "encoding_tool"))
1142 mkv_write_simpletag(s
->pb
, t
);
1144 end_ebml_master(s
->pb
, tag
);
1148 static int mkv_check_tag(AVDictionary
*m
)
1150 AVDictionaryEntry
*t
= NULL
;
1152 while ((t
= av_dict_get(m
, "", t
, AV_DICT_IGNORE_SUFFIX
)))
1153 if (av_strcasecmp(t
->key
, "title") && av_strcasecmp(t
->key
, "stereo_mode"))
1159 static int mkv_write_tags(AVFormatContext
*s
)
1161 MatroskaMuxContext
*mkv
= s
->priv_data
;
1162 ebml_master tags
= {0};
1165 ff_metadata_conv_ctx(s
, ff_mkv_metadata_conv
, NULL
);
1167 if (mkv_check_tag(s
->metadata
)) {
1168 ret
= mkv_write_tag(s
, s
->metadata
, 0, 0, &tags
);
1169 if (ret
< 0) return ret
;
1172 for (i
= 0; i
< s
->nb_streams
; i
++) {
1173 AVStream
*st
= s
->streams
[i
];
1175 if (!mkv_check_tag(st
->metadata
))
1178 ret
= mkv_write_tag(s
, st
->metadata
, MATROSKA_ID_TAGTARGETS_TRACKUID
, i
+ 1, &tags
);
1179 if (ret
< 0) return ret
;
1182 for (i
= 0; i
< s
->nb_chapters
; i
++) {
1183 AVChapter
*ch
= s
->chapters
[i
];
1185 if (!mkv_check_tag(ch
->metadata
))
1188 ret
= mkv_write_tag(s
, ch
->metadata
, MATROSKA_ID_TAGTARGETS_CHAPTERUID
, ch
->id
+ mkv
->chapter_id_offset
, &tags
);
1189 if (ret
< 0) return ret
;
1193 end_ebml_master(s
->pb
, tags
);
1197 static int mkv_write_attachments(AVFormatContext
*s
)
1199 MatroskaMuxContext
*mkv
= s
->priv_data
;
1200 AVIOContext
*pb
= s
->pb
;
1201 ebml_master attachments
;
1205 if (!mkv
->have_attachments
)
1208 av_lfg_init(&c
, av_get_random_seed());
1210 ret
= mkv_add_seekhead_entry(mkv
->main_seekhead
, MATROSKA_ID_ATTACHMENTS
, avio_tell(pb
));
1211 if (ret
< 0) return ret
;
1213 attachments
= start_ebml_master(pb
, MATROSKA_ID_ATTACHMENTS
, 0);
1215 for (i
= 0; i
< s
->nb_streams
; i
++) {
1216 AVStream
*st
= s
->streams
[i
];
1217 ebml_master attached_file
;
1218 AVDictionaryEntry
*t
;
1219 const char *mimetype
= NULL
;
1222 if (st
->codec
->codec_type
!= AVMEDIA_TYPE_ATTACHMENT
)
1225 attached_file
= start_ebml_master(pb
, MATROSKA_ID_ATTACHEDFILE
, 0);
1227 if (t
= av_dict_get(st
->metadata
, "title", NULL
, 0))
1228 put_ebml_string(pb
, MATROSKA_ID_FILEDESC
, t
->value
);
1229 if (!(t
= av_dict_get(st
->metadata
, "filename", NULL
, 0))) {
1230 av_log(s
, AV_LOG_ERROR
, "Attachment stream %d has no filename tag.\n", i
);
1231 return AVERROR(EINVAL
);
1233 put_ebml_string(pb
, MATROSKA_ID_FILENAME
, t
->value
);
1234 if (t
= av_dict_get(st
->metadata
, "mimetype", NULL
, 0))
1235 mimetype
= t
->value
;
1236 else if (st
->codec
->codec_id
!= AV_CODEC_ID_NONE
) {
1238 for (i
= 0; ff_mkv_mime_tags
[i
].id
!= AV_CODEC_ID_NONE
; i
++)
1239 if (ff_mkv_mime_tags
[i
].id
== st
->codec
->codec_id
) {
1240 mimetype
= ff_mkv_mime_tags
[i
].str
;
1245 av_log(s
, AV_LOG_ERROR
, "Attachment stream %d has no mimetype tag and "
1246 "it cannot be deduced from the codec id.\n", i
);
1247 return AVERROR(EINVAL
);
1250 if (s
->flags
& AVFMT_FLAG_BITEXACT
) {
1251 struct AVSHA
*sha
= av_sha_alloc();
1254 return AVERROR(ENOMEM
);
1255 av_sha_init(sha
, 160);
1256 av_sha_update(sha
, st
->codec
->extradata
, st
->codec
->extradata_size
);
1257 av_sha_final(sha
, digest
);
1259 fileuid
= AV_RL64(digest
);
1261 fileuid
= av_lfg_get(&c
);
1263 av_log(s
, AV_LOG_VERBOSE
, "Using %.16"PRIx64
" for attachment %d\n",
1266 put_ebml_string(pb
, MATROSKA_ID_FILEMIMETYPE
, mimetype
);
1267 put_ebml_binary(pb
, MATROSKA_ID_FILEDATA
, st
->codec
->extradata
, st
->codec
->extradata_size
);
1268 put_ebml_uint(pb
, MATROSKA_ID_FILEUID
, fileuid
);
1269 end_ebml_master(pb
, attached_file
);
1271 end_ebml_master(pb
, attachments
);
1276 static int mkv_write_header(AVFormatContext
*s
)
1278 MatroskaMuxContext
*mkv
= s
->priv_data
;
1279 AVIOContext
*pb
= s
->pb
;
1280 ebml_master ebml_header
, segment_info
;
1281 AVDictionaryEntry
*tag
;
1282 int ret
, i
, version
= 2;
1284 if (!strcmp(s
->oformat
->name
, "webm"))
1285 mkv
->mode
= MODE_WEBM
;
1287 mkv
->mode
= MODE_MATROSKAv2
;
1289 if (s
->avoid_negative_ts
< 0)
1290 s
->avoid_negative_ts
= 1;
1292 if (mkv
->mode
!= MODE_WEBM
||
1293 av_dict_get(s
->metadata
, "stereo_mode", NULL
, 0) ||
1294 av_dict_get(s
->metadata
, "alpha_mode", NULL
, 0))
1297 for (i
= 0; i
< s
->nb_streams
; i
++) {
1298 if (s
->streams
[i
]->codec
->codec_id
== AV_CODEC_ID_ATRAC3
||
1299 s
->streams
[i
]->codec
->codec_id
== AV_CODEC_ID_COOK
||
1300 s
->streams
[i
]->codec
->codec_id
== AV_CODEC_ID_RA_288
||
1301 s
->streams
[i
]->codec
->codec_id
== AV_CODEC_ID_SIPR
||
1302 s
->streams
[i
]->codec
->codec_id
== AV_CODEC_ID_RV10
||
1303 s
->streams
[i
]->codec
->codec_id
== AV_CODEC_ID_RV20
) {
1304 av_log(s
, AV_LOG_ERROR
,
1305 "The Matroska muxer does not yet support muxing %s\n",
1306 avcodec_get_name(s
->streams
[i
]->codec
->codec_id
));
1307 return AVERROR_PATCHWELCOME
;
1309 if (s
->streams
[i
]->codec
->codec_id
== AV_CODEC_ID_OPUS
||
1310 av_dict_get(s
->streams
[i
]->metadata
, "stereo_mode", NULL
, 0) ||
1311 av_dict_get(s
->streams
[i
]->metadata
, "alpha_mode", NULL
, 0))
1315 mkv
->tracks
= av_mallocz_array(s
->nb_streams
, sizeof(*mkv
->tracks
));
1317 return AVERROR(ENOMEM
);
1319 ebml_header
= start_ebml_master(pb
, EBML_ID_HEADER
, 0);
1320 put_ebml_uint (pb
, EBML_ID_EBMLVERSION
, 1);
1321 put_ebml_uint (pb
, EBML_ID_EBMLREADVERSION
, 1);
1322 put_ebml_uint (pb
, EBML_ID_EBMLMAXIDLENGTH
, 4);
1323 put_ebml_uint (pb
, EBML_ID_EBMLMAXSIZELENGTH
, 8);
1324 put_ebml_string (pb
, EBML_ID_DOCTYPE
, s
->oformat
->name
);
1325 put_ebml_uint (pb
, EBML_ID_DOCTYPEVERSION
, version
);
1326 put_ebml_uint (pb
, EBML_ID_DOCTYPEREADVERSION
, 2);
1327 end_ebml_master(pb
, ebml_header
);
1329 mkv
->segment
= start_ebml_master(pb
, MATROSKA_ID_SEGMENT
, 0);
1330 mkv
->segment_offset
= avio_tell(pb
);
1332 // we write 2 seek heads - one at the end of the file to point to each
1333 // cluster, and one at the beginning to point to all other level one
1334 // elements (including the seek head at the end of the file), which
1335 // isn't more than 10 elements if we only write one of each other
1336 // currently defined level 1 element
1337 mkv
->main_seekhead
= mkv_start_seekhead(pb
, mkv
->segment_offset
, 10);
1338 if (!mkv
->main_seekhead
)
1339 return AVERROR(ENOMEM
);
1341 ret
= mkv_add_seekhead_entry(mkv
->main_seekhead
, MATROSKA_ID_INFO
, avio_tell(pb
));
1342 if (ret
< 0) return ret
;
1344 segment_info
= start_ebml_master(pb
, MATROSKA_ID_INFO
, 0);
1345 put_ebml_uint(pb
, MATROSKA_ID_TIMECODESCALE
, 1000000);
1346 if ((tag
= av_dict_get(s
->metadata
, "title", NULL
, 0)))
1347 put_ebml_string(pb
, MATROSKA_ID_TITLE
, tag
->value
);
1348 if (!(s
->flags
& AVFMT_FLAG_BITEXACT
)) {
1349 uint32_t segment_uid
[4];
1352 av_lfg_init(&lfg
, av_get_random_seed());
1354 for (i
= 0; i
< 4; i
++)
1355 segment_uid
[i
] = av_lfg_get(&lfg
);
1357 put_ebml_string(pb
, MATROSKA_ID_MUXINGAPP
, LIBAVFORMAT_IDENT
);
1358 if ((tag
= av_dict_get(s
->metadata
, "encoding_tool", NULL
, 0)))
1359 put_ebml_string(pb
, MATROSKA_ID_WRITINGAPP
, tag
->value
);
1361 put_ebml_string(pb
, MATROSKA_ID_WRITINGAPP
, LIBAVFORMAT_IDENT
);
1362 put_ebml_binary(pb
, MATROSKA_ID_SEGMENTUID
, segment_uid
, 16);
1364 const char *ident
= "Lavf";
1365 put_ebml_string(pb
, MATROSKA_ID_MUXINGAPP
, ident
);
1366 put_ebml_string(pb
, MATROSKA_ID_WRITINGAPP
, ident
);
1369 if (tag
= av_dict_get(s
->metadata
, "creation_time", NULL
, 0)) {
1370 // Adjust time so it's relative to 2001-01-01 and convert to nanoseconds.
1371 int64_t date_utc
= (ff_iso8601_to_unix_time(tag
->value
) - 978307200) * 1000000000;
1372 uint8_t date_utc_buf
[8];
1373 AV_WB64(date_utc_buf
, date_utc
);
1374 put_ebml_binary(pb
, MATROSKA_ID_DATEUTC
, date_utc_buf
, 8);
1377 // reserve space for the duration
1379 mkv
->duration_offset
= avio_tell(pb
);
1380 put_ebml_void(pb
, 11); // assumes double-precision float to be written
1381 end_ebml_master(pb
, segment_info
);
1383 ret
= mkv_write_tracks(s
);
1387 for (i
= 0; i
< s
->nb_chapters
; i
++)
1388 mkv
->chapter_id_offset
= FFMAX(mkv
->chapter_id_offset
, 1LL - s
->chapters
[i
]->id
);
1390 if (mkv
->mode
!= MODE_WEBM
) {
1391 ret
= mkv_write_chapters(s
);
1395 ret
= mkv_write_tags(s
);
1399 ret
= mkv_write_attachments(s
);
1404 if (!s
->pb
->seekable
)
1405 mkv_write_seekhead(pb
, mkv
->main_seekhead
);
1407 mkv
->cues
= mkv_start_cues(mkv
->segment_offset
);
1409 return AVERROR(ENOMEM
);
1411 if (pb
->seekable
&& mkv
->reserve_cues_space
) {
1412 mkv
->cues_pos
= avio_tell(pb
);
1413 put_ebml_void(pb
, mkv
->reserve_cues_space
);
1416 av_init_packet(&mkv
->cur_audio_pkt
);
1417 mkv
->cur_audio_pkt
.size
= 0;
1418 mkv
->cluster_pos
= -1;
1422 // start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or
1423 // after 4k and on a keyframe
1425 if (mkv
->cluster_time_limit
< 0)
1426 mkv
->cluster_time_limit
= 5000;
1427 if (mkv
->cluster_size_limit
< 0)
1428 mkv
->cluster_size_limit
= 5 * 1024 * 1024;
1430 if (mkv
->cluster_time_limit
< 0)
1431 mkv
->cluster_time_limit
= 1000;
1432 if (mkv
->cluster_size_limit
< 0)
1433 mkv
->cluster_size_limit
= 32 * 1024;
1439 static int mkv_blockgroup_size(int pkt_size
)
1441 int size
= pkt_size
+ 4;
1442 size
+= ebml_num_size(size
);
1443 size
+= 2; // EBML ID for block and block duration
1444 size
+= 8; // max size of block duration
1445 size
+= ebml_num_size(size
);
1446 size
+= 1; // blockgroup EBML ID
1450 static int mkv_strip_wavpack(const uint8_t *src
, uint8_t **pdst
, int *size
)
1457 dst
= av_malloc(srclen
);
1459 return AVERROR(ENOMEM
);
1461 while (srclen
>= WV_HEADER_SIZE
) {
1464 ret
= ff_wv_parse_header(&header
, src
);
1467 src
+= WV_HEADER_SIZE
;
1468 srclen
-= WV_HEADER_SIZE
;
1470 if (srclen
< header
.blocksize
) {
1471 ret
= AVERROR_INVALIDDATA
;
1475 if (header
.initial
) {
1476 AV_WL32(dst
+ offset
, header
.samples
);
1479 AV_WL32(dst
+ offset
, header
.flags
);
1480 AV_WL32(dst
+ offset
+ 4, header
.crc
);
1483 if (!(header
.initial
&& header
.final
)) {
1484 AV_WL32(dst
+ offset
, header
.blocksize
);
1488 memcpy(dst
+ offset
, src
, header
.blocksize
);
1489 src
+= header
.blocksize
;
1490 srclen
-= header
.blocksize
;
1491 offset
+= header
.blocksize
;
1503 static void mkv_write_block(AVFormatContext
*s
, AVIOContext
*pb
,
1504 unsigned int blockid
, AVPacket
*pkt
, int flags
)
1506 MatroskaMuxContext
*mkv
= s
->priv_data
;
1507 AVCodecContext
*codec
= s
->streams
[pkt
->stream_index
]->codec
;
1508 uint8_t *data
= NULL
, *side_data
= NULL
;
1509 int offset
= 0, size
= pkt
->size
, side_data_size
= 0;
1510 int64_t ts
= mkv
->tracks
[pkt
->stream_index
].write_dts
? pkt
->dts
: pkt
->pts
;
1511 uint64_t additional_id
= 0;
1512 int64_t discard_padding
= 0;
1513 ebml_master block_group
, block_additions
, block_more
;
1515 av_log(s
, AV_LOG_DEBUG
, "Writing block at offset %" PRIu64
", size %d, "
1516 "pts %" PRId64
", dts %" PRId64
", duration %d, flags %d\n",
1517 avio_tell(pb
), pkt
->size
, pkt
->pts
, pkt
->dts
, pkt
->duration
, flags
);
1518 if (codec
->codec_id
== AV_CODEC_ID_H264
&& codec
->extradata_size
> 0 &&
1519 (AV_RB24(codec
->extradata
) == 1 || AV_RB32(codec
->extradata
) == 1))
1520 ff_avc_parse_nal_units_buf(pkt
->data
, &data
, &size
);
1521 else if (codec
->codec_id
== AV_CODEC_ID_HEVC
&& codec
->extradata_size
> 6 &&
1522 (AV_RB24(codec
->extradata
) == 1 || AV_RB32(codec
->extradata
) == 1))
1523 /* extradata is Annex B, assume the bitstream is too and convert it */
1524 ff_hevc_annexb2mp4_buf(pkt
->data
, &data
, &size
, 0, NULL
);
1525 else if (codec
->codec_id
== AV_CODEC_ID_WAVPACK
) {
1526 int ret
= mkv_strip_wavpack(pkt
->data
, &data
, &size
);
1528 av_log(s
, AV_LOG_ERROR
, "Error stripping a WavPack packet.\n");
1534 if (codec
->codec_id
== AV_CODEC_ID_PRORES
) {
1535 /* Matroska specification requires to remove the first QuickTime atom
1541 side_data
= av_packet_get_side_data(pkt
,
1542 AV_PKT_DATA_SKIP_SAMPLES
,
1545 if (side_data
&& side_data_size
>= 10) {
1546 discard_padding
= av_rescale_q(AV_RL32(side_data
+ 4),
1547 (AVRational
){1, codec
->sample_rate
},
1548 (AVRational
){1, 1000000000});
1551 side_data
= av_packet_get_side_data(pkt
,
1552 AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL
,
1555 additional_id
= AV_RB64(side_data
);
1557 side_data_size
-= 8;
1560 if ((side_data_size
&& additional_id
== 1) || discard_padding
) {
1561 block_group
= start_ebml_master(pb
, MATROSKA_ID_BLOCKGROUP
, 0);
1562 blockid
= MATROSKA_ID_BLOCK
;
1565 put_ebml_id(pb
, blockid
);
1566 put_ebml_num(pb
, size
+ 4, 0);
1567 // this assumes stream_index is less than 126
1568 avio_w8(pb
, 0x80 | (mkv
->is_dash
? mkv
->dash_track_number
: (pkt
->stream_index
+ 1)));
1569 avio_wb16(pb
, ts
- mkv
->cluster_pts
);
1571 avio_write(pb
, data
+ offset
, size
);
1572 if (data
!= pkt
->data
)
1575 if (discard_padding
) {
1576 put_ebml_sint(pb
, MATROSKA_ID_DISCARDPADDING
, discard_padding
);
1579 if (side_data_size
&& additional_id
== 1) {
1580 block_additions
= start_ebml_master(pb
, MATROSKA_ID_BLOCKADDITIONS
, 0);
1581 block_more
= start_ebml_master(pb
, MATROSKA_ID_BLOCKMORE
, 0);
1582 put_ebml_uint(pb
, MATROSKA_ID_BLOCKADDID
, 1);
1583 put_ebml_id(pb
, MATROSKA_ID_BLOCKADDITIONAL
);
1584 put_ebml_num(pb
, side_data_size
, 0);
1585 avio_write(pb
, side_data
, side_data_size
);
1586 end_ebml_master(pb
, block_more
);
1587 end_ebml_master(pb
, block_additions
);
1589 if ((side_data_size
&& additional_id
== 1) || discard_padding
) {
1590 end_ebml_master(pb
, block_group
);
1594 static int mkv_write_vtt_blocks(AVFormatContext
*s
, AVIOContext
*pb
, AVPacket
*pkt
)
1596 MatroskaMuxContext
*mkv
= s
->priv_data
;
1597 ebml_master blockgroup
;
1598 int id_size
, settings_size
, size
;
1599 uint8_t *id
, *settings
;
1600 int64_t ts
= mkv
->tracks
[pkt
->stream_index
].write_dts
? pkt
->dts
: pkt
->pts
;
1601 const int flags
= 0;
1604 id
= av_packet_get_side_data(pkt
, AV_PKT_DATA_WEBVTT_IDENTIFIER
,
1608 settings
= av_packet_get_side_data(pkt
, AV_PKT_DATA_WEBVTT_SETTINGS
,
1611 size
= id_size
+ 1 + settings_size
+ 1 + pkt
->size
;
1613 av_log(s
, AV_LOG_DEBUG
, "Writing block at offset %" PRIu64
", size %d, "
1614 "pts %" PRId64
", dts %" PRId64
", duration %d, flags %d\n",
1615 avio_tell(pb
), size
, pkt
->pts
, pkt
->dts
, pkt
->duration
, flags
);
1617 blockgroup
= start_ebml_master(pb
, MATROSKA_ID_BLOCKGROUP
, mkv_blockgroup_size(size
));
1619 put_ebml_id(pb
, MATROSKA_ID_BLOCK
);
1620 put_ebml_num(pb
, size
+ 4, 0);
1621 avio_w8(pb
, 0x80 | (pkt
->stream_index
+ 1)); // this assumes stream_index is less than 126
1622 avio_wb16(pb
, ts
- mkv
->cluster_pts
);
1624 avio_printf(pb
, "%.*s\n%.*s\n%.*s", id_size
, id
, settings_size
, settings
, pkt
->size
, pkt
->data
);
1626 put_ebml_uint(pb
, MATROSKA_ID_BLOCKDURATION
, pkt
->duration
);
1627 end_ebml_master(pb
, blockgroup
);
1629 return pkt
->duration
;
1632 static void mkv_flush_dynbuf(AVFormatContext
*s
)
1634 MatroskaMuxContext
*mkv
= s
->priv_data
;
1641 bufsize
= avio_close_dyn_buf(mkv
->dyn_bc
, &dyn_buf
);
1642 avio_write(s
->pb
, dyn_buf
, bufsize
);
1647 static void mkv_start_new_cluster(AVFormatContext
*s
, AVPacket
*pkt
)
1649 MatroskaMuxContext
*mkv
= s
->priv_data
;
1652 if (s
->pb
->seekable
) {
1658 av_log(s
, AV_LOG_DEBUG
,
1659 "Starting new cluster at offset %" PRIu64
" bytes, "
1660 "pts %" PRIu64
"dts %" PRIu64
"\n",
1661 avio_tell(pb
), pkt
->pts
, pkt
->dts
);
1662 end_ebml_master(pb
, mkv
->cluster
);
1663 mkv
->cluster_pos
= -1;
1665 mkv_flush_dynbuf(s
);
1669 static int mkv_write_packet_internal(AVFormatContext
*s
, AVPacket
*pkt
, int add_cue
)
1671 MatroskaMuxContext
*mkv
= s
->priv_data
;
1672 AVIOContext
*pb
= s
->pb
;
1673 AVCodecContext
*codec
= s
->streams
[pkt
->stream_index
]->codec
;
1674 int keyframe
= !!(pkt
->flags
& AV_PKT_FLAG_KEY
);
1675 int duration
= pkt
->duration
;
1677 int64_t ts
= mkv
->tracks
[pkt
->stream_index
].write_dts
? pkt
->dts
: pkt
->pts
;
1678 int64_t relative_packet_pos
;
1679 int dash_tracknum
= mkv
->is_dash
? mkv
->dash_track_number
: pkt
->stream_index
+ 1;
1681 if (ts
== AV_NOPTS_VALUE
) {
1682 av_log(s
, AV_LOG_ERROR
, "Can't write packet with unknown timestamp\n");
1683 return AVERROR(EINVAL
);
1685 ts
+= mkv
->tracks
[pkt
->stream_index
].ts_offset
;
1687 if (mkv
->cluster_pos
!= -1) {
1688 int64_t cluster_time
= ts
- mkv
->cluster_pts
+ mkv
->tracks
[pkt
->stream_index
].ts_offset
;
1689 if ((int16_t)cluster_time
!= cluster_time
) {
1690 av_log(s
, AV_LOG_WARNING
, "Starting new cluster due to timestamp\n");
1691 mkv_start_new_cluster(s
, pkt
);
1695 if (!s
->pb
->seekable
) {
1697 ret
= avio_open_dyn_buf(&mkv
->dyn_bc
);
1699 av_log(s
, AV_LOG_ERROR
, "Failed to open dynamic buffer\n");
1706 if (mkv
->cluster_pos
== -1) {
1707 mkv
->cluster_pos
= avio_tell(s
->pb
);
1708 mkv
->cluster
= start_ebml_master(pb
, MATROSKA_ID_CLUSTER
, 0);
1709 put_ebml_uint(pb
, MATROSKA_ID_CLUSTERTIMECODE
, FFMAX(0, ts
));
1710 mkv
->cluster_pts
= FFMAX(0, ts
);
1713 relative_packet_pos
= avio_tell(s
->pb
) - mkv
->cluster
.pos
;
1715 if (codec
->codec_type
!= AVMEDIA_TYPE_SUBTITLE
) {
1716 mkv_write_block(s
, pb
, MATROSKA_ID_SIMPLEBLOCK
, pkt
, keyframe
<< 7);
1717 if (codec
->codec_type
== AVMEDIA_TYPE_VIDEO
&& keyframe
|| add_cue
) {
1718 ret
= mkv_add_cuepoint(mkv
->cues
, pkt
->stream_index
, dash_tracknum
, ts
, mkv
->cluster_pos
, relative_packet_pos
, -1);
1719 if (ret
< 0) return ret
;
1722 if (codec
->codec_id
== AV_CODEC_ID_WEBVTT
) {
1723 duration
= mkv_write_vtt_blocks(s
, pb
, pkt
);
1725 ebml_master blockgroup
= start_ebml_master(pb
, MATROSKA_ID_BLOCKGROUP
,
1726 mkv_blockgroup_size(pkt
->size
));
1727 /* For backward compatibility, prefer convergence_duration. */
1728 if (pkt
->convergence_duration
> 0) {
1729 duration
= pkt
->convergence_duration
;
1731 mkv_write_block(s
, pb
, MATROSKA_ID_BLOCK
, pkt
, 0);
1732 put_ebml_uint(pb
, MATROSKA_ID_BLOCKDURATION
, duration
);
1733 end_ebml_master(pb
, blockgroup
);
1736 ret
= mkv_add_cuepoint(mkv
->cues
, pkt
->stream_index
, dash_tracknum
, ts
,
1737 mkv
->cluster_pos
, relative_packet_pos
, duration
);
1742 mkv
->duration
= FFMAX(mkv
->duration
, ts
+ duration
);
1746 static int mkv_write_packet(AVFormatContext
*s
, AVPacket
*pkt
)
1748 MatroskaMuxContext
*mkv
= s
->priv_data
;
1749 int codec_type
= s
->streams
[pkt
->stream_index
]->codec
->codec_type
;
1750 int keyframe
= !!(pkt
->flags
& AV_PKT_FLAG_KEY
);
1752 int64_t cluster_time
;
1754 int start_new_cluster
;
1756 if (mkv
->tracks
[pkt
->stream_index
].write_dts
)
1757 cluster_time
= pkt
->dts
- mkv
->cluster_pts
;
1759 cluster_time
= pkt
->pts
- mkv
->cluster_pts
;
1760 cluster_time
+= mkv
->tracks
[pkt
->stream_index
].ts_offset
;
1762 // start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or
1763 // after 4k and on a keyframe
1764 if (s
->pb
->seekable
) {
1765 cluster_size
= avio_tell(s
->pb
) - mkv
->cluster_pos
;
1767 cluster_size
= avio_tell(mkv
->dyn_bc
);
1770 if (mkv
->is_dash
&& codec_type
== AVMEDIA_TYPE_VIDEO
) {
1771 // WebM DASH specification states that the first block of every cluster
1772 // has to be a key frame. So for DASH video, we only create a cluster
1773 // on seeing key frames.
1774 start_new_cluster
= keyframe
;
1775 } else if (mkv
->is_dash
&& codec_type
== AVMEDIA_TYPE_AUDIO
&&
1776 (mkv
->cluster_pos
== -1 ||
1777 cluster_time
> mkv
->cluster_time_limit
)) {
1778 // For DASH audio, we create a Cluster based on cluster_time_limit
1779 start_new_cluster
= 1;
1780 } else if (!mkv
->is_dash
&&
1781 (cluster_size
> mkv
->cluster_size_limit
||
1782 cluster_time
> mkv
->cluster_time_limit
||
1783 (codec_type
== AVMEDIA_TYPE_VIDEO
&& keyframe
&&
1784 cluster_size
> 4 * 1024))) {
1785 start_new_cluster
= 1;
1787 start_new_cluster
= 0;
1790 if (mkv
->cluster_pos
!= -1 && start_new_cluster
) {
1791 mkv_start_new_cluster(s
, pkt
);
1794 // check if we have an audio packet cached
1795 if (mkv
->cur_audio_pkt
.size
> 0) {
1796 // for DASH audio, a CuePoint has to be added when there is a new cluster.
1797 ret
= mkv_write_packet_internal(s
, &mkv
->cur_audio_pkt
,
1798 mkv
->is_dash
? start_new_cluster
: 0);
1799 av_free_packet(&mkv
->cur_audio_pkt
);
1801 av_log(s
, AV_LOG_ERROR
,
1802 "Could not write cached audio packet ret:%d\n", ret
);
1807 // buffer an audio packet to ensure the packet containing the video
1808 // keyframe's timecode is contained in the same cluster for WebM
1809 if (codec_type
== AVMEDIA_TYPE_AUDIO
) {
1810 mkv
->cur_audio_pkt
= *pkt
;
1812 mkv
->cur_audio_pkt
.buf
= av_buffer_ref(pkt
->buf
);
1813 ret
= mkv
->cur_audio_pkt
.buf
? 0 : AVERROR(ENOMEM
);
1815 ret
= av_dup_packet(&mkv
->cur_audio_pkt
);
1816 if (mkv
->cur_audio_pkt
.side_data_elems
> 0) {
1817 ret
= av_copy_packet_side_data(&mkv
->cur_audio_pkt
, &mkv
->cur_audio_pkt
);
1820 ret
= mkv_write_packet_internal(s
, pkt
, 0);
1824 static int mkv_write_flush_packet(AVFormatContext
*s
, AVPacket
*pkt
)
1826 MatroskaMuxContext
*mkv
= s
->priv_data
;
1828 if (s
->pb
->seekable
)
1833 if (mkv
->cluster_pos
!= -1) {
1834 av_log(s
, AV_LOG_DEBUG
,
1835 "Flushing cluster at offset %" PRIu64
" bytes\n",
1837 end_ebml_master(pb
, mkv
->cluster
);
1838 mkv
->cluster_pos
= -1;
1840 mkv_flush_dynbuf(s
);
1845 return mkv_write_packet(s
, pkt
);
1848 static int mkv_write_trailer(AVFormatContext
*s
)
1850 MatroskaMuxContext
*mkv
= s
->priv_data
;
1851 AVIOContext
*pb
= s
->pb
;
1852 int64_t currentpos
, cuespos
;
1855 // check if we have an audio packet cached
1856 if (mkv
->cur_audio_pkt
.size
> 0) {
1857 ret
= mkv_write_packet_internal(s
, &mkv
->cur_audio_pkt
, 0);
1858 av_free_packet(&mkv
->cur_audio_pkt
);
1860 av_log(s
, AV_LOG_ERROR
,
1861 "Could not write cached audio packet ret:%d\n", ret
);
1867 end_ebml_master(mkv
->dyn_bc
, mkv
->cluster
);
1868 mkv_flush_dynbuf(s
);
1869 } else if (mkv
->cluster_pos
!= -1) {
1870 end_ebml_master(pb
, mkv
->cluster
);
1873 if (mkv
->mode
!= MODE_WEBM
) {
1874 ret
= mkv_write_chapters(s
);
1880 if (mkv
->cues
->num_entries
) {
1881 if (mkv
->reserve_cues_space
) {
1884 currentpos
= avio_tell(pb
);
1885 avio_seek(pb
, mkv
->cues_pos
, SEEK_SET
);
1887 cuespos
= mkv_write_cues(s
, mkv
->cues
, mkv
->tracks
, s
->nb_streams
);
1888 cues_end
= avio_tell(pb
);
1889 if (cues_end
> cuespos
+ mkv
->reserve_cues_space
) {
1890 av_log(s
, AV_LOG_ERROR
,
1891 "Insufficient space reserved for cues: %d "
1892 "(needed: %" PRId64
").\n",
1893 mkv
->reserve_cues_space
, cues_end
- cuespos
);
1894 return AVERROR(EINVAL
);
1897 if (cues_end
< cuespos
+ mkv
->reserve_cues_space
)
1898 put_ebml_void(pb
, mkv
->reserve_cues_space
-
1899 (cues_end
- cuespos
));
1901 avio_seek(pb
, currentpos
, SEEK_SET
);
1903 cuespos
= mkv_write_cues(s
, mkv
->cues
, mkv
->tracks
, s
->nb_streams
);
1906 ret
= mkv_add_seekhead_entry(mkv
->main_seekhead
, MATROSKA_ID_CUES
,
1912 mkv_write_seekhead(pb
, mkv
->main_seekhead
);
1914 // update the duration
1915 av_log(s
, AV_LOG_DEBUG
, "end duration = %" PRIu64
"\n", mkv
->duration
);
1916 currentpos
= avio_tell(pb
);
1917 avio_seek(pb
, mkv
->duration_offset
, SEEK_SET
);
1918 put_ebml_float(pb
, MATROSKA_ID_DURATION
, mkv
->duration
);
1920 avio_seek(pb
, currentpos
, SEEK_SET
);
1923 end_ebml_master(pb
, mkv
->segment
);
1924 av_freep(&mkv
->tracks
);
1925 av_freep(&mkv
->cues
->entries
);
1926 av_freep(&mkv
->cues
);
1931 static int mkv_query_codec(enum AVCodecID codec_id
, int std_compliance
)
1934 for (i
= 0; ff_mkv_codec_tags
[i
].id
!= AV_CODEC_ID_NONE
; i
++)
1935 if (ff_mkv_codec_tags
[i
].id
== codec_id
)
1938 if (std_compliance
< FF_COMPLIANCE_NORMAL
) {
1939 enum AVMediaType type
= avcodec_get_type(codec_id
);
1940 // mkv theoretically supports any video/audio through VFW/ACM
1941 if (type
== AVMEDIA_TYPE_VIDEO
|| type
== AVMEDIA_TYPE_AUDIO
)
1948 static const AVCodecTag additional_audio_tags
[] = {
1949 { AV_CODEC_ID_ALAC
, 0XFFFFFFFF },
1950 { AV_CODEC_ID_EAC3
, 0XFFFFFFFF },
1951 { AV_CODEC_ID_MLP
, 0xFFFFFFFF },
1952 { AV_CODEC_ID_OPUS
, 0xFFFFFFFF },
1953 { AV_CODEC_ID_PCM_S16BE
, 0xFFFFFFFF },
1954 { AV_CODEC_ID_PCM_S24BE
, 0xFFFFFFFF },
1955 { AV_CODEC_ID_PCM_S32BE
, 0xFFFFFFFF },
1956 { AV_CODEC_ID_QDM2
, 0xFFFFFFFF },
1957 { AV_CODEC_ID_RA_144
, 0xFFFFFFFF },
1958 { AV_CODEC_ID_RA_288
, 0xFFFFFFFF },
1959 { AV_CODEC_ID_COOK
, 0xFFFFFFFF },
1960 { AV_CODEC_ID_TRUEHD
, 0xFFFFFFFF },
1961 { AV_CODEC_ID_NONE
, 0xFFFFFFFF }
1964 static const AVCodecTag additional_video_tags
[] = {
1965 { AV_CODEC_ID_RV10
, 0xFFFFFFFF },
1966 { AV_CODEC_ID_RV20
, 0xFFFFFFFF },
1967 { AV_CODEC_ID_RV30
, 0xFFFFFFFF },
1968 { AV_CODEC_ID_RV40
, 0xFFFFFFFF },
1969 { AV_CODEC_ID_VP9
, 0xFFFFFFFF },
1970 { AV_CODEC_ID_NONE
, 0xFFFFFFFF }
1973 #define OFFSET(x) offsetof(MatroskaMuxContext, x)
1974 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM
1975 static const AVOption options
[] = {
1976 { "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
},
1977 { "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
},
1978 { "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
},
1979 { "dash", "Create a WebM file conforming to WebM DASH specification", OFFSET(is_dash
), AV_OPT_TYPE_INT
, { .i64
= 0 }, 0, 1, FLAGS
},
1980 { "dash_track_number", "Track number for the DASH stream", OFFSET(dash_track_number
), AV_OPT_TYPE_INT
, { .i64
= 1 }, 0, 127, FLAGS
},
1984 #if CONFIG_MATROSKA_MUXER
1985 static const AVClass matroska_class
= {
1986 .class_name
= "matroska muxer",
1987 .item_name
= av_default_item_name
,
1989 .version
= LIBAVUTIL_VERSION_INT
,
1992 AVOutputFormat ff_matroska_muxer
= {
1994 .long_name
= NULL_IF_CONFIG_SMALL("Matroska"),
1995 .mime_type
= "video/x-matroska",
1996 .extensions
= "mkv",
1997 .priv_data_size
= sizeof(MatroskaMuxContext
),
1998 .audio_codec
= CONFIG_LIBVORBIS_ENCODER
?
1999 AV_CODEC_ID_VORBIS
: AV_CODEC_ID_AC3
,
2000 .video_codec
= CONFIG_LIBX264_ENCODER
?
2001 AV_CODEC_ID_H264
: AV_CODEC_ID_MPEG4
,
2002 .write_header
= mkv_write_header
,
2003 .write_packet
= mkv_write_flush_packet
,
2004 .write_trailer
= mkv_write_trailer
,
2005 .flags
= AVFMT_GLOBALHEADER
| AVFMT_VARIABLE_FPS
|
2006 AVFMT_TS_NONSTRICT
| AVFMT_ALLOW_FLUSH
,
2007 .codec_tag
= (const AVCodecTag
* const []){
2008 ff_codec_bmp_tags
, ff_codec_wav_tags
,
2009 additional_audio_tags
, additional_video_tags
, 0
2011 .subtitle_codec
= AV_CODEC_ID_ASS
,
2012 .query_codec
= mkv_query_codec
,
2013 .priv_class
= &matroska_class
,
2017 #if CONFIG_WEBM_MUXER
2018 static const AVClass webm_class
= {
2019 .class_name
= "webm muxer",
2020 .item_name
= av_default_item_name
,
2022 .version
= LIBAVUTIL_VERSION_INT
,
2025 AVOutputFormat ff_webm_muxer
= {
2027 .long_name
= NULL_IF_CONFIG_SMALL("WebM"),
2028 .mime_type
= "video/webm",
2029 .extensions
= "webm",
2030 .priv_data_size
= sizeof(MatroskaMuxContext
),
2031 .audio_codec
= AV_CODEC_ID_VORBIS
,
2032 .video_codec
= AV_CODEC_ID_VP8
,
2033 .subtitle_codec
= AV_CODEC_ID_WEBVTT
,
2034 .write_header
= mkv_write_header
,
2035 .write_packet
= mkv_write_flush_packet
,
2036 .write_trailer
= mkv_write_trailer
,
2037 .flags
= AVFMT_GLOBALHEADER
| AVFMT_VARIABLE_FPS
|
2038 AVFMT_TS_NONSTRICT
| AVFMT_ALLOW_FLUSH
,
2039 .priv_class
= &webm_class
,
2043 #if CONFIG_MATROSKA_AUDIO_MUXER
2044 static const AVClass mka_class
= {
2045 .class_name
= "matroska audio muxer",
2046 .item_name
= av_default_item_name
,
2048 .version
= LIBAVUTIL_VERSION_INT
,
2050 AVOutputFormat ff_matroska_audio_muxer
= {
2052 .long_name
= NULL_IF_CONFIG_SMALL("Matroska Audio"),
2053 .mime_type
= "audio/x-matroska",
2054 .extensions
= "mka",
2055 .priv_data_size
= sizeof(MatroskaMuxContext
),
2056 .audio_codec
= CONFIG_LIBVORBIS_ENCODER
?
2057 AV_CODEC_ID_VORBIS
: AV_CODEC_ID_AC3
,
2058 .video_codec
= AV_CODEC_ID_NONE
,
2059 .write_header
= mkv_write_header
,
2060 .write_packet
= mkv_write_flush_packet
,
2061 .write_trailer
= mkv_write_trailer
,
2062 .flags
= AVFMT_GLOBALHEADER
| AVFMT_TS_NONSTRICT
|
2064 .codec_tag
= (const AVCodecTag
* const []){
2065 ff_codec_wav_tags
, additional_audio_tags
, 0
2067 .priv_class
= &mka_class
,