Signed-off-by: Martin Storsjö <martin@martin.st>tags/n2.2-rc1
@@ -106,12 +106,17 @@ static int alloc_table(VLC *vlc, int size, int use_static) | |||
vlc->table_size += size; | |||
if (vlc->table_size > vlc->table_allocated) { | |||
int err; | |||
if (use_static) | |||
return AVERROR_BUG; | |||
vlc->table_allocated += (1 << vlc->bits); | |||
vlc->table = av_realloc(vlc->table, sizeof(VLC_TYPE) * 2 * vlc->table_allocated); | |||
if (!vlc->table) | |||
return AVERROR(ENOMEM); | |||
if ((err = av_reallocp(&vlc->table, | |||
sizeof(VLC_TYPE) * 2 * | |||
vlc->table_allocated)) < 0) { | |||
vlc->table_allocated = 0; | |||
vlc->table_size = 0; | |||
return err; | |||
} | |||
} | |||
return index; | |||
} | |||
@@ -178,7 +178,11 @@ static int tgv_decode_inter(TgvContext *s, AVFrame *frame, | |||
} | |||
if (num_blocks_packed > s->num_blocks_packed) { | |||
s->block_codebook = av_realloc(s->block_codebook, num_blocks_packed*16); | |||
int err; | |||
if ((err = av_reallocp(&s->block_codebook, num_blocks_packed * 16)) < 0) { | |||
s->num_blocks_packed = 0; | |||
return err; | |||
} | |||
s->num_blocks_packed = num_blocks_packed; | |||
} | |||
@@ -296,13 +296,13 @@ static int flashsv_decode_frame(AVCodecContext *avctx, void *data, | |||
/* the block size could change between frames, make sure the buffer | |||
* is large enough, if not, get a larger one */ | |||
if (s->block_size < s->block_width * s->block_height) { | |||
int tmpblock_size = 3 * s->block_width * s->block_height; | |||
int tmpblock_size = 3 * s->block_width * s->block_height, err; | |||
s->tmpblock = av_realloc(s->tmpblock, tmpblock_size); | |||
if (!s->tmpblock) { | |||
if ((err = av_reallocp(&s->tmpblock, tmpblock_size)) < 0) { | |||
s->block_size = 0; | |||
av_log(avctx, AV_LOG_ERROR, | |||
"Cannot allocate decompression buffer.\n"); | |||
return AVERROR(ENOMEM); | |||
return err; | |||
} | |||
if (s->ver == 2) { | |||
s->deflate_block_size = calc_deflate_block_size(tmpblock_size); | |||
@@ -311,12 +311,10 @@ static int flashsv_decode_frame(AVCodecContext *avctx, void *data, | |||
"Cannot determine deflate buffer size.\n"); | |||
return -1; | |||
} | |||
s->deflate_block = av_realloc(s->deflate_block, | |||
s->deflate_block_size); | |||
if (!s->deflate_block) { | |||
av_log(avctx, AV_LOG_ERROR, | |||
"Cannot allocate deflate buffer.\n"); | |||
return AVERROR(ENOMEM); | |||
if ((err = av_reallocp(&s->deflate_block, s->deflate_block_size)) < 0) { | |||
s->block_size = 0; | |||
av_log(avctx, AV_LOG_ERROR, "Cannot allocate deflate buffer.\n"); | |||
return err; | |||
} | |||
} | |||
} | |||
@@ -340,11 +338,13 @@ static int flashsv_decode_frame(AVCodecContext *avctx, void *data, | |||
/* we care for keyframes only in Screen Video v2 */ | |||
s->is_keyframe = (avpkt->flags & AV_PKT_FLAG_KEY) && (s->ver == 2); | |||
if (s->is_keyframe) { | |||
s->keyframedata = av_realloc(s->keyframedata, avpkt->size); | |||
int err; | |||
if ((err = av_reallocp(&s->keyframedata, avpkt->size)) < 0) | |||
return err; | |||
memcpy(s->keyframedata, avpkt->data, avpkt->size); | |||
s->blocks = av_realloc(s->blocks, | |||
(v_blocks + !!v_part) * (h_blocks + !!h_part) * | |||
sizeof(s->blocks[0])); | |||
if ((err = av_reallocp(&s->blocks, (v_blocks + !!v_part) * | |||
(h_blocks + !!h_part) * sizeof(s->blocks[0]))) < 0) | |||
return err; | |||
} | |||
av_dlog(avctx, "image: %dx%d block: %dx%d num: %dx%d part: %dx%d\n", | |||
@@ -236,16 +236,14 @@ static int jpg_decode_data(JPGContext *c, int width, int height, | |||
int swapuv) | |||
{ | |||
GetBitContext gb; | |||
uint8_t *tmp; | |||
int mb_w, mb_h, mb_x, mb_y, i, j; | |||
int bx, by; | |||
int unesc_size; | |||
int ret; | |||
tmp = av_realloc(c->buf, src_size + FF_INPUT_BUFFER_PADDING_SIZE); | |||
if (!tmp) | |||
return AVERROR(ENOMEM); | |||
c->buf = tmp; | |||
if ((ret = av_reallocp(&c->buf, | |||
src_size + FF_INPUT_BUFFER_PADDING_SIZE)) < 0) | |||
return ret; | |||
jpg_unescape(src, src_size, c->buf, &unesc_size); | |||
memset(c->buf + unesc_size, 0, FF_INPUT_BUFFER_PADDING_SIZE); | |||
init_get_bits(&gb, c->buf, unesc_size * 8); | |||
@@ -478,8 +476,7 @@ static int g2m_load_cursor(AVCodecContext *avctx, G2MContext *c, | |||
uint32_t bits; | |||
uint32_t cur_size, cursor_w, cursor_h, cursor_stride; | |||
uint32_t cursor_hot_x, cursor_hot_y; | |||
int cursor_fmt; | |||
uint8_t *tmp; | |||
int cursor_fmt, err; | |||
cur_size = bytestream2_get_be32(gb); | |||
cursor_w = bytestream2_get_byte(gb); | |||
@@ -514,13 +511,11 @@ static int g2m_load_cursor(AVCodecContext *avctx, G2MContext *c, | |||
return AVERROR_PATCHWELCOME; | |||
} | |||
tmp = av_realloc(c->cursor, cursor_stride * cursor_h); | |||
if (!tmp) { | |||
if ((err = av_reallocp(&c->cursor, cursor_stride * cursor_h)) < 0) { | |||
av_log(avctx, AV_LOG_ERROR, "Cannot allocate cursor buffer\n"); | |||
return AVERROR(ENOMEM); | |||
return err; | |||
} | |||
c->cursor = tmp; | |||
c->cursor_w = cursor_w; | |||
c->cursor_h = cursor_h; | |||
c->cursor_hot_x = cursor_hot_x; | |||
@@ -37,13 +37,14 @@ static int alloc_and_copy(uint8_t **poutbuf, int *poutbuf_size, | |||
{ | |||
uint32_t offset = *poutbuf_size; | |||
uint8_t nal_header_size = offset ? 3 : 4; | |||
void *tmp; | |||
int err; | |||
*poutbuf_size += sps_pps_size + in_size + nal_header_size; | |||
tmp = av_realloc(*poutbuf, *poutbuf_size + FF_INPUT_BUFFER_PADDING_SIZE); | |||
if (!tmp) | |||
return AVERROR(ENOMEM); | |||
*poutbuf = tmp; | |||
if ((err = av_reallocp(poutbuf, | |||
*poutbuf_size + FF_INPUT_BUFFER_PADDING_SIZE)) < 0) { | |||
*poutbuf_size = 0; | |||
return err; | |||
} | |||
if (sps_pps) | |||
memcpy(*poutbuf + offset, sps_pps, sps_pps_size); | |||
memcpy(*poutbuf + sps_pps_size + nal_header_size + offset, in, in_size); | |||
@@ -84,7 +85,7 @@ static int h264_extradata_to_annexb(AVCodecContext *avctx, const int padding) | |||
} | |||
while (unit_nb--) { | |||
void *tmp; | |||
int err; | |||
unit_size = AV_RB16(extradata); | |||
total_size += unit_size + 4; | |||
@@ -94,12 +95,8 @@ static int h264_extradata_to_annexb(AVCodecContext *avctx, const int padding) | |||
av_free(out); | |||
return AVERROR(EINVAL); | |||
} | |||
tmp = av_realloc(out, total_size + padding); | |||
if (!tmp) { | |||
av_free(out); | |||
return AVERROR(ENOMEM); | |||
} | |||
out = tmp; | |||
if ((err = av_reallocp(&out, total_size + padding)) < 0) | |||
return err; | |||
memcpy(out + total_size - unit_size - 4, nalu_header, 4); | |||
memcpy(out + total_size - unit_size, extradata + 2, unit_size); | |||
extradata += 2 + unit_size; | |||
@@ -57,18 +57,14 @@ typedef struct LAMEContext { | |||
static int realloc_buffer(LAMEContext *s) | |||
{ | |||
if (!s->buffer || s->buffer_size - s->buffer_index < BUFFER_SIZE) { | |||
uint8_t *tmp; | |||
int new_size = s->buffer_index + 2 * BUFFER_SIZE; | |||
int new_size = s->buffer_index + 2 * BUFFER_SIZE, err; | |||
av_dlog(s->avctx, "resizing output buffer: %d -> %d\n", s->buffer_size, | |||
new_size); | |||
tmp = av_realloc(s->buffer, new_size); | |||
if (!tmp) { | |||
av_freep(&s->buffer); | |||
if ((err = av_reallocp(&s->buffer, new_size)) < 0) { | |||
s->buffer_size = s->buffer_index = 0; | |||
return AVERROR(ENOMEM); | |||
return err; | |||
} | |||
s->buffer = tmp; | |||
s->buffer_size = new_size; | |||
} | |||
return 0; | |||
@@ -292,6 +292,7 @@ static int libschroedinger_encode_frame(AVCodecContext *avctx, AVPacket *pkt, | |||
/* Now check to see if we have any output from the encoder. */ | |||
while (go) { | |||
int err; | |||
SchroStateEnum state; | |||
state = schro_encoder_wait(encoder); | |||
switch (state) { | |||
@@ -306,8 +307,12 @@ static int libschroedinger_encode_frame(AVCodecContext *avctx, AVPacket *pkt, | |||
* be able to set the pts correctly. So we don't write data | |||
* to the frame output queue until we actually have a frame | |||
*/ | |||
p_schro_params->enc_buf = av_realloc(p_schro_params->enc_buf, | |||
p_schro_params->enc_buf_size + enc_buf->length); | |||
if ((err = av_reallocp(&p_schro_params->enc_buf, | |||
p_schro_params->enc_buf_size + | |||
enc_buf->length)) < 0) { | |||
p_schro_params->enc_buf_size = 0; | |||
return err; | |||
} | |||
memcpy(p_schro_params->enc_buf + p_schro_params->enc_buf_size, | |||
enc_buf->data, enc_buf->length); | |||
@@ -58,8 +58,8 @@ static int concatenate_packet(unsigned int* offset, | |||
const ogg_packet* packet) | |||
{ | |||
const char* message = NULL; | |||
uint8_t* newdata = NULL; | |||
int newsize = avc_context->extradata_size + 2 + packet->bytes; | |||
int err = AVERROR_INVALIDDATA; | |||
if (packet->bytes < 0) { | |||
message = "ogg_packet has negative size"; | |||
@@ -68,16 +68,16 @@ static int concatenate_packet(unsigned int* offset, | |||
} else if (newsize < avc_context->extradata_size) { | |||
message = "extradata_size would overflow"; | |||
} else { | |||
newdata = av_realloc(avc_context->extradata, newsize); | |||
if (!newdata) | |||
if ((err = av_reallocp(&avc_context->extradata, newsize)) < 0) { | |||
avc_context->extradata_size = 0; | |||
message = "av_realloc failed"; | |||
} | |||
} | |||
if (message) { | |||
av_log(avc_context, AV_LOG_ERROR, "concatenate_packet failed: %s\n", message); | |||
return -1; | |||
return err; | |||
} | |||
avc_context->extradata = newdata; | |||
avc_context->extradata_size = newsize; | |||
AV_WB16(avc_context->extradata + (*offset), packet->bytes); | |||
*offset += 2; | |||
@@ -468,11 +468,13 @@ static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out, | |||
break; | |||
case VPX_CODEC_STATS_PKT: { | |||
struct vpx_fixed_buf *stats = &ctx->twopass_stats; | |||
stats->buf = av_realloc(stats->buf, | |||
stats->sz + pkt->data.twopass_stats.sz); | |||
if (!stats->buf) { | |||
int err; | |||
if ((err = av_reallocp(&stats->buf, | |||
stats->sz + | |||
pkt->data.twopass_stats.sz)) < 0) { | |||
stats->sz = 0; | |||
av_log(avctx, AV_LOG_ERROR, "Stat buffer realloc failed\n"); | |||
return AVERROR(ENOMEM); | |||
return err; | |||
} | |||
memcpy((uint8_t*)stats->buf + stats->sz, | |||
pkt->data.twopass_stats.buf, pkt->data.twopass_stats.sz); | |||
@@ -119,9 +119,7 @@ static av_cold int shorten_decode_init(AVCodecContext *avctx) | |||
static int allocate_buffers(ShortenContext *s) | |||
{ | |||
int i, chan; | |||
int *coeffs; | |||
void *tmp_ptr; | |||
int i, chan, err; | |||
for (chan = 0; chan < s->channels; chan++) { | |||
if (FFMAX(1, s->nmean) >= UINT_MAX / sizeof(int32_t)) { | |||
@@ -135,26 +133,21 @@ static int allocate_buffers(ShortenContext *s) | |||
return AVERROR_INVALIDDATA; | |||
} | |||
tmp_ptr = | |||
av_realloc(s->offset[chan], sizeof(int32_t) * FFMAX(1, s->nmean)); | |||
if (!tmp_ptr) | |||
return AVERROR(ENOMEM); | |||
s->offset[chan] = tmp_ptr; | |||
if ((err = av_reallocp(&s->offset[chan], | |||
sizeof(int32_t) * | |||
FFMAX(1, s->nmean))) < 0) | |||
return err; | |||
tmp_ptr = av_realloc(s->decoded_base[chan], (s->blocksize + s->nwrap) * | |||
sizeof(s->decoded_base[0][0])); | |||
if (!tmp_ptr) | |||
return AVERROR(ENOMEM); | |||
s->decoded_base[chan] = tmp_ptr; | |||
if ((err = av_reallocp(&s->decoded_base[chan], (s->blocksize + s->nwrap) * | |||
sizeof(s->decoded_base[0][0]))) < 0) | |||
return err; | |||
for (i = 0; i < s->nwrap; i++) | |||
s->decoded_base[chan][i] = 0; | |||
s->decoded[chan] = s->decoded_base[chan] + s->nwrap; | |||
} | |||
coeffs = av_realloc(s->coeffs, s->nwrap * sizeof(*s->coeffs)); | |||
if (!coeffs) | |||
return AVERROR(ENOMEM); | |||
s->coeffs = coeffs; | |||
if ((err = av_reallocp(&s->coeffs, s->nwrap * sizeof(*s->coeffs))) < 0) | |||
return err; | |||
return 0; | |||
} | |||