if (ret < 0)
return ret;
+ if (pkt.size >= 8 && id != AV_CODEC_ID_BMP) {
+ if (AV_RB64(pkt.data) == 0x89504e470d0a1a0a) {
+ id = AV_CODEC_ID_PNG;
+ } else {
+ id = AV_CODEC_ID_MJPEG;
+ }
+ }
+
st->disposition |= AV_DISPOSITION_ATTACHED_PIC;
st->attached_pic = pkt;
if (!raw && (data_type == 3 || (data_type == 0 && (langcode < 0x400 || langcode == 0x7fff)))) { // MAC Encoded
mov_read_mac_string(c, pb, str_size, str, str_size_alloc);
} else {
- avio_read(pb, str, str_size);
+ int ret = ffio_read_size(pb, str, str_size);
+ if (ret < 0) {
+ av_free(str);
+ return ret;
+ }
str[str_size] = 0;
}
c->fc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
int64_t start;
int i, nb_chapters, str_len, version;
char str[256+1];
+ int ret;
if ((atom.size -= 5) < 0)
return 0;
if ((atom.size -= 9+str_len) < 0)
return 0;
- avio_read(pb, str, str_len);
+ ret = ffio_read_size(pb, str, str_len);
+ if (ret < 0)
+ return ret;
str[str_len] = 0;
avpriv_new_chapter(c->fc, i, (AVRational){1,10000000}, start, AV_NOPTS_VALUE, str);
}
return AVERROR(ENOMEM);
sc->drefs_count = entries;
- for (i = 0; i < sc->drefs_count; i++) {
+ for (i = 0; i < entries; i++) {
MOVDref *dref = &sc->drefs[i];
uint32_t size = avio_rb32(pb);
int64_t next = avio_tell(pb) + size - 4;
/* macintosh alias record */
uint16_t volume_len, len;
int16_t type;
+ int ret;
avio_skip(pb, 10);
volume_len = avio_r8(pb);
volume_len = FFMIN(volume_len, 27);
- avio_read(pb, dref->volume, 27);
+ ret = ffio_read_size(pb, dref->volume, 27);
+ if (ret < 0)
+ return ret;
dref->volume[volume_len] = 0;
av_log(c->fc, AV_LOG_DEBUG, "volume %s, len %d\n", dref->volume, volume_len);
len = avio_r8(pb);
len = FFMIN(len, 63);
- avio_read(pb, dref->filename, 63);
+ ret = ffio_read_size(pb, dref->filename, 63);
+ if (ret < 0)
+ return ret;
dref->filename[len] = 0;
av_log(c->fc, AV_LOG_DEBUG, "filename %s, len %d\n", dref->filename, len);
dref->path = av_mallocz(len+1);
if (!dref->path)
return AVERROR(ENOMEM);
- avio_read(pb, dref->path, len);
+
+ ret = ffio_read_size(pb, dref->path, len);
+ if (ret < 0) {
+ av_freep(&dref->path);
+ return ret;
+ }
if (len > volume_len && !strncmp(dref->path, dref->volume, volume_len)) {
len -= volume_len;
memmove(dref->path, dref->path+volume_len, len);
dref->path[len] = 0;
}
for (j = 0; j < len; j++)
- if (dref->path[j] == ':')
+ if (dref->path[j] == ':' || dref->path[j] == 0)
dref->path[j] = '/';
av_log(c->fc, AV_LOG_DEBUG, "path %s\n", dref->path);
} else if (type == 0) { // directory name
dref->dir = av_malloc(len+1);
if (!dref->dir)
return AVERROR(ENOMEM);
- avio_read(pb, dref->dir, len);
+
+ ret = ffio_read_size(pb, dref->dir, len);
+ if (ret < 0) {
+ av_freep(&dref->dir);
+ return ret;
+ }
dref->dir[len] = 0;
for (j = 0; j < len; j++)
if (dref->dir[j] == ':')
} else
avio_skip(pb, len);
}
+ } else {
+ av_log(c->fc, AV_LOG_DEBUG, "Unknown dref type 0x08%x size %d\n",
+ dref->type, size);
+ entries--;
+ i--;
}
avio_seek(pb, next, SEEK_SET);
}
uint32_t av_unused ctype;
int64_t title_size;
char *title_str;
+ int ret;
if (c->fc->nb_streams < 1) // meta before first trak
return 0;
title_str = av_malloc(title_size + 1); /* Add null terminator */
if (!title_str)
return AVERROR(ENOMEM);
- avio_read(pb, title_str, title_size);
+
+ ret = ffio_read_size(pb, title_str, title_size);
+ if (ret < 0) {
+ av_freep(&title_str);
+ return ret;
+ }
title_str[title_size] = 0;
if (title_str[0]) {
int off = (!c->isom && title_str[0] == title_size - 1);
return 0;
st = c->fc->streams[c->fc->nb_streams-1];
- ast = (enum AVAudioServiceType*)ff_stream_new_side_data(st, AV_PKT_DATA_AUDIO_SERVICE_TYPE,
+ ast = (enum AVAudioServiceType*)av_stream_new_side_data(st, AV_PKT_DATA_AUDIO_SERVICE_TYPE,
sizeof(*ast));
if (!ast)
return AVERROR(ENOMEM);
return 0;
st = c->fc->streams[c->fc->nb_streams-1];
- ast = (enum AVAudioServiceType*)ff_stream_new_side_data(st, AV_PKT_DATA_AUDIO_SERVICE_TYPE,
+ ast = (enum AVAudioServiceType*)av_stream_new_side_data(st, AV_PKT_DATA_AUDIO_SERVICE_TYPE,
sizeof(*ast));
if (!ast)
return AVERROR(ENOMEM);
return 0;
st = c->fc->streams[c->fc->nb_streams-1];
- return ff_get_wav_header(pb, st->codec, atom.size);
+ return ff_get_wav_header(c->fc, pb, st->codec, atom.size);
}
static int mov_read_pasp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
char minor_ver_str[11]; /* 32 bit integer -> 10 digits + null */
char* comp_brands_str;
uint8_t type[5] = {0};
+ int ret = ffio_read_size(pb, type, 4);
+ if (ret < 0)
+ return ret;
- avio_read(pb, type, 4);
if (strcmp(type, "qt "))
c->isom = 1;
av_log(c->fc, AV_LOG_DEBUG, "ISO: File Type Major Brand: %.4s\n",(char *)&type);
comp_brands_str = av_malloc(comp_brand_size + 1); /* Add null terminator */
if (!comp_brands_str)
return AVERROR(ENOMEM);
- avio_read(pb, comp_brands_str, comp_brand_size);
+
+ ret = ffio_read_size(pb, comp_brands_str, comp_brand_size);
+ if (ret < 0) {
+ av_freep(&comp_brands_str);
+ return ret;
+ }
comp_brands_str[comp_brand_size] = 0;
av_dict_set(&c->fc->metadata, "compatible_brands", comp_brands_str, 0);
av_freep(&comp_brands_str);
static int mov_read_smi(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
AVStream *st;
+ int ret;
if (c->fc->nb_streams < 1)
return 0;
// currently SVQ3 decoder expect full STSD header - so let's fake it
// this should be fixed and just SMI header should be passed
av_free(st->codec->extradata);
- st->codec->extradata = av_mallocz(atom.size + 0x5a + FF_INPUT_BUFFER_PADDING_SIZE);
+ st->codec->extradata = av_mallocz(atom.size + 0x5a + AV_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata)
return AVERROR(ENOMEM);
st->codec->extradata_size = 0x5a + atom.size;
memcpy(st->codec->extradata, "SVQ3", 4); // fake
- avio_read(pb, st->codec->extradata + 0x5a, atom.size);
+
+ ret = ffio_read_size(pb, st->codec->extradata + 0x5a, atom.size);
+ if (ret < 0)
+ return ret;
+
av_log(c->fc, AV_LOG_TRACE, "Reading SMI %"PRId64" %s\n", atom.size, st->codec->extradata + 0x5a);
return 0;
}
{
AVStream *st;
char color_parameter_type[5] = { 0 };
- int color_primaries, color_trc, color_matrix;
+ uint16_t color_primaries, color_trc, color_matrix;
+ int ret;
if (c->fc->nb_streams < 1)
return 0;
st = c->fc->streams[c->fc->nb_streams - 1];
- avio_read(pb, color_parameter_type, 4);
+ ret = ffio_read_size(pb, color_parameter_type, 4);
+ if (ret < 0)
+ return ret;
if (strncmp(color_parameter_type, "nclx", 4) &&
strncmp(color_parameter_type, "nclc", 4)) {
av_log(c->fc, AV_LOG_WARNING, "unsupported color_parameter_type %s\n",
if (c->fc->nb_streams < 1) // will happen with jp2 files
return 0;
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 + AV_INPUT_BUFFER_PADDING_SIZE;
if (size > INT_MAX || (uint64_t)atom.size > INT_MAX)
return AVERROR_INVALIDDATA;
if ((err = av_reallocp(&st->codec->extradata, size)) < 0) {
return err;
}
buf = st->codec->extradata + st->codec->extradata_size;
- st->codec->extradata_size= size - FF_INPUT_BUFFER_PADDING_SIZE;
+ st->codec->extradata_size= size - AV_INPUT_BUFFER_PADDING_SIZE;
AV_WB32( buf , atom.size + 8);
AV_WL32( buf + 4, atom.type);
- avio_read(pb, buf + 8, atom.size);
+
+ err = ffio_read_size(pb, buf + 8, atom.size);
+ if (err < 0)
+ return err;
+
return 0;
}
static int mov_read_wave(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
AVStream *st;
+ int ret;
if (c->fc->nb_streams < 1)
return 0;
if (st->codec->codec_id == AV_CODEC_ID_QDM2 || st->codec->codec_id == AV_CODEC_ID_QDMC) {
// pass all frma atom to codec, needed at least for QDMC and QDM2
av_free(st->codec->extradata);
- st->codec->extradata = av_mallocz(atom.size + FF_INPUT_BUFFER_PADDING_SIZE);
+ st->codec->extradata = av_mallocz(atom.size + AV_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata)
return AVERROR(ENOMEM);
st->codec->extradata_size = atom.size;
- avio_read(pb, st->codec->extradata, atom.size);
+
+ ret = ffio_read_size(pb, st->codec->extradata, atom.size);
+ if (ret < 0)
+ return ret;
} else if (atom.size > 8) { /* to read frma, esds atoms */
- int ret;
if ((ret = mov_read_default(c, pb, atom)) < 0)
return ret;
} else
static int mov_read_glbl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
AVStream *st;
+ int ret;
if (c->fc->nb_streams < 1)
return 0;
return mov_read_default(c, pb, atom);
}
av_free(st->codec->extradata);
- st->codec->extradata = av_mallocz(atom.size + FF_INPUT_BUFFER_PADDING_SIZE);
+ st->codec->extradata = av_mallocz(atom.size + AV_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata)
return AVERROR(ENOMEM);
st->codec->extradata_size = atom.size;
- avio_read(pb, st->codec->extradata, atom.size);
+
+ ret = ffio_read_size(pb, st->codec->extradata, atom.size);
+ if (ret < 0)
+ return ret;
+
return 0;
}
{
AVStream *st;
uint8_t profile_level;
+ int ret;
if (c->fc->nb_streams < 1)
return 0;
return 0;
av_free(st->codec->extradata);
- st->codec->extradata = av_mallocz(atom.size - 7 + FF_INPUT_BUFFER_PADDING_SIZE);
+ st->codec->extradata = av_mallocz(atom.size - 7 + AV_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata)
return AVERROR(ENOMEM);
st->codec->extradata_size = atom.size - 7;
avio_seek(pb, 6, SEEK_CUR);
- avio_read(pb, st->codec->extradata, st->codec->extradata_size);
+
+ ret = ffio_read_size(pb, st->codec->extradata, st->codec->extradata_size);
+ if (ret < 0)
+ return ret;
+
return 0;
}
static int mov_read_strf(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
AVStream *st;
+ int ret;
if (c->fc->nb_streams < 1)
return 0;
return AVERROR_INVALIDDATA;
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 + AV_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata)
return AVERROR(ENOMEM);
st->codec->extradata_size = atom.size - 40;
avio_skip(pb, 40);
- avio_read(pb, st->codec->extradata, atom.size - 40);
+
+ ret = ffio_read_size(pb, st->codec->extradata, atom.size - 40);
+ if (ret < 0)
+ return ret;
+
return 0;
}
ff_mov_get_lpcm_codec_id(st->codec->bits_per_coded_sample,
flags);
}
+ if (version == 0 || (version == 1 && sc->audio_cid != -2)) {
+ /* can't correctly handle variable sized packet as audio unit */
+ switch (st->codec->codec_id) {
+ case AV_CODEC_ID_MP2:
+ case AV_CODEC_ID_MP3:
+ st->need_parsing = AVSTREAM_PARSE_FULL;
+ break;
+ }
+ }
}
switch (st->codec->codec_id) {
av_freep(&st->codec->extradata);
st->codec->extradata_size = 0;
- st->codec->extradata = av_mallocz(strlen(buf) + FF_INPUT_BUFFER_PADDING_SIZE);
+ st->codec->extradata = av_mallocz(strlen(buf) + AV_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata)
return AVERROR(ENOMEM);
st->codec->extradata_size = strlen(buf);
AVStream *st, MOVStreamContext *sc,
int size)
{
+ int ret;
+
if (st->codec->codec_tag == MKTAG('t','m','c','d')) {
st->codec->extradata_size = size;
- st->codec->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
+ st->codec->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata)
return AVERROR(ENOMEM);
- avio_read(pb, st->codec->extradata, size);
+ ret = ffio_read_size(pb, st->codec->extradata, size);
+ if (ret < 0)
+ return ret;
} else {
/* other codec type, just skip (rtp, mp4s ...) */
avio_skip(pb, size);
switch (st->codec->codec_id) {
#if CONFIG_DV_DEMUXER
case AV_CODEC_ID_DVAUDIO:
- c->dv_fctx = avformat_alloc_context();
+ c->dv_fctx = avformat_alloc_context();
+ if (!c->dv_fctx) {
+ av_log(c->fc, AV_LOG_ERROR, "dv demux context alloc error\n");
+ return AVERROR(ENOMEM);
+ }
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");
case AV_CODEC_ID_MP3:
/* force type after stsd for m1a hdlr */
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
- st->need_parsing = AVSTREAM_PARSE_FULL;
break;
case AV_CODEC_ID_GSM:
case AV_CODEC_ID_ADPCM_MS:
id = mov_codec_id(st, format);
- av_log(c->fc, AV_LOG_TRACE, "size=%"PRIu32" 4CC= %"PRIu8"%"PRIu8"%"PRIu8"%"PRIu8" codec_type=%d\n", size,
- (format >> 0) & 0xff, (format >> 8) & 0xff, (format >> 16) & 0xff,
- (format >> 24) & 0xff, st->codec->codec_type);
+ av_log(c->fc, AV_LOG_TRACE,
+ "size=%"PRIu32" format=0x%08x codec_type=%d\n",
+ size, format, st->codec->codec_type);
if (st->codec->codec_type==AVMEDIA_TYPE_VIDEO) {
st->codec->codec_id = id;
unsigned int i, entries, sample_size, field_size, num_bytes;
GetBitContext gb;
unsigned char* buf;
+ int ret;
if (c->fc->nb_streams < 1)
return 0;
num_bytes = (entries*field_size+4)>>3;
- buf = av_malloc(num_bytes+FF_INPUT_BUFFER_PADDING_SIZE);
+ buf = av_malloc(num_bytes+AV_INPUT_BUFFER_PADDING_SIZE);
if (!buf) {
av_freep(&sc->sample_sizes);
return AVERROR(ENOMEM);
}
- if (avio_read(pb, buf, num_bytes) < num_bytes) {
+ ret = ffio_read_size(pb, buf, num_bytes);
+ if (ret < 0) {
av_freep(&sc->sample_sizes);
av_free(buf);
- return AVERROR_INVALIDDATA;
+ return ret;
}
init_get_bits(&gb, buf, 8*num_bytes);
sc->sample_count = i;
+ av_free(buf);
+
if (pb->eof_reached)
return AVERROR_EOF;
- av_free(buf);
return 0;
}
av_log(c->fc, AV_LOG_TRACE, "track[%i].ctts.entries = %i\n", c->fc->nb_streams-1, entries);
+ av_freep(&sc->ctts_data);
+
if (!entries)
return 0;
if (entries >= UINT_MAX / sizeof(*sc->ctts_data))
return AVERROR_INVALIDDATA;
- sc->ctts_data = av_malloc(entries * sizeof(*sc->ctts_data));
+ sc->ctts_data = av_realloc(NULL, entries * sizeof(*sc->ctts_data));
if (!sc->ctts_data)
return AVERROR(ENOMEM);
AVIndexEntry *e;
unsigned size, samples;
+ if (sc->samples_per_frame > 1 && !sc->bytes_per_frame) {
+ avpriv_request_sample(mov->fc,
+ "Zero bytes per frame, but %d samples per frame",
+ sc->samples_per_frame);
+ return;
+ }
+
if (sc->samples_per_frame >= 160) { // gsm
samples = sc->samples_per_frame;
size = sc->bytes_per_frame;
for (i = 0; i < 2; i++) {
uint8_t **p;
uint32_t len, tag;
+ int ret;
if (end - avio_tell(pb) <= 12)
break;
*p = av_malloc(len + 1);
if (!*p)
break;
- avio_read(pb, *p, len);
+ ret = ffio_read_size(pb, *p, len);
+ if (ret < 0) {
+ av_freep(p);
+ return ret;
+ }
(*p)[len] = 0;
}
int64_t dts;
int data_offset = 0;
unsigned entries, first_sample_flags = frag->flags;
- int flags, distance, i, found_keyframe = 0, err;
+ int flags, distance, i, err;
for (i = 0; i < c->fc->nb_streams; i++) {
if (c->fc->streams[i]->id == frag->track_id) {
sc->ctts_count++;
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
keyframe = 1;
- else if (!found_keyframe)
- keyframe = found_keyframe =
+ else
+ keyframe =
!(sample_flags & (MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC |
MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES));
if (keyframe)
av_free(cmov_data);
return AVERROR(ENOMEM);
}
- avio_read(pb, cmov_data, cmov_len);
+ ret = ffio_read_size(pb, cmov_data, cmov_len);
+ if (ret < 0)
+ goto free_and_return;
+
if (uncompress (moov_data, (uLongf *) &moov_len, (const Bytef *)cmov_data, cmov_len) != Z_OK)
goto free_and_return;
if (ffio_init_context(&ctx, moov_data, moov_len, 0, NULL, NULL, NULL, NULL) != 0)
goto retry;
pkt->flags |= sample->flags & AVINDEX_KEYFRAME ? AV_PKT_FLAG_KEY : 0;
pkt->pos = sample->pos;
- av_log(s, AV_LOG_TRACE, "stream %d, pts %"PRId64", dts %"PRId64", pos 0x%"PRIx64", duration %d\n",
+ av_log(s, AV_LOG_TRACE, "stream %d, pts %"PRId64", dts %"PRId64", pos 0x%"PRIx64", duration %"PRId64"\n",
pkt->stream_index, pkt->pts, pkt->dts, pkt->pos, pkt->duration);
return 0;
}