if (!key)
return 0;
if (atom.size < 0)
- return -1;
+ return AVERROR_INVALIDDATA;
str_size = FFMIN3(sizeof(str)-1, str_size, atom.size);
avio_rb32(pb); // version + flags
entries = avio_rb32(pb);
if (entries >= UINT_MAX / sizeof(*sc->drefs))
- return -1;
+ return AVERROR_INVALIDDATA;
sc->drefs = av_mallocz(entries * sizeof(*sc->drefs));
if (!sc->drefs)
return AVERROR(ENOMEM);
int64_t next = avio_tell(pb) + size - 4;
if (size < 12)
- return -1;
+ return AVERROR_INVALIDDATA;
dref->type = avio_rl32(pb);
avio_rb32(pb); // version + flags
comp_brand_size = atom.size - 8;
if (comp_brand_size < 0)
- return -1;
+ return AVERROR_INVALIDDATA;
comp_brands_str = av_malloc(comp_brand_size + 1); /* Add null terminator */
if (!comp_brands_str)
return AVERROR(ENOMEM);
/* this atom should contain all header atoms */
static int mov_read_moov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
- if (mov_read_default(c, pb, atom) < 0)
- return -1;
+ int ret;
+
+ if ((ret = mov_read_default(c, pb, atom)) < 0)
+ return ret;
/* we parsed the 'moov' atom, we can terminate the parsing as soon as we find the 'mdat' */
/* so we don't parse the whole file if over a network */
c->found_moov=1;
sc = st->priv_data;
version = avio_r8(pb);
- if (version > 1)
- return -1; /* unsupported */
-
+ if (version > 1) {
+ av_log_ask_for_sample(c, "unsupported version %d\n", version);
+ return AVERROR_PATCHWELCOME;
+ }
avio_rb24(pb); /* flags */
if (version == 1) {
creation_time = avio_rb64(pb);
st = c->fc->streams[c->fc->nb_streams-1];
if ((uint64_t)atom.size > (1<<30))
- return -1;
+ return AVERROR_INVALIDDATA;
// currently SVQ3 decoder expect full STSD header - so let's fake it
// this should be fixed and just SMI header should be passed
size= (uint64_t)st->codec->extradata_size + atom.size + 8 + FF_INPUT_BUFFER_PADDING_SIZE;
if (size > INT_MAX || (uint64_t)atom.size > INT_MAX)
- return -1;
+ return AVERROR_INVALIDDATA;
buf= av_realloc(st->codec->extradata, size);
if (!buf)
- return -1;
+ return AVERROR(ENOMEM);
st->codec->extradata= buf;
buf+= st->codec->extradata_size;
st->codec->extradata_size= size - FF_INPUT_BUFFER_PADDING_SIZE;
st = c->fc->streams[c->fc->nb_streams-1];
if ((uint64_t)atom.size > (1<<30))
- return -1;
+ return AVERROR_INVALIDDATA;
if (st->codec->codec_id == CODEC_ID_QDM2 || st->codec->codec_id == CODEC_ID_QDMC) {
// pass all frma atom to codec, needed at least for QDMC and QDM2
st->codec->extradata_size = atom.size;
avio_read(pb, st->codec->extradata, atom.size);
} else if (atom.size > 8) { /* to read frma, esds atoms */
- if (mov_read_default(c, pb, atom) < 0)
- return -1;
+ int ret;
+ if ((ret = mov_read_default(c, pb, atom)) < 0)
+ return ret;
} else
avio_skip(pb, atom.size);
return 0;
st = c->fc->streams[c->fc->nb_streams-1];
if ((uint64_t)atom.size > (1<<30))
- return -1;
+ return AVERROR_INVALIDDATA;
if (atom.size >= 10) {
// Broken files created by legacy versions of Libav and FFmpeg will
st = c->fc->streams[c->fc->nb_streams-1];
if ((uint64_t)atom.size > (1<<30))
- return -1;
+ return AVERROR_INVALIDDATA;
av_free(st->codec->extradata);
st->codec->extradata = av_mallocz(atom.size - 40 + FF_INPUT_BUFFER_PADDING_SIZE);
if (!entries)
return 0;
if (entries >= UINT_MAX/sizeof(int64_t))
- return -1;
+ return AVERROR_INVALIDDATA;
sc->chunk_offsets = av_malloc(entries * sizeof(int64_t));
if (!sc->chunk_offsets)
for (i=0; i<entries; i++)
sc->chunk_offsets[i] = avio_rb64(pb);
else
- return -1;
+ return AVERROR_INVALIDDATA;
return 0;
}
/* this will read extra atoms at the end (wave, alac, damr, avcC, SMI ...) */
a.size = size - (avio_tell(pb) - start_pos);
if (a.size > 8) {
- if (mov_read_default(c, pb, a) < 0)
- return -1;
+ int ret;
+ if ((ret = mov_read_default(c, pb, a)) < 0)
+ return ret;
} else if (a.size > 0)
avio_skip(pb, a.size);
}
c->dv_demux = avpriv_dv_init_demux(c->dv_fctx);
if (!c->dv_demux) {
av_log(c->fc, AV_LOG_ERROR, "dv demux context init error\n");
- return -1;
+ return AVERROR(ENOMEM);
}
sc->dv_audio_container = 1;
st->codec->codec_id = CODEC_ID_PCM_S16LE;
if (!entries)
return 0;
if (entries >= UINT_MAX / sizeof(*sc->stsc_data))
- return -1;
+ return AVERROR_INVALIDDATA;
sc->stsc_data = av_malloc(entries * sizeof(*sc->stsc_data));
if (!sc->stsc_data)
return AVERROR(ENOMEM);
entries = avio_rb32(pb);
if (entries >= UINT_MAX / sizeof(*sc->stps_data))
- return -1;
+ return AVERROR_INVALIDDATA;
sc->stps_data = av_malloc(entries * sizeof(*sc->stps_data));
if (!sc->stps_data)
return AVERROR(ENOMEM);
av_dlog(c->fc, "keyframe_count = %d\n", entries);
if (entries >= UINT_MAX / sizeof(int))
- return -1;
+ return AVERROR_INVALIDDATA;
sc->keyframes = av_malloc(entries * sizeof(int));
if (!sc->keyframes)
return AVERROR(ENOMEM);
if (field_size != 4 && field_size != 8 && field_size != 16 && field_size != 32) {
av_log(c->fc, AV_LOG_ERROR, "Invalid sample field size %d\n", field_size);
- return -1;
+ return AVERROR_INVALIDDATA;
}
if (!entries)
return 0;
if (entries >= UINT_MAX / sizeof(int) || entries >= (UINT_MAX - 4) / field_size)
- return -1;
+ return AVERROR_INVALIDDATA;
sc->sample_sizes = av_malloc(entries * sizeof(int));
if (!sc->sample_sizes)
return AVERROR(ENOMEM);
if (avio_read(pb, buf, num_bytes) < num_bytes) {
av_freep(&sc->sample_sizes);
av_free(buf);
- return -1;
+ return AVERROR_INVALIDDATA;
}
init_get_bits(&gb, buf, 8*num_bytes);
if (!entries)
return 0;
if (entries >= UINT_MAX / sizeof(*sc->ctts_data))
- return -1;
+ return AVERROR_INVALIDDATA;
sc->ctts_data = av_malloc(entries * sizeof(*sc->ctts_data));
if (!sc->ctts_data)
return AVERROR(ENOMEM);
track_id = avio_rb32(pb);
if (!track_id)
- return -1;
+ return AVERROR_INVALIDDATA;
frag->track_id = track_id;
for (i = 0; i < c->trex_count; i++)
if (c->trex_data[i].track_id == frag->track_id) {
}
if (!trex) {
av_log(c->fc, AV_LOG_ERROR, "could not find corresponding trex\n");
- return -1;
+ return AVERROR_INVALIDDATA;
}
if (flags & 0x01) frag->base_data_offset = avio_rb64(pb);
MOVTrackExt *trex;
if ((uint64_t)c->trex_count+1 >= UINT_MAX / sizeof(*c->trex_data))
- return -1;
+ return AVERROR_INVALIDDATA;
trex = av_realloc(c->trex_data, (c->trex_count+1)*sizeof(*c->trex_data));
if (!trex)
return AVERROR(ENOMEM);
}
if (!st) {
av_log(c->fc, AV_LOG_ERROR, "could not find corresponding track id %d\n", frag->track_id);
- return -1;
+ return AVERROR_INVALIDDATA;
}
sc = st->priv_data;
if (sc->pseudo_stream_id+1 != frag->stsd_id)
sc->ctts_count++;
}
if ((uint64_t)entries+sc->ctts_count >= UINT_MAX/sizeof(*sc->ctts_data))
- return -1;
+ return AVERROR_INVALIDDATA;
ctts_data = av_realloc(sc->ctts_data,
(entries+sc->ctts_count)*sizeof(*sc->ctts_data));
if (!ctts_data)
avio_rb32(pb); /* dcom atom */
if (avio_rl32(pb) != MKTAG('d','c','o','m'))
- return -1;
+ return AVERROR_INVALIDDATA;
if (avio_rl32(pb) != MKTAG('z','l','i','b')) {
av_log(c->fc, AV_LOG_ERROR, "unknown compression for cmov atom !");
- return -1;
+ return AVERROR_INVALIDDATA;
}
avio_rb32(pb); /* cmvd atom */
if (avio_rl32(pb) != MKTAG('c','m','v','d'))
- return -1;
+ return AVERROR_INVALIDDATA;
moov_len = avio_rb32(pb); /* uncompressed size */
cmov_len = atom.size - 6 * 4;
return ret;
#else
av_log(c->fc, AV_LOG_ERROR, "this file requires zlib support compiled in\n");
- return -1;
+ return AVERROR(ENOSYS);
#endif
}
edit_count = avio_rb32(pb); /* entries */
if ((uint64_t)edit_count*12+8 > atom.size)
- return -1;
+ return AVERROR_INVALIDDATA;
for (i=0; i<edit_count; i++){
int64_t time;
}
if (!mov->found_moov) {
av_log(s, AV_LOG_ERROR, "moov atom not found\n");
- return -1;
+ return AVERROR_INVALIDDATA;
}
av_dlog(mov->fc, "on_parse_exit_offset=%"PRId64"\n", avio_tell(pb));
if (avio_seek(sc->pb, sample->pos, SEEK_SET) != sample->pos) {
av_log(mov->fc, AV_LOG_ERROR, "stream %d, offset 0x%"PRIx64": partial file\n",
sc->ffindex, sample->pos);
- return -1;
+ return AVERROR_INVALIDDATA;
}
ret = av_get_packet(sc->pb, pkt, sample->size);
if (ret < 0)
if (sample < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
sample = 0;
if (sample < 0) /* not sure what to do */
- return -1;
+ return AVERROR_INVALIDDATA;
sc->current_sample = sample;
av_dlog(s, "stream %d, found sample %d\n", st->index, sc->current_sample);
/* adjust ctts index */
int i;
if (stream_index >= s->nb_streams)
- return -1;
+ return AVERROR_INVALIDDATA;
if (sample_time < 0)
sample_time = 0;
st = s->streams[stream_index];
sample = mov_seek_stream(s, st, sample_time, flags);
if (sample < 0)
- return -1;
+ return sample;
/* adjust seek timestamp to found sample timestamp */
seek_timestamp = st->index_entries[sample].timestamp;