#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 },
};
return 0;
}
+static int is_cover_image(const AVStream *st)
+{
+ /* Eg. AV_DISPOSITION_ATTACHED_PIC | AV_DISPOSITION_TIMED_THUMBNAILS
+ * is encoded as sparse video track */
+ return st && st->disposition == AV_DISPOSITION_ATTACHED_PIC;
+}
+
static int rtp_hinting_needed(const AVStream *st)
{
/* Add hint tracks for each real audio and video stream */
- if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
+ if (is_cover_image(st))
return 0;
return st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
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);
return tag;
}
-static int mov_get_codec_tag(AVFormatContext *s, MOVTrack *track)
+static unsigned int mov_get_codec_tag(AVFormatContext *s, MOVTrack *track)
{
- int tag = track->par->codec_tag;
+ unsigned int tag = track->par->codec_tag;
if (!tag || (s->strict_std_compliance >= FF_COMPLIANCE_NORMAL &&
(track->par->codec_id == AV_CODEC_ID_DVVIDEO ||
return tag;
}
-static int mov_find_codec_tag(AVFormatContext *s, MOVTrack *track)
+static const AVCodecTag codec_cover_image_tags[] = {
+ { AV_CODEC_ID_MJPEG, 0xD },
+ { AV_CODEC_ID_PNG, 0xE },
+ { AV_CODEC_ID_BMP, 0x1B },
+ { AV_CODEC_ID_NONE, 0 },
+};
+
+static unsigned int validate_codec_tag(const AVCodecTag *const *tags,
+ unsigned int tag, int codec_id)
{
- int tag;
+ int i;
- if (track->mode == MODE_MP4 || track->mode == MODE_PSP)
- tag = track->par->codec_tag;
- else if (track->mode == MODE_ISM)
- tag = track->par->codec_tag;
- else if (track->mode == MODE_IPOD) {
+ /**
+ * Check that tag + id is in the table
+ */
+ for (i = 0; tags && tags[i]; i++) {
+ const AVCodecTag *codec_tags = tags[i];
+ while (codec_tags->id != AV_CODEC_ID_NONE) {
+ if (avpriv_toupper4(codec_tags->tag) == avpriv_toupper4(tag) &&
+ codec_tags->id == codec_id)
+ return codec_tags->tag;
+ codec_tags++;
+ }
+ }
+ return 0;
+}
+
+static unsigned int mov_find_codec_tag(AVFormatContext *s, MOVTrack *track)
+{
+ unsigned int tag;
+
+ if (is_cover_image(track->st))
+ return ff_codec_get_tag(codec_cover_image_tags, track->par->codec_id);
+
+ if (track->mode == MODE_IPOD)
if (!av_match_ext(s->url, "m4a") &&
!av_match_ext(s->url, "m4v") &&
!av_match_ext(s->url, "m4b"))
av_log(s, AV_LOG_WARNING, "Warning, extension is not .m4a nor .m4v "
"Quicktime/Ipod might not play the file\n");
- tag = track->par->codec_tag;
- } else if (track->mode & MODE_3GP)
- tag = track->par->codec_tag;
- else if (track->mode == MODE_F4V)
- tag = track->par->codec_tag;
- else
- tag = mov_get_codec_tag(s, track);
+ if (track->mode == MODE_MOV)
+ tag = mov_get_codec_tag(s, track);
+ else
+ tag = validate_codec_tag(s->oformat->codec_tag, track->par->codec_tag,
+ track->par->codec_id);
return tag;
}
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)
{
MOVMuxContext *mov = s->priv_data;
int64_t pos = 0;
- int i, type;
+ int i;
for (i = 0; i < s->nb_streams; i++) {
MOVTrack *trk = &mov->tracks[i];
- AVStream *st = s->streams[i];
- if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC) ||
- trk->cover_image.size <= 0)
- continue;
-
- switch (st->codecpar->codec_id) {
- case AV_CODEC_ID_MJPEG:
- type = 0xD;
- break;
- case AV_CODEC_ID_PNG:
- type = 0xE;
- break;
- case AV_CODEC_ID_BMP:
- type = 0x1B;
- break;
- default:
- av_log(s, AV_LOG_ERROR, "unsupported codec_id (0x%x) for cover",
- st->codecpar->codec_id);
+ if (!is_cover_image(trk->st) || trk->cover_image.size <= 0)
continue;
- }
if (!pos) {
pos = avio_tell(pb);
}
avio_wb32(pb, 16 + trk->cover_image.size);
ffio_wfourcc(pb, "data");
- avio_wb32(pb, type);
+ avio_wb32(pb, trk->tag);
avio_wb32(pb , 0);
avio_write(pb, trk->cover_image.data, trk->cover_image.size);
}
AVStream *st = track->st;
AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL,0);
- if (track->par->codec_type == AVMEDIA_TYPE_VIDEO) {
+ if (track->par->codec_type == AVMEDIA_TYPE_VIDEO && !is_cover_image(st)) {
type = "video";
} else if (track->par->codec_type == AVMEDIA_TYPE_AUDIO) {
type = "audio";
} else {
continue;
}
- if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
- continue;
props = (AVCPBProperties*)av_stream_get_side_data(track->st, AV_PKT_DATA_CPB_PROPERTIES, NULL);
for (i = 0; i < s->nb_streams; i++) {
AVStream *st = s->streams[i];
- if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
+ if (is_cover_image(st))
continue;
if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
has_video = 1;
int video_streams_nb = 0, audio_streams_nb = 0, other_streams_nb = 0;
for (i = 0; i < s->nb_streams; i++) {
AVStream *st = s->streams[i];
- if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
+ if (is_cover_image(st))
continue;
if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
video_streams_nb++;
int buf_size, moov_size;
for (i = 0; i < mov->nb_streams; i++)
- if (!mov->tracks[i].entry &&
- (i >= s->nb_streams || !(s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC)))
+ if (!mov->tracks[i].entry && !is_cover_image(mov->tracks[i].st))
break;
/* Don't write the initial moov unless all tracks have data */
if (i < mov->nb_streams && !force)
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);
{
MOVMuxContext *mov = s->priv_data;
MOVTrack *trk;
- AVStream *st;
if (!pkt) {
mov_flush_fragment(s, 1);
return 1;
}
- st = s->streams[pkt->stream_index];
trk = &mov->tracks[pkt->stream_index];
- if (st->disposition & AV_DISPOSITION_ATTACHED_PIC) {
+ if (is_cover_image(trk->st)) {
int ret;
- if (st->nb_frames >= 1) {
- if (st->nb_frames == 1)
+ if (trk->st->nb_frames >= 1) {
+ if (trk->st->nb_frames == 1)
av_log(s, AV_LOG_WARNING, "Got more than one picture in stream %d,"
" ignoring.\n", pkt->stream_index);
return 0;
if (st->codecpar->codec_type <= AVMEDIA_TYPE_UNKNOWN ||
st->codecpar->codec_type >= AVMEDIA_TYPE_NB ||
- st->disposition & AV_DISPOSITION_ATTACHED_PIC)
+ is_cover_image(st))
continue;
if (first[st->codecpar->codec_type] < 0)
/* 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;
} 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') },
{ AV_CODEC_ID_EVRC , MKTAG('m', 'p', '4', 'a') },
{ AV_CODEC_ID_DVD_SUBTITLE, MKTAG('m', 'p', '4', 's') },
{ AV_CODEC_ID_MOV_TEXT , MKTAG('t', 'x', '3', 'g') },
+ { AV_CODEC_ID_BIN_DATA , MKTAG('g', 'p', 'm', 'd') },
{ AV_CODEC_ID_NONE , 0 },
};
projects / ffmpeg / blobdiff