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 "libavutil/intreadwrite.h"
28 #include "libavutil/md5.h"
29 #include "libavcodec/xiph.h"
30 #include "libavcodec/mpeg4audio.h"
31 #include "libavcodec/flac.h"
33 typedef struct ebml_master
{
34 int64_t pos
; ///< absolute offset in the file where the master's elements start
35 int sizebytes
; ///< how many bytes were reserved for the size
38 typedef struct mkv_seekhead_entry
{
39 unsigned int elementid
;
43 typedef struct mkv_seekhead
{
45 int64_t segment_offset
; ///< the file offset to the beginning of the segment
46 int reserved_size
; ///< -1 if appending to file
48 mkv_seekhead_entry
*entries
;
55 int64_t cluster_pos
; ///< file offset of the cluster containing the block
59 int64_t segment_offset
;
60 mkv_cuepoint
*entries
;
64 typedef struct MatroskaMuxContext
{
66 int64_t segment_offset
;
69 int64_t cluster_pos
; ///< file offset of the current cluster
71 int64_t duration_offset
;
73 mkv_seekhead
*main_seekhead
;
74 mkv_seekhead
*cluster_seekhead
;
77 struct AVMD5
*md5_ctx
;
81 /** 2 bytes * 3 for EBML IDs, 3 1-byte EBML lengths, 8 bytes for 64 bit
82 * offset, 4 bytes for target EBML ID */
83 #define MAX_SEEKENTRY_SIZE 21
85 /** per-cuepoint-track - 3 1-byte EBML IDs, 3 1-byte EBML sizes, 2
87 #define MAX_CUETRACKPOS_SIZE 22
89 /** per-cuepoint - 2 1-byte EBML IDs, 2 1-byte EBML sizes, 8-byte uint max */
90 #define MAX_CUEPOINT_SIZE(num_tracks) 12 + MAX_CUETRACKPOS_SIZE*num_tracks
93 static int ebml_id_size(unsigned int id
)
95 return (av_log2(id
+1)-1)/7+1;
98 static void put_ebml_id(ByteIOContext
*pb
, unsigned int id
)
100 int i
= ebml_id_size(id
);
102 put_byte(pb
, id
>> (i
*8));
106 * Write an EBML size meaning "unknown size".
108 * @param bytes The number of bytes the size should occupy (maximum: 8).
110 static void put_ebml_size_unknown(ByteIOContext
*pb
, int bytes
)
113 put_byte(pb
, 0x1ff >> bytes
);
119 * Calculate how many bytes are needed to represent a given number in EBML.
121 static int ebml_num_size(uint64_t num
)
124 while ((num
+1) >> bytes
*7) bytes
++;
129 * Write a number in EBML variable length format.
131 * @param bytes The number of bytes that need to be used to write the number.
132 * If zero, any number of bytes can be used.
134 static void put_ebml_num(ByteIOContext
*pb
, uint64_t num
, int bytes
)
136 int i
, needed_bytes
= ebml_num_size(num
);
138 // sizes larger than this are currently undefined in EBML
139 assert(num
< (1ULL<<56)-1);
142 // don't care how many bytes are used, so use the min
143 bytes
= needed_bytes
;
144 // the bytes needed to write the given size would exceed the bytes
145 // that we need to use, so write unknown size. This shouldn't happen.
146 assert(bytes
>= needed_bytes
);
148 num
|= 1ULL << bytes
*7;
149 for (i
= bytes
- 1; i
>= 0; i
--)
150 put_byte(pb
, num
>> i
*8);
153 static void put_ebml_uint(ByteIOContext
*pb
, unsigned int elementid
, uint64_t val
)
157 while (tmp
>>=8) bytes
++;
159 put_ebml_id(pb
, elementid
);
160 put_ebml_num(pb
, bytes
, 0);
161 for (i
= bytes
- 1; i
>= 0; i
--)
162 put_byte(pb
, val
>> i
*8);
165 static void put_ebml_float(ByteIOContext
*pb
, unsigned int elementid
, double val
)
167 put_ebml_id(pb
, elementid
);
168 put_ebml_num(pb
, 8, 0);
169 put_be64(pb
, av_dbl2int(val
));
172 static void put_ebml_binary(ByteIOContext
*pb
, unsigned int elementid
,
173 const uint8_t *buf
, int size
)
175 put_ebml_id(pb
, elementid
);
176 put_ebml_num(pb
, size
, 0);
177 put_buffer(pb
, buf
, size
);
180 static void put_ebml_string(ByteIOContext
*pb
, unsigned int elementid
, const char *str
)
182 put_ebml_binary(pb
, elementid
, str
, strlen(str
));
186 * Writes a void element of a given size. Useful for reserving space in
187 * the file to be written to later.
189 * @param size The number of bytes to reserve, which must be at least 2.
191 static void put_ebml_void(ByteIOContext
*pb
, uint64_t size
)
193 int64_t currentpos
= url_ftell(pb
);
197 put_ebml_id(pb
, EBML_ID_VOID
);
198 // we need to subtract the length needed to store the size from the
199 // size we need to reserve so 2 cases, we use 8 bytes to store the
200 // size if possible, 1 byte otherwise
202 put_ebml_num(pb
, size
-1, 0);
204 put_ebml_num(pb
, size
-9, 8);
205 while(url_ftell(pb
) < currentpos
+ size
)
209 static ebml_master
start_ebml_master(ByteIOContext
*pb
, unsigned int elementid
, uint64_t expectedsize
)
211 int bytes
= expectedsize
? ebml_num_size(expectedsize
) : 8;
212 put_ebml_id(pb
, elementid
);
213 put_ebml_size_unknown(pb
, bytes
);
214 return (ebml_master
){ url_ftell(pb
), bytes
};
217 static void end_ebml_master(ByteIOContext
*pb
, ebml_master master
)
219 int64_t pos
= url_ftell(pb
);
221 // leave the unknown size for masters when streaming
222 if (url_is_streamed(pb
))
225 url_fseek(pb
, master
.pos
- master
.sizebytes
, SEEK_SET
);
226 put_ebml_num(pb
, pos
- master
.pos
, master
.sizebytes
);
227 url_fseek(pb
, pos
, SEEK_SET
);
230 static void put_xiph_size(ByteIOContext
*pb
, int size
)
233 for (i
= 0; i
< size
/ 255; i
++)
235 put_byte(pb
, size
% 255);
239 * Initialize a mkv_seekhead element to be ready to index level 1 Matroska
240 * elements. If a maximum number of elements is specified, enough space
241 * will be reserved at the current file location to write a seek head of
244 * @param segment_offset The absolute offset to the position in the file
245 * where the segment begins.
246 * @param numelements The maximum number of elements that will be indexed
247 * by this seek head, 0 if unlimited.
249 static mkv_seekhead
* mkv_start_seekhead(ByteIOContext
*pb
, int64_t segment_offset
, int numelements
)
251 mkv_seekhead
*new_seekhead
= av_mallocz(sizeof(mkv_seekhead
));
252 if (new_seekhead
== NULL
)
255 new_seekhead
->segment_offset
= segment_offset
;
257 if (numelements
> 0) {
258 new_seekhead
->filepos
= url_ftell(pb
);
259 // 21 bytes max for a seek entry, 10 bytes max for the SeekHead ID
260 // and size, and 3 bytes to guarantee that an EBML void element
261 // will fit afterwards
262 new_seekhead
->reserved_size
= numelements
* MAX_SEEKENTRY_SIZE
+ 13;
263 new_seekhead
->max_entries
= numelements
;
264 put_ebml_void(pb
, new_seekhead
->reserved_size
);
269 static int mkv_add_seekhead_entry(mkv_seekhead
*seekhead
, unsigned int elementid
, uint64_t filepos
)
271 mkv_seekhead_entry
*entries
= seekhead
->entries
;
273 // don't store more elements than we reserved space for
274 if (seekhead
->max_entries
> 0 && seekhead
->max_entries
<= seekhead
->num_entries
)
277 entries
= av_realloc(entries
, (seekhead
->num_entries
+ 1) * sizeof(mkv_seekhead_entry
));
279 return AVERROR(ENOMEM
);
281 entries
[seekhead
->num_entries
].elementid
= elementid
;
282 entries
[seekhead
->num_entries
++].segmentpos
= filepos
- seekhead
->segment_offset
;
284 seekhead
->entries
= entries
;
289 * Write the seek head to the file and free it. If a maximum number of
290 * elements was specified to mkv_start_seekhead(), the seek head will
291 * be written at the location reserved for it. Otherwise, it is written
292 * at the current location in the file.
294 * @return The file offset where the seekhead was written.
296 static int64_t mkv_write_seekhead(ByteIOContext
*pb
, mkv_seekhead
*seekhead
)
298 ebml_master metaseek
, seekentry
;
302 currentpos
= url_ftell(pb
);
304 if (seekhead
->reserved_size
> 0)
305 url_fseek(pb
, seekhead
->filepos
, SEEK_SET
);
307 metaseek
= start_ebml_master(pb
, MATROSKA_ID_SEEKHEAD
, seekhead
->reserved_size
);
308 for (i
= 0; i
< seekhead
->num_entries
; i
++) {
309 mkv_seekhead_entry
*entry
= &seekhead
->entries
[i
];
311 seekentry
= start_ebml_master(pb
, MATROSKA_ID_SEEKENTRY
, MAX_SEEKENTRY_SIZE
);
313 put_ebml_id(pb
, MATROSKA_ID_SEEKID
);
314 put_ebml_num(pb
, ebml_id_size(entry
->elementid
), 0);
315 put_ebml_id(pb
, entry
->elementid
);
317 put_ebml_uint(pb
, MATROSKA_ID_SEEKPOSITION
, entry
->segmentpos
);
318 end_ebml_master(pb
, seekentry
);
320 end_ebml_master(pb
, metaseek
);
322 if (seekhead
->reserved_size
> 0) {
323 uint64_t remaining
= seekhead
->filepos
+ seekhead
->reserved_size
- url_ftell(pb
);
324 put_ebml_void(pb
, remaining
);
325 url_fseek(pb
, currentpos
, SEEK_SET
);
327 currentpos
= seekhead
->filepos
;
329 av_free(seekhead
->entries
);
335 static mkv_cues
* mkv_start_cues(int64_t segment_offset
)
337 mkv_cues
*cues
= av_mallocz(sizeof(mkv_cues
));
341 cues
->segment_offset
= segment_offset
;
345 static int mkv_add_cuepoint(mkv_cues
*cues
, AVPacket
*pkt
, int64_t cluster_pos
)
347 mkv_cuepoint
*entries
= cues
->entries
;
349 entries
= av_realloc(entries
, (cues
->num_entries
+ 1) * sizeof(mkv_cuepoint
));
351 return AVERROR(ENOMEM
);
353 entries
[cues
->num_entries
].pts
= pkt
->pts
;
354 entries
[cues
->num_entries
].tracknum
= pkt
->stream_index
+ 1;
355 entries
[cues
->num_entries
++].cluster_pos
= cluster_pos
- cues
->segment_offset
;
357 cues
->entries
= entries
;
361 static int64_t mkv_write_cues(ByteIOContext
*pb
, mkv_cues
*cues
, int num_tracks
)
363 ebml_master cues_element
;
367 currentpos
= url_ftell(pb
);
368 cues_element
= start_ebml_master(pb
, MATROSKA_ID_CUES
, 0);
370 for (i
= 0; i
< cues
->num_entries
; i
++) {
371 ebml_master cuepoint
, track_positions
;
372 mkv_cuepoint
*entry
= &cues
->entries
[i
];
373 uint64_t pts
= entry
->pts
;
375 cuepoint
= start_ebml_master(pb
, MATROSKA_ID_POINTENTRY
, MAX_CUEPOINT_SIZE(num_tracks
));
376 put_ebml_uint(pb
, MATROSKA_ID_CUETIME
, pts
);
378 // put all the entries from different tracks that have the exact same
379 // timestamp into the same CuePoint
380 for (j
= 0; j
< cues
->num_entries
- i
&& entry
[j
].pts
== pts
; j
++) {
381 track_positions
= start_ebml_master(pb
, MATROSKA_ID_CUETRACKPOSITION
, MAX_CUETRACKPOS_SIZE
);
382 put_ebml_uint(pb
, MATROSKA_ID_CUETRACK
, entry
[j
].tracknum
);
383 put_ebml_uint(pb
, MATROSKA_ID_CUECLUSTERPOSITION
, entry
[j
].cluster_pos
);
384 end_ebml_master(pb
, track_positions
);
387 end_ebml_master(pb
, cuepoint
);
389 end_ebml_master(pb
, cues_element
);
391 av_free(cues
->entries
);
396 static int put_xiph_codecpriv(AVFormatContext
*s
, ByteIOContext
*pb
, AVCodecContext
*codec
)
398 uint8_t *header_start
[3];
400 int first_header_size
;
403 if (codec
->codec_id
== CODEC_ID_VORBIS
)
404 first_header_size
= 30;
406 first_header_size
= 42;
408 if (ff_split_xiph_headers(codec
->extradata
, codec
->extradata_size
,
409 first_header_size
, header_start
, header_len
) < 0) {
410 av_log(s
, AV_LOG_ERROR
, "Extradata corrupt.\n");
414 put_byte(pb
, 2); // number packets - 1
415 for (j
= 0; j
< 2; j
++) {
416 put_xiph_size(pb
, header_len
[j
]);
418 for (j
= 0; j
< 3; j
++)
419 put_buffer(pb
, header_start
[j
], header_len
[j
]);
424 static int put_flac_codecpriv(AVFormatContext
*s
, ByteIOContext
*pb
, AVCodecContext
*codec
)
427 enum FLACExtradataFormat format
;
429 if (!ff_flac_is_extradata_valid(codec
, &format
, &streaminfo
)) {
430 av_log(s
, AV_LOG_ERROR
, "Invalid FLAC extradata\n");
433 if (format
== FLAC_EXTRADATA_FORMAT_STREAMINFO
) {
434 // only the streaminfo packet
435 put_buffer(pb
, "fLaC", 4);
437 put_be24(pb
, FLAC_STREAMINFO_SIZE
);
439 put_buffer(pb
, codec
->extradata
, codec
->extradata_size
);
443 static void get_aac_sample_rates(AVFormatContext
*s
, AVCodecContext
*codec
, int *sample_rate
, int *output_sample_rate
)
447 if (codec
->extradata_size
< 2) {
448 av_log(s
, AV_LOG_WARNING
, "No AAC extradata, unable to determine samplerate.\n");
452 sri
= ((codec
->extradata
[0] << 1) & 0xE) | (codec
->extradata
[1] >> 7);
454 av_log(s
, AV_LOG_WARNING
, "AAC samplerate index out of bounds\n");
457 *sample_rate
= ff_mpeg4audio_sample_rates
[sri
];
459 // if sbr, get output sample rate as well
460 if (codec
->extradata_size
== 5) {
461 sri
= (codec
->extradata
[4] >> 3) & 0xF;
463 av_log(s
, AV_LOG_WARNING
, "AAC output samplerate index out of bounds\n");
466 *output_sample_rate
= ff_mpeg4audio_sample_rates
[sri
];
470 static int mkv_write_codecprivate(AVFormatContext
*s
, ByteIOContext
*pb
, AVCodecContext
*codec
, int native_id
, int qt_id
)
472 ByteIOContext
*dyn_cp
;
474 int ret
, codecpriv_size
;
476 ret
= url_open_dyn_buf(&dyn_cp
);
481 if (codec
->codec_id
== CODEC_ID_VORBIS
|| codec
->codec_id
== CODEC_ID_THEORA
)
482 ret
= put_xiph_codecpriv(s
, dyn_cp
, codec
);
483 else if (codec
->codec_id
== CODEC_ID_FLAC
)
484 ret
= put_flac_codecpriv(s
, dyn_cp
, codec
);
485 else if (codec
->codec_id
== CODEC_ID_H264
)
486 ret
= ff_isom_write_avcc(dyn_cp
, codec
->extradata
, codec
->extradata_size
);
487 else if (codec
->extradata_size
)
488 put_buffer(dyn_cp
, codec
->extradata
, codec
->extradata_size
);
489 } else if (codec
->codec_type
== CODEC_TYPE_VIDEO
) {
491 if (!codec
->codec_tag
)
492 codec
->codec_tag
= codec_get_tag(codec_movvideo_tags
, codec
->codec_id
);
493 if (codec
->extradata_size
)
494 put_buffer(dyn_cp
, codec
->extradata
, codec
->extradata_size
);
496 if (!codec
->codec_tag
)
497 codec
->codec_tag
= codec_get_tag(codec_bmp_tags
, codec
->codec_id
);
498 if (!codec
->codec_tag
) {
499 av_log(s
, AV_LOG_ERROR
, "No bmp codec ID found.");
503 put_bmp_header(dyn_cp
, codec
, codec_bmp_tags
, 0);
506 } else if (codec
->codec_type
== CODEC_TYPE_AUDIO
) {
507 if (!codec
->codec_tag
)
508 codec
->codec_tag
= codec_get_tag(codec_wav_tags
, codec
->codec_id
);
509 if (!codec
->codec_tag
) {
510 av_log(s
, AV_LOG_ERROR
, "No wav codec ID found.");
514 put_wav_header(dyn_cp
, codec
);
517 codecpriv_size
= url_close_dyn_buf(dyn_cp
, &codecpriv
);
519 put_ebml_binary(pb
, MATROSKA_ID_CODECPRIVATE
, codecpriv
, codecpriv_size
);
524 static int mkv_write_tracks(AVFormatContext
*s
)
526 MatroskaMuxContext
*mkv
= s
->priv_data
;
527 ByteIOContext
*pb
= s
->pb
;
531 ret
= mkv_add_seekhead_entry(mkv
->main_seekhead
, MATROSKA_ID_TRACKS
, url_ftell(pb
));
532 if (ret
< 0) return ret
;
534 tracks
= start_ebml_master(pb
, MATROSKA_ID_TRACKS
, 0);
535 for (i
= 0; i
< s
->nb_streams
; i
++) {
536 AVStream
*st
= s
->streams
[i
];
537 AVCodecContext
*codec
= st
->codec
;
538 ebml_master subinfo
, track
;
541 int bit_depth
= av_get_bits_per_sample(codec
->codec_id
);
542 int sample_rate
= codec
->sample_rate
;
543 int output_sample_rate
= 0;
547 bit_depth
= av_get_bits_per_sample_format(codec
->sample_fmt
);
549 if (codec
->codec_id
== CODEC_ID_AAC
)
550 get_aac_sample_rates(s
, codec
, &sample_rate
, &output_sample_rate
);
552 track
= start_ebml_master(pb
, MATROSKA_ID_TRACKENTRY
, 0);
553 put_ebml_uint (pb
, MATROSKA_ID_TRACKNUMBER
, i
+ 1);
554 put_ebml_uint (pb
, MATROSKA_ID_TRACKUID
, i
+ 1);
555 put_ebml_uint (pb
, MATROSKA_ID_TRACKFLAGLACING
, 0); // no lacing (yet)
557 if ((tag
= av_metadata_get(st
->metadata
, "description", NULL
, 0)))
558 put_ebml_string(pb
, MATROSKA_ID_TRACKNAME
, tag
->value
);
559 tag
= av_metadata_get(st
->metadata
, "language", NULL
, 0);
560 put_ebml_string(pb
, MATROSKA_ID_TRACKLANGUAGE
, tag
? tag
->value
:"und");
563 put_ebml_uint(pb
, MATROSKA_ID_TRACKFLAGDEFAULT
, !!(st
->disposition
& AV_DISPOSITION_DEFAULT
));
565 // look for a codec ID string specific to mkv to use,
566 // if none are found, use AVI codes
567 for (j
= 0; ff_mkv_codec_tags
[j
].id
!= CODEC_ID_NONE
; j
++) {
568 if (ff_mkv_codec_tags
[j
].id
== codec
->codec_id
) {
569 put_ebml_string(pb
, MATROSKA_ID_CODECID
, ff_mkv_codec_tags
[j
].str
);
575 switch (codec
->codec_type
) {
576 case CODEC_TYPE_VIDEO
:
577 put_ebml_uint(pb
, MATROSKA_ID_TRACKTYPE
, MATROSKA_TRACK_TYPE_VIDEO
);
580 codec_get_tag(codec_movvideo_tags
, codec
->codec_id
) &&
581 (!codec_get_tag(codec_bmp_tags
, codec
->codec_id
)
582 || codec
->codec_id
== CODEC_ID_SVQ1
583 || codec
->codec_id
== CODEC_ID_SVQ3
584 || codec
->codec_id
== CODEC_ID_CINEPAK
))
588 put_ebml_string(pb
, MATROSKA_ID_CODECID
, "V_QUICKTIME");
590 // if there is no mkv-specific codec ID, use VFW mode
591 put_ebml_string(pb
, MATROSKA_ID_CODECID
, "V_MS/VFW/FOURCC");
593 subinfo
= start_ebml_master(pb
, MATROSKA_ID_TRACKVIDEO
, 0);
594 // XXX: interlace flag?
595 put_ebml_uint (pb
, MATROSKA_ID_VIDEOPIXELWIDTH
, codec
->width
);
596 put_ebml_uint (pb
, MATROSKA_ID_VIDEOPIXELHEIGHT
, codec
->height
);
597 if (st
->sample_aspect_ratio
.num
) {
598 int d_width
= codec
->width
*av_q2d(st
->sample_aspect_ratio
);
599 put_ebml_uint(pb
, MATROSKA_ID_VIDEODISPLAYWIDTH
, d_width
);
600 put_ebml_uint(pb
, MATROSKA_ID_VIDEODISPLAYHEIGHT
, codec
->height
);
602 end_ebml_master(pb
, subinfo
);
605 case CODEC_TYPE_AUDIO
:
606 put_ebml_uint(pb
, MATROSKA_ID_TRACKTYPE
, MATROSKA_TRACK_TYPE_AUDIO
);
609 // no mkv-specific ID, use ACM mode
610 put_ebml_string(pb
, MATROSKA_ID_CODECID
, "A_MS/ACM");
612 subinfo
= start_ebml_master(pb
, MATROSKA_ID_TRACKAUDIO
, 0);
613 put_ebml_uint (pb
, MATROSKA_ID_AUDIOCHANNELS
, codec
->channels
);
614 put_ebml_float (pb
, MATROSKA_ID_AUDIOSAMPLINGFREQ
, sample_rate
);
615 if (output_sample_rate
)
616 put_ebml_float(pb
, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ
, output_sample_rate
);
618 put_ebml_uint(pb
, MATROSKA_ID_AUDIOBITDEPTH
, bit_depth
);
619 end_ebml_master(pb
, subinfo
);
622 case CODEC_TYPE_SUBTITLE
:
623 put_ebml_uint(pb
, MATROSKA_ID_TRACKTYPE
, MATROSKA_TRACK_TYPE_SUBTITLE
);
626 av_log(s
, AV_LOG_ERROR
, "Only audio, video, and subtitles are supported for Matroska.");
629 ret
= mkv_write_codecprivate(s
, pb
, codec
, native_id
, qt_id
);
630 if (ret
< 0) return ret
;
632 end_ebml_master(pb
, track
);
634 // ms precision is the de-facto standard timescale for mkv files
635 av_set_pts_info(st
, 64, 1, 1000);
637 end_ebml_master(pb
, tracks
);
641 static int mkv_write_header(AVFormatContext
*s
)
643 MatroskaMuxContext
*mkv
= s
->priv_data
;
644 ByteIOContext
*pb
= s
->pb
;
645 ebml_master ebml_header
, segment_info
;
649 mkv
->md5_ctx
= av_mallocz(av_md5_size
);
650 av_md5_init(mkv
->md5_ctx
);
652 ebml_header
= start_ebml_master(pb
, EBML_ID_HEADER
, 0);
653 put_ebml_uint (pb
, EBML_ID_EBMLVERSION
, 1);
654 put_ebml_uint (pb
, EBML_ID_EBMLREADVERSION
, 1);
655 put_ebml_uint (pb
, EBML_ID_EBMLMAXIDLENGTH
, 4);
656 put_ebml_uint (pb
, EBML_ID_EBMLMAXSIZELENGTH
, 8);
657 put_ebml_string (pb
, EBML_ID_DOCTYPE
, "matroska");
658 put_ebml_uint (pb
, EBML_ID_DOCTYPEVERSION
, 2);
659 put_ebml_uint (pb
, EBML_ID_DOCTYPEREADVERSION
, 2);
660 end_ebml_master(pb
, ebml_header
);
662 mkv
->segment
= start_ebml_master(pb
, MATROSKA_ID_SEGMENT
, 0);
663 mkv
->segment_offset
= url_ftell(pb
);
665 // we write 2 seek heads - one at the end of the file to point to each
666 // cluster, and one at the beginning to point to all other level one
667 // elements (including the seek head at the end of the file), which
668 // isn't more than 10 elements if we only write one of each other
669 // currently defined level 1 element
670 mkv
->main_seekhead
= mkv_start_seekhead(pb
, mkv
->segment_offset
, 10);
671 mkv
->cluster_seekhead
= mkv_start_seekhead(pb
, mkv
->segment_offset
, 0);
672 if (mkv
->main_seekhead
== NULL
|| mkv
->cluster_seekhead
== NULL
)
673 return AVERROR(ENOMEM
);
675 ret
= mkv_add_seekhead_entry(mkv
->main_seekhead
, MATROSKA_ID_INFO
, url_ftell(pb
));
676 if (ret
< 0) return ret
;
678 segment_info
= start_ebml_master(pb
, MATROSKA_ID_INFO
, 0);
679 put_ebml_uint(pb
, MATROSKA_ID_TIMECODESCALE
, 1000000);
680 if ((tag
= av_metadata_get(s
->metadata
, "title", NULL
, 0)))
681 put_ebml_string(pb
, MATROSKA_ID_TITLE
, tag
->value
);
682 if (!(s
->streams
[0]->codec
->flags
& CODEC_FLAG_BITEXACT
)) {
683 put_ebml_string(pb
, MATROSKA_ID_MUXINGAPP
, LIBAVFORMAT_IDENT
);
684 put_ebml_string(pb
, MATROSKA_ID_WRITINGAPP
, LIBAVFORMAT_IDENT
);
686 // reserve space to write the segment UID later
687 mkv
->segment_uid
= url_ftell(pb
);
688 put_ebml_void(pb
, 19);
691 // reserve space for the duration
693 mkv
->duration_offset
= url_ftell(pb
);
694 put_ebml_void(pb
, 11); // assumes double-precision float to be written
695 end_ebml_master(pb
, segment_info
);
697 ret
= mkv_write_tracks(s
);
698 if (ret
< 0) return ret
;
700 ret
= mkv_add_seekhead_entry(mkv
->cluster_seekhead
, MATROSKA_ID_CLUSTER
, url_ftell(pb
));
701 if (ret
< 0) return ret
;
703 mkv
->cluster_pos
= url_ftell(pb
);
704 mkv
->cluster
= start_ebml_master(pb
, MATROSKA_ID_CLUSTER
, 0);
705 put_ebml_uint(pb
, MATROSKA_ID_CLUSTERTIMECODE
, 0);
706 mkv
->cluster_pts
= 0;
708 mkv
->cues
= mkv_start_cues(mkv
->segment_offset
);
709 if (mkv
->cues
== NULL
)
710 return AVERROR(ENOMEM
);
712 put_flush_packet(pb
);
716 static int mkv_blockgroup_size(int pkt_size
)
718 int size
= pkt_size
+ 4;
719 size
+= ebml_num_size(size
);
720 size
+= 2; // EBML ID for block and block duration
721 size
+= 8; // max size of block duration
722 size
+= ebml_num_size(size
);
723 size
+= 1; // blockgroup EBML ID
727 static int ass_get_duration(const uint8_t *p
)
729 int sh
, sm
, ss
, sc
, eh
, em
, es
, ec
;
732 if (sscanf(p
, "%*[^,],%d:%d:%d%*c%d,%d:%d:%d%*c%d",
733 &sh
, &sm
, &ss
, &sc
, &eh
, &em
, &es
, &ec
) != 8)
735 start
= 3600000*sh
+ 60000*sm
+ 1000*ss
+ 10*sc
;
736 end
= 3600000*eh
+ 60000*em
+ 1000*es
+ 10*ec
;
740 static int mkv_write_ass_blocks(AVFormatContext
*s
, AVPacket
*pkt
)
742 MatroskaMuxContext
*mkv
= s
->priv_data
;
743 ByteIOContext
*pb
= s
->pb
;
744 int i
, layer
= 0, max_duration
= 0, size
, line_size
, data_size
= pkt
->size
;
745 uint8_t *start
, *end
, *data
= pkt
->data
;
746 ebml_master blockgroup
;
750 int duration
= ass_get_duration(data
);
751 max_duration
= FFMAX(duration
, max_duration
);
752 end
= memchr(data
, '\n', data_size
);
753 size
= line_size
= end
? end
-data
+1 : data_size
;
754 size
-= end
? (end
[-1]=='\r')+1 : 0;
756 for (i
=0; i
<3; i
++, start
++)
757 if (!(start
= memchr(start
, ',', size
-(start
-data
))))
759 size
-= start
- data
;
760 sscanf(data
, "Dialogue: %d,", &layer
);
761 i
= snprintf(buffer
, sizeof(buffer
), "%"PRId64
",%d,",
762 s
->streams
[pkt
->stream_index
]->nb_frames
++, layer
);
763 size
= FFMIN(i
+size
, sizeof(buffer
));
764 memcpy(buffer
+i
, start
, size
-i
);
766 av_log(s
, AV_LOG_DEBUG
, "Writing block at offset %" PRIu64
", size %d, "
767 "pts %" PRId64
", duration %d\n",
768 url_ftell(pb
), size
, pkt
->pts
, duration
);
769 blockgroup
= start_ebml_master(pb
, MATROSKA_ID_BLOCKGROUP
, mkv_blockgroup_size(size
));
770 put_ebml_id(pb
, MATROSKA_ID_BLOCK
);
771 put_ebml_num(pb
, size
+4, 0);
772 put_byte(pb
, 0x80 | (pkt
->stream_index
+ 1)); // this assumes stream_index is less than 126
773 put_be16(pb
, pkt
->pts
- mkv
->cluster_pts
);
775 put_buffer(pb
, buffer
, size
);
776 put_ebml_uint(pb
, MATROSKA_ID_BLOCKDURATION
, duration
);
777 end_ebml_master(pb
, blockgroup
);
780 data_size
-= line_size
;
786 static void mkv_write_block(AVFormatContext
*s
, unsigned int blockid
, AVPacket
*pkt
, int flags
)
788 MatroskaMuxContext
*mkv
= s
->priv_data
;
789 ByteIOContext
*pb
= s
->pb
;
790 AVCodecContext
*codec
= s
->streams
[pkt
->stream_index
]->codec
;
791 uint8_t *data
= NULL
;
792 int size
= pkt
->size
;
794 av_log(s
, AV_LOG_DEBUG
, "Writing block at offset %" PRIu64
", size %d, "
795 "pts %" PRId64
", dts %" PRId64
", duration %d, flags %d\n",
796 url_ftell(pb
), pkt
->size
, pkt
->pts
, pkt
->dts
, pkt
->duration
, flags
);
797 if (codec
->codec_id
== CODEC_ID_H264
&& codec
->extradata_size
> 0 &&
798 (AV_RB24(codec
->extradata
) == 1 || AV_RB32(codec
->extradata
) == 1))
799 ff_avc_parse_nal_units_buf(pkt
->data
, &data
, &size
);
802 put_ebml_id(pb
, blockid
);
803 put_ebml_num(pb
, size
+4, 0);
804 put_byte(pb
, 0x80 | (pkt
->stream_index
+ 1)); // this assumes stream_index is less than 126
805 put_be16(pb
, pkt
->pts
- mkv
->cluster_pts
);
807 put_buffer(pb
, data
, size
);
808 if (data
!= pkt
->data
)
812 static int mkv_write_packet(AVFormatContext
*s
, AVPacket
*pkt
)
814 MatroskaMuxContext
*mkv
= s
->priv_data
;
815 ByteIOContext
*pb
= s
->pb
;
816 AVCodecContext
*codec
= s
->streams
[pkt
->stream_index
]->codec
;
817 int keyframe
= !!(pkt
->flags
& PKT_FLAG_KEY
);
818 int duration
= pkt
->duration
;
821 // start a new cluster every 5 MB or 5 sec
822 if (url_ftell(pb
) > mkv
->cluster_pos
+ 5*1024*1024 || pkt
->pts
> mkv
->cluster_pts
+ 5000) {
823 av_log(s
, AV_LOG_DEBUG
, "Starting new cluster at offset %" PRIu64
824 " bytes, pts %" PRIu64
"\n", url_ftell(pb
), pkt
->pts
);
825 end_ebml_master(pb
, mkv
->cluster
);
827 ret
= mkv_add_seekhead_entry(mkv
->cluster_seekhead
, MATROSKA_ID_CLUSTER
, url_ftell(pb
));
828 if (ret
< 0) return ret
;
830 mkv
->cluster_pos
= url_ftell(pb
);
831 mkv
->cluster
= start_ebml_master(pb
, MATROSKA_ID_CLUSTER
, 0);
832 put_ebml_uint(pb
, MATROSKA_ID_CLUSTERTIMECODE
, pkt
->pts
);
833 mkv
->cluster_pts
= pkt
->pts
;
834 av_md5_update(mkv
->md5_ctx
, pkt
->data
, FFMIN(200, pkt
->size
));
837 if (codec
->codec_type
!= CODEC_TYPE_SUBTITLE
) {
838 mkv_write_block(s
, MATROSKA_ID_SIMPLEBLOCK
, pkt
, keyframe
<< 7);
839 } else if (codec
->codec_id
== CODEC_ID_SSA
) {
840 duration
= mkv_write_ass_blocks(s
, pkt
);
842 ebml_master blockgroup
= start_ebml_master(pb
, MATROSKA_ID_BLOCKGROUP
, mkv_blockgroup_size(pkt
->size
));
843 duration
= pkt
->convergence_duration
;
844 mkv_write_block(s
, MATROSKA_ID_BLOCK
, pkt
, 0);
845 put_ebml_uint(pb
, MATROSKA_ID_BLOCKDURATION
, duration
);
846 end_ebml_master(pb
, blockgroup
);
849 if (codec
->codec_type
== CODEC_TYPE_VIDEO
&& keyframe
) {
850 ret
= mkv_add_cuepoint(mkv
->cues
, pkt
, mkv
->cluster_pos
);
851 if (ret
< 0) return ret
;
854 mkv
->duration
= FFMAX(mkv
->duration
, pkt
->pts
+ duration
);
858 static int mkv_write_trailer(AVFormatContext
*s
)
860 MatroskaMuxContext
*mkv
= s
->priv_data
;
861 ByteIOContext
*pb
= s
->pb
;
862 int64_t currentpos
, second_seekhead
, cuespos
;
865 end_ebml_master(pb
, mkv
->cluster
);
867 if (!url_is_streamed(pb
)) {
868 cuespos
= mkv_write_cues(pb
, mkv
->cues
, s
->nb_streams
);
869 second_seekhead
= mkv_write_seekhead(pb
, mkv
->cluster_seekhead
);
871 ret
= mkv_add_seekhead_entry(mkv
->main_seekhead
, MATROSKA_ID_CUES
, cuespos
);
872 if (ret
< 0) return ret
;
873 ret
= mkv_add_seekhead_entry(mkv
->main_seekhead
, MATROSKA_ID_SEEKHEAD
, second_seekhead
);
874 if (ret
< 0) return ret
;
875 mkv_write_seekhead(pb
, mkv
->main_seekhead
);
877 // update the duration
878 av_log(s
, AV_LOG_DEBUG
, "end duration = %" PRIu64
"\n", mkv
->duration
);
879 currentpos
= url_ftell(pb
);
880 url_fseek(pb
, mkv
->duration_offset
, SEEK_SET
);
881 put_ebml_float(pb
, MATROSKA_ID_DURATION
, mkv
->duration
);
883 // write the md5sum of some frames as the segment UID
884 if (!(s
->streams
[0]->codec
->flags
& CODEC_FLAG_BITEXACT
)) {
885 uint8_t segment_uid
[16];
886 av_md5_final(mkv
->md5_ctx
, segment_uid
);
887 url_fseek(pb
, mkv
->segment_uid
, SEEK_SET
);
888 put_ebml_binary(pb
, MATROSKA_ID_SEGMENTUID
, segment_uid
, 16);
890 url_fseek(pb
, currentpos
, SEEK_SET
);
893 end_ebml_master(pb
, mkv
->segment
);
894 av_free(mkv
->md5_ctx
);
895 put_flush_packet(pb
);
899 AVOutputFormat matroska_muxer
= {
901 NULL_IF_CONFIG_SMALL("Matroska file format"),
904 sizeof(MatroskaMuxContext
),
910 .flags
= AVFMT_GLOBALHEADER
| AVFMT_VARIABLE_FPS
,
911 .codec_tag
= (const AVCodecTag
* const []){codec_bmp_tags
, codec_wav_tags
, 0},
912 .subtitle_codec
= CODEC_ID_TEXT
,
915 AVOutputFormat matroska_audio_muxer
= {
917 NULL_IF_CONFIG_SMALL("Matroska file format"),
920 sizeof(MatroskaMuxContext
),
926 .flags
= AVFMT_GLOBALHEADER
,
927 .codec_tag
= (const AVCodecTag
* const []){codec_wav_tags
, 0},