#include "riff.h"
#include "avio.h"
#include "isom.h"
+#include "av1.h"
#include "avc.h"
#include "libavcodec/ac3_parser_internal.h"
#include "libavcodec/dnxhddata.h"
{ "write_prft", "Write producer reference time box with specified time source", offsetof(MOVMuxContext, write_prft), AV_OPT_TYPE_INT, {.i64 = MOV_PRFT_NONE}, 0, MOV_PRFT_NB-1, AV_OPT_FLAG_ENCODING_PARAM, "prft"},
{ "wallclock", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = MOV_PRFT_SRC_WALLCLOCK}, 0, 0, AV_OPT_FLAG_ENCODING_PARAM, "prft"},
{ "pts", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = MOV_PRFT_SRC_PTS}, 0, 0, AV_OPT_FLAG_ENCODING_PARAM, "prft"},
+ { "empty_hdlr_name", "write zero-length name string in hdlr atoms within mdia and minf atoms", offsetof(MOVMuxContext, empty_hdlr_name), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
{ NULL },
};
if (avpriv_ac3_parse_header(&hdr, pkt->data, pkt->size) < 0) {
/* drop the packets until we see a good one */
if (!track->entry) {
- av_log(mov, AV_LOG_WARNING, "Dropping invalid packet from start of the stream\n");
+ av_log(mov->fc, AV_LOG_WARNING, "Dropping invalid packet from start of the stream\n");
ret = 0;
} else
ret = AVERROR_INVALIDDATA;
if (hdr->substreamid == info->num_ind_sub + 1) {
//info->num_ind_sub++;
- avpriv_request_sample(track->par, "Multiple independent substreams");
+ avpriv_request_sample(mov->fc, "Multiple independent substreams");
ret = AVERROR_PATCHWELCOME;
goto end;
} else if (hdr->substreamid < info->num_ind_sub ||
info->ec3_done = 1;
goto concatenate;
}
+ } else {
+ if (hdr->substreamid != 0) {
+ avpriv_request_sample(mov->fc, "Multiple non EAC3 independent substreams");
+ ret = AVERROR_PATCHWELCOME;
+ goto end;
+ }
}
/* fill the info needed for the "dec3" atom */
uint32_t tag = track->tag;
if (track->mode == MODE_MOV) {
- if (track->timescale > UINT16_MAX) {
+ if (track->timescale > UINT16_MAX || !track->par->channels) {
if (mov_get_lpcm_flags(track->par->codec_id))
tag = AV_RL32("lpcm");
version = 2;
return 0xf;
}
+static int mov_write_av1c_tag(AVIOContext *pb, MOVTrack *track)
+{
+ int64_t pos = avio_tell(pb);
+
+ avio_wb32(pb, 0);
+ ffio_wfourcc(pb, "av1C");
+ ff_isom_write_av1c(pb, track->vos_data, track->vos_len);
+ return update_size(pb, pos);
+}
+
static int mov_write_avcc_tag(AVIOContext *pb, MOVTrack *track)
{
int64_t pos = avio_tell(pb);
mov_write_uuid_tag_ipod(pb);
} else if (track->par->codec_id == AV_CODEC_ID_VP9) {
mov_write_vpcc_tag(mov->fc, pb, track);
+ } else if (track->par->codec_id == AV_CODEC_ID_AV1) {
+ mov_write_av1c_tag(pb, track);
} else if (track->par->codec_id == AV_CODEC_ID_VC1 && track->vos_len > 0)
mov_write_dvc1_tag(pb, track);
else if (track->par->codec_id == AV_CODEC_ID_VP6F ||
decoded. */
if (roll_samples_remaining > 0)
distance = 0;
- /* Verify distance is a minimum of 2 (60ms) packets and a maximum of
- 32 (2.5ms) packets. */
- av_assert0(distance == 0 || (distance >= 2 && distance <= 32));
+ /* Verify distance is a maximum of 32 (2.5ms) packets. */
+ if (distance > 32)
+ return AVERROR_INVALIDDATA;
if (i && distance == sgpd_entries[entries].roll_distance) {
sgpd_entries[entries].count++;
} else {
static int mov_write_hdlr_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
{
+ MOVMuxContext *mov = s->priv_data;
const char *hdlr, *descr = NULL, *hdlr_type = NULL;
int64_t pos = avio_tell(pb);
// 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);
+ t = av_dict_get(track->st->metadata, "handler_name", NULL, 0);
if (t && utf8len(t->value))
descr = t->value;
}
}
+ if (mov->empty_hdlr_name) /* expressly allowed by QTFF and not prohibited in ISO 14496-12 8.4.3.3 */
+ descr = "";
+
avio_wb32(pb, 0); /* size */
ffio_wfourcc(pb, "hdlr");
avio_wb32(pb, 0); /* Version & flags */
} else if (track->tag == MKTAG('g','p','m','d')) {
mov_write_gmhd_tag(pb, track);
}
- if (track->mode == MODE_MOV) /* FIXME: Why do it for MODE_MOV only ? */
+ if (track->mode == MODE_MOV) /* ISO 14496-12 8.4.3.1 specifies hdlr only within mdia or meta boxes */
mov_write_hdlr_tag(s, pb, NULL);
mov_write_dinf_tag(pb);
if ((ret = mov_write_stbl_tag(s, pb, mov, track)) < 0)
else
samples_in_chunk = 1;
+ if (samples_in_chunk < 1) {
+ av_log(s, AV_LOG_ERROR, "fatal error, input packet contains no samples\n");
+ return AVERROR_PATCHWELCOME;
+ }
+
/* copy extradata if it exists */
if (trk->vos_len == 0 && par->extradata_size > 0 &&
!TAG_IS_AVCI(trk->tag) &&
} 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);
+ avio_write(pb, reformatted_data, size);
+ } else {
+ size = ff_av1_filter_obus(pb, pkt->data, pkt->size);
+ }
#if CONFIG_AC3_PARSER
} else if (par->codec_id == AV_CODEC_ID_EAC3) {
size = handle_eac3(mov, pkt, trk);
if (trk->par->codec_id == AV_CODEC_ID_MP4ALS ||
trk->par->codec_id == AV_CODEC_ID_AAC ||
+ trk->par->codec_id == AV_CODEC_ID_AV1 ||
trk->par->codec_id == AV_CODEC_ID_FLAC) {
int side_size = 0;
uint8_t *side = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);
/* 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;
+ FF_MOV_FLAG_FRAGMENT | FF_MOV_FLAG_NEGATIVE_CTS_OFFSETS;
if (mov->flags & FF_MOV_FLAG_DASH)
mov->flags |= FF_MOV_FLAG_FRAGMENT | FF_MOV_FLAG_EMPTY_MOOV |
FF_MOV_FLAG_DEFAULT_BASE_MOOF;
pix_fmt == AV_PIX_FMT_MONOWHITE ||
pix_fmt == AV_PIX_FMT_MONOBLACK;
}
- if (track->par->codec_id == AV_CODEC_ID_VP9) {
+ if (track->par->codec_id == AV_CODEC_ID_VP9 ||
+ track->par->codec_id == AV_CODEC_ID_AV1) {
if (track->mode != MODE_MP4) {
- av_log(s, AV_LOG_ERROR, "VP9 only supported in MP4.\n");
+ av_log(s, AV_LOG_ERROR, "%s only supported in MP4.\n", avcodec_get_name(track->par->codec_id));
return AVERROR(EINVAL);
}
- } else if (track->par->codec_id == AV_CODEC_ID_AV1) {
- /* spec is not finished, so forbid for now */
- av_log(s, AV_LOG_ERROR, "AV1 muxing is currently not supported.\n");
- return AVERROR_PATCHWELCOME;
+ if (track->par->codec_id == AV_CODEC_ID_AV1 &&
+ s->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
+ av_log(s, AV_LOG_ERROR,
+ "av1 in MP4 support is experimental, add "
+ "'-strict %d' if you want to use it.\n",
+ FF_COMPLIANCE_EXPERIMENTAL);
+ return AVERROR_EXPERIMENTAL;
+ }
} else if (track->par->codec_id == AV_CODEC_ID_VP8) {
/* altref frames handling is not defined in the spec as of version v1.0,
* so just forbid muxing VP8 streams altogether until a new version does */
{ AV_CODEC_ID_DIRAC , MKTAG('d', 'r', 'a', 'c') },
{ AV_CODEC_ID_TSCC2 , MKTAG('m', 'p', '4', 'v') },
{ AV_CODEC_ID_VP9 , MKTAG('v', 'p', '0', '9') },
+ { AV_CODEC_ID_AV1 , MKTAG('a', 'v', '0', '1') },
{ AV_CODEC_ID_AAC , MKTAG('m', 'p', '4', 'a') },
{ AV_CODEC_ID_MP4ALS , MKTAG('m', 'p', '4', 'a') },
{ AV_CODEC_ID_MP3 , MKTAG('m', 'p', '4', 'a') },