diff options
Diffstat (limited to 'libavformat/movenc.c')
-rw-r--r-- | libavformat/movenc.c | 334 |
1 files changed, 306 insertions, 28 deletions
diff --git a/libavformat/movenc.c b/libavformat/movenc.c index 0463528362..2e8ef90e0e 100644 --- a/libavformat/movenc.c +++ b/libavformat/movenc.c @@ -4,20 +4,20 @@ * Copyright (c) 2004 Gildas Bazin <gbazin at videolan dot org> * Copyright (c) 2009 Baptiste Coudurier <baptiste dot coudurier at gmail dot com> * - * This file is part of Libav. + * This file is part of FFmpeg. * - * Libav is free software; you can redistribute it and/or + * FFmpeg is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * - * Libav is distributed in the hope that it will be useful, + * FFmpeg is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with Libav; if not, write to the Free Software + * License along with FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ @@ -45,8 +45,11 @@ static const AVOption options[] = { { "movflags", "MOV muxer flags", offsetof(MOVMuxContext, flags), AV_OPT_TYPE_FLAGS, {.dbl = 0}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" }, { "rtphint", "Add RTP hint tracks", 0, AV_OPT_TYPE_CONST, {.dbl = FF_MOV_FLAG_RTP_HINT}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" }, + { "moov_size", "maximum moov size so it can be placed at the begin", offsetof(MOVMuxContext, reserved_moov_size), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, 0 }, + { "frag_size", "maximum fragment size", offsetof(MOVMuxContext, max_fragment_size), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, 0 }, + { "frag_duration", "maximum fragment duration", offsetof(MOVMuxContext, max_fragment_duration), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, 0 }, FF_RTP_FLAG_OPTS(MOVMuxContext, rtp_flags), - { "skip_iods", "Skip writing iods atom.", offsetof(MOVMuxContext, iods_skip), AV_OPT_TYPE_INT, {.dbl = 0}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM}, + { "skip_iods", "Skip writing iods atom.", offsetof(MOVMuxContext, iods_skip), AV_OPT_TYPE_INT, {.dbl = 1}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM}, { "iods_audio_profile", "iods audio profile atom.", offsetof(MOVMuxContext, iods_audio_profile), AV_OPT_TYPE_INT, {.dbl = -1}, -1, 255, AV_OPT_FLAG_ENCODING_PARAM}, { "iods_video_profile", "iods video profile atom.", offsetof(MOVMuxContext, iods_video_profile), AV_OPT_TYPE_INT, {.dbl = -1}, -1, 255, AV_OPT_FLAG_ENCODING_PARAM}, { NULL }, @@ -60,6 +63,8 @@ static const AVClass flavor ## _muxer_class = {\ .version = LIBAVUTIL_VERSION_INT,\ }; +static int update_first_fragment(AVFormatContext *s); + //FIXME support 64 bit variant with wide placeholders static int64_t updateSize(AVIOContext *pb, int64_t pos) { @@ -84,8 +89,10 @@ static int mov_write_stco_tag(AVIOContext *pb, MOVTrack *track) } else ffio_wfourcc(pb, "stco"); avio_wb32(pb, 0); /* version & flags */ - avio_wb32(pb, track->entry); /* entry count */ + avio_wb32(pb, track->chunkCount); /* entry count */ for (i=0; i<track->entry; i++) { + if(!track->cluster[i].chunkNum) + continue; if(mode64 == 1) avio_wb64(pb, track->cluster[i].pos); else @@ -143,11 +150,11 @@ static int mov_write_stsc_tag(AVIOContext *pb, MOVTrack *track) ffio_wfourcc(pb, "stsc"); avio_wb32(pb, 0); // version & flags entryPos = avio_tell(pb); - avio_wb32(pb, track->entry); // entry count + avio_wb32(pb, track->chunkCount); // entry count for (i=0; i<track->entry; i++) { - if(oldval != track->cluster[i].samplesInChunk) + if(oldval != track->cluster[i].samplesInChunk && track->cluster[i].chunkNum) { - avio_wb32(pb, i+1); // first chunk + avio_wb32(pb, track->cluster[i].chunkNum); // first chunk avio_wb32(pb, track->cluster[i].samplesInChunk); // samples per chunk avio_wb32(pb, 0x1); // sample description index oldval = track->cluster[i].samplesInChunk; @@ -271,10 +278,20 @@ static void putDescr(AVIOContext *pb, int tag, unsigned int size) avio_w8(pb, size & 0x7F); } +static unsigned compute_avg_bitrate(MOVTrack *track) +{ + uint64_t size = 0; + int i; + for (i = 0; i < track->entry; i++) + size += track->cluster[i].size; + return size * 8 * track->timescale / track->trackDuration; +} + static int mov_write_esds_tag(AVIOContext *pb, MOVTrack *track) // Basic { int64_t pos = avio_tell(pb); int decoderSpecificInfoLen = track->vosLen ? 5+track->vosLen : 0; + unsigned avg_bitrate; avio_wb32(pb, 0); // size ffio_wfourcc(pb, "esds"); @@ -306,11 +323,10 @@ static int mov_write_esds_tag(AVIOContext *pb, MOVTrack *track) // Basic avio_w8(pb, track->enc->rc_buffer_size>>(3+16)); // Buffersize DB (24 bits) avio_wb16(pb, (track->enc->rc_buffer_size>>3)&0xFFFF); // Buffersize DB - avio_wb32(pb, FFMAX(track->enc->bit_rate, track->enc->rc_max_rate)); // maxbitrate (FIXME should be max rate in any 1 sec window) - if(track->enc->rc_max_rate != track->enc->rc_min_rate || track->enc->rc_min_rate==0) - avio_wb32(pb, 0); // vbr - else - avio_wb32(pb, track->enc->rc_max_rate); // avg bitrate + avg_bitrate = compute_avg_bitrate(track); + // maxbitrate (FIXME should be max rate in any 1 sec window) + avio_wb32(pb, FFMAX3(track->enc->bit_rate, track->enc->rc_max_rate, avg_bitrate)); + avio_wb32(pb, avg_bitrate); if (track->vosLen) { // DecoderSpecific info descriptor @@ -1387,14 +1403,14 @@ static int mov_write_udta_sdp(AVIOContext *pb, AVFormatContext *ctx, int index) return len + 24; } -static int mov_write_trak_tag(AVIOContext *pb, MOVTrack *track, AVStream *st) +static int mov_write_trak_tag(AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track, AVStream *st) { int64_t pos = avio_tell(pb); avio_wb32(pb, 0); /* size */ ffio_wfourcc(pb, "trak"); mov_write_tkhd_tag(pb, track, st); - if (track->mode == MODE_PSP || track->flags & MOV_TRACK_CTTS || track->cluster[0].dts) - mov_write_edts_tag(pb, track); // PSP Movies require edts box + if(!mov->fragments) // EDTS with fragments is tricky as we dont know the duration when its written + mov_write_edts_tag(pb, track); // PSP Movies and several other cases require edts box if (track->tref_tag) mov_write_tref_tag(pb, track); mov_write_mdia_tag(pb, track); @@ -1410,6 +1426,72 @@ static int mov_write_trak_tag(AVIOContext *pb, MOVTrack *track, AVStream *st) return updateSize(pb, pos); } +static int mov_write_tfhd_tag(AVIOContext *pb, MOVTrack *track, AVStream *st) +{ + int64_t pos = avio_tell(pb); + int flags=1; + + avio_wb32(pb, 0); + ffio_wfourcc(pb, "tfhd"); + avio_w8(pb, 0); + avio_wb24(pb, flags); + avio_wb32(pb, track->trackID); + + track->base_data_offset_pos= avio_tell(pb); + if (flags & 0x01) avio_wb64(pb, 0); + + return updateSize(pb, pos); +} + +static int mov_write_trun_tag(AVIOContext *pb, MOVTrack *track) +{ + int64_t pos = avio_tell(pb); + int sample_count= track->entry - track->cluster_write_index; + int tr_flags=0; + int i; + + for(i=track->cluster_write_index; i<track->entry; i++){ + int64_t duration = i + 1 == track->entry ? + track->trackDuration - track->cluster[i].dts + track->cluster[0].dts : /* readjusting */ + track->cluster[i+1].dts - track->cluster[i].dts; + if(duration != 1) tr_flags |= 0x100; + if(track->trex_size != track->cluster[i].size) tr_flags |= 0x200; + if(track->trex_flags != ((track->cluster[i].flags&MOV_SYNC_SAMPLE) ? 0x02000000 : 0x01010000)) + tr_flags |= 0x400; + if(track->cluster[i].cts) tr_flags |= 0x800; + } + + avio_wb32(pb, 0); + ffio_wfourcc(pb, "trun"); + avio_w8(pb, 0); + avio_wb24(pb, tr_flags); + avio_wb32(pb, sample_count); + if(tr_flags&1) avio_wb32(pb, 0); + + for(i=track->cluster_write_index; i<track->entry; i++){ + int64_t duration = i + 1 == track->entry ? + track->trackDuration - track->cluster[i].dts + track->cluster[0].dts : /* readjusting */ + track->cluster[i+1].dts - track->cluster[i].dts; + + if(tr_flags&0x100) avio_wb32(pb, duration); + if(tr_flags&0x200) avio_wb32(pb, track->cluster[i].size); + if(tr_flags&0x400) avio_wb32(pb, (track->cluster[i].flags&MOV_SYNC_SAMPLE) ? 0x02000000 : 0x01010000); + if(tr_flags&0x800) avio_wb32(pb, track->cluster[i].cts); + } + + return updateSize(pb, pos); +} + +static int mov_write_traf_tag(AVIOContext *pb, MOVTrack *track, AVStream *st) +{ + int64_t pos = avio_tell(pb); + avio_wb32(pb, 0); /* size */ + ffio_wfourcc(pb, "traf"); + mov_write_tfhd_tag(pb, track, st); + mov_write_trun_tag(pb, track); + return updateSize(pb, pos); +} + static int mov_write_iods_tag(AVIOContext *pb, MOVMuxContext *mov) { int i, has_audio = 0, has_video = 0; @@ -1816,6 +1898,61 @@ static int mov_write_uuidusmt_tag(AVIOContext *pb, AVFormatContext *s) return 0; } +static void build_chunks(MOVTrack *trk) +{ + int i; + MOVIentry *chunk= &trk->cluster[0]; + uint64_t chunkSize = chunk->size; + chunk->chunkNum= 1; + trk->chunkCount= 1; + for(i=1; i<trk->entry; i++){ + if(chunk->pos + chunkSize == trk->cluster[i].pos){ + chunkSize += trk->cluster[i].size; + chunk->samplesInChunk += trk->cluster[i].entries; + }else{ + trk->cluster[i].chunkNum = chunk->chunkNum+1; + chunk=&trk->cluster[i]; + chunkSize = chunk->size; + trk->chunkCount++; + } + } +} + +static int mov_write_trex_tag(AVIOContext *pb, MOVTrack *track, AVStream *st) +{ + int64_t pos = avio_tell(pb); + avio_wb32(pb, 0); /* size */ + ffio_wfourcc(pb, "trex"); + + avio_w8(pb, 0); + avio_wb24(pb, 0); + avio_wb32(pb, track->trackID); + avio_wb32(pb, 1); // stsd_id + avio_wb32(pb, 1); // duration + track->trex_size= track->entry ? track->cluster[FFMIN(1, track->entry-1)].size : 1; + avio_wb32(pb, track->trex_size); + track->trex_flags= st->codec->codec_type != AVMEDIA_TYPE_VIDEO ? 0x02000000 : 0x01010000; + avio_wb32(pb, track->trex_flags); + return updateSize(pb, pos); +} + +static int mov_write_mvex_tag(AVIOContext *pb, MOVMuxContext *mov, + AVFormatContext *s) +{ + int i; + int64_t pos = avio_tell(pb); + avio_wb32(pb, 0); /* size placeholder*/ + ffio_wfourcc(pb, "mvex"); + + for (i=0; i<mov->nb_streams; i++) { + if(mov->tracks[i].entry > 0) { + mov_write_trex_tag(pb, &(mov->tracks[i]), i < s->nb_streams ? s->streams[i] : NULL); + } + } + + return updateSize(pb, pos); +} + static int mov_write_moov_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s) { @@ -1829,6 +1966,8 @@ static int mov_write_moov_tag(AVIOContext *pb, MOVMuxContext *mov, mov->tracks[i].time = mov->time; mov->tracks[i].trackID = i+1; + + build_chunks(&mov->tracks[i]); } if (mov->chapter_track) @@ -1849,10 +1988,13 @@ static int mov_write_moov_tag(AVIOContext *pb, MOVMuxContext *mov, mov_write_iods_tag(pb, mov); for (i=0; i<mov->nb_streams; i++) { if(mov->tracks[i].entry > 0) { - mov_write_trak_tag(pb, &(mov->tracks[i]), i < s->nb_streams ? s->streams[i] : NULL); + mov_write_trak_tag(pb, mov, &(mov->tracks[i]), i < s->nb_streams ? s->streams[i] : NULL); } } + if(mov->fragments) + mov_write_mvex_tag(pb, mov, s); + if (mov->mode == MODE_PSP) mov_write_uuidusmt_tag(pb, s); else @@ -1861,6 +2003,36 @@ static int mov_write_moov_tag(AVIOContext *pb, MOVMuxContext *mov, return updateSize(pb, pos); } +static int mov_write_mfhd_tag(AVIOContext *pb, MOVMuxContext *mov) +{ + int i; + int64_t pos = avio_tell(pb); + avio_wb32(pb, 0); /* size placeholder*/ + ffio_wfourcc(pb, "mfhd"); + avio_wb32(pb, 0); + avio_wb32(pb, mov->frag_seq_num++); + + return updateSize(pb, pos); //FIXME replace by hardcoded num also above +} + +static int mov_write_moof_tag(AVIOContext *pb, MOVMuxContext *mov, + AVFormatContext *s) +{ + int i; + int64_t pos = avio_tell(pb); + avio_wb32(pb, 0); /* size placeholder*/ + ffio_wfourcc(pb, "moof"); + + mov_write_mfhd_tag(pb, mov); + for (i=0; i<mov->nb_streams; i++) { + if(mov->tracks[i].entry > 0) { + mov_write_traf_tag(pb, &(mov->tracks[i]), i < s->nb_streams ? s->streams[i] : NULL); + } + } + + return updateSize(pb, pos); +} + static int mov_write_mdat_tag(AVIOContext *pb, MOVMuxContext *mov) { avio_wb32(pb, 8); // placeholder for extended size field (64 bit) @@ -2011,11 +2183,54 @@ static int mov_parse_mpeg2_frame(AVPacket *pkt, uint32_t *flags) return 0; } +static int flush_cluster_buffer(AVFormatContext *s){ + MOVMuxContext *mov = s->priv_data; + int i, j; + int has_data=0; + + for (i=0; i<mov->nb_streams; i++){ + MOVTrack *track= &mov->tracks[i]; + if(track->entry != track->cluster_write_index) + has_data=1; + } + + if(mov->frag_seq_num==0){ + update_first_fragment(s); + mov->frag_seq_num++; + }else if(has_data) { + mov_write_moof_tag(s->pb, mov, s); + mov_write_mdat_tag(s->pb, mov); + for (i=0; i<mov->nb_streams; i++){ + MOVTrack *track= &mov->tracks[i]; + if(track->entry > 0) { + int64_t pos= avio_tell(s->pb); + avio_seek(s->pb, track->base_data_offset_pos, SEEK_SET); + avio_wb64(s->pb, pos); + avio_seek(s->pb, pos, SEEK_SET); + for(j=track->cluster_write_index; j<track->entry; j++){ + avio_write(s->pb, track->cluster[j].data, track->cluster[j].size); + av_freep(&track->cluster[j].data); + } + } + } + updateSize(s->pb, mov->mdat_pos); + } + mov->mdat_size = 0; + for (i=0; i<mov->nb_streams; i++) { + MOVTrack *track= &mov->tracks[i]; + track->cluster_write_index= track->entry; + } + avio_flush(s->pb); + + return 0; +} + int ff_mov_write_packet(AVFormatContext *s, AVPacket *pkt) { MOVMuxContext *mov = s->priv_data; AVIOContext *pb = s->pb; MOVTrack *trk = &mov->tracks[pkt->stream_index]; + AVStream *st = s->streams[pkt->stream_index]; AVCodecContext *enc = trk->enc; unsigned int samplesInChunk = 0; int size= pkt->size; @@ -2024,6 +2239,13 @@ int ff_mov_write_packet(AVFormatContext *s, AVPacket *pkt) if (!s->pb->seekable) return 0; /* Can't handle that */ if (!size) return 0; /* Discard 0 sized packets */ + if (mov->fragments && trk->entry > trk->cluster_write_index && + ( mov->max_fragment_duration && av_rescale_q(pkt->dts - trk->cluster[ trk->cluster_write_index ].dts, st->time_base, AV_TIME_BASE_Q) >= mov->max_fragment_duration + || mov->max_fragment_size && mov->mdat_size + size >= mov->max_fragment_size) + ){ + flush_cluster_buffer(s); + } + if (enc->codec_id == CODEC_ID_AMR_NB) { /* We must find out how many AMR blocks there are in one packet */ static uint16_t packed_size[16] = @@ -2050,16 +2272,44 @@ int ff_mov_write_packet(AVFormatContext *s, AVPacket *pkt) memcpy(trk->vosData, enc->extradata, trk->vosLen); } + if (!(trk->entry % MOV_INDEX_CLUSTER_SIZE)) { + trk->cluster = av_realloc_f(trk->cluster, sizeof(*trk->cluster), (trk->entry + MOV_INDEX_CLUSTER_SIZE)); + if (!trk->cluster) + return -1; + } + if (enc->codec_id == CODEC_ID_H264 && trk->vosLen > 0 && *(uint8_t *)trk->vosData != 1) { /* from x264 or from bytestream h264 */ /* nal reformating needed */ - if (trk->hint_track >= 0 && trk->hint_track < mov->nb_streams) { + if(mov->frag_seq_num>0){ + uint8_t *buf=NULL; + size= pkt->size; + + if(ff_avc_parse_nal_units_buf(pkt->data, &buf, &size) < 0){ + av_log(s, AV_LOG_ERROR, "malformated H264 bitstream\n"); + return -1; + } + trk->cluster[trk->entry].data= buf; + if (trk->hint_track >= 0 && trk->hint_track < mov->nb_streams) { + reformatted_data= av_malloc(size); + memcpy(reformatted_data, buf, size); + } + }else if (trk->hint_track >= 0 && trk->hint_track < mov->nb_streams) { ff_avc_parse_nal_units_buf(pkt->data, &reformatted_data, &size); avio_write(pb, reformatted_data, size); } else { size = ff_avc_parse_nal_units(pb, pkt->data, pkt->size); } + } else if (enc->codec_id == CODEC_ID_AAC && pkt->size > 2 && + (AV_RB16(pkt->data) & 0xfff0) == 0xfff0) { + av_log(s, AV_LOG_ERROR, "malformated aac bitstream, use -absf aac_adtstoasc\n"); + return -1; + } else if (mov->frag_seq_num>0){ + trk->cluster[trk->entry].data = av_malloc(size); + if (!trk->cluster[trk->entry].data) + return AVERROR(ENOMEM); + memcpy(trk->cluster[trk->entry].data, pkt->data, size); } else { avio_write(pb, pkt->data, size); } @@ -2074,14 +2324,9 @@ int ff_mov_write_packet(AVFormatContext *s, AVPacket *pkt) memcpy(trk->vosData, pkt->data, size); } - if (!(trk->entry % MOV_INDEX_CLUSTER_SIZE)) { - trk->cluster = av_realloc(trk->cluster, (trk->entry + MOV_INDEX_CLUSTER_SIZE) * sizeof(*trk->cluster)); - if (!trk->cluster) - return -1; - } - - trk->cluster[trk->entry].pos = avio_tell(pb) - size; + trk->cluster[trk->entry].pos = avio_tell(pb) - (mov->frag_seq_num==0 ? size : 0); trk->cluster[trk->entry].samplesInChunk = samplesInChunk; + trk->cluster[trk->entry].chunkNum = 0; trk->cluster[trk->entry].size = size; trk->cluster[trk->entry].entries = samplesInChunk; trk->cluster[trk->entry].dts = pkt->dts; @@ -2170,6 +2415,10 @@ static int mov_write_header(AVFormatContext *s) /* Default mode == MP4 */ mov->mode = MODE_MP4; + if(mov->max_fragment_duration || mov->max_fragment_size){ + mov->fragments= 1; + } + if (s->oformat != NULL) { if (!strcmp("3gp", s->oformat->name)) mov->mode = MODE_3GP; else if (!strcmp("3g2", s->oformat->name)) mov->mode = MODE_3GP|MODE_3G2; @@ -2289,6 +2538,11 @@ static int mov_write_header(AVFormatContext *s) avpriv_set_pts_info(st, 64, 1, track->timescale); } + if(mov->reserved_moov_size){ + mov->reserved_moov_pos= avio_tell(pb); + avio_skip(pb, mov->reserved_moov_size); + } + mov_write_mdat_tag(pb, mov); #if FF_API_TIMESTAMP @@ -2323,7 +2577,7 @@ static int mov_write_header(AVFormatContext *s) return -1; } -static int mov_write_trailer(AVFormatContext *s) +static int update_first_fragment(AVFormatContext *s) { MOVMuxContext *mov = s->priv_data; AVIOContext *pb = s->pb; @@ -2343,9 +2597,33 @@ static int mov_write_trailer(AVFormatContext *s) ffio_wfourcc(pb, "mdat"); avio_wb64(pb, mov->mdat_size+16); } - avio_seek(pb, moov_pos, SEEK_SET); + avio_seek(pb, mov->reserved_moov_size ? mov->reserved_moov_pos : moov_pos, SEEK_SET); mov_write_moov_tag(pb, mov, s); + if(mov->reserved_moov_size){ + int64_t size= mov->reserved_moov_size - (avio_tell(pb) - mov->reserved_moov_pos); + if(size < 8){ + av_log(s, AV_LOG_ERROR, "reserved_moov_size is too small, needed %"PRId64" additional\n", 8-size); + return -1; + } + avio_wb32(pb, size); + ffio_wfourcc(pb, "free"); + for(i=0; i<size; i++) + avio_w8(pb, 0); + avio_seek(pb, moov_pos, SEEK_SET); + } + + return 0; +} + +static int mov_write_trailer(AVFormatContext *s) +{ + MOVMuxContext *mov = s->priv_data; + AVIOContext *pb = s->pb; + int res = 0; + int i; + + flush_cluster_buffer(s); if (mov->chapter_track) av_freep(&mov->tracks[mov->chapter_track].enc); |