00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
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 "libavutil/intreadwrite.h"
00029 #include "libavutil/md5.h"
00030 #include "libavcodec/xiph.h"
00031 #include "libavcodec/mpeg4audio.h"
00032
00033 typedef struct ebml_master {
00034 int64_t pos;
00035 int sizebytes;
00036 } ebml_master;
00037
00038 typedef struct mkv_seekhead_entry {
00039 unsigned int elementid;
00040 uint64_t segmentpos;
00041 } mkv_seekhead_entry;
00042
00043 typedef struct mkv_seekhead {
00044 int64_t filepos;
00045 int64_t segment_offset;
00046 int reserved_size;
00047 int max_entries;
00048 mkv_seekhead_entry *entries;
00049 int num_entries;
00050 } mkv_seekhead;
00051
00052 typedef struct {
00053 uint64_t pts;
00054 int tracknum;
00055 int64_t cluster_pos;
00056 } mkv_cuepoint;
00057
00058 typedef struct {
00059 int64_t segment_offset;
00060 mkv_cuepoint *entries;
00061 int num_entries;
00062 } mkv_cues;
00063
00064 typedef struct {
00065 int write_dts;
00066 } mkv_track;
00067
00068 typedef struct MatroskaMuxContext {
00069 ByteIOContext *dyn_bc;
00070 ebml_master segment;
00071 int64_t segment_offset;
00072 int64_t segment_uid;
00073 ebml_master cluster;
00074 int64_t cluster_pos;
00075 int64_t cluster_pts;
00076 int64_t duration_offset;
00077 int64_t duration;
00078 mkv_seekhead *main_seekhead;
00079 mkv_seekhead *cluster_seekhead;
00080 mkv_cues *cues;
00081 mkv_track *tracks;
00082
00083 struct AVMD5 *md5_ctx;
00084 } MatroskaMuxContext;
00085
00086
00089 #define MAX_SEEKENTRY_SIZE 21
00090
00093 #define MAX_CUETRACKPOS_SIZE 22
00094
00096 #define MAX_CUEPOINT_SIZE(num_tracks) 12 + MAX_CUETRACKPOS_SIZE*num_tracks
00097
00098
00099 static int ebml_id_size(unsigned int id)
00100 {
00101 return (av_log2(id+1)-1)/7+1;
00102 }
00103
00104 static void put_ebml_id(ByteIOContext *pb, unsigned int id)
00105 {
00106 int i = ebml_id_size(id);
00107 while (i--)
00108 put_byte(pb, id >> (i*8));
00109 }
00110
00116 static void put_ebml_size_unknown(ByteIOContext *pb, int bytes)
00117 {
00118 assert(bytes <= 8);
00119 put_byte(pb, 0x1ff >> bytes);
00120 while (--bytes)
00121 put_byte(pb, 0xff);
00122 }
00123
00127 static int ebml_num_size(uint64_t num)
00128 {
00129 int bytes = 1;
00130 while ((num+1) >> bytes*7) bytes++;
00131 return bytes;
00132 }
00133
00140 static void put_ebml_num(ByteIOContext *pb, uint64_t num, int bytes)
00141 {
00142 int i, needed_bytes = ebml_num_size(num);
00143
00144
00145 assert(num < (1ULL<<56)-1);
00146
00147 if (bytes == 0)
00148
00149 bytes = needed_bytes;
00150
00151
00152 assert(bytes >= needed_bytes);
00153
00154 num |= 1ULL << bytes*7;
00155 for (i = bytes - 1; i >= 0; i--)
00156 put_byte(pb, num >> i*8);
00157 }
00158
00159 static void put_ebml_uint(ByteIOContext *pb, unsigned int elementid, uint64_t val)
00160 {
00161 int i, bytes = 1;
00162 uint64_t tmp = val;
00163 while (tmp>>=8) bytes++;
00164
00165 put_ebml_id(pb, elementid);
00166 put_ebml_num(pb, bytes, 0);
00167 for (i = bytes - 1; i >= 0; i--)
00168 put_byte(pb, val >> i*8);
00169 }
00170
00171 static void put_ebml_float(ByteIOContext *pb, unsigned int elementid, double val)
00172 {
00173 put_ebml_id(pb, elementid);
00174 put_ebml_num(pb, 8, 0);
00175 put_be64(pb, av_dbl2int(val));
00176 }
00177
00178 static void put_ebml_binary(ByteIOContext *pb, unsigned int elementid,
00179 const uint8_t *buf, int size)
00180 {
00181 put_ebml_id(pb, elementid);
00182 put_ebml_num(pb, size, 0);
00183 put_buffer(pb, buf, size);
00184 }
00185
00186 static void put_ebml_string(ByteIOContext *pb, unsigned int elementid, const char *str)
00187 {
00188 put_ebml_binary(pb, elementid, str, strlen(str));
00189 }
00190
00197 static void put_ebml_void(ByteIOContext *pb, uint64_t size)
00198 {
00199 int64_t currentpos = url_ftell(pb);
00200
00201 assert(size >= 2);
00202
00203 put_ebml_id(pb, EBML_ID_VOID);
00204
00205
00206
00207 if (size < 10)
00208 put_ebml_num(pb, size-1, 0);
00209 else
00210 put_ebml_num(pb, size-9, 8);
00211 while(url_ftell(pb) < currentpos + size)
00212 put_byte(pb, 0);
00213 }
00214
00215 static ebml_master start_ebml_master(ByteIOContext *pb, unsigned int elementid, uint64_t expectedsize)
00216 {
00217 int bytes = expectedsize ? ebml_num_size(expectedsize) : 8;
00218 put_ebml_id(pb, elementid);
00219 put_ebml_size_unknown(pb, bytes);
00220 return (ebml_master){ url_ftell(pb), bytes };
00221 }
00222
00223 static void end_ebml_master(ByteIOContext *pb, ebml_master master)
00224 {
00225 int64_t pos = url_ftell(pb);
00226
00227 if (url_fseek(pb, master.pos - master.sizebytes, SEEK_SET) < 0)
00228 return;
00229 put_ebml_num(pb, pos - master.pos, master.sizebytes);
00230 url_fseek(pb, pos, SEEK_SET);
00231 }
00232
00233 static void put_xiph_size(ByteIOContext *pb, int size)
00234 {
00235 int i;
00236 for (i = 0; i < size / 255; i++)
00237 put_byte(pb, 255);
00238 put_byte(pb, size % 255);
00239 }
00240
00252 static mkv_seekhead * mkv_start_seekhead(ByteIOContext *pb, int64_t segment_offset, int numelements)
00253 {
00254 mkv_seekhead *new_seekhead = av_mallocz(sizeof(mkv_seekhead));
00255 if (new_seekhead == NULL)
00256 return NULL;
00257
00258 new_seekhead->segment_offset = segment_offset;
00259
00260 if (numelements > 0) {
00261 new_seekhead->filepos = url_ftell(pb);
00262
00263
00264
00265 new_seekhead->reserved_size = numelements * MAX_SEEKENTRY_SIZE + 13;
00266 new_seekhead->max_entries = numelements;
00267 put_ebml_void(pb, new_seekhead->reserved_size);
00268 }
00269 return new_seekhead;
00270 }
00271
00272 static int mkv_add_seekhead_entry(mkv_seekhead *seekhead, unsigned int elementid, uint64_t filepos)
00273 {
00274 mkv_seekhead_entry *entries = seekhead->entries;
00275
00276
00277 if (seekhead->max_entries > 0 && seekhead->max_entries <= seekhead->num_entries)
00278 return -1;
00279
00280 entries = av_realloc(entries, (seekhead->num_entries + 1) * sizeof(mkv_seekhead_entry));
00281 if (entries == NULL)
00282 return AVERROR(ENOMEM);
00283
00284 entries[seekhead->num_entries ].elementid = elementid;
00285 entries[seekhead->num_entries++].segmentpos = filepos - seekhead->segment_offset;
00286
00287 seekhead->entries = entries;
00288 return 0;
00289 }
00290
00300 static int64_t mkv_write_seekhead(ByteIOContext *pb, mkv_seekhead *seekhead)
00301 {
00302 ebml_master metaseek, seekentry;
00303 int64_t currentpos;
00304 int i;
00305
00306 currentpos = url_ftell(pb);
00307
00308 if (seekhead->reserved_size > 0)
00309 if (url_fseek(pb, seekhead->filepos, SEEK_SET) < 0)
00310 return -1;
00311
00312 metaseek = start_ebml_master(pb, MATROSKA_ID_SEEKHEAD, seekhead->reserved_size);
00313 for (i = 0; i < seekhead->num_entries; i++) {
00314 mkv_seekhead_entry *entry = &seekhead->entries[i];
00315
00316 seekentry = start_ebml_master(pb, MATROSKA_ID_SEEKENTRY, MAX_SEEKENTRY_SIZE);
00317
00318 put_ebml_id(pb, MATROSKA_ID_SEEKID);
00319 put_ebml_num(pb, ebml_id_size(entry->elementid), 0);
00320 put_ebml_id(pb, entry->elementid);
00321
00322 put_ebml_uint(pb, MATROSKA_ID_SEEKPOSITION, entry->segmentpos);
00323 end_ebml_master(pb, seekentry);
00324 }
00325 end_ebml_master(pb, metaseek);
00326
00327 if (seekhead->reserved_size > 0) {
00328 uint64_t remaining = seekhead->filepos + seekhead->reserved_size - url_ftell(pb);
00329 put_ebml_void(pb, remaining);
00330 url_fseek(pb, currentpos, SEEK_SET);
00331
00332 currentpos = seekhead->filepos;
00333 }
00334 av_free(seekhead->entries);
00335 av_free(seekhead);
00336
00337 return currentpos;
00338 }
00339
00340 static mkv_cues * mkv_start_cues(int64_t segment_offset)
00341 {
00342 mkv_cues *cues = av_mallocz(sizeof(mkv_cues));
00343 if (cues == NULL)
00344 return NULL;
00345
00346 cues->segment_offset = segment_offset;
00347 return cues;
00348 }
00349
00350 static int mkv_add_cuepoint(mkv_cues *cues, int stream, int64_t ts, int64_t cluster_pos)
00351 {
00352 mkv_cuepoint *entries = cues->entries;
00353
00354 entries = av_realloc(entries, (cues->num_entries + 1) * sizeof(mkv_cuepoint));
00355 if (entries == NULL)
00356 return AVERROR(ENOMEM);
00357
00358 if (ts < 0)
00359 return 0;
00360
00361 entries[cues->num_entries ].pts = ts;
00362 entries[cues->num_entries ].tracknum = stream + 1;
00363 entries[cues->num_entries++].cluster_pos = cluster_pos - cues->segment_offset;
00364
00365 cues->entries = entries;
00366 return 0;
00367 }
00368
00369 static int64_t mkv_write_cues(ByteIOContext *pb, mkv_cues *cues, int num_tracks)
00370 {
00371 ebml_master cues_element;
00372 int64_t currentpos;
00373 int i, j;
00374
00375 currentpos = url_ftell(pb);
00376 cues_element = start_ebml_master(pb, MATROSKA_ID_CUES, 0);
00377
00378 for (i = 0; i < cues->num_entries; i++) {
00379 ebml_master cuepoint, track_positions;
00380 mkv_cuepoint *entry = &cues->entries[i];
00381 uint64_t pts = entry->pts;
00382
00383 cuepoint = start_ebml_master(pb, MATROSKA_ID_POINTENTRY, MAX_CUEPOINT_SIZE(num_tracks));
00384 put_ebml_uint(pb, MATROSKA_ID_CUETIME, pts);
00385
00386
00387
00388 for (j = 0; j < cues->num_entries - i && entry[j].pts == pts; j++) {
00389 track_positions = start_ebml_master(pb, MATROSKA_ID_CUETRACKPOSITION, MAX_CUETRACKPOS_SIZE);
00390 put_ebml_uint(pb, MATROSKA_ID_CUETRACK , entry[j].tracknum );
00391 put_ebml_uint(pb, MATROSKA_ID_CUECLUSTERPOSITION, entry[j].cluster_pos);
00392 end_ebml_master(pb, track_positions);
00393 }
00394 i += j - 1;
00395 end_ebml_master(pb, cuepoint);
00396 }
00397 end_ebml_master(pb, cues_element);
00398
00399 av_free(cues->entries);
00400 av_free(cues);
00401 return currentpos;
00402 }
00403
00404 static int put_xiph_codecpriv(AVFormatContext *s, ByteIOContext *pb, AVCodecContext *codec)
00405 {
00406 uint8_t *header_start[3];
00407 int header_len[3];
00408 int first_header_size;
00409 int j;
00410
00411 if (codec->codec_id == CODEC_ID_VORBIS)
00412 first_header_size = 30;
00413 else
00414 first_header_size = 42;
00415
00416 if (ff_split_xiph_headers(codec->extradata, codec->extradata_size,
00417 first_header_size, header_start, header_len) < 0) {
00418 av_log(s, AV_LOG_ERROR, "Extradata corrupt.\n");
00419 return -1;
00420 }
00421
00422 put_byte(pb, 2);
00423 for (j = 0; j < 2; j++) {
00424 put_xiph_size(pb, header_len[j]);
00425 }
00426 for (j = 0; j < 3; j++)
00427 put_buffer(pb, header_start[j], header_len[j]);
00428
00429 return 0;
00430 }
00431
00432 static void get_aac_sample_rates(AVFormatContext *s, AVCodecContext *codec, int *sample_rate, int *output_sample_rate)
00433 {
00434 int sri;
00435
00436 if (codec->extradata_size < 2) {
00437 av_log(s, AV_LOG_WARNING, "No AAC extradata, unable to determine samplerate.\n");
00438 return;
00439 }
00440
00441 sri = ((codec->extradata[0] << 1) & 0xE) | (codec->extradata[1] >> 7);
00442 if (sri > 12) {
00443 av_log(s, AV_LOG_WARNING, "AAC samplerate index out of bounds\n");
00444 return;
00445 }
00446 *sample_rate = ff_mpeg4audio_sample_rates[sri];
00447
00448
00449 if (codec->extradata_size == 5) {
00450 sri = (codec->extradata[4] >> 3) & 0xF;
00451 if (sri > 12) {
00452 av_log(s, AV_LOG_WARNING, "AAC output samplerate index out of bounds\n");
00453 return;
00454 }
00455 *output_sample_rate = ff_mpeg4audio_sample_rates[sri];
00456 }
00457 }
00458
00459 static int mkv_write_codecprivate(AVFormatContext *s, ByteIOContext *pb, AVCodecContext *codec, int native_id, int qt_id)
00460 {
00461 ByteIOContext *dyn_cp;
00462 uint8_t *codecpriv;
00463 int ret, codecpriv_size;
00464
00465 ret = url_open_dyn_buf(&dyn_cp);
00466 if(ret < 0)
00467 return ret;
00468
00469 if (native_id) {
00470 if (codec->codec_id == CODEC_ID_VORBIS || codec->codec_id == CODEC_ID_THEORA)
00471 ret = put_xiph_codecpriv(s, dyn_cp, codec);
00472 else if (codec->codec_id == CODEC_ID_FLAC)
00473 ret = ff_flac_write_header(dyn_cp, codec, 1);
00474 else if (codec->codec_id == CODEC_ID_H264)
00475 ret = ff_isom_write_avcc(dyn_cp, codec->extradata, codec->extradata_size);
00476 else if (codec->extradata_size)
00477 put_buffer(dyn_cp, codec->extradata, codec->extradata_size);
00478 } else if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
00479 if (qt_id) {
00480 if (!codec->codec_tag)
00481 codec->codec_tag = ff_codec_get_tag(codec_movvideo_tags, codec->codec_id);
00482 if (codec->extradata_size)
00483 put_buffer(dyn_cp, codec->extradata, codec->extradata_size);
00484 } else {
00485 if (!codec->codec_tag)
00486 codec->codec_tag = ff_codec_get_tag(ff_codec_bmp_tags, codec->codec_id);
00487 if (!codec->codec_tag) {
00488 av_log(s, AV_LOG_ERROR, "No bmp codec ID found.\n");
00489 ret = -1;
00490 }
00491
00492 ff_put_bmp_header(dyn_cp, codec, ff_codec_bmp_tags, 0);
00493 }
00494
00495 } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
00496 unsigned int tag;
00497 tag = ff_codec_get_tag(ff_codec_wav_tags, codec->codec_id);
00498 if (!tag) {
00499 av_log(s, AV_LOG_ERROR, "No wav codec ID found.\n");
00500 ret = -1;
00501 }
00502 if (!codec->codec_tag)
00503 codec->codec_tag = tag;
00504
00505 ff_put_wav_header(dyn_cp, codec);
00506 }
00507
00508 codecpriv_size = url_close_dyn_buf(dyn_cp, &codecpriv);
00509 if (codecpriv_size)
00510 put_ebml_binary(pb, MATROSKA_ID_CODECPRIVATE, codecpriv, codecpriv_size);
00511 av_free(codecpriv);
00512 return ret;
00513 }
00514
00515 static int mkv_write_tracks(AVFormatContext *s)
00516 {
00517 MatroskaMuxContext *mkv = s->priv_data;
00518 ByteIOContext *pb = s->pb;
00519 ebml_master tracks;
00520 int i, j, ret;
00521
00522 ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_TRACKS, url_ftell(pb));
00523 if (ret < 0) return ret;
00524
00525 tracks = start_ebml_master(pb, MATROSKA_ID_TRACKS, 0);
00526 for (i = 0; i < s->nb_streams; i++) {
00527 AVStream *st = s->streams[i];
00528 AVCodecContext *codec = st->codec;
00529 ebml_master subinfo, track;
00530 int native_id = 0;
00531 int qt_id = 0;
00532 int bit_depth = av_get_bits_per_sample(codec->codec_id);
00533 int sample_rate = codec->sample_rate;
00534 int output_sample_rate = 0;
00535 AVMetadataTag *tag;
00536
00537 if (!bit_depth)
00538 bit_depth = av_get_bits_per_sample_format(codec->sample_fmt);
00539
00540 if (codec->codec_id == CODEC_ID_AAC)
00541 get_aac_sample_rates(s, codec, &sample_rate, &output_sample_rate);
00542
00543 track = start_ebml_master(pb, MATROSKA_ID_TRACKENTRY, 0);
00544 put_ebml_uint (pb, MATROSKA_ID_TRACKNUMBER , i + 1);
00545 put_ebml_uint (pb, MATROSKA_ID_TRACKUID , i + 1);
00546 put_ebml_uint (pb, MATROSKA_ID_TRACKFLAGLACING , 0);
00547 put_ebml_float(pb, MATROSKA_ID_TRACKTIMECODESCALE, 1.0);
00548
00549 if ((tag = av_metadata_get(st->metadata, "title", NULL, 0)))
00550 put_ebml_string(pb, MATROSKA_ID_TRACKNAME, tag->value);
00551 tag = av_metadata_get(st->metadata, "language", NULL, 0);
00552 put_ebml_string(pb, MATROSKA_ID_TRACKLANGUAGE, tag ? tag->value:"und");
00553
00554 if (st->disposition)
00555 put_ebml_uint(pb, MATROSKA_ID_TRACKFLAGDEFAULT, !!(st->disposition & AV_DISPOSITION_DEFAULT));
00556
00557
00558
00559 for (j = 0; ff_mkv_codec_tags[j].id != CODEC_ID_NONE; j++) {
00560 if (ff_mkv_codec_tags[j].id == codec->codec_id) {
00561 put_ebml_string(pb, MATROSKA_ID_CODECID, ff_mkv_codec_tags[j].str);
00562 native_id = 1;
00563 break;
00564 }
00565 }
00566
00567 switch (codec->codec_type) {
00568 case AVMEDIA_TYPE_VIDEO:
00569 put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, MATROSKA_TRACK_TYPE_VIDEO);
00570
00571 if (!native_id &&
00572 ff_codec_get_tag(codec_movvideo_tags, codec->codec_id) &&
00573 (!ff_codec_get_tag(ff_codec_bmp_tags, codec->codec_id)
00574 || codec->codec_id == CODEC_ID_SVQ1
00575 || codec->codec_id == CODEC_ID_SVQ3
00576 || codec->codec_id == CODEC_ID_CINEPAK))
00577 qt_id = 1;
00578
00579 if (qt_id)
00580 put_ebml_string(pb, MATROSKA_ID_CODECID, "V_QUICKTIME");
00581 else if (!native_id) {
00582
00583 put_ebml_string(pb, MATROSKA_ID_CODECID, "V_MS/VFW/FOURCC");
00584 mkv->tracks[i].write_dts = 1;
00585 }
00586
00587 subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKVIDEO, 0);
00588
00589 put_ebml_uint (pb, MATROSKA_ID_VIDEOPIXELWIDTH , codec->width);
00590 put_ebml_uint (pb, MATROSKA_ID_VIDEOPIXELHEIGHT, codec->height);
00591 if (st->sample_aspect_ratio.num) {
00592 int d_width = codec->width*av_q2d(st->sample_aspect_ratio);
00593 put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH , d_width);
00594 put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, codec->height);
00595 }
00596 end_ebml_master(pb, subinfo);
00597 break;
00598
00599 case AVMEDIA_TYPE_AUDIO:
00600 put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, MATROSKA_TRACK_TYPE_AUDIO);
00601
00602 if (!native_id)
00603
00604 put_ebml_string(pb, MATROSKA_ID_CODECID, "A_MS/ACM");
00605
00606 subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKAUDIO, 0);
00607 put_ebml_uint (pb, MATROSKA_ID_AUDIOCHANNELS , codec->channels);
00608 put_ebml_float (pb, MATROSKA_ID_AUDIOSAMPLINGFREQ, sample_rate);
00609 if (output_sample_rate)
00610 put_ebml_float(pb, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate);
00611 if (bit_depth)
00612 put_ebml_uint(pb, MATROSKA_ID_AUDIOBITDEPTH, bit_depth);
00613 end_ebml_master(pb, subinfo);
00614 break;
00615
00616 case AVMEDIA_TYPE_SUBTITLE:
00617 put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, MATROSKA_TRACK_TYPE_SUBTITLE);
00618 break;
00619 default:
00620 av_log(s, AV_LOG_ERROR, "Only audio, video, and subtitles are supported for Matroska.");
00621 break;
00622 }
00623 ret = mkv_write_codecprivate(s, pb, codec, native_id, qt_id);
00624 if (ret < 0) return ret;
00625
00626 end_ebml_master(pb, track);
00627
00628
00629 av_set_pts_info(st, 64, 1, 1000);
00630 }
00631 end_ebml_master(pb, tracks);
00632 return 0;
00633 }
00634
00635 static int mkv_write_chapters(AVFormatContext *s)
00636 {
00637 MatroskaMuxContext *mkv = s->priv_data;
00638 ByteIOContext *pb = s->pb;
00639 ebml_master chapters, editionentry;
00640 AVRational scale = {1, 1E9};
00641 int i, ret;
00642
00643 if (!s->nb_chapters)
00644 return 0;
00645
00646 ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_CHAPTERS, url_ftell(pb));
00647 if (ret < 0) return ret;
00648
00649 chapters = start_ebml_master(pb, MATROSKA_ID_CHAPTERS , 0);
00650 editionentry = start_ebml_master(pb, MATROSKA_ID_EDITIONENTRY, 0);
00651 put_ebml_uint(pb, MATROSKA_ID_EDITIONFLAGDEFAULT, 1);
00652 put_ebml_uint(pb, MATROSKA_ID_EDITIONFLAGHIDDEN , 0);
00653 for (i = 0; i < s->nb_chapters; i++) {
00654 ebml_master chapteratom, chapterdisplay;
00655 AVChapter *c = s->chapters[i];
00656 AVMetadataTag *t = NULL;
00657
00658 chapteratom = start_ebml_master(pb, MATROSKA_ID_CHAPTERATOM, 0);
00659 put_ebml_uint(pb, MATROSKA_ID_CHAPTERUID, c->id);
00660 put_ebml_uint(pb, MATROSKA_ID_CHAPTERTIMESTART,
00661 av_rescale_q(c->start, c->time_base, scale));
00662 put_ebml_uint(pb, MATROSKA_ID_CHAPTERTIMEEND,
00663 av_rescale_q(c->end, c->time_base, scale));
00664 put_ebml_uint(pb, MATROSKA_ID_CHAPTERFLAGHIDDEN , 0);
00665 put_ebml_uint(pb, MATROSKA_ID_CHAPTERFLAGENABLED, 1);
00666 if ((t = av_metadata_get(c->metadata, "title", NULL, 0))) {
00667 chapterdisplay = start_ebml_master(pb, MATROSKA_ID_CHAPTERDISPLAY, 0);
00668 put_ebml_string(pb, MATROSKA_ID_CHAPSTRING, t->value);
00669 put_ebml_string(pb, MATROSKA_ID_CHAPLANG , "und");
00670 end_ebml_master(pb, chapterdisplay);
00671 }
00672 end_ebml_master(pb, chapteratom);
00673 }
00674 end_ebml_master(pb, editionentry);
00675 end_ebml_master(pb, chapters);
00676 return 0;
00677 }
00678
00679 static int mkv_write_header(AVFormatContext *s)
00680 {
00681 MatroskaMuxContext *mkv = s->priv_data;
00682 ByteIOContext *pb = s->pb;
00683 ebml_master ebml_header, segment_info;
00684 AVMetadataTag *tag;
00685 int ret;
00686
00687 mkv->md5_ctx = av_mallocz(av_md5_size);
00688 av_md5_init(mkv->md5_ctx);
00689 mkv->tracks = av_mallocz(s->nb_streams * sizeof(*mkv->tracks));
00690
00691 ebml_header = start_ebml_master(pb, EBML_ID_HEADER, 0);
00692 put_ebml_uint (pb, EBML_ID_EBMLVERSION , 1);
00693 put_ebml_uint (pb, EBML_ID_EBMLREADVERSION , 1);
00694 put_ebml_uint (pb, EBML_ID_EBMLMAXIDLENGTH , 4);
00695 put_ebml_uint (pb, EBML_ID_EBMLMAXSIZELENGTH , 8);
00696 put_ebml_string (pb, EBML_ID_DOCTYPE , "matroska");
00697 put_ebml_uint (pb, EBML_ID_DOCTYPEVERSION , 2);
00698 put_ebml_uint (pb, EBML_ID_DOCTYPEREADVERSION , 2);
00699 end_ebml_master(pb, ebml_header);
00700
00701 mkv->segment = start_ebml_master(pb, MATROSKA_ID_SEGMENT, 0);
00702 mkv->segment_offset = url_ftell(pb);
00703
00704
00705
00706
00707
00708
00709 mkv->main_seekhead = mkv_start_seekhead(pb, mkv->segment_offset, 10);
00710 mkv->cluster_seekhead = mkv_start_seekhead(pb, mkv->segment_offset, 0);
00711 if (mkv->main_seekhead == NULL || mkv->cluster_seekhead == NULL)
00712 return AVERROR(ENOMEM);
00713
00714 ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_INFO, url_ftell(pb));
00715 if (ret < 0) return ret;
00716
00717 segment_info = start_ebml_master(pb, MATROSKA_ID_INFO, 0);
00718 put_ebml_uint(pb, MATROSKA_ID_TIMECODESCALE, 1000000);
00719 if ((tag = av_metadata_get(s->metadata, "title", NULL, 0)))
00720 put_ebml_string(pb, MATROSKA_ID_TITLE, tag->value);
00721 if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
00722 put_ebml_string(pb, MATROSKA_ID_MUXINGAPP , LIBAVFORMAT_IDENT);
00723 put_ebml_string(pb, MATROSKA_ID_WRITINGAPP, LIBAVFORMAT_IDENT);
00724
00725
00726 mkv->segment_uid = url_ftell(pb);
00727 put_ebml_void(pb, 19);
00728 }
00729
00730
00731 mkv->duration = 0;
00732 mkv->duration_offset = url_ftell(pb);
00733 put_ebml_void(pb, 11);
00734 end_ebml_master(pb, segment_info);
00735
00736 ret = mkv_write_tracks(s);
00737 if (ret < 0) return ret;
00738
00739 ret = mkv_write_chapters(s);
00740 if (ret < 0) return ret;
00741
00742 if (url_is_streamed(s->pb))
00743 mkv_write_seekhead(pb, mkv->main_seekhead);
00744
00745 mkv->cues = mkv_start_cues(mkv->segment_offset);
00746 if (mkv->cues == NULL)
00747 return AVERROR(ENOMEM);
00748
00749 put_flush_packet(pb);
00750 return 0;
00751 }
00752
00753 static int mkv_blockgroup_size(int pkt_size)
00754 {
00755 int size = pkt_size + 4;
00756 size += ebml_num_size(size);
00757 size += 2;
00758 size += 8;
00759 size += ebml_num_size(size);
00760 size += 1;
00761 return size;
00762 }
00763
00764 static int ass_get_duration(const uint8_t *p)
00765 {
00766 int sh, sm, ss, sc, eh, em, es, ec;
00767 uint64_t start, end;
00768
00769 if (sscanf(p, "%*[^,],%d:%d:%d%*c%d,%d:%d:%d%*c%d",
00770 &sh, &sm, &ss, &sc, &eh, &em, &es, &ec) != 8)
00771 return 0;
00772 start = 3600000*sh + 60000*sm + 1000*ss + 10*sc;
00773 end = 3600000*eh + 60000*em + 1000*es + 10*ec;
00774 return end - start;
00775 }
00776
00777 static int mkv_write_ass_blocks(AVFormatContext *s, ByteIOContext *pb, AVPacket *pkt)
00778 {
00779 MatroskaMuxContext *mkv = s->priv_data;
00780 int i, layer = 0, max_duration = 0, size, line_size, data_size = pkt->size;
00781 uint8_t *start, *end, *data = pkt->data;
00782 ebml_master blockgroup;
00783 char buffer[2048];
00784
00785 while (data_size) {
00786 int duration = ass_get_duration(data);
00787 max_duration = FFMAX(duration, max_duration);
00788 end = memchr(data, '\n', data_size);
00789 size = line_size = end ? end-data+1 : data_size;
00790 size -= end ? (end[-1]=='\r')+1 : 0;
00791 start = data;
00792 for (i=0; i<3; i++, start++)
00793 if (!(start = memchr(start, ',', size-(start-data))))
00794 return max_duration;
00795 size -= start - data;
00796 sscanf(data, "Dialogue: %d,", &layer);
00797 i = snprintf(buffer, sizeof(buffer), "%"PRId64",%d,",
00798 s->streams[pkt->stream_index]->nb_frames++, layer);
00799 size = FFMIN(i+size, sizeof(buffer));
00800 memcpy(buffer+i, start, size-i);
00801
00802 av_log(s, AV_LOG_DEBUG, "Writing block at offset %" PRIu64 ", size %d, "
00803 "pts %" PRId64 ", duration %d\n",
00804 url_ftell(pb), size, pkt->pts, duration);
00805 blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, mkv_blockgroup_size(size));
00806 put_ebml_id(pb, MATROSKA_ID_BLOCK);
00807 put_ebml_num(pb, size+4, 0);
00808 put_byte(pb, 0x80 | (pkt->stream_index + 1));
00809 put_be16(pb, pkt->pts - mkv->cluster_pts);
00810 put_byte(pb, 0);
00811 put_buffer(pb, buffer, size);
00812 put_ebml_uint(pb, MATROSKA_ID_BLOCKDURATION, duration);
00813 end_ebml_master(pb, blockgroup);
00814
00815 data += line_size;
00816 data_size -= line_size;
00817 }
00818
00819 return max_duration;
00820 }
00821
00822 static void mkv_write_block(AVFormatContext *s, ByteIOContext *pb,
00823 unsigned int blockid, AVPacket *pkt, int flags)
00824 {
00825 MatroskaMuxContext *mkv = s->priv_data;
00826 AVCodecContext *codec = s->streams[pkt->stream_index]->codec;
00827 uint8_t *data = NULL;
00828 int size = pkt->size;
00829 int64_t ts = mkv->tracks[pkt->stream_index].write_dts ? pkt->dts : pkt->pts;
00830
00831 av_log(s, AV_LOG_DEBUG, "Writing block at offset %" PRIu64 ", size %d, "
00832 "pts %" PRId64 ", dts %" PRId64 ", duration %d, flags %d\n",
00833 url_ftell(pb), pkt->size, pkt->pts, pkt->dts, pkt->duration, flags);
00834 if (codec->codec_id == CODEC_ID_H264 && codec->extradata_size > 0 &&
00835 (AV_RB24(codec->extradata) == 1 || AV_RB32(codec->extradata) == 1))
00836 ff_avc_parse_nal_units_buf(pkt->data, &data, &size);
00837 else
00838 data = pkt->data;
00839 put_ebml_id(pb, blockid);
00840 put_ebml_num(pb, size+4, 0);
00841 put_byte(pb, 0x80 | (pkt->stream_index + 1));
00842 put_be16(pb, ts - mkv->cluster_pts);
00843 put_byte(pb, flags);
00844 put_buffer(pb, data, size);
00845 if (data != pkt->data)
00846 av_free(data);
00847 }
00848
00849 static void mkv_flush_dynbuf(AVFormatContext *s)
00850 {
00851 MatroskaMuxContext *mkv = s->priv_data;
00852 int bufsize;
00853 uint8_t *dyn_buf;
00854
00855 if (!mkv->dyn_bc)
00856 return;
00857
00858 bufsize = url_close_dyn_buf(mkv->dyn_bc, &dyn_buf);
00859 put_buffer(s->pb, dyn_buf, bufsize);
00860 av_free(dyn_buf);
00861 mkv->dyn_bc = NULL;
00862 }
00863
00864 static int mkv_write_packet(AVFormatContext *s, AVPacket *pkt)
00865 {
00866 MatroskaMuxContext *mkv = s->priv_data;
00867 ByteIOContext *pb = s->pb;
00868 AVCodecContext *codec = s->streams[pkt->stream_index]->codec;
00869 int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
00870 int duration = pkt->duration;
00871 int ret;
00872 int64_t ts = mkv->tracks[pkt->stream_index].write_dts ? pkt->dts : pkt->pts;
00873
00874 if (ts == AV_NOPTS_VALUE) {
00875 av_log(s, AV_LOG_ERROR, "Can't write packet with unknown timestamp\n");
00876 return AVERROR(EINVAL);
00877 }
00878
00879 if (url_is_streamed(s->pb)) {
00880 if (!mkv->dyn_bc)
00881 url_open_dyn_buf(&mkv->dyn_bc);
00882 pb = mkv->dyn_bc;
00883 }
00884
00885 if (!mkv->cluster_pos) {
00886 ret = mkv_add_seekhead_entry(mkv->cluster_seekhead, MATROSKA_ID_CLUSTER, url_ftell(pb));
00887 if (ret < 0) return ret;
00888
00889 mkv->cluster_pos = url_ftell(s->pb);
00890 mkv->cluster = start_ebml_master(pb, MATROSKA_ID_CLUSTER, 0);
00891 put_ebml_uint(pb, MATROSKA_ID_CLUSTERTIMECODE, FFMAX(0, ts));
00892 mkv->cluster_pts = FFMAX(0, ts);
00893 av_md5_update(mkv->md5_ctx, pkt->data, FFMIN(200, pkt->size));
00894 }
00895
00896 if (codec->codec_type != AVMEDIA_TYPE_SUBTITLE) {
00897 mkv_write_block(s, pb, MATROSKA_ID_SIMPLEBLOCK, pkt, keyframe << 7);
00898 } else if (codec->codec_id == CODEC_ID_SSA) {
00899 duration = mkv_write_ass_blocks(s, pb, pkt);
00900 } else {
00901 ebml_master blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, mkv_blockgroup_size(pkt->size));
00902 duration = pkt->convergence_duration;
00903 mkv_write_block(s, pb, MATROSKA_ID_BLOCK, pkt, 0);
00904 put_ebml_uint(pb, MATROSKA_ID_BLOCKDURATION, duration);
00905 end_ebml_master(pb, blockgroup);
00906 }
00907
00908 if (codec->codec_type == AVMEDIA_TYPE_VIDEO && keyframe) {
00909 ret = mkv_add_cuepoint(mkv->cues, pkt->stream_index, ts, mkv->cluster_pos);
00910 if (ret < 0) return ret;
00911 }
00912
00913
00914 if ((url_is_streamed(s->pb) && (url_ftell(pb) > 32*1024 || ts > mkv->cluster_pts + 1000))
00915 || url_ftell(pb) > mkv->cluster_pos + 5*1024*1024 || ts > mkv->cluster_pts + 5000) {
00916 av_log(s, AV_LOG_DEBUG, "Starting new cluster at offset %" PRIu64
00917 " bytes, pts %" PRIu64 "\n", url_ftell(pb), ts);
00918 end_ebml_master(pb, mkv->cluster);
00919 mkv->cluster_pos = 0;
00920 if (mkv->dyn_bc)
00921 mkv_flush_dynbuf(s);
00922 }
00923
00924 mkv->duration = FFMAX(mkv->duration, ts + duration);
00925 return 0;
00926 }
00927
00928 static int mkv_write_trailer(AVFormatContext *s)
00929 {
00930 MatroskaMuxContext *mkv = s->priv_data;
00931 ByteIOContext *pb = s->pb;
00932 int64_t currentpos, second_seekhead, cuespos;
00933 int ret;
00934
00935 if (mkv->dyn_bc) {
00936 end_ebml_master(mkv->dyn_bc, mkv->cluster);
00937 mkv_flush_dynbuf(s);
00938 } else if (mkv->cluster_pos) {
00939 end_ebml_master(pb, mkv->cluster);
00940 }
00941
00942 if (!url_is_streamed(pb)) {
00943 cuespos = mkv_write_cues(pb, mkv->cues, s->nb_streams);
00944 second_seekhead = mkv_write_seekhead(pb, mkv->cluster_seekhead);
00945
00946 ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_CUES , cuespos);
00947 if (ret < 0) return ret;
00948 if (second_seekhead >= 0) {
00949 ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_SEEKHEAD, second_seekhead);
00950 if (ret < 0) return ret;
00951 }
00952 mkv_write_seekhead(pb, mkv->main_seekhead);
00953
00954
00955 av_log(s, AV_LOG_DEBUG, "end duration = %" PRIu64 "\n", mkv->duration);
00956 currentpos = url_ftell(pb);
00957 url_fseek(pb, mkv->duration_offset, SEEK_SET);
00958 put_ebml_float(pb, MATROSKA_ID_DURATION, mkv->duration);
00959
00960
00961 if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
00962 uint8_t segment_uid[16];
00963 av_md5_final(mkv->md5_ctx, segment_uid);
00964 url_fseek(pb, mkv->segment_uid, SEEK_SET);
00965 put_ebml_binary(pb, MATROSKA_ID_SEGMENTUID, segment_uid, 16);
00966 }
00967 url_fseek(pb, currentpos, SEEK_SET);
00968 }
00969
00970 end_ebml_master(pb, mkv->segment);
00971 av_free(mkv->md5_ctx);
00972 av_free(mkv->tracks);
00973 put_flush_packet(pb);
00974 return 0;
00975 }
00976
00977 AVOutputFormat matroska_muxer = {
00978 "matroska",
00979 NULL_IF_CONFIG_SMALL("Matroska file format"),
00980 "video/x-matroska",
00981 "mkv",
00982 sizeof(MatroskaMuxContext),
00983 CODEC_ID_MP2,
00984 CODEC_ID_MPEG4,
00985 mkv_write_header,
00986 mkv_write_packet,
00987 mkv_write_trailer,
00988 .flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS,
00989 .codec_tag = (const AVCodecTag* const []){ff_codec_bmp_tags, ff_codec_wav_tags, 0},
00990 .subtitle_codec = CODEC_ID_TEXT,
00991 };
00992
00993 AVOutputFormat matroska_audio_muxer = {
00994 "matroska",
00995 NULL_IF_CONFIG_SMALL("Matroska file format"),
00996 "audio/x-matroska",
00997 "mka",
00998 sizeof(MatroskaMuxContext),
00999 CODEC_ID_MP2,
01000 CODEC_ID_NONE,
01001 mkv_write_header,
01002 mkv_write_packet,
01003 mkv_write_trailer,
01004 .flags = AVFMT_GLOBALHEADER,
01005 .codec_tag = (const AVCodecTag* const []){ff_codec_wav_tags, 0},
01006 };