Libav 0.7.1
|
00001 /* 00002 * Matroska muxer 00003 * Copyright (c) 2007 David Conrad 00004 * 00005 * This file is part of Libav. 00006 * 00007 * Libav is free software; you can redistribute it and/or 00008 * modify it under the terms of the GNU Lesser General Public 00009 * License as published by the Free Software Foundation; either 00010 * version 2.1 of the License, or (at your option) any later version. 00011 * 00012 * Libav is distributed in the hope that it will be useful, 00013 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00014 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00015 * Lesser General Public License for more details. 00016 * 00017 * You should have received a copy of the GNU Lesser General Public 00018 * License along with Libav; if not, write to the Free Software 00019 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 00020 */ 00021 00022 #include "avformat.h" 00023 #include "riff.h" 00024 #include "isom.h" 00025 #include "matroska.h" 00026 #include "avc.h" 00027 #include "flacenc.h" 00028 #include "avlanguage.h" 00029 #include "libavutil/samplefmt.h" 00030 #include "libavutil/intreadwrite.h" 00031 #include "libavutil/random_seed.h" 00032 #include "libavutil/lfg.h" 00033 #include "libavutil/dict.h" 00034 #include "libavcodec/xiph.h" 00035 #include "libavcodec/mpeg4audio.h" 00036 #include <strings.h> 00037 00038 typedef struct ebml_master { 00039 int64_t pos; 00040 int sizebytes; 00041 } ebml_master; 00042 00043 typedef struct mkv_seekhead_entry { 00044 unsigned int elementid; 00045 uint64_t segmentpos; 00046 } mkv_seekhead_entry; 00047 00048 typedef struct mkv_seekhead { 00049 int64_t filepos; 00050 int64_t segment_offset; 00051 int reserved_size; 00052 int max_entries; 00053 mkv_seekhead_entry *entries; 00054 int num_entries; 00055 } mkv_seekhead; 00056 00057 typedef struct { 00058 uint64_t pts; 00059 int tracknum; 00060 int64_t cluster_pos; 00061 } mkv_cuepoint; 00062 00063 typedef struct { 00064 int64_t segment_offset; 00065 mkv_cuepoint *entries; 00066 int num_entries; 00067 } mkv_cues; 00068 00069 typedef struct { 00070 int write_dts; 00071 } mkv_track; 00072 00073 #define MODE_MATROSKAv2 0x01 00074 #define MODE_WEBM 0x02 00075 00076 typedef struct MatroskaMuxContext { 00077 int mode; 00078 AVIOContext *dyn_bc; 00079 ebml_master segment; 00080 int64_t segment_offset; 00081 ebml_master cluster; 00082 int64_t cluster_pos; 00083 int64_t cluster_pts; 00084 int64_t duration_offset; 00085 int64_t duration; 00086 mkv_seekhead *main_seekhead; 00087 mkv_cues *cues; 00088 mkv_track *tracks; 00089 00090 unsigned int audio_buffer_size; 00091 AVPacket cur_audio_pkt; 00092 } MatroskaMuxContext; 00093 00094 00097 #define MAX_SEEKENTRY_SIZE 21 00098 00101 #define MAX_CUETRACKPOS_SIZE 22 00102 00104 #define MAX_CUEPOINT_SIZE(num_tracks) 12 + MAX_CUETRACKPOS_SIZE*num_tracks 00105 00106 00107 static int ebml_id_size(unsigned int id) 00108 { 00109 return (av_log2(id+1)-1)/7+1; 00110 } 00111 00112 static void put_ebml_id(AVIOContext *pb, unsigned int id) 00113 { 00114 int i = ebml_id_size(id); 00115 while (i--) 00116 avio_w8(pb, id >> (i*8)); 00117 } 00118 00124 static void put_ebml_size_unknown(AVIOContext *pb, int bytes) 00125 { 00126 assert(bytes <= 8); 00127 avio_w8(pb, 0x1ff >> bytes); 00128 while (--bytes) 00129 avio_w8(pb, 0xff); 00130 } 00131 00135 static int ebml_num_size(uint64_t num) 00136 { 00137 int bytes = 1; 00138 while ((num+1) >> bytes*7) bytes++; 00139 return bytes; 00140 } 00141 00148 static void put_ebml_num(AVIOContext *pb, uint64_t num, int bytes) 00149 { 00150 int i, needed_bytes = ebml_num_size(num); 00151 00152 // sizes larger than this are currently undefined in EBML 00153 assert(num < (1ULL<<56)-1); 00154 00155 if (bytes == 0) 00156 // don't care how many bytes are used, so use the min 00157 bytes = needed_bytes; 00158 // the bytes needed to write the given size would exceed the bytes 00159 // that we need to use, so write unknown size. This shouldn't happen. 00160 assert(bytes >= needed_bytes); 00161 00162 num |= 1ULL << bytes*7; 00163 for (i = bytes - 1; i >= 0; i--) 00164 avio_w8(pb, num >> i*8); 00165 } 00166 00167 static void put_ebml_uint(AVIOContext *pb, unsigned int elementid, uint64_t val) 00168 { 00169 int i, bytes = 1; 00170 uint64_t tmp = val; 00171 while (tmp>>=8) bytes++; 00172 00173 put_ebml_id(pb, elementid); 00174 put_ebml_num(pb, bytes, 0); 00175 for (i = bytes - 1; i >= 0; i--) 00176 avio_w8(pb, val >> i*8); 00177 } 00178 00179 static void put_ebml_float(AVIOContext *pb, unsigned int elementid, double val) 00180 { 00181 put_ebml_id(pb, elementid); 00182 put_ebml_num(pb, 8, 0); 00183 avio_wb64(pb, av_dbl2int(val)); 00184 } 00185 00186 static void put_ebml_binary(AVIOContext *pb, unsigned int elementid, 00187 const void *buf, int size) 00188 { 00189 put_ebml_id(pb, elementid); 00190 put_ebml_num(pb, size, 0); 00191 avio_write(pb, buf, size); 00192 } 00193 00194 static void put_ebml_string(AVIOContext *pb, unsigned int elementid, const char *str) 00195 { 00196 put_ebml_binary(pb, elementid, str, strlen(str)); 00197 } 00198 00205 static void put_ebml_void(AVIOContext *pb, uint64_t size) 00206 { 00207 int64_t currentpos = avio_tell(pb); 00208 00209 assert(size >= 2); 00210 00211 put_ebml_id(pb, EBML_ID_VOID); 00212 // we need to subtract the length needed to store the size from the 00213 // size we need to reserve so 2 cases, we use 8 bytes to store the 00214 // size if possible, 1 byte otherwise 00215 if (size < 10) 00216 put_ebml_num(pb, size-1, 0); 00217 else 00218 put_ebml_num(pb, size-9, 8); 00219 while(avio_tell(pb) < currentpos + size) 00220 avio_w8(pb, 0); 00221 } 00222 00223 static ebml_master start_ebml_master(AVIOContext *pb, unsigned int elementid, uint64_t expectedsize) 00224 { 00225 int bytes = expectedsize ? ebml_num_size(expectedsize) : 8; 00226 put_ebml_id(pb, elementid); 00227 put_ebml_size_unknown(pb, bytes); 00228 return (ebml_master){ avio_tell(pb), bytes }; 00229 } 00230 00231 static void end_ebml_master(AVIOContext *pb, ebml_master master) 00232 { 00233 int64_t pos = avio_tell(pb); 00234 00235 if (avio_seek(pb, master.pos - master.sizebytes, SEEK_SET) < 0) 00236 return; 00237 put_ebml_num(pb, pos - master.pos, master.sizebytes); 00238 avio_seek(pb, pos, SEEK_SET); 00239 } 00240 00241 static void put_xiph_size(AVIOContext *pb, int size) 00242 { 00243 int i; 00244 for (i = 0; i < size / 255; i++) 00245 avio_w8(pb, 255); 00246 avio_w8(pb, size % 255); 00247 } 00248 00260 static mkv_seekhead * mkv_start_seekhead(AVIOContext *pb, int64_t segment_offset, int numelements) 00261 { 00262 mkv_seekhead *new_seekhead = av_mallocz(sizeof(mkv_seekhead)); 00263 if (new_seekhead == NULL) 00264 return NULL; 00265 00266 new_seekhead->segment_offset = segment_offset; 00267 00268 if (numelements > 0) { 00269 new_seekhead->filepos = avio_tell(pb); 00270 // 21 bytes max for a seek entry, 10 bytes max for the SeekHead ID 00271 // and size, and 3 bytes to guarantee that an EBML void element 00272 // will fit afterwards 00273 new_seekhead->reserved_size = numelements * MAX_SEEKENTRY_SIZE + 13; 00274 new_seekhead->max_entries = numelements; 00275 put_ebml_void(pb, new_seekhead->reserved_size); 00276 } 00277 return new_seekhead; 00278 } 00279 00280 static int mkv_add_seekhead_entry(mkv_seekhead *seekhead, unsigned int elementid, uint64_t filepos) 00281 { 00282 mkv_seekhead_entry *entries = seekhead->entries; 00283 00284 // don't store more elements than we reserved space for 00285 if (seekhead->max_entries > 0 && seekhead->max_entries <= seekhead->num_entries) 00286 return -1; 00287 00288 entries = av_realloc(entries, (seekhead->num_entries + 1) * sizeof(mkv_seekhead_entry)); 00289 if (entries == NULL) 00290 return AVERROR(ENOMEM); 00291 00292 entries[seekhead->num_entries ].elementid = elementid; 00293 entries[seekhead->num_entries++].segmentpos = filepos - seekhead->segment_offset; 00294 00295 seekhead->entries = entries; 00296 return 0; 00297 } 00298 00308 static int64_t mkv_write_seekhead(AVIOContext *pb, mkv_seekhead *seekhead) 00309 { 00310 ebml_master metaseek, seekentry; 00311 int64_t currentpos; 00312 int i; 00313 00314 currentpos = avio_tell(pb); 00315 00316 if (seekhead->reserved_size > 0) 00317 if (avio_seek(pb, seekhead->filepos, SEEK_SET) < 0) 00318 return -1; 00319 00320 metaseek = start_ebml_master(pb, MATROSKA_ID_SEEKHEAD, seekhead->reserved_size); 00321 for (i = 0; i < seekhead->num_entries; i++) { 00322 mkv_seekhead_entry *entry = &seekhead->entries[i]; 00323 00324 seekentry = start_ebml_master(pb, MATROSKA_ID_SEEKENTRY, MAX_SEEKENTRY_SIZE); 00325 00326 put_ebml_id(pb, MATROSKA_ID_SEEKID); 00327 put_ebml_num(pb, ebml_id_size(entry->elementid), 0); 00328 put_ebml_id(pb, entry->elementid); 00329 00330 put_ebml_uint(pb, MATROSKA_ID_SEEKPOSITION, entry->segmentpos); 00331 end_ebml_master(pb, seekentry); 00332 } 00333 end_ebml_master(pb, metaseek); 00334 00335 if (seekhead->reserved_size > 0) { 00336 uint64_t remaining = seekhead->filepos + seekhead->reserved_size - avio_tell(pb); 00337 put_ebml_void(pb, remaining); 00338 avio_seek(pb, currentpos, SEEK_SET); 00339 00340 currentpos = seekhead->filepos; 00341 } 00342 av_free(seekhead->entries); 00343 av_free(seekhead); 00344 00345 return currentpos; 00346 } 00347 00348 static mkv_cues * mkv_start_cues(int64_t segment_offset) 00349 { 00350 mkv_cues *cues = av_mallocz(sizeof(mkv_cues)); 00351 if (cues == NULL) 00352 return NULL; 00353 00354 cues->segment_offset = segment_offset; 00355 return cues; 00356 } 00357 00358 static int mkv_add_cuepoint(mkv_cues *cues, int stream, int64_t ts, int64_t cluster_pos) 00359 { 00360 mkv_cuepoint *entries = cues->entries; 00361 00362 entries = av_realloc(entries, (cues->num_entries + 1) * sizeof(mkv_cuepoint)); 00363 if (entries == NULL) 00364 return AVERROR(ENOMEM); 00365 00366 if (ts < 0) 00367 return 0; 00368 00369 entries[cues->num_entries ].pts = ts; 00370 entries[cues->num_entries ].tracknum = stream + 1; 00371 entries[cues->num_entries++].cluster_pos = cluster_pos - cues->segment_offset; 00372 00373 cues->entries = entries; 00374 return 0; 00375 } 00376 00377 static int64_t mkv_write_cues(AVIOContext *pb, mkv_cues *cues, int num_tracks) 00378 { 00379 ebml_master cues_element; 00380 int64_t currentpos; 00381 int i, j; 00382 00383 currentpos = avio_tell(pb); 00384 cues_element = start_ebml_master(pb, MATROSKA_ID_CUES, 0); 00385 00386 for (i = 0; i < cues->num_entries; i++) { 00387 ebml_master cuepoint, track_positions; 00388 mkv_cuepoint *entry = &cues->entries[i]; 00389 uint64_t pts = entry->pts; 00390 00391 cuepoint = start_ebml_master(pb, MATROSKA_ID_POINTENTRY, MAX_CUEPOINT_SIZE(num_tracks)); 00392 put_ebml_uint(pb, MATROSKA_ID_CUETIME, pts); 00393 00394 // put all the entries from different tracks that have the exact same 00395 // timestamp into the same CuePoint 00396 for (j = 0; j < cues->num_entries - i && entry[j].pts == pts; j++) { 00397 track_positions = start_ebml_master(pb, MATROSKA_ID_CUETRACKPOSITION, MAX_CUETRACKPOS_SIZE); 00398 put_ebml_uint(pb, MATROSKA_ID_CUETRACK , entry[j].tracknum ); 00399 put_ebml_uint(pb, MATROSKA_ID_CUECLUSTERPOSITION, entry[j].cluster_pos); 00400 end_ebml_master(pb, track_positions); 00401 } 00402 i += j - 1; 00403 end_ebml_master(pb, cuepoint); 00404 } 00405 end_ebml_master(pb, cues_element); 00406 00407 return currentpos; 00408 } 00409 00410 static int put_xiph_codecpriv(AVFormatContext *s, AVIOContext *pb, AVCodecContext *codec) 00411 { 00412 uint8_t *header_start[3]; 00413 int header_len[3]; 00414 int first_header_size; 00415 int j; 00416 00417 if (codec->codec_id == CODEC_ID_VORBIS) 00418 first_header_size = 30; 00419 else 00420 first_header_size = 42; 00421 00422 if (ff_split_xiph_headers(codec->extradata, codec->extradata_size, 00423 first_header_size, header_start, header_len) < 0) { 00424 av_log(s, AV_LOG_ERROR, "Extradata corrupt.\n"); 00425 return -1; 00426 } 00427 00428 avio_w8(pb, 2); // number packets - 1 00429 for (j = 0; j < 2; j++) { 00430 put_xiph_size(pb, header_len[j]); 00431 } 00432 for (j = 0; j < 3; j++) 00433 avio_write(pb, header_start[j], header_len[j]); 00434 00435 return 0; 00436 } 00437 00438 static void get_aac_sample_rates(AVFormatContext *s, AVCodecContext *codec, int *sample_rate, int *output_sample_rate) 00439 { 00440 MPEG4AudioConfig mp4ac; 00441 00442 if (ff_mpeg4audio_get_config(&mp4ac, codec->extradata, codec->extradata_size) < 0) { 00443 av_log(s, AV_LOG_WARNING, "Error parsing AAC extradata, unable to determine samplerate.\n"); 00444 return; 00445 } 00446 00447 *sample_rate = mp4ac.sample_rate; 00448 *output_sample_rate = mp4ac.ext_sample_rate; 00449 } 00450 00451 static int mkv_write_codecprivate(AVFormatContext *s, AVIOContext *pb, AVCodecContext *codec, int native_id, int qt_id) 00452 { 00453 AVIOContext *dyn_cp; 00454 uint8_t *codecpriv; 00455 int ret, codecpriv_size; 00456 00457 ret = avio_open_dyn_buf(&dyn_cp); 00458 if(ret < 0) 00459 return ret; 00460 00461 if (native_id) { 00462 if (codec->codec_id == CODEC_ID_VORBIS || codec->codec_id == CODEC_ID_THEORA) 00463 ret = put_xiph_codecpriv(s, dyn_cp, codec); 00464 else if (codec->codec_id == CODEC_ID_FLAC) 00465 ret = ff_flac_write_header(dyn_cp, codec, 1); 00466 else if (codec->codec_id == CODEC_ID_H264) 00467 ret = ff_isom_write_avcc(dyn_cp, codec->extradata, codec->extradata_size); 00468 else if (codec->extradata_size) 00469 avio_write(dyn_cp, codec->extradata, codec->extradata_size); 00470 } else if (codec->codec_type == AVMEDIA_TYPE_VIDEO) { 00471 if (qt_id) { 00472 if (!codec->codec_tag) 00473 codec->codec_tag = ff_codec_get_tag(codec_movvideo_tags, codec->codec_id); 00474 if (codec->extradata_size) 00475 avio_write(dyn_cp, codec->extradata, codec->extradata_size); 00476 } else { 00477 if (!codec->codec_tag) 00478 codec->codec_tag = ff_codec_get_tag(ff_codec_bmp_tags, codec->codec_id); 00479 if (!codec->codec_tag) { 00480 av_log(s, AV_LOG_ERROR, "No bmp codec ID found.\n"); 00481 ret = -1; 00482 } 00483 00484 ff_put_bmp_header(dyn_cp, codec, ff_codec_bmp_tags, 0); 00485 } 00486 00487 } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) { 00488 unsigned int tag; 00489 tag = ff_codec_get_tag(ff_codec_wav_tags, codec->codec_id); 00490 if (!tag) { 00491 av_log(s, AV_LOG_ERROR, "No wav codec ID found.\n"); 00492 ret = -1; 00493 } 00494 if (!codec->codec_tag) 00495 codec->codec_tag = tag; 00496 00497 ff_put_wav_header(dyn_cp, codec); 00498 } 00499 00500 codecpriv_size = avio_close_dyn_buf(dyn_cp, &codecpriv); 00501 if (codecpriv_size) 00502 put_ebml_binary(pb, MATROSKA_ID_CODECPRIVATE, codecpriv, codecpriv_size); 00503 av_free(codecpriv); 00504 return ret; 00505 } 00506 00507 static int mkv_write_tracks(AVFormatContext *s) 00508 { 00509 MatroskaMuxContext *mkv = s->priv_data; 00510 AVIOContext *pb = s->pb; 00511 ebml_master tracks; 00512 int i, j, ret; 00513 00514 ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_TRACKS, avio_tell(pb)); 00515 if (ret < 0) return ret; 00516 00517 tracks = start_ebml_master(pb, MATROSKA_ID_TRACKS, 0); 00518 for (i = 0; i < s->nb_streams; i++) { 00519 AVStream *st = s->streams[i]; 00520 AVCodecContext *codec = st->codec; 00521 ebml_master subinfo, track; 00522 int native_id = 0; 00523 int qt_id = 0; 00524 int bit_depth = av_get_bits_per_sample(codec->codec_id); 00525 int sample_rate = codec->sample_rate; 00526 int output_sample_rate = 0; 00527 AVDictionaryEntry *tag; 00528 00529 if (!bit_depth) 00530 bit_depth = av_get_bits_per_sample_fmt(codec->sample_fmt); 00531 00532 if (codec->codec_id == CODEC_ID_AAC) 00533 get_aac_sample_rates(s, codec, &sample_rate, &output_sample_rate); 00534 00535 track = start_ebml_master(pb, MATROSKA_ID_TRACKENTRY, 0); 00536 put_ebml_uint (pb, MATROSKA_ID_TRACKNUMBER , i + 1); 00537 put_ebml_uint (pb, MATROSKA_ID_TRACKUID , i + 1); 00538 put_ebml_uint (pb, MATROSKA_ID_TRACKFLAGLACING , 0); // no lacing (yet) 00539 00540 if ((tag = av_dict_get(st->metadata, "title", NULL, 0))) 00541 put_ebml_string(pb, MATROSKA_ID_TRACKNAME, tag->value); 00542 tag = av_dict_get(st->metadata, "language", NULL, 0); 00543 put_ebml_string(pb, MATROSKA_ID_TRACKLANGUAGE, tag ? tag->value:"und"); 00544 00545 if (st->disposition) 00546 put_ebml_uint(pb, MATROSKA_ID_TRACKFLAGDEFAULT, !!(st->disposition & AV_DISPOSITION_DEFAULT)); 00547 00548 // look for a codec ID string specific to mkv to use, 00549 // if none are found, use AVI codes 00550 for (j = 0; ff_mkv_codec_tags[j].id != CODEC_ID_NONE; j++) { 00551 if (ff_mkv_codec_tags[j].id == codec->codec_id) { 00552 put_ebml_string(pb, MATROSKA_ID_CODECID, ff_mkv_codec_tags[j].str); 00553 native_id = 1; 00554 break; 00555 } 00556 } 00557 00558 if (mkv->mode == MODE_WEBM && !(codec->codec_id == CODEC_ID_VP8 || 00559 codec->codec_id == CODEC_ID_VORBIS)) { 00560 av_log(s, AV_LOG_ERROR, 00561 "Only VP8 video and Vorbis audio are supported for WebM.\n"); 00562 return AVERROR(EINVAL); 00563 } 00564 00565 switch (codec->codec_type) { 00566 case AVMEDIA_TYPE_VIDEO: 00567 put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, MATROSKA_TRACK_TYPE_VIDEO); 00568 put_ebml_uint(pb, MATROSKA_ID_TRACKDEFAULTDURATION, av_q2d(codec->time_base)*1E9); 00569 00570 if (!native_id && 00571 ff_codec_get_tag(codec_movvideo_tags, codec->codec_id) && 00572 (!ff_codec_get_tag(ff_codec_bmp_tags, codec->codec_id) 00573 || codec->codec_id == CODEC_ID_SVQ1 00574 || codec->codec_id == CODEC_ID_SVQ3 00575 || codec->codec_id == CODEC_ID_CINEPAK)) 00576 qt_id = 1; 00577 00578 if (qt_id) 00579 put_ebml_string(pb, MATROSKA_ID_CODECID, "V_QUICKTIME"); 00580 else if (!native_id) { 00581 // if there is no mkv-specific codec ID, use VFW mode 00582 put_ebml_string(pb, MATROSKA_ID_CODECID, "V_MS/VFW/FOURCC"); 00583 mkv->tracks[i].write_dts = 1; 00584 } 00585 00586 subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKVIDEO, 0); 00587 // XXX: interlace flag? 00588 put_ebml_uint (pb, MATROSKA_ID_VIDEOPIXELWIDTH , codec->width); 00589 put_ebml_uint (pb, MATROSKA_ID_VIDEOPIXELHEIGHT, codec->height); 00590 if ((tag = av_dict_get(s->metadata, "stereo_mode", NULL, 0))) { 00591 uint8_t stereo_fmt = atoi(tag->value); 00592 int valid_fmt = 0; 00593 00594 switch (mkv->mode) { 00595 case MODE_WEBM: 00596 if (stereo_fmt <= MATROSKA_VIDEO_STEREOMODE_TYPE_TOP_BOTTOM 00597 || stereo_fmt == MATROSKA_VIDEO_STEREOMODE_TYPE_RIGHT_LEFT) 00598 valid_fmt = 1; 00599 break; 00600 case MODE_MATROSKAv2: 00601 if (stereo_fmt <= MATROSKA_VIDEO_STEREOMODE_TYPE_BOTH_EYES_BLOCK_RL) 00602 valid_fmt = 1; 00603 break; 00604 } 00605 00606 if (valid_fmt) 00607 put_ebml_uint (pb, MATROSKA_ID_VIDEOSTEREOMODE, stereo_fmt); 00608 } 00609 if (st->sample_aspect_ratio.num) { 00610 int d_width = codec->width*av_q2d(st->sample_aspect_ratio); 00611 put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH , d_width); 00612 put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, codec->height); 00613 put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYUNIT, 3); 00614 } 00615 end_ebml_master(pb, subinfo); 00616 break; 00617 00618 case AVMEDIA_TYPE_AUDIO: 00619 put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, MATROSKA_TRACK_TYPE_AUDIO); 00620 00621 if (!native_id) 00622 // no mkv-specific ID, use ACM mode 00623 put_ebml_string(pb, MATROSKA_ID_CODECID, "A_MS/ACM"); 00624 00625 subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKAUDIO, 0); 00626 put_ebml_uint (pb, MATROSKA_ID_AUDIOCHANNELS , codec->channels); 00627 put_ebml_float (pb, MATROSKA_ID_AUDIOSAMPLINGFREQ, sample_rate); 00628 if (output_sample_rate) 00629 put_ebml_float(pb, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate); 00630 if (bit_depth) 00631 put_ebml_uint(pb, MATROSKA_ID_AUDIOBITDEPTH, bit_depth); 00632 end_ebml_master(pb, subinfo); 00633 break; 00634 00635 case AVMEDIA_TYPE_SUBTITLE: 00636 put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, MATROSKA_TRACK_TYPE_SUBTITLE); 00637 if (!native_id) { 00638 av_log(s, AV_LOG_ERROR, "Subtitle codec %d is not supported.\n", codec->codec_id); 00639 return AVERROR(ENOSYS); 00640 } 00641 break; 00642 default: 00643 av_log(s, AV_LOG_ERROR, "Only audio, video, and subtitles are supported for Matroska.\n"); 00644 break; 00645 } 00646 ret = mkv_write_codecprivate(s, pb, codec, native_id, qt_id); 00647 if (ret < 0) return ret; 00648 00649 end_ebml_master(pb, track); 00650 00651 // ms precision is the de-facto standard timescale for mkv files 00652 av_set_pts_info(st, 64, 1, 1000); 00653 } 00654 end_ebml_master(pb, tracks); 00655 return 0; 00656 } 00657 00658 static int mkv_write_chapters(AVFormatContext *s) 00659 { 00660 MatroskaMuxContext *mkv = s->priv_data; 00661 AVIOContext *pb = s->pb; 00662 ebml_master chapters, editionentry; 00663 AVRational scale = {1, 1E9}; 00664 int i, ret; 00665 00666 if (!s->nb_chapters) 00667 return 0; 00668 00669 ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_CHAPTERS, avio_tell(pb)); 00670 if (ret < 0) return ret; 00671 00672 chapters = start_ebml_master(pb, MATROSKA_ID_CHAPTERS , 0); 00673 editionentry = start_ebml_master(pb, MATROSKA_ID_EDITIONENTRY, 0); 00674 put_ebml_uint(pb, MATROSKA_ID_EDITIONFLAGDEFAULT, 1); 00675 put_ebml_uint(pb, MATROSKA_ID_EDITIONFLAGHIDDEN , 0); 00676 for (i = 0; i < s->nb_chapters; i++) { 00677 ebml_master chapteratom, chapterdisplay; 00678 AVChapter *c = s->chapters[i]; 00679 AVDictionaryEntry *t = NULL; 00680 00681 chapteratom = start_ebml_master(pb, MATROSKA_ID_CHAPTERATOM, 0); 00682 put_ebml_uint(pb, MATROSKA_ID_CHAPTERUID, c->id); 00683 put_ebml_uint(pb, MATROSKA_ID_CHAPTERTIMESTART, 00684 av_rescale_q(c->start, c->time_base, scale)); 00685 put_ebml_uint(pb, MATROSKA_ID_CHAPTERTIMEEND, 00686 av_rescale_q(c->end, c->time_base, scale)); 00687 put_ebml_uint(pb, MATROSKA_ID_CHAPTERFLAGHIDDEN , 0); 00688 put_ebml_uint(pb, MATROSKA_ID_CHAPTERFLAGENABLED, 1); 00689 if ((t = av_dict_get(c->metadata, "title", NULL, 0))) { 00690 chapterdisplay = start_ebml_master(pb, MATROSKA_ID_CHAPTERDISPLAY, 0); 00691 put_ebml_string(pb, MATROSKA_ID_CHAPSTRING, t->value); 00692 put_ebml_string(pb, MATROSKA_ID_CHAPLANG , "und"); 00693 end_ebml_master(pb, chapterdisplay); 00694 } 00695 end_ebml_master(pb, chapteratom); 00696 } 00697 end_ebml_master(pb, editionentry); 00698 end_ebml_master(pb, chapters); 00699 return 0; 00700 } 00701 00702 static void mkv_write_simpletag(AVIOContext *pb, AVDictionaryEntry *t) 00703 { 00704 uint8_t *key = av_strdup(t->key); 00705 uint8_t *p = key; 00706 const uint8_t *lang = NULL; 00707 ebml_master tag; 00708 00709 if ((p = strrchr(p, '-')) && 00710 (lang = av_convert_lang_to(p + 1, AV_LANG_ISO639_2_BIBL))) 00711 *p = 0; 00712 00713 p = key; 00714 while (*p) { 00715 if (*p == ' ') 00716 *p = '_'; 00717 else if (*p >= 'a' && *p <= 'z') 00718 *p -= 'a' - 'A'; 00719 p++; 00720 } 00721 00722 tag = start_ebml_master(pb, MATROSKA_ID_SIMPLETAG, 0); 00723 put_ebml_string(pb, MATROSKA_ID_TAGNAME, key); 00724 if (lang) 00725 put_ebml_string(pb, MATROSKA_ID_TAGLANG, lang); 00726 put_ebml_string(pb, MATROSKA_ID_TAGSTRING, t->value); 00727 end_ebml_master(pb, tag); 00728 00729 av_freep(&key); 00730 } 00731 00732 static int mkv_write_tag(AVFormatContext *s, AVDictionary *m, unsigned int elementid, 00733 unsigned int uid, ebml_master *tags) 00734 { 00735 MatroskaMuxContext *mkv = s->priv_data; 00736 ebml_master tag, targets; 00737 AVDictionaryEntry *t = NULL; 00738 int ret; 00739 00740 if (!tags->pos) { 00741 ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_TAGS, avio_tell(s->pb)); 00742 if (ret < 0) return ret; 00743 00744 *tags = start_ebml_master(s->pb, MATROSKA_ID_TAGS, 0); 00745 } 00746 00747 tag = start_ebml_master(s->pb, MATROSKA_ID_TAG, 0); 00748 targets = start_ebml_master(s->pb, MATROSKA_ID_TAGTARGETS, 0); 00749 if (elementid) 00750 put_ebml_uint(s->pb, elementid, uid); 00751 end_ebml_master(s->pb, targets); 00752 00753 while ((t = av_dict_get(m, "", t, AV_DICT_IGNORE_SUFFIX))) 00754 if (strcasecmp(t->key, "title")) 00755 mkv_write_simpletag(s->pb, t); 00756 00757 end_ebml_master(s->pb, tag); 00758 return 0; 00759 } 00760 00761 static int mkv_write_tags(AVFormatContext *s) 00762 { 00763 ebml_master tags = {0}; 00764 int i, ret; 00765 00766 ff_metadata_conv_ctx(s, ff_mkv_metadata_conv, NULL); 00767 00768 if (av_dict_get(s->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX)) { 00769 ret = mkv_write_tag(s, s->metadata, 0, 0, &tags); 00770 if (ret < 0) return ret; 00771 } 00772 00773 for (i = 0; i < s->nb_streams; i++) { 00774 AVStream *st = s->streams[i]; 00775 00776 if (!av_dict_get(st->metadata, "", 0, AV_DICT_IGNORE_SUFFIX)) 00777 continue; 00778 00779 ret = mkv_write_tag(s, st->metadata, MATROSKA_ID_TAGTARGETS_TRACKUID, i + 1, &tags); 00780 if (ret < 0) return ret; 00781 } 00782 00783 for (i = 0; i < s->nb_chapters; i++) { 00784 AVChapter *ch = s->chapters[i]; 00785 00786 if (!av_dict_get(ch->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX)) 00787 continue; 00788 00789 ret = mkv_write_tag(s, ch->metadata, MATROSKA_ID_TAGTARGETS_CHAPTERUID, ch->id, &tags); 00790 if (ret < 0) return ret; 00791 } 00792 00793 if (tags.pos) 00794 end_ebml_master(s->pb, tags); 00795 return 0; 00796 } 00797 00798 static int mkv_write_header(AVFormatContext *s) 00799 { 00800 MatroskaMuxContext *mkv = s->priv_data; 00801 AVIOContext *pb = s->pb; 00802 ebml_master ebml_header, segment_info; 00803 AVDictionaryEntry *tag; 00804 int ret, i; 00805 00806 if (!strcmp(s->oformat->name, "webm")) mkv->mode = MODE_WEBM; 00807 else mkv->mode = MODE_MATROSKAv2; 00808 00809 mkv->tracks = av_mallocz(s->nb_streams * sizeof(*mkv->tracks)); 00810 if (!mkv->tracks) 00811 return AVERROR(ENOMEM); 00812 00813 ebml_header = start_ebml_master(pb, EBML_ID_HEADER, 0); 00814 put_ebml_uint (pb, EBML_ID_EBMLVERSION , 1); 00815 put_ebml_uint (pb, EBML_ID_EBMLREADVERSION , 1); 00816 put_ebml_uint (pb, EBML_ID_EBMLMAXIDLENGTH , 4); 00817 put_ebml_uint (pb, EBML_ID_EBMLMAXSIZELENGTH , 8); 00818 put_ebml_string (pb, EBML_ID_DOCTYPE , s->oformat->name); 00819 put_ebml_uint (pb, EBML_ID_DOCTYPEVERSION , 2); 00820 put_ebml_uint (pb, EBML_ID_DOCTYPEREADVERSION , 2); 00821 end_ebml_master(pb, ebml_header); 00822 00823 mkv->segment = start_ebml_master(pb, MATROSKA_ID_SEGMENT, 0); 00824 mkv->segment_offset = avio_tell(pb); 00825 00826 // we write 2 seek heads - one at the end of the file to point to each 00827 // cluster, and one at the beginning to point to all other level one 00828 // elements (including the seek head at the end of the file), which 00829 // isn't more than 10 elements if we only write one of each other 00830 // currently defined level 1 element 00831 mkv->main_seekhead = mkv_start_seekhead(pb, mkv->segment_offset, 10); 00832 if (!mkv->main_seekhead) 00833 return AVERROR(ENOMEM); 00834 00835 ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_INFO, avio_tell(pb)); 00836 if (ret < 0) return ret; 00837 00838 segment_info = start_ebml_master(pb, MATROSKA_ID_INFO, 0); 00839 put_ebml_uint(pb, MATROSKA_ID_TIMECODESCALE, 1000000); 00840 if ((tag = av_dict_get(s->metadata, "title", NULL, 0))) 00841 put_ebml_string(pb, MATROSKA_ID_TITLE, tag->value); 00842 if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) { 00843 uint32_t segment_uid[4]; 00844 AVLFG lfg; 00845 00846 av_lfg_init(&lfg, av_get_random_seed()); 00847 00848 for (i = 0; i < 4; i++) 00849 segment_uid[i] = av_lfg_get(&lfg); 00850 00851 put_ebml_string(pb, MATROSKA_ID_MUXINGAPP , LIBAVFORMAT_IDENT); 00852 put_ebml_string(pb, MATROSKA_ID_WRITINGAPP, LIBAVFORMAT_IDENT); 00853 put_ebml_binary(pb, MATROSKA_ID_SEGMENTUID, segment_uid, 16); 00854 } 00855 00856 // reserve space for the duration 00857 mkv->duration = 0; 00858 mkv->duration_offset = avio_tell(pb); 00859 put_ebml_void(pb, 11); // assumes double-precision float to be written 00860 end_ebml_master(pb, segment_info); 00861 00862 ret = mkv_write_tracks(s); 00863 if (ret < 0) return ret; 00864 00865 if (mkv->mode != MODE_WEBM) { 00866 ret = mkv_write_chapters(s); 00867 if (ret < 0) return ret; 00868 00869 ret = mkv_write_tags(s); 00870 if (ret < 0) return ret; 00871 } 00872 00873 if (!s->pb->seekable) 00874 mkv_write_seekhead(pb, mkv->main_seekhead); 00875 00876 mkv->cues = mkv_start_cues(mkv->segment_offset); 00877 if (mkv->cues == NULL) 00878 return AVERROR(ENOMEM); 00879 00880 av_init_packet(&mkv->cur_audio_pkt); 00881 mkv->cur_audio_pkt.size = 0; 00882 mkv->audio_buffer_size = 0; 00883 00884 avio_flush(pb); 00885 return 0; 00886 } 00887 00888 static int mkv_blockgroup_size(int pkt_size) 00889 { 00890 int size = pkt_size + 4; 00891 size += ebml_num_size(size); 00892 size += 2; // EBML ID for block and block duration 00893 size += 8; // max size of block duration 00894 size += ebml_num_size(size); 00895 size += 1; // blockgroup EBML ID 00896 return size; 00897 } 00898 00899 static int ass_get_duration(const uint8_t *p) 00900 { 00901 int sh, sm, ss, sc, eh, em, es, ec; 00902 uint64_t start, end; 00903 00904 if (sscanf(p, "%*[^,],%d:%d:%d%*c%d,%d:%d:%d%*c%d", 00905 &sh, &sm, &ss, &sc, &eh, &em, &es, &ec) != 8) 00906 return 0; 00907 start = 3600000*sh + 60000*sm + 1000*ss + 10*sc; 00908 end = 3600000*eh + 60000*em + 1000*es + 10*ec; 00909 return end - start; 00910 } 00911 00912 static int mkv_write_ass_blocks(AVFormatContext *s, AVIOContext *pb, AVPacket *pkt) 00913 { 00914 MatroskaMuxContext *mkv = s->priv_data; 00915 int i, layer = 0, max_duration = 0, size, line_size, data_size = pkt->size; 00916 uint8_t *start, *end, *data = pkt->data; 00917 ebml_master blockgroup; 00918 char buffer[2048]; 00919 00920 while (data_size) { 00921 int duration = ass_get_duration(data); 00922 max_duration = FFMAX(duration, max_duration); 00923 end = memchr(data, '\n', data_size); 00924 size = line_size = end ? end-data+1 : data_size; 00925 size -= end ? (end[-1]=='\r')+1 : 0; 00926 start = data; 00927 for (i=0; i<3; i++, start++) 00928 if (!(start = memchr(start, ',', size-(start-data)))) 00929 return max_duration; 00930 size -= start - data; 00931 sscanf(data, "Dialogue: %d,", &layer); 00932 i = snprintf(buffer, sizeof(buffer), "%"PRId64",%d,", 00933 s->streams[pkt->stream_index]->nb_frames++, layer); 00934 size = FFMIN(i+size, sizeof(buffer)); 00935 memcpy(buffer+i, start, size-i); 00936 00937 av_log(s, AV_LOG_DEBUG, "Writing block at offset %" PRIu64 ", size %d, " 00938 "pts %" PRId64 ", duration %d\n", 00939 avio_tell(pb), size, pkt->pts, duration); 00940 blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, mkv_blockgroup_size(size)); 00941 put_ebml_id(pb, MATROSKA_ID_BLOCK); 00942 put_ebml_num(pb, size+4, 0); 00943 avio_w8(pb, 0x80 | (pkt->stream_index + 1)); // this assumes stream_index is less than 126 00944 avio_wb16(pb, pkt->pts - mkv->cluster_pts); 00945 avio_w8(pb, 0); 00946 avio_write(pb, buffer, size); 00947 put_ebml_uint(pb, MATROSKA_ID_BLOCKDURATION, duration); 00948 end_ebml_master(pb, blockgroup); 00949 00950 data += line_size; 00951 data_size -= line_size; 00952 } 00953 00954 return max_duration; 00955 } 00956 00957 static void mkv_write_block(AVFormatContext *s, AVIOContext *pb, 00958 unsigned int blockid, AVPacket *pkt, int flags) 00959 { 00960 MatroskaMuxContext *mkv = s->priv_data; 00961 AVCodecContext *codec = s->streams[pkt->stream_index]->codec; 00962 uint8_t *data = NULL; 00963 int size = pkt->size; 00964 int64_t ts = mkv->tracks[pkt->stream_index].write_dts ? pkt->dts : pkt->pts; 00965 00966 av_log(s, AV_LOG_DEBUG, "Writing block at offset %" PRIu64 ", size %d, " 00967 "pts %" PRId64 ", dts %" PRId64 ", duration %d, flags %d\n", 00968 avio_tell(pb), pkt->size, pkt->pts, pkt->dts, pkt->duration, flags); 00969 if (codec->codec_id == CODEC_ID_H264 && codec->extradata_size > 0 && 00970 (AV_RB24(codec->extradata) == 1 || AV_RB32(codec->extradata) == 1)) 00971 ff_avc_parse_nal_units_buf(pkt->data, &data, &size); 00972 else 00973 data = pkt->data; 00974 put_ebml_id(pb, blockid); 00975 put_ebml_num(pb, size+4, 0); 00976 avio_w8(pb, 0x80 | (pkt->stream_index + 1)); // this assumes stream_index is less than 126 00977 avio_wb16(pb, ts - mkv->cluster_pts); 00978 avio_w8(pb, flags); 00979 avio_write(pb, data, size); 00980 if (data != pkt->data) 00981 av_free(data); 00982 } 00983 00984 static int srt_get_duration(uint8_t **buf) 00985 { 00986 int i, duration = 0; 00987 00988 for (i=0; i<2 && !duration; i++) { 00989 int s_hour, s_min, s_sec, s_hsec, e_hour, e_min, e_sec, e_hsec; 00990 if (sscanf(*buf, "%d:%2d:%2d%*1[,.]%3d --> %d:%2d:%2d%*1[,.]%3d", 00991 &s_hour, &s_min, &s_sec, &s_hsec, 00992 &e_hour, &e_min, &e_sec, &e_hsec) == 8) { 00993 s_min += 60*s_hour; e_min += 60*e_hour; 00994 s_sec += 60*s_min; e_sec += 60*e_min; 00995 s_hsec += 1000*s_sec; e_hsec += 1000*e_sec; 00996 duration = e_hsec - s_hsec; 00997 } 00998 *buf += strcspn(*buf, "\n") + 1; 00999 } 01000 return duration; 01001 } 01002 01003 static int mkv_write_srt_blocks(AVFormatContext *s, AVIOContext *pb, AVPacket *pkt) 01004 { 01005 ebml_master blockgroup; 01006 AVPacket pkt2 = *pkt; 01007 int64_t duration = srt_get_duration(&pkt2.data); 01008 pkt2.size -= pkt2.data - pkt->data; 01009 01010 blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, 01011 mkv_blockgroup_size(pkt2.size)); 01012 mkv_write_block(s, pb, MATROSKA_ID_BLOCK, &pkt2, 0); 01013 put_ebml_uint(pb, MATROSKA_ID_BLOCKDURATION, duration); 01014 end_ebml_master(pb, blockgroup); 01015 01016 return duration; 01017 } 01018 01019 static void mkv_flush_dynbuf(AVFormatContext *s) 01020 { 01021 MatroskaMuxContext *mkv = s->priv_data; 01022 int bufsize; 01023 uint8_t *dyn_buf; 01024 01025 if (!mkv->dyn_bc) 01026 return; 01027 01028 bufsize = avio_close_dyn_buf(mkv->dyn_bc, &dyn_buf); 01029 avio_write(s->pb, dyn_buf, bufsize); 01030 av_free(dyn_buf); 01031 mkv->dyn_bc = NULL; 01032 } 01033 01034 static int mkv_write_packet_internal(AVFormatContext *s, AVPacket *pkt) 01035 { 01036 MatroskaMuxContext *mkv = s->priv_data; 01037 AVIOContext *pb = s->pb; 01038 AVCodecContext *codec = s->streams[pkt->stream_index]->codec; 01039 int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY); 01040 int duration = pkt->duration; 01041 int ret; 01042 int64_t ts = mkv->tracks[pkt->stream_index].write_dts ? pkt->dts : pkt->pts; 01043 01044 if (ts == AV_NOPTS_VALUE) { 01045 av_log(s, AV_LOG_ERROR, "Can't write packet with unknown timestamp\n"); 01046 return AVERROR(EINVAL); 01047 } 01048 01049 if (!s->pb->seekable) { 01050 if (!mkv->dyn_bc) 01051 avio_open_dyn_buf(&mkv->dyn_bc); 01052 pb = mkv->dyn_bc; 01053 } 01054 01055 if (!mkv->cluster_pos) { 01056 mkv->cluster_pos = avio_tell(s->pb); 01057 mkv->cluster = start_ebml_master(pb, MATROSKA_ID_CLUSTER, 0); 01058 put_ebml_uint(pb, MATROSKA_ID_CLUSTERTIMECODE, FFMAX(0, ts)); 01059 mkv->cluster_pts = FFMAX(0, ts); 01060 } 01061 01062 if (codec->codec_type != AVMEDIA_TYPE_SUBTITLE) { 01063 mkv_write_block(s, pb, MATROSKA_ID_SIMPLEBLOCK, pkt, keyframe << 7); 01064 } else if (codec->codec_id == CODEC_ID_SSA) { 01065 duration = mkv_write_ass_blocks(s, pb, pkt); 01066 } else if (codec->codec_id == CODEC_ID_SRT) { 01067 duration = mkv_write_srt_blocks(s, pb, pkt); 01068 } else { 01069 ebml_master blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, mkv_blockgroup_size(pkt->size)); 01070 duration = pkt->convergence_duration; 01071 mkv_write_block(s, pb, MATROSKA_ID_BLOCK, pkt, 0); 01072 put_ebml_uint(pb, MATROSKA_ID_BLOCKDURATION, duration); 01073 end_ebml_master(pb, blockgroup); 01074 } 01075 01076 if (codec->codec_type == AVMEDIA_TYPE_VIDEO && keyframe) { 01077 ret = mkv_add_cuepoint(mkv->cues, pkt->stream_index, ts, mkv->cluster_pos); 01078 if (ret < 0) return ret; 01079 } 01080 01081 mkv->duration = FFMAX(mkv->duration, ts + duration); 01082 return 0; 01083 } 01084 01085 static int mkv_copy_packet(MatroskaMuxContext *mkv, const AVPacket *pkt) 01086 { 01087 uint8_t *data = mkv->cur_audio_pkt.data; 01088 mkv->cur_audio_pkt = *pkt; 01089 mkv->cur_audio_pkt.data = av_fast_realloc(data, &mkv->audio_buffer_size, pkt->size); 01090 if (!mkv->cur_audio_pkt.data) 01091 return AVERROR(ENOMEM); 01092 01093 memcpy(mkv->cur_audio_pkt.data, pkt->data, pkt->size); 01094 mkv->cur_audio_pkt.size = pkt->size; 01095 return 0; 01096 } 01097 01098 static int mkv_write_packet(AVFormatContext *s, AVPacket *pkt) 01099 { 01100 MatroskaMuxContext *mkv = s->priv_data; 01101 AVIOContext *pb = s->pb->seekable ? s->pb : mkv->dyn_bc; 01102 AVCodecContext *codec = s->streams[pkt->stream_index]->codec; 01103 int ret, keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY); 01104 int64_t ts = mkv->tracks[pkt->stream_index].write_dts ? pkt->dts : pkt->pts; 01105 int cluster_size = avio_tell(pb) - (s->pb->seekable ? mkv->cluster_pos : 0); 01106 01107 // start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or 01108 // after 4k and on a keyframe 01109 if (mkv->cluster_pos && 01110 ((!s->pb->seekable && (cluster_size > 32*1024 || ts > mkv->cluster_pts + 1000)) 01111 || cluster_size > 5*1024*1024 || ts > mkv->cluster_pts + 5000 01112 || (codec->codec_type == AVMEDIA_TYPE_VIDEO && keyframe && cluster_size > 4*1024))) { 01113 av_log(s, AV_LOG_DEBUG, "Starting new cluster at offset %" PRIu64 01114 " bytes, pts %" PRIu64 "\n", avio_tell(pb), ts); 01115 end_ebml_master(pb, mkv->cluster); 01116 mkv->cluster_pos = 0; 01117 if (mkv->dyn_bc) 01118 mkv_flush_dynbuf(s); 01119 } 01120 01121 // check if we have an audio packet cached 01122 if (mkv->cur_audio_pkt.size > 0) { 01123 ret = mkv_write_packet_internal(s, &mkv->cur_audio_pkt); 01124 mkv->cur_audio_pkt.size = 0; 01125 if (ret < 0) { 01126 av_log(s, AV_LOG_ERROR, "Could not write cached audio packet ret:%d\n", ret); 01127 return ret; 01128 } 01129 } 01130 01131 // buffer an audio packet to ensure the packet containing the video 01132 // keyframe's timecode is contained in the same cluster for WebM 01133 if (codec->codec_type == AVMEDIA_TYPE_AUDIO) 01134 ret = mkv_copy_packet(mkv, pkt); 01135 else 01136 ret = mkv_write_packet_internal(s, pkt); 01137 return ret; 01138 } 01139 01140 static int mkv_write_trailer(AVFormatContext *s) 01141 { 01142 MatroskaMuxContext *mkv = s->priv_data; 01143 AVIOContext *pb = s->pb; 01144 int64_t currentpos, cuespos; 01145 int ret; 01146 01147 // check if we have an audio packet cached 01148 if (mkv->cur_audio_pkt.size > 0) { 01149 ret = mkv_write_packet_internal(s, &mkv->cur_audio_pkt); 01150 mkv->cur_audio_pkt.size = 0; 01151 if (ret < 0) { 01152 av_log(s, AV_LOG_ERROR, "Could not write cached audio packet ret:%d\n", ret); 01153 return ret; 01154 } 01155 } 01156 01157 if (mkv->dyn_bc) { 01158 end_ebml_master(mkv->dyn_bc, mkv->cluster); 01159 mkv_flush_dynbuf(s); 01160 } else if (mkv->cluster_pos) { 01161 end_ebml_master(pb, mkv->cluster); 01162 } 01163 01164 if (pb->seekable) { 01165 if (mkv->cues->num_entries) { 01166 cuespos = mkv_write_cues(pb, mkv->cues, s->nb_streams); 01167 01168 ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_CUES, cuespos); 01169 if (ret < 0) return ret; 01170 } 01171 01172 mkv_write_seekhead(pb, mkv->main_seekhead); 01173 01174 // update the duration 01175 av_log(s, AV_LOG_DEBUG, "end duration = %" PRIu64 "\n", mkv->duration); 01176 currentpos = avio_tell(pb); 01177 avio_seek(pb, mkv->duration_offset, SEEK_SET); 01178 put_ebml_float(pb, MATROSKA_ID_DURATION, mkv->duration); 01179 01180 avio_seek(pb, currentpos, SEEK_SET); 01181 } 01182 01183 end_ebml_master(pb, mkv->segment); 01184 av_free(mkv->tracks); 01185 av_freep(&mkv->cues->entries); 01186 av_freep(&mkv->cues); 01187 av_destruct_packet(&mkv->cur_audio_pkt); 01188 avio_flush(pb); 01189 return 0; 01190 } 01191 01192 #if CONFIG_MATROSKA_MUXER 01193 AVOutputFormat ff_matroska_muxer = { 01194 "matroska", 01195 NULL_IF_CONFIG_SMALL("Matroska file format"), 01196 "video/x-matroska", 01197 "mkv", 01198 sizeof(MatroskaMuxContext), 01199 CODEC_ID_MP2, 01200 CODEC_ID_MPEG4, 01201 mkv_write_header, 01202 mkv_write_packet, 01203 mkv_write_trailer, 01204 .flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS, 01205 .codec_tag = (const AVCodecTag* const []){ff_codec_bmp_tags, ff_codec_wav_tags, 0}, 01206 .subtitle_codec = CODEC_ID_TEXT, 01207 }; 01208 #endif 01209 01210 #if CONFIG_WEBM_MUXER 01211 AVOutputFormat ff_webm_muxer = { 01212 "webm", 01213 NULL_IF_CONFIG_SMALL("WebM file format"), 01214 "video/webm", 01215 "webm", 01216 sizeof(MatroskaMuxContext), 01217 CODEC_ID_VORBIS, 01218 CODEC_ID_VP8, 01219 mkv_write_header, 01220 mkv_write_packet, 01221 mkv_write_trailer, 01222 .flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS, 01223 }; 01224 #endif 01225 01226 #if CONFIG_MATROSKA_AUDIO_MUXER 01227 AVOutputFormat ff_matroska_audio_muxer = { 01228 "matroska", 01229 NULL_IF_CONFIG_SMALL("Matroska file format"), 01230 "audio/x-matroska", 01231 "mka", 01232 sizeof(MatroskaMuxContext), 01233 CODEC_ID_MP2, 01234 CODEC_ID_NONE, 01235 mkv_write_header, 01236 mkv_write_packet, 01237 mkv_write_trailer, 01238 .flags = AVFMT_GLOBALHEADER, 01239 .codec_tag = (const AVCodecTag* const []){ff_codec_wav_tags, 0}, 01240 }; 01241 #endif