{
ADXDemuxerContext *c = s->priv_data;
AVCodecParameters *par;
-
+ int ret;
AVStream *st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
c->header_size = avio_rb16(s->pb) + 4;
avio_seek(s->pb, -4, SEEK_CUR);
- if (ff_get_extradata(s, par, s->pb, c->header_size) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = ff_get_extradata(s, par, s->pb, c->header_size)) < 0)
+ return ret;
if (par->extradata_size < 12) {
av_log(s, AV_LOG_ERROR, "Invalid extradata size.\n");
{
AFCDemuxContext *c = s->priv_data;
AVStream *st;
+ int ret;
st = avformat_new_stream(s, NULL);
if (!st)
st->codecpar->channels = 2;
st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
- if (ff_alloc_extradata(st->codecpar, 1))
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(st->codecpar, 1)) < 0)
+ return ret;
st->codecpar->extradata[0] = 8 * st->codecpar->channels;
c->data_end = avio_rb32(s->pb) + 32LL;
case MKTAG('w', 'a', 'v', 'e'):
if ((uint64_t)size > (1<<30))
return -1;
- if (ff_get_extradata(s, st->codecpar, pb, size) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = ff_get_extradata(s, st->codecpar, pb, size)) < 0)
+ return ret;
if ( (st->codecpar->codec_id == AV_CODEC_ID_QDMC || st->codecpar->codec_id == AV_CODEC_ID_QDM2)
&& size>=12*4 && !st->codecpar->block_align) {
st->codecpar->block_align = AV_RB32(st->codecpar->extradata+11*4);
}
break;
case MKTAG('C','H','A','N'):
- if(ff_mov_read_chan(s, pb, st, size) < 0)
- return AVERROR_INVALIDDATA;
+ if ((ret = ff_mov_read_chan(s, pb, st, size)) < 0)
+ return ret;
break;
case MKTAG('A','P','C','M'): /* XA ADPCM compressed sound chunk */
st->codecpar->codec_id = AV_CODEC_ID_ADPCM_XA;
{
AVIOContext *pb = s->pb;
AVStream *st;
+ int ret;
avio_rl32(pb); /* CRYO */
avio_rl32(pb); /* _APC */
st->codecpar->sample_rate = avio_rl32(pb);
/* initial predictor values for adpcm decoder */
- if (ff_get_extradata(s, st->codecpar, pb, 2 * 4) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = ff_get_extradata(s, st->codecpar, pb, 2 * 4)) < 0)
+ return ret;
if (avio_rl32(pb)) {
st->codecpar->channels = 2;
APEContext *ape = s->priv_data;
AVStream *st;
uint32_t tag;
- int i;
+ int i, ret;
int total_blocks, final_size = 0;
int64_t pts, file_size;
st->duration = total_blocks;
avpriv_set_pts_info(st, 64, 1, ape->samplerate);
- if (ff_alloc_extradata(st->codecpar, APE_EXTRADATA_SIZE))
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(st->codecpar, APE_EXTRADATA_SIZE)) < 0)
+ return ret;
AV_WL16(st->codecpar->extradata + 0, ape->fileversion);
AV_WL16(st->codecpar->extradata + 2, ape->compressiontype);
AV_WL16(st->codecpar->extradata + 4, ape->formatflags);
int nblocks;
APEContext *ape = s->priv_data;
uint32_t extra_size = 8;
+ int64_t ret64;
if (avio_feof(s->pb))
return AVERROR_EOF;
if (ape->currentframe >= ape->totalframes)
return AVERROR_EOF;
- if (avio_seek(s->pb, ape->frames[ape->currentframe].pos, SEEK_SET) < 0)
- return AVERROR(EIO);
+ ret64 = avio_seek(s->pb, ape->frames[ape->currentframe].pos, SEEK_SET);
+ if (ret64 < 0)
+ return ret64;
/* Calculate how many blocks there are in this frame */
if (ape->currentframe == (ape->totalframes - 1))
return AVERROR(EIO);
}
- if (av_new_packet(pkt, ape->frames[ape->currentframe].size + extra_size) < 0)
- return AVERROR(ENOMEM);
+ ret = av_new_packet(pkt, ape->frames[ape->currentframe].size + extra_size);
+ if (ret < 0)
+ return ret;
AV_WL32(pkt->data , nblocks);
AV_WL32(pkt->data + 4, ape->frames[ape->currentframe].skip);
AVStream *st = s->streams[stream_index];
APEContext *ape = s->priv_data;
int index = av_index_search_timestamp(st, timestamp, flags);
+ int64_t ret;
if (index < 0)
return -1;
- if (avio_seek(s->pb, st->index_entries[index].pos, SEEK_SET) < 0)
- return -1;
+ if ((ret = avio_seek(s->pb, st->index_entries[index].pos, SEEK_SET)) < 0)
+ return ret;
ape->currentframe = index;
return 0;
}
st->attached_pic.stream_index = st->index;
st->attached_pic.flags |= AV_PKT_FLAG_KEY;
} else {
- if (ff_get_extradata(s, st->codecpar, s->pb, size) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = ff_get_extradata(s, st->codecpar, s->pb, size)) < 0)
+ return ret;
st->codecpar->codec_type = AVMEDIA_TYPE_ATTACHMENT;
}
} else {
int64_t pres_time = av_rescale_q(c->start, c->time_base, scale);
uint64_t offset;
int32_t send_time = get_send_time(asf, pres_time, &offset);
- int len = 0;
+ int len = 0, ret;
uint8_t *buf;
AVIOContext *dyn_buf;
if (t) {
- if (avio_open_dyn_buf(&dyn_buf) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = avio_open_dyn_buf(&dyn_buf)) < 0)
+ return ret;
avio_put_str16le(dyn_buf, t->value);
len = avio_close_dyn_buf(dyn_buf, &buf);
}
/* title and other info */
if (has_title) {
- int len;
+ int len, ret;
uint8_t *buf;
AVIOContext *dyn_buf;
- if (avio_open_dyn_buf(&dyn_buf) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = avio_open_dyn_buf(&dyn_buf)) < 0)
+ return ret;
hpos = put_header(pb, &ff_asf_comment_header);
if (desc) {
AVIOContext *dyn_buf;
uint8_t *buf;
- int len;
+ int len, ret;
- if (avio_open_dyn_buf(&dyn_buf) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = avio_open_dyn_buf(&dyn_buf)) < 0)
+ return ret;
avio_put_str16le(dyn_buf, desc);
len = avio_close_dyn_buf(dyn_buf, &buf);
av_log(s, AV_LOG_WARNING, "New extradata in strf chunk, freeing previous one.\n");
av_freep(&st->codecpar->extradata);
}
- if (ff_get_extradata(s, st->codecpar, pb, st->codecpar->extradata_size) < 0)
- return AVERROR(ENOMEM);
+ ret = ff_get_extradata(s, st->codecpar, pb,
+ st->codecpar->extradata_size);
+ if (ret < 0)
+ return ret;
}
// FIXME: check if the encoder really did this correctly
av_log(s, AV_LOG_WARNING, "New extradata in strd chunk, freeing previous one.\n");
av_freep(&st->codecpar->extradata);
}
- if (ff_get_extradata(s, st->codecpar, pb, size) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = ff_get_extradata(s, st->codecpar, pb, size)) < 0)
+ return ret;
}
if (st->codecpar->extradata_size & 1) //FIXME check if the encoder really did this correctly
AVS_VideoFrame *frame;
unsigned char *dst_p;
const unsigned char *src_p;
- int n, i, plane, rowsize, planeheight, pitch, bits;
+ int n, i, plane, rowsize, planeheight, pitch, bits, ret;
const char *error;
int avsplus av_unused;
if (!pkt->size)
return AVERROR_UNKNOWN;
- if (av_new_packet(pkt, pkt->size) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, pkt->size)) < 0)
+ return ret;
pkt->pts = n;
pkt->dts = n;
{
AviSynthContext *avs = s->priv_data;
AVRational fps, samplerate;
- int samples;
+ int samples, ret;
int64_t n;
const char *error;
if (!pkt->size)
return AVERROR_UNKNOWN;
- if (av_new_packet(pkt, pkt->size) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, pkt->size)) < 0)
+ return ret;
pkt->pts = n;
pkt->dts = n;
vst->codecpar->codec_id = AV_CODEC_ID_NONE;
}
- if (ff_get_extradata(s, vst->codecpar, pb, 4) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = ff_get_extradata(s, vst->codecpar, pb, 4)) < 0)
+ return ret;
bink->num_audio_tracks = avio_rl32(pb);
ast->codecpar->channels = 1;
ast->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
}
- if (ff_alloc_extradata(ast->codecpar, 4))
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(ast->codecpar, 4)) < 0)
+ return ret;
AV_WL32(ast->codecpar->extradata, vst->codecpar->codec_tag);
}
{
BinkDemuxContext *bink = s->priv_data;
AVStream *vst = s->streams[0];
+ int64_t ret;
if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
return -1;
/* seek to the first frame */
- if (avio_seek(s->pb, vst->index_entries[0].pos + bink->smush_size, SEEK_SET) < 0)
- return -1;
+ ret = avio_seek(s->pb, vst->index_entries[0].pos + bink->smush_size, SEEK_SET);
+ if (ret < 0)
+ return ret;
bink->video_pts = 0;
memset(bink->audio_pts, 0, sizeof(bink->audio_pts));
{
BinDemuxContext *bin = s->priv_data;
AVIOContext *pb = s->pb;
-
+ int ret;
AVStream *st = init_stream(s);
if (!st)
return AVERROR(ENOMEM);
st->codecpar->codec_id = AV_CODEC_ID_BINTEXT;
- if (ff_alloc_extradata(st->codecpar, 2))
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(st->codecpar, 2)) < 0)
+ return ret;
st->codecpar->extradata[0] = 16;
st->codecpar->extradata[1] = 0;
BinDemuxContext *bin = s->priv_data;
AVIOContext *pb = s->pb;
char fontheight, flags;
-
+ int ret;
AVStream *st = init_stream(s);
if (!st)
return AVERROR(ENOMEM);
st->codecpar->extradata_size += fontheight * (flags & 0x10 ? 512 : 256);
st->codecpar->codec_id = flags & 4 ? AV_CODEC_ID_XBIN : AV_CODEC_ID_BINTEXT;
- if (ff_alloc_extradata(st->codecpar, st->codecpar->extradata_size))
- return AVERROR(ENOMEM);
+ ret = ff_alloc_extradata(st->codecpar, st->codecpar->extradata_size);
+ if (ret < 0)
+ return ret;
st->codecpar->extradata[0] = fontheight;
st->codecpar->extradata[1] = flags;
if (avio_read(pb, st->codecpar->extradata + 2, st->codecpar->extradata_size - 2) < 0)
BinDemuxContext *bin = s->priv_data;
AVIOContext *pb = s->pb;
AVStream *st;
+ int ret;
if (avio_r8(pb) != 1)
return AVERROR_INVALIDDATA;
return AVERROR(ENOMEM);
st->codecpar->codec_id = AV_CODEC_ID_BINTEXT;
- if (ff_alloc_extradata(st->codecpar, 2 + 48 + 4096))
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(st->codecpar, 2 + 48 + 4096)) < 0)
+ return ret;
st->codecpar->extradata[0] = 16;
st->codecpar->extradata[1] = BINTEXT_PALETTE|BINTEXT_FONT;
BinDemuxContext *bin = s->priv_data;
AVIOContext *pb = s->pb;
AVStream *st;
- int got_width = 0;
+ int got_width = 0, ret;
if (!(pb->seekable & AVIO_SEEKABLE_NORMAL))
return AVERROR(EIO);
return AVERROR(ENOMEM);
st->codecpar->codec_id = AV_CODEC_ID_IDF;
- if (ff_alloc_extradata(st->codecpar, 2 + 48 + 4096))
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(st->codecpar, 2 + 48 + 4096)) < 0)
+ return ret;
st->codecpar->extradata[0] = 16;
st->codecpar->extradata[1] = BINTEXT_PALETTE|BINTEXT_FONT;
if(ret != 8 * packet_size * sizeof(uint16_t))
return AVERROR(EIO);
- if (av_new_packet(pkt, packet_size) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, packet_size)) < 0)
+ return ret;
init_put_bits(&pbo, pkt->data, packet_size);
for(j=0; j < packet_size; j++)
audio_size, c->size);
return AVERROR_INVALIDDATA;
}
- if (av_new_packet(pkt, audio_size) < 0)
- return AVERROR(ENOMEM);
+ if ((err = av_new_packet(pkt, audio_size)) < 0)
+ return err;
memcpy(pkt->data, c->packet + 1, pkt->size);
pkt->stream_index = 1;
pkt->pts = c->audio_pos;
} else
break;
}
- if (av_new_packet(pkt, c->size + 1) < 0)
- return AVERROR(ENOMEM);
+ if ((err = av_new_packet(pkt, c->size + 1)) < 0)
+ return err;
pkt->stream_index = 0;
c->get_next = 1;
memcpy(pkt->data, c->packet, pkt->size);
(32 + 4 + size) > (INT_MAX / par->channels) ||
(32 + 4 + size) * par->channels > INT_MAX - 8)
return AVERROR_INVALIDDATA;
- if (av_new_packet(pkt, 8 + (32 + 4 + size) * par->channels) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, 8 + (32 + 4 + size) * par->channels)) < 0)
+ return ret;
dst = pkt->data;
if (par->codec_id == AV_CODEC_ID_ADPCM_THP_LE) {
bytestream_put_le32(&dst, size * par->channels);
{
AVIOContext *pb = s->pb;
AVStream *st = s->streams[0];
+ int ret;
if (size < 0 || size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
return -1;
}
av_freep(&st->codecpar->extradata);
- if (ff_alloc_extradata(st->codecpar, ALAC_HEADER))
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(st->codecpar, ALAC_HEADER)) < 0)
+ return ret;
/* For the old style cookie, we skip 12 bytes, then read 36 bytes.
* The new style cookie only contains the last 24 bytes of what was
avio_skip(pb, size);
} else {
av_freep(&st->codecpar->extradata);
- if (ff_get_extradata(s, st->codecpar, pb, size) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = ff_get_extradata(s, st->codecpar, pb, size)) < 0)
+ return ret;
}
return 0;
avpriv_set_pts_info(st, 64, 1, cdxl->sample_rate);
}
- if (av_new_packet(pkt, video_size + CDXL_HEADER_SIZE) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, video_size + CDXL_HEADER_SIZE)) < 0)
+ return ret;
memcpy(pkt->data, cdxl->header, CDXL_HEADER_SIZE);
ret = avio_read(pb, pkt->data + CDXL_HEADER_SIZE, video_size);
if (ret < 0) {
{
AVIOContext *pb = s->pb;
AVStream *st;
- int frames;
+ int frames, ret;
int version;
uint32_t mspf;
avio_skip(pb, 128 - 16); // padding
st->duration = frames;
- if (ff_alloc_extradata(st->codecpar, 2))
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(st->codecpar, 2)) < 0)
+ return ret;
AV_WL16(st->codecpar->extradata, version);
if (version == 0x100)
st->sample_aspect_ratio = (AVRational){2, 1};
if (packet_size <= 0 || skip_size <= 0)
return AVERROR_INVALIDDATA;
- if (av_new_packet(pkt, packet_size) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, packet_size)) < 0)
+ return ret;
dst = pkt->data;
for (ch = 0; ch < st->codecpar->channels; ch++) {
ret = avio_read(pb, dst, packet_size / st->codecpar->channels);
tag = AV_RL32(buf);
switch (tag) {
case MKTAG('N', 'U', 'L', 'L'):
- if(av_new_packet(pkt, 4 + pal_size) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, 4 + pal_size)) < 0)
+ return ret;
pkt->stream_index = 0;
if(pal_size) memcpy(pkt->data, pal, pal_size);
memcpy(pkt->data + pal_size, buf, 4);
size);
return AVERROR_INVALIDDATA;
}
- if(av_new_packet(pkt, size + DXA_EXTRA_SIZE + pal_size) < 0)
- return AVERROR(ENOMEM);
+ ret = av_new_packet(pkt, size + DXA_EXTRA_SIZE + pal_size);
+ if (ret < 0)
+ return ret;
memcpy(pkt->data + pal_size, buf, DXA_EXTRA_SIZE);
ret = avio_read(s->pb, pkt->data + DXA_EXTRA_SIZE + pal_size, size);
if(ret != size){
AVIOContext *pb = s->pb;
unsigned char header[FLIC_HEADER_SIZE];
AVStream *st, *ast;
- int speed;
+ int speed, ret;
int magic_number;
unsigned char preamble[FLIC_PREAMBLE_SIZE];
}
/* send over the whole 128-byte FLIC header */
- if (ff_alloc_extradata(st->codecpar, FLIC_HEADER_SIZE))
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(st->codecpar, FLIC_HEADER_SIZE)) < 0)
+ return ret;
memcpy(st->codecpar->extradata, header, FLIC_HEADER_SIZE);
/* peek at the preamble to detect TFTD videos - they seem to always start with an audio chunk */
/* send over abbreviated FLIC header chunk */
av_freep(&st->codecpar->extradata);
- if (ff_alloc_extradata(st->codecpar, 12))
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(st->codecpar, 12)) < 0)
+ return ret;
memcpy(st->codecpar->extradata, header, 12);
} else if (magic_number == FLIC_FILE_MAGIC_1) {
static int flv_get_extradata(AVFormatContext *s, AVStream *st, int size)
{
+ int ret;
if (!size)
return 0;
av_freep(&st->codecpar->extradata);
- if (ff_get_extradata(s, st->codecpar, s->pb, size) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = ff_get_extradata(s, st->codecpar, s->pb, size)) < 0)
+ return ret;
st->internal->need_context_update = 1;
return 0;
}
int64_t offset;
AVCodecParameters *par;
AVStream *st = avformat_new_stream(s, NULL);
+ int ret;
avio_skip(pb, 3); // "FSB"
version = avio_r8(pb) - '0';
par->block_align = 8 * par->channels;
if (par->channels > INT_MAX / 32)
return AVERROR_INVALIDDATA;
- ff_alloc_extradata(par, 32 * par->channels);
- if (!par->extradata)
- return AVERROR(ENOMEM);
+ ret = ff_alloc_extradata(par, 32 * par->channels);
+ if (ret < 0)
+ return ret;
avio_seek(pb, 0x68, SEEK_SET);
for (c = 0; c < par->channels; c++) {
avio_read(pb, par->extradata + 32 * c, 32);
switch (par->codec_id) {
case AV_CODEC_ID_XMA2:
- ff_alloc_extradata(par, 34);
- if (!par->extradata)
- return AVERROR(ENOMEM);
+ ret = ff_alloc_extradata(par, 34);
+ if (ret < 0)
+ return ret;
memset(par->extradata, 0, 34);
par->block_align = 2048;
break;
case AV_CODEC_ID_ADPCM_THP:
if (par->channels > INT_MAX / 32)
return AVERROR_INVALIDDATA;
- ff_alloc_extradata(par, 32 * par->channels);
- if (!par->extradata)
- return AVERROR(ENOMEM);
+ ret = ff_alloc_extradata(par, 32 * par->channels);
+ if (ret < 0)
+ return ret;
avio_seek(pb, 0x80, SEEK_SET);
for (c = 0; c < par->channels; c++) {
avio_read(pb, par->extradata + 32 * c, 32);
static int id3v2_put_ttag(ID3v2EncContext *id3, AVIOContext *avioc, const char *str1, const char *str2,
uint32_t tag, enum ID3v2Encoding enc)
{
- int len;
+ int len, ret;
uint8_t *pb;
AVIOContext *dyn_buf;
- if (avio_open_dyn_buf(&dyn_buf) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = avio_open_dyn_buf(&dyn_buf)) < 0)
+ return ret;
/* check if the strings are ASCII-only and use UTF16 only if
* they're not */
*/
static int id3v2_put_priv(ID3v2EncContext *id3, AVIOContext *avioc, const char *key, const char *data)
{
- int len;
+ int len, ret;
uint8_t *pb;
AVIOContext *dyn_buf;
return 0;
}
- if (avio_open_dyn_buf(&dyn_buf) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = avio_open_dyn_buf(&dyn_buf)) < 0)
+ return ret;
// owner + null byte.
avio_write(dyn_buf, key, strlen(key) + 1);
const char *mimetype = NULL, *desc = "";
int enc = id3->version == 3 ? ID3v2_ENCODING_UTF16BOM :
ID3v2_ENCODING_UTF8;
- int i, len, type = 0;
+ int i, len, type = 0, ret;
/* get the mimetype*/
while (mime->id != AV_CODEC_ID_NONE) {
enc = ID3v2_ENCODING_ISO8859;
/* start writing */
- if (avio_open_dyn_buf(&dyn_buf) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = avio_open_dyn_buf(&dyn_buf)) < 0)
+ return ret;
avio_w8(dyn_buf, enc);
avio_put_str(dyn_buf, mimetype);
JVDemuxContext *jv = s->priv_data;
AVIOContext *pb = s->pb;
AVStream *ast = s->streams[0];
+ int ret;
while (!avio_feof(s->pb) && jv->pts < ast->nb_index_entries) {
const AVIndexEntry *e = ast->index_entries + jv->pts;
case JV_AUDIO:
jv->state++;
if (jvf->audio_size) {
- if (av_get_packet(s->pb, pkt, jvf->audio_size) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_get_packet(s->pb, pkt, jvf->audio_size)) < 0)
+ return ret;
pkt->stream_index = 0;
pkt->pts = e->timestamp;
pkt->flags |= AV_PKT_FLAG_KEY;
case JV_VIDEO:
jv->state++;
if (jvf->video_size || jvf->palette_size) {
- int ret;
int size = jvf->video_size + jvf->palette_size;
- if (av_new_packet(pkt, size + JV_PREAMBLE_SIZE))
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, size + JV_PREAMBLE_SIZE)) < 0)
+ return ret;
AV_WL32(pkt->data, jvf->video_size);
pkt->data[4] = jvf->video_type;
static int modplug_read_packet(AVFormatContext *s, AVPacket *pkt)
{
ModPlugContext *modplug = s->priv_data;
+ int ret;
if (modplug->video_stream) {
modplug->video_switch ^= 1; // one video packet for one audio packet
var_values[VAR_PATTERN] = ModPlug_GetCurrentPattern(modplug->f);
var_values[VAR_ROW ] = ModPlug_GetCurrentRow (modplug->f);
- if (av_new_packet(pkt, modplug->fsize) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, modplug->fsize)) < 0)
+ return ret;
pkt->stream_index = 1;
memset(pkt->data, 0, modplug->fsize);
}
}
- if (av_new_packet(pkt, AUDIO_PKT_SIZE) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, AUDIO_PKT_SIZE)) < 0)
+ return ret;
if (modplug->video_stream)
pkt->pts = pkt->dts = modplug->packet_count++ * modplug->ts_per_packet;
AVIOContext *pb = s->pb;
unsigned char preamble[MM_PREAMBLE_SIZE];
unsigned int type, length;
+ int ret;
while(1) {
case MM_TYPE_INTRA_HHV :
case MM_TYPE_INTER_HHV :
/* output preamble + data */
- if (av_new_packet(pkt, length + MM_PREAMBLE_SIZE))
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, length + MM_PREAMBLE_SIZE)) < 0)
+ return ret;
memcpy(pkt->data, preamble, MM_PREAMBLE_SIZE);
if (avio_read(pb, pkt->data + MM_PREAMBLE_SIZE, length) != length)
return AVERROR(EIO);
return 0;
case MM_TYPE_AUDIO :
- if (av_get_packet(s->pb, pkt, length)<0)
- return AVERROR(ENOMEM);
+ if ((ret = av_get_packet(s->pb, pkt, length)) < 0)
+ return ret;
pkt->stream_index = 1;
pkt->pts = mm->audio_pts++;
return 0;
static int mov_read_dops(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
const int OPUS_SEEK_PREROLL_MS = 80;
+ int ret;
AVStream *st;
size_t size;
uint16_t pre_skip;
/* OpusSpecificBox size plus magic for Ogg OpusHead header. */
size = atom.size + 8;
- if (ff_alloc_extradata(st->codecpar, size))
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
+ return ret;
AV_WL32(st->codecpar->extradata, MKTAG('O','p','u','s'));
AV_WL32(st->codecpar->extradata + 4, MKTAG('H','e','a','d'));
MPCContext *c = s->priv_data;
AVIOContext *pb = s->pb;
AVStream *st;
- int tag = 0;
+ int tag = 0, ret;
int64_t size, pos;
c->header_pos = avio_tell(pb);
st->codecpar->codec_id = AV_CODEC_ID_MUSEPACK8;
st->codecpar->bits_per_coded_sample = 16;
- if (ff_get_extradata(s, st->codecpar, pb, 2) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = ff_get_extradata(s, st->codecpar, pb, 2)) < 0)
+ return ret;
st->codecpar->channels = (st->codecpar->extradata[1] >> 4) + 1;
st->codecpar->sample_rate = mpc8_rate[st->codecpar->extradata[0] >> 5];
static int mpc8_read_packet(AVFormatContext *s, AVPacket *pkt)
{
MPCContext *c = s->priv_data;
- int tag;
+ int tag, ret;
int64_t pos, size;
while(!avio_feof(s->pb)){
if (size < 0)
return -1;
if(tag == TAG_AUDIOPACKET){
- if(av_get_packet(s->pb, pkt, size) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_get_packet(s->pb, pkt, size)) < 0)
+ return ret;
pkt->stream_index = 0;
pkt->duration = 1;
return 0;
case 0x56: /* DVB teletext descriptor */
{
uint8_t *extradata = NULL;
- int language_count = desc_len / 5;
+ int language_count = desc_len / 5, ret;
if (desc_len > 0 && desc_len % 5 != 0)
return AVERROR_INVALIDDATA;
av_assert0(language_count <= sizeof(language) / 4);
if (st->codecpar->extradata == NULL) {
- if (ff_alloc_extradata(st->codecpar, language_count * 2)) {
- return AVERROR(ENOMEM);
- }
+ ret = ff_alloc_extradata(st->codecpar, language_count * 2);
+ if (ret < 0)
+ return ret;
}
if (st->codecpar->extradata_size < language_count * 2)
* subtitling_type (1 byte),
* composition_page_id (2 bytes),
* ancillary_page_id (2 bytes) */
- int language_count = desc_len / 8;
+ int language_count = desc_len / 8, ret;
if (desc_len > 0 && desc_len % 8 != 0)
return AVERROR_INVALIDDATA;
av_assert0(language_count <= sizeof(language) / 4);
if (st->codecpar->extradata == NULL) {
- if (ff_alloc_extradata(st->codecpar, language_count * 5)) {
- return AVERROR(ENOMEM);
- }
+ ret = ff_alloc_extradata(st->codecpar, language_count * 5);
+ if (ret < 0)
+ return ret;
}
if (st->codecpar->extradata_size < language_count * 5)
uint8_t pcr_buf[12];
const uint8_t *data;
- if (av_new_packet(pkt, TS_PACKET_SIZE) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, TS_PACKET_SIZE)) < 0)
+ return ret;
ret = read_packet(s, pkt->data, ts->raw_packet_size, &data);
pkt->pos = avio_tell(s->pb);
if (ret < 0) {
ret = avio_open_dyn_buf(&ts_st->amux->pb);
if (ret < 0)
- return AVERROR(ENOMEM);
+ return ret;
ret = av_write_frame(ts_st->amux, &pkt2);
if (ret < 0) {
AVIOContext *pb = s->pb;
AVStream *ast, *vst;
unsigned int version, frames_count, msecs_per_frame, player_version;
+ int ret;
ast = avformat_new_stream(s, NULL);
if (!ast)
if (!vst)
return AVERROR(ENOMEM);
- if (ff_alloc_extradata(vst->codecpar, 2))
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(vst->codecpar, 2)) < 0)
+ return ret;
version = avio_r8(pb);
vst->codecpar->extradata[0] = avio_r8(pb);
GET_V(st->codecpar->extradata_size, tmp < (1 << 30));
if (st->codecpar->extradata_size) {
- if (ff_get_extradata(s, st->codecpar, bc, st->codecpar->extradata_size) < 0)
- return AVERROR(ENOMEM);
+ ret = ff_get_extradata(s, st->codecpar, bc,
+ st->codecpar->extradata_size);
+ if (ret < 0)
+ return ret;
}
if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
if (!vst && !myth)
return 1; // no codec data needed
while (!avio_feof(pb)) {
- int size, subtype;
+ int size, subtype, ret;
frametype = avio_r8(pb);
switch (frametype) {
av_freep(&vst->codecpar->extradata);
vst->codecpar->extradata_size = 0;
}
- if (ff_get_extradata(NULL, vst->codecpar, pb, size) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = ff_get_extradata(NULL, vst->codecpar, pb, size)) < 0)
+ return ret;
size = 0;
if (!myth)
return 0;
AVStream *st = s->streams[idx];
struct oggcelt_private *priv = os->private;
uint8_t *p = os->buf + os->pstart;
+ int ret;
if (os->psize == 60 &&
!memcmp(p, ff_celt_codec.magic, ff_celt_codec.magicsize)) {
priv = av_malloc(sizeof(struct oggcelt_private));
if (!priv)
return AVERROR(ENOMEM);
- if (ff_alloc_extradata(st->codecpar, 2 * sizeof(uint32_t)) < 0) {
+ ret = ff_alloc_extradata(st->codecpar, 2 * sizeof(uint32_t));
+ if (ret < 0) {
av_free(priv);
- return AVERROR(ENOMEM);
+ return ret;
}
version = AV_RL32(p + 28);
/* unused header size field skipped */
struct ogg_stream *os = ogg->streams + idx;
AVStream *st = s->streams[idx];
GetBitContext gb;
- int mdt;
+ int mdt, ret;
if (os->buf[os->pstart] == 0xff)
return 0;
st->codecpar->codec_id = AV_CODEC_ID_FLAC;
st->need_parsing = AVSTREAM_PARSE_HEADERS;
- if (ff_alloc_extradata(st->codecpar, FLAC_STREAMINFO_SIZE) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(st->codecpar, FLAC_STREAMINFO_SIZE)) < 0)
+ return ret;
memcpy(st->codecpar->extradata, streaminfo_start, st->codecpar->extradata_size);
samplerate = AV_RB24(st->codecpar->extradata + 10) >> 4;
uint64_t time_unit;
uint64_t spu;
uint32_t size;
+ int ret;
bytestream2_init(&p, os->buf + os->pstart, os->psize);
if (!(bytestream2_peek_byte(&p) & 1))
if (bytestream2_get_bytes_left(&p) < size)
return AVERROR_INVALIDDATA;
av_freep(&st->codecpar->extradata);
- if (ff_alloc_extradata(st->codecpar, size) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
+ return ret;
bytestream2_get_buffer(&p, st->codecpar->extradata, st->codecpar->extradata_size);
}
}
AVStream *st = avf->streams[idx];
struct oggopus_private *priv = os->private;
uint8_t *packet = os->buf + os->pstart;
+ int ret;
if (!priv) {
priv = os->private = av_mallocz(sizeof(*priv));
/*channel_map = AV_RL8 (packet + 18);*/
av_freep(&st->codecpar->extradata);
- if (ff_alloc_extradata(st->codecpar, os->psize))
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(st->codecpar, os->psize)) < 0)
+ return ret;
memcpy(st->codecpar->extradata, packet, os->psize);
struct speex_params *spxp = os->private;
AVStream *st = s->streams[idx];
uint8_t *p = os->buf + os->pstart;
+ int ret;
if (!spxp) {
spxp = av_mallocz(sizeof(*spxp));
if (frames_per_packet)
spxp->packet_size *= frames_per_packet;
- if (ff_alloc_extradata(st->codecpar, os->psize) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(st->codecpar, os->psize)) < 0)
+ return ret;
memcpy(st->codecpar->extradata, p, st->codecpar->extradata_size);
avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
/* fake the ATRAC3 extradata
* (wav format, makes stream copy to wav work) */
- if (ff_alloc_extradata(st->codecpar, 14))
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(st->codecpar, 14)) < 0)
+ return ret;
edata = st->codecpar->extradata;
AV_WL16(&edata[0], 1); // always 1
PAFDemuxContext *p = s->priv_data;
AVIOContext *pb = s->pb;
uint32_t count, offset;
- int size, i;
+ int size, i, ret;
if (p->current_frame >= p->nb_frames)
return AVERROR_EOF;
return AVERROR_EOF;
if (p->got_audio) {
- if (av_new_packet(pkt, p->audio_size) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, p->audio_size)) < 0)
+ return ret;
memcpy(pkt->data, p->temp_audio_frame, p->audio_size);
pkt->duration = PAF_SOUND_SAMPLES * (p->audio_size / PAF_SOUND_FRAME_SIZE);
size = p->video_size - p->frames_offset_table[p->current_frame];
- if (av_new_packet(pkt, size) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, size)) < 0)
+ return ret;
pkt->stream_index = 0;
pkt->duration = 1;
size = raw->raw_packet_size;
- if (av_new_packet(pkt, size) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, size)) < 0)
+ return ret;
pkt->pos= avio_tell(s->pb);
pkt->stream_index = 0;
if(signature == RLV3_TAG && back_size > 0)
st->codecpar->extradata_size += back_size;
- if(ff_get_extradata(s, st->codecpar, pb, st->codecpar->extradata_size) < 0)
- return AVERROR(ENOMEM);
+ ret = ff_get_extradata(s, st->codecpar, pb, st->codecpar->extradata_size);
+ if (ret < 0)
+ return ret;
/** setup audio stream if present */
if(sound_rate){
av_log(s, AV_LOG_ERROR, "extradata size %u too large\n", size);
return -1;
}
- if (ff_get_extradata(s, par, pb, size) < 0)
- return AVERROR(ENOMEM);
- return 0;
+ return ff_get_extradata(s, par, pb, size);
}
static void rm_read_metadata(AVFormatContext *s, AVIOContext *pb, int wide)
switch (par->codec_id) {
case AV_CODEC_ID_XMA2:
par->block_align = 2048;
- ff_alloc_extradata(par, 34);
- if (!par->extradata)
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(par, 34)) < 0)
+ return ret;
memset(par->extradata, 0, 34);
break;
case AV_CODEC_ID_ADPCM_PSX:
av_log(ctx, AV_LOG_ERROR, "Invalid AC3 packet data\n");
return AVERROR_INVALIDDATA;
}
- if (av_new_packet(pkt, len)) {
+ if ((err = av_new_packet(pkt, len)) < 0) {
av_log(ctx, AV_LOG_ERROR, "Out of memory.\n");
- return AVERROR(ENOMEM);
+ return err;
}
pkt->stream_index = st->index;
{
const uint8_t *frame_sizes = NULL;
int frames;
- int i;
+ int i, ret;
const uint8_t *speech_data;
uint8_t *ptr;
speech_data = buf + 1 + frames;
/* Everything except the codec mode request byte should be output. */
- if (av_new_packet(pkt, len - 1)) {
+ if ((ret = av_new_packet(pkt, len - 1)) < 0) {
av_log(ctx, AV_LOG_ERROR, "Out of memory\n");
- return AVERROR(ENOMEM);
+ return ret;
}
pkt->stream_index = st->index;
ptr = pkt->data;
{
uint8_t *ptr;
uint16_t header;
- int startcode, vrc, picture_header;
+ int startcode, vrc, picture_header, ret;
if (len < 2) {
av_log(ctx, AV_LOG_ERROR, "Too short H.263 RTP packet\n");
return AVERROR_INVALIDDATA;
}
- if (av_new_packet(pkt, len + startcode)) {
+ if ((ret = av_new_packet(pkt, len + startcode)) < 0) {
av_log(ctx, AV_LOG_ERROR, "Out of memory\n");
- return AVERROR(ENOMEM);
+ return ret;
}
pkt->stream_index = st->index;
ptr = pkt->data;
goto end;
}
av_freep(&st->codecpar->extradata);
- if (ff_alloc_extradata(st->codecpar, (get_bits_left(&gb) + 7)/8)) {
- ret = AVERROR(ENOMEM);
+ ret = ff_alloc_extradata(st->codecpar, (get_bits_left(&gb) + 7)/8);
+ if (ret < 0) {
goto end;
}
for (i = 0; i < st->codecpar->extradata_size; i++)
return AVERROR_INVALIDDATA;
}
- if (av_new_packet(pkt, adu_size)) {
+ if ((err = av_new_packet(pkt, adu_size)) < 0) {
av_log(ctx, AV_LOG_ERROR, "Out of memory.\n");
- return AVERROR(ENOMEM);
+ return err;
}
pkt->stream_index = st->index;
if (!continuation && adu_size <= len) {
/* One or more complete frames */
- if (av_new_packet(pkt, adu_size)) {
+ if ((err = av_new_packet(pkt, adu_size)) < 0) {
av_log(ctx, AV_LOG_ERROR, "Out of memory.\n");
- return AVERROR(ENOMEM);
+ return err;
}
pkt->stream_index = st->index;
int flags)
{
unsigned int h;
+ int ret;
if (len <= 4)
return AVERROR_INVALIDDATA;
h = AV_RB32(buf);
buf += 4;
len -= 4;
}
- if (av_new_packet(pkt, len) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, len)) < 0)
+ return ret;
memcpy(pkt->data, buf, len);
pkt->stream_index = st->index;
return 0;
static int parse_fmtp_config(AVCodecParameters *par, const char *value)
{
/* decode the hexa encoded parameter */
- int len = ff_hex_to_data(NULL, value);
+ int len = ff_hex_to_data(NULL, value), ret;
av_freep(&par->extradata);
- if (ff_alloc_extradata(par, len))
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(par, len)) < 0)
+ return ret;
ff_hex_to_data(par->extradata, value);
return 0;
}
const uint8_t *buf, const uint8_t *end)
{
const uint8_t *p = buf;
+ int ret;
while (end - p >= 2) {
unsigned int item_len = p[0], config_item = p[1];
if (item_len < 30)
return AVERROR_INVALIDDATA;
av_freep(&st->codecpar->extradata);
- if (ff_alloc_extradata(st->codecpar, 26 + item_len)) {
- return AVERROR(ENOMEM);
+ ret = ff_alloc_extradata(st->codecpar, 26 + item_len);
+ if (ret < 0) {
+ return ret;
}
AV_WB32(st->codecpar->extradata, 12);
memcpy(st->codecpar->extradata + 4, "frma", 4);
GetBitContext gb;
int packing_scheme, has_payload_desc, has_packet_info, alen,
has_marker_bit = flags & RTP_FLAG_MARKER,
- keyframe;
+ keyframe, ret;
if (qt->remaining) {
int num = qt->pkt.size / qt->bytes_per_frame;
- if (av_new_packet(pkt, qt->bytes_per_frame))
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, qt->bytes_per_frame)) < 0)
+ return ret;
pkt->stream_index = st->index;
pkt->flags = qt->pkt.flags;
memcpy(pkt->data,
alen % qt->bytes_per_frame != 0)
return AVERROR_INVALIDDATA; /* wrongly padded */
qt->remaining = (alen / qt->bytes_per_frame) - 1;
- if (av_new_packet(pkt, qt->bytes_per_frame))
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, qt->bytes_per_frame)) < 0)
+ return ret;
memcpy(pkt->data, buf + avio_tell(&pb), qt->bytes_per_frame);
pkt->flags = keyframe ? AV_PKT_FLAG_KEY : 0;
pkt->stream_index = st->index;
int flags)
{
- int ident, fragmented, tdt, num_pkts, pkt_len;
+ int ident, fragmented, tdt, num_pkts, pkt_len, ret;
if (!buf) {
if (!data->split_buf || data->split_pos + 2 > data->split_buf_len ||
av_log(ctx, AV_LOG_ERROR, "Not enough data to return\n");
return AVERROR_INVALIDDATA;
}
- if (av_new_packet(pkt, pkt_len)) {
+ if ((ret = av_new_packet(pkt, pkt_len)) < 0) {
av_log(ctx, AV_LOG_ERROR, "Out of memory.\n");
- return AVERROR(ENOMEM);
+ return ret;
}
pkt->stream_index = st->index;
memcpy(pkt->data, data->split_buf + data->split_pos, pkt_len);
len -= 6;
if (fragmented == 0) {
- if (av_new_packet(pkt, pkt_len)) {
+ if ((ret = av_new_packet(pkt, pkt_len)) < 0) {
av_log(ctx, AV_LOG_ERROR, "Out of memory.\n");
- return AVERROR(ENOMEM);
+ return ret;
}
pkt->stream_index = st->index;
memcpy(pkt->data, buf, pkt_len);
{
unsigned num_packed, num_headers, length, length1, length2, extradata_alloc;
+ int ret;
uint8_t *ptr;
if (packed_headers_end - packed_headers < 9) {
* -- AV_INPUT_BUFFER_PADDING_SIZE required */
extradata_alloc = length + length/255 + 3 + AV_INPUT_BUFFER_PADDING_SIZE;
- if (ff_alloc_extradata(par, extradata_alloc)) {
+ if ((ret = ff_alloc_extradata(par, extradata_alloc)) < 0) {
av_log(s, AV_LOG_ERROR, "Out of memory\n");
- return AVERROR(ENOMEM);
+ return ret;
}
ptr = par->extradata;
*ptr++ = 2;
static int encode_intervals(struct sbg_script *s, AVCodecParameters *par,
struct ws_intervals *inter)
{
- int i, edata_size = 4;
+ int i, edata_size = 4, ret;
uint8_t *edata;
for (i = 0; i < inter->nb_inter; i++) {
if (edata_size < 0)
return AVERROR(ENOMEM);
}
- if (ff_alloc_extradata(par, edata_size))
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(par, edata_size)) < 0)
+ return ret;
edata = par->extradata;
#define ADD_EDATA32(v) do { AV_WL32(edata, (v)); edata += 4; } while(0)
static int sbg_read_packet(AVFormatContext *avf, AVPacket *packet)
{
int64_t ts, end_ts;
+ int ret;
ts = avf->streams[0]->cur_dts;
end_ts = ts + avf->streams[0]->codecpar->frame_size;
end_ts);
if (end_ts <= ts)
return AVERROR_EOF;
- if (av_new_packet(packet, 12) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(packet, 12)) < 0)
+ return ret;
packet->dts = packet->pts = ts;
packet->duration = end_ts - ts;
AV_WL64(packet->data + 0, ts);
avio_skip(s->pb, 30);
if (pos == FIRST) {
- if (av_new_packet(pkt, next - 52 + 24) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, next - 52 + 24)) < 0)
+ return ret;
memcpy(pkt->data, header, 24);
ret = avio_read(s->pb, pkt->data + 24, next - 52);
if (ret < 0) {
vst->codecpar->width >>= 1;
vst->codecpar->height >>= 1;
}
- if (ff_alloc_extradata(vst->codecpar, VMD_HEADER_SIZE))
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(vst->codecpar, VMD_HEADER_SIZE)) < 0)
+ return ret;
memcpy(vst->codecpar->extradata, vmd->vmd_header, VMD_HEADER_SIZE);
}
if(ffio_limit(pb, frame->frame_size) != frame->frame_size)
return AVERROR(EIO);
- if (av_new_packet(pkt, frame->frame_size + BYTES_PER_FRAME_RECORD))
- return AVERROR(ENOMEM);
+ ret = av_new_packet(pkt, frame->frame_size + BYTES_PER_FRAME_RECORD);
+ if (ret < 0)
+ return ret;
pkt->pos= avio_tell(pb);
memcpy(pkt->data, frame->frame_record, BYTES_PER_FRAME_RECORD);
if(vmd->is_indeo3 && frame->frame_record[0] == 0x02)
static int siff_read_packet(AVFormatContext *s, AVPacket *pkt)
{
SIFFContext *c = s->priv_data;
+ int ret;
if (c->has_video) {
unsigned int size;
size = c->pktsize - c->sndsize - c->gmcsize - 2;
size = ffio_limit(s->pb, size);
- if (av_new_packet(pkt, size + c->gmcsize + 2) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, size + c->gmcsize + 2)) < 0)
+ return ret;
AV_WL16(pkt->data, c->flags);
if (c->gmcsize)
memcpy(pkt->data + 2, c->gmc, c->gmcsize);
/* load trees to extradata, they will be unpacked by decoder */
- if(ff_alloc_extradata(st->codecpar, smk->treesize + 16)){
+ if ((ret = ff_alloc_extradata(st->codecpar, smk->treesize + 16)) < 0) {
av_log(s, AV_LOG_ERROR,
"Cannot allocate %"PRIu32" bytes of extradata\n",
smk->treesize + 16);
av_freep(&smk->frm_size);
av_freep(&smk->frm_flags);
- return AVERROR(ENOMEM);
+ return ret;
}
ret = avio_read(pb, st->codecpar->extradata + 16, st->codecpar->extradata_size - 16);
if(ret != st->codecpar->extradata_size - 16){
}
if (frame_size < 0 || frame_size >= INT_MAX/2)
return AVERROR_INVALIDDATA;
- if (av_new_packet(pkt, frame_size + 769))
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, frame_size + 769)) < 0)
+ return ret;
if(smk->frm_size[smk->cur_frame] & 1)
palchange |= 2;
pkt->data[0] = palchange;
} else {
if (smk->stream_id[smk->curstream] < 0 || !smk->bufs[smk->curstream])
return AVERROR_INVALIDDATA;
- if (av_new_packet(pkt, smk->buf_sizes[smk->curstream]))
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, smk->buf_sizes[smk->curstream])) < 0)
+ return ret;
memcpy(pkt->data, smk->bufs[smk->curstream], smk->buf_sizes[smk->curstream]);
pkt->size = smk->buf_sizes[smk->curstream];
pkt->stream_index = smk->stream_id[smk->curstream];
uint32_t magic, nframes, size, subversion, i;
uint32_t width = 0, height = 0, got_audio = 0, read = 0;
uint32_t sample_rate, channels, palette[256];
+ int ret;
magic = avio_rb32(pb);
avio_skip(pb, 4); // skip movie size
vst->codecpar->height = height;
if (!smush->version) {
- if (ff_alloc_extradata(vst->codecpar, 1024 + 2))
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(vst->codecpar, 1024 + 2)) < 0)
+ return ret;
AV_WL16(vst->codecpar->extradata, subversion);
for (i = 0; i < 256; i++)
int ff_subtitles_queue_read_packet(FFDemuxSubtitlesQueue *q, AVPacket *pkt)
{
AVPacket *sub = q->subs + q->current_sub_idx;
+ int ret;
if (q->current_sub_idx == q->nb_subs)
return AVERROR_EOF;
- if (av_packet_ref(pkt, sub) < 0) {
- return AVERROR(ENOMEM);
+ if ((ret = av_packet_ref(pkt, sub)) < 0) {
+ return ret;
}
pkt->dts = pkt->pts;
/* video packet */
if (seq->current_pal_data_size + seq->current_video_data_size != 0) {
- if (av_new_packet(pkt, 1 + seq->current_pal_data_size + seq->current_video_data_size))
- return AVERROR(ENOMEM);
+ rc = av_new_packet(pkt, 1 + seq->current_pal_data_size
+ + seq->current_video_data_size);
+ if (rc < 0)
+ return rc;
pkt->data[0] = 0;
if (seq->current_pal_data_size) {
TYDemuxContext *ty = s->priv_data;
const int subrec_type = rec_hdr->subrec_type;
const int64_t rec_size = rec_hdr->rec_size;
- int es_offset1;
+ int es_offset1, ret;
int got_packet = 0;
if (subrec_type != 0x02 && subrec_type != 0x0c &&
int size = rec_hdr->rec_size - VIDEO_PES_LENGTH - es_offset1;
ty->cur_chunk_pos += VIDEO_PES_LENGTH + es_offset1;
- if (av_new_packet(pkt, size) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, size)) < 0)
+ return ret;
memcpy(pkt->data, ty->chunk + ty->cur_chunk_pos, size);
ty->cur_chunk_pos += size;
pkt->stream_index = 0;
}
if (!got_packet) {
- if (av_new_packet(pkt, rec_size) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, rec_size)) < 0)
+ return ret;
memcpy(pkt->data, ty->chunk + ty->cur_chunk_pos, rec_size);
ty->cur_chunk_pos += rec_size;
pkt->stream_index = 0;
TYDemuxContext *ty = s->priv_data;
const int subrec_type = rec_hdr->subrec_type;
const int64_t rec_size = rec_hdr->rec_size;
- int es_offset1;
+ int es_offset1, ret;
if (subrec_type == 2) {
int need = 0;
ty->pes_buf_cnt = 0;
}
- if (av_new_packet(pkt, rec_size - need) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, rec_size - need)) < 0)
+ return ret;
memcpy(pkt->data, ty->chunk + ty->cur_chunk_pos, rec_size - need);
ty->cur_chunk_pos += rec_size - need;
pkt->stream_index = 1;
}
}
} else if (subrec_type == 0x03) {
- if (av_new_packet(pkt, rec_size) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, rec_size)) < 0)
+ return ret;
memcpy(pkt->data, ty->chunk + ty->cur_chunk_pos, rec_size);
ty->cur_chunk_pos += rec_size;
pkt->stream_index = 1;
} else if (subrec_type == 0x04) {
/* SA Audio with no PES Header */
/* ================================================ */
- if (av_new_packet(pkt, rec_size) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, rec_size)) < 0)
+ return ret;
memcpy(pkt->data, ty->chunk + ty->cur_chunk_pos, rec_size);
ty->cur_chunk_pos += rec_size;
pkt->stream_index = 1;
pkt->pts = ty->last_audio_pts;
} else if (subrec_type == 0x09) {
- if (av_new_packet(pkt, rec_size) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, rec_size)) < 0)
+ return ret;
memcpy(pkt->data, ty->chunk + ty->cur_chunk_pos, rec_size);
ty->cur_chunk_pos += rec_size ;
pkt->stream_index = 1;
};
const uint8_t *data = NULL;
- int size = 0;
+ int ret, size = 0;
if (st->codecpar->width == 1920) {
if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
return 0;
av_freep(&st->codecpar->extradata);
- if (ff_alloc_extradata(st->codecpar, size))
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
+ return ret;
memcpy(st->codecpar->extradata, data, size);
return 0;
{
AVIOContext *pb = s->pb;
AVStream *st;
- int frames;
+ int frames, ret;
uint32_t fps;
uint32_t size;
st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codecpar->codec_id = AV_CODEC_ID_WMV3;
- if (ff_get_extradata(s, st->codecpar, pb, VC1_EXTRADATA_SIZE) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = ff_get_extradata(s, st->codecpar, pb, VC1_EXTRADATA_SIZE)) < 0)
+ return ret;
avio_skip(pb, size - 4);
st->codecpar->height = avio_rl32(pb);
static int track_header(VividasDemuxContext *viv, AVFormatContext *s, uint8_t *buf, int size)
{
- int i,j;
+ int i, j, ret;
int64_t off;
int val_1;
int num_video;
xd_size += len;
}
- st->codecpar->extradata_size = 64 + xd_size + xd_size / 255;
- if (ff_alloc_extradata(st->codecpar, st->codecpar->extradata_size)) {
- return AVERROR(ENOMEM);
- }
+ ret = ff_alloc_extradata(st->codecpar, 64 + xd_size + xd_size / 255);
+ if (ret < 0)
+ return ret;
p = st->codecpar->extradata;
p[0] = 2;
int rate_flag = -1;
int header_size;
int read_bitrate = 0;
- int size;
+ int size, ret;
uint8_t comm_chunk[12];
if (!st)
avpriv_set_pts_info(st, 64, size, st->codecpar->sample_rate);
/* put first 12 bytes of COMM chunk in extradata */
- if (ff_alloc_extradata(st->codecpar, 12))
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(st->codecpar, 12)) < 0)
+ return ret;
memcpy(st->codecpar->extradata, comm_chunk, 12);
ff_metadata_conv_ctx(s, NULL, vqf_metadata_conv);
static int wav_parse_xma2_tag(AVFormatContext *s, int64_t size, AVStream **st)
{
AVIOContext *pb = s->pb;
- int version, num_streams, i, channels = 0;
+ int version, num_streams, i, channels = 0, ret;
if (size < 36)
return AVERROR_INVALIDDATA;
avio_seek(pb, -size, SEEK_CUR);
av_freep(&(*st)->codecpar->extradata);
- if (ff_get_extradata(s, (*st)->codecpar, pb, size) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = ff_get_extradata(s, (*st)->codecpar, pb, size)) < 0)
+ return ret;
return 0;
}
vst->codecpar->codec_id = AV_CODEC_ID_SMVJPEG;
vst->codecpar->width = avio_rl24(pb);
vst->codecpar->height = avio_rl24(pb);
- if (ff_alloc_extradata(vst->codecpar, 4)) {
+ if ((ret = ff_alloc_extradata(vst->codecpar, 4)) < 0) {
av_log(s, AV_LOG_ERROR, "Could not allocate extradata.\n");
- return AVERROR(ENOMEM);
+ return ret;
}
size = avio_rl24(pb);
wav->smv_data_ofs = avio_tell(pb) + (size - 5) * 3;
uint8_t scratch[VQA_PREAMBLE_SIZE];
uint32_t chunk_tag;
uint32_t chunk_size;
- int fps;
+ int fps, ret;
/* initialize the video decoder stream */
st = avformat_new_stream(s, NULL);
avio_seek(pb, 20, SEEK_SET);
/* the VQA header needs to go to the decoder */
- if (ff_get_extradata(s, st->codecpar, pb, VQA_HEADER_SIZE) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = ff_get_extradata(s, st->codecpar, pb, VQA_HEADER_SIZE)) < 0)
+ return ret;
header = st->codecpar->extradata;
st->codecpar->width = AV_RL16(&header[6]);
st->codecpar->height = AV_RL16(&header[8]);
break;
case SND2_TAG:
st->codecpar->codec_id = AV_CODEC_ID_ADPCM_IMA_WS;
- if (ff_alloc_extradata(st->codecpar, 2))
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(st->codecpar, 2)) < 0)
+ return ret;
AV_WL16(st->codecpar->extradata, wsvqa->version);
break;
}
}
pos = wc->pos;
- if (av_new_packet(pkt, wc->header.blocksize + WV_HEADER_SIZE) < 0)
- return AVERROR(ENOMEM);
+ if ((ret = av_new_packet(pkt, wc->header.blocksize + WV_HEADER_SIZE)) < 0)
+ return ret;
memcpy(pkt->data, wc->block_header, WV_HEADER_SIZE);
ret = avio_read(s->pb, pkt->data + WV_HEADER_SIZE, wc->header.blocksize);
if (ret != wc->header.blocksize) {
avpriv_request_sample(s, "Unexpected extradata (%d bytes)",
st->codecpar->extradata_size);
} else if (st->codecpar->codec_id == AV_CODEC_ID_WMAPRO) {
- if (ff_alloc_extradata(st->codecpar, 18))
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(st->codecpar, 18)) < 0)
+ return ret;
memset(st->codecpar->extradata, 0, st->codecpar->extradata_size);
st->codecpar->extradata[ 0] = st->codecpar->bits_per_coded_sample;
st->codecpar->extradata[14] = 224;
} else {
- if (ff_alloc_extradata(st->codecpar, 6))
- return AVERROR(ENOMEM);
+ if ((ret = ff_alloc_extradata(st->codecpar, 6)) < 0)
+ return ret;
memset(st->codecpar->extradata, 0, st->codecpar->extradata_size);
/* setup extradata with our experimentally obtained value */
projects / ffmpeg / commitdiff