From f8ef91ff3d6bb83d601d816ef9368f911021c64b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20B=C5=93sch?= Date: Mon, 19 Aug 2013 16:05:31 -0700 Subject: [PATCH] movenc: add faststart option for web streaming MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Faststart moves the moov atom to the beginning of the file and rewrites the rest of the file after muxing is complete. Signed-off-by: Martin Storsjö --- doc/muxers.texi | 4 ++ libavformat/movenc.c | 137 +++++++++++++++++++++++++++++++++++++++++-- libavformat/movenc.h | 3 + 3 files changed, 140 insertions(+), 4 deletions(-) diff --git a/doc/muxers.texi b/doc/muxers.texi index 742e72aa02..6e06e463f1 100644 --- a/doc/muxers.texi +++ b/doc/muxers.texi @@ -239,6 +239,10 @@ more efficient), but with this option set, the muxer writes one moof/mdat pair for each track, making it easier to separate tracks. This option is implicitly set when writing ismv (Smooth Streaming) files. +@item -movflags faststart +Run a second pass moving the index (moov atom) to the beginning of the file. +This operation can take a while, and will not work in various situations such +as fragmented output, thus it is not enabled by default. @end table Smooth Streaming content can be pushed in real time to a publishing diff --git a/libavformat/movenc.c b/libavformat/movenc.c index 39d4e44a44..49b4fa13b7 100644 --- a/libavformat/movenc.c +++ b/libavformat/movenc.c @@ -51,6 +51,7 @@ static const AVOption options[] = { { "separate_moof", "Write separate moof/mdat atoms for each track", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_SEPARATE_MOOF}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" }, { "frag_custom", "Flush fragments on caller requests", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_FRAG_CUSTOM}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" }, { "isml", "Create a live smooth streaming feed (for pushing to a publishing point)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_ISML}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" }, + { "faststart", "Run a second pass to put the index (moov atom) at the beginning of the file", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_FASTSTART}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" }, FF_RTP_FLAG_OPTS(MOVMuxContext, rtp_flags), { "skip_iods", "Skip writing iods atom.", offsetof(MOVMuxContext, iods_skip), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM}, { "iods_audio_profile", "iods audio profile atom.", offsetof(MOVMuxContext, iods_audio_profile), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 255, AV_OPT_FLAG_ENCODING_PARAM}, @@ -3027,6 +3028,13 @@ static int mov_write_header(AVFormatContext *s) FF_MOV_FLAG_FRAG_CUSTOM)) mov->flags |= FF_MOV_FLAG_FRAGMENT; + /* faststart: moov at the beginning of the file, if supported */ + if (mov->flags & FF_MOV_FLAG_FASTSTART) { + if ((mov->flags & FF_MOV_FLAG_FRAGMENT) || + (s->flags & AVFMT_FLAG_CUSTOM_IO)) + mov->flags &= ~FF_MOV_FLAG_FASTSTART; + } + /* Non-seekable output is ok if using fragmentation. If ism_lookahead * is enabled, we don't support non-seekable output at all. */ if (!s->pb->seekable && @@ -3169,8 +3177,11 @@ static int mov_write_header(AVFormatContext *s) FF_MOV_FLAG_FRAGMENT; } - if (!(mov->flags & FF_MOV_FLAG_FRAGMENT)) + if (!(mov->flags & FF_MOV_FLAG_FRAGMENT)) { + if (mov->flags & FF_MOV_FLAG_FASTSTART) + mov->reserved_moov_pos = avio_tell(pb); mov_write_mdat_tag(pb, mov); + } if (t = av_dict_get(s->metadata, "creation_time", NULL, 0)) mov->time = ff_iso8601_to_unix_time(t->value); @@ -3208,6 +3219,115 @@ static int mov_write_header(AVFormatContext *s) return -1; } +static int get_moov_size(AVFormatContext *s) +{ + int ret; + uint8_t *buf; + AVIOContext *moov_buf; + MOVMuxContext *mov = s->priv_data; + + if ((ret = avio_open_dyn_buf(&moov_buf)) < 0) + return ret; + mov_write_moov_tag(moov_buf, mov, s); + ret = avio_close_dyn_buf(moov_buf, &buf); + av_free(buf); + return ret; +} + +/* + * This function gets the moov size if moved to the top of the file: the chunk + * offset table can switch between stco (32-bit entries) to co64 (64-bit + * entries) when the moov is moved to the beginning, so the size of the moov + * would change. It also updates the chunk offset tables. + */ +static int compute_moov_size(AVFormatContext *s) +{ + int i, moov_size, moov_size2; + MOVMuxContext *mov = s->priv_data; + + moov_size = get_moov_size(s); + if (moov_size < 0) + return moov_size; + + for (i = 0; i < mov->nb_streams; i++) + mov->tracks[i].data_offset += moov_size; + + moov_size2 = get_moov_size(s); + if (moov_size2 < 0) + return moov_size2; + + /* if the size changed, we just switched from stco to co64 and need to + * update the offsets */ + if (moov_size2 != moov_size) + for (i = 0; i < mov->nb_streams; i++) + mov->tracks[i].data_offset += moov_size2 - moov_size; + + return moov_size2; +} + +static int shift_data(AVFormatContext *s) +{ + int ret = 0, moov_size; + MOVMuxContext *mov = s->priv_data; + int64_t pos, pos_end = avio_tell(s->pb); + uint8_t *buf, *read_buf[2]; + int read_buf_id = 0; + int read_size[2]; + AVIOContext *read_pb; + + moov_size = compute_moov_size(s); + if (moov_size < 0) + return moov_size; + + buf = av_malloc(moov_size * 2); + if (!buf) + return AVERROR(ENOMEM); + read_buf[0] = buf; + read_buf[1] = buf + moov_size; + + /* Shift the data: the AVIO context of the output can only be used for + * writing, so we re-open the same output, but for reading. It also avoids + * a read/seek/write/seek back and forth. */ + avio_flush(s->pb); + ret = avio_open(&read_pb, s->filename, AVIO_FLAG_READ); + if (ret < 0) { + av_log(s, AV_LOG_ERROR, "Unable to re-open %s output file for " + "the second pass (faststart)\n", s->filename); + goto end; + } + + /* mark the end of the shift to up to the last data we wrote, and get ready + * for writing */ + pos_end = avio_tell(s->pb); + avio_seek(s->pb, mov->reserved_moov_pos + moov_size, SEEK_SET); + + /* start reading at where the new moov will be placed */ + avio_seek(read_pb, mov->reserved_moov_pos, SEEK_SET); + pos = avio_tell(read_pb); + +#define READ_BLOCK do { \ + read_size[read_buf_id] = avio_read(read_pb, read_buf[read_buf_id], moov_size); \ + read_buf_id ^= 1; \ +} while (0) + + /* shift data by chunk of at most moov_size */ + READ_BLOCK; + do { + int n; + READ_BLOCK; + n = read_size[read_buf_id]; + if (n <= 0) + break; + avio_write(s->pb, read_buf[read_buf_id], n); + pos += n; + } while (pos < pos_end); + avio_close(read_pb); + +end: + av_free(buf); + return ret; +} + static int mov_write_trailer(AVFormatContext *s) { MOVMuxContext *mov = s->priv_data; @@ -3226,9 +3346,9 @@ static int mov_write_trailer(AVFormatContext *s) } } - moov_pos = avio_tell(pb); - if (!(mov->flags & FF_MOV_FLAG_FRAGMENT)) { + moov_pos = avio_tell(pb); + /* Write size of mdat tag */ if (mov->mdat_size + 8 <= UINT32_MAX) { avio_seek(pb, mov->mdat_pos, SEEK_SET); @@ -3244,7 +3364,16 @@ static int mov_write_trailer(AVFormatContext *s) } avio_seek(pb, moov_pos, SEEK_SET); - mov_write_moov_tag(pb, mov, s); + if (mov->flags & FF_MOV_FLAG_FASTSTART) { + av_log(s, AV_LOG_INFO, "Starting second pass: moving the moov atom to the beginning of the file\n"); + res = shift_data(s); + if (res == 0) { + avio_seek(s->pb, mov->reserved_moov_pos, SEEK_SET); + mov_write_moov_tag(pb, mov, s); + } + } else { + mov_write_moov_tag(pb, mov, s); + } } else { mov_flush_fragment(s); mov_write_mfra_tag(pb, mov); diff --git a/libavformat/movenc.h b/libavformat/movenc.h index d15d69ccaa..a6282e14c7 100644 --- a/libavformat/movenc.h +++ b/libavformat/movenc.h @@ -156,6 +156,8 @@ typedef struct MOVMuxContext { int max_fragment_size; int ism_lookahead; AVIOContext *mdat_buf; + + int64_t reserved_moov_pos; } MOVMuxContext; #define FF_MOV_FLAG_RTP_HINT 1 @@ -165,6 +167,7 @@ typedef struct MOVMuxContext { #define FF_MOV_FLAG_SEPARATE_MOOF 16 #define FF_MOV_FLAG_FRAG_CUSTOM 32 #define FF_MOV_FLAG_ISML 64 +#define FF_MOV_FLAG_FASTSTART 128 int ff_mov_write_packet(AVFormatContext *s, AVPacket *pkt);