{ "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" },
+ { "cmaf", "Write CMAF compatible fragmented MP4", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_CMAF}, 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" },
{ "global_sidx", "Write a global sidx index at the start of the file", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_GLOBAL_SIDX}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
{ "skip_sidx", "Skip writing of sidx atom", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_SKIP_SIDX}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
{ "write_colr", "Write colr atom (Experimental, may be renamed or changed, do not use from scripts)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_WRITE_COLR}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
+ { "prefer_icc", "If writing colr atom prioritise usage of ICC profile if it exists in stream packet side data", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_PREFER_ICC}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
{ "write_gama", "Write deprecated gama atom", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_WRITE_GAMA}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
{ "use_metadata_tags", "Use mdta atom for metadata.", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_USE_MDTA}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
{ "skip_trailer", "Skip writing the mfra/tfra/mfro trailer for fragmented files", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_SKIP_TRAILER}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
return 0;
}
-static int mov_write_colr_tag(AVIOContext *pb, MOVTrack *track)
+static int mov_write_colr_tag(AVIOContext *pb, MOVTrack *track, int prefer_icc)
{
int64_t pos = avio_tell(pb);
// Ref (MOV): https://developer.apple.com/library/mac/technotes/tn2162/_index.html#//apple_ref/doc/uid/DTS40013070-CH1-TNTAG9
// Ref (MP4): ISO/IEC 14496-12:2012
+ const uint8_t *icc_profile;
+ int icc_profile_size;
+
+ if (prefer_icc) {
+ icc_profile = av_stream_get_side_data(track->st, AV_PKT_DATA_ICC_PROFILE, &icc_profile_size);
+
+ if (icc_profile) {
+ avio_wb32(pb, 12 + icc_profile_size);
+ ffio_wfourcc(pb, "colr");
+ ffio_wfourcc(pb, "prof");
+ avio_write(pb, icc_profile, icc_profile_size);
+ return 12 + icc_profile_size;
+ }
+ else {
+ av_log(NULL, AV_LOG_INFO, "no ICC profile found, will write nclx/nclc colour info instead\n");
+ }
+ }
+
if (track->par->color_primaries == AVCOL_PRI_UNSPECIFIED &&
track->par->color_trc == AVCOL_TRC_UNSPECIFIED &&
track->par->color_space == AVCOL_SPC_UNSPECIFIED) {
}
if (mov->flags & FF_MOV_FLAG_WRITE_COLR) {
if (track->mode == MODE_MOV || track->mode == MODE_MP4)
- mov_write_colr_tag(pb, track);
+ mov_write_colr_tag(pb, track, mov->flags & FF_MOV_FLAG_PREFER_ICC);
else
av_log(mov->fc, AV_LOG_WARNING, "Not writing 'colr' atom. Format is not MOV or MP4.\n");
}
return update_size(pb, pos);
}
+static int64_t calc_pts_duration(MOVMuxContext *mov, MOVTrack *track)
+{
+ if (track->tag == MKTAG('t','m','c','d')) {
+ // tmcd tracks gets track_duration set in mov_write_moov_tag from
+ // another track's duration, while the end_pts may be left at zero.
+ // Calculate the pts duration for that track instead.
+ return av_rescale(calc_pts_duration(mov, &mov->tracks[track->src_track]),
+ track->timescale, mov->tracks[track->src_track].timescale);
+ }
+ if (track->end_pts != AV_NOPTS_VALUE &&
+ track->start_dts != AV_NOPTS_VALUE &&
+ track->start_cts != AV_NOPTS_VALUE) {
+ return track->end_pts - (track->start_dts + track->start_cts);
+ }
+ return track->track_duration;
+}
+
static int mov_write_mdhd_tag(AVIOContext *pb, MOVMuxContext *mov,
MOVTrack *track)
{
- int version = track->track_duration < INT32_MAX ? 0 : 1;
+ int64_t duration = calc_pts_duration(mov, track);
+ int version = duration < INT32_MAX ? 0 : 1;
if (track->mode == MODE_ISM)
version = 1;
else if (!track->entry)
(version == 1) ? avio_wb64(pb, 0) : avio_wb32(pb, 0);
else
- (version == 1) ? avio_wb64(pb, track->track_duration) : avio_wb32(pb, track->track_duration); /* duration */
+ (version == 1) ? avio_wb64(pb, duration) : avio_wb32(pb, duration); /* duration */
avio_wb16(pb, track->language); /* language */
avio_wb16(pb, 0); /* reserved (quality) */
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);
+ int64_t duration = av_rescale_rnd(calc_pts_duration(mov, track),
+ MOV_TIMESCALE, track->timescale,
+ AV_ROUND_UP);
int version = duration < INT32_MAX ? 0 : 1;
int flags = MOV_TKHD_FLAG_IN_MOVIE;
int rotation = 0;
static int mov_write_edts_tag(AVIOContext *pb, MOVMuxContext *mov,
MOVTrack *track)
{
- int64_t duration = av_rescale_rnd(track->track_duration, MOV_TIMESCALE,
- track->timescale, AV_ROUND_UP);
+ int64_t duration = av_rescale_rnd(calc_pts_duration(mov, track),
+ MOV_TIMESCALE, track->timescale,
+ AV_ROUND_UP);
int version = duration < INT32_MAX ? 0 : 1;
int entry_size, entry_count, size;
int64_t delay, start_ct = track->start_cts;
for (i = 0; i < mov->nb_streams; i++) {
if (mov->tracks[i].entry > 0 && mov->tracks[i].timescale) {
- int64_t max_track_len_temp = av_rescale_rnd(mov->tracks[i].track_duration,
+ int64_t max_track_len_temp = av_rescale_rnd(
+ calc_pts_duration(mov, &mov->tracks[i]),
MOV_TIMESCALE,
mov->tracks[i].timescale,
AV_ROUND_UP);
flags &= ~MOV_TFHD_BASE_DATA_OFFSET;
flags |= MOV_TFHD_DEFAULT_BASE_IS_MOOF;
}
+ /* CMAF requires all values to be explicit in tfhd atoms */
+ if (mov->flags & FF_MOV_FLAG_CMAF)
+ flags |= MOV_TFHD_STSD_ID;
/* Don't set a default sample size, the silverlight player refuses
* to play files with that set. Don't set a default sample duration,
* file format says it MUST NOT be set. */
if (track->mode == MODE_ISM)
flags &= ~(MOV_TFHD_DEFAULT_SIZE | MOV_TFHD_DEFAULT_DURATION |
- MOV_TFHD_BASE_DATA_OFFSET);
+ MOV_TFHD_BASE_DATA_OFFSET | MOV_TFHD_STSD_ID);
avio_wb32(pb, 0); /* size placeholder */
ffio_wfourcc(pb, "tfhd");
avio_wb32(pb, track->track_id); /* track-id */
if (flags & MOV_TFHD_BASE_DATA_OFFSET)
avio_wb64(pb, moof_offset);
+ if (flags & MOV_TFHD_STSD_ID) {
+ avio_wb32(pb, 1);
+ }
if (flags & MOV_TFHD_DEFAULT_DURATION) {
track->default_duration = get_cluster_duration(track, 0);
avio_wb32(pb, track->default_duration);
{
int64_t pos = avio_tell(pb), pts_us, ntp_ts;
MOVTrack *first_track;
+ int flags = 24;
/* PRFT should be associated with at most one track. So, choosing only the
* first track. */
}
if (mov->write_prft == MOV_PRFT_SRC_WALLCLOCK) {
- ntp_ts = ff_get_formatted_ntp_time(ff_ntp_time());
+ if (first_track->cluster[0].prft.wallclock) {
+ /* Round the NTP time to whole milliseconds. */
+ ntp_ts = ff_get_formatted_ntp_time((first_track->cluster[0].prft.wallclock / 1000) * 1000 +
+ NTP_OFFSET_US);
+ flags = first_track->cluster[0].prft.flags;
+ } else
+ ntp_ts = ff_get_formatted_ntp_time(ff_ntp_time());
} else if (mov->write_prft == MOV_PRFT_SRC_PTS) {
pts_us = av_rescale_q(first_track->cluster[0].pts,
first_track->st->time_base, AV_TIME_BASE_Q);
avio_wb32(pb, 0); // Size place holder
ffio_wfourcc(pb, "prft"); // Type
avio_w8(pb, 1); // Version
- avio_wb24(pb, 0); // Flags
+ avio_wb24(pb, flags); // Flags
avio_wb32(pb, first_track->track_id); // reference track ID
avio_wb64(pb, ntp_ts); // NTP time stamp
avio_wb64(pb, first_track->cluster[0].pts); //media time
// brand, if not already the major brand. This is compatible with users that
// don't understand tfdt.
if (mov->mode == MODE_MP4) {
+ if (mov->flags & FF_MOV_FLAG_CMAF)
+ ffio_wfourcc(pb, "cmfc");
if (mov->flags & FF_MOV_FLAG_FRAGMENT && !(mov->flags & FF_MOV_FLAG_NEGATIVE_CTS_OFFSETS))
ffio_wfourcc(pb, "iso6");
} else {
AVIOContext *pb = s->pb;
MOVTrack *trk = &mov->tracks[pkt->stream_index];
AVCodecParameters *par = trk->par;
+ AVProducerReferenceTime *prft;
unsigned int samples_in_chunk = 0;
- int size = pkt->size, ret = 0;
+ int size = pkt->size, ret = 0, offset = 0;
+ int prft_size;
uint8_t *reformatted_data = NULL;
ret = check_pkt(s, pkt);
/* from x264 or from bytestream H.264 */
/* NAL reformatting needed */
if (trk->hint_track >= 0 && trk->hint_track < mov->nb_streams) {
- ff_avc_parse_nal_units_buf(pkt->data, &reformatted_data,
- &size);
+ ret = ff_avc_parse_nal_units_buf(pkt->data, &reformatted_data,
+ &size);
+ if (ret < 0)
+ return ret;
avio_write(pb, reformatted_data, size);
} else {
if (trk->cenc.aes_ctr) {
(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);
+ ret = ff_hevc_annexb2mp4_buf(pkt->data, &reformatted_data,
+ &size, 0, NULL);
+ if (ret < 0)
+ return ret;
avio_write(pb, reformatted_data, size);
} else {
size = ff_hevc_annexb2mp4(pb, pkt->data, pkt->size, 0, NULL);
}
} else if (par->codec_id == AV_CODEC_ID_AV1) {
if (trk->hint_track >= 0 && trk->hint_track < mov->nb_streams) {
- ff_av1_filter_obus_buf(pkt->data, &reformatted_data, &size);
+ ret = ff_av1_filter_obus_buf(pkt->data, &reformatted_data,
+ &size, &offset);
+ if (ret < 0)
+ return ret;
avio_write(pb, reformatted_data, size);
} else {
size = ff_av1_filter_obus(pb, pkt->data, pkt->size);
}
if (trk->entry >= trk->cluster_capacity) {
- unsigned new_capacity = 2 * (trk->entry + MOV_INDEX_CLUSTER_SIZE);
+ unsigned new_capacity = trk->entry + MOV_INDEX_CLUSTER_SIZE;
if (av_reallocp_array(&trk->cluster, new_capacity,
sizeof(*trk->cluster))) {
ret = AVERROR(ENOMEM);
trk->cluster[trk->entry].flags |= MOV_DISPOSABLE_SAMPLE;
trk->has_disposable++;
}
+
+ prft = (AVProducerReferenceTime *)av_packet_get_side_data(pkt, AV_PKT_DATA_PRFT, &prft_size);
+ if (prft && prft_size == sizeof(AVProducerReferenceTime))
+ memcpy(&trk->cluster[trk->entry].prft, prft, prft_size);
+ else
+ memset(&trk->cluster[trk->entry].prft, 0, sizeof(AVProducerReferenceTime));
+
trk->entry++;
trk->sample_count += samples_in_chunk;
mov->mdat_size += size;
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);
+ reformatted_data ? reformatted_data + offset
+ : NULL, size);
end:
err:
- av_free(reformatted_data);
+ if (pkt->data != reformatted_data)
+ av_free(reformatted_data);
return ret;
}
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->flags & FF_MOV_FLAG_CMAF)
+ mov->flags |= FF_MOV_FLAG_FRAGMENT | FF_MOV_FLAG_EMPTY_MOOV |
+ FF_MOV_FLAG_DEFAULT_BASE_MOOF | FF_MOV_FLAG_NEGATIVE_CTS_OFFSETS;
if (mov->flags & FF_MOV_FLAG_EMPTY_MOOV && s->flags & AVFMT_FLAG_AUTO_BSF) {
av_log(s, AV_LOG_VERBOSE, "Empty MOOV enabled; disabling automatic bitstream filtering\n");
s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO)
mov->use_editlist = 0;
}
+ if (mov->flags & FF_MOV_FLAG_CMAF) {
+ // CMAF Track requires negative cts offsets without edit lists
+ mov->use_editlist = 0;
+ }
}
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)
+ if (mov->flags & FF_MOV_FLAG_CMAF && mov->use_editlist) {
+ av_log(s, AV_LOG_WARNING, "Edit list enabled; Assuming writing CMAF Track File\n");
+ mov->flags &= ~FF_MOV_FLAG_NEGATIVE_CTS_OFFSETS;
+ }
+ if (!mov->use_editlist && s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_AUTO &&
+ !(mov->flags & FF_MOV_FLAG_NEGATIVE_CTS_OFFSETS))
s->avoid_negative_ts = AVFMT_AVOID_NEG_TS_MAKE_ZERO;
/* Clear the omit_tfhd_offset flag if default_base_moof is set;
}
if (mov->video_track_timescale) {
track->timescale = mov->video_track_timescale;
+ if (mov->mode == MODE_ISM && mov->video_track_timescale != 10000000)
+ av_log(s, AV_LOG_WARNING, "Warning: some tools, like mp4split, assume a timescale of 10000000 for ISMV.\n");
} else {
track->timescale = st->time_base.den;
while(track->timescale < 10000)
av_log(s, AV_LOG_ERROR, "%s only supported in MP4.\n", avcodec_get_name(track->par->codec_id));
return AVERROR(EINVAL);
}
- if (s->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
+ if (track->par->codec_id != AV_CODEC_ID_OPUS &&
+ s->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
av_log(s, AV_LOG_ERROR,
"%s in MP4 support is experimental, add "
"'-strict %d' if you want to use it.\n",
}
if (!track->height)
track->height = st->codecpar->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;
+ /* The Protected Interoperable File Format (PIFF) standard, used by ISMV recommends but
+ doesn't mandate a track timescale of 10,000,000. The muxer allows a custom timescale
+ for video tracks, so if user-set, it isn't overwritten */
+ if (mov->mode == MODE_ISM &&
+ (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO ||
+ (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && !mov->video_track_timescale))) {
+ track->timescale = 10000000;
+ }
avpriv_set_pts_info(st, 64, 1, track->timescale);
{
int ret = 0, moov_size;
MOVMuxContext *mov = s->priv_data;
- int64_t pos, pos_end = avio_tell(s->pb);
+ int64_t pos, pos_end;
uint8_t *buf, *read_buf[2];
int read_buf_id = 0;
int read_size[2];
projects / ffmpeg / blobdiff