Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

mov, mxfdec: Employ more meaningful return values.

Browse Source 
Signed-off-by: Diego Biurrun <diego@biurrun.de>
release/0.10
Daniel Huang 13 years ago committed by Diego Biurrun
parent e2ff436ef6
commit bcd5d979aa
2 changed files with 95 additions and 86 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 93
      libavformat/mov.c
  2. 88
      libavformat/mxfdec.c

93
libavformat/mov.c
Unescape 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
Unescape 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);

Write Preview
Loading…
Cancel
Save