har0ke/FFmpeg
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

mov, mxfdec: Employ more meaningful return values.

Browse Source 
Signed-off-by: Diego Biurrun <diego@biurrun.de>
This commit is contained in:
Daniel Huang 2012-01-14 15:25:12 -06:00 committed by Diego Biurrun
parent e2ff436ef6
commit bcd5d979aa
2 changed files with 95 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

93
libavformat/mov.c
View File

@ -239,7 +239,7 @@ static int mov_read_udta_string(MOVContext *c, AVIOContext *pb, MOVAtom atom)
if (!key) if (!key)
return 0; return 0;
if (atom.size < 0) if (atom.size < 0)
return -1; return AVERROR_INVALIDDATA;
str_size = FFMIN3(sizeof(str)-1, str_size, atom.size); str_size = FFMIN3(sizeof(str)-1, str_size, atom.size);
@ -380,7 +380,7 @@ static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
avio_rb32(pb); // version + flags avio_rb32(pb); // version + flags
entries = avio_rb32(pb); entries = avio_rb32(pb);
if (entries >= UINT_MAX / sizeof(*sc->drefs)) if (entries >= UINT_MAX / sizeof(*sc->drefs))
return -1; return AVERROR_INVALIDDATA;
sc->drefs = av_mallocz(entries * sizeof(*sc->drefs)); sc->drefs = av_mallocz(entries * sizeof(*sc->drefs));
if (!sc->drefs) if (!sc->drefs)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
@ -392,7 +392,7 @@ static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int64_t next = avio_tell(pb) + size - 4; int64_t next = avio_tell(pb) + size - 4;
if (size < 12) if (size < 12)
return -1; return AVERROR_INVALIDDATA;
dref->type = avio_rl32(pb); dref->type = avio_rl32(pb);
avio_rb32(pb); // version + flags avio_rb32(pb); // version + flags
@ -673,7 +673,7 @@ static int mov_read_ftyp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
comp_brand_size = atom.size - 8; comp_brand_size = atom.size - 8;
if (comp_brand_size < 0) if (comp_brand_size < 0)
return -1; return AVERROR_INVALIDDATA;
comp_brands_str = av_malloc(comp_brand_size + 1); /* Add null terminator */ comp_brands_str = av_malloc(comp_brand_size + 1); /* Add null terminator */
if (!comp_brands_str) if (!comp_brands_str)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
@ -688,8 +688,10 @@ static int mov_read_ftyp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
/* this atom should contain all header atoms */ /* this atom should contain all header atoms */
static int mov_read_moov(MOVContext *c, AVIOContext *pb, MOVAtom atom) static int mov_read_moov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{ {
if (mov_read_default(c, pb, atom) < 0) int ret;
return -1;
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' */ /* 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 */ /* so we don't parse the whole file if over a network */
c->found_moov=1; c->found_moov=1;
@ -731,9 +733,10 @@ static int mov_read_mdhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
sc = st->priv_data; sc = st->priv_data;
version = avio_r8(pb); version = avio_r8(pb);
if (version > 1) if (version > 1) {
return -1; /* unsupported */ av_log_ask_for_sample(c, "unsupported version %d\n", version);
return AVERROR_PATCHWELCOME;
}
avio_rb24(pb); /* flags */ avio_rb24(pb); /* flags */
if (version == 1) { if (version == 1) {
creation_time = avio_rb64(pb); creation_time = avio_rb64(pb);
@ -802,7 +805,7 @@ static int mov_read_smi(MOVContext *c, AVIOContext *pb, MOVAtom atom)
st = c->fc->streams[c->fc->nb_streams-1]; st = c->fc->streams[c->fc->nb_streams-1];
if ((uint64_t)atom.size > (1<<30)) if ((uint64_t)atom.size > (1<<30))
return -1; return AVERROR_INVALIDDATA;
// currently SVQ3 decoder expect full STSD header - so let's fake it // currently SVQ3 decoder expect full STSD header - so let's fake it
// this should be fixed and just SMI header should be passed // this should be fixed and just SMI header should be passed
@ -895,10 +898,10 @@ static int mov_read_extradata(MOVContext *c, AVIOContext *pb, MOVAtom atom)
st= c->fc->streams[c->fc->nb_streams-1]; st= c->fc->streams[c->fc->nb_streams-1];
size= (uint64_t)st->codec->extradata_size + atom.size + 8 + FF_INPUT_BUFFER_PADDING_SIZE; 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) if (size > INT_MAX || (uint64_t)atom.size > INT_MAX)
return -1; return AVERROR_INVALIDDATA;
buf= av_realloc(st->codec->extradata, size); buf= av_realloc(st->codec->extradata, size);
if (!buf) if (!buf)
return -1; return AVERROR(ENOMEM);
st->codec->extradata= buf; st->codec->extradata= buf;
buf+= st->codec->extradata_size; buf+= st->codec->extradata_size;
st->codec->extradata_size= size - FF_INPUT_BUFFER_PADDING_SIZE; st->codec->extradata_size= size - FF_INPUT_BUFFER_PADDING_SIZE;
@ -917,7 +920,7 @@ static int mov_read_wave(MOVContext *c, AVIOContext *pb, MOVAtom atom)
st = c->fc->streams[c->fc->nb_streams-1]; st = c->fc->streams[c->fc->nb_streams-1];
if ((uint64_t)atom.size > (1<<30)) 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) { 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 // pass all frma atom to codec, needed at least for QDMC and QDM2
@ -928,8 +931,9 @@ static int mov_read_wave(MOVContext *c, AVIOContext *pb, MOVAtom atom)
st->codec->extradata_size = atom.size; st->codec->extradata_size = atom.size;
avio_read(pb, st->codec->extradata, atom.size); avio_read(pb, st->codec->extradata, atom.size);
} else if (atom.size > 8) { /* to read frma, esds atoms */ } else if (atom.size > 8) { /* to read frma, esds atoms */
if (mov_read_default(c, pb, atom) < 0) int ret;
return -1; if ((ret = mov_read_default(c, pb, atom)) < 0)
return ret;
} else } else
avio_skip(pb, atom.size); avio_skip(pb, atom.size);
return 0; return 0;
@ -948,7 +952,7 @@ static int mov_read_glbl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
st = c->fc->streams[c->fc->nb_streams-1]; st = c->fc->streams[c->fc->nb_streams-1];
if ((uint64_t)atom.size > (1<<30)) if ((uint64_t)atom.size > (1<<30))
return -1; return AVERROR_INVALIDDATA;
if (atom.size >= 10) { if (atom.size >= 10) {
// Broken files created by legacy versions of Libav and FFmpeg will // Broken files created by legacy versions of Libav and FFmpeg will
@ -984,7 +988,7 @@ static int mov_read_strf(MOVContext *c, AVIOContext *pb, MOVAtom atom)
st = c->fc->streams[c->fc->nb_streams-1]; st = c->fc->streams[c->fc->nb_streams-1];
if ((uint64_t)atom.size > (1<<30)) if ((uint64_t)atom.size > (1<<30))
return -1; return AVERROR_INVALIDDATA;
av_free(st->codec->extradata); av_free(st->codec->extradata);
st->codec->extradata = av_mallocz(atom.size - 40 + FF_INPUT_BUFFER_PADDING_SIZE); st->codec->extradata = av_mallocz(atom.size - 40 + FF_INPUT_BUFFER_PADDING_SIZE);
@ -1015,7 +1019,7 @@ static int mov_read_stco(MOVContext *c, AVIOContext *pb, MOVAtom atom)
if (!entries) if (!entries)
return 0; return 0;
if (entries >= UINT_MAX/sizeof(int64_t)) if (entries >= UINT_MAX/sizeof(int64_t))
return -1; return AVERROR_INVALIDDATA;
sc->chunk_offsets = av_malloc(entries * sizeof(int64_t)); sc->chunk_offsets = av_malloc(entries * sizeof(int64_t));
if (!sc->chunk_offsets) if (!sc->chunk_offsets)
@ -1029,7 +1033,7 @@ static int mov_read_stco(MOVContext *c, AVIOContext *pb, MOVAtom atom)
for (i=0; i<entries; i++) for (i=0; i<entries; i++)
sc->chunk_offsets[i] = avio_rb64(pb); sc->chunk_offsets[i] = avio_rb64(pb);
else else
return -1; return AVERROR_INVALIDDATA;
return 0; return 0;
} }
@ -1338,8 +1342,9 @@ int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
/* this will read extra atoms at the end (wave, alac, damr, avcC, SMI ...) */ /* this will read extra atoms at the end (wave, alac, damr, avcC, SMI ...) */
a.size = size - (avio_tell(pb) - start_pos); a.size = size - (avio_tell(pb) - start_pos);
if (a.size > 8) { if (a.size > 8) {
if (mov_read_default(c, pb, a) < 0) int ret;
return -1; if ((ret = mov_read_default(c, pb, a)) < 0)
return ret;
} else if (a.size > 0) } else if (a.size > 0)
avio_skip(pb, a.size); avio_skip(pb, a.size);
} }
@ -1355,7 +1360,7 @@ int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
c->dv_demux = avpriv_dv_init_demux(c->dv_fctx); c->dv_demux = avpriv_dv_init_demux(c->dv_fctx);
if (!c->dv_demux) { if (!c->dv_demux) {
av_log(c->fc, AV_LOG_ERROR, "dv demux context init error\n"); av_log(c->fc, AV_LOG_ERROR, "dv demux context init error\n");
return -1; return AVERROR(ENOMEM);
} }
sc->dv_audio_container = 1; sc->dv_audio_container = 1;
st->codec->codec_id = CODEC_ID_PCM_S16LE; st->codec->codec_id = CODEC_ID_PCM_S16LE;
@ -1438,7 +1443,7 @@ static int mov_read_stsc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
if (!entries) if (!entries)
return 0; return 0;
if (entries >= UINT_MAX / sizeof(*sc->stsc_data)) if (entries >= UINT_MAX / sizeof(*sc->stsc_data))
return -1; return AVERROR_INVALIDDATA;
sc->stsc_data = av_malloc(entries * sizeof(*sc->stsc_data)); sc->stsc_data = av_malloc(entries * sizeof(*sc->stsc_data));
if (!sc->stsc_data) if (!sc->stsc_data)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
@ -1467,7 +1472,7 @@ static int mov_read_stps(MOVContext *c, AVIOContext *pb, MOVAtom atom)
entries = avio_rb32(pb); entries = avio_rb32(pb);
if (entries >= UINT_MAX / sizeof(*sc->stps_data)) if (entries >= UINT_MAX / sizeof(*sc->stps_data))
return -1; return AVERROR_INVALIDDATA;
sc->stps_data = av_malloc(entries * sizeof(*sc->stps_data)); sc->stps_data = av_malloc(entries * sizeof(*sc->stps_data));
if (!sc->stps_data) if (!sc->stps_data)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
@ -1500,7 +1505,7 @@ static int mov_read_stss(MOVContext *c, AVIOContext *pb, MOVAtom atom)
av_dlog(c->fc, "keyframe_count = %d\n", entries); av_dlog(c->fc, "keyframe_count = %d\n", entries);
if (entries >= UINT_MAX / sizeof(int)) if (entries >= UINT_MAX / sizeof(int))
return -1; return AVERROR_INVALIDDATA;
sc->keyframes = av_malloc(entries * sizeof(int)); sc->keyframes = av_malloc(entries * sizeof(int));
if (!sc->keyframes) if (!sc->keyframes)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
@ -1549,13 +1554,13 @@ static int mov_read_stsz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
if (field_size != 4 && field_size != 8 && field_size != 16 && field_size != 32) { 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); av_log(c->fc, AV_LOG_ERROR, "Invalid sample field size %d\n", field_size);
return -1; return AVERROR_INVALIDDATA;
} }
if (!entries) if (!entries)
return 0; return 0;
if (entries >= UINT_MAX / sizeof(int) || entries >= (UINT_MAX - 4) / field_size) 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)); sc->sample_sizes = av_malloc(entries * sizeof(int));
if (!sc->sample_sizes) if (!sc->sample_sizes)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
@ -1571,7 +1576,7 @@ static int mov_read_stsz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
if (avio_read(pb, buf, num_bytes) < num_bytes) { if (avio_read(pb, buf, num_bytes) < num_bytes) {
av_freep(&sc->sample_sizes); av_freep(&sc->sample_sizes);
av_free(buf); av_free(buf);
return -1; return AVERROR_INVALIDDATA;
} }
init_get_bits(&gb, buf, 8*num_bytes); init_get_bits(&gb, buf, 8*num_bytes);
@ -1656,7 +1661,7 @@ static int mov_read_ctts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
if (!entries) if (!entries)
return 0; return 0;
if (entries >= UINT_MAX / sizeof(*sc->ctts_data)) if (entries >= UINT_MAX / sizeof(*sc->ctts_data))
return -1; return AVERROR_INVALIDDATA;
sc->ctts_data = av_malloc(entries * sizeof(*sc->ctts_data)); sc->ctts_data = av_malloc(entries * sizeof(*sc->ctts_data));
if (!sc->ctts_data) if (!sc->ctts_data)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
@ -2120,7 +2125,7 @@ static int mov_read_tfhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
track_id = avio_rb32(pb); track_id = avio_rb32(pb);
if (!track_id) if (!track_id)
return -1; return AVERROR_INVALIDDATA;
frag->track_id = track_id; frag->track_id = track_id;
for (i = 0; i < c->trex_count; i++) for (i = 0; i < c->trex_count; i++)
if (c->trex_data[i].track_id == frag->track_id) { if (c->trex_data[i].track_id == frag->track_id) {
@ -2129,7 +2134,7 @@ static int mov_read_tfhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
} }
if (!trex) { if (!trex) {
av_log(c->fc, AV_LOG_ERROR, "could not find corresponding trex\n"); 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); if (flags & 0x01) frag->base_data_offset = avio_rb64(pb);
@ -2155,7 +2160,7 @@ static int mov_read_trex(MOVContext *c, AVIOContext *pb, MOVAtom atom)
MOVTrackExt *trex; MOVTrackExt *trex;
if ((uint64_t)c->trex_count+1 >= UINT_MAX / sizeof(*c->trex_data)) 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)); trex = av_realloc(c->trex_data, (c->trex_count+1)*sizeof(*c->trex_data));
if (!trex) if (!trex)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
@ -2191,7 +2196,7 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
} }
if (!st) { if (!st) {
av_log(c->fc, AV_LOG_ERROR, "could not find corresponding track id %d\n", frag->track_id); 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; sc = st->priv_data;
if (sc->pseudo_stream_id+1 != frag->stsd_id) if (sc->pseudo_stream_id+1 != frag->stsd_id)
@ -2218,7 +2223,7 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
sc->ctts_count++; sc->ctts_count++;
} }
if ((uint64_t)entries+sc->ctts_count >= UINT_MAX/sizeof(*sc->ctts_data)) 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, ctts_data = av_realloc(sc->ctts_data,
(entries+sc->ctts_count)*sizeof(*sc->ctts_data)); (entries+sc->ctts_count)*sizeof(*sc->ctts_data));
if (!ctts_data) if (!ctts_data)
@ -2294,14 +2299,14 @@ static int mov_read_cmov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
avio_rb32(pb); /* dcom atom */ avio_rb32(pb); /* dcom atom */
if (avio_rl32(pb) != MKTAG('d','c','o','m')) if (avio_rl32(pb) != MKTAG('d','c','o','m'))
return -1; return AVERROR_INVALIDDATA;
if (avio_rl32(pb) != MKTAG('z','l','i','b')) { if (avio_rl32(pb) != MKTAG('z','l','i','b')) {
av_log(c->fc, AV_LOG_ERROR, "unknown compression for cmov atom !"); av_log(c->fc, AV_LOG_ERROR, "unknown compression for cmov atom !");
return -1; return AVERROR_INVALIDDATA;
} }
avio_rb32(pb); /* cmvd atom */ avio_rb32(pb); /* cmvd atom */
if (avio_rl32(pb) != MKTAG('c','m','v','d')) if (avio_rl32(pb) != MKTAG('c','m','v','d'))
return -1; return AVERROR_INVALIDDATA;
moov_len = avio_rb32(pb); /* uncompressed size */ moov_len = avio_rb32(pb); /* uncompressed size */
cmov_len = atom.size - 6 * 4; cmov_len = atom.size - 6 * 4;
@ -2327,7 +2332,7 @@ free_and_return:
return ret; return ret;
#else #else
av_log(c->fc, AV_LOG_ERROR, "this file requires zlib support compiled in\n"); av_log(c->fc, AV_LOG_ERROR, "this file requires zlib support compiled in\n");
return -1; return AVERROR(ENOSYS);
#endif #endif
} }
@ -2346,7 +2351,7 @@ static int mov_read_elst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
edit_count = avio_rb32(pb); /* entries */ edit_count = avio_rb32(pb); /* entries */
if ((uint64_t)edit_count*12+8 > atom.size) if ((uint64_t)edit_count*12+8 > atom.size)
return -1; return AVERROR_INVALIDDATA;
for (i=0; i<edit_count; i++){ for (i=0; i<edit_count; i++){
int64_t time; int64_t time;
@ -2565,7 +2570,7 @@ static int mov_read_header(AVFormatContext *s, AVFormatParameters *ap)
} }
if (!mov->found_moov) { if (!mov->found_moov) {
av_log(s, AV_LOG_ERROR, "moov atom not found\n"); 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)); av_dlog(mov->fc, "on_parse_exit_offset=%"PRId64"\n", avio_tell(pb));
@ -2627,7 +2632,7 @@ static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
if (avio_seek(sc->pb, sample->pos, SEEK_SET) != sample->pos) { 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", av_log(mov->fc, AV_LOG_ERROR, "stream %d, offset 0x%"PRIx64": partial file\n",
sc->ffindex, sample->pos); sc->ffindex, sample->pos);
return -1; return AVERROR_INVALIDDATA;
} }
ret = av_get_packet(sc->pb, pkt, sample->size); ret = av_get_packet(sc->pb, pkt, sample->size);
if (ret < 0) if (ret < 0)
@ -2694,7 +2699,7 @@ static int mov_seek_stream(AVFormatContext *s, AVStream *st, int64_t timestamp,
if (sample < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp) if (sample < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
sample = 0; sample = 0;
if (sample < 0) /* not sure what to do */ if (sample < 0) /* not sure what to do */
return -1; return AVERROR_INVALIDDATA;
sc->current_sample = sample; sc->current_sample = sample;
av_dlog(s, "stream %d, found sample %d\n", st->index, sc->current_sample); av_dlog(s, "stream %d, found sample %d\n", st->index, sc->current_sample);
/* adjust ctts index */ /* adjust ctts index */
@ -2721,14 +2726,14 @@ static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_ti
int i; int i;
if (stream_index >= s->nb_streams) if (stream_index >= s->nb_streams)
return -1; return AVERROR_INVALIDDATA;
if (sample_time < 0) if (sample_time < 0)
sample_time = 0; sample_time = 0;
st = s->streams[stream_index]; st = s->streams[stream_index];
sample = mov_seek_stream(s, st, sample_time, flags); sample = mov_seek_stream(s, st, sample_time, flags);
if (sample < 0) if (sample < 0)
return -1; return sample;
/* adjust seek timestamp to found sample timestamp */ /* adjust seek timestamp to found sample timestamp */
seek_timestamp = st->index_entries[sample].timestamp; seek_timestamp = st->index_entries[sample].timestamp;

88
libavformat/mxfdec.c
View File

@ -170,7 +170,7 @@ static int64_t klv_decode_ber_length(AVIOContext *pb)
int bytes_num = size & 0x7f; int bytes_num = size & 0x7f;
/* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */ /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
if (bytes_num > 8) if (bytes_num > 8)
return -1; return AVERROR_INVALIDDATA;
size = 0; size = 0;
while (bytes_num--) while (bytes_num--)
size = size << 8 | avio_r8(pb); size = size << 8 | avio_r8(pb);
@ -194,7 +194,7 @@ static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
static int klv_read_packet(KLVPacket *klv, AVIOContext *pb) static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
{ {
if (!mxf_read_sync(pb, mxf_klv_key, 4)) if (!mxf_read_sync(pb, mxf_klv_key, 4))
return -1; return AVERROR_INVALIDDATA;
klv->offset = avio_tell(pb) - 4; klv->offset = avio_tell(pb) - 4;
memcpy(klv->key, mxf_klv_key, 4); memcpy(klv->key, mxf_klv_key, 4);
avio_read(pb, klv->key + 4, 12); avio_read(pb, klv->key + 4, 12);
@ -224,7 +224,7 @@ static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt,
int i; int i;
if (length > 61444) /* worst case PAL 1920 samples 8 channels */ if (length > 61444) /* worst case PAL 1920 samples 8 channels */
return -1; return AVERROR_INVALIDDATA;
length = av_get_packet(pb, pkt, length); length = av_get_packet(pb, pkt, length);
if (length < 0) if (length < 0)
return length; return length;
@ -261,7 +261,7 @@ static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv
if (!mxf->aesc && s->key && s->keylen == 16) { if (!mxf->aesc && s->key && s->keylen == 16) {
mxf->aesc = av_malloc(av_aes_size); mxf->aesc = av_malloc(av_aes_size);
if (!mxf->aesc) if (!mxf->aesc)
return -1; return AVERROR(ENOMEM);
av_aes_init(mxf->aesc, s->key, 128, 1); av_aes_init(mxf->aesc, s->key, 128, 1);
} }
// crypto context // crypto context
@ -273,19 +273,19 @@ static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv
klv_decode_ber_length(pb); klv_decode_ber_length(pb);
avio_read(pb, klv->key, 16); avio_read(pb, klv->key, 16);
if (!IS_KLV_KEY(klv, mxf_essence_element_key)) if (!IS_KLV_KEY(klv, mxf_essence_element_key))
return -1; return AVERROR_INVALIDDATA;
index = mxf_get_stream_index(s, klv); index = mxf_get_stream_index(s, klv);
if (index < 0) if (index < 0)
return -1; return AVERROR_INVALIDDATA;
// source size // source size
klv_decode_ber_length(pb); klv_decode_ber_length(pb);
orig_size = avio_rb64(pb); orig_size = avio_rb64(pb);
if (orig_size < plaintext_size) if (orig_size < plaintext_size)
return -1; return AVERROR_INVALIDDATA;
// enc. code // enc. code
size = klv_decode_ber_length(pb); size = klv_decode_ber_length(pb);
if (size < 32 || size - 32 < orig_size) if (size < 32 || size - 32 < orig_size)
return -1; return AVERROR_INVALIDDATA;
avio_read(pb, ivec, 16); avio_read(pb, ivec, 16);
avio_read(pb, tmpbuf, 16); avio_read(pb, tmpbuf, 16);
if (mxf->aesc) if (mxf->aesc)
@ -313,15 +313,16 @@ static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
KLVPacket klv; KLVPacket klv;
while (!s->pb->eof_reached) { while (!s->pb->eof_reached) {
int ret;
if (klv_read_packet(&klv, s->pb) < 0) if (klv_read_packet(&klv, s->pb) < 0)
return -1; return -1;
PRINT_KEY(s, "read packet", klv.key); PRINT_KEY(s, "read packet", klv.key);
av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset); av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) { if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
int res = mxf_decrypt_triplet(s, pkt, &klv); ret = mxf_decrypt_triplet(s, pkt, &klv);
if (res < 0) { if (ret < 0) {
av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n"); av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
return -1; return AVERROR_INVALIDDATA;
} }
return 0; return 0;
} }
@ -337,10 +338,10 @@ static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) { if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
if (mxf_get_d10_aes3_packet(s->pb, s->streams[index], pkt, klv.length) < 0) { if (mxf_get_d10_aes3_packet(s->pb, s->streams[index], pkt, klv.length) < 0) {
av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n"); av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
return -1; return AVERROR_INVALIDDATA;
} }
} else { } else {
int ret = av_get_packet(s->pb, pkt, klv.length); ret = av_get_packet(s->pb, pkt, klv.length);
if (ret < 0) if (ret < 0)
return ret; return ret;
} }
@ -361,15 +362,16 @@ static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, U
int item_len = avio_rb32(pb); int item_len = avio_rb32(pb);
if (item_len != 18) { if (item_len != 18) {
av_log(mxf->fc, AV_LOG_ERROR, "unsupported primer pack item length\n"); av_log_ask_for_sample(pb, "unsupported primer pack item length %d\n",
return -1; item_len);
return AVERROR_PATCHWELCOME;
} }
if (item_num > UINT_MAX / item_len) if (item_num > UINT_MAX / item_len)
return -1; return AVERROR_INVALIDDATA;
mxf->local_tags_count = item_num; mxf->local_tags_count = item_num;
mxf->local_tags = av_malloc(item_num*item_len); mxf->local_tags = av_malloc(item_num*item_len);
if (!mxf->local_tags) if (!mxf->local_tags)
return -1; return AVERROR(ENOMEM);
avio_read(pb, mxf->local_tags, item_num*item_len); avio_read(pb, mxf->local_tags, item_num*item_len);
return 0; return 0;
} }
@ -380,7 +382,7 @@ static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
mxf->metadata_sets = av_realloc(mxf->metadata_sets, (mxf->metadata_sets_count + 1) * sizeof(*mxf->metadata_sets)); mxf->metadata_sets = av_realloc(mxf->metadata_sets, (mxf->metadata_sets_count + 1) * sizeof(*mxf->metadata_sets));
if (!mxf->metadata_sets) if (!mxf->metadata_sets)
return -1; return AVERROR(ENOMEM);
mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set; mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set;
mxf->metadata_sets_count++; mxf->metadata_sets_count++;
return 0; return 0;
@ -390,7 +392,7 @@ static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, i
{ {
MXFCryptoContext *cryptocontext = arg; MXFCryptoContext *cryptocontext = arg;
if (size != 16) if (size != 16)
return -1; return AVERROR_INVALIDDATA;
if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul)) if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
avio_read(pb, cryptocontext->source_container_ul, 16); avio_read(pb, cryptocontext->source_container_ul, 16);
return 0; return 0;
@ -403,10 +405,10 @@ static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int siz
case 0x1901: case 0x1901:
mxf->packages_count = avio_rb32(pb); mxf->packages_count = avio_rb32(pb);
if (mxf->packages_count >= UINT_MAX / sizeof(UID)) if (mxf->packages_count >= UINT_MAX / sizeof(UID))
return -1; return AVERROR_INVALIDDATA;
mxf->packages_refs = av_malloc(mxf->packages_count * sizeof(UID)); mxf->packages_refs = av_malloc(mxf->packages_count * sizeof(UID));
if (!mxf->packages_refs) if (!mxf->packages_refs)
return -1; return AVERROR(ENOMEM);
avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */ avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
avio_read(pb, (uint8_t *)mxf->packages_refs, mxf->packages_count * sizeof(UID)); avio_read(pb, (uint8_t *)mxf->packages_refs, mxf->packages_count * sizeof(UID));
break; break;
@ -443,10 +445,10 @@ static int mxf_read_material_package(void *arg, AVIOContext *pb, int tag, int si
case 0x4403: case 0x4403:
package->tracks_count = avio_rb32(pb); package->tracks_count = avio_rb32(pb);
if (package->tracks_count >= UINT_MAX / sizeof(UID)) if (package->tracks_count >= UINT_MAX / sizeof(UID))
return -1; return AVERROR_INVALIDDATA;
package->tracks_refs = av_malloc(package->tracks_count * sizeof(UID)); package->tracks_refs = av_malloc(package->tracks_count * sizeof(UID));
if (!package->tracks_refs) if (!package->tracks_refs)
return -1; return AVERROR(ENOMEM);
avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */ avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID)); avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
break; break;
@ -488,10 +490,10 @@ static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID
case 0x1001: case 0x1001:
sequence->structural_components_count = avio_rb32(pb); sequence->structural_components_count = avio_rb32(pb);
if (sequence->structural_components_count >= UINT_MAX / sizeof(UID)) if (sequence->structural_components_count >= UINT_MAX / sizeof(UID))
return -1; return AVERROR_INVALIDDATA;
sequence->structural_components_refs = av_malloc(sequence->structural_components_count * sizeof(UID)); sequence->structural_components_refs = av_malloc(sequence->structural_components_count * sizeof(UID));
if (!sequence->structural_components_refs) if (!sequence->structural_components_refs)
return -1; return AVERROR(ENOMEM);
avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */ avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
avio_read(pb, (uint8_t *)sequence->structural_components_refs, sequence->structural_components_count * sizeof(UID)); avio_read(pb, (uint8_t *)sequence->structural_components_refs, sequence->structural_components_count * sizeof(UID));
break; break;
@ -506,10 +508,10 @@ static int mxf_read_source_package(void *arg, AVIOContext *pb, int tag, int size
case 0x4403: case 0x4403:
package->tracks_count = avio_rb32(pb); package->tracks_count = avio_rb32(pb);
if (package->tracks_count >= UINT_MAX / sizeof(UID)) if (package->tracks_count >= UINT_MAX / sizeof(UID))
return -1; return AVERROR_INVALIDDATA;
package->tracks_refs = av_malloc(package->tracks_count * sizeof(UID)); package->tracks_refs = av_malloc(package->tracks_count * sizeof(UID));
if (!package->tracks_refs) if (!package->tracks_refs)
return -1; return AVERROR(ENOMEM);
avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */ avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID)); avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
break; break;
@ -564,10 +566,10 @@ static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int
case 0x3F01: case 0x3F01:
descriptor->sub_descriptors_count = avio_rb32(pb); descriptor->sub_descriptors_count = avio_rb32(pb);
if (descriptor->sub_descriptors_count >= UINT_MAX / sizeof(UID)) if (descriptor->sub_descriptors_count >= UINT_MAX / sizeof(UID))
return -1; return AVERROR_INVALIDDATA;
descriptor->sub_descriptors_refs = av_malloc(descriptor->sub_descriptors_count * sizeof(UID)); descriptor->sub_descriptors_refs = av_malloc(descriptor->sub_descriptors_count * sizeof(UID));
if (!descriptor->sub_descriptors_refs) if (!descriptor->sub_descriptors_refs)
return -1; return AVERROR(ENOMEM);
avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */ avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
avio_read(pb, (uint8_t *)descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count * sizeof(UID)); avio_read(pb, (uint8_t *)descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count * sizeof(UID));
break; break;
@ -611,7 +613,7 @@ static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int
if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) { if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
descriptor->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE); descriptor->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
if (!descriptor->extradata) if (!descriptor->extradata)
return -1; return AVERROR(ENOMEM);
descriptor->extradata_size = size; descriptor->extradata_size = size;
avio_read(pb, descriptor->extradata, size); avio_read(pb, descriptor->extradata, size);
} }
@ -684,7 +686,7 @@ static int mxf_parse_structural_metadata(MXFContext *mxf)
} }
if (!material_package) { if (!material_package) {
av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n"); av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
return -1; return AVERROR_INVALIDDATA;
} }
for (i = 0; i < material_package->tracks_count; i++) { for (i = 0; i < material_package->tracks_count; i++) {
@ -732,7 +734,7 @@ static int mxf_parse_structural_metadata(MXFContext *mxf)
for (k = 0; k < source_package->tracks_count; k++) { for (k = 0; k < source_package->tracks_count; k++) {
if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) { if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n"); av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
return -1; return AVERROR_INVALIDDATA;
} }
if (temp_track->track_id == component->source_track_id) { if (temp_track->track_id == component->source_track_id) {
source_track = temp_track; source_track = temp_track;
@ -750,7 +752,7 @@ static int mxf_parse_structural_metadata(MXFContext *mxf)
st = avformat_new_stream(mxf->fc, NULL); st = avformat_new_stream(mxf->fc, NULL);
if (!st) { if (!st) {
av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n"); av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
return -1; return AVERROR(ENOMEM);
} }
st->id = source_track->track_id; st->id = source_track->track_id;
st->priv_data = source_track; st->priv_data = source_track;
@ -762,7 +764,7 @@ static int mxf_parse_structural_metadata(MXFContext *mxf)
if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) { if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n"); av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
return -1; return AVERROR_INVALIDDATA;
} }
PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul); PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
@ -880,8 +882,9 @@ static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadF
uint64_t klv_end = avio_tell(pb) + klv->length; uint64_t klv_end = avio_tell(pb) + klv->length;
if (!ctx) if (!ctx)
return -1; return AVERROR(ENOMEM);
while (avio_tell(pb) + 4 < klv_end) { while (avio_tell(pb) + 4 < klv_end) {
int ret;
int tag = avio_rb16(pb); int tag = avio_rb16(pb);
int size = avio_rb16(pb); /* KLV specified by 0x53 */ int size = avio_rb16(pb); /* KLV specified by 0x53 */
uint64_t next = avio_tell(pb) + size; uint64_t next = avio_tell(pb) + size;
@ -905,8 +908,8 @@ static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadF
} }
if (ctx_size && tag == 0x3C0A) if (ctx_size && tag == 0x3C0A)
avio_read(pb, ctx->uid, 16); avio_read(pb, ctx->uid, 16);
else if (read_child(ctx, pb, tag, size, uid) < 0) else if ((ret = read_child(ctx, pb, tag, size, uid)) < 0)
return -1; return ret;
avio_seek(pb, next, SEEK_SET); avio_seek(pb, next, SEEK_SET);
} }
@ -921,15 +924,16 @@ static int mxf_read_header(AVFormatContext *s, AVFormatParameters *ap)
if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) { if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n"); av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
return -1; return AVERROR_INVALIDDATA;
} }
avio_seek(s->pb, -14, SEEK_CUR); avio_seek(s->pb, -14, SEEK_CUR);
mxf->fc = s; mxf->fc = s;
while (!s->pb->eof_reached) { while (!s->pb->eof_reached) {
int ret;
const MXFMetadataReadTableEntry *metadata; const MXFMetadataReadTableEntry *metadata;
if (klv_read_packet(&klv, s->pb) < 0) if ((ret = klv_read_packet(&klv, s->pb)) < 0)
return -1; return ret;
PRINT_KEY(s, "read header", klv.key); PRINT_KEY(s, "read header", klv.key);
av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset); av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) || if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
@ -948,7 +952,7 @@ static int mxf_read_header(AVFormatContext *s, AVFormatParameters *ap)
res = metadata->read(mxf, s->pb, 0, 0, NULL); res = metadata->read(mxf, s->pb, 0, 0, NULL);
if (res < 0) { if (res < 0) {
av_log(s, AV_LOG_ERROR, "error reading header metadata\n"); av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
return -1; return res;
} }
break; break;
} }
@ -1016,7 +1020,7 @@ static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_ti
int64_t seconds; int64_t seconds;
if (!s->bit_rate) if (!s->bit_rate)
return -1; return AVERROR_INVALIDDATA;
if (sample_time < 0) if (sample_time < 0)
sample_time = 0; sample_time = 0;
seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den); seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);