X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;ds=sidebyside;f=libavformat%2Fmovenc.c;h=8af3c3419f843c5d0cd4bcd12b0e4512bbdb9d5b;hb=4b1f5e5090abed6c618c8ba380cd7d28d140f867;hp=ef038577affc183fefef10154fe3436e2528c7a9;hpb=21732063a346475eb22c332b27e8216b79f9ad4a;p=ffmpeg diff --git a/libavformat/movenc.c b/libavformat/movenc.c index ef038577aff..8af3c3419f8 100644 --- a/libavformat/movenc.c +++ b/libavformat/movenc.c @@ -21,6 +21,9 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ +#include +#include + #include "movenc.h" #include "avformat.h" #include "avio_internal.h" @@ -37,6 +40,7 @@ #include "libavutil/mathematics.h" #include "libavutil/opt.h" #include "libavutil/dict.h" +#include "hevc.h" #include "rtpenc.h" #include "mov_chan.h" @@ -51,6 +55,9 @@ 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" }, + { "omit_tfhd_offset", "Omit the base data offset in tfhd atoms", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_OMIT_TFHD_OFFSET}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" }, + { "disable_chpl", "Disable Nero chapter atom", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_DISABLE_CHPL}, 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}, @@ -59,6 +66,7 @@ static const AVOption options[] = { { "min_frag_duration", "Minimum fragment duration", offsetof(MOVMuxContext, min_fragment_duration), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM}, { "frag_size", "Maximum fragment size", offsetof(MOVMuxContext, max_fragment_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM}, { "ism_lookahead", "Number of lookahead entries for ISM files", offsetof(MOVMuxContext, ism_lookahead), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM}, + { "brand", "Override major brand", offsetof(MOVMuxContext, major_brand), AV_OPT_TYPE_STRING, {.str = NULL}, .flags = AV_OPT_FLAG_ENCODING_PARAM }, { NULL }, }; @@ -70,6 +78,17 @@ static const AVClass flavor ## _muxer_class = {\ .version = LIBAVUTIL_VERSION_INT,\ }; +static int utf8len(const uint8_t *b) +{ + int len = 0; + int val; + while (*b) { + GET_UTF8(val, *b++, return -1;) + len++; + } + return len; +} + //FIXME support 64 bit variant with wide placeholders static int64_t update_size(AVIOContext *pb, int64_t pos) { @@ -81,15 +100,21 @@ static int64_t update_size(AVIOContext *pb, int64_t pos) return curpos - pos; } +static int co64_required(const MOVTrack *track) +{ + if (track->entry > 0 && track->cluster[track->entry - 1].pos + track->data_offset > UINT32_MAX) + return 1; + return 0; +} + /* Chunk offset atom */ static int mov_write_stco_tag(AVIOContext *pb, MOVTrack *track) { int i; - int mode64 = 0; // use 32 bit size variant if possible + int mode64 = co64_required(track); // use 32 bit size variant if possible int64_t pos = avio_tell(pb); avio_wb32(pb, 0); /* size */ - if (pos > UINT32_MAX) { - mode64 = 1; + if (mode64) { ffio_wfourcc(pb, "co64"); } else ffio_wfourcc(pb, "stco"); @@ -297,7 +322,9 @@ static int mov_write_esds_tag(AVIOContext *pb, MOVTrack *track) // Basic // the following fields is made of 6 bits to identify the streamtype (4 for video, 5 for audio) // plus 1 bit to indicate upstream and 1 bit set to 1 (reserved) - if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO) + if (track->enc->codec_id == AV_CODEC_ID_DVD_SUBTITLE) + avio_w8(pb, (0x38 << 2) | 1); // flags (= NeroSubpicStream) + else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO) avio_w8(pb, 0x15); // flags (= Audiostream) else avio_w8(pb, 0x11); // flags (= Visualstream) @@ -468,7 +495,13 @@ static int mov_write_dvc1_structs(MOVTrack *track, uint8_t *buf) put_bits(&pbc, 1, !slices); /* no slice code */ put_bits(&pbc, 1, 0); /* no bframe */ put_bits(&pbc, 1, 0); /* reserved */ - put_bits32(&pbc, track->enc->time_base.den); /* framerate */ + + /* framerate */ + if (track->st->avg_frame_rate.num > 0 && track->st->avg_frame_rate.den > 0) + put_bits32(&pbc, track->st->avg_frame_rate.num / track->st->avg_frame_rate.den); + else + put_bits32(&pbc, 0xffffffff); + flush_put_bits(&pbc); av_free(unescaped); @@ -675,6 +708,16 @@ static int mov_write_avcc_tag(AVIOContext *pb, MOVTrack *track) return update_size(pb, pos); } +static int mov_write_hvcc_tag(AVIOContext *pb, MOVTrack *track) +{ + int64_t pos = avio_tell(pb); + + avio_wb32(pb, 0); + ffio_wfourcc(pb, "hvcC"); + ff_isom_write_hvcc(pb, track->vos_data, track->vos_len, 0); + return update_size(pb, pos); +} + /* also used by all avid codecs (dv, imx, meridien) and their variants */ static int mov_write_avid_tag(AVIOContext *pb, MOVTrack *track) { @@ -731,12 +774,14 @@ static int mp4_get_codec_tag(AVFormatContext *s, MOVTrack *track) return 0; if (track->enc->codec_id == AV_CODEC_ID_H264) tag = MKTAG('a','v','c','1'); + else if (track->enc->codec_id == AV_CODEC_ID_HEVC) tag = MKTAG('h','e','v','1'); else if (track->enc->codec_id == AV_CODEC_ID_AC3) tag = MKTAG('a','c','-','3'); else if (track->enc->codec_id == AV_CODEC_ID_DIRAC) tag = MKTAG('d','r','a','c'); else if (track->enc->codec_id == AV_CODEC_ID_MOV_TEXT) tag = MKTAG('t','x','3','g'); else if (track->enc->codec_id == AV_CODEC_ID_VC1) tag = MKTAG('v','c','-','1'); else if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) tag = MKTAG('m','p','4','v'); else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO) tag = MKTAG('m','p','4','a'); + else if (track->enc->codec_id == AV_CODEC_ID_DVD_SUBTITLE) tag = MKTAG('m','p','4','s'); return tag; } @@ -781,10 +826,10 @@ static int mov_get_dv_codec_tag(AVFormatContext *s, MOVTrack *track) else if (track->enc->pix_fmt == AV_PIX_FMT_YUV420P) tag = MKTAG('d','v','c','p'); else tag = MKTAG('d','v','p','p'); else if (track->enc->height == 720) /* HD 720 line */ - if (track->enc->time_base.den == 50) tag = MKTAG('d','v','h','q'); + if (track->st->time_base.den == 50) tag = MKTAG('d','v','h','q'); else tag = MKTAG('d','v','h','p'); else if (track->enc->height == 1080) /* HD 1080 line */ - if (track->enc->time_base.den == 25) tag = MKTAG('d','v','h','5'); + if (track->st->time_base.den == 25) tag = MKTAG('d','v','h','5'); else tag = MKTAG('d','v','h','6'); else { av_log(s, AV_LOG_ERROR, "unsupported height for dv codec\n"); @@ -880,6 +925,15 @@ static const AVCodecTag codec_3gp_tags[] = { { AV_CODEC_ID_NONE, 0 }, }; +static const AVCodecTag codec_f4v_tags[] = { + { AV_CODEC_ID_MP3, MKTAG('.','m','p','3') }, + { AV_CODEC_ID_AAC, MKTAG('m','p','4','a') }, + { AV_CODEC_ID_H264, MKTAG('a','v','c','1') }, + { AV_CODEC_ID_VP6A, MKTAG('V','P','6','A') }, + { AV_CODEC_ID_VP6F, MKTAG('V','P','6','F') }, + { AV_CODEC_ID_NONE, 0 }, +}; + static int mov_find_codec_tag(AVFormatContext *s, MOVTrack *track) { int tag; @@ -894,6 +948,8 @@ static int mov_find_codec_tag(AVFormatContext *s, MOVTrack *track) tag = ipod_get_codec_tag(s, track); else if (track->mode & MODE_3GP) tag = ff_codec_get_tag(codec_3gp_tags, track->enc->codec_id); + else if (track->mode == MODE_F4V) + tag = ff_codec_get_tag(codec_f4v_tags, track->enc->codec_id); else tag = mov_get_codec_tag(s, track); @@ -942,7 +998,9 @@ static int mov_write_subtitle_tag(AVIOContext *pb, MOVTrack *track) avio_wb16(pb, 0); /* Reserved */ avio_wb16(pb, 1); /* Data-reference index */ - if (track->enc->extradata_size) + if (track->enc->codec_id == AV_CODEC_ID_DVD_SUBTITLE) + mov_write_esds_tag(pb, track); + else if (track->enc->extradata_size) avio_write(pb, track->enc->extradata, track->enc->extradata_size); return update_size(pb, pos); @@ -963,6 +1021,7 @@ static int mov_write_pasp_tag(AVIOContext *pb, MOVTrack *track) static int mov_write_video_tag(AVIOContext *pb, MOVTrack *track) { + AVDictionaryEntry *encoder; int64_t pos = avio_tell(pb); char compressor_name[32] = { 0 }; @@ -996,8 +1055,9 @@ static int mov_write_video_tag(AVIOContext *pb, MOVTrack *track) avio_wb16(pb, 1); /* Frame count (= 1) */ /* FIXME not sure, ISO 14496-1 draft where it shall be set to 0 */ - if (track->mode == MODE_MOV && track->enc->codec && track->enc->codec->name) - av_strlcpy(compressor_name, track->enc->codec->name, 32); + if (track->mode == MODE_MOV && + (encoder = av_dict_get(track->st->metadata, "encoder", NULL, 0))) + av_strlcpy(compressor_name, encoder->value, 32); avio_w8(pb, strlen(compressor_name)); avio_write(pb, compressor_name, 31); @@ -1014,6 +1074,8 @@ static int mov_write_video_tag(AVIOContext *pb, MOVTrack *track) mov_write_svq3_tag(pb); else if (track->enc->codec_id == AV_CODEC_ID_DNXHD) mov_write_avid_tag(pb, track); + else if (track->enc->codec_id == AV_CODEC_ID_HEVC) + mov_write_hvcc_tag(pb, track); else if (track->enc->codec_id == AV_CODEC_ID_H264) { mov_write_avcc_tag(pb, track); if (track->mode == MODE_IPOD) @@ -1022,7 +1084,11 @@ static int mov_write_video_tag(AVIOContext *pb, MOVTrack *track) mov_write_fiel_tag(pb, track); else if (track->enc->codec_id == AV_CODEC_ID_VC1 && track->vos_len > 0) mov_write_dvc1_tag(pb, track); - else if (track->vos_len > 0) + else if (track->enc->codec_id == AV_CODEC_ID_VP6F || + track->enc->codec_id == AV_CODEC_ID_VP6A) { + /* Don't write any potential extradata here - the cropping + * is signalled via the normal width/height fields. */ + } else if (track->vos_len > 0) mov_write_glbl_tag(pb, track); if (track->enc->sample_aspect_ratio.den && track->enc->sample_aspect_ratio.num && @@ -1053,6 +1119,19 @@ static int mov_write_rtp_tag(AVIOContext *pb, MOVTrack *track) return update_size(pb, pos); } +static int mov_write_tmcd_tag(AVIOContext *pb, MOVTrack *track) +{ + int64_t pos = avio_tell(pb); + + avio_wb32(pb, 0); /* size */ + ffio_wfourcc(pb, "tmcd"); /* Data format */ + avio_wb32(pb, 0); /* Reserved */ + avio_wb32(pb, 1); /* Data reference index */ + if (track->enc->extradata_size) + avio_write(pb, track->enc->extradata, track->enc->extradata_size); + return update_size(pb, pos); +} + static int mov_write_stsd_tag(AVIOContext *pb, MOVTrack *track) { int64_t pos = avio_tell(pb); @@ -1068,6 +1147,8 @@ static int mov_write_stsd_tag(AVIOContext *pb, MOVTrack *track) mov_write_subtitle_tag(pb, track); else if (track->enc->codec_tag == MKTAG('r','t','p',' ')) mov_write_rtp_tag(pb, track); + else if (track->enc->codec_tag == MKTAG('t','m','c','d')) + mov_write_tmcd_tag(pb, track); return update_size(pb, pos); } @@ -1234,16 +1315,22 @@ static int mov_write_vmhd_tag(AVIOContext *pb) return 0x14; } +static int is_clcp_track(MOVTrack *track) +{ + return track->tag == MKTAG('c','7','0','8') || + track->tag == MKTAG('c','6','0','8'); +} + static int mov_write_hdlr_tag(AVIOContext *pb, MOVTrack *track) { const char *hdlr, *descr = NULL, *hdlr_type = NULL; int64_t pos = avio_tell(pb); - if (!track) { /* no media --> data handler */ - hdlr = "dhlr"; - hdlr_type = "url "; - descr = "DataHandler"; - } else { + hdlr = "dhlr"; + hdlr_type = "url "; + descr = "DataHandler"; + + if (track) { hdlr = (track->mode == MODE_MOV) ? "mhlr" : "\0\0\0\0"; if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) { hdlr_type = "vide"; @@ -1252,12 +1339,39 @@ static int mov_write_hdlr_tag(AVIOContext *pb, MOVTrack *track) hdlr_type = "soun"; descr = "SoundHandler"; } else if (track->enc->codec_type == AVMEDIA_TYPE_SUBTITLE) { - if (track->tag == MKTAG('t','x','3','g')) hdlr_type = "sbtl"; - else hdlr_type = "text"; + if (track->tag == MKTAG('t','x','3','g')) { + hdlr_type = "sbtl"; + } else if (track->tag == MKTAG('m','p','4','s')) { + hdlr_type = "subp"; + } else if (is_clcp_track(track)) { + hdlr_type = "clcp"; + } else { + hdlr_type = "text"; + } descr = "SubtitleHandler"; } else if (track->enc->codec_tag == MKTAG('r','t','p',' ')) { hdlr_type = "hint"; descr = "HintHandler"; + } else if (track->enc->codec_tag == MKTAG('t','m','c','d')) { + hdlr_type = "tmcd"; + descr = "TimeCodeHandler"; + } else { + char tag_buf[32]; + av_get_codec_tag_string(tag_buf, sizeof(tag_buf), + track->enc->codec_tag); + + av_log(track->enc, AV_LOG_WARNING, + "Unknown hldr_type for %s / 0x%04X, writing dummy values\n", + tag_buf, track->enc->codec_tag); + } + if (track->st) { + // hdlr.name is used by some players to identify the content title + // of the track. So if an alternate handler description is + // specified, use it. + AVDictionaryEntry *t; + t = av_dict_get(track->st->metadata, "handler", NULL, 0); + if (t && utf8len(t->value)) + descr = t->value; } } @@ -1302,10 +1416,15 @@ static int mov_write_minf_tag(AVIOContext *pb, MOVTrack *track) else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO) mov_write_smhd_tag(pb); else if (track->enc->codec_type == AVMEDIA_TYPE_SUBTITLE) { - if (track->tag == MKTAG('t','e','x','t')) mov_write_gmhd_tag(pb); - else mov_write_nmhd_tag(pb); + if (track->tag == MKTAG('t','e','x','t') || is_clcp_track(track)) { + mov_write_gmhd_tag(pb); + } else { + mov_write_nmhd_tag(pb); + } } else if (track->tag == MKTAG('r','t','p',' ')) { mov_write_hmhd_tag(pb); + } else if (track->tag == MKTAG('t','m','c','d')) { + mov_write_gmhd_tag(pb); } if (track->mode == MODE_MOV) /* FIXME: Why do it for MODE_MOV only ? */ mov_write_hdlr_tag(pb, NULL); @@ -1361,11 +1480,25 @@ static int mov_write_mdia_tag(AVIOContext *pb, MOVTrack *track) return update_size(pb, pos); } -static int mov_write_tkhd_tag(AVIOContext *pb, MOVTrack *track, AVStream *st) +static int mov_write_tkhd_tag(AVIOContext *pb, MOVMuxContext *mov, + MOVTrack *track, AVStream *st) { int64_t duration = av_rescale_rnd(track->track_duration, MOV_TIMESCALE, track->timescale, AV_ROUND_UP); int version = duration < INT32_MAX ? 0 : 1; + int flags = MOV_TKHD_FLAG_IN_MOVIE; + int group = 0; + + + if (st) { + if (mov->per_stream_grouping) + group = st->index; + else + group = st->codec->codec_type; + } + + if (track->flags & MOV_TRACK_ENABLED) + flags |= MOV_TKHD_FLAG_ENABLED; if (track->mode == MODE_ISM) version = 1; @@ -1373,7 +1506,7 @@ static int mov_write_tkhd_tag(AVIOContext *pb, MOVTrack *track, AVStream *st) (version == 1) ? avio_wb32(pb, 104) : avio_wb32(pb, 92); /* size */ ffio_wfourcc(pb, "tkhd"); avio_w8(pb, version); - avio_wb24(pb, 0xf); /* flags (track enabled) */ + avio_wb24(pb, flags); if (version == 1) { avio_wb64(pb, track->time); avio_wb64(pb, track->time); @@ -1391,7 +1524,7 @@ static int mov_write_tkhd_tag(AVIOContext *pb, MOVTrack *track, AVStream *st) avio_wb32(pb, 0); /* reserved */ avio_wb32(pb, 0); /* reserved */ avio_wb16(pb, 0); /* layer */ - avio_wb16(pb, st ? st->codec->codec_type : 0); /* alternate group) */ + avio_wb16(pb, group); /* alternate group) */ /* Volume, only for audio */ if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO) avio_wb16(pb, 0x0100); @@ -1446,6 +1579,12 @@ static int mov_write_tapt_tag(AVIOContext *pb, MOVTrack *track) avio_wb32(pb, width << 16); avio_wb32(pb, track->enc->height << 16); + avio_wb32(pb, 20); + ffio_wfourcc(pb, "prof"); + avio_wb32(pb, 0); + avio_wb32(pb, width << 16); + avio_wb32(pb, track->enc->height << 16); + avio_wb32(pb, 20); ffio_wfourcc(pb, "enof"); avio_wb32(pb, 0); @@ -1553,15 +1692,57 @@ static int mov_write_udta_sdp(AVIOContext *pb, MOVTrack *track) return len + 24; } +static int mov_write_track_metadata(AVIOContext *pb, AVStream *st, + const char *tag, const char *str) +{ + int64_t pos = avio_tell(pb); + AVDictionaryEntry *t = av_dict_get(st->metadata, str, NULL, 0); + if (!t || !utf8len(t->value)) + return 0; + + avio_wb32(pb, 0); /* size */ + ffio_wfourcc(pb, tag); /* type */ + avio_write(pb, t->value, strlen(t->value)); /* UTF8 string value */ + return update_size(pb, pos); +} + +static int mov_write_track_udta_tag(AVIOContext *pb, MOVMuxContext *mov, + AVStream *st) +{ + AVIOContext *pb_buf; + int ret, size; + uint8_t *buf; + + if (!st || mov->fc->flags & AVFMT_FLAG_BITEXACT) + return 0; + + ret = avio_open_dyn_buf(&pb_buf); + if (ret < 0) + return ret; + + if (mov->mode & MODE_MP4) + mov_write_track_metadata(pb_buf, st, "name", "title"); + + if ((size = avio_close_dyn_buf(pb_buf, &buf)) > 0) { + avio_wb32(pb, size + 8); + ffio_wfourcc(pb, "udta"); + avio_write(pb, buf, size); + } + av_free(buf); + + return 0; +} + 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); + mov_write_tkhd_tag(pb, mov, track, st); if (track->mode == MODE_PSP || track->flags & MOV_TRACK_CTTS || - (track->entry && track->cluster[0].dts)) { + (track->entry && track->cluster[0].dts) || + is_clcp_track(track)) { if (!(mov->flags & FF_MOV_FLAG_FRAGMENT)) mov_write_edts_tag(pb, track); // PSP Movies require edts box } @@ -1572,11 +1753,18 @@ static int mov_write_trak_tag(AVIOContext *pb, MOVMuxContext *mov, mov_write_uuid_tag_psp(pb, track); // PSP Movies require this uuid box if (track->tag == MKTAG('r','t','p',' ')) mov_write_udta_sdp(pb, track); - if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO && track->mode == MODE_MOV) { - double sample_aspect_ratio = av_q2d(st->sample_aspect_ratio); - if (0.0 != sample_aspect_ratio && 1.0 != sample_aspect_ratio) + if (track->mode == MODE_MOV) { + if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) { + double sample_aspect_ratio = av_q2d(st->sample_aspect_ratio); + if ((0.0 != sample_aspect_ratio && 1.0 != sample_aspect_ratio)) { + mov_write_tapt_tag(pb, track); + } + } + if (is_clcp_track(track)) { mov_write_tapt_tag(pb, track); + } } + mov_write_track_udta_tag(pb, mov, st); return update_size(pb, pos); } @@ -1640,7 +1828,7 @@ static int mov_write_mvhd_tag(AVIOContext *pb, MOVMuxContext *mov) int version; for (i = 0; i < mov->nb_streams; i++) { - if (mov->tracks[i].entry > 0) { + if (mov->tracks[i].entry > 0 && mov->tracks[i].timescale) { max_track_len_temp = av_rescale_rnd(mov->tracks[i].track_duration, MOV_TIMESCALE, mov->tracks[i].timescale, @@ -1803,7 +1991,8 @@ static int mov_write_ilst_tag(AVIOContext *pb, MOVMuxContext *mov, mov_write_string_metadata(s, pb, "\251wrt", "composer" , 1); mov_write_string_metadata(s, pb, "\251alb", "album" , 1); mov_write_string_metadata(s, pb, "\251day", "date" , 1); - mov_write_string_tag(pb, "\251too", LIBAVFORMAT_IDENT, 0, 1); + if (!mov_write_string_metadata(s, pb, "\251too", "encoding_tool", 1)) + mov_write_string_tag(pb, "\251too", LIBAVFORMAT_IDENT, 0, 1); mov_write_string_metadata(s, pb, "\251cmt", "comment" , 1); mov_write_string_metadata(s, pb, "\251gen", "genre" , 1); mov_write_string_metadata(s, pb, "\251cpy", "copyright", 1); @@ -1833,17 +2022,6 @@ static int mov_write_meta_tag(AVIOContext *pb, MOVMuxContext *mov, return size; } -static int utf8len(const uint8_t *b) -{ - int len = 0; - int val; - while (*b) { - GET_UTF8(val, *b++, return -1;) - len++; - } - return len; -} - static int ascii_to_wc(AVIOContext *pb, const uint8_t *b) { int val; @@ -1914,13 +2092,11 @@ static int mov_write_udta_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s) { AVIOContext *pb_buf; - int i, ret, size; + int ret, size; uint8_t *buf; - for (i = 0; i < s->nb_streams; i++) - if (mov->tracks[i].enc->flags & CODEC_FLAG_BITEXACT) { - return 0; - } + if (s->flags & AVFMT_FLAG_BITEXACT) + return 0; ret = avio_open_dyn_buf(&pb_buf); if (ret < 0) @@ -1950,7 +2126,7 @@ static int mov_write_udta_tag(AVIOContext *pb, MOVMuxContext *mov, mov_write_meta_tag(pb_buf, mov, s); } - if (s->nb_chapters) + if (s->nb_chapters && !(mov->flags & FF_MOV_FLAG_DISABLE_CHPL)) mov_write_chpl_tag(pb_buf, s); if ((size = avio_close_dyn_buf(pb_buf, &buf)) > 0) { @@ -2175,8 +2351,8 @@ static int mov_write_mfhd_tag(AVIOContext *pb, MOVMuxContext *mov) return 0; } -static int mov_write_tfhd_tag(AVIOContext *pb, MOVTrack *track, - int64_t moof_offset) +static int mov_write_tfhd_tag(AVIOContext *pb, MOVMuxContext *mov, + MOVTrack *track, int64_t moof_offset) { int64_t pos = avio_tell(pb); uint32_t flags = MOV_TFHD_DEFAULT_SIZE | MOV_TFHD_DEFAULT_DURATION | @@ -2186,6 +2362,8 @@ static int mov_write_tfhd_tag(AVIOContext *pb, MOVTrack *track, } else { flags |= MOV_TFHD_DEFAULT_FLAGS; } + if (mov->flags & FF_MOV_FLAG_OMIT_TFHD_OFFSET) + flags &= ~MOV_TFHD_BASE_DATA_OFFSET; /* Don't set a default sample size, the silverlight player refuses * to play files with that set. Don't set a default sample duration, @@ -2230,7 +2408,8 @@ static uint32_t get_sample_flags(MOVTrack *track, MOVIentry *entry) (MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES | MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC); } -static int mov_write_trun_tag(AVIOContext *pb, MOVTrack *track) +static int mov_write_trun_tag(AVIOContext *pb, MOVMuxContext *mov, + MOVTrack *track, int moof_size) { int64_t pos = avio_tell(pb); uint32_t flags = MOV_TRUN_DATA_OFFSET; @@ -2255,8 +2434,13 @@ static int mov_write_trun_tag(AVIOContext *pb, MOVTrack *track) avio_wb24(pb, flags); avio_wb32(pb, track->entry); /* sample count */ - track->moof_size_offset = avio_tell(pb); - avio_wb32(pb, 0); /* data offset */ + if (mov->flags & FF_MOV_FLAG_OMIT_TFHD_OFFSET && + !(mov->flags & FF_MOV_FLAG_SEPARATE_MOOF) && + track->track_id != 1) + avio_wb32(pb, 0); /* Later tracks follow immediately after the previous one */ + else + avio_wb32(pb, moof_size + 8 + track->data_offset + + track->cluster[0].pos); /* data offset */ if (flags & MOV_TRUN_FIRST_SAMPLE_FLAGS) avio_wb32(pb, get_sample_flags(track, &track->cluster[0])); @@ -2345,14 +2529,15 @@ static int mov_write_tfrf_tags(AVIOContext *pb, MOVMuxContext *mov, } static int mov_write_traf_tag(AVIOContext *pb, MOVMuxContext *mov, - MOVTrack *track, int64_t moof_offset) + MOVTrack *track, int64_t moof_offset, + int moof_size) { int64_t pos = avio_tell(pb); avio_wb32(pb, 0); /* size placeholder */ ffio_wfourcc(pb, "traf"); - mov_write_tfhd_tag(pb, track, moof_offset); - mov_write_trun_tag(pb, track); + mov_write_tfhd_tag(pb, mov, track, moof_offset); + mov_write_trun_tag(pb, mov, track, moof_size); if (mov->mode == MODE_ISM) { mov_write_tfxd_tag(pb, track); @@ -2370,10 +2555,11 @@ static int mov_write_traf_tag(AVIOContext *pb, MOVMuxContext *mov, return update_size(pb, pos); } -static int mov_write_moof_tag(AVIOContext *pb, MOVMuxContext *mov, int tracks) +static int mov_write_moof_tag_internal(AVIOContext *pb, MOVMuxContext *mov, + int tracks, int moof_size) { - int64_t pos = avio_tell(pb), end; - int i, moof_size; + int64_t pos = avio_tell(pb); + int i; avio_wb32(pb, 0); /* size placeholder */ ffio_wfourcc(pb, "moof"); @@ -2385,25 +2571,24 @@ static int mov_write_moof_tag(AVIOContext *pb, MOVMuxContext *mov, int tracks) continue; if (!track->entry) continue; - mov_write_traf_tag(pb, mov, track, pos); - } - - end = avio_tell(pb); - moof_size = end - pos; - for (i = 0; i < mov->nb_streams; i++) { - MOVTrack *track = &mov->tracks[i]; - if (tracks >= 0 && i != tracks) - continue; - if (!track->entry) - continue; - avio_seek(pb, mov->tracks[i].moof_size_offset, SEEK_SET); - avio_wb32(pb, moof_size + 8 + mov->tracks[i].data_offset); + mov_write_traf_tag(pb, mov, track, pos, moof_size); } - avio_seek(pb, end, SEEK_SET); return update_size(pb, pos); } +static int mov_write_moof_tag(AVIOContext *pb, MOVMuxContext *mov, int tracks) +{ + AVIOContext *avio_buf; + int ret, moof_size; + + if ((ret = ffio_open_null_buf(&avio_buf)) < 0) + return ret; + mov_write_moof_tag_internal(avio_buf, mov, tracks, 0); + moof_size = ffio_close_null_buf(avio_buf); + return mov_write_moof_tag_internal(pb, mov, tracks, moof_size); +} + static int mov_write_tfra_tag(AVIOContext *pb, MOVTrack *track) { int64_t pos = avio_tell(pb); @@ -2485,7 +2670,9 @@ static int mov_write_ftyp_tag(AVIOContext *pb, AVFormatContext *s) avio_wb32(pb, 0); /* size */ ffio_wfourcc(pb, "ftyp"); - if (mov->mode == MODE_3GP) { + if (mov->major_brand && strlen(mov->major_brand) >= 4) + ffio_wfourcc(pb, mov->major_brand); + else if (mov->mode == MODE_3GP) { ffio_wfourcc(pb, has_h264 ? "3gp6" : "3gp4"); minor = has_h264 ? 0x100 : 0x200; } else if (mov->mode & MODE_3G2) { @@ -2499,6 +2686,8 @@ static int mov_write_ftyp_tag(AVIOContext *pb, AVFormatContext *s) ffio_wfourcc(pb, has_video ? "M4V ":"M4A "); else if (mov->mode == MODE_ISM) ffio_wfourcc(pb, "isml"); + else if (mov->mode == MODE_F4V) + ffio_wfourcc(pb, "f4v "); else ffio_wfourcc(pb, "qt "); @@ -2529,10 +2718,12 @@ static int mov_write_ftyp_tag(AVIOContext *pb, AVFormatContext *s) static void mov_write_uuidprof_tag(AVIOContext *pb, AVFormatContext *s) { + AVStream *video_st = s->streams[0]; AVCodecContext *video_codec = s->streams[0]->codec; AVCodecContext *audio_codec = s->streams[1]->codec; int audio_rate = audio_codec->sample_rate; - int frame_rate = ((video_codec->time_base.den) * (0x10000)) / (video_codec->time_base.num); + // TODO: should be avg_frame_rate + int frame_rate = ((video_st->time_base.den) * (0x10000)) / (video_st->time_base.num); int audio_kbitrate = audio_codec->bit_rate / 1000; int video_kbitrate = FFMIN(video_codec->bit_rate / 1000, 800 - audio_kbitrate); @@ -2689,11 +2880,10 @@ static int mov_flush_fragment(AVFormatContext *s) if (i < mov->nb_streams) return 0; - if ((ret = avio_open_dyn_buf(&moov_buf)) < 0) + if ((ret = ffio_open_null_buf(&moov_buf)) < 0) return ret; mov_write_moov_tag(moov_buf, mov, s); - buf_size = avio_close_dyn_buf(moov_buf, &buf); - av_free(buf); + buf_size = ffio_close_null_buf(moov_buf); for (i = 0; i < mov->nb_streams; i++) mov->tracks[i].data_offset = pos + buf_size + 8; @@ -2860,6 +3050,15 @@ int ff_mov_write_packet(AVFormatContext *s, AVPacket *pkt) } else { size = ff_avc_parse_nal_units(pb, pkt->data, pkt->size); } + } else if (enc->codec_id == AV_CODEC_ID_HEVC && trk->vos_len > 6 && + (AV_RB24(trk->vos_data) == 1 || AV_RB32(trk->vos_data) == 1)) { + /* extradata is Annex B, assume the bitstream is too and convert it */ + if (trk->hint_track >= 0 && trk->hint_track < mov->nb_streams) { + ff_hevc_annexb2mp4_buf(pkt->data, &reformatted_data, &size, 0, NULL); + avio_write(pb, reformatted_data, size); + } else { + size = ff_hevc_annexb2mp4(pb, pkt->data, pkt->size, 0, NULL); + } } else { avio_write(pb, pkt->data, size); } @@ -2924,8 +3123,6 @@ int ff_mov_write_packet(AVFormatContext *s, AVPacket *pkt) trk->sample_count += samples_in_chunk; mov->mdat_size += size; - avio_flush(pb); - if (trk->hint_track >= 0 && trk->hint_track < mov->nb_streams) ff_mov_add_hinted_packet(s, pkt, trk->hint_track, trk->entry, reformatted_data, size); @@ -2968,18 +3165,27 @@ static int mov_write_packet(AVFormatContext *s, AVPacket *pkt) // QuickTime chapters involve an additional text track with the chapter names // as samples, and a tref pointing from the other tracks to the chapter one. -static void mov_create_chapter_track(AVFormatContext *s, int tracknum) +static int mov_create_chapter_track(AVFormatContext *s, int tracknum) { MOVMuxContext *mov = s->priv_data; MOVTrack *track = &mov->tracks[tracknum]; AVPacket pkt = { .stream_index = tracknum, .flags = AV_PKT_FLAG_KEY }; int i, len; + // These properties are required to make QT recognize the chapter track + uint8_t chapter_properties[43] = { 0, 0, 0, 0, 0, 0, 0, 1, }; track->mode = mov->mode; track->tag = MKTAG('t','e','x','t'); track->timescale = MOV_TIMESCALE; track->enc = avcodec_alloc_context3(NULL); + if (!track->enc) + return AVERROR(ENOMEM); track->enc->codec_type = AVMEDIA_TYPE_SUBTITLE; + track->enc->extradata = av_malloc(sizeof(chapter_properties)); + if (!track->enc->extradata) + return AVERROR(ENOMEM); + track->enc->extradata_size = sizeof(chapter_properties); + memcpy(track->enc->extradata, chapter_properties, sizeof(chapter_properties)); for (i = 0; i < s->nb_chapters; i++) { AVChapter *c = s->chapters[i]; @@ -2990,15 +3196,165 @@ static void mov_create_chapter_track(AVFormatContext *s, int tracknum) pkt.duration = end - pkt.dts; if ((t = av_dict_get(c->metadata, "title", NULL, 0))) { + const char encd[12] = { + 0x00, 0x00, 0x00, 0x0C, + 'e', 'n', 'c', 'd', + 0x00, 0x00, 0x01, 0x00 }; len = strlen(t->value); - pkt.size = len + 2; + pkt.size = len + 2 + 12; pkt.data = av_malloc(pkt.size); + if (!pkt.data) + return AVERROR(ENOMEM); AV_WB16(pkt.data, len); memcpy(pkt.data + 2, t->value, len); + memcpy(pkt.data + len + 2, encd, sizeof(encd)); ff_mov_write_packet(s, &pkt); av_freep(&pkt.data); } } + + return 0; +} + +/* + * st->disposition controls the "enabled" flag in the tkhd tag. + * QuickTime will not play a track if it is not enabled. So make sure + * that one track of each type (audio, video, subtitle) is enabled. + * + * Subtitles are special. For audio and video, setting "enabled" also + * makes the track "default" (i.e. it is rendered when played). For + * subtitles, an "enabled" subtitle is not rendered by default, but + * if no subtitle is enabled, the subtitle menu in QuickTime will be + * empty! + */ +static void enable_tracks(AVFormatContext *s) +{ + MOVMuxContext *mov = s->priv_data; + int i; + int enabled[AVMEDIA_TYPE_NB]; + int first[AVMEDIA_TYPE_NB]; + + for (i = 0; i < AVMEDIA_TYPE_NB; i++) { + enabled[i] = 0; + first[i] = -1; + } + + for (i = 0; i < s->nb_streams; i++) { + AVStream *st = s->streams[i]; + + if (st->codec->codec_type <= AVMEDIA_TYPE_UNKNOWN || + st->codec->codec_type >= AVMEDIA_TYPE_NB) + continue; + + if (first[st->codec->codec_type] < 0) + first[st->codec->codec_type] = i; + if (st->disposition & AV_DISPOSITION_DEFAULT) { + mov->tracks[i].flags |= MOV_TRACK_ENABLED; + enabled[st->codec->codec_type]++; + } + } + + for (i = 0; i < AVMEDIA_TYPE_NB; i++) { + switch (i) { + case AVMEDIA_TYPE_VIDEO: + case AVMEDIA_TYPE_AUDIO: + case AVMEDIA_TYPE_SUBTITLE: + if (enabled[i] > 1) + mov->per_stream_grouping = 1; + if (!enabled[i] && first[i] >= 0) + mov->tracks[first[i]].flags |= MOV_TRACK_ENABLED; + break; + } + } +} + +static void mov_free(AVFormatContext *s) +{ + MOVMuxContext *mov = s->priv_data; + int i; + + if (mov->chapter_track) { + if (mov->tracks[mov->chapter_track].enc) + av_free(mov->tracks[mov->chapter_track].enc->extradata); + av_freep(&mov->tracks[mov->chapter_track].enc); + } + + for (i = 0; i < mov->nb_streams; i++) { + if (mov->tracks[i].tag == MKTAG('r','t','p',' ')) + ff_mov_close_hinting(&mov->tracks[i]); + av_freep(&mov->tracks[i].cluster); + av_freep(&mov->tracks[i].frag_info); + + if (mov->tracks[i].vos_len) + av_free(mov->tracks[i].vos_data); + } + + av_freep(&mov->tracks); +} + +static uint32_t rgb_to_yuv(uint32_t rgb) +{ + uint8_t r, g, b; + int y, cb, cr; + + r = (rgb >> 16) & 0xFF; + g = (rgb >> 8) & 0xFF; + b = (rgb ) & 0xFF; + + y = av_clip_uint8( 16. + 0.257 * r + 0.504 * g + 0.098 * b); + cb = av_clip_uint8(128. - 0.148 * r - 0.291 * g + 0.439 * b); + cr = av_clip_uint8(128. + 0.439 * r - 0.368 * g - 0.071 * b); + + return (y << 16) | (cr << 8) | cb; +} + +static int mov_create_dvd_sub_decoder_specific_info(MOVTrack *track, + AVStream *st) +{ + int i, width = 720, height = 480; + int have_palette = 0, have_size = 0; + uint32_t palette[16]; + char *cur = st->codec->extradata; + + while (cur && *cur) { + if (strncmp("palette:", cur, 8) == 0) { + int i, count; + count = sscanf(cur + 8, + "%06"PRIx32", %06"PRIx32", %06"PRIx32", %06"PRIx32", " + "%06"PRIx32", %06"PRIx32", %06"PRIx32", %06"PRIx32", " + "%06"PRIx32", %06"PRIx32", %06"PRIx32", %06"PRIx32", " + "%06"PRIx32", %06"PRIx32", %06"PRIx32", %06"PRIx32"", + &palette[ 0], &palette[ 1], &palette[ 2], &palette[ 3], + &palette[ 4], &palette[ 5], &palette[ 6], &palette[ 7], + &palette[ 8], &palette[ 9], &palette[10], &palette[11], + &palette[12], &palette[13], &palette[14], &palette[15]); + + for (i = 0; i < count; i++) { + palette[i] = rgb_to_yuv(palette[i]); + } + have_palette = 1; + } else if (!strncmp("size:", cur, 5)) { + sscanf(cur + 5, "%dx%d", &width, &height); + have_size = 1; + } + if (have_palette && have_size) + break; + cur += strcspn(cur, "\n\r"); + cur += strspn(cur, "\n\r"); + } + if (have_palette) { + track->vos_data = av_malloc(16*4); + if (!track->vos_data) + return AVERROR(ENOMEM); + for (i = 0; i < 16; i++) { + AV_WB32(track->vos_data + i * 4, palette[i]); + } + track->vos_len = 16 * 4; + } + st->codec->width = width; + st->codec->height = track->height = height; + + return 0; } static int mov_write_header(AVFormatContext *s) @@ -3008,6 +3364,21 @@ static int mov_write_header(AVFormatContext *s) AVDictionaryEntry *t; int i, hint_track = 0; + mov->fc = s; + + /* Default mode == MP4 */ + mov->mode = MODE_MP4; + + if (s->oformat) { + if (!strcmp("3gp", s->oformat->name)) mov->mode = MODE_3GP; + else if (!strcmp("3g2", s->oformat->name)) mov->mode = MODE_3GP|MODE_3G2; + else if (!strcmp("mov", s->oformat->name)) mov->mode = MODE_MOV; + else if (!strcmp("psp", s->oformat->name)) mov->mode = MODE_PSP; + else if (!strcmp("ipod",s->oformat->name)) mov->mode = MODE_IPOD; + else if (!strcmp("ismv",s->oformat->name)) mov->mode = MODE_ISM; + else if (!strcmp("f4v", s->oformat->name)) mov->mode = MODE_F4V; + } + /* Set the FRAGMENT flag if any of the fragmentation methods are * enabled. */ if (mov->max_fragment_duration || mov->max_fragment_size || @@ -3016,39 +3387,41 @@ static int mov_write_header(AVFormatContext *s) FF_MOV_FLAG_FRAG_CUSTOM)) mov->flags |= FF_MOV_FLAG_FRAGMENT; + /* Set other implicit flags immediately */ + if (mov->mode == MODE_ISM) + mov->flags |= FF_MOV_FLAG_EMPTY_MOOV | FF_MOV_FLAG_SEPARATE_MOOF | + 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)) { + av_log(s, AV_LOG_WARNING, "The faststart flag is incompatible " + "with fragmentation and custom IO, disabling faststart\n"); + 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 && - ((!(mov->flags & FF_MOV_FLAG_FRAGMENT) && - !(s->oformat && !strcmp(s->oformat->name, "ismv"))) - || mov->ism_lookahead)) { + (!(mov->flags & FF_MOV_FLAG_FRAGMENT) || mov->ism_lookahead)) { av_log(s, AV_LOG_ERROR, "muxer does not support non seekable output\n"); - return -1; + return AVERROR(EINVAL); } - /* Default mode == MP4 */ - mov->mode = MODE_MP4; - 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; - else if (!strcmp("mov", s->oformat->name)) mov->mode = MODE_MOV; - else if (!strcmp("psp", s->oformat->name)) mov->mode = MODE_PSP; - else if (!strcmp("ipod",s->oformat->name)) mov->mode = MODE_IPOD; - else if (!strcmp("ismv",s->oformat->name)) mov->mode = MODE_ISM; - - mov_write_ftyp_tag(pb,s); - if (mov->mode == MODE_PSP) { - if (s->nb_streams != 2) { - av_log(s, AV_LOG_ERROR, "PSP mode need one video and one audio stream\n"); - return -1; - } - mov_write_uuidprof_tag(pb, s); + mov_write_ftyp_tag(pb,s); + if (mov->mode == MODE_PSP) { + if (s->nb_streams != 2) { + av_log(s, AV_LOG_ERROR, "PSP mode need one video and one audio stream\n"); + return AVERROR(EINVAL); } + mov_write_uuidprof_tag(pb, s); } mov->nb_streams = s->nb_streams; - if (mov->mode & (MODE_MOV|MODE_IPOD) && s->nb_chapters) + if (mov->mode & (MODE_MP4|MODE_MOV|MODE_IPOD) && s->nb_chapters) mov->chapter_track = mov->nb_streams++; if (mov->flags & FF_MOV_FLAG_RTP_HINT) { @@ -3063,7 +3436,9 @@ static int mov_write_header(AVFormatContext *s) } } - mov->tracks = av_mallocz(mov->nb_streams * sizeof(*mov->tracks)); + // Reserve an extra stream for chapters for the case where chapters + // are written in the trailer + mov->tracks = av_mallocz((mov->nb_streams + 1) * sizeof(*mov->tracks)); if (!mov->tracks) return AVERROR(ENOMEM); @@ -3072,6 +3447,7 @@ static int mov_write_header(AVFormatContext *s) MOVTrack *track= &mov->tracks[i]; AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL,0); + track->st = st; track->enc = st->codec; track->language = ff_mov_iso639_to_lang(lang?lang->value:"und", mov->mode!=MODE_MOV); if (track->language < 0) @@ -3097,7 +3473,7 @@ static int mov_write_header(AVFormatContext *s) } track->height = track->tag >> 24 == 'n' ? 486 : 576; } - track->timescale = st->codec->time_base.den; + track->timescale = st->time_base.den; if (track->mode == MODE_MOV && track->timescale > 100000) av_log(s, AV_LOG_WARNING, "WARNING codec timebase is very high. If duration is too long,\n" @@ -3125,7 +3501,9 @@ static int mov_write_header(AVFormatContext *s) goto error; } } else if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) { - track->timescale = st->codec->time_base.den; + track->timescale = st->time_base.den; + } else if (st->codec->codec_type == AVMEDIA_TYPE_DATA) { + track->timescale = st->time_base.den; } if (!track->height) track->height = st->codec->height; @@ -3138,24 +3516,29 @@ static int mov_write_header(AVFormatContext *s) /* copy extradata if it exists */ if (st->codec->extradata_size) { - track->vos_len = st->codec->extradata_size; - track->vos_data = av_malloc(track->vos_len); - memcpy(track->vos_data, st->codec->extradata, track->vos_len); + if (st->codec->codec_id == AV_CODEC_ID_DVD_SUBTITLE) + mov_create_dvd_sub_decoder_specific_info(track, st); + else { + track->vos_len = st->codec->extradata_size; + track->vos_data = av_malloc(track->vos_len); + memcpy(track->vos_data, st->codec->extradata, track->vos_len); + } } } - if (mov->mode == MODE_ISM) { + enable_tracks(s); + + if (mov->flags & FF_MOV_FLAG_FRAGMENT) { /* If no fragmentation options have been set, set a default. */ if (!(mov->flags & (FF_MOV_FLAG_FRAG_KEYFRAME | FF_MOV_FLAG_FRAG_CUSTOM)) && !mov->max_fragment_duration && !mov->max_fragment_size) - mov->max_fragment_duration = 5000000; - mov->flags |= FF_MOV_FLAG_EMPTY_MOOV | FF_MOV_FLAG_SEPARATE_MOOF | - FF_MOV_FLAG_FRAGMENT; - } - - if (!(mov->flags & FF_MOV_FLAG_FRAGMENT)) + mov->flags |= FF_MOV_FLAG_FRAG_KEYFRAME; + } else { + 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); @@ -3163,7 +3546,8 @@ static int mov_write_header(AVFormatContext *s) mov->time += 0x7C25B080; // 1970 based -> 1904 based if (mov->chapter_track) - mov_create_chapter_track(s, mov->chapter_track); + if (mov_create_chapter_track(s, mov->chapter_track) < 0) + goto error; if (mov->flags & FF_MOV_FLAG_RTP_HINT) { /* Initialize the hint tracks for each audio and video stream */ @@ -3189,20 +3573,138 @@ static int mov_write_header(AVFormatContext *s) return 0; error: - av_freep(&mov->tracks); + mov_free(s); return -1; } +static int get_moov_size(AVFormatContext *s) +{ + int ret; + AVIOContext *moov_buf; + MOVMuxContext *mov = s->priv_data; + + if ((ret = ffio_open_null_buf(&moov_buf)) < 0) + return ret; + mov_write_moov_tag(moov_buf, mov, s); + return ffio_close_null_buf(moov_buf); +} + +/* + * 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; AVIOContext *pb = s->pb; int res = 0; int i; - - int64_t moov_pos = avio_tell(pb); + int64_t moov_pos; + + // If there were no chapters when the header was written, but there + // are chapters now, write them in the trailer. This only works + // when we are not doing fragments. + if (!mov->chapter_track && !(mov->flags & FF_MOV_FLAG_FRAGMENT)) { + if (mov->mode & (MODE_MP4|MODE_MOV|MODE_IPOD) && s->nb_chapters) { + mov->chapter_track = mov->nb_streams++; + if ((res = mov_create_chapter_track(s, mov->chapter_track)) < 0) + goto error; + } + } 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); @@ -3218,18 +3720,22 @@ 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); } - if (mov->chapter_track) - av_freep(&mov->tracks[mov->chapter_track].enc); - for (i = 0; i < mov->nb_streams; i++) { - if (mov->tracks[i].tag == MKTAG('r','t','p',' ')) - ff_mov_close_hinting(&mov->tracks[i]); if (mov->flags & FF_MOV_FLAG_FRAGMENT && mov->tracks[i].vc1_info.struct_offset && s->pb->seekable) { int64_t off = avio_tell(pb); @@ -3240,14 +3746,10 @@ static int mov_write_trailer(AVFormatContext *s) avio_seek(pb, off, SEEK_SET); } } - av_freep(&mov->tracks[i].cluster); - av_freep(&mov->tracks[i].frag_info); - - if (mov->tracks[i].vos_len) - av_free(mov->tracks[i].vos_data); } - av_freep(&mov->tracks); +error: + mov_free(s); return res; } @@ -3265,7 +3767,7 @@ AVOutputFormat ff_mov_muxer = { .write_header = mov_write_header, .write_packet = mov_write_packet, .write_trailer = mov_write_trailer, - .flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH, + .flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH | AVFMT_TS_NEGATIVE, .codec_tag = (const AVCodecTag* const []){ ff_codec_movvideo_tags, ff_codec_movaudio_tags, 0 }, @@ -3284,7 +3786,7 @@ AVOutputFormat ff_tgp_muxer = { .write_header = mov_write_header, .write_packet = mov_write_packet, .write_trailer = mov_write_trailer, - .flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH, + .flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH | AVFMT_TS_NEGATIVE, .codec_tag = (const AVCodecTag* const []){ codec_3gp_tags, 0 }, .priv_class = &tgp_muxer_class, }; @@ -3303,7 +3805,7 @@ AVOutputFormat ff_mp4_muxer = { .write_header = mov_write_header, .write_packet = mov_write_packet, .write_trailer = mov_write_trailer, - .flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH, + .flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH | AVFMT_TS_NEGATIVE, .codec_tag = (const AVCodecTag* const []){ ff_mp4_obj_type, 0 }, .priv_class = &mp4_muxer_class, }; @@ -3321,7 +3823,7 @@ AVOutputFormat ff_psp_muxer = { .write_header = mov_write_header, .write_packet = mov_write_packet, .write_trailer = mov_write_trailer, - .flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH, + .flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH | AVFMT_TS_NEGATIVE, .codec_tag = (const AVCodecTag* const []){ ff_mp4_obj_type, 0 }, .priv_class = &psp_muxer_class, }; @@ -3338,7 +3840,7 @@ AVOutputFormat ff_tg2_muxer = { .write_header = mov_write_header, .write_packet = mov_write_packet, .write_trailer = mov_write_trailer, - .flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH, + .flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH | AVFMT_TS_NEGATIVE, .codec_tag = (const AVCodecTag* const []){ codec_3gp_tags, 0 }, .priv_class = &tg2_muxer_class, }; @@ -3356,7 +3858,7 @@ AVOutputFormat ff_ipod_muxer = { .write_header = mov_write_header, .write_packet = mov_write_packet, .write_trailer = mov_write_trailer, - .flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH, + .flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH | AVFMT_TS_NEGATIVE, .codec_tag = (const AVCodecTag* const []){ codec_ipod_tags, 0 }, .priv_class = &ipod_muxer_class, }; @@ -3374,8 +3876,26 @@ AVOutputFormat ff_ismv_muxer = { .write_header = mov_write_header, .write_packet = mov_write_packet, .write_trailer = mov_write_trailer, - .flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH, + .flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH | AVFMT_TS_NEGATIVE, .codec_tag = (const AVCodecTag* const []){ ff_mp4_obj_type, 0 }, .priv_class = &ismv_muxer_class, }; #endif +#if CONFIG_F4V_MUXER +MOV_CLASS(f4v) +AVOutputFormat ff_f4v_muxer = { + .name = "f4v", + .long_name = NULL_IF_CONFIG_SMALL("F4V Adobe Flash Video"), + .mime_type = "application/f4v", + .extensions = "f4v", + .priv_data_size = sizeof(MOVMuxContext), + .audio_codec = AV_CODEC_ID_AAC, + .video_codec = AV_CODEC_ID_H264, + .write_header = mov_write_header, + .write_packet = mov_write_packet, + .write_trailer = mov_write_trailer, + .flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH | AVFMT_TS_NEGATIVE, + .codec_tag = (const AVCodecTag* const []){ codec_f4v_tags, 0 }, + .priv_class = &f4v_muxer_class, +}; +#endif