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/md5.h"
28 #include "libavcodec/xiph.h"
29 #include "libavcodec/mpeg4audio.h"
31 typedef struct ebml_master
{
32 int64_t pos
; ///< absolute offset in the file where the master's elements start
33 int sizebytes
; ///< how many bytes were reserved for the size
36 typedef struct mkv_seekhead_entry
{
37 unsigned int elementid
;
41 typedef struct mkv_seekhead
{
43 int64_t segment_offset
; ///< the file offset to the beginning of the segment
44 int reserved_size
; ///< -1 if appending to file
46 mkv_seekhead_entry
*entries
;
53 int64_t cluster_pos
; ///< file offset of the cluster containing the block
57 int64_t segment_offset
;
58 mkv_cuepoint
*entries
;
62 typedef struct MatroskaMuxContext
{
64 int64_t segment_offset
;
67 int64_t cluster_pos
; ///< file offset of the current cluster
69 int64_t duration_offset
;
71 mkv_seekhead
*main_seekhead
;
72 mkv_seekhead
*cluster_seekhead
;
75 struct AVMD5
*md5_ctx
;
79 /** 2 bytes * 3 for EBML IDs, 3 1-byte EBML lengths, 8 bytes for 64 bit
80 * offset, 4 bytes for target EBML ID */
81 #define MAX_SEEKENTRY_SIZE 21
83 /** per-cuepoint-track - 3 1-byte EBML IDs, 3 1-byte EBML sizes, 2
85 #define MAX_CUETRACKPOS_SIZE 22
87 /** per-cuepoint - 2 1-byte EBML IDs, 2 1-byte EBML sizes, 8-byte uint max */
88 #define MAX_CUEPOINT_SIZE(num_tracks) 12 + MAX_CUETRACKPOS_SIZE*num_tracks
91 static int ebml_id_size(unsigned int id
)
93 return (av_log2(id
+1)-1)/7+1;
96 static void put_ebml_id(ByteIOContext
*pb
, unsigned int id
)
98 int i
= ebml_id_size(id
);
100 put_byte(pb
, id
>> (i
*8));
104 * Write an EBML size meaning "unknown size".
106 * @param bytes The number of bytes the size should occupy (maximum: 8).
108 static void put_ebml_size_unknown(ByteIOContext
*pb
, int bytes
)
111 put_byte(pb
, 0x1ff >> bytes
);
117 * Calculate how many bytes are needed to represent a given number in EBML.
119 static int ebml_num_size(uint64_t num
)
122 while ((num
+1) >> bytes
*7) bytes
++;
127 * Write a number in EBML variable length format.
129 * @param bytes The number of bytes that need to be used to write the number.
130 * If zero, any number of bytes can be used.
132 static void put_ebml_num(ByteIOContext
*pb
, uint64_t num
, int bytes
)
134 int i
, needed_bytes
= ebml_num_size(num
);
136 // sizes larger than this are currently undefined in EBML
137 assert(num
< (1ULL<<56)-1);
140 // don't care how many bytes are used, so use the min
141 bytes
= needed_bytes
;
142 // the bytes needed to write the given size would exceed the bytes
143 // that we need to use, so write unknown size. This shouldn't happen.
144 assert(bytes
>= needed_bytes
);
146 num
|= 1ULL << bytes
*7;
147 for (i
= bytes
- 1; i
>= 0; i
--)
148 put_byte(pb
, num
>> i
*8);
151 static void put_ebml_uint(ByteIOContext
*pb
, unsigned int elementid
, uint64_t val
)
155 while (tmp
>>=8) bytes
++;
157 put_ebml_id(pb
, elementid
);
158 put_ebml_num(pb
, bytes
, 0);
159 for (i
= bytes
- 1; i
>= 0; i
--)
160 put_byte(pb
, val
>> i
*8);
163 static void put_ebml_float(ByteIOContext
*pb
, unsigned int elementid
, double val
)
165 put_ebml_id(pb
, elementid
);
166 put_ebml_num(pb
, 8, 0);
167 put_be64(pb
, av_dbl2int(val
));
170 static void put_ebml_binary(ByteIOContext
*pb
, unsigned int elementid
,
171 const uint8_t *buf
, int size
)
173 put_ebml_id(pb
, elementid
);
174 put_ebml_num(pb
, size
, 0);
175 put_buffer(pb
, buf
, size
);
178 static void put_ebml_string(ByteIOContext
*pb
, unsigned int elementid
, const char *str
)
180 put_ebml_binary(pb
, elementid
, str
, strlen(str
));
184 * Writes a void element of a given size. Useful for reserving space in
185 * the file to be written to later.
187 * @param size The number of bytes to reserve, which must be at least 2.
189 static void put_ebml_void(ByteIOContext
*pb
, uint64_t size
)
191 int64_t currentpos
= url_ftell(pb
);
195 put_ebml_id(pb
, EBML_ID_VOID
);
196 // we need to subtract the length needed to store the size from the
197 // size we need to reserve so 2 cases, we use 8 bytes to store the
198 // size if possible, 1 byte otherwise
200 put_ebml_num(pb
, size
-1, 0);
202 put_ebml_num(pb
, size
-9, 8);
203 while(url_ftell(pb
) < currentpos
+ size
)
207 static ebml_master
start_ebml_master(ByteIOContext
*pb
, unsigned int elementid
, uint64_t expectedsize
)
209 int bytes
= expectedsize
? ebml_num_size(expectedsize
) : 8;
210 put_ebml_id(pb
, elementid
);
211 put_ebml_size_unknown(pb
, bytes
);
212 return (ebml_master
){ url_ftell(pb
), bytes
};
215 static void end_ebml_master(ByteIOContext
*pb
, ebml_master master
)
217 int64_t pos
= url_ftell(pb
);
219 // leave the unknown size for masters when streaming
220 if (url_is_streamed(pb
))
223 url_fseek(pb
, master
.pos
- master
.sizebytes
, SEEK_SET
);
224 put_ebml_num(pb
, pos
- master
.pos
, master
.sizebytes
);
225 url_fseek(pb
, pos
, SEEK_SET
);
228 static void put_xiph_size(ByteIOContext
*pb
, int size
)
231 for (i
= 0; i
< size
/ 255; i
++)
233 put_byte(pb
, size
% 255);
237 * Initialize a mkv_seekhead element to be ready to index level 1 Matroska
238 * elements. If a maximum number of elements is specified, enough space
239 * will be reserved at the current file location to write a seek head of
242 * @param segment_offset The absolute offset to the position in the file
243 * where the segment begins.
244 * @param numelements The maximum number of elements that will be indexed
245 * by this seek head, 0 if unlimited.
247 static mkv_seekhead
* mkv_start_seekhead(ByteIOContext
*pb
, int64_t segment_offset
, int numelements
)
249 mkv_seekhead
*new_seekhead
= av_mallocz(sizeof(mkv_seekhead
));
250 if (new_seekhead
== NULL
)
253 new_seekhead
->segment_offset
= segment_offset
;
255 if (numelements
> 0) {
256 new_seekhead
->filepos
= url_ftell(pb
);
257 // 21 bytes max for a seek entry, 10 bytes max for the SeekHead ID
258 // and size, and 3 bytes to guarantee that an EBML void element
259 // will fit afterwards
260 new_seekhead
->reserved_size
= numelements
* MAX_SEEKENTRY_SIZE
+ 13;
261 new_seekhead
->max_entries
= numelements
;
262 put_ebml_void(pb
, new_seekhead
->reserved_size
);
267 static int mkv_add_seekhead_entry(mkv_seekhead
*seekhead
, unsigned int elementid
, uint64_t filepos
)
269 mkv_seekhead_entry
*entries
= seekhead
->entries
;
271 // don't store more elements than we reserved space for
272 if (seekhead
->max_entries
> 0 && seekhead
->max_entries
<= seekhead
->num_entries
)
275 entries
= av_realloc(entries
, (seekhead
->num_entries
+ 1) * sizeof(mkv_seekhead_entry
));
277 return AVERROR(ENOMEM
);
279 entries
[seekhead
->num_entries
].elementid
= elementid
;
280 entries
[seekhead
->num_entries
++].segmentpos
= filepos
- seekhead
->segment_offset
;
282 seekhead
->entries
= entries
;
287 * Write the seek head to the file and free it. If a maximum number of
288 * elements was specified to mkv_start_seekhead(), the seek head will
289 * be written at the location reserved for it. Otherwise, it is written
290 * at the current location in the file.
292 * @return The file offset where the seekhead was written.
294 static int64_t mkv_write_seekhead(ByteIOContext
*pb
, mkv_seekhead
*seekhead
)
296 ebml_master metaseek
, seekentry
;
300 currentpos
= url_ftell(pb
);
302 if (seekhead
->reserved_size
> 0)
303 url_fseek(pb
, seekhead
->filepos
, SEEK_SET
);
305 metaseek
= start_ebml_master(pb
, MATROSKA_ID_SEEKHEAD
, seekhead
->reserved_size
);
306 for (i
= 0; i
< seekhead
->num_entries
; i
++) {
307 mkv_seekhead_entry
*entry
= &seekhead
->entries
[i
];
309 seekentry
= start_ebml_master(pb
, MATROSKA_ID_SEEKENTRY
, MAX_SEEKENTRY_SIZE
);
311 put_ebml_id(pb
, MATROSKA_ID_SEEKID
);
312 put_ebml_num(pb
, ebml_id_size(entry
->elementid
), 0);
313 put_ebml_id(pb
, entry
->elementid
);
315 put_ebml_uint(pb
, MATROSKA_ID_SEEKPOSITION
, entry
->segmentpos
);
316 end_ebml_master(pb
, seekentry
);
318 end_ebml_master(pb
, metaseek
);
320 if (seekhead
->reserved_size
> 0) {
321 uint64_t remaining
= seekhead
->filepos
+ seekhead
->reserved_size
- url_ftell(pb
);
322 put_ebml_void(pb
, remaining
);
323 url_fseek(pb
, currentpos
, SEEK_SET
);
325 currentpos
= seekhead
->filepos
;
327 av_free(seekhead
->entries
);
333 static mkv_cues
* mkv_start_cues(int64_t segment_offset
)
335 mkv_cues
*cues
= av_mallocz(sizeof(mkv_cues
));
339 cues
->segment_offset
= segment_offset
;
343 static int mkv_add_cuepoint(mkv_cues
*cues
, AVPacket
*pkt
, int64_t cluster_pos
)
345 mkv_cuepoint
*entries
= cues
->entries
;
347 entries
= av_realloc(entries
, (cues
->num_entries
+ 1) * sizeof(mkv_cuepoint
));
349 return AVERROR(ENOMEM
);
351 entries
[cues
->num_entries
].pts
= pkt
->pts
;
352 entries
[cues
->num_entries
].tracknum
= pkt
->stream_index
+ 1;
353 entries
[cues
->num_entries
++].cluster_pos
= cluster_pos
- cues
->segment_offset
;
355 cues
->entries
= entries
;
359 static int64_t mkv_write_cues(ByteIOContext
*pb
, mkv_cues
*cues
, int num_tracks
)
361 ebml_master cues_element
;
365 currentpos
= url_ftell(pb
);
366 cues_element
= start_ebml_master(pb
, MATROSKA_ID_CUES
, 0);
368 for (i
= 0; i
< cues
->num_entries
; i
++) {
369 ebml_master cuepoint
, track_positions
;
370 mkv_cuepoint
*entry
= &cues
->entries
[i
];
371 uint64_t pts
= entry
->pts
;
373 cuepoint
= start_ebml_master(pb
, MATROSKA_ID_POINTENTRY
, MAX_CUEPOINT_SIZE(num_tracks
));
374 put_ebml_uint(pb
, MATROSKA_ID_CUETIME
, pts
);
376 // put all the entries from different tracks that have the exact same
377 // timestamp into the same CuePoint
378 for (j
= 0; j
< cues
->num_entries
- i
&& entry
[j
].pts
== pts
; j
++) {
379 track_positions
= start_ebml_master(pb
, MATROSKA_ID_CUETRACKPOSITION
, MAX_CUETRACKPOS_SIZE
);
380 put_ebml_uint(pb
, MATROSKA_ID_CUETRACK
, entry
[j
].tracknum
);
381 put_ebml_uint(pb
, MATROSKA_ID_CUECLUSTERPOSITION
, entry
[j
].cluster_pos
);
382 end_ebml_master(pb
, track_positions
);
385 end_ebml_master(pb
, cuepoint
);
387 end_ebml_master(pb
, cues_element
);
389 av_free(cues
->entries
);
394 static int put_xiph_codecpriv(AVFormatContext
*s
, ByteIOContext
*pb
, AVCodecContext
*codec
)
396 uint8_t *header_start
[3];
398 int first_header_size
;
401 if (codec
->codec_id
== CODEC_ID_VORBIS
)
402 first_header_size
= 30;
404 first_header_size
= 42;
406 if (ff_split_xiph_headers(codec
->extradata
, codec
->extradata_size
,
407 first_header_size
, header_start
, header_len
) < 0) {
408 av_log(s
, AV_LOG_ERROR
, "Extradata corrupt.\n");
412 put_byte(pb
, 2); // number packets - 1
413 for (j
= 0; j
< 2; j
++) {
414 put_xiph_size(pb
, header_len
[j
]);
416 for (j
= 0; j
< 3; j
++)
417 put_buffer(pb
, header_start
[j
], header_len
[j
]);
422 #define FLAC_STREAMINFO_SIZE 34
424 static int put_flac_codecpriv(AVFormatContext
*s
, ByteIOContext
*pb
, AVCodecContext
*codec
)
426 // if the extradata_size is greater than FLAC_STREAMINFO_SIZE,
427 // assume that it's in Matroska format already
428 if (codec
->extradata_size
< FLAC_STREAMINFO_SIZE
) {
429 av_log(s
, AV_LOG_ERROR
, "Invalid FLAC extradata\n");
431 } else if (codec
->extradata_size
== FLAC_STREAMINFO_SIZE
) {
432 // only the streaminfo packet
433 put_buffer(pb
, "fLaC", 4);
435 put_be24(pb
, FLAC_STREAMINFO_SIZE
);
436 } else if(memcmp("fLaC", codec
->extradata
, 4)) {
437 av_log(s
, AV_LOG_ERROR
, "Invalid FLAC extradata\n");
440 put_buffer(pb
, codec
->extradata
, codec
->extradata_size
);
444 static void get_aac_sample_rates(AVFormatContext
*s
, AVCodecContext
*codec
, int *sample_rate
, int *output_sample_rate
)
448 if (codec
->extradata_size
< 2) {
449 av_log(s
, AV_LOG_WARNING
, "No AAC extradata, unable to determine samplerate.\n");
453 sri
= ((codec
->extradata
[0] << 1) & 0xE) | (codec
->extradata
[1] >> 7);
455 av_log(s
, AV_LOG_WARNING
, "AAC samplerate index out of bounds\n");
458 *sample_rate
= ff_mpeg4audio_sample_rates
[sri
];
460 // if sbr, get output sample rate as well
461 if (codec
->extradata_size
== 5) {
462 sri
= (codec
->extradata
[4] >> 3) & 0xF;
464 av_log(s
, AV_LOG_WARNING
, "AAC output samplerate index out of bounds\n");
467 *output_sample_rate
= ff_mpeg4audio_sample_rates
[sri
];
471 static int mkv_write_codecprivate(AVFormatContext
*s
, ByteIOContext
*pb
, AVCodecContext
*codec
, int native_id
, int qt_id
)
473 ByteIOContext
*dyn_cp
;
475 int ret
, codecpriv_size
;
477 ret
= url_open_dyn_buf(&dyn_cp
);
482 if (codec
->codec_id
== CODEC_ID_VORBIS
|| codec
->codec_id
== CODEC_ID_THEORA
)
483 ret
= put_xiph_codecpriv(s
, dyn_cp
, codec
);
484 else if (codec
->codec_id
== CODEC_ID_FLAC
)
485 ret
= put_flac_codecpriv(s
, dyn_cp
, codec
);
486 else if (codec
->codec_id
== CODEC_ID_H264
)
487 ret
= ff_isom_write_avcc(dyn_cp
, codec
->extradata
, codec
->extradata_size
);
488 else if (codec
->extradata_size
)
489 put_buffer(dyn_cp
, codec
->extradata
, codec
->extradata_size
);
490 } else if (codec
->codec_type
== CODEC_TYPE_VIDEO
) {
492 if (!codec
->codec_tag
)
493 codec
->codec_tag
= codec_get_tag(codec_movvideo_tags
, codec
->codec_id
);
494 if (codec
->extradata_size
)
495 put_buffer(dyn_cp
, codec
->extradata
, codec
->extradata_size
);
497 if (!codec
->codec_tag
)
498 codec
->codec_tag
= codec_get_tag(codec_bmp_tags
, codec
->codec_id
);
499 if (!codec
->codec_tag
) {
500 av_log(s
, AV_LOG_ERROR
, "No bmp codec ID found.");
504 put_bmp_header(dyn_cp
, codec
, codec_bmp_tags
, 0);
507 } else if (codec
->codec_type
== CODEC_TYPE_AUDIO
) {
508 if (!codec
->codec_tag
)
509 codec
->codec_tag
= codec_get_tag(codec_wav_tags
, codec
->codec_id
);
510 if (!codec
->codec_tag
) {
511 av_log(s
, AV_LOG_ERROR
, "No wav codec ID found.");
515 put_wav_header(dyn_cp
, codec
);
518 codecpriv_size
= url_close_dyn_buf(dyn_cp
, &codecpriv
);
520 put_ebml_binary(pb
, MATROSKA_ID_CODECPRIVATE
, codecpriv
, codecpriv_size
);
525 static int mkv_write_tracks(AVFormatContext
*s
)
527 MatroskaMuxContext
*mkv
= s
->priv_data
;
528 ByteIOContext
*pb
= s
->pb
;
532 ret
= mkv_add_seekhead_entry(mkv
->main_seekhead
, MATROSKA_ID_TRACKS
, url_ftell(pb
));
533 if (ret
< 0) return ret
;
535 tracks
= start_ebml_master(pb
, MATROSKA_ID_TRACKS
, 0);
536 for (i
= 0; i
< s
->nb_streams
; i
++) {
537 AVStream
*st
= s
->streams
[i
];
538 AVCodecContext
*codec
= st
->codec
;
539 ebml_master subinfo
, track
;
542 int bit_depth
= av_get_bits_per_sample(codec
->codec_id
);
543 int sample_rate
= codec
->sample_rate
;
544 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)
558 put_ebml_string(pb
, MATROSKA_ID_TRACKLANGUAGE
, st
->language
);
560 put_ebml_string(pb
, MATROSKA_ID_TRACKLANGUAGE
, "und");
562 put_ebml_uint(pb
, MATROSKA_ID_TRACKFLAGDEFAULT
, !!(st
->disposition
& AV_DISPOSITION_DEFAULT
));
564 // look for a codec ID string specific to mkv to use,
565 // if none are found, use AVI codes
566 for (j
= 0; ff_mkv_codec_tags
[j
].id
!= CODEC_ID_NONE
; j
++) {
567 if (ff_mkv_codec_tags
[j
].id
== codec
->codec_id
) {
568 put_ebml_string(pb
, MATROSKA_ID_CODECID
, ff_mkv_codec_tags
[j
].str
);
574 switch (codec
->codec_type
) {
575 case CODEC_TYPE_VIDEO
:
576 put_ebml_uint(pb
, MATROSKA_ID_TRACKTYPE
, MATROSKA_TRACK_TYPE_VIDEO
);
579 codec_get_tag(codec_movvideo_tags
, codec
->codec_id
) &&
580 (!codec_get_tag(codec_bmp_tags
, codec
->codec_id
)
581 || codec
->codec_id
== CODEC_ID_SVQ1
582 || codec
->codec_id
== CODEC_ID_SVQ3
583 || codec
->codec_id
== CODEC_ID_CINEPAK
))
587 put_ebml_string(pb
, MATROSKA_ID_CODECID
, "V_QUICKTIME");
589 // if there is no mkv-specific codec ID, use VFW mode
590 put_ebml_string(pb
, MATROSKA_ID_CODECID
, "V_MS/VFW/FOURCC");
592 subinfo
= start_ebml_master(pb
, MATROSKA_ID_TRACKVIDEO
, 0);
593 // XXX: interlace flag?
594 put_ebml_uint (pb
, MATROSKA_ID_VIDEOPIXELWIDTH
, codec
->width
);
595 put_ebml_uint (pb
, MATROSKA_ID_VIDEOPIXELHEIGHT
, codec
->height
);
596 if (st
->sample_aspect_ratio
.num
) {
597 int d_width
= codec
->width
*av_q2d(st
->sample_aspect_ratio
);
598 put_ebml_uint(pb
, MATROSKA_ID_VIDEODISPLAYWIDTH
, d_width
);
599 put_ebml_uint(pb
, MATROSKA_ID_VIDEODISPLAYHEIGHT
, codec
->height
);
601 end_ebml_master(pb
, subinfo
);
604 case CODEC_TYPE_AUDIO
:
605 put_ebml_uint(pb
, MATROSKA_ID_TRACKTYPE
, MATROSKA_TRACK_TYPE_AUDIO
);
608 // no mkv-specific ID, use ACM mode
609 put_ebml_string(pb
, MATROSKA_ID_CODECID
, "A_MS/ACM");
611 subinfo
= start_ebml_master(pb
, MATROSKA_ID_TRACKAUDIO
, 0);
612 put_ebml_uint (pb
, MATROSKA_ID_AUDIOCHANNELS
, codec
->channels
);
613 put_ebml_float (pb
, MATROSKA_ID_AUDIOSAMPLINGFREQ
, sample_rate
);
614 if (output_sample_rate
)
615 put_ebml_float(pb
, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ
, output_sample_rate
);
617 put_ebml_uint(pb
, MATROSKA_ID_AUDIOBITDEPTH
, bit_depth
);
618 end_ebml_master(pb
, subinfo
);
621 case CODEC_TYPE_SUBTITLE
:
622 put_ebml_uint(pb
, MATROSKA_ID_TRACKTYPE
, MATROSKA_TRACK_TYPE_SUBTITLE
);
625 av_log(s
, AV_LOG_ERROR
, "Only audio, video, and subtitles are supported for Matroska.");
628 ret
= mkv_write_codecprivate(s
, pb
, codec
, native_id
, qt_id
);
629 if (ret
< 0) return ret
;
631 end_ebml_master(pb
, track
);
633 // ms precision is the de-facto standard timescale for mkv files
634 av_set_pts_info(st
, 64, 1, 1000);
636 end_ebml_master(pb
, tracks
);
640 static int mkv_write_header(AVFormatContext
*s
)
642 MatroskaMuxContext
*mkv
= s
->priv_data
;
643 ByteIOContext
*pb
= s
->pb
;
644 ebml_master ebml_header
, segment_info
;
647 mkv
->md5_ctx
= av_mallocz(av_md5_size
);
648 av_md5_init(mkv
->md5_ctx
);
650 ebml_header
= start_ebml_master(pb
, EBML_ID_HEADER
, 0);
651 put_ebml_uint (pb
, EBML_ID_EBMLVERSION
, 1);
652 put_ebml_uint (pb
, EBML_ID_EBMLREADVERSION
, 1);
653 put_ebml_uint (pb
, EBML_ID_EBMLMAXIDLENGTH
, 4);
654 put_ebml_uint (pb
, EBML_ID_EBMLMAXSIZELENGTH
, 8);
655 put_ebml_string (pb
, EBML_ID_DOCTYPE
, "matroska");
656 put_ebml_uint (pb
, EBML_ID_DOCTYPEVERSION
, 2);
657 put_ebml_uint (pb
, EBML_ID_DOCTYPEREADVERSION
, 2);
658 end_ebml_master(pb
, ebml_header
);
660 mkv
->segment
= start_ebml_master(pb
, MATROSKA_ID_SEGMENT
, 0);
661 mkv
->segment_offset
= url_ftell(pb
);
663 // we write 2 seek heads - one at the end of the file to point to each
664 // cluster, and one at the beginning to point to all other level one
665 // elements (including the seek head at the end of the file), which
666 // isn't more than 10 elements if we only write one of each other
667 // currently defined level 1 element
668 mkv
->main_seekhead
= mkv_start_seekhead(pb
, mkv
->segment_offset
, 10);
669 mkv
->cluster_seekhead
= mkv_start_seekhead(pb
, mkv
->segment_offset
, 0);
670 if (mkv
->main_seekhead
== NULL
|| mkv
->cluster_seekhead
== NULL
)
671 return AVERROR(ENOMEM
);
673 ret
= mkv_add_seekhead_entry(mkv
->main_seekhead
, MATROSKA_ID_INFO
, url_ftell(pb
));
674 if (ret
< 0) return ret
;
676 segment_info
= start_ebml_master(pb
, MATROSKA_ID_INFO
, 0);
677 put_ebml_uint(pb
, MATROSKA_ID_TIMECODESCALE
, 1000000);
678 if (strlen(s
->title
))
679 put_ebml_string(pb
, MATROSKA_ID_TITLE
, s
->title
);
680 if (!(s
->streams
[0]->codec
->flags
& CODEC_FLAG_BITEXACT
)) {
681 put_ebml_string(pb
, MATROSKA_ID_MUXINGAPP
, LIBAVFORMAT_IDENT
);
682 put_ebml_string(pb
, MATROSKA_ID_WRITINGAPP
, LIBAVFORMAT_IDENT
);
684 // reserve space to write the segment UID later
685 mkv
->segment_uid
= url_ftell(pb
);
686 put_ebml_void(pb
, 19);
689 // reserve space for the duration
691 mkv
->duration_offset
= url_ftell(pb
);
692 put_ebml_void(pb
, 11); // assumes double-precision float to be written
693 end_ebml_master(pb
, segment_info
);
695 ret
= mkv_write_tracks(s
);
696 if (ret
< 0) return ret
;
698 ret
= mkv_add_seekhead_entry(mkv
->cluster_seekhead
, MATROSKA_ID_CLUSTER
, url_ftell(pb
));
699 if (ret
< 0) return ret
;
701 mkv
->cluster_pos
= url_ftell(pb
);
702 mkv
->cluster
= start_ebml_master(pb
, MATROSKA_ID_CLUSTER
, 0);
703 put_ebml_uint(pb
, MATROSKA_ID_CLUSTERTIMECODE
, 0);
704 mkv
->cluster_pts
= 0;
706 mkv
->cues
= mkv_start_cues(mkv
->segment_offset
);
707 if (mkv
->cues
== NULL
)
708 return AVERROR(ENOMEM
);
713 static int mkv_blockgroup_size(int pkt_size
)
715 int size
= pkt_size
+ 4;
716 size
+= ebml_num_size(size
);
717 size
+= 2; // EBML ID for block and block duration
718 size
+= 8; // max size of block duration
719 size
+= ebml_num_size(size
);
720 size
+= 1; // blockgroup EBML ID
724 static int ass_get_duration(const uint8_t *p
)
726 int sh
, sm
, ss
, sc
, eh
, em
, es
, ec
;
729 if (sscanf(p
, "%*[^,],%d:%d:%d%*c%d,%d:%d:%d%*c%d",
730 &sh
, &sm
, &ss
, &sc
, &eh
, &em
, &es
, &ec
) != 8)
732 start
= 3600000*sh
+ 60000*sm
+ 1000*ss
+ 10*sc
;
733 end
= 3600000*eh
+ 60000*em
+ 1000*es
+ 10*ec
;
737 static int mkv_write_ass_blocks(AVFormatContext
*s
, AVPacket
*pkt
)
739 MatroskaMuxContext
*mkv
= s
->priv_data
;
740 ByteIOContext
*pb
= s
->pb
;
741 int i
, layer
= 0, max_duration
= 0, size
, line_size
, data_size
= pkt
->size
;
742 uint8_t *start
, *end
, *data
= pkt
->data
;
743 ebml_master blockgroup
;
747 int duration
= ass_get_duration(data
);
748 max_duration
= FFMAX(duration
, max_duration
);
749 end
= memchr(data
, '\n', data_size
);
750 size
= line_size
= end
? end
-data
+1 : data_size
;
751 size
-= end
? (end
[-1]=='\r')+1 : 0;
753 for (i
=0; i
<3; i
++, start
++)
754 if (!(start
= memchr(start
, ',', size
-(start
-data
))))
756 size
-= start
- data
;
757 sscanf(data
, "Dialogue: %d,", &layer
);
758 i
= snprintf(buffer
, sizeof(buffer
), "%"PRId64
",%d,",
759 s
->streams
[pkt
->stream_index
]->nb_frames
++, layer
);
760 size
= FFMIN(i
+size
, sizeof(buffer
));
761 memcpy(buffer
+i
, start
, size
-i
);
763 av_log(s
, AV_LOG_DEBUG
, "Writing block at offset %" PRIu64
", size %d, "
764 "pts %" PRId64
", duration %d\n",
765 url_ftell(pb
), size
, pkt
->pts
, duration
);
766 blockgroup
= start_ebml_master(pb
, MATROSKA_ID_BLOCKGROUP
, mkv_blockgroup_size(size
));
767 put_ebml_id(pb
, MATROSKA_ID_BLOCK
);
768 put_ebml_num(pb
, size
+4, 0);
769 put_byte(pb
, 0x80 | (pkt
->stream_index
+ 1)); // this assumes stream_index is less than 126
770 put_be16(pb
, pkt
->pts
- mkv
->cluster_pts
);
772 put_buffer(pb
, buffer
, size
);
773 put_ebml_uint(pb
, MATROSKA_ID_BLOCKDURATION
, duration
);
774 end_ebml_master(pb
, blockgroup
);
777 data_size
-= line_size
;
783 static void mkv_write_block(AVFormatContext
*s
, unsigned int blockid
, AVPacket
*pkt
, int flags
)
785 MatroskaMuxContext
*mkv
= s
->priv_data
;
786 ByteIOContext
*pb
= s
->pb
;
788 av_log(s
, AV_LOG_DEBUG
, "Writing block at offset %" PRIu64
", size %d, "
789 "pts %" PRId64
", dts %" PRId64
", duration %d, flags %d\n",
790 url_ftell(pb
), pkt
->size
, pkt
->pts
, pkt
->dts
, pkt
->duration
, flags
);
791 put_ebml_id(pb
, blockid
);
792 put_ebml_num(pb
, pkt
->size
+4, 0);
793 put_byte(pb
, 0x80 | (pkt
->stream_index
+ 1)); // this assumes stream_index is less than 126
794 put_be16(pb
, pkt
->pts
- mkv
->cluster_pts
);
796 put_buffer(pb
, pkt
->data
, pkt
->size
);
799 static int mkv_write_packet(AVFormatContext
*s
, AVPacket
*pkt
)
801 MatroskaMuxContext
*mkv
= s
->priv_data
;
802 ByteIOContext
*pb
= s
->pb
;
803 AVCodecContext
*codec
= s
->streams
[pkt
->stream_index
]->codec
;
804 int keyframe
= !!(pkt
->flags
& PKT_FLAG_KEY
);
805 int duration
= pkt
->duration
;
808 // start a new cluster every 5 MB or 5 sec
809 if (url_ftell(pb
) > mkv
->cluster_pos
+ 5*1024*1024 || pkt
->pts
> mkv
->cluster_pts
+ 5000) {
810 av_log(s
, AV_LOG_DEBUG
, "Starting new cluster at offset %" PRIu64
811 " bytes, pts %" PRIu64
"\n", url_ftell(pb
), pkt
->pts
);
812 end_ebml_master(pb
, mkv
->cluster
);
814 ret
= mkv_add_seekhead_entry(mkv
->cluster_seekhead
, MATROSKA_ID_CLUSTER
, url_ftell(pb
));
815 if (ret
< 0) return ret
;
817 mkv
->cluster_pos
= url_ftell(pb
);
818 mkv
->cluster
= start_ebml_master(pb
, MATROSKA_ID_CLUSTER
, 0);
819 put_ebml_uint(pb
, MATROSKA_ID_CLUSTERTIMECODE
, pkt
->pts
);
820 mkv
->cluster_pts
= pkt
->pts
;
821 av_md5_update(mkv
->md5_ctx
, pkt
->data
, FFMIN(200, pkt
->size
));
824 if (codec
->codec_id
== CODEC_ID_H264
&&
825 codec
->extradata_size
> 0 && AV_RB32(codec
->extradata
) == 0x00000001) {
826 /* from x264 or from bytestream h264 */
827 /* nal reformating needed */
828 int ret
= ff_avc_parse_nal_units(pkt
->data
, &pkt
->data
, &pkt
->size
);
834 if (codec
->codec_type
!= CODEC_TYPE_SUBTITLE
) {
835 mkv_write_block(s
, MATROSKA_ID_SIMPLEBLOCK
, pkt
, keyframe
<< 7);
836 } else if (codec
->codec_id
== CODEC_ID_SSA
) {
837 duration
= mkv_write_ass_blocks(s
, pkt
);
839 ebml_master blockgroup
= start_ebml_master(pb
, MATROSKA_ID_BLOCKGROUP
, mkv_blockgroup_size(pkt
->size
));
840 duration
= pkt
->convergence_duration
;
841 mkv_write_block(s
, MATROSKA_ID_BLOCK
, pkt
, 0);
842 put_ebml_uint(pb
, MATROSKA_ID_BLOCKDURATION
, duration
);
843 end_ebml_master(pb
, blockgroup
);
846 if (codec
->codec_type
== CODEC_TYPE_VIDEO
&& keyframe
) {
847 ret
= mkv_add_cuepoint(mkv
->cues
, pkt
, mkv
->cluster_pos
);
848 if (ret
< 0) return ret
;
851 mkv
->duration
= FFMAX(mkv
->duration
, pkt
->pts
+ duration
);
855 static int mkv_write_trailer(AVFormatContext
*s
)
857 MatroskaMuxContext
*mkv
= s
->priv_data
;
858 ByteIOContext
*pb
= s
->pb
;
859 int64_t currentpos
, second_seekhead
, cuespos
;
862 end_ebml_master(pb
, mkv
->cluster
);
864 if (!url_is_streamed(pb
)) {
865 cuespos
= mkv_write_cues(pb
, mkv
->cues
, s
->nb_streams
);
866 second_seekhead
= mkv_write_seekhead(pb
, mkv
->cluster_seekhead
);
868 ret
= mkv_add_seekhead_entry(mkv
->main_seekhead
, MATROSKA_ID_CUES
, cuespos
);
869 if (ret
< 0) return ret
;
870 ret
= mkv_add_seekhead_entry(mkv
->main_seekhead
, MATROSKA_ID_SEEKHEAD
, second_seekhead
);
871 if (ret
< 0) return ret
;
872 mkv_write_seekhead(pb
, mkv
->main_seekhead
);
874 // update the duration
875 av_log(s
, AV_LOG_DEBUG
, "end duration = %" PRIu64
"\n", mkv
->duration
);
876 currentpos
= url_ftell(pb
);
877 url_fseek(pb
, mkv
->duration_offset
, SEEK_SET
);
878 put_ebml_float(pb
, MATROSKA_ID_DURATION
, mkv
->duration
);
880 // write the md5sum of some frames as the segment UID
881 if (!(s
->streams
[0]->codec
->flags
& CODEC_FLAG_BITEXACT
)) {
882 uint8_t segment_uid
[16];
883 av_md5_final(mkv
->md5_ctx
, segment_uid
);
884 url_fseek(pb
, mkv
->segment_uid
, SEEK_SET
);
885 put_ebml_binary(pb
, MATROSKA_ID_SEGMENTUID
, segment_uid
, 16);
887 url_fseek(pb
, currentpos
, SEEK_SET
);
890 end_ebml_master(pb
, mkv
->segment
);
891 av_free(mkv
->md5_ctx
);
895 AVOutputFormat matroska_muxer
= {
897 NULL_IF_CONFIG_SMALL("Matroska file format"),
900 sizeof(MatroskaMuxContext
),
906 .flags
= AVFMT_GLOBALHEADER
,
907 .codec_tag
= (const AVCodecTag
* const []){codec_bmp_tags
, codec_wav_tags
, 0},
908 .subtitle_codec
= CODEC_ID_TEXT
,
911 AVOutputFormat matroska_audio_muxer
= {
913 NULL_IF_CONFIG_SMALL("Matroska file format"),
916 sizeof(MatroskaMuxContext
),
922 .flags
= AVFMT_GLOBALHEADER
,
923 .codec_tag
= (const AVCodecTag
* const []){codec_wav_tags
, 0},