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" },
+ { "empty_moov", "Make the initial moov atom empty (not supported by QuickTime)", 0, AV_OPT_TYPE_CONST, {.dbl = FF_MOV_FLAG_EMPTY_MOOV}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
+ { "frag_keyframe", "Fragment at video keyframes", 0, AV_OPT_TYPE_CONST, {.dbl = FF_MOV_FLAG_FRAG_KEYFRAME}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
+ { "separate_moof", "Write separate moof/mdat atoms for each track", 0, AV_OPT_TYPE_CONST, {.dbl = 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, {.dbl = 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, {.dbl = FF_MOV_FLAG_ISML}, 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, {.dbl = 0}, 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},
+ { "frag_duration", "Maximum fragment duration", offsetof(MOVMuxContext, max_fragment_duration), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
+ { "frag_size", "Maximum fragment size", offsetof(MOVMuxContext, max_fragment_size), AV_OPT_TYPE_INT, {.dbl = 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, {.dbl = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
{ NULL },
};
oldtst = tst;
entries += track->cluster[i].entries;
}
- if (equalChunks) {
- int sSize = track->cluster[0].size/track->cluster[0].entries;
+ if (equalChunks && track->entry) {
+ int sSize = track->entry ? track->cluster[0].size/track->cluster[0].entries : 0;
sSize = FFMAX(1, sSize); // adpcm mono case could make sSize == 0
avio_wb32(pb, sSize); // sample size
avio_wb32(pb, entries); // sample count
avio_wb16(pb, 0);
avio_wb32(pb, 0x00010000);
avio_wb32(pb, 72);
- avio_wb64(pb, av_double2int(track->timescale));
+ avio_wb64(pb, av_double2int(track->enc->sample_rate));
avio_wb32(pb, track->enc->channels);
avio_wb32(pb, 0x7F000000);
avio_wb32(pb, av_get_bits_per_sample(track->enc->codec_id));
avio_wb16(pb, 0);
avio_wb16(pb, 0); /* packet size (= 0) */
- avio_wb16(pb, track->timescale); /* Time scale */
+ avio_wb16(pb, track->enc->sample_rate);
avio_wb16(pb, 0); /* Reserved */
}
{
int tag = track->enc->codec_tag;
- if (track->mode == MODE_MP4 || track->mode == MODE_PSP)
+ if (track->mode == MODE_MP4 || track->mode == MODE_PSP || track->mode == MODE_ISM)
tag = mp4_get_codec_tag(s, track);
else if (track->mode == MODE_IPOD)
tag = ipod_get_codec_tag(s, track);
return 28;
}
+static const uint16_t fiel_data[] = {
+ 0x0000, 0x0100, 0x0201, 0x0206, 0x0209, 0x020e
+};
+
+static int mov_write_fiel_tag(AVIOContext *pb, MOVTrack *track)
+{
+ unsigned mov_field_order = 0;
+ if (track->enc->field_order < FF_ARRAY_ELEMS(fiel_data))
+ mov_field_order = fiel_data[track->enc->field_order];
+ else
+ return 0;
+ avio_wb32(pb, 10);
+ ffio_wfourcc(pb, "fiel");
+ avio_wb16(pb, mov_field_order);
+ return 10;
+}
+
static int mov_write_subtitle_tag(AVIOContext *pb, MOVTrack *track)
{
int64_t pos = avio_tell(pb);
mov_write_avcc_tag(pb, track);
if(track->mode == MODE_IPOD)
mov_write_uuid_tag_ipod(pb);
- } else if(track->vosLen > 0)
+ } else if (track->enc->field_order != AV_FIELD_UNKNOWN)
+ mov_write_fiel_tag(pb, track);
+ else if(track->vosLen > 0)
mov_write_glbl_tag(pb, track);
if (track->enc->sample_aspect_ratio.den && track->enc->sample_aspect_ratio.num &&
stts_entries[0].duration = 1;
entries = 1;
} else {
- stts_entries = av_malloc(track->entry * sizeof(*stts_entries)); /* worst case */
+ stts_entries = track->entry ?
+ av_malloc(track->entry * sizeof(*stts_entries)) : /* worst case */
+ NULL;
for (i=0; i<track->entry; i++) {
int64_t duration = i + 1 == track->entry ?
- track->trackDuration - track->cluster[i].dts + track->cluster[0].dts : /* readjusting */
+ track->trackDuration - track->cluster[i].dts + track->start_dts : /* readjusting */
track->cluster[i+1].dts - track->cluster[i].dts;
if (i && duration == stts_entries[entries].duration) {
stts_entries[entries].count++; /* compress */
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 (track->mode == MODE_PSP || track->flags & MOV_TRACK_CTTS ||
+ (track->entry && track->cluster[0].dts)) {
+ if (!(mov->flags & FF_MOV_FLAG_FRAGMENT))
+ mov_write_edts_tag(pb, track); // PSP Movies require edts box
+ }
if (track->tref_tag)
mov_write_tref_tag(pb, track);
mov_write_mdia_tag(pb, track);
return updateSize(pb, pos);
}
+static int mov_write_trex_tag(AVIOContext *pb, MOVTrack *track)
+{
+ avio_wb32(pb, 0x20); /* size */
+ ffio_wfourcc(pb, "trex");
+ avio_wb32(pb, 0); /* version & flags */
+ avio_wb32(pb, track->trackID); /* track ID */
+ avio_wb32(pb, 1); /* default sample description index */
+ avio_wb32(pb, 0); /* default sample duration */
+ avio_wb32(pb, 0); /* default sample size */
+ avio_wb32(pb, 0); /* default sample flags */
+ return 0;
+}
+
+static int mov_write_mvex_tag(AVIOContext *pb, MOVMuxContext *mov)
+{
+ int64_t pos = avio_tell(pb);
+ int i;
+ avio_wb32(pb, 0x0); /* size */
+ ffio_wfourcc(pb, "mvex");
+ for (i = 0; i < mov->nb_streams; i++)
+ mov_write_trex_tag(pb, &mov->tracks[i]);
+ return updateSize(pb, pos);
+}
+
static int mov_write_mvhd_tag(AVIOContext *pb, MOVMuxContext *mov)
{
int maxTrackID = 1, i;
ffio_wfourcc(pb, "moov");
for (i=0; i<mov->nb_streams; i++) {
- if(mov->tracks[i].entry <= 0) continue;
+ if (mov->tracks[i].entry <= 0 && !(mov->flags & FF_MOV_FLAG_FRAGMENT))
+ continue;
mov->tracks[i].time = mov->time;
mov->tracks[i].trackID = i+1;
if (mov->mode != MODE_MOV && !mov->iods_skip)
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);
+ if (mov->tracks[i].entry > 0 || mov->flags & FF_MOV_FLAG_FRAGMENT) {
+ mov_write_trak_tag(pb, mov, &(mov->tracks[i]), i < s->nb_streams ? s->streams[i] : NULL);
}
}
+ if (mov->flags & FF_MOV_FLAG_FRAGMENT)
+ mov_write_mvex_tag(pb, mov); /* QuickTime requires trak to precede this */
if (mov->mode == MODE_PSP)
mov_write_uuidusmt_tag(pb, s);
return updateSize(pb, pos);
}
+static void param_write_int(AVIOContext *pb, const char *name, int value)
+{
+ avio_printf(pb, "<param name=\"%s\" value=\"%d\" valuetype=\"data\"/>\n", name, value);
+}
+
+static void param_write_string(AVIOContext *pb, const char *name, const char *value)
+{
+ avio_printf(pb, "<param name=\"%s\" value=\"%s\" valuetype=\"data\"/>\n", name, value);
+}
+
+static void param_write_hex(AVIOContext *pb, const char *name, const uint8_t *value, int len)
+{
+ char buf[150];
+ len = FFMIN(sizeof(buf)/2 - 1, len);
+ ff_data_to_hex(buf, value, len, 0);
+ buf[2*len] = '\0';
+ avio_printf(pb, "<param name=\"%s\" value=\"%s\" valuetype=\"data\"/>\n", name, buf);
+}
+
+static void write_h264_extradata(AVIOContext *pb, AVCodecContext *enc)
+{
+ uint16_t sps_size, pps_size, len;
+ char buf[150];
+ sps_size = AV_RB16(&enc->extradata[6]);
+ if (11 + sps_size > enc->extradata_size)
+ return;
+ pps_size = AV_RB16(&enc->extradata[9 + sps_size]);
+ if (11 + sps_size + pps_size > enc->extradata_size)
+ return;
+ len = FFMIN(sizeof(buf)/2 - 1, sps_size);
+ ff_data_to_hex(buf, &enc->extradata[8], len, 0);
+ buf[2*len] = '\0';
+ avio_printf(pb, "<param name=\"CodecPrivateData\" value=\"00000001%s", buf);
+ len = FFMIN(sizeof(buf)/2 - 1, pps_size);
+ ff_data_to_hex(buf, &enc->extradata[11 + sps_size], len, 0);
+ buf[2*len] = '\0';
+ avio_printf(pb, "00000001%s\" valuetype=\"data\"/>\n", buf);
+}
+
+static int mov_write_isml_manifest(AVIOContext *pb, MOVMuxContext *mov)
+{
+ int64_t pos = avio_tell(pb);
+ int i;
+ const uint8_t uuid[] = {
+ 0xa5, 0xd4, 0x0b, 0x30, 0xe8, 0x14, 0x11, 0xdd,
+ 0xba, 0x2f, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66
+ };
+
+ avio_wb32(pb, 0);
+ ffio_wfourcc(pb, "uuid");
+ avio_write(pb, uuid, sizeof(uuid));
+ avio_wb32(pb, 0);
+
+ avio_printf(pb, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
+ avio_printf(pb, "<smil xmlns=\"http://www.w3.org/2001/SMIL20/Language\">\n");
+ avio_printf(pb, "<head>\n");
+ avio_printf(pb, "<meta name=\"creator\" content=\"%s\" />\n",
+ LIBAVFORMAT_IDENT);
+ avio_printf(pb, "</head>\n");
+ avio_printf(pb, "<body>\n");
+ avio_printf(pb, "<switch>\n");
+ for (i = 0; i < mov->nb_streams; i++) {
+ MOVTrack *track = &mov->tracks[i];
+ const char *type;
+ /* track->trackID is initialized in write_moov, and thus isn't known
+ * here yet */
+ int track_id = i + 1;
+
+ if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) {
+ type = "video";
+ } else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO) {
+ type = "audio";
+ } else {
+ continue;
+ }
+ avio_printf(pb, "<%s systemBitrate=\"%d\">\n", type,
+ track->enc->bit_rate);
+ param_write_int(pb, "systemBitrate", track->enc->bit_rate);
+ param_write_int(pb, "trackID", track_id);
+ if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) {
+ if (track->enc->codec_id == CODEC_ID_H264 &&
+ track->enc->extradata_size >= 11 &&
+ track->enc->extradata[0] == 1) {
+ write_h264_extradata(pb, track->enc);
+ } else {
+ param_write_hex(pb, "CodecPrivateData", track->enc->extradata,
+ track->enc->extradata_size);
+ }
+ if (track->enc->codec_id == CODEC_ID_H264) {
+ param_write_string(pb, "FourCC", "H264");
+ } else if (track->enc->codec_id == CODEC_ID_VC1) {
+ param_write_string(pb, "FourCC", "WVC1");
+ }
+ param_write_int(pb, "MaxWidth", track->enc->width);
+ param_write_int(pb, "MaxHeight", track->enc->height);
+ param_write_int(pb, "DisplayWidth", track->enc->width);
+ param_write_int(pb, "DisplayHeight", track->enc->height);
+ } else {
+ if (track->enc->codec_id == CODEC_ID_AAC) {
+ param_write_string(pb, "FourCC", "AACL");
+ } else if (track->enc->codec_id == CODEC_ID_WMAPRO) {
+ param_write_string(pb, "FourCC", "WMAP");
+ }
+ param_write_hex(pb, "CodecPrivateData", track->enc->extradata,
+ track->enc->extradata_size);
+ param_write_int(pb, "AudioTag", ff_codec_get_tag(ff_codec_wav_tags,
+ track->enc->codec_id));
+ param_write_int(pb, "Channels", track->enc->channels);
+ param_write_int(pb, "SamplingRate", track->enc->sample_rate);
+ param_write_int(pb, "BitsPerSample", 16);
+ param_write_int(pb, "PacketSize", track->enc->block_align ?
+ track->enc->block_align : 4);
+ }
+ avio_printf(pb, "</%s>\n", type);
+ }
+ avio_printf(pb, "</switch>\n");
+ avio_printf(pb, "</body>\n");
+ avio_printf(pb, "</smil>\n");
+
+ return updateSize(pb, pos);
+}
+
+static int mov_write_mfhd_tag(AVIOContext *pb, MOVMuxContext *mov)
+{
+ avio_wb32(pb, 16);
+ ffio_wfourcc(pb, "mfhd");
+ avio_wb32(pb, 0);
+ avio_wb32(pb, mov->fragments);
+ return 0;
+}
+
+static int mov_write_tfhd_tag(AVIOContext *pb, MOVTrack *track,
+ int64_t moof_offset)
+{
+ int64_t pos = avio_tell(pb);
+ /* default-sample-size + default-sample-duration + base-data-offset */
+ uint32_t flags = 0x19;
+ if (!track->entry) {
+ flags |= 0x010000; /* duration-is-empty */
+ } else {
+ flags |= 0x20; /* default-sample-flags-present */
+ }
+
+ /* Don't set a default sample size when creating data for silverlight,
+ * the player refuses to play files with that set. */
+ if (track->mode == MODE_ISM)
+ flags &= ~0x10;
+
+ avio_wb32(pb, 0); /* size placeholder */
+ ffio_wfourcc(pb, "tfhd");
+ avio_w8(pb, 0); /* version */
+ avio_wb24(pb, flags);
+
+ avio_wb32(pb, track->trackID); /* track-id */
+ if (flags & 0x01)
+ avio_wb64(pb, moof_offset);
+ if (flags & 0x08) {
+ track->default_duration = track->audio_vbr ? track->enc->frame_size : 1;
+ avio_wb32(pb, track->default_duration);
+ }
+ if (flags & 0x10) {
+ track->default_size = track->entry ? track->cluster[0].size : 1;
+ avio_wb32(pb, track->default_size);
+ } else
+ track->default_size = -1;
+
+ if (flags & 0x20) {
+ track->default_sample_flags =
+ track->enc->codec_type == AVMEDIA_TYPE_VIDEO ?
+ 0x01010000 : 0x02000000;
+ avio_wb32(pb, track->default_sample_flags);
+ }
+
+ return updateSize(pb, pos);
+}
+
+static uint32_t get_sample_flags(MOVTrack *track, MOVIentry *entry)
+{
+ return entry->flags & MOV_SYNC_SAMPLE ? 0x02000000 : 0x01010000;
+}
+
+static int mov_write_trun_tag(AVIOContext *pb, MOVTrack *track)
+{
+ int64_t pos = avio_tell(pb);
+ uint32_t flags = 1; /* data-offset-present */
+ int i;
+
+ for (i = 0; i < track->entry; i++) {
+ int64_t duration = i + 1 == track->entry ?
+ track->trackDuration - track->cluster[i].dts + track->start_dts :
+ track->cluster[i + 1].dts - track->cluster[i].dts;
+ if (duration != track->default_duration)
+ flags |= 0x100; /* sample-duration-present */
+ if (track->cluster[i].size != track->default_size)
+ flags |= 0x200; /* sample-size-present */
+ if (i > 0 && get_sample_flags(track, &track->cluster[i]) != track->default_sample_flags)
+ flags |= 0x400; /* sample-flags-present */
+ }
+ if (!(flags & 0x400))
+ flags |= 0x4; /* first-sample-flags-present */
+ if (track->flags & MOV_TRACK_CTTS)
+ flags |= 0x800; /* sample-composition-time-offsets-present */
+
+ avio_wb32(pb, 0); /* size placeholder */
+ ffio_wfourcc(pb, "trun");
+ avio_w8(pb, 0); /* version */
+ 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 (flags & 0x4) /* first sample flags */
+ avio_wb32(pb, get_sample_flags(track, &track->cluster[0]));
+
+ for (i = 0; i < track->entry; i++) {
+ int64_t duration = i + 1 == track->entry ?
+ track->trackDuration - track->cluster[i].dts + track->start_dts :
+ track->cluster[i + 1].dts - track->cluster[i].dts;
+ if (flags & 0x100)
+ avio_wb32(pb, duration);
+ if (flags & 0x200)
+ avio_wb32(pb, track->cluster[i].size);
+ if (flags & 0x400)
+ avio_wb32(pb, get_sample_flags(track, &track->cluster[i]));
+ if (flags & 0x800)
+ avio_wb32(pb, track->cluster[i].cts);
+ }
+
+ return updateSize(pb, pos);
+}
+
+static int mov_write_tfxd_tag(AVIOContext *pb, MOVTrack *track)
+{
+ int64_t pos = avio_tell(pb);
+ const uint8_t uuid[] = {
+ 0x6d, 0x1d, 0x9b, 0x05, 0x42, 0xd5, 0x44, 0xe6,
+ 0x80, 0xe2, 0x14, 0x1d, 0xaf, 0xf7, 0x57, 0xb2
+ };
+
+ avio_wb32(pb, 0); /* size placeholder */
+ ffio_wfourcc(pb, "uuid");
+ avio_write(pb, uuid, sizeof(uuid));
+ avio_w8(pb, 1);
+ avio_wb24(pb, 0);
+ avio_wb64(pb, track->frag_start);
+ avio_wb64(pb, track->start_dts + track->trackDuration -
+ track->cluster[0].dts);
+
+ return updateSize(pb, pos);
+}
+
+static int mov_write_tfrf_tag(AVIOContext *pb, MOVMuxContext *mov,
+ MOVTrack *track, int entry)
+{
+ int n = track->nb_frag_info - 1 - entry, i;
+ int size = 8 + 16 + 4 + 1 + 16*n;
+ const uint8_t uuid[] = {
+ 0xd4, 0x80, 0x7e, 0xf2, 0xca, 0x39, 0x46, 0x95,
+ 0x8e, 0x54, 0x26, 0xcb, 0x9e, 0x46, 0xa7, 0x9f
+ };
+
+ if (entry < 0)
+ return 0;
+
+ avio_seek(pb, track->frag_info[entry].tfrf_offset, SEEK_SET);
+ avio_wb32(pb, size);
+ ffio_wfourcc(pb, "uuid");
+ avio_write(pb, uuid, sizeof(uuid));
+ avio_w8(pb, 1);
+ avio_wb24(pb, 0);
+ avio_w8(pb, n);
+ for (i = 0; i < n; i++) {
+ int index = entry + 1 + i;
+ avio_wb64(pb, track->frag_info[index].time);
+ avio_wb64(pb, track->frag_info[index].duration);
+ }
+ if (n < mov->ism_lookahead) {
+ int free_size = 16*(mov->ism_lookahead - n);
+ avio_wb32(pb, free_size);
+ ffio_wfourcc(pb, "free");
+ for (i = 0; i < free_size - 8; i++)
+ avio_w8(pb, 0);
+ }
+
+ return 0;
+}
+
+static int mov_write_tfrf_tags(AVIOContext *pb, MOVMuxContext *mov,
+ MOVTrack *track)
+{
+ int64_t pos = avio_tell(pb);
+ int i;
+ for (i = 0; i < mov->ism_lookahead; i++) {
+ /* Update the tfrf tag for the last ism_lookahead fragments,
+ * nb_frag_info - 1 is the next fragment to be written. */
+ mov_write_tfrf_tag(pb, mov, track, track->nb_frag_info - 2 - i);
+ }
+ avio_seek(pb, pos, SEEK_SET);
+ return 0;
+}
+
+static int mov_write_traf_tag(AVIOContext *pb, MOVMuxContext *mov,
+ MOVTrack *track, int64_t moof_offset)
+{
+ 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);
+ if (mov->mode == MODE_ISM) {
+ mov_write_tfxd_tag(pb, track);
+
+ if (mov->ism_lookahead) {
+ int i, size = 16 + 4 + 1 + 16*mov->ism_lookahead;
+
+ track->tfrf_offset = avio_tell(pb);
+ avio_wb32(pb, 8 + size);
+ ffio_wfourcc(pb, "free");
+ for (i = 0; i < size; i++)
+ avio_w8(pb, 0);
+ }
+ }
+
+ return updateSize(pb, pos);
+}
+
+static int mov_write_moof_tag(AVIOContext *pb, MOVMuxContext *mov, int tracks)
+{
+ int64_t pos = avio_tell(pb), end;
+ int i, moof_size;
+
+ avio_wb32(pb, 0); /* size placeholder */
+ ffio_wfourcc(pb, "moof");
+
+ mov_write_mfhd_tag(pb, mov);
+ for (i = 0; i < mov->nb_streams; i++) {
+ MOVTrack *track = &mov->tracks[i];
+ if (tracks >= 0 && i != 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);
+ }
+ avio_seek(pb, end, SEEK_SET);
+
+ return updateSize(pb, pos);
+}
+
+static int mov_write_tfra_tag(AVIOContext *pb, MOVTrack *track)
+{
+ int64_t pos = avio_tell(pb);
+ int i;
+
+ avio_wb32(pb, 0); /* size placeholder */
+ ffio_wfourcc(pb, "tfra");
+ avio_w8(pb, 1); /* version */
+ avio_wb24(pb, 0);
+
+ avio_wb32(pb, track->trackID);
+ avio_wb32(pb, 0); /* length of traf/trun/sample num */
+ avio_wb32(pb, track->nb_frag_info);
+ for (i = 0; i < track->nb_frag_info; i++) {
+ avio_wb64(pb, track->frag_info[i].time);
+ avio_wb64(pb, track->frag_info[i].offset);
+ avio_w8(pb, 1); /* traf number */
+ avio_w8(pb, 1); /* trun number */
+ avio_w8(pb, 1); /* sample number */
+ }
+
+ return updateSize(pb, pos);
+}
+
+static int mov_write_mfra_tag(AVIOContext *pb, MOVMuxContext *mov)
+{
+ int64_t pos = avio_tell(pb);
+ int i;
+
+ avio_wb32(pb, 0); /* size placeholder */
+ ffio_wfourcc(pb, "mfra");
+ /* An empty mfra atom is enough to indicate to the publishing point that
+ * the stream has ended. */
+ if (mov->flags & FF_MOV_FLAG_ISML)
+ return updateSize(pb, pos);
+
+ for (i = 0; i < mov->nb_streams; i++) {
+ MOVTrack *track = &mov->tracks[i];
+ if (track->nb_frag_info)
+ mov_write_tfra_tag(pb, track);
+ }
+
+ avio_wb32(pb, 16);
+ ffio_wfourcc(pb, "mfro");
+ avio_wb32(pb, 0); /* version + flags */
+ avio_wb32(pb, avio_tell(pb) + 4 - pos);
+
+ 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)
ffio_wfourcc(pb, "isom");
else if (mov->mode == MODE_IPOD)
ffio_wfourcc(pb, has_video ? "M4V ":"M4A ");
+ else if (mov->mode == MODE_ISM)
+ ffio_wfourcc(pb, "isml");
else
ffio_wfourcc(pb, "qt ");
if(mov->mode == MODE_MOV)
ffio_wfourcc(pb, "qt ");
- else{
+ else if (mov->mode == MODE_ISM) {
+ ffio_wfourcc(pb, "piff");
+ ffio_wfourcc(pb, "iso2");
+ } else {
ffio_wfourcc(pb, "isom");
ffio_wfourcc(pb, "iso2");
if(has_h264)
return 0;
}
-int ff_mov_write_packet(AVFormatContext *s, AVPacket *pkt)
+static int mov_flush_fragment(AVFormatContext *s)
+{
+ MOVMuxContext *mov = s->priv_data;
+ int i, first_track = -1;
+ int64_t mdat_size = 0;
+
+ if (!(mov->flags & FF_MOV_FLAG_FRAGMENT))
+ return 0;
+
+ if (!(mov->flags & FF_MOV_FLAG_EMPTY_MOOV) && mov->fragments == 0) {
+ int64_t pos = avio_tell(s->pb);
+
+ for (i = 0; i < mov->nb_streams; i++)
+ if (!mov->tracks[i].entry)
+ break;
+ /* Don't write the initial moov unless all tracks have data */
+ if (i < mov->nb_streams)
+ return 0;
+ avio_seek(s->pb, mov->mdat_pos, SEEK_SET);
+ avio_wb32(s->pb, mov->mdat_size + 8);
+ avio_seek(s->pb, pos, SEEK_SET);
+ mov_write_moov_tag(s->pb, mov, s);
+ mov->fragments++;
+ mov->mdat_size = 0;
+ for (i = 0; i < mov->nb_streams; i++) {
+ if (mov->tracks[i].entry)
+ mov->tracks[i].frag_start += mov->tracks[i].start_dts +
+ mov->tracks[i].trackDuration -
+ mov->tracks[i].cluster[0].dts;
+ mov->tracks[i].entry = 0;
+ }
+ avio_flush(s->pb);
+ return 0;
+ }
+
+ for (i = 0; i < mov->nb_streams; i++) {
+ MOVTrack *track = &mov->tracks[i];
+ if (mov->flags & FF_MOV_FLAG_SEPARATE_MOOF)
+ track->data_offset = 0;
+ else
+ track->data_offset = mdat_size;
+ if (!track->mdat_buf)
+ continue;
+ mdat_size += avio_tell(track->mdat_buf);
+ if (first_track < 0)
+ first_track = i;
+ }
+
+ if (!mdat_size)
+ return 0;
+
+ for (i = 0; i < mov->nb_streams; i++) {
+ MOVTrack *track = &mov->tracks[i];
+ int buf_size, write_moof = 1, moof_tracks = -1;
+ uint8_t *buf;
+ int64_t duration = 0;
+
+ if (track->entry)
+ duration = track->start_dts + track->trackDuration -
+ track->cluster[0].dts;
+ if (mov->flags & FF_MOV_FLAG_SEPARATE_MOOF) {
+ if (!track->mdat_buf)
+ continue;
+ mdat_size = avio_tell(track->mdat_buf);
+ moof_tracks = i;
+ } else {
+ write_moof = i == first_track;
+ }
+
+ if (write_moof) {
+ MOVFragmentInfo *info;
+ avio_flush(s->pb);
+ track->nb_frag_info++;
+ track->frag_info = av_realloc(track->frag_info,
+ sizeof(*track->frag_info) *
+ track->nb_frag_info);
+ info = &track->frag_info[track->nb_frag_info - 1];
+ info->offset = avio_tell(s->pb);
+ info->time = mov->tracks[i].frag_start;
+ info->duration = duration;
+ mov_write_tfrf_tags(s->pb, mov, track);
+
+ mov_write_moof_tag(s->pb, mov, moof_tracks);
+ info->tfrf_offset = track->tfrf_offset;
+ mov->fragments++;
+
+ avio_wb32(s->pb, mdat_size + 8);
+ ffio_wfourcc(s->pb, "mdat");
+ }
+
+ if (track->entry)
+ track->frag_start += duration;
+ track->entry = 0;
+ if (!track->mdat_buf)
+ continue;
+ buf_size = avio_close_dyn_buf(track->mdat_buf, &buf);
+ track->mdat_buf = NULL;
+
+ avio_write(s->pb, buf, buf_size);
+ av_free(buf);
+ }
+
+ mov->mdat_size = 0;
+
+ avio_flush(s->pb);
+ return 0;
+}
+
+static int mov_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
{
MOVMuxContext *mov = s->priv_data;
AVIOContext *pb = s->pb;
int size= pkt->size;
uint8_t *reformatted_data = NULL;
- if (!s->pb->seekable) return 0; /* Can't handle that */
+ if (!s->pb->seekable && !(mov->flags & FF_MOV_FLAG_EMPTY_MOOV))
+ return 0; /* Can't handle that */
+
if (!size) return 0; /* Discard 0 sized packets */
+ if ((mov->max_fragment_duration && trk->entry &&
+ av_rescale_q(pkt->dts - trk->cluster[0].dts,
+ s->streams[pkt->stream_index]->time_base,
+ AV_TIME_BASE_Q) >= mov->max_fragment_duration) ||
+ (mov->max_fragment_size && mov->mdat_size + size >= mov->max_fragment_size) ||
+ (mov->flags & FF_MOV_FLAG_FRAG_KEYFRAME &&
+ enc->codec_type == AVMEDIA_TYPE_VIDEO &&
+ trk->entry && pkt->flags & AV_PKT_FLAG_KEY)) {
+ mov_flush_fragment(s);
+ }
+
+ if (mov->flags & FF_MOV_FLAG_FRAGMENT && mov->fragments > 0) {
+ if (!trk->mdat_buf) {
+ int ret;
+ if ((ret = avio_open_dyn_buf(&trk->mdat_buf)) < 0)
+ return ret;
+ }
+ pb = trk->mdat_buf;
+ }
+
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] =
trk->cluster[trk->entry].size = size;
trk->cluster[trk->entry].entries = samplesInChunk;
trk->cluster[trk->entry].dts = pkt->dts;
- trk->trackDuration = pkt->dts - trk->cluster[0].dts + pkt->duration;
+ if (!trk->entry && trk->start_dts != AV_NOPTS_VALUE) {
+ /* First packet of a new fragment. We already wrote the duration
+ * of the last packet of the previous fragment based on trackDuration,
+ * which might not exactly match our dts. Therefore adjust the dts
+ * of this packet to be what the previous packets duration implies. */
+ trk->cluster[trk->entry].dts = trk->start_dts + trk->trackDuration;
+ }
+ if (trk->start_dts == AV_NOPTS_VALUE)
+ trk->start_dts = pkt->dts;
+ trk->trackDuration = pkt->dts - trk->start_dts + pkt->duration;
if (pkt->pts == AV_NOPTS_VALUE) {
av_log(s, AV_LOG_WARNING, "pts has no value\n");
return 0;
}
+int ff_mov_write_packet(AVFormatContext *s, AVPacket *pkt)
+{
+ if (!pkt) {
+ mov_flush_fragment(s);
+ return 1;
+ } else {
+ return mov_write_packet_internal(s, 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)
AVDictionaryEntry *t;
int i, hint_track = 0;
- if (!s->pb->seekable) {
+ /* Non-seekable output is ok if EMPTY_MOOV is set, or if using the ismv
+ * format (which sets EMPTY_MOOV later in this function). If ism_lookahead
+ * is enabled, we don't support non-seekable output at all. */
+ if (!s->pb->seekable &&
+ ((!(mov->flags & FF_MOV_FLAG_EMPTY_MOOV) &&
+ !(s->oformat && !strcmp(s->oformat->name, "ismv")))
+ || mov->ism_lookahead)) {
av_log(s, AV_LOG_ERROR, "muxer does not support non seekable output\n");
return -1;
}
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 (mov->mode & (MODE_MOV|MODE_IPOD) && s->nb_chapters)
mov->chapter_track = mov->nb_streams++;
-#if FF_API_FLAG_RTP_HINT
- if (s->flags & AVFMT_FLAG_RTP_HINT) {
- av_log(s, AV_LOG_WARNING, "The RTP_HINT flag is deprecated, enable it "
- "via the -movflags rtphint muxer option "
- "instead.\n");
- mov->flags |= FF_MOV_FLAG_RTP_HINT;
- }
-#endif
if (mov->flags & FF_MOV_FLAG_RTP_HINT) {
/* Add hint tracks for each audio and video stream */
hint_track = mov->nb_streams;
/* If hinting of this track is enabled by a later hint track,
* this is updated. */
track->hint_track = -1;
+ track->start_dts = AV_NOPTS_VALUE;
if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
if (track->tag == MKTAG('m','x','3','p') || track->tag == MKTAG('m','x','3','n') ||
track->tag == MKTAG('m','x','4','p') || track->tag == MKTAG('m','x','4','n') ||
}
/* set audio_vbr for compressed audio */
if (av_get_bits_per_sample(st->codec->codec_id) < 8) {
- if (!st->codec->frame_size) {
+ if (!st->codec->frame_size && track->mode == MODE_MOV) {
av_log(s, AV_LOG_ERROR, "track %d: codec frame size is not set\n", i);
goto error;
}
}
if (!track->height)
track->height = st->codec->height;
+ /* The ism specific timescale isn't mandatory, but is assumed by
+ * some tools, such as mp4split. */
+ if (mov->mode == MODE_ISM)
+ track->timescale = 10000000;
avpriv_set_pts_info(st, 64, 1, track->timescale);
+
+ /* copy extradata if it exists */
+ if (st->codec->extradata_size) {
+ track->vosLen = st->codec->extradata_size;
+ track->vosData = av_malloc(track->vosLen);
+ memcpy(track->vosData, st->codec->extradata, track->vosLen);
+ }
}
- mov_write_mdat_tag(pb, mov);
+ if (mov->mode == MODE_ISM) {
+ /* 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;
+ }
+
+ /* Set the FRAGMENT flag if any of the fragmentation methods are
+ * enabled. */
+ if (mov->max_fragment_duration || mov->max_fragment_size ||
+ mov->flags & (FF_MOV_FLAG_EMPTY_MOOV |
+ FF_MOV_FLAG_FRAG_KEYFRAME |
+ FF_MOV_FLAG_FRAG_CUSTOM))
+ mov->flags |= FF_MOV_FLAG_FRAGMENT;
+
+ if (!(mov->flags & FF_MOV_FLAG_EMPTY_MOOV))
+ mov_write_mdat_tag(pb, mov);
-#if FF_API_TIMESTAMP
- if (s->timestamp)
- mov->time = s->timestamp;
- else
-#endif
if (t = av_dict_get(s->metadata, "creation_time", NULL, 0))
mov->time = ff_iso8601_to_unix_time(t->value);
- mov->time += 0x7C25B080; //1970 based -> 1904 based
+ if (mov->time)
+ mov->time += 0x7C25B080; // 1970 based -> 1904 based
if (mov->chapter_track)
mov_create_chapter_track(s, mov->chapter_track);
avio_flush(pb);
+ if (mov->flags & FF_MOV_FLAG_ISML)
+ mov_write_isml_manifest(pb, mov);
+
+ if (mov->flags & FF_MOV_FLAG_EMPTY_MOOV) {
+ mov_write_moov_tag(pb, mov, s);
+ mov->fragments++;
+ }
+
return 0;
error:
av_freep(&mov->tracks);
int64_t 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);
- avio_wb32(pb, mov->mdat_size+8);
+ if (!(mov->flags & FF_MOV_FLAG_FRAGMENT)) {
+ /* Write size of mdat tag */
+ if (mov->mdat_size + 8 <= UINT32_MAX) {
+ avio_seek(pb, mov->mdat_pos, SEEK_SET);
+ avio_wb32(pb, mov->mdat_size + 8);
+ } else {
+ /* overwrite 'wide' placeholder atom */
+ avio_seek(pb, mov->mdat_pos - 8, SEEK_SET);
+ /* special value: real atom size will be 64 bit value after
+ * tag field */
+ avio_wb32(pb, 1);
+ ffio_wfourcc(pb, "mdat");
+ avio_wb64(pb, mov->mdat_size + 16);
+ }
+ avio_seek(pb, moov_pos, SEEK_SET);
+
+ mov_write_moov_tag(pb, mov, s);
} else {
- /* overwrite 'wide' placeholder atom */
- avio_seek(pb, mov->mdat_pos - 8, SEEK_SET);
- avio_wb32(pb, 1); /* special value: real atom size will be 64 bit value after tag field */
- ffio_wfourcc(pb, "mdat");
- avio_wb64(pb, mov->mdat_size+16);
+ mov_flush_fragment(s);
+ mov_write_mfra_tag(pb, mov);
}
- avio_seek(pb, moov_pos, SEEK_SET);
-
- mov_write_moov_tag(pb, mov, s);
if (mov->chapter_track)
av_freep(&mov->tracks[mov->chapter_track].enc);
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].vosLen) av_free(mov->tracks[i].vosData);
.write_header = mov_write_header,
.write_packet = ff_mov_write_packet,
.write_trailer = mov_write_trailer,
- .flags = AVFMT_GLOBALHEADER,
+ .flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH,
.codec_tag = (const AVCodecTag* const []){codec_movvideo_tags, codec_movaudio_tags, 0},
.priv_class = &mov_muxer_class,
};
.write_header = mov_write_header,
.write_packet = ff_mov_write_packet,
.write_trailer = mov_write_trailer,
- .flags = AVFMT_GLOBALHEADER,
+ .flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH,
.codec_tag = (const AVCodecTag* const []){codec_3gp_tags, 0},
.priv_class = &tgp_muxer_class,
};
.write_header = mov_write_header,
.write_packet = ff_mov_write_packet,
.write_trailer = mov_write_trailer,
- .flags = AVFMT_GLOBALHEADER,
+ .flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH,
.codec_tag = (const AVCodecTag* const []){ff_mp4_obj_type, 0},
.priv_class = &mp4_muxer_class,
};
.write_header = mov_write_header,
.write_packet = ff_mov_write_packet,
.write_trailer = mov_write_trailer,
- .flags = AVFMT_GLOBALHEADER,
+ .flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH,
.codec_tag = (const AVCodecTag* const []){ff_mp4_obj_type, 0},
.priv_class = &psp_muxer_class,
};
.write_header = mov_write_header,
.write_packet = ff_mov_write_packet,
.write_trailer = mov_write_trailer,
- .flags = AVFMT_GLOBALHEADER,
+ .flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH,
.codec_tag = (const AVCodecTag* const []){codec_3gp_tags, 0},
.priv_class = &tg2_muxer_class,
};
.write_header = mov_write_header,
.write_packet = ff_mov_write_packet,
.write_trailer = mov_write_trailer,
- .flags = AVFMT_GLOBALHEADER,
+ .flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH,
.codec_tag = (const AVCodecTag* const []){codec_ipod_tags, 0},
.priv_class = &ipod_muxer_class,
};
#endif
+#if CONFIG_ISMV_MUXER
+MOV_CLASS(ismv)
+AVOutputFormat ff_ismv_muxer = {
+ .name = "ismv",
+ .long_name = NULL_IF_CONFIG_SMALL("ISMV/ISMA (Smooth Streaming) format"),
+ .mime_type = "application/mp4",
+ .extensions = "ismv,isma",
+ .priv_data_size = sizeof(MOVMuxContext),
+ .audio_codec = CODEC_ID_AAC,
+ .video_codec = CODEC_ID_H264,
+ .write_header = mov_write_header,
+ .write_packet = ff_mov_write_packet,
+ .write_trailer = mov_write_trailer,
+ .flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH,
+ .codec_tag = (const AVCodecTag* const []){ff_mp4_obj_type, 0},
+ .priv_class = &ismv_muxer_class,
+};
+#endif