{ "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" },
{ "default_base_moof", "Set the default-base-is-moof flag in tfhd atoms", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_DEFAULT_BASE_MOOF}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
+ { "dash", "Write DASH compatible fragmented MP4", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_DASH}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
+ { "frag_discont", "Signal that the next fragment is discontinuous from earlier ones", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_FRAG_DISCONT}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
+ { "delay_moov", "Delay writing the initial moov until the first fragment is cut, or until the first fragment flush", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_DELAY_MOOV}, 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},
{ "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 },
{ "use_editlist", "use edit list", offsetof(MOVMuxContext, use_editlist), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, AV_OPT_FLAG_ENCODING_PARAM},
+ { "fragment_index", "Fragment number of the next fragment", offsetof(MOVMuxContext, fragments), AV_OPT_TYPE_INT, {.i64 = 1}, 1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
+ { "frag_interleave", "Interleave samples within fragments (max number of consecutive samples, lower is tighter interleaving, but with more overhead)", offsetof(MOVMuxContext, frag_interleave), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
{ NULL },
};
if (track->start_dts == AV_NOPTS_VALUE) {
/* No packets written yet, vc1_info isn't authoritative yet. */
- /* Assume inline sequence and entry headers. This will be
- * overwritten at the end if the file is seekable. */
+ /* Assume inline sequence and entry headers. */
packet_seq = packet_entry = 1;
+ av_log(NULL, AV_LOG_WARNING,
+ "moov atom written before any packets, unable to write correct "
+ "dvc1 atom. Set the delay_moov flag to fix this.\n");
}
unescaped = av_mallocz(track->vos_len + FF_INPUT_BUFFER_PADDING_SIZE);
avio_wb32(pb, track->vos_len + 8 + sizeof(buf));
ffio_wfourcc(pb, "dvc1");
- track->vc1_info.struct_offset = avio_tell(pb);
avio_write(pb, buf, sizeof(buf));
avio_write(pb, track->vos_data, track->vos_len);
int i;
ctts_entries = av_malloc((track->entry + 1) * sizeof(*ctts_entries)); /* worst case */
+ if (!ctts_entries)
+ return AVERROR(ENOMEM);
ctts_entries[0].count = 1;
ctts_entries[0].duration = track->cluster[0].cts;
for (i = 1; i < track->entry; i++) {
/* Time to sample atom */
static int mov_write_stts_tag(AVIOContext *pb, MOVTrack *track)
{
- MOVStts *stts_entries;
+ MOVStts *stts_entries = NULL;
uint32_t entries = -1;
uint32_t atom_size;
int i;
if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO && !track->audio_vbr) {
stts_entries = av_malloc(sizeof(*stts_entries)); /* one entry */
+ if (!stts_entries)
+ return AVERROR(ENOMEM);
stts_entries[0].count = track->sample_count;
stts_entries[0].duration = 1;
entries = 1;
} else {
- stts_entries = track->entry ?
- av_malloc(track->entry * sizeof(*stts_entries)) : /* worst case */
- NULL;
+ if (track->entry) {
+ stts_entries = av_malloc(track->entry * sizeof(*stts_entries)); /* worst case */
+ if (!stts_entries)
+ return AVERROR(ENOMEM);
+ }
for (i = 0; i < track->entry; i++) {
int duration = get_cluster_duration(track, i);
if (i && duration == stts_entries[entries].duration) {
if (track->mode == MODE_MOV && track->flags & MOV_TRACK_STPS)
mov_write_stss_tag(pb, track, MOV_PARTIAL_SYNC_SAMPLE);
if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO &&
- track->flags & MOV_TRACK_CTTS)
+ track->flags & MOV_TRACK_CTTS && track->entry)
mov_write_ctts_tag(pb, track);
mov_write_stsc_tag(pb, track);
mov_write_stsz_tag(pb, track);
int flags = MOV_TKHD_FLAG_IN_MOVIE;
int group = 0;
+ uint32_t *display_matrix = NULL;
+ int display_matrix_size, i;
if (st) {
if (mov->per_stream_grouping)
group = st->index;
else
group = st->codec->codec_type;
+
+ display_matrix = (uint32_t*)av_stream_get_side_data(st, AV_PKT_DATA_DISPLAYMATRIX,
+ &display_matrix_size);
+ if (display_matrix_size < 9 * sizeof(*display_matrix))
+ display_matrix = NULL;
}
if (track->flags & MOV_TRACK_ENABLED)
avio_wb16(pb, 0); /* reserved */
/* Matrix structure */
- avio_wb32(pb, 0x00010000); /* reserved */
- avio_wb32(pb, 0x0); /* reserved */
- avio_wb32(pb, 0x0); /* reserved */
- avio_wb32(pb, 0x0); /* reserved */
- avio_wb32(pb, 0x00010000); /* reserved */
- avio_wb32(pb, 0x0); /* reserved */
- avio_wb32(pb, 0x0); /* reserved */
- avio_wb32(pb, 0x0); /* reserved */
- avio_wb32(pb, 0x40000000); /* reserved */
+ if (display_matrix) {
+ for (i = 0; i < 9; i++)
+ avio_wb32(pb, display_matrix[i]);
+ } else {
+ avio_wb32(pb, 0x00010000); /* reserved */
+ avio_wb32(pb, 0x0); /* reserved */
+ avio_wb32(pb, 0x0); /* reserved */
+ avio_wb32(pb, 0x0); /* reserved */
+ avio_wb32(pb, 0x00010000); /* reserved */
+ avio_wb32(pb, 0x0); /* reserved */
+ avio_wb32(pb, 0x0); /* reserved */
+ avio_wb32(pb, 0x0); /* reserved */
+ avio_wb32(pb, 0x40000000); /* reserved */
+ }
/* Track width and height, for visual only */
if (st && (track->enc->codec_type == AVMEDIA_TYPE_VIDEO ||
track->timescale, AV_ROUND_UP);
int version = duration < INT32_MAX ? 0 : 1;
int entry_size, entry_count, size;
- int64_t delay, start_ct = track->cluster[0].cts;
- delay = av_rescale_rnd(track->cluster[0].dts + start_ct, MOV_TIMESCALE,
+ int64_t delay, start_ct = track->start_cts;
+ delay = av_rescale_rnd(track->start_dts + start_ct, MOV_TIMESCALE,
track->timescale, AV_ROUND_DOWN);
version |= delay < INT32_MAX ? 0 : 1;
* special meaning. Normally start_ct should end up positive or zero
* here, but use FFMIN in case dts is a a small positive integer
* rounded to 0 when represented in MOV_TIMESCALE units. */
- start_ct = -FFMIN(track->cluster[0].dts, 0);
+ start_ct = -FFMIN(track->start_dts, 0);
/* Note, this delay is calculated from the pts of the first sample,
* ensuring that we don't reduce the duration for cases with
* dts<0 pts=0. */
MOVTrack *track, AVStream *st)
{
int64_t pos = avio_tell(pb);
+ int entry_backup = track->entry;
+ /* If we want to have an empty moov, but some samples already have been
+ * buffered (delay_moov), pretend that no samples have been written yet. */
+ if (mov->flags & FF_MOV_FLAG_EMPTY_MOOV)
+ track->entry = 0;
+
avio_wb32(pb, 0); /* size */
ffio_wfourcc(pb, "trak");
mov_write_tkhd_tag(pb, mov, track, st);
- if (track->entry &&
+ if (track->start_dts != AV_NOPTS_VALUE &&
(track->mode == MODE_PSP || track->flags & MOV_TRACK_CTTS ||
- track->cluster[0].dts || is_clcp_track(track))) {
+ track->start_dts || is_clcp_track(track))) {
if (mov->use_editlist)
mov_write_edts_tag(pb, mov, track); // PSP Movies require edts box
else if ((track->entry && track->cluster[0].dts) || track->mode == MODE_PSP || is_clcp_track(track))
}
}
mov_write_track_udta_tag(pb, mov, st);
+ track->entry = entry_backup;
return update_size(pb, pos);
}
int audio_profile = mov->iods_audio_profile;
int video_profile = mov->iods_video_profile;
for (i = 0; i < mov->nb_streams; i++) {
- if (mov->tracks[i].entry > 0) {
+ if (mov->tracks[i].entry > 0 || mov->flags & FF_MOV_FLAG_EMPTY_MOOV) {
has_audio |= mov->tracks[i].enc->codec_type == AVMEDIA_TYPE_AUDIO;
has_video |= mov->tracks[i].enc->codec_type == AVMEDIA_TYPE_VIDEO;
}
max_track_id = mov->tracks[i].track_id;
}
}
+ /* If using delay_moov, make sure the output is the same as if no
+ * samples had been written yet. */
+ if (mov->flags & FF_MOV_FLAG_EMPTY_MOOV) {
+ max_track_len = 0;
+ max_track_id = 1;
+ }
version = max_track_len < UINT32_MAX ? 0 : 1;
(version == 1) ? avio_wb32(pb, 120) : avio_wb32(pb, 108); /* size */
mov_write_string_metadata(s, pb_buf, "\251des", "comment", 0);
mov_write_string_metadata(s, pb_buf, "\251gen", "genre", 0);
mov_write_string_metadata(s, pb_buf, "\251cpy", "copyright", 0);
+ mov_write_string_metadata(s, pb_buf, "\251mak", "make", 0);
+ mov_write_string_metadata(s, pb_buf, "\251mod", "model", 0);
} else {
/* iTunes meta data */
mov_write_meta_tag(pb_buf, mov, s);
return 0;
}
+static uint32_t get_sample_flags(MOVTrack *track, MOVIentry *entry)
+{
+ return entry->flags & MOV_SYNC_SAMPLE ? MOV_FRAG_SAMPLE_FLAG_DEPENDS_NO :
+ (MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES | MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC);
+}
+
static int mov_write_tfhd_tag(AVIOContext *pb, MOVMuxContext *mov,
MOVTrack *track, int64_t moof_offset)
{
track->default_size = -1;
if (flags & MOV_TFHD_DEFAULT_FLAGS) {
- track->default_sample_flags =
- track->enc->codec_type == AVMEDIA_TYPE_VIDEO ?
- (MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES | MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC) :
- MOV_FRAG_SAMPLE_FLAG_DEPENDS_NO;
+ /* Set the default flags based on the second sample, if available.
+ * If the first sample is different, that can be signaled via a separate field. */
+ if (track->entry > 1)
+ track->default_sample_flags = get_sample_flags(track, &track->cluster[1]);
+ else
+ track->default_sample_flags =
+ track->enc->codec_type == AVMEDIA_TYPE_VIDEO ?
+ (MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES | MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC) :
+ MOV_FRAG_SAMPLE_FLAG_DEPENDS_NO;
avio_wb32(pb, track->default_sample_flags);
}
return update_size(pb, pos);
}
-static uint32_t get_sample_flags(MOVTrack *track, MOVIentry *entry)
-{
- return entry->flags & MOV_SYNC_SAMPLE ? MOV_FRAG_SAMPLE_FLAG_DEPENDS_NO :
- (MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES | MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC);
-}
-
static int mov_write_trun_tag(AVIOContext *pb, MOVMuxContext *mov,
- MOVTrack *track, int moof_size)
+ MOVTrack *track, int moof_size,
+ int first, int end)
{
int64_t pos = avio_tell(pb);
uint32_t flags = MOV_TRUN_DATA_OFFSET;
int i;
- for (i = 0; i < track->entry; i++) {
+ for (i = first; i < end; i++) {
if (get_cluster_duration(track, i) != track->default_duration)
flags |= MOV_TRUN_SAMPLE_DURATION;
if (track->cluster[i].size != track->default_size)
flags |= MOV_TRUN_SAMPLE_SIZE;
- if (i > 0 && get_sample_flags(track, &track->cluster[i]) != track->default_sample_flags)
+ if (i > first && get_sample_flags(track, &track->cluster[i]) != track->default_sample_flags)
flags |= MOV_TRUN_SAMPLE_FLAGS;
}
- if (!(flags & MOV_TRUN_SAMPLE_FLAGS))
+ if (!(flags & MOV_TRUN_SAMPLE_FLAGS) && track->entry > 0 &&
+ get_sample_flags(track, &track->cluster[0]) != track->default_sample_flags)
flags |= MOV_TRUN_FIRST_SAMPLE_FLAGS;
if (track->flags & MOV_TRACK_CTTS)
flags |= MOV_TRUN_SAMPLE_CTS;
avio_w8(pb, 0); /* version */
avio_wb24(pb, flags);
- avio_wb32(pb, track->entry); /* sample count */
+ avio_wb32(pb, end - first); /* sample count */
if (mov->flags & FF_MOV_FLAG_OMIT_TFHD_OFFSET &&
!(mov->flags & FF_MOV_FLAG_DEFAULT_BASE_MOOF) &&
!mov->first_trun)
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 */
+ track->cluster[first].pos); /* data offset */
if (flags & MOV_TRUN_FIRST_SAMPLE_FLAGS)
- avio_wb32(pb, get_sample_flags(track, &track->cluster[0]));
+ avio_wb32(pb, get_sample_flags(track, &track->cluster[first]));
- for (i = 0; i < track->entry; i++) {
+ for (i = first; i < end; i++) {
if (flags & MOV_TRUN_SAMPLE_DURATION)
avio_wb32(pb, get_cluster_duration(track, i));
if (flags & MOV_TRUN_SAMPLE_SIZE)
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->track_duration -
- track->cluster[0].dts);
+ avio_wb64(pb, track->start_dts + track->frag_start +
+ track->cluster[0].cts);
+ avio_wb64(pb, track->end_pts -
+ (track->cluster[0].dts + track->cluster[0].cts));
return update_size(pb, pos);
}
return 0;
}
+static int mov_add_tfra_entries(AVIOContext *pb, MOVMuxContext *mov, int tracks,
+ int size)
+{
+ int i;
+ for (i = 0; i < mov->nb_streams; i++) {
+ MOVTrack *track = &mov->tracks[i];
+ MOVFragmentInfo *info;
+ if ((tracks >= 0 && i != tracks) || !track->entry)
+ continue;
+ track->nb_frag_info++;
+ if (track->nb_frag_info >= track->frag_info_capacity) {
+ unsigned new_capacity = track->nb_frag_info + MOV_FRAG_INFO_ALLOC_INCREMENT;
+ if (av_reallocp_array(&track->frag_info,
+ new_capacity,
+ sizeof(*track->frag_info)))
+ return AVERROR(ENOMEM);
+ track->frag_info_capacity = new_capacity;
+ }
+ info = &track->frag_info[track->nb_frag_info - 1];
+ info->offset = avio_tell(pb);
+ info->size = size;
+ // Try to recreate the original pts for the first packet
+ // from the fields we have stored
+ info->time = track->start_dts + track->frag_start +
+ track->cluster[0].cts;
+ info->duration = track->end_pts -
+ (track->cluster[0].dts + track->cluster[0].cts);
+ // If the pts is less than zero, we will have trimmed
+ // away parts of the media track using an edit list,
+ // and the corresponding start presentation time is zero.
+ if (info->time < 0) {
+ info->duration += info->time;
+ info->time = 0;
+ }
+ info->tfrf_offset = 0;
+ mov_write_tfrf_tags(pb, mov, track);
+ }
+ return 0;
+}
+
static int mov_write_tfdt_tag(AVIOContext *pb, MOVTrack *track)
{
int64_t pos = avio_tell(pb);
int moof_size)
{
int64_t pos = avio_tell(pb);
+ int i, start = 0;
avio_wb32(pb, 0); /* size placeholder */
ffio_wfourcc(pb, "traf");
mov_write_tfhd_tag(pb, mov, track, moof_offset);
if (mov->mode != MODE_ISM)
mov_write_tfdt_tag(pb, track);
- mov_write_trun_tag(pb, mov, track, moof_size);
+ for (i = 1; i < track->entry; i++) {
+ if (track->cluster[i].pos != track->cluster[i - 1].pos + track->cluster[i - 1].size) {
+ mov_write_trun_tag(pb, mov, track, moof_size, start, i);
+ start = i;
+ }
+ }
+ mov_write_trun_tag(pb, mov, track, moof_size, start, track->entry);
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);
+ if (track->nb_frag_info > 0) {
+ MOVFragmentInfo *info = &track->frag_info[track->nb_frag_info - 1];
+ if (!info->tfrf_offset)
+ info->tfrf_offset = avio_tell(pb);
+ }
avio_wb32(pb, 8 + size);
ffio_wfourcc(pb, "free");
for (i = 0; i < size; i++)
return update_size(pb, pos);
}
-static int mov_write_moof_tag(AVIOContext *pb, MOVMuxContext *mov, int tracks)
+static int mov_write_sidx_tag(AVIOContext *pb,
+ MOVTrack *track, int ref_size, int total_sidx_size)
+{
+ int64_t pos = avio_tell(pb), offset_pos, end_pos;
+ int64_t presentation_time, duration, offset;
+ int starts_with_SAP, i, entries;
+
+ if (track->entry) {
+ entries = 1;
+ presentation_time = track->start_dts + track->frag_start +
+ track->cluster[0].cts;
+ duration = track->end_pts -
+ (track->cluster[0].dts + track->cluster[0].cts);
+ starts_with_SAP = track->cluster[0].flags & MOV_SYNC_SAMPLE;
+
+ // pts<0 should be cut away using edts
+ if (presentation_time < 0) {
+ duration += presentation_time;
+ presentation_time = 0;
+ }
+ } else {
+ entries = track->nb_frag_info;
+ presentation_time = track->frag_info[0].time;
+ }
+
+ avio_wb32(pb, 0); /* size */
+ ffio_wfourcc(pb, "sidx");
+ avio_w8(pb, 1); /* version */
+ avio_wb24(pb, 0);
+ avio_wb32(pb, track->track_id); /* reference_ID */
+ avio_wb32(pb, track->timescale); /* timescale */
+ avio_wb64(pb, presentation_time); /* earliest_presentation_time */
+ offset_pos = avio_tell(pb);
+ avio_wb64(pb, 0); /* first_offset (offset to referenced moof) */
+ avio_wb16(pb, 0); /* reserved */
+
+ avio_wb16(pb, entries); /* reference_count */
+ for (i = 0; i < entries; i++) {
+ if (!track->entry) {
+ if (i > 1 && track->frag_info[i].offset != track->frag_info[i - 1].offset + track->frag_info[i - 1].size) {
+ av_log(NULL, AV_LOG_ERROR, "Non-consecutive fragments, writing incorrect sidx\n");
+ }
+ duration = track->frag_info[i].duration;
+ ref_size = track->frag_info[i].size;
+ starts_with_SAP = 1;
+ }
+ avio_wb32(pb, (0 << 31) | (ref_size & 0x7fffffff)); /* reference_type (0 = media) | referenced_size */
+ avio_wb32(pb, duration); /* subsegment_duration */
+ avio_wb32(pb, (starts_with_SAP << 31) | (0 << 28) | 0); /* starts_with_SAP | SAP_type | SAP_delta_time */
+ }
+
+ end_pos = avio_tell(pb);
+ offset = pos + total_sidx_size - end_pos;
+ avio_seek(pb, offset_pos, SEEK_SET);
+ avio_wb64(pb, offset);
+ avio_seek(pb, end_pos, SEEK_SET);
+ return update_size(pb, pos);
+}
+
+static int mov_write_sidx_tags(AVIOContext *pb, MOVMuxContext *mov,
+ int tracks, int ref_size)
+{
+ int i, round, ret;
+ AVIOContext *avio_buf;
+ int total_size = 0;
+ for (round = 0; round < 2; round++) {
+ // First run one round to calculate the total size of all
+ // sidx atoms.
+ // This would be much simpler if we'd only write one sidx
+ // atom, for the first track in the moof.
+ if (round == 0) {
+ if ((ret = ffio_open_null_buf(&avio_buf)) < 0)
+ return ret;
+ } else {
+ avio_buf = pb;
+ }
+ for (i = 0; i < mov->nb_streams; i++) {
+ MOVTrack *track = &mov->tracks[i];
+ if (tracks >= 0 && i != tracks)
+ continue;
+ // When writing a sidx for the full file, entry is 0, but
+ // we want to include all tracks. ref_size is 0 in this case,
+ // since we read it from frag_info instead.
+ if (!track->entry && ref_size > 0)
+ continue;
+ total_size -= mov_write_sidx_tag(avio_buf, track, ref_size,
+ total_size);
+ }
+ if (round == 0)
+ total_size = ffio_close_null_buf(avio_buf);
+ }
+ return 0;
+}
+
+static int mov_write_moof_tag(AVIOContext *pb, MOVMuxContext *mov, int tracks,
+ int64_t mdat_size)
{
AVIOContext *avio_buf;
int ret, moof_size;
return ret;
mov_write_moof_tag_internal(avio_buf, mov, tracks, 0);
moof_size = ffio_close_null_buf(avio_buf);
+
+ if (mov->flags & FF_MOV_FLAG_DASH && !(mov->flags & FF_MOV_FLAG_FASTSTART))
+ mov_write_sidx_tags(pb, mov, tracks, moof_size + 8 + mdat_size);
+
+ if ((ret = mov_add_tfra_entries(pb, mov, tracks, moof_size + 8 + mdat_size)) < 0)
+ return ret;
+
return mov_write_moof_tag_internal(pb, mov, tracks, moof_size);
}
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_wb64(pb, track->frag_info[i].offset + track->data_offset);
avio_w8(pb, 1); /* traf number */
avio_w8(pb, 1); /* trun number */
avio_w8(pb, 1); /* sample number */
ffio_wfourcc(pb, "MSNV");
else if (mov->mode == MODE_MP4)
ffio_wfourcc(pb, "mp41");
+
+ if (mov->flags & FF_MOV_FLAG_DASH && mov->flags & FF_MOV_FLAG_FASTSTART)
+ ffio_wfourcc(pb, "dash");
+
return update_size(pb, pos);
}
avio_wb32(pb, 0x010001); /* ? */
}
+static int mov_write_identification(AVIOContext *pb, AVFormatContext *s)
+{
+ MOVMuxContext *mov = s->priv_data;
+ 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);
+ }
+ return 0;
+}
+
static int mov_parse_mpeg2_frame(AVPacket *pkt, uint32_t *flags)
{
uint32_t c = -1;
return 0;
}
-static void mov_parse_vc1_frame(AVPacket *pkt, MOVTrack *trk, int fragment)
+static void mov_parse_vc1_frame(AVPacket *pkt, MOVTrack *trk)
{
const uint8_t *start, *next, *end = pkt->data + pkt->size;
int seq = 0, entry = 0;
break;
}
}
- if (!trk->entry && !fragment) {
+ if (!trk->entry && trk->vc1_info.first_packet_seen)
+ trk->vc1_info.first_frag_written = 1;
+ if (!trk->entry && !trk->vc1_info.first_frag_written) {
/* First packet in first fragment */
trk->vc1_info.first_packet_seq = seq;
trk->vc1_info.first_packet_entry = entry;
+ trk->vc1_info.first_packet_seen = 1;
} else if ((seq && !trk->vc1_info.packet_seq) ||
(entry && !trk->vc1_info.packet_entry)) {
int i;
trk->vc1_info.packet_seq = 1;
if (entry)
trk->vc1_info.packet_entry = 1;
- if (!fragment) {
+ if (!trk->vc1_info.first_frag_written) {
/* First fragment */
if ((!seq || trk->vc1_info.first_packet_seq) &&
(!entry || trk->vc1_info.first_packet_entry)) {
}
}
+static int mov_flush_fragment_interleaving(AVFormatContext *s, MOVTrack *track)
+{
+ MOVMuxContext *mov = s->priv_data;
+ int ret, buf_size;
+ uint8_t *buf;
+ int i, offset;
+
+ if (!track->mdat_buf)
+ return 0;
+ if (!mov->mdat_buf) {
+ if ((ret = avio_open_dyn_buf(&mov->mdat_buf)) < 0)
+ return ret;
+ }
+ buf_size = avio_close_dyn_buf(track->mdat_buf, &buf);
+ track->mdat_buf = NULL;
+
+ offset = avio_tell(mov->mdat_buf);
+ avio_write(mov->mdat_buf, buf, buf_size);
+ av_free(buf);
+
+ for (i = track->entries_flushed; i < track->entry; i++)
+ track->cluster[i].pos += offset;
+ track->entries_flushed = track->entry;
+ return 0;
+}
+
static int mov_flush_fragment(AVFormatContext *s)
{
MOVMuxContext *mov = s->priv_data;
if (!(mov->flags & FF_MOV_FLAG_FRAGMENT))
return 0;
- if (!(mov->flags & FF_MOV_FLAG_EMPTY_MOOV) && mov->fragments == 0) {
+ for (i = 0; i < mov->nb_streams; i++) {
+ MOVTrack *track = &mov->tracks[i];
+ if (track->entry <= 1)
+ continue;
+ // Sample durations are calculated as the diff of dts values,
+ // but for the last sample in a fragment, we don't know the dts
+ // of the first sample in the next fragment, so we have to rely
+ // on what was set as duration in the AVPacket. Not all callers
+ // set this though, so we might want to replace it with an
+ // estimate if it currently is zero.
+ if (get_cluster_duration(track, track->entry - 1) != 0)
+ continue;
+ // Use the duration (i.e. dts diff) of the second last sample for
+ // the last one. This is a wild guess (and fatal if it turns out
+ // to be too long), but probably the best we can do - having a zero
+ // duration is bad as well.
+ track->track_duration += get_cluster_duration(track, track->entry - 2);
+ track->end_pts += get_cluster_duration(track, track->entry - 2);
+ if (!mov->missing_duration_warned) {
+ av_log(s, AV_LOG_WARNING,
+ "Estimating the duration of the last packet in a "
+ "fragment, consider setting the duration field in "
+ "AVPacket instead.\n");
+ mov->missing_duration_warned = 1;
+ }
+ }
+
+ if (!mov->moov_written) {
int64_t pos = avio_tell(s->pb);
int ret;
AVIOContext *moov_buf;
for (i = 0; i < mov->nb_streams; i++)
mov->tracks[i].data_offset = pos + buf_size + 8;
+ if (mov->flags & FF_MOV_FLAG_DELAY_MOOV)
+ mov_write_identification(s->pb, s);
mov_write_moov_tag(s->pb, mov, s);
+ if (mov->flags & FF_MOV_FLAG_DELAY_MOOV) {
+ if (mov->flags & FF_MOV_FLAG_FASTSTART)
+ mov->reserved_moov_pos = avio_tell(s->pb);
+ avio_flush(s->pb);
+ mov->moov_written = 1;
+ return 0;
+ }
+
buf_size = avio_close_dyn_buf(mov->mdat_buf, &buf);
mov->mdat_buf = NULL;
avio_wb32(s->pb, buf_size + 8);
avio_write(s->pb, buf, buf_size);
av_free(buf);
- mov->fragments++;
+ mov->moov_written = 1;
mov->mdat_size = 0;
for (i = 0; i < mov->nb_streams; i++) {
if (mov->tracks[i].entry)
return 0;
}
+ if (mov->frag_interleave) {
+ for (i = 0; i < mov->nb_streams; i++) {
+ MOVTrack *track = &mov->tracks[i];
+ int ret;
+ if ((ret = mov_flush_fragment_interleaving(s, track)) < 0)
+ return ret;
+ }
+
+ if (!mov->mdat_buf)
+ return 0;
+ mdat_size = avio_tell(mov->mdat_buf);
+ }
+
for (i = 0; i < mov->nb_streams; i++) {
MOVTrack *track = &mov->tracks[i];
- if (mov->flags & FF_MOV_FLAG_SEPARATE_MOOF)
+ if (mov->flags & FF_MOV_FLAG_SEPARATE_MOOF || mov->frag_interleave)
track->data_offset = 0;
else
track->data_offset = mdat_size;
- if (!track->mdat_buf)
+ if (!track->entry)
continue;
- mdat_size += avio_tell(track->mdat_buf);
+ if (track->mdat_buf)
+ mdat_size += avio_tell(track->mdat_buf);
if (first_track < 0)
first_track = i;
}
}
if (write_moof) {
- MOVFragmentInfo *info;
avio_flush(s->pb);
- track->nb_frag_info++;
- if (track->nb_frag_info >= track->frag_info_capacity) {
- unsigned new_capacity = track->nb_frag_info + MOV_FRAG_INFO_ALLOC_INCREMENT;
- if (av_reallocp_array(&track->frag_info,
- new_capacity,
- sizeof(*track->frag_info)))
- return AVERROR(ENOMEM);
- track->frag_info_capacity = new_capacity;
- }
- info = &track->frag_info[track->nb_frag_info - 1];
- info->offset = avio_tell(s->pb);
- info->time = track->frag_start;
- if (track->entry) {
- // Try to recreate the original pts for the first packet
- // from the fields we have stored
- info->time = track->start_dts + track->frag_start +
- track->cluster[0].cts;
- // If the pts is less than zero, we will have trimmed
- // away parts of the media track using an edit list,
- // and the corresponding start presentation time is zero.
- if (info->time < 0)
- info->time = 0;
- }
- 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_write_moof_tag(s->pb, mov, moof_tracks, mdat_size);
mov->fragments++;
avio_wb32(s->pb, mdat_size + 8);
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;
+ track->entries_flushed = 0;
+ if (!mov->frag_interleave) {
+ if (!track->mdat_buf)
+ continue;
+ buf_size = avio_close_dyn_buf(track->mdat_buf, &buf);
+ track->mdat_buf = NULL;
+ } else {
+ if (!mov->mdat_buf)
+ continue;
+ buf_size = avio_close_dyn_buf(mov->mdat_buf, &buf);
+ mov->mdat_buf = NULL;
+ }
avio_write(s->pb, buf, buf_size);
av_free(buf);
return 0;
}
+static int mov_auto_flush_fragment(AVFormatContext *s)
+{
+ MOVMuxContext *mov = s->priv_data;
+ int had_moov = mov->moov_written;
+ int ret = mov_flush_fragment(s);
+ if (ret < 0)
+ return ret;
+ // If using delay_moov, the first flush only wrote the moov,
+ // not the actual moof+mdat pair, thus flush once again.
+ if (!had_moov && mov->flags & FF_MOV_FLAG_DELAY_MOOV)
+ ret = mov_flush_fragment(s);
+ return ret;
+}
+
int ff_mov_write_packet(AVFormatContext *s, AVPacket *pkt)
{
MOVMuxContext *mov = s->priv_data;
if (mov->flags & FF_MOV_FLAG_FRAGMENT) {
int ret;
- if (mov->fragments > 0) {
+ if (mov->moov_written || mov->flags & FF_MOV_FLAG_EMPTY_MOOV) {
+ if (mov->frag_interleave && mov->fragments > 0) {
+ if (trk->entry - trk->entries_flushed >= mov->frag_interleave) {
+ if ((ret = mov_flush_fragment_interleaving(s, trk)) < 0)
+ return ret;
+ }
+ }
+
if (!trk->mdat_buf) {
if ((ret = avio_open_dyn_buf(&trk->mdat_buf)) < 0)
return ret;
if (trk->vos_len == 0 && enc->extradata_size > 0) {
trk->vos_len = enc->extradata_size;
trk->vos_data = av_malloc(trk->vos_len);
+ if (!trk->vos_data) {
+ ret = AVERROR(ENOMEM);
+ goto err;
+ }
memcpy(trk->vos_data, enc->extradata, trk->vos_len);
}
trk->cluster[trk->entry].entries = samples_in_chunk;
trk->cluster[trk->entry].dts = pkt->dts;
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 track_duration,
- * 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->track_duration;
+ if (!trk->frag_discont) {
+ /* First packet of a new fragment. We already wrote the duration
+ * of the last packet of the previous fragment based on track_duration,
+ * 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->track_duration;
+ /* We also may have written the pts and the corresponding duration
+ * in sidx/tfrf/tfxd tags; make sure the sidx pts and duration match up with
+ * the next fragment. This means the cts of the first sample must
+ * be the same in all fragments. */
+ if ((mov->flags & FF_MOV_FLAG_DASH && !(mov->flags & FF_MOV_FLAG_FASTSTART)) ||
+ mov->mode == MODE_ISM)
+ pkt->pts = pkt->dts + trk->end_pts - trk->cluster[trk->entry].dts;
+ } else {
+ /* New fragment, but discontinuous from previous fragments.
+ * Pretend the duration sum of the earlier fragments is
+ * pkt->dts - trk->start_dts. */
+ trk->frag_start = pkt->dts - trk->start_dts;
+ trk->end_pts = AV_NOPTS_VALUE;
+ trk->frag_discont = 0;
+ }
}
if (!trk->entry && trk->start_dts == AV_NOPTS_VALUE && !mov->use_editlist &&
s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO) {
}
if (trk->start_dts == AV_NOPTS_VALUE) {
trk->start_dts = pkt->dts;
- if (pkt->dts && mov->flags & FF_MOV_FLAG_EMPTY_MOOV)
+ if (trk->frag_discont) {
+ /* Pretend the whole stream started at dts=0, with earlier fragments
+ * already written, with a duration summing up to pkt->dts. */
+ trk->frag_start = pkt->dts;
+ trk->start_dts = 0;
+ trk->frag_discont = 0;
+ } else if (pkt->dts && mov->moov_written)
av_log(s, AV_LOG_WARNING,
- "Track %d starts with a nonzero dts %"PRId64". This "
- "currently isn't handled correctly in combination with "
- "empty_moov.\n", pkt->stream_index, pkt->dts);
+ "Track %d starts with a nonzero dts %"PRId64", while the moov "
+ "already has been written. Set the delay_moov flag to handle "
+ "this case.\n",
+ pkt->stream_index, pkt->dts);
}
trk->track_duration = pkt->dts - trk->start_dts + pkt->duration;
trk->flags |= MOV_TRACK_CTTS;
trk->cluster[trk->entry].cts = pkt->pts - pkt->dts;
trk->cluster[trk->entry].flags = 0;
+ if (trk->start_cts == AV_NOPTS_VALUE)
+ trk->start_cts = pkt->pts - pkt->dts;
+ if (trk->end_pts == AV_NOPTS_VALUE)
+ trk->end_pts = trk->cluster[trk->entry].dts +
+ trk->cluster[trk->entry].cts + pkt->duration;
+ else
+ trk->end_pts = FFMAX(trk->end_pts, trk->cluster[trk->entry].dts +
+ trk->cluster[trk->entry].cts +
+ pkt->duration);
+
if (enc->codec_id == AV_CODEC_ID_VC1) {
- mov_parse_vc1_frame(pkt, trk, mov->fragments);
+ mov_parse_vc1_frame(pkt, trk);
} else if (pkt->flags & AV_PKT_FLAG_KEY) {
if (mov->mode == MODE_MOV && enc->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
trk->entry > 0) { // force sync sample for the first key frame
if (!pkt->size)
return 0; /* Discard 0 sized packets */
+ if (mov->flags & FF_MOV_FLAG_FRAG_DISCONT) {
+ int i;
+ for (i = 0; i < s->nb_streams; i++)
+ mov->tracks[i].frag_discont = 1;
+ mov->flags &= ~FF_MOV_FLAG_FRAG_DISCONT;
+ }
+
if (trk->entry)
frag_duration = av_rescale_q(pkt->dts - trk->cluster[0].dts,
s->streams[pkt->stream_index]->time_base,
(mov->flags & FF_MOV_FLAG_FRAG_KEYFRAME &&
enc->codec_type == AVMEDIA_TYPE_VIDEO &&
trk->entry && pkt->flags & AV_PKT_FLAG_KEY)) {
- if (frag_duration >= mov->min_fragment_duration)
- mov_flush_fragment(s);
+ if (frag_duration >= mov->min_fragment_duration) {
+ // Set the duration of this track to line up with the next
+ // sample in this track. This avoids relying on AVPacket
+ // duration, but only helps for this particular track, not
+ // for the other ones that are flushed at the same time.
+ trk->track_duration = pkt->dts - trk->start_dts;
+ trk->end_pts = pkt->pts;
+ mov_auto_flush_fragment(s);
+ }
}
return ff_mov_write_packet(s, pkt);
AVIOContext *pb = s->pb;
MOVMuxContext *mov = s->priv_data;
AVDictionaryEntry *t;
- int i, hint_track = 0;
+ int i, ret, hint_track = 0;
mov->fc = s;
else if (!strcmp("f4v", s->oformat->name)) mov->mode = MODE_F4V;
}
+ if (mov->flags & FF_MOV_FLAG_DELAY_MOOV)
+ mov->flags |= FF_MOV_FLAG_EMPTY_MOOV;
+
/* Set the FRAGMENT flag if any of the fragmentation methods are
* enabled. */
if (mov->max_fragment_duration || mov->max_fragment_size ||
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) {
- av_log(s, AV_LOG_WARNING, "The faststart flag is incompatible "
- "with fragmentation, disabling faststart\n");
- mov->flags &= ~FF_MOV_FLAG_FASTSTART;
- }
- }
+ if (mov->flags & FF_MOV_FLAG_DASH)
+ mov->flags |= FF_MOV_FLAG_FRAGMENT | FF_MOV_FLAG_EMPTY_MOOV |
+ FF_MOV_FLAG_DEFAULT_BASE_MOOF;
if (mov->use_editlist < 0) {
mov->use_editlist = 1;
- if (mov->flags & FF_MOV_FLAG_FRAGMENT) {
+ if (mov->flags & FF_MOV_FLAG_FRAGMENT &&
+ !(mov->flags & FF_MOV_FLAG_DELAY_MOOV)) {
// If we can avoid needing an edit list by shifting the
// tracks, prefer that over (trying to) write edit lists
// in fragmented output.
mov->use_editlist = 0;
}
}
- if (mov->flags & FF_MOV_FLAG_EMPTY_MOOV && mov->use_editlist)
- av_log(s, AV_LOG_WARNING, "No meaningful edit list will be written when using empty_moov\n");
+ if (mov->flags & FF_MOV_FLAG_EMPTY_MOOV &&
+ !(mov->flags & FF_MOV_FLAG_DELAY_MOOV) && mov->use_editlist)
+ av_log(s, AV_LOG_WARNING, "No meaningful edit list will be written when using empty_moov without delay_moov\n");
if (!mov->use_editlist && s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_AUTO)
s->avoid_negative_ts = AVFMT_AVOID_NEG_TS_MAKE_ZERO;
+ /* Clear the omit_tfhd_offset flag if default_base_moof is set;
+ * if the latter is set that's enough and omit_tfhd_offset doesn't
+ * add anything extra on top of that. */
+ if (mov->flags & FF_MOV_FLAG_OMIT_TFHD_OFFSET &&
+ mov->flags & FF_MOV_FLAG_DEFAULT_BASE_MOOF)
+ mov->flags &= ~FF_MOV_FLAG_OMIT_TFHD_OFFSET;
+
+ if (mov->frag_interleave &&
+ mov->flags & (FF_MOV_FLAG_OMIT_TFHD_OFFSET | FF_MOV_FLAG_SEPARATE_MOOF)) {
+ av_log(s, AV_LOG_ERROR,
+ "Sample interleaving in fragments is mutually exclusive with "
+ "omit_tfhd_offset and separate_moof\n");
+ return AVERROR(EINVAL);
+ }
+
/* 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_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);
+ if (!(mov->flags & FF_MOV_FLAG_DELAY_MOOV)) {
+ if ((ret = mov_write_identification(pb, s)) < 0)
+ return ret;
}
mov->nb_streams = s->nb_streams;
* this is updated. */
track->hint_track = -1;
track->start_dts = AV_NOPTS_VALUE;
+ track->start_cts = AV_NOPTS_VALUE;
+ track->end_pts = 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') ||
else {
track->vos_len = st->codec->extradata_size;
track->vos_data = av_malloc(track->vos_len);
+ if (!track->vos_data)
+ goto error;
memcpy(track->vos_data, st->codec->extradata, track->vos_len);
}
}
if (mov->flags & FF_MOV_FLAG_ISML)
mov_write_isml_manifest(pb, mov);
- if (mov->flags & FF_MOV_FLAG_EMPTY_MOOV) {
+ if (mov->flags & FF_MOV_FLAG_EMPTY_MOOV &&
+ !(mov->flags & FF_MOV_FLAG_DELAY_MOOV)) {
mov_write_moov_tag(pb, mov, s);
- mov->fragments++;
+ mov->moov_written = 1;
+ if (mov->flags & FF_MOV_FLAG_FASTSTART)
+ mov->reserved_moov_pos = avio_tell(pb);
}
return 0;
return ffio_close_null_buf(moov_buf);
}
+static int get_sidx_size(AVFormatContext *s)
+{
+ int ret;
+ AVIOContext *buf;
+ MOVMuxContext *mov = s->priv_data;
+
+ if ((ret = ffio_open_null_buf(&buf)) < 0)
+ return ret;
+ mov_write_sidx_tags(buf, mov, -1, 0);
+ return ffio_close_null_buf(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
return moov_size2;
}
+static int compute_sidx_size(AVFormatContext *s)
+{
+ int i, sidx_size;
+ MOVMuxContext *mov = s->priv_data;
+
+ sidx_size = get_sidx_size(s);
+ if (sidx_size < 0)
+ return sidx_size;
+
+ for (i = 0; i < mov->nb_streams; i++)
+ mov->tracks[i].data_offset += sidx_size;
+
+ return sidx_size;
+}
+
static int shift_data(AVFormatContext *s)
{
int ret = 0, moov_size;
int read_size[2];
AVIOContext *read_pb;
- moov_size = compute_moov_size(s);
+ if (mov->flags & FF_MOV_FLAG_FRAGMENT)
+ moov_size = compute_sidx_size(s);
+ else
+ moov_size = compute_moov_size(s);
if (moov_size < 0)
return moov_size;
mov_write_moov_tag(pb, mov, s);
}
} else {
- mov_flush_fragment(s);
- mov_write_mfra_tag(pb, mov);
- }
-
- for (i = 0; i < mov->nb_streams; i++) {
- if (mov->flags & FF_MOV_FLAG_FRAGMENT &&
- mov->tracks[i].vc1_info.struct_offset && s->pb->seekable) {
- int64_t off = avio_tell(pb);
- uint8_t buf[7];
- if (mov_write_dvc1_structs(&mov->tracks[i], buf) >= 0) {
- avio_seek(pb, mov->tracks[i].vc1_info.struct_offset, SEEK_SET);
- avio_write(pb, buf, 7);
- avio_seek(pb, off, SEEK_SET);
+ mov_auto_flush_fragment(s);
+ for (i = 0; i < mov->nb_streams; i++)
+ mov->tracks[i].data_offset = 0;
+ if (mov->flags & FF_MOV_FLAG_FASTSTART) {
+ av_log(s, AV_LOG_INFO, "Starting second pass: inserting sidx atoms\n");
+ res = shift_data(s);
+ if (res == 0) {
+ int64_t end = avio_tell(pb);
+ avio_seek(pb, mov->reserved_moov_pos, SEEK_SET);
+ mov_write_sidx_tags(pb, mov, -1, 0);
+ avio_seek(pb, end, SEEK_SET);
+ mov_write_mfra_tag(pb, mov);
}
+ } else {
+ mov_write_mfra_tag(pb, mov);
}
}
projects / ffmpeg / blobdiff