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 "md5.h"
00024 #include "riff.h"
00025 #include "xiph.h"
00026 #include "matroska.h"
00027 #include "avc.h"
00028
00029 typedef struct ebml_master {
00030 offset_t pos;
00031 int sizebytes;
00032 } ebml_master;
00033
00034 typedef struct mkv_seekhead_entry {
00035 unsigned int elementid;
00036 uint64_t segmentpos;
00037 } mkv_seekhead_entry;
00038
00039 typedef struct mkv_seekhead {
00040 offset_t filepos;
00041 offset_t segment_offset;
00042 int reserved_size;
00043 int max_entries;
00044 mkv_seekhead_entry *entries;
00045 int num_entries;
00046 } mkv_seekhead;
00047
00048 typedef struct {
00049 uint64_t pts;
00050 int tracknum;
00051 offset_t cluster_pos;
00052 } mkv_cuepoint;
00053
00054 typedef struct {
00055 offset_t segment_offset;
00056 mkv_cuepoint *entries;
00057 int num_entries;
00058 } mkv_cues;
00059
00060 typedef struct MatroskaMuxContext {
00061 ebml_master segment;
00062 offset_t segment_offset;
00063 offset_t segment_uid;
00064 ebml_master cluster;
00065 offset_t cluster_pos;
00066 uint64_t cluster_pts;
00067 offset_t duration_offset;
00068 uint64_t duration;
00069 mkv_seekhead *main_seekhead;
00070 mkv_seekhead *cluster_seekhead;
00071 mkv_cues *cues;
00072
00073 struct AVMD5 *md5_ctx;
00074 } MatroskaMuxContext;
00075
00076
00079 #define MAX_SEEKENTRY_SIZE 21
00080
00083 #define MAX_CUETRACKPOS_SIZE 22
00084
00086 #define MAX_CUEPOINT_SIZE(num_tracks) 12 + MAX_CUETRACKPOS_SIZE*num_tracks
00087
00088
00089 static int ebml_id_size(unsigned int id)
00090 {
00091 return (av_log2(id+1)-1)/7+1;
00092 }
00093
00094 static void put_ebml_id(ByteIOContext *pb, unsigned int id)
00095 {
00096 int i = ebml_id_size(id);
00097 while (i--)
00098 put_byte(pb, id >> (i*8));
00099 }
00100
00106 static void put_ebml_size_unknown(ByteIOContext *pb, int bytes)
00107 {
00108 assert(bytes <= 8);
00109 put_byte(pb, 0x1ff >> bytes);
00110 while (--bytes)
00111 put_byte(pb, 0xff);
00112 }
00113
00117 static int ebml_num_size(uint64_t num)
00118 {
00119 int bytes = 1;
00120 while ((num+1) >> bytes*7) bytes++;
00121 return bytes;
00122 }
00123
00130 static void put_ebml_num(ByteIOContext *pb, uint64_t num, int bytes)
00131 {
00132 int i, needed_bytes = ebml_num_size(num);
00133
00134
00135 assert(num < (1ULL<<56)-1);
00136
00137 if (bytes == 0)
00138
00139 bytes = needed_bytes;
00140
00141
00142 assert(bytes >= needed_bytes);
00143
00144 num |= 1ULL << bytes*7;
00145 for (i = bytes - 1; i >= 0; i--)
00146 put_byte(pb, num >> i*8);
00147 }
00148
00149 static void put_ebml_uint(ByteIOContext *pb, unsigned int elementid, uint64_t val)
00150 {
00151 int i, bytes = 1;
00152 while (val >> bytes*8) bytes++;
00153
00154 put_ebml_id(pb, elementid);
00155 put_ebml_num(pb, bytes, 0);
00156 for (i = bytes - 1; i >= 0; i--)
00157 put_byte(pb, val >> i*8);
00158 }
00159
00160 static void put_ebml_float(ByteIOContext *pb, unsigned int elementid, double val)
00161 {
00162 put_ebml_id(pb, elementid);
00163 put_ebml_num(pb, 8, 0);
00164 put_be64(pb, av_dbl2int(val));
00165 }
00166
00167 static void put_ebml_binary(ByteIOContext *pb, unsigned int elementid,
00168 const uint8_t *buf, int size)
00169 {
00170 put_ebml_id(pb, elementid);
00171 put_ebml_num(pb, size, 0);
00172 put_buffer(pb, buf, size);
00173 }
00174
00175 static void put_ebml_string(ByteIOContext *pb, unsigned int elementid, const char *str)
00176 {
00177 put_ebml_binary(pb, elementid, str, strlen(str));
00178 }
00179
00186 static void put_ebml_void(ByteIOContext *pb, uint64_t size)
00187 {
00188 offset_t currentpos = url_ftell(pb);
00189
00190 assert(size >= 2);
00191
00192 put_ebml_id(pb, EBML_ID_VOID);
00193
00194
00195
00196 if (size < 10)
00197 put_ebml_num(pb, size-1, 0);
00198 else
00199 put_ebml_num(pb, size-9, 8);
00200 while(url_ftell(pb) < currentpos + size)
00201 put_byte(pb, 0);
00202 }
00203
00204 static ebml_master start_ebml_master(ByteIOContext *pb, unsigned int elementid, uint64_t expectedsize)
00205 {
00206 int bytes = expectedsize ? ebml_num_size(expectedsize) : 8;
00207 put_ebml_id(pb, elementid);
00208 put_ebml_size_unknown(pb, bytes);
00209 return (ebml_master){ url_ftell(pb), bytes };
00210 }
00211
00212 static void end_ebml_master(ByteIOContext *pb, ebml_master master)
00213 {
00214 offset_t pos = url_ftell(pb);
00215
00216
00217 if (url_is_streamed(pb))
00218 return;
00219
00220 url_fseek(pb, master.pos - master.sizebytes, SEEK_SET);
00221 put_ebml_num(pb, pos - master.pos, master.sizebytes);
00222 url_fseek(pb, pos, SEEK_SET);
00223 }
00224
00225 static void put_xiph_size(ByteIOContext *pb, int size)
00226 {
00227 int i;
00228 for (i = 0; i < size / 255; i++)
00229 put_byte(pb, 255);
00230 put_byte(pb, size % 255);
00231 }
00232
00244 static mkv_seekhead * mkv_start_seekhead(ByteIOContext *pb, offset_t segment_offset, int numelements)
00245 {
00246 mkv_seekhead *new_seekhead = av_mallocz(sizeof(mkv_seekhead));
00247 if (new_seekhead == NULL)
00248 return NULL;
00249
00250 new_seekhead->segment_offset = segment_offset;
00251
00252 if (numelements > 0) {
00253 new_seekhead->filepos = url_ftell(pb);
00254
00255
00256
00257 new_seekhead->reserved_size = numelements * MAX_SEEKENTRY_SIZE + 13;
00258 new_seekhead->max_entries = numelements;
00259 put_ebml_void(pb, new_seekhead->reserved_size);
00260 }
00261 return new_seekhead;
00262 }
00263
00264 static int mkv_add_seekhead_entry(mkv_seekhead *seekhead, unsigned int elementid, uint64_t filepos)
00265 {
00266 mkv_seekhead_entry *entries = seekhead->entries;
00267
00268
00269 if (seekhead->max_entries > 0 && seekhead->max_entries <= seekhead->num_entries)
00270 return -1;
00271
00272 entries = av_realloc(entries, (seekhead->num_entries + 1) * sizeof(mkv_seekhead_entry));
00273 if (entries == NULL)
00274 return AVERROR(ENOMEM);
00275
00276 entries[seekhead->num_entries ].elementid = elementid;
00277 entries[seekhead->num_entries++].segmentpos = filepos - seekhead->segment_offset;
00278
00279 seekhead->entries = entries;
00280 return 0;
00281 }
00282
00291 static offset_t mkv_write_seekhead(ByteIOContext *pb, mkv_seekhead *seekhead)
00292 {
00293 ebml_master metaseek, seekentry;
00294 offset_t currentpos;
00295 int i;
00296
00297 currentpos = url_ftell(pb);
00298
00299 if (seekhead->reserved_size > 0)
00300 url_fseek(pb, seekhead->filepos, SEEK_SET);
00301
00302 metaseek = start_ebml_master(pb, MATROSKA_ID_SEEKHEAD, seekhead->reserved_size);
00303 for (i = 0; i < seekhead->num_entries; i++) {
00304 mkv_seekhead_entry *entry = &seekhead->entries[i];
00305
00306 seekentry = start_ebml_master(pb, MATROSKA_ID_SEEKENTRY, MAX_SEEKENTRY_SIZE);
00307
00308 put_ebml_id(pb, MATROSKA_ID_SEEKID);
00309 put_ebml_num(pb, ebml_id_size(entry->elementid), 0);
00310 put_ebml_id(pb, entry->elementid);
00311
00312 put_ebml_uint(pb, MATROSKA_ID_SEEKPOSITION, entry->segmentpos);
00313 end_ebml_master(pb, seekentry);
00314 }
00315 end_ebml_master(pb, metaseek);
00316
00317 if (seekhead->reserved_size > 0) {
00318 uint64_t remaining = seekhead->filepos + seekhead->reserved_size - url_ftell(pb);
00319 put_ebml_void(pb, remaining);
00320 url_fseek(pb, currentpos, SEEK_SET);
00321
00322 currentpos = seekhead->filepos;
00323 }
00324 av_free(seekhead->entries);
00325 av_free(seekhead);
00326
00327 return currentpos;
00328 }
00329
00330 static mkv_cues * mkv_start_cues(offset_t segment_offset)
00331 {
00332 mkv_cues *cues = av_mallocz(sizeof(mkv_cues));
00333 if (cues == NULL)
00334 return NULL;
00335
00336 cues->segment_offset = segment_offset;
00337 return cues;
00338 }
00339
00340 static int mkv_add_cuepoint(mkv_cues *cues, AVPacket *pkt, offset_t cluster_pos)
00341 {
00342 mkv_cuepoint *entries = cues->entries;
00343
00344 entries = av_realloc(entries, (cues->num_entries + 1) * sizeof(mkv_cuepoint));
00345 if (entries == NULL)
00346 return AVERROR(ENOMEM);
00347
00348 entries[cues->num_entries ].pts = pkt->pts;
00349 entries[cues->num_entries ].tracknum = pkt->stream_index + 1;
00350 entries[cues->num_entries++].cluster_pos = cluster_pos - cues->segment_offset;
00351
00352 cues->entries = entries;
00353 return 0;
00354 }
00355
00356 static offset_t mkv_write_cues(ByteIOContext *pb, mkv_cues *cues, int num_tracks)
00357 {
00358 ebml_master cues_element;
00359 offset_t currentpos;
00360 int i, j;
00361
00362 currentpos = url_ftell(pb);
00363 cues_element = start_ebml_master(pb, MATROSKA_ID_CUES, 0);
00364
00365 for (i = 0; i < cues->num_entries; i++) {
00366 ebml_master cuepoint, track_positions;
00367 mkv_cuepoint *entry = &cues->entries[i];
00368 uint64_t pts = entry->pts;
00369
00370 cuepoint = start_ebml_master(pb, MATROSKA_ID_POINTENTRY, MAX_CUEPOINT_SIZE(num_tracks));
00371 put_ebml_uint(pb, MATROSKA_ID_CUETIME, pts);
00372
00373
00374
00375 for (j = 0; j < cues->num_entries - i && entry[j].pts == pts; j++) {
00376 track_positions = start_ebml_master(pb, MATROSKA_ID_CUETRACKPOSITION, MAX_CUETRACKPOS_SIZE);
00377 put_ebml_uint(pb, MATROSKA_ID_CUETRACK , entry[j].tracknum );
00378 put_ebml_uint(pb, MATROSKA_ID_CUECLUSTERPOSITION, entry[j].cluster_pos);
00379 end_ebml_master(pb, track_positions);
00380 }
00381 i += j - 1;
00382 end_ebml_master(pb, cuepoint);
00383 }
00384 end_ebml_master(pb, cues_element);
00385
00386 av_free(cues->entries);
00387 av_free(cues);
00388 return currentpos;
00389 }
00390
00391 static int put_xiph_codecpriv(AVFormatContext *s, ByteIOContext *pb, AVCodecContext *codec)
00392 {
00393 uint8_t *header_start[3];
00394 int header_len[3];
00395 int first_header_size;
00396 int j;
00397
00398 if (codec->codec_id == CODEC_ID_VORBIS)
00399 first_header_size = 30;
00400 else
00401 first_header_size = 42;
00402
00403 if (ff_split_xiph_headers(codec->extradata, codec->extradata_size,
00404 first_header_size, header_start, header_len) < 0) {
00405 av_log(s, AV_LOG_ERROR, "Extradata corrupt.\n");
00406 return -1;
00407 }
00408
00409 put_byte(pb, 2);
00410 for (j = 0; j < 2; j++) {
00411 put_xiph_size(pb, header_len[j]);
00412 }
00413 for (j = 0; j < 3; j++)
00414 put_buffer(pb, header_start[j], header_len[j]);
00415
00416 return 0;
00417 }
00418
00419 #define FLAC_STREAMINFO_SIZE 34
00420
00421 static int put_flac_codecpriv(AVFormatContext *s, ByteIOContext *pb, AVCodecContext *codec)
00422 {
00423
00424
00425 if (codec->extradata_size < FLAC_STREAMINFO_SIZE) {
00426 av_log(s, AV_LOG_ERROR, "Invalid FLAC extradata\n");
00427 return -1;
00428 } else if (codec->extradata_size == FLAC_STREAMINFO_SIZE) {
00429
00430 put_byte(pb, 0);
00431 put_xiph_size(pb, codec->extradata_size);
00432 av_log(s, AV_LOG_ERROR, "Only one packet\n");
00433 }
00434 put_buffer(pb, codec->extradata, codec->extradata_size);
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 static const int aac_sample_rates[] = {
00441 96000, 88200, 64000, 48000, 44100, 32000,
00442 24000, 22050, 16000, 12000, 11025, 8000,
00443 };
00444 int sri;
00445
00446 if (codec->extradata_size < 2) {
00447 av_log(s, AV_LOG_WARNING, "No AAC extradata, unable to determine samplerate.\n");
00448 return;
00449 }
00450
00451 sri = ((codec->extradata[0] << 1) & 0xE) | (codec->extradata[1] >> 7);
00452 if (sri > 12) {
00453 av_log(s, AV_LOG_WARNING, "AAC samplerate index out of bounds\n");
00454 return;
00455 }
00456 *sample_rate = aac_sample_rates[sri];
00457
00458
00459 if (codec->extradata_size == 5) {
00460 sri = (codec->extradata[4] >> 3) & 0xF;
00461 if (sri > 12) {
00462 av_log(s, AV_LOG_WARNING, "AAC output samplerate index out of bounds\n");
00463 return;
00464 }
00465 *output_sample_rate = aac_sample_rates[sri];
00466 }
00467 }
00468
00469 static int mkv_write_codecprivate(AVFormatContext *s, ByteIOContext *pb, AVCodecContext *codec, int native_id)
00470 {
00471 ByteIOContext *dyn_cp;
00472 uint8_t *codecpriv;
00473 int ret, codecpriv_size;
00474
00475 ret = url_open_dyn_buf(&dyn_cp);
00476 if(ret < 0)
00477 return ret;
00478
00479 if (native_id) {
00480 if (codec->codec_id == CODEC_ID_VORBIS || codec->codec_id == CODEC_ID_THEORA)
00481 ret = put_xiph_codecpriv(s, dyn_cp, codec);
00482 else if (codec->codec_id == CODEC_ID_FLAC)
00483 ret = put_flac_codecpriv(s, dyn_cp, codec);
00484 else if (codec->codec_id == CODEC_ID_H264)
00485 ret = ff_isom_write_avcc(dyn_cp, codec->extradata, codec->extradata_size);
00486 else if (codec->extradata_size)
00487 put_buffer(dyn_cp, codec->extradata, codec->extradata_size);
00488 } else if (codec->codec_type == CODEC_TYPE_VIDEO) {
00489 if (!codec->codec_tag)
00490 codec->codec_tag = codec_get_tag(codec_bmp_tags, codec->codec_id);
00491 if (!codec->codec_tag) {
00492 av_log(s, AV_LOG_ERROR, "No bmp codec ID found.");
00493 ret = -1;
00494 }
00495
00496 put_bmp_header(dyn_cp, codec, codec_bmp_tags, 0);
00497
00498 } else if (codec->codec_type == CODEC_TYPE_AUDIO) {
00499 if (!codec->codec_tag)
00500 codec->codec_tag = codec_get_tag(codec_wav_tags, codec->codec_id);
00501 if (!codec->codec_tag) {
00502 av_log(s, AV_LOG_ERROR, "No wav codec ID found.");
00503 ret = -1;
00504 }
00505
00506 put_wav_header(dyn_cp, codec);
00507 }
00508
00509 codecpriv_size = url_close_dyn_buf(dyn_cp, &codecpriv);
00510 if (codecpriv_size)
00511 put_ebml_binary(pb, MATROSKA_ID_CODECPRIVATE, codecpriv, codecpriv_size);
00512 av_free(codecpriv);
00513 return ret;
00514 }
00515
00516 static int mkv_write_tracks(AVFormatContext *s)
00517 {
00518 MatroskaMuxContext *mkv = s->priv_data;
00519 ByteIOContext *pb = s->pb;
00520 ebml_master tracks;
00521 int i, j, ret;
00522
00523 ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_TRACKS, url_ftell(pb));
00524 if (ret < 0) return ret;
00525
00526 tracks = start_ebml_master(pb, MATROSKA_ID_TRACKS, 0);
00527 for (i = 0; i < s->nb_streams; i++) {
00528 AVStream *st = s->streams[i];
00529 AVCodecContext *codec = st->codec;
00530 ebml_master subinfo, track;
00531 int native_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
00536 if (!bit_depth)
00537 bit_depth = av_get_bits_per_sample_format(codec->sample_fmt);
00538
00539 if (codec->codec_id == CODEC_ID_AAC)
00540 get_aac_sample_rates(s, codec, &sample_rate, &output_sample_rate);
00541
00542 track = start_ebml_master(pb, MATROSKA_ID_TRACKENTRY, 0);
00543 put_ebml_uint (pb, MATROSKA_ID_TRACKNUMBER , i + 1);
00544 put_ebml_uint (pb, MATROSKA_ID_TRACKUID , i + 1);
00545 put_ebml_uint (pb, MATROSKA_ID_TRACKFLAGLACING , 0);
00546
00547 if (st->language[0])
00548 put_ebml_string(pb, MATROSKA_ID_TRACKLANGUAGE, st->language);
00549 else
00550 put_ebml_string(pb, MATROSKA_ID_TRACKLANGUAGE, "und");
00551
00552
00553
00554 for (j = 0; ff_mkv_codec_tags[j].id != CODEC_ID_NONE; j++) {
00555 if (ff_mkv_codec_tags[j].id == codec->codec_id) {
00556 put_ebml_string(pb, MATROSKA_ID_CODECID, ff_mkv_codec_tags[j].str);
00557 native_id = 1;
00558 break;
00559 }
00560 }
00561
00562 switch (codec->codec_type) {
00563 case CODEC_TYPE_VIDEO:
00564 put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, MATROSKA_TRACK_TYPE_VIDEO);
00565
00566 if (!native_id)
00567
00568 put_ebml_string(pb, MATROSKA_ID_CODECID, MATROSKA_CODEC_ID_VIDEO_VFW_FOURCC);
00569
00570 subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKVIDEO, 0);
00571
00572 put_ebml_uint (pb, MATROSKA_ID_VIDEOPIXELWIDTH , codec->width);
00573 put_ebml_uint (pb, MATROSKA_ID_VIDEOPIXELHEIGHT, codec->height);
00574 if (codec->sample_aspect_ratio.num) {
00575 AVRational dar = av_mul_q(codec->sample_aspect_ratio,
00576 (AVRational){codec->width, codec->height});
00577 put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH , dar.num);
00578 put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, dar.den);
00579 }
00580 end_ebml_master(pb, subinfo);
00581 break;
00582
00583 case CODEC_TYPE_AUDIO:
00584 put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, MATROSKA_TRACK_TYPE_AUDIO);
00585
00586 if (!native_id)
00587
00588 put_ebml_string(pb, MATROSKA_ID_CODECID, MATROSKA_CODEC_ID_AUDIO_ACM);
00589
00590 subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKAUDIO, 0);
00591 put_ebml_uint (pb, MATROSKA_ID_AUDIOCHANNELS , codec->channels);
00592 put_ebml_float (pb, MATROSKA_ID_AUDIOSAMPLINGFREQ, sample_rate);
00593 if (output_sample_rate)
00594 put_ebml_float(pb, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate);
00595 if (bit_depth)
00596 put_ebml_uint(pb, MATROSKA_ID_AUDIOBITDEPTH, bit_depth);
00597 end_ebml_master(pb, subinfo);
00598 break;
00599
00600 case CODEC_TYPE_SUBTITLE:
00601 put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, MATROSKA_TRACK_TYPE_SUBTITLE);
00602 break;
00603 default:
00604 av_log(s, AV_LOG_ERROR, "Only audio, video, and subtitles are supported for Matroska.");
00605 break;
00606 }
00607 ret = mkv_write_codecprivate(s, pb, codec, native_id);
00608 if (ret < 0) return ret;
00609
00610 end_ebml_master(pb, track);
00611
00612
00613 av_set_pts_info(st, 64, 1, 1000);
00614 }
00615 end_ebml_master(pb, tracks);
00616 return 0;
00617 }
00618
00619 static int mkv_write_header(AVFormatContext *s)
00620 {
00621 MatroskaMuxContext *mkv = s->priv_data;
00622 ByteIOContext *pb = s->pb;
00623 ebml_master ebml_header, segment_info;
00624 int ret;
00625
00626 mkv->md5_ctx = av_mallocz(av_md5_size);
00627 av_md5_init(mkv->md5_ctx);
00628
00629 ebml_header = start_ebml_master(pb, EBML_ID_HEADER, 0);
00630 put_ebml_uint (pb, EBML_ID_EBMLVERSION , 1);
00631 put_ebml_uint (pb, EBML_ID_EBMLREADVERSION , 1);
00632 put_ebml_uint (pb, EBML_ID_EBMLMAXIDLENGTH , 4);
00633 put_ebml_uint (pb, EBML_ID_EBMLMAXSIZELENGTH , 8);
00634 put_ebml_string (pb, EBML_ID_DOCTYPE , "matroska");
00635 put_ebml_uint (pb, EBML_ID_DOCTYPEVERSION , 2);
00636 put_ebml_uint (pb, EBML_ID_DOCTYPEREADVERSION , 2);
00637 end_ebml_master(pb, ebml_header);
00638
00639 mkv->segment = start_ebml_master(pb, MATROSKA_ID_SEGMENT, 0);
00640 mkv->segment_offset = url_ftell(pb);
00641
00642
00643
00644
00645
00646
00647 mkv->main_seekhead = mkv_start_seekhead(pb, mkv->segment_offset, 10);
00648 mkv->cluster_seekhead = mkv_start_seekhead(pb, mkv->segment_offset, 0);
00649 if (mkv->main_seekhead == NULL || mkv->cluster_seekhead == NULL)
00650 return AVERROR(ENOMEM);
00651
00652 ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_INFO, url_ftell(pb));
00653 if (ret < 0) return ret;
00654
00655 segment_info = start_ebml_master(pb, MATROSKA_ID_INFO, 0);
00656 put_ebml_uint(pb, MATROSKA_ID_TIMECODESCALE, 1000000);
00657 if (strlen(s->title))
00658 put_ebml_string(pb, MATROSKA_ID_TITLE, s->title);
00659 if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
00660 put_ebml_string(pb, MATROSKA_ID_MUXINGAPP , LIBAVFORMAT_IDENT);
00661 put_ebml_string(pb, MATROSKA_ID_WRITINGAPP, LIBAVFORMAT_IDENT);
00662
00663
00664 mkv->segment_uid = url_ftell(pb);
00665 put_ebml_void(pb, 19);
00666 }
00667
00668
00669 mkv->duration = 0;
00670 mkv->duration_offset = url_ftell(pb);
00671 put_ebml_void(pb, 11);
00672 end_ebml_master(pb, segment_info);
00673
00674 ret = mkv_write_tracks(s);
00675 if (ret < 0) return ret;
00676
00677 ret = mkv_add_seekhead_entry(mkv->cluster_seekhead, MATROSKA_ID_CLUSTER, url_ftell(pb));
00678 if (ret < 0) return ret;
00679
00680 mkv->cluster_pos = url_ftell(pb);
00681 mkv->cluster = start_ebml_master(pb, MATROSKA_ID_CLUSTER, 0);
00682 put_ebml_uint(pb, MATROSKA_ID_CLUSTERTIMECODE, 0);
00683 mkv->cluster_pts = 0;
00684
00685 mkv->cues = mkv_start_cues(mkv->segment_offset);
00686 if (mkv->cues == NULL)
00687 return AVERROR(ENOMEM);
00688
00689 return 0;
00690 }
00691
00692 static int mkv_block_size(AVPacket *pkt)
00693 {
00694 int size = 4;
00695 return size + pkt->size;
00696 }
00697
00698 static int mkv_blockgroup_size(AVPacket *pkt)
00699 {
00700 int size = mkv_block_size(pkt);
00701 size += ebml_num_size(size);
00702 size += 2;
00703 size += 8;
00704 size += ebml_num_size(size);
00705 size += 1;
00706 return size;
00707 }
00708
00709 static void mkv_write_block(AVFormatContext *s, unsigned int blockid, AVPacket *pkt, int flags)
00710 {
00711 MatroskaMuxContext *mkv = s->priv_data;
00712 ByteIOContext *pb = s->pb;
00713
00714 av_log(s, AV_LOG_DEBUG, "Writing block at offset %" PRIu64 ", size %d, "
00715 "pts %" PRId64 ", dts %" PRId64 ", duration %d, flags %d\n",
00716 url_ftell(pb), pkt->size, pkt->pts, pkt->dts, pkt->duration, flags);
00717 put_ebml_id(pb, blockid);
00718 put_ebml_num(pb, mkv_block_size(pkt), 0);
00719 put_byte(pb, 0x80 | (pkt->stream_index + 1));
00720 put_be16(pb, pkt->pts - mkv->cluster_pts);
00721 put_byte(pb, flags);
00722 put_buffer(pb, pkt->data, pkt->size);
00723 }
00724
00725 static int mkv_write_packet(AVFormatContext *s, AVPacket *pkt)
00726 {
00727 MatroskaMuxContext *mkv = s->priv_data;
00728 ByteIOContext *pb = s->pb;
00729 AVCodecContext *codec = s->streams[pkt->stream_index]->codec;
00730 int keyframe = !!(pkt->flags & PKT_FLAG_KEY);
00731 int ret;
00732
00733
00734 if (url_ftell(pb) > mkv->cluster_pos + 5*1024*1024 || pkt->pts > mkv->cluster_pts + 5000) {
00735 av_log(s, AV_LOG_DEBUG, "Starting new cluster at offset %" PRIu64
00736 " bytes, pts %" PRIu64 "\n", url_ftell(pb), pkt->pts);
00737 end_ebml_master(pb, mkv->cluster);
00738
00739 ret = mkv_add_seekhead_entry(mkv->cluster_seekhead, MATROSKA_ID_CLUSTER, url_ftell(pb));
00740 if (ret < 0) return ret;
00741
00742 mkv->cluster_pos = url_ftell(pb);
00743 mkv->cluster = start_ebml_master(pb, MATROSKA_ID_CLUSTER, 0);
00744 put_ebml_uint(pb, MATROSKA_ID_CLUSTERTIMECODE, pkt->pts);
00745 mkv->cluster_pts = pkt->pts;
00746 av_md5_update(mkv->md5_ctx, pkt->data, FFMIN(200, pkt->size));
00747 }
00748
00749 if (codec->codec_id == CODEC_ID_H264 &&
00750 codec->extradata_size > 0 && AV_RB32(codec->extradata) == 0x00000001) {
00751
00752
00753 int ret = ff_avc_parse_nal_units(pkt->data, &pkt->data, &pkt->size);
00754 if (ret < 0)
00755 return ret;
00756 assert(pkt->size);
00757 }
00758
00759 if (codec->codec_type != CODEC_TYPE_SUBTITLE) {
00760 mkv_write_block(s, MATROSKA_ID_SIMPLEBLOCK, pkt, keyframe << 7);
00761 } else {
00762 ebml_master blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, mkv_blockgroup_size(pkt));
00763 mkv_write_block(s, MATROSKA_ID_BLOCK, pkt, 0);
00764 put_ebml_uint(pb, MATROSKA_ID_DURATION, pkt->duration);
00765 end_ebml_master(pb, blockgroup);
00766 }
00767
00768 if (codec->codec_type == CODEC_TYPE_VIDEO && keyframe) {
00769 ret = mkv_add_cuepoint(mkv->cues, pkt, mkv->cluster_pos);
00770 if (ret < 0) return ret;
00771 }
00772
00773 mkv->duration = FFMAX(mkv->duration, pkt->pts + pkt->duration);
00774 return 0;
00775 }
00776
00777 static int mkv_write_trailer(AVFormatContext *s)
00778 {
00779 MatroskaMuxContext *mkv = s->priv_data;
00780 ByteIOContext *pb = s->pb;
00781 offset_t currentpos, second_seekhead, cuespos;
00782 int ret;
00783
00784 end_ebml_master(pb, mkv->cluster);
00785
00786 if (!url_is_streamed(pb)) {
00787 cuespos = mkv_write_cues(pb, mkv->cues, s->nb_streams);
00788 second_seekhead = mkv_write_seekhead(pb, mkv->cluster_seekhead);
00789
00790 ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_CUES , cuespos);
00791 if (ret < 0) return ret;
00792 ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_SEEKHEAD, second_seekhead);
00793 if (ret < 0) return ret;
00794 mkv_write_seekhead(pb, mkv->main_seekhead);
00795
00796
00797 av_log(s, AV_LOG_DEBUG, "end duration = %" PRIu64 "\n", mkv->duration);
00798 currentpos = url_ftell(pb);
00799 url_fseek(pb, mkv->duration_offset, SEEK_SET);
00800 put_ebml_float(pb, MATROSKA_ID_DURATION, mkv->duration);
00801
00802
00803 if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
00804 uint8_t segment_uid[16];
00805 av_md5_final(mkv->md5_ctx, segment_uid);
00806 url_fseek(pb, mkv->segment_uid, SEEK_SET);
00807 put_ebml_binary(pb, MATROSKA_ID_SEGMENTUID, segment_uid, 16);
00808 }
00809 url_fseek(pb, currentpos, SEEK_SET);
00810 }
00811
00812 end_ebml_master(pb, mkv->segment);
00813 av_free(mkv->md5_ctx);
00814 return 0;
00815 }
00816
00817 AVOutputFormat matroska_muxer = {
00818 "matroska",
00819 "Matroska File Format",
00820 "video/x-matroska",
00821 "mkv",
00822 sizeof(MatroskaMuxContext),
00823 CODEC_ID_MP2,
00824 CODEC_ID_MPEG4,
00825 mkv_write_header,
00826 mkv_write_packet,
00827 mkv_write_trailer,
00828 .codec_tag = (const AVCodecTag*[]){codec_bmp_tags, codec_wav_tags, 0},
00829 .subtitle_codec = CODEC_ID_TEXT,
00830 };
00831
00832 AVOutputFormat matroska_audio_muxer = {
00833 "matroska",
00834 "Matroska File Format",
00835 "audio/x-matroska",
00836 "mka",
00837 sizeof(MatroskaMuxContext),
00838 CODEC_ID_MP2,
00839 CODEC_ID_NONE,
00840 mkv_write_header,
00841 mkv_write_packet,
00842 mkv_write_trailer,
00843 .codec_tag = (const AVCodecTag*[]){codec_wav_tags, 0},
00844 };