| Message ID | 1589299605-2411-1-git-send-email-lance.lmwang@gmail.com |
|---|---|
| State | New |
| Headers | show |
| Series | [FFmpeg-devel] avcodec: improve the function of FF_ALLOC{Z}{_ARRAY}_OR_GOTO | expand |
| Context | Check | Description |
|---|---|---|
| andriy/default | pending | |
| andriy/make | success | Make finished |
| andriy/make_fate | success | Make fate finished |
On Wed, 13 May 2020, lance.lmwang@gmail.com wrote: > From: Limin Wang <lance.lmwang@gmail.com> > > Please refer to the details here: > https://patchwork.ffmpeg.org/project/ffmpeg/patch/1589212343-8334-1-git-send-email-lance.lmwang@gmail.com/ > > Suggested-by: Nicolas George <george@nsup.org> > Signed-off-by: Limin Wang <lance.lmwang@gmail.com> > --- > libavcodec/aacenc.c | 8 ++-- > libavcodec/ac3enc.c | 102 +++++++++++++++++++++---------------------- > libavcodec/ac3enc_template.c | 15 +++---- > libavcodec/adpcmenc.c | 35 +++++---------- > libavcodec/alac.c | 17 +++----- > libavcodec/apedec.c | 9 ++-- > libavcodec/dnxhdenc.c | 73 +++++++++++++++---------------- > libavcodec/h264dec.c | 69 ++++++++++++++--------------- > libavcodec/iirfilter.c | 12 ++--- > libavcodec/mpegpicture.c | 11 ++--- > libavcodec/mpegvideo.c | 78 +++++++++++++++------------------ > libavcodec/mpegvideo_enc.c | 31 +++++-------- > libavcodec/snow.c | 25 +++++------ > libavcodec/twinvq.c | 23 +++++----- > libavutil/internal.h | 24 +++++----- > libswscale/utils.c | 40 ++++++++--------- > 16 files changed, 260 insertions(+), 312 deletions(-) > > diff --git a/libavcodec/aacenc.c b/libavcodec/aacenc.c > index 4d0abb1..9855e40 100644 > --- a/libavcodec/aacenc.c > +++ b/libavcodec/aacenc.c > @@ -939,16 +939,14 @@ static av_cold int dsp_init(AVCodecContext *avctx, AACEncContext *s) > > static av_cold int alloc_buffers(AVCodecContext *avctx, AACEncContext *s) > { > - int ch; > - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->buffer.samples, s->channels, 3 * 1024 * sizeof(s->buffer.samples[0]), alloc_fail); > - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->cpe, s->chan_map[0], sizeof(ChannelElement), alloc_fail); > + int ret, ch; > + FF_ALLOCZ_ARRAY_OR_GOTO(s->buffer.samples, s->channels, 3 * 1024 * sizeof(s->buffer.samples[0]), ret, return ret); > + FF_ALLOCZ_ARRAY_OR_GOTO(s->cpe, s->chan_map[0], sizeof(ChannelElement), ret, return ret); If you want to change the existing macro, then you have to rename it, because it no longer does goto... Also I kind of disagree with Nicholas that we should always assign a ret variable, I think a single error statement is better. For example in the case above a goto fail is a lot nicer (and returning ENOMEM) there. Please wait a bit before a conclusion is reached about the macro, and only implement it later. Also this patch is non-trivial now, and some changes are definitely not OK (e.g removing ff_h264_free_tables(h) and similar cleanup functions from the failure path). Regards, Marton > > for(ch = 0; ch < s->channels; ch++) > s->planar_samples[ch] = s->buffer.samples + 3 * 1024 * ch; > > return 0; > -alloc_fail: > - return AVERROR(ENOMEM); > } > > static av_cold void aac_encode_init_tables(void) > diff --git a/libavcodec/ac3enc.c b/libavcodec/ac3enc.c > index ddbc7b2..19434d4 100644 > --- a/libavcodec/ac3enc.c > +++ b/libavcodec/ac3enc.c > @@ -2322,60 +2322,60 @@ static av_cold void set_bandwidth(AC3EncodeContext *s) > > static av_cold int allocate_buffers(AC3EncodeContext *s) > { > - AVCodecContext *avctx = s->avctx; > int blk, ch; > int channels = s->channels + 1; /* includes coupling channel */ > int channel_blocks = channels * s->num_blocks; > int total_coefs = AC3_MAX_COEFS * channel_blocks; > + int ret; > + > + if (ret = s->allocate_sample_buffers(s)) > + return ret; > > - if (s->allocate_sample_buffers(s)) > - goto alloc_fail; > - > - FF_ALLOC_ARRAY_OR_GOTO(avctx, s->bap_buffer, total_coefs, > - sizeof(*s->bap_buffer), alloc_fail); > - FF_ALLOC_ARRAY_OR_GOTO(avctx, s->bap1_buffer, total_coefs, > - sizeof(*s->bap1_buffer), alloc_fail); > - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->mdct_coef_buffer, total_coefs, > - sizeof(*s->mdct_coef_buffer), alloc_fail); > - FF_ALLOC_ARRAY_OR_GOTO(avctx, s->exp_buffer, total_coefs, > - sizeof(*s->exp_buffer), alloc_fail); > - FF_ALLOC_ARRAY_OR_GOTO(avctx, s->grouped_exp_buffer, channel_blocks, 128 * > - sizeof(*s->grouped_exp_buffer), alloc_fail); > - FF_ALLOC_ARRAY_OR_GOTO(avctx, s->psd_buffer, total_coefs, > - sizeof(*s->psd_buffer), alloc_fail); > - FF_ALLOC_ARRAY_OR_GOTO(avctx, s->band_psd_buffer, channel_blocks, 64 * > - sizeof(*s->band_psd_buffer), alloc_fail); > - FF_ALLOC_ARRAY_OR_GOTO(avctx, s->mask_buffer, channel_blocks, 64 * > - sizeof(*s->mask_buffer), alloc_fail); > - FF_ALLOC_ARRAY_OR_GOTO(avctx, s->qmant_buffer, total_coefs, > - sizeof(*s->qmant_buffer), alloc_fail); > + FF_ALLOC_ARRAY_OR_GOTO(s->bap_buffer, total_coefs, > + sizeof(*s->bap_buffer), ret, return ret); > + FF_ALLOC_ARRAY_OR_GOTO(s->bap1_buffer, total_coefs, > + sizeof(*s->bap1_buffer), ret, return ret); > + FF_ALLOCZ_ARRAY_OR_GOTO(s->mdct_coef_buffer, total_coefs, > + sizeof(*s->mdct_coef_buffer), ret, return ret); > + FF_ALLOC_ARRAY_OR_GOTO(s->exp_buffer, total_coefs, > + sizeof(*s->exp_buffer), ret, return ret); > + FF_ALLOC_ARRAY_OR_GOTO(s->grouped_exp_buffer, channel_blocks, 128 * > + sizeof(*s->grouped_exp_buffer), ret, return ret); > + FF_ALLOC_ARRAY_OR_GOTO(s->psd_buffer, total_coefs, > + sizeof(*s->psd_buffer), ret, return ret); > + FF_ALLOC_ARRAY_OR_GOTO(s->band_psd_buffer, channel_blocks, 64 * > + sizeof(*s->band_psd_buffer), ret, return ret); > + FF_ALLOC_ARRAY_OR_GOTO(s->mask_buffer, channel_blocks, 64 * > + sizeof(*s->mask_buffer), ret, return ret); > + FF_ALLOC_ARRAY_OR_GOTO(s->qmant_buffer, total_coefs, > + sizeof(*s->qmant_buffer), ret, return ret); > if (s->cpl_enabled) { > - FF_ALLOC_ARRAY_OR_GOTO(avctx, s->cpl_coord_exp_buffer, channel_blocks, 16 * > - sizeof(*s->cpl_coord_exp_buffer), alloc_fail); > - FF_ALLOC_ARRAY_OR_GOTO(avctx, s->cpl_coord_mant_buffer, channel_blocks, 16 * > - sizeof(*s->cpl_coord_mant_buffer), alloc_fail); > + FF_ALLOC_ARRAY_OR_GOTO(s->cpl_coord_exp_buffer, channel_blocks, 16 * > + sizeof(*s->cpl_coord_exp_buffer), ret, return ret); > + FF_ALLOC_ARRAY_OR_GOTO(s->cpl_coord_mant_buffer, channel_blocks, 16 * > + sizeof(*s->cpl_coord_mant_buffer), ret, return ret); > } > for (blk = 0; blk < s->num_blocks; blk++) { > AC3Block *block = &s->blocks[blk]; > - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->mdct_coef, channels, sizeof(*block->mdct_coef), > - alloc_fail); > - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->exp, channels, sizeof(*block->exp), > - alloc_fail); > - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->grouped_exp, channels, sizeof(*block->grouped_exp), > - alloc_fail); > - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->psd, channels, sizeof(*block->psd), > - alloc_fail); > - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->band_psd, channels, sizeof(*block->band_psd), > - alloc_fail); > - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->mask, channels, sizeof(*block->mask), > - alloc_fail); > - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->qmant, channels, sizeof(*block->qmant), > - alloc_fail); > + FF_ALLOCZ_ARRAY_OR_GOTO(block->mdct_coef, channels, sizeof(*block->mdct_coef), > + ret, return ret); > + FF_ALLOCZ_ARRAY_OR_GOTO(block->exp, channels, sizeof(*block->exp), > + ret, return ret); > + FF_ALLOCZ_ARRAY_OR_GOTO(block->grouped_exp, channels, sizeof(*block->grouped_exp), > + ret, return ret); > + FF_ALLOCZ_ARRAY_OR_GOTO(block->psd, channels, sizeof(*block->psd), > + ret, return ret); > + FF_ALLOCZ_ARRAY_OR_GOTO(block->band_psd, channels, sizeof(*block->band_psd), > + ret, return ret); > + FF_ALLOCZ_ARRAY_OR_GOTO(block->mask, channels, sizeof(*block->mask), > + ret, return ret); > + FF_ALLOCZ_ARRAY_OR_GOTO(block->qmant, channels, sizeof(*block->qmant), > + ret, return ret); > if (s->cpl_enabled) { > - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->cpl_coord_exp, channels, sizeof(*block->cpl_coord_exp), > - alloc_fail); > - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->cpl_coord_mant, channels, sizeof(*block->cpl_coord_mant), > - alloc_fail); > + FF_ALLOCZ_ARRAY_OR_GOTO(block->cpl_coord_exp, channels, sizeof(*block->cpl_coord_exp), > + ret, return ret); > + FF_ALLOCZ_ARRAY_OR_GOTO(block->cpl_coord_mant, channels, sizeof(*block->cpl_coord_mant), > + ret, return ret); > } > > for (ch = 0; ch < channels; ch++) { > @@ -2397,28 +2397,26 @@ static av_cold int allocate_buffers(AC3EncodeContext *s) > } > > if (!s->fixed_point) { > - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->fixed_coef_buffer, total_coefs, > - sizeof(*s->fixed_coef_buffer), alloc_fail); > + FF_ALLOCZ_ARRAY_OR_GOTO(s->fixed_coef_buffer, total_coefs, > + sizeof(*s->fixed_coef_buffer), ret, return ret); > for (blk = 0; blk < s->num_blocks; blk++) { > AC3Block *block = &s->blocks[blk]; > - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->fixed_coef, channels, > - sizeof(*block->fixed_coef), alloc_fail); > + FF_ALLOCZ_ARRAY_OR_GOTO(block->fixed_coef, channels, > + sizeof(*block->fixed_coef), ret, return ret); > for (ch = 0; ch < channels; ch++) > block->fixed_coef[ch] = &s->fixed_coef_buffer[AC3_MAX_COEFS * (s->num_blocks * ch + blk)]; > } > } else { > for (blk = 0; blk < s->num_blocks; blk++) { > AC3Block *block = &s->blocks[blk]; > - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->fixed_coef, channels, > - sizeof(*block->fixed_coef), alloc_fail); > + FF_ALLOCZ_ARRAY_OR_GOTO(block->fixed_coef, channels, > + sizeof(*block->fixed_coef), ret, return ret); > for (ch = 0; ch < channels; ch++) > block->fixed_coef[ch] = (int32_t *)block->mdct_coef[ch]; > } > } > > return 0; > -alloc_fail: > - return AVERROR(ENOMEM); > } > > > diff --git a/libavcodec/ac3enc_template.c b/libavcodec/ac3enc_template.c > index be65987..ec4e984 100644 > --- a/libavcodec/ac3enc_template.c > +++ b/libavcodec/ac3enc_template.c > @@ -39,21 +39,20 @@ > > int AC3_NAME(allocate_sample_buffers)(AC3EncodeContext *s) > { > + int ret; > int ch; > > - FF_ALLOC_OR_GOTO(s->avctx, s->windowed_samples, AC3_WINDOW_SIZE * > - sizeof(*s->windowed_samples), alloc_fail); > - FF_ALLOC_ARRAY_OR_GOTO(s->avctx, s->planar_samples, s->channels, sizeof(*s->planar_samples), > - alloc_fail); > + FF_ALLOC_OR_GOTO(s->windowed_samples, AC3_WINDOW_SIZE * > + sizeof(*s->windowed_samples), ret, return ret); > + FF_ALLOC_ARRAY_OR_GOTO(s->planar_samples, s->channels, sizeof(*s->planar_samples), > + ret, return ret); > for (ch = 0; ch < s->channels; ch++) { > - FF_ALLOCZ_OR_GOTO(s->avctx, s->planar_samples[ch], > + FF_ALLOCZ_OR_GOTO(s->planar_samples[ch], > (AC3_FRAME_SIZE+AC3_BLOCK_SIZE) * sizeof(**s->planar_samples), > - alloc_fail); > + ret, return ret); > } > > return 0; > -alloc_fail: > - return AVERROR(ENOMEM); > } > > > diff --git a/libavcodec/adpcmenc.c b/libavcodec/adpcmenc.c > index 668939c..18d08fd 100644 > --- a/libavcodec/adpcmenc.c > +++ b/libavcodec/adpcmenc.c > @@ -65,7 +65,7 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx) > ADPCMEncodeContext *s = avctx->priv_data; > uint8_t *extradata; > int i; > - int ret = AVERROR(ENOMEM); > + int ret; > > if (avctx->channels > 2) { > av_log(avctx, AV_LOG_ERROR, "only stereo or mono is supported\n"); > @@ -80,14 +80,10 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx) > if (avctx->trellis) { > int frontier = 1 << avctx->trellis; > int max_paths = frontier * FREEZE_INTERVAL; > - FF_ALLOC_OR_GOTO(avctx, s->paths, > - max_paths * sizeof(*s->paths), error); > - FF_ALLOC_OR_GOTO(avctx, s->node_buf, > - 2 * frontier * sizeof(*s->node_buf), error); > - FF_ALLOC_OR_GOTO(avctx, s->nodep_buf, > - 2 * frontier * sizeof(*s->nodep_buf), error); > - FF_ALLOC_OR_GOTO(avctx, s->trellis_hash, > - 65536 * sizeof(*s->trellis_hash), error); > + FF_ALLOC_OR_GOTO(s->paths, max_paths * sizeof(*s->paths), ret, return ret); > + FF_ALLOC_OR_GOTO(s->node_buf, 2 * frontier * sizeof(*s->node_buf), ret, return ret); > + FF_ALLOC_OR_GOTO(s->nodep_buf, 2 * frontier * sizeof(*s->nodep_buf), ret, return ret); > + FF_ALLOC_OR_GOTO(s->trellis_hash, 65536 * sizeof(*s->trellis_hash), ret, return ret); > } > > avctx->bits_per_coded_sample = av_get_bits_per_sample(avctx->codec->id); > @@ -114,7 +110,7 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx) > avctx->bits_per_coded_sample = 4; > avctx->block_align = BLKSIZE; > if (!(avctx->extradata = av_malloc(32 + AV_INPUT_BUFFER_PADDING_SIZE))) > - goto error; > + return AVERROR(ENOMEM); > avctx->extradata_size = 32; > extradata = avctx->extradata; > bytestream_put_le16(&extradata, avctx->frame_size); > @@ -134,20 +130,15 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx) > avctx->sample_rate != 44100) { > av_log(avctx, AV_LOG_ERROR, "Sample rate must be 11025, " > "22050 or 44100\n"); > - ret = AVERROR(EINVAL); > - goto error; > + return AVERROR(EINVAL); > } > avctx->frame_size = 512 * (avctx->sample_rate / 11025); > break; > default: > - ret = AVERROR(EINVAL); > - goto error; > + return AVERROR(EINVAL); > } > > return 0; > -error: > - adpcm_encode_close(avctx); > - return ret; > } > > static av_cold int adpcm_encode_close(AVCodecContext *avctx) > @@ -509,7 +500,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, > > /* stereo: 4 bytes (8 samples) for left, 4 bytes for right */ > if (avctx->trellis > 0) { > - FF_ALLOC_ARRAY_OR_GOTO(avctx, buf, avctx->channels, blocks * 8, error); > + FF_ALLOC_ARRAY_OR_GOTO(buf, avctx->channels, blocks * 8, ret, return ret); > for (ch = 0; ch < avctx->channels; ch++) { > adpcm_compress_trellis(avctx, &samples_p[ch][1], > buf + ch * blocks * 8, &c->status[ch], > @@ -588,7 +579,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, > } > > if (avctx->trellis > 0) { > - FF_ALLOC_OR_GOTO(avctx, buf, 2 * n, error); > + FF_ALLOC_OR_GOTO(buf, 2 * n, ret, return ret); > adpcm_compress_trellis(avctx, samples + avctx->channels, buf, > &c->status[0], n, avctx->channels); > if (avctx->channels == 2) > @@ -636,7 +627,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, > > if (avctx->trellis > 0) { > n = avctx->block_align - 7 * avctx->channels; > - FF_ALLOC_OR_GOTO(avctx, buf, 2 * n, error); > + FF_ALLOC_OR_GOTO(buf, 2 * n, ret, return ret); > if (avctx->channels == 1) { > adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n, > avctx->channels); > @@ -663,7 +654,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, > case AV_CODEC_ID_ADPCM_YAMAHA: > n = frame->nb_samples / 2; > if (avctx->trellis > 0) { > - FF_ALLOC_OR_GOTO(avctx, buf, 2 * n * 2, error); > + FF_ALLOC_OR_GOTO(buf, 2 * n * 2, ret, return ret); > n *= 2; > if (avctx->channels == 1) { > adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n, > @@ -694,8 +685,6 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, > avpkt->size = pkt_size; > *got_packet_ptr = 1; > return 0; > -error: > - return AVERROR(ENOMEM); > } > > static const enum AVSampleFormat sample_fmts[] = { > diff --git a/libavcodec/alac.c b/libavcodec/alac.c > index c8c0422..e7245b8 100644 > --- a/libavcodec/alac.c > +++ b/libavcodec/alac.c > @@ -487,7 +487,7 @@ static av_cold int alac_decode_close(AVCodecContext *avctx) > > static int allocate_buffers(ALACContext *alac) > { > - int ch; > + int ch, ret; > unsigned buf_size = alac->max_samples_per_frame * sizeof(int32_t); > > for (ch = 0; ch < 2; ch++) { > @@ -497,22 +497,19 @@ static int allocate_buffers(ALACContext *alac) > } > > for (ch = 0; ch < FFMIN(alac->channels, 2); ch++) { > - FF_ALLOC_OR_GOTO(alac->avctx, alac->predict_error_buffer[ch], > - buf_size, buf_alloc_fail); > + FF_ALLOC_OR_GOTO(alac->predict_error_buffer[ch], > + buf_size, ret, return ret); > > alac->direct_output = alac->sample_size > 16; > if (!alac->direct_output) { > - FF_ALLOC_OR_GOTO(alac->avctx, alac->output_samples_buffer[ch], > - buf_size + AV_INPUT_BUFFER_PADDING_SIZE, buf_alloc_fail); > + FF_ALLOC_OR_GOTO(alac->output_samples_buffer[ch], > + buf_size + AV_INPUT_BUFFER_PADDING_SIZE, ret, return ret); > } > > - FF_ALLOC_OR_GOTO(alac->avctx, alac->extra_bits_buffer[ch], > - buf_size + AV_INPUT_BUFFER_PADDING_SIZE, buf_alloc_fail); > + FF_ALLOC_OR_GOTO(alac->extra_bits_buffer[ch], > + buf_size + AV_INPUT_BUFFER_PADDING_SIZE, ret, return ret); > } > return 0; > -buf_alloc_fail: > - alac_decode_close(alac->avctx); > - return AVERROR(ENOMEM); > } > > static int alac_set_info(ALACContext *alac) > diff --git a/libavcodec/apedec.c b/libavcodec/apedec.c > index 2d19250..7db4467 100644 > --- a/libavcodec/apedec.c > +++ b/libavcodec/apedec.c > @@ -215,7 +215,7 @@ static av_cold int ape_decode_close(AVCodecContext *avctx) > static av_cold int ape_decode_init(AVCodecContext *avctx) > { > APEContext *s = avctx->priv_data; > - int i; > + int i, ret; > > if (avctx->extradata_size != 6) { > av_log(avctx, AV_LOG_ERROR, "Incorrect extradata\n"); > @@ -260,9 +260,9 @@ static av_cold int ape_decode_init(AVCodecContext *avctx) > for (i = 0; i < APE_FILTER_LEVELS; i++) { > if (!ape_filter_orders[s->fset][i]) > break; > - FF_ALLOC_OR_GOTO(avctx, s->filterbuf[i], > + FF_ALLOC_OR_GOTO(s->filterbuf[i], > (ape_filter_orders[s->fset][i] * 3 + HISTORY_SIZE) * 4, > - filter_alloc_fail); > + ret, return ret); > } > > if (s->fileversion < 3860) { > @@ -298,9 +298,6 @@ static av_cold int ape_decode_init(AVCodecContext *avctx) > avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO; > > return 0; > -filter_alloc_fail: > - ape_decode_close(avctx); > - return AVERROR(ENOMEM); > } > > /** > diff --git a/libavcodec/dnxhdenc.c b/libavcodec/dnxhdenc.c > index 32ac90f..79d3f3f 100644 > --- a/libavcodec/dnxhdenc.c > +++ b/libavcodec/dnxhdenc.c > @@ -205,15 +205,16 @@ static av_cold int dnxhd_init_vlc(DNXHDEncContext *ctx) > { > int i, j, level, run; > int max_level = 1 << (ctx->bit_depth + 2); > + int ret; > > - FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->orig_vlc_codes, > - max_level, 4 * sizeof(*ctx->orig_vlc_codes), fail); > - FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->orig_vlc_bits, > - max_level, 4 * sizeof(*ctx->orig_vlc_bits), fail); > - FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_codes, > - 63 * 2, fail); > - FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_bits, > - 63, fail); > + FF_ALLOCZ_ARRAY_OR_GOTO(ctx->orig_vlc_codes, > + max_level, 4 * sizeof(*ctx->orig_vlc_codes), ret, return ret); > + FF_ALLOCZ_ARRAY_OR_GOTO(ctx->orig_vlc_bits, > + max_level, 4 * sizeof(*ctx->orig_vlc_bits), ret, return ret); > + FF_ALLOCZ_OR_GOTO(ctx->run_codes, > + 63 * 2, ret, return ret); > + FF_ALLOCZ_OR_GOTO(ctx->run_bits, > + 63, ret, return ret); > > ctx->vlc_codes = ctx->orig_vlc_codes + max_level * 2; > ctx->vlc_bits = ctx->orig_vlc_bits + max_level * 2; > @@ -258,8 +259,6 @@ static av_cold int dnxhd_init_vlc(DNXHDEncContext *ctx) > ctx->run_bits[run] = ctx->cid_table->run_bits[i]; > } > return 0; > -fail: > - return AVERROR(ENOMEM); > } > > static av_cold int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias) > @@ -269,17 +268,18 @@ static av_cold int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias) > int qscale, i; > const uint8_t *luma_weight_table = ctx->cid_table->luma_weight; > const uint8_t *chroma_weight_table = ctx->cid_table->chroma_weight; > + int ret; > > - FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l, > - (ctx->m.avctx->qmax + 1), 64 * sizeof(int), fail); > - FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c, > - (ctx->m.avctx->qmax + 1), 64 * sizeof(int), fail); > - FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l16, > + FF_ALLOCZ_ARRAY_OR_GOTO(ctx->qmatrix_l, > + (ctx->m.avctx->qmax + 1), 64 * sizeof(int), ret, return ret); > + FF_ALLOCZ_ARRAY_OR_GOTO(ctx->qmatrix_c, > + (ctx->m.avctx->qmax + 1), 64 * sizeof(int), ret, return ret); > + FF_ALLOCZ_ARRAY_OR_GOTO(ctx->qmatrix_l16, > (ctx->m.avctx->qmax + 1), 64 * 2 * sizeof(uint16_t), > - fail); > - FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c16, > + ret, return ret); > + FF_ALLOCZ_ARRAY_OR_GOTO(ctx->qmatrix_c16, > (ctx->m.avctx->qmax + 1), 64 * 2 * sizeof(uint16_t), > - fail); > + ret, return ret); > > if (ctx->bit_depth == 8) { > for (i = 1; i < 64; i++) { > @@ -338,27 +338,24 @@ static av_cold int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias) > ctx->m.q_intra_matrix = ctx->qmatrix_l; > > return 0; > -fail: > - return AVERROR(ENOMEM); > } > > static av_cold int dnxhd_init_rc(DNXHDEncContext *ctx) > { > - FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->mb_rc, (ctx->m.avctx->qmax + 1), > - ctx->m.mb_num * sizeof(RCEntry), fail); > + int ret; > + FF_ALLOCZ_ARRAY_OR_GOTO(ctx->mb_rc, (ctx->m.avctx->qmax + 1), > + ctx->m.mb_num * sizeof(RCEntry), ret, return ret); > if (ctx->m.avctx->mb_decision != FF_MB_DECISION_RD) { > - FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->mb_cmp, > - ctx->m.mb_num, sizeof(RCCMPEntry), fail); > - FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->mb_cmp_tmp, > - ctx->m.mb_num, sizeof(RCCMPEntry), fail); > + FF_ALLOCZ_ARRAY_OR_GOTO(ctx->mb_cmp, > + ctx->m.mb_num, sizeof(RCCMPEntry), ret, return ret); > + FF_ALLOCZ_ARRAY_OR_GOTO(ctx->mb_cmp_tmp, > + ctx->m.mb_num, sizeof(RCCMPEntry), ret, return ret); > } > ctx->frame_bits = (ctx->coding_unit_size - > ctx->data_offset - 4 - ctx->min_padding) * 8; > ctx->qscale = 1; > ctx->lambda = 2 << LAMBDA_FRAC_BITS; // qscale 2 > return 0; > -fail: > - return AVERROR(ENOMEM); > } > > static av_cold int dnxhd_encode_init(AVCodecContext *avctx) > @@ -509,14 +506,14 @@ static av_cold int dnxhd_encode_init(AVCodecContext *avctx) > if ((ret = dnxhd_init_rc(ctx)) < 0) > return ret; > > - FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->slice_size, > - ctx->m.mb_height * sizeof(uint32_t), fail); > - FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->slice_offs, > - ctx->m.mb_height * sizeof(uint32_t), fail); > - FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_bits, > - ctx->m.mb_num * sizeof(uint16_t), fail); > - FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_qscale, > - ctx->m.mb_num * sizeof(uint8_t), fail); > + FF_ALLOCZ_OR_GOTO(ctx->slice_size, > + ctx->m.mb_height * sizeof(uint32_t), ret, return ret); > + FF_ALLOCZ_OR_GOTO(ctx->slice_offs, > + ctx->m.mb_height * sizeof(uint32_t), ret, return ret); > + FF_ALLOCZ_OR_GOTO(ctx->mb_bits, > + ctx->m.mb_num * sizeof(uint16_t), ret, return ret); > + FF_ALLOCZ_OR_GOTO(ctx->mb_qscale, > + ctx->m.mb_num * sizeof(uint8_t), ret, return ret); > > #if FF_API_CODED_FRAME > FF_DISABLE_DEPRECATION_WARNINGS > @@ -542,14 +539,12 @@ FF_ENABLE_DEPRECATION_WARNINGS > for (i = 1; i < avctx->thread_count; i++) { > ctx->thread[i] = av_malloc(sizeof(DNXHDEncContext)); > if (!ctx->thread[i]) > - goto fail; > + return AVERROR(ENOMEM); > memcpy(ctx->thread[i], ctx, sizeof(DNXHDEncContext)); > } > } > > return 0; > -fail: // for FF_ALLOCZ_OR_GOTO > - return AVERROR(ENOMEM); > } > > static int dnxhd_write_header(AVCodecContext *avctx, uint8_t *buf) > diff --git a/libavcodec/h264dec.c b/libavcodec/h264dec.c > index 4c355fe..0bcc60f 100644 > --- a/libavcodec/h264dec.c > +++ b/libavcodec/h264dec.c > @@ -181,39 +181,40 @@ int ff_h264_alloc_tables(H264Context *h) > const int big_mb_num = h->mb_stride * (h->mb_height + 1); > const int row_mb_num = 2*h->mb_stride*FFMAX(h->nb_slice_ctx, 1); > int x, y; > + int ret; > > - FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->intra4x4_pred_mode, > - row_mb_num, 8 * sizeof(uint8_t), fail) > + FF_ALLOCZ_ARRAY_OR_GOTO(h->intra4x4_pred_mode, > + row_mb_num, 8 * sizeof(uint8_t), ret, return ret) > h->slice_ctx[0].intra4x4_pred_mode = h->intra4x4_pred_mode; > > - FF_ALLOCZ_OR_GOTO(h->avctx, h->non_zero_count, > - big_mb_num * 48 * sizeof(uint8_t), fail) > - FF_ALLOCZ_OR_GOTO(h->avctx, h->slice_table_base, > - (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base), fail) > - FF_ALLOCZ_OR_GOTO(h->avctx, h->cbp_table, > - big_mb_num * sizeof(uint16_t), fail) > - FF_ALLOCZ_OR_GOTO(h->avctx, h->chroma_pred_mode_table, > - big_mb_num * sizeof(uint8_t), fail) > - FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[0], > - row_mb_num, 16 * sizeof(uint8_t), fail); > - FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[1], > - row_mb_num, 16 * sizeof(uint8_t), fail); > + FF_ALLOCZ_OR_GOTO(h->non_zero_count, > + big_mb_num * 48 * sizeof(uint8_t), ret, return ret) > + FF_ALLOCZ_OR_GOTO(h->slice_table_base, > + (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base), ret, return ret) > + FF_ALLOCZ_OR_GOTO(h->cbp_table, > + big_mb_num * sizeof(uint16_t), ret, return ret) > + FF_ALLOCZ_OR_GOTO(h->chroma_pred_mode_table, > + big_mb_num * sizeof(uint8_t), ret, return ret) > + FF_ALLOCZ_ARRAY_OR_GOTO(h->mvd_table[0], > + row_mb_num, 16 * sizeof(uint8_t), ret, return ret); > + FF_ALLOCZ_ARRAY_OR_GOTO(h->mvd_table[1], > + row_mb_num, 16 * sizeof(uint8_t), ret, return ret); > h->slice_ctx[0].mvd_table[0] = h->mvd_table[0]; > h->slice_ctx[0].mvd_table[1] = h->mvd_table[1]; > > - FF_ALLOCZ_OR_GOTO(h->avctx, h->direct_table, > - 4 * big_mb_num * sizeof(uint8_t), fail); > - FF_ALLOCZ_OR_GOTO(h->avctx, h->list_counts, > - big_mb_num * sizeof(uint8_t), fail) > + FF_ALLOCZ_OR_GOTO(h->direct_table, > + 4 * big_mb_num * sizeof(uint8_t), ret, return ret); > + FF_ALLOCZ_OR_GOTO(h->list_counts, > + big_mb_num * sizeof(uint8_t), ret, return ret) > > memset(h->slice_table_base, -1, > (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base)); > h->slice_table = h->slice_table_base + h->mb_stride * 2 + 1; > > - FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2b_xy, > - big_mb_num * sizeof(uint32_t), fail); > - FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2br_xy, > - big_mb_num * sizeof(uint32_t), fail); > + FF_ALLOCZ_OR_GOTO(h->mb2b_xy, > + big_mb_num * sizeof(uint32_t), ret, return ret); > + FF_ALLOCZ_OR_GOTO(h->mb2br_xy, > + big_mb_num * sizeof(uint32_t), ret, return ret); > for (y = 0; y < h->mb_height; y++) > for (x = 0; x < h->mb_width; x++) { > const int mb_xy = x + y * h->mb_stride; > @@ -224,10 +225,6 @@ int ff_h264_alloc_tables(H264Context *h) > } > > return 0; > - > -fail: > - ff_h264_free_tables(h); > - return AVERROR(ENOMEM); > } > > /** > @@ -242,6 +239,7 @@ int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl) > int c_size = h->mb_stride * (h->mb_height + 1); > int yc_size = y_size + 2 * c_size; > int x, y, i; > + int ret; > > sl->ref_cache[0][scan8[5] + 1] = > sl->ref_cache[0][scan8[7] + 1] = > @@ -268,8 +266,8 @@ int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl) > er->b8_stride = h->mb_width * 2 + 1; > > // error resilience code looks cleaner with this > - FF_ALLOCZ_OR_GOTO(h->avctx, er->mb_index2xy, > - (h->mb_num + 1) * sizeof(int), fail); > + FF_ALLOCZ_OR_GOTO(er->mb_index2xy, > + (h->mb_num + 1) * sizeof(int), ret, return ret); > > for (y = 0; y < h->mb_height; y++) > for (x = 0; x < h->mb_width; x++) > @@ -278,14 +276,14 @@ int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl) > er->mb_index2xy[h->mb_height * h->mb_width] = (h->mb_height - 1) * > h->mb_stride + h->mb_width; > > - FF_ALLOCZ_OR_GOTO(h->avctx, er->error_status_table, > - mb_array_size * sizeof(uint8_t), fail); > + FF_ALLOCZ_OR_GOTO(er->error_status_table, > + mb_array_size * sizeof(uint8_t), ret, return ret); > > - FF_ALLOC_OR_GOTO(h->avctx, er->er_temp_buffer, > - h->mb_height * h->mb_stride * (4*sizeof(int) + 1), fail); > + FF_ALLOC_OR_GOTO(er->er_temp_buffer, > + h->mb_height * h->mb_stride * (4*sizeof(int) + 1), ret, return ret); > > - FF_ALLOCZ_OR_GOTO(h->avctx, sl->dc_val_base, > - yc_size * sizeof(int16_t), fail); > + FF_ALLOCZ_OR_GOTO(sl->dc_val_base, > + yc_size * sizeof(int16_t), ret, return ret); > er->dc_val[0] = sl->dc_val_base + h->mb_width * 2 + 2; > er->dc_val[1] = sl->dc_val_base + y_size + h->mb_stride + 1; > er->dc_val[2] = er->dc_val[1] + c_size; > @@ -294,9 +292,6 @@ int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl) > } > > return 0; > - > -fail: > - return AVERROR(ENOMEM); // ff_h264_free_tables will clean up for us > } > > static int h264_init_context(AVCodecContext *avctx, H264Context *h) > diff --git a/libavcodec/iirfilter.c b/libavcodec/iirfilter.c > index b202515..e00cf39 100644 > --- a/libavcodec/iirfilter.c > +++ b/libavcodec/iirfilter.c > @@ -171,12 +171,12 @@ av_cold struct FFIIRFilterCoeffs *ff_iir_filter_init_coeffs(void *avc, > if (order <= 0 || order > MAXORDER || cutoff_ratio >= 1.0) > return NULL; > > - FF_ALLOCZ_OR_GOTO(avc, c, sizeof(FFIIRFilterCoeffs), > - init_fail); > - FF_ALLOC_OR_GOTO(avc, c->cx, sizeof(c->cx[0]) * ((order >> 1) + 1), > - init_fail); > - FF_ALLOC_OR_GOTO(avc, c->cy, sizeof(c->cy[0]) * order, > - init_fail); > + FF_ALLOCZ_OR_GOTO(c, sizeof(FFIIRFilterCoeffs), > + ret, goto init_fail); > + FF_ALLOC_OR_GOTO(c->cx, sizeof(c->cx[0]) * ((order >> 1) + 1), > + ret, goto init_fail); > + FF_ALLOC_OR_GOTO(c->cy, sizeof(c->cy[0]) * order, > + ret, goto init_fail); > c->order = order; > > switch (filt_type) { > diff --git a/libavcodec/mpegpicture.c b/libavcodec/mpegpicture.c > index 5fce25e..7d70cc8 100644 > --- a/libavcodec/mpegpicture.c > +++ b/libavcodec/mpegpicture.c > @@ -60,6 +60,7 @@ int ff_mpeg_framesize_alloc(AVCodecContext *avctx, MotionEstContext *me, > { > # define EMU_EDGE_HEIGHT (4 * 70) > int alloc_size = FFALIGN(FFABS(linesize) + 64, 32); > + int ret; > > if (avctx->hwaccel) > return 0; > @@ -78,11 +79,11 @@ int ff_mpeg_framesize_alloc(AVCodecContext *avctx, MotionEstContext *me, > // at uvlinesize. It supports only YUV420 so 24x24 is enough > // linesize * interlaced * MBsize > // we also use this buffer for encoding in encode_mb_internal() needig an additional 32 lines > - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, sc->edge_emu_buffer, alloc_size, EMU_EDGE_HEIGHT, > - fail); > + FF_ALLOCZ_ARRAY_OR_GOTO(sc->edge_emu_buffer, alloc_size, EMU_EDGE_HEIGHT, > + ret, goto fail); > > - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, me->scratchpad, alloc_size, 4 * 16 * 2, > - fail) > + FF_ALLOCZ_ARRAY_OR_GOTO(me->scratchpad, alloc_size, 4 * 16 * 2, > + ret, goto fail) > me->temp = me->scratchpad; > sc->rd_scratchpad = me->scratchpad; > sc->b_scratchpad = me->scratchpad; > @@ -91,7 +92,7 @@ int ff_mpeg_framesize_alloc(AVCodecContext *avctx, MotionEstContext *me, > return 0; > fail: > av_freep(&sc->edge_emu_buffer); > - return AVERROR(ENOMEM); > + return ret; > } > > /** > diff --git a/libavcodec/mpegvideo.c b/libavcodec/mpegvideo.c > index 49fd1c9..aaf1b40 100644 > --- a/libavcodec/mpegvideo.c > +++ b/libavcodec/mpegvideo.c > @@ -360,6 +360,7 @@ static int init_duplicate_context(MpegEncContext *s) > int c_size = s->mb_stride * (s->mb_height + 1); > int yc_size = y_size + 2 * c_size; > int i; > + int ret; > > if (s->mb_height & 1) > yc_size += 2*s->b8_stride + 2*s->mb_stride; > @@ -372,25 +373,22 @@ static int init_duplicate_context(MpegEncContext *s) > s->sc.obmc_scratchpad = NULL; > > if (s->encoding) { > - FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map, > - ME_MAP_SIZE * sizeof(uint32_t), fail) > - FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map, > - ME_MAP_SIZE * sizeof(uint32_t), fail) > + FF_ALLOCZ_OR_GOTO(s->me.map, ME_MAP_SIZE * sizeof(uint32_t), ret, return ret) > + FF_ALLOCZ_OR_GOTO(s->me.score_map, ME_MAP_SIZE * sizeof(uint32_t), ret, return ret) > if (s->noise_reduction) { > - FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum, > - 2 * 64 * sizeof(int), fail) > + FF_ALLOCZ_OR_GOTO(s->dct_error_sum, 2 * 64 * sizeof(int), ret, return ret) > } > } > - FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(int16_t), fail) > + FF_ALLOCZ_OR_GOTO(s->blocks, 64 * 12 * 2 * sizeof(int16_t), ret, return ret) > s->block = s->blocks[0]; > > for (i = 0; i < 12; i++) { > s->pblocks[i] = &s->block[i]; > } > > - FF_ALLOCZ_OR_GOTO(s->avctx, s->block32, sizeof(*s->block32), fail) > + FF_ALLOCZ_OR_GOTO(s->block32, sizeof(*s->block32), ret, return ret) > s->dpcm_direction = 0; > - FF_ALLOCZ_OR_GOTO(s->avctx, s->dpcm_macroblock, sizeof(*s->dpcm_macroblock), fail) > + FF_ALLOCZ_OR_GOTO(s->dpcm_macroblock, sizeof(*s->dpcm_macroblock), ret, return ret) > > if (s->avctx->codec_tag == AV_RL32("VCR2")) { > // exchange uv > @@ -399,16 +397,13 @@ static int init_duplicate_context(MpegEncContext *s) > > if (s->out_format == FMT_H263) { > /* ac values */ > - FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base, > - yc_size * sizeof(int16_t) * 16, fail); > + FF_ALLOCZ_OR_GOTO(s->ac_val_base, yc_size * sizeof(int16_t) * 16, ret, return ret); > s->ac_val[0] = s->ac_val_base + s->b8_stride + 1; > s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1; > s->ac_val[2] = s->ac_val[1] + c_size; > } > > return 0; > -fail: > - return AVERROR(ENOMEM); // free() through ff_mpv_common_end() > } > > static void free_duplicate_context(MpegEncContext *s) > @@ -687,6 +682,7 @@ void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx) > static int init_context_frame(MpegEncContext *s) > { > int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y; > + int ret; > > s->mb_width = (s->width + 15) / 16; > s->mb_stride = s->mb_width + 1; > @@ -715,8 +711,8 @@ static int init_context_frame(MpegEncContext *s) > if (s->mb_height & 1) > yc_size += 2*s->b8_stride + 2*s->mb_stride; > > - FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), > - fail); // error resilience code looks cleaner with this > + FF_ALLOCZ_OR_GOTO(s->mb_index2xy, (s->mb_num + 1) * sizeof(int), > + ret, return ret); // error resilience code looks cleaner with this > for (y = 0; y < s->mb_height; y++) > for (x = 0; x < s->mb_width; x++) > s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride; > @@ -725,12 +721,12 @@ static int init_context_frame(MpegEncContext *s) > > if (s->encoding) { > /* Allocate MV tables */ > - FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail) > - FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail) > - FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail) > - FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail) > - FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail) > - FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail) > + FF_ALLOCZ_OR_GOTO(s->p_mv_table_base, mv_table_size * 2 * sizeof(int16_t), ret, return ret) > + FF_ALLOCZ_OR_GOTO(s->b_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), ret, return ret) > + FF_ALLOCZ_OR_GOTO(s->b_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), ret, return ret) > + FF_ALLOCZ_OR_GOTO(s->b_bidir_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), ret, return ret) > + FF_ALLOCZ_OR_GOTO(s->b_bidir_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), ret, return ret) > + FF_ALLOCZ_OR_GOTO(s->b_direct_mv_table_base, mv_table_size * 2 * sizeof(int16_t), ret, return ret) > s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1; > s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1; > s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1; > @@ -739,14 +735,14 @@ static int init_context_frame(MpegEncContext *s) > s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1; > > /* Allocate MB type table */ > - FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size * sizeof(uint16_t), fail) // needed for encoding > + FF_ALLOCZ_OR_GOTO(s->mb_type, mb_array_size * sizeof(uint16_t), ret, return ret) // needed for encoding > > - FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail) > + FF_ALLOCZ_OR_GOTO(s->lambda_table, mb_array_size * sizeof(int), ret, return ret) > > - FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab, > - mb_array_size * sizeof(float), fail); > - FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab, > - mb_array_size * sizeof(float), fail); > + FF_ALLOC_OR_GOTO(s->cplx_tab, > + mb_array_size * sizeof(float), ret, return ret); > + FF_ALLOC_OR_GOTO(s->bits_tab, > + mb_array_size * sizeof(float), ret, return ret); > > } > > @@ -757,34 +753,33 @@ static int init_context_frame(MpegEncContext *s) > int j, k; > for (j = 0; j < 2; j++) { > for (k = 0; k < 2; k++) { > - FF_ALLOCZ_OR_GOTO(s->avctx, > - s->b_field_mv_table_base[i][j][k], > + FF_ALLOCZ_OR_GOTO(s->b_field_mv_table_base[i][j][k], > mv_table_size * 2 * sizeof(int16_t), > - fail); > + ret, return ret); > s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + > s->mb_stride + 1; > } > - FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail) > - FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail) > + FF_ALLOCZ_OR_GOTO(s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), ret, return ret) > + FF_ALLOCZ_OR_GOTO(s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), ret, return ret) > s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1; > } > - FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail) > + FF_ALLOCZ_OR_GOTO(s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), ret, return ret) > } > } > if (s->out_format == FMT_H263) { > /* cbp values */ > - FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size + (s->mb_height&1)*2*s->b8_stride, fail); > + FF_ALLOCZ_OR_GOTO(s->coded_block_base, y_size + (s->mb_height&1)*2*s->b8_stride, ret, return ret); > s->coded_block = s->coded_block_base + s->b8_stride + 1; > > /* cbp, ac_pred, pred_dir */ > - FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table , mb_array_size * sizeof(uint8_t), fail); > - FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail); > + FF_ALLOCZ_OR_GOTO(s->cbp_table , mb_array_size * sizeof(uint8_t), ret, return ret); > + FF_ALLOCZ_OR_GOTO(s->pred_dir_table, mb_array_size * sizeof(uint8_t), ret, return ret); > } > > if (s->h263_pred || s->h263_plus || !s->encoding) { > /* dc values */ > // MN: we need these for error resilience of intra-frames > - FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail); > + FF_ALLOCZ_OR_GOTO(s->dc_val_base, yc_size * sizeof(int16_t), ret, return ret); > s->dc_val[0] = s->dc_val_base + s->b8_stride + 1; > s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1; > s->dc_val[2] = s->dc_val[1] + c_size; > @@ -793,16 +788,14 @@ static int init_context_frame(MpegEncContext *s) > } > > /* which mb is an intra block */ > - FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail); > + FF_ALLOCZ_OR_GOTO(s->mbintra_table, mb_array_size, ret, return ret); > memset(s->mbintra_table, 1, mb_array_size); > > /* init macroblock skip table */ > - FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail); > + FF_ALLOCZ_OR_GOTO(s->mbskip_table, mb_array_size + 2, ret, return ret); > // Note the + 1 is for a quicker MPEG-4 slice_end detection > > return ff_mpeg_er_init(s); > -fail: > - return AVERROR(ENOMEM); > } > > static void clear_context(MpegEncContext *s) > @@ -934,8 +927,7 @@ av_cold int ff_mpv_common_init(MpegEncContext *s) > if (ret) > return ret; > > - FF_ALLOCZ_OR_GOTO(s->avctx, s->picture, > - MAX_PICTURE_COUNT * sizeof(Picture), fail_nomem); > + FF_ALLOCZ_OR_GOTO(s->picture, MAX_PICTURE_COUNT * sizeof(Picture), ret, return ret); > for (i = 0; i < MAX_PICTURE_COUNT; i++) { > s->picture[i].f = av_frame_alloc(); > if (!s->picture[i].f) > diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c > index 50ae57e..bc0fc4f 100644 > --- a/libavcodec/mpegvideo_enc.c > +++ b/libavcodec/mpegvideo_enc.c > @@ -924,27 +924,23 @@ FF_ENABLE_DEPRECATION_WARNINGS > ff_qpeldsp_init(&s->qdsp); > > if (s->msmpeg4_version) { > - FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, > - 2 * 2 * (MAX_LEVEL + 1) * > - (MAX_RUN + 1) * 2 * sizeof(int), fail); > + FF_ALLOCZ_OR_GOTO(s->ac_stats, 2 * 2 * (MAX_LEVEL + 1) * > + (MAX_RUN + 1) * 2 * sizeof(int), ret, return ret); > } > - FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail); > + FF_ALLOCZ_OR_GOTO(s->avctx->stats_out, 256, ret, return ret); > > - FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix, 64 * 32 * sizeof(int), fail); > - FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix, 64 * 32 * sizeof(int), fail); > - FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix, 64 * 32 * sizeof(int), fail); > - FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail); > - FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail); > - FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail); > - FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, > - MAX_PICTURE_COUNT * sizeof(Picture *), fail); > - FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, > - MAX_PICTURE_COUNT * sizeof(Picture *), fail); > + FF_ALLOCZ_OR_GOTO(s->q_intra_matrix, 64 * 32 * sizeof(int), ret, return ret); > + FF_ALLOCZ_OR_GOTO(s->q_chroma_intra_matrix, 64 * 32 * sizeof(int), ret, return ret); > + FF_ALLOCZ_OR_GOTO(s->q_inter_matrix, 64 * 32 * sizeof(int), ret, return ret); > + FF_ALLOCZ_OR_GOTO(s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), ret, return ret); > + FF_ALLOCZ_OR_GOTO(s->q_chroma_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), ret, return ret); > + FF_ALLOCZ_OR_GOTO(s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), ret, return ret); > + FF_ALLOCZ_OR_GOTO(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture *), ret, return ret); > + FF_ALLOCZ_OR_GOTO(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture *), ret, return ret); > > > if (s->noise_reduction) { > - FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, > - 2 * 64 * sizeof(uint16_t), fail); > + FF_ALLOCZ_OR_GOTO(s->dct_offset, 2 * 64 * sizeof(uint16_t), ret, return ret); > } > > ff_dct_encode_init(s); > @@ -1059,9 +1055,6 @@ FF_ENABLE_DEPRECATION_WARNINGS > cpb_props->buffer_size = avctx->rc_buffer_size; > > return 0; > -fail: > - ff_mpv_encode_end(avctx); > - return AVERROR_UNKNOWN; > } > > av_cold int ff_mpv_encode_end(AVCodecContext *avctx) > diff --git a/libavcodec/snow.c b/libavcodec/snow.c > index a3e6afc..07c3d5e 100644 > --- a/libavcodec/snow.c > +++ b/libavcodec/snow.c > @@ -431,6 +431,7 @@ av_cold int ff_snow_common_init(AVCodecContext *avctx){ > SnowContext *s = avctx->priv_data; > int width, height; > int i, j; > + int ret; > > s->avctx= avctx; > s->max_ref_frames=1; //just make sure it's not an invalid value in case of no initial keyframe > @@ -487,28 +488,26 @@ av_cold int ff_snow_common_init(AVCodecContext *avctx){ > width= s->avctx->width; > height= s->avctx->height; > > - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->spatial_idwt_buffer, width, height * sizeof(IDWTELEM), fail); > - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->spatial_dwt_buffer, width, height * sizeof(DWTELEM), fail); //FIXME this does not belong here > - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->temp_dwt_buffer, width, sizeof(DWTELEM), fail); > - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->temp_idwt_buffer, width, sizeof(IDWTELEM), fail); > - FF_ALLOC_ARRAY_OR_GOTO(avctx, s->run_buffer, ((width + 1) >> 1), ((height + 1) >> 1) * sizeof(*s->run_buffer), fail); > + FF_ALLOCZ_ARRAY_OR_GOTO(s->spatial_idwt_buffer, width, height * sizeof(IDWTELEM), ret, return ret); > + FF_ALLOCZ_ARRAY_OR_GOTO(s->spatial_dwt_buffer, width, height * sizeof(DWTELEM), ret, return ret); //FIXME this does not belong here > + FF_ALLOCZ_ARRAY_OR_GOTO(s->temp_dwt_buffer, width, sizeof(DWTELEM), ret, return ret); > + FF_ALLOCZ_ARRAY_OR_GOTO(s->temp_idwt_buffer, width, sizeof(IDWTELEM), ret, return ret); > + FF_ALLOC_ARRAY_OR_GOTO(s->run_buffer, ((width + 1) >> 1), ((height + 1) >> 1) * sizeof(*s->run_buffer), ret, return ret); > > for(i=0; i<MAX_REF_FRAMES; i++) { > for(j=0; j<MAX_REF_FRAMES; j++) > ff_scale_mv_ref[i][j] = 256*(i+1)/(j+1); > s->last_picture[i] = av_frame_alloc(); > if (!s->last_picture[i]) > - goto fail; > + return AVERROR(ENOMEM); > } > > s->mconly_picture = av_frame_alloc(); > s->current_picture = av_frame_alloc(); > if (!s->mconly_picture || !s->current_picture) > - goto fail; > + return AVERROR(ENOMEM); > > return 0; > -fail: > - return AVERROR(ENOMEM); > } > > int ff_snow_common_init_after_header(AVCodecContext *avctx) { > @@ -520,9 +519,9 @@ int ff_snow_common_init_after_header(AVCodecContext *avctx) { > if ((ret = ff_get_buffer(s->avctx, s->mconly_picture, > AV_GET_BUFFER_FLAG_REF)) < 0) > return ret; > - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->scratchbuf, FFMAX(s->mconly_picture->linesize[0], 2*avctx->width+256), 7*MB_SIZE, fail); > + FF_ALLOCZ_ARRAY_OR_GOTO(s->scratchbuf, FFMAX(s->mconly_picture->linesize[0], 2*avctx->width+256), 7*MB_SIZE, ret, return ret); > emu_buf_size = FFMAX(s->mconly_picture->linesize[0], 2*avctx->width+256) * (2 * MB_SIZE + HTAPS_MAX - 1); > - FF_ALLOC_OR_GOTO(avctx, s->emu_edge_buffer, emu_buf_size, fail); > + FF_ALLOC_OR_GOTO(s->emu_edge_buffer, emu_buf_size, ret, return ret); > } > > if(s->mconly_picture->format != avctx->pix_fmt) { > @@ -571,7 +570,7 @@ int ff_snow_common_init_after_header(AVCodecContext *avctx) { > av_freep(&b->x_coeff); > b->x_coeff=av_mallocz_array(((b->width+1) * b->height+1), sizeof(x_and_coeff)); > if (!b->x_coeff) > - goto fail; > + return AVERROR(ENOMEM); > } > w= (w+1)>>1; > h= (h+1)>>1; > @@ -579,8 +578,6 @@ int ff_snow_common_init_after_header(AVCodecContext *avctx) { > } > > return 0; > -fail: > - return AVERROR(ENOMEM); > } > > #define USE_HALFPEL_PLANE 0 > diff --git a/libavcodec/twinvq.c b/libavcodec/twinvq.c > index 34ca184..74a3ba7 100644 > --- a/libavcodec/twinvq.c > +++ b/libavcodec/twinvq.c > @@ -546,24 +546,24 @@ static av_cold int init_mdct_win(TwinVQContext *tctx) > return ret; > } > > - FF_ALLOC_ARRAY_OR_GOTO(tctx->avctx, tctx->tmp_buf, > - mtab->size, sizeof(*tctx->tmp_buf), alloc_fail); > + FF_ALLOC_ARRAY_OR_GOTO(tctx->tmp_buf, > + mtab->size, sizeof(*tctx->tmp_buf), ret, return ret); > > - FF_ALLOC_ARRAY_OR_GOTO(tctx->avctx, tctx->spectrum, > + FF_ALLOC_ARRAY_OR_GOTO(tctx->spectrum, > 2 * mtab->size, channels * sizeof(*tctx->spectrum), > - alloc_fail); > - FF_ALLOC_ARRAY_OR_GOTO(tctx->avctx, tctx->curr_frame, > + ret, return ret); > + FF_ALLOC_ARRAY_OR_GOTO(tctx->curr_frame, > 2 * mtab->size, channels * sizeof(*tctx->curr_frame), > - alloc_fail); > - FF_ALLOC_ARRAY_OR_GOTO(tctx->avctx, tctx->prev_frame, > + ret, return ret); > + FF_ALLOC_ARRAY_OR_GOTO(tctx->prev_frame, > 2 * mtab->size, channels * sizeof(*tctx->prev_frame), > - alloc_fail); > + ret, return ret); > > for (i = 0; i < 3; i++) { > int m = 4 * mtab->size / mtab->fmode[i].sub; > double freq = 2 * M_PI / m; > - FF_ALLOC_ARRAY_OR_GOTO(tctx->avctx, tctx->cos_tabs[i], > - (m / 4), sizeof(*tctx->cos_tabs[i]), alloc_fail); > + FF_ALLOC_ARRAY_OR_GOTO(tctx->cos_tabs[i], > + (m / 4), sizeof(*tctx->cos_tabs[i]), ret, return ret); > > for (j = 0; j <= m / 8; j++) > tctx->cos_tabs[i][j] = cos((2 * j + 1) * freq); > @@ -576,9 +576,6 @@ static av_cold int init_mdct_win(TwinVQContext *tctx) > ff_init_ff_sine_windows(av_log2(mtab->size)); > > return 0; > - > -alloc_fail: > - return AVERROR(ENOMEM); > } > > /** > diff --git a/libavutil/internal.h b/libavutil/internal.h > index 4acbcf5..9cf5780 100644 > --- a/libavutil/internal.h > +++ b/libavutil/internal.h > @@ -137,39 +137,39 @@ > # define LOCAL_ALIGNED_32(t, v, ...) E1(LOCAL_ALIGNED_A(32, t, v, __VA_ARGS__,,)) > #endif > > -#define FF_ALLOC_OR_GOTO(ctx, p, size, label)\ > +#define FF_ALLOC_OR_GOTO(p, size, ret, errstatement)\ > {\ > p = av_malloc(size);\ > if (!(p) && (size) != 0) {\ > - av_log(ctx, AV_LOG_ERROR, "Cannot allocate memory.\n");\ > - goto label;\ > + ret = AVERROR(ENOMEM);\ > + errstatement;\ > }\ > } > > -#define FF_ALLOCZ_OR_GOTO(ctx, p, size, label)\ > +#define FF_ALLOCZ_OR_GOTO(p, size, ret, errstatement)\ > {\ > p = av_mallocz(size);\ > if (!(p) && (size) != 0) {\ > - av_log(ctx, AV_LOG_ERROR, "Cannot allocate memory.\n");\ > - goto label;\ > + ret = AVERROR(ENOMEM);\ > + errstatement;\ > }\ > } > > -#define FF_ALLOC_ARRAY_OR_GOTO(ctx, p, nelem, elsize, label)\ > +#define FF_ALLOC_ARRAY_OR_GOTO(p, nelem, elsize, ret, errstatement)\ > {\ > p = av_malloc_array(nelem, elsize);\ > if (!p) {\ > - av_log(ctx, AV_LOG_ERROR, "Cannot allocate memory.\n");\ > - goto label;\ > + ret = AVERROR(ENOMEM);\ > + errstatement;\ > }\ > } > > -#define FF_ALLOCZ_ARRAY_OR_GOTO(ctx, p, nelem, elsize, label)\ > +#define FF_ALLOCZ_ARRAY_OR_GOTO(p, nelem, elsize, ret, errstatement)\ > {\ > p = av_mallocz_array(nelem, elsize);\ > if (!p) {\ > - av_log(ctx, AV_LOG_ERROR, "Cannot allocate memory.\n");\ > - goto label;\ > + ret = AVERROR(ENOMEM);\ > + errstatement;\ > }\ > } > > diff --git a/libswscale/utils.c b/libswscale/utils.c > index 15c0a19..8ff6a9c 100644 > --- a/libswscale/utils.c > +++ b/libswscale/utils.c > @@ -352,13 +352,13 @@ static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, > emms_c(); // FIXME should not be required but IS (even for non-MMX versions) > > // NOTE: the +3 is for the MMX(+1) / SSE(+3) scaler which reads over the end > - FF_ALLOC_ARRAY_OR_GOTO(NULL, *filterPos, (dstW + 3), sizeof(**filterPos), fail); > + FF_ALLOC_ARRAY_OR_GOTO(*filterPos, (dstW + 3), sizeof(**filterPos), ret, goto fail); > > if (FFABS(xInc - 0x10000) < 10 && srcPos == dstPos) { // unscaled > int i; > filterSize = 1; > - FF_ALLOCZ_ARRAY_OR_GOTO(NULL, filter, > - dstW, sizeof(*filter) * filterSize, fail); > + FF_ALLOCZ_ARRAY_OR_GOTO(filter, > + dstW, sizeof(*filter) * filterSize, ret, goto fail); > > for (i = 0; i < dstW; i++) { > filter[i * filterSize] = fone; > @@ -368,8 +368,8 @@ static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, > int i; > int64_t xDstInSrc; > filterSize = 1; > - FF_ALLOC_ARRAY_OR_GOTO(NULL, filter, > - dstW, sizeof(*filter) * filterSize, fail); > + FF_ALLOC_ARRAY_OR_GOTO(filter, > + dstW, sizeof(*filter) * filterSize, ret, goto fail); > > xDstInSrc = ((dstPos*(int64_t)xInc)>>8) - ((srcPos*0x8000LL)>>7); > for (i = 0; i < dstW; i++) { > @@ -384,8 +384,8 @@ static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, > int i; > int64_t xDstInSrc; > filterSize = 2; > - FF_ALLOC_ARRAY_OR_GOTO(NULL, filter, > - dstW, sizeof(*filter) * filterSize, fail); > + FF_ALLOC_ARRAY_OR_GOTO(filter, > + dstW, sizeof(*filter) * filterSize, ret, goto fail); > > xDstInSrc = ((dstPos*(int64_t)xInc)>>8) - ((srcPos*0x8000LL)>>7); > for (i = 0; i < dstW; i++) { > @@ -425,8 +425,8 @@ static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, > filterSize = FFMIN(filterSize, srcW - 2); > filterSize = FFMAX(filterSize, 1); > > - FF_ALLOC_ARRAY_OR_GOTO(NULL, filter, > - dstW, sizeof(*filter) * filterSize, fail); > + FF_ALLOC_ARRAY_OR_GOTO(filter, > + dstW, sizeof(*filter) * filterSize, ret, goto fail); > > xDstInSrc = ((dstPos*(int64_t)xInc)>>7) - ((srcPos*0x10000LL)>>7); > for (i = 0; i < dstW; i++) { > @@ -525,7 +525,7 @@ static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, > if (dstFilter) > filter2Size += dstFilter->length - 1; > av_assert0(filter2Size > 0); > - FF_ALLOCZ_ARRAY_OR_GOTO(NULL, filter2, dstW, filter2Size * sizeof(*filter2), fail); > + FF_ALLOCZ_ARRAY_OR_GOTO(filter2, dstW, filter2Size * sizeof(*filter2), ret, goto fail); > > for (i = 0; i < dstW; i++) { > int j, k; > @@ -684,8 +684,8 @@ static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, > > // Note the +1 is for the MMX scaler which reads over the end > /* align at 16 for AltiVec (needed by hScale_altivec_real) */ > - FF_ALLOCZ_ARRAY_OR_GOTO(NULL, *outFilter, > - (dstW + 3), *outFilterSize * sizeof(int16_t), fail); > + FF_ALLOCZ_ARRAY_OR_GOTO(*outFilter, > + (dstW + 3), *outFilterSize * sizeof(int16_t), ret, goto fail); > > /* normalize & store in outFilter */ > for (i = 0; i < dstW; i++) { > @@ -1415,7 +1415,7 @@ av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter, > c->chrDstW = AV_CEIL_RSHIFT(dstW, c->chrDstHSubSample); > c->chrDstH = AV_CEIL_RSHIFT(dstH, c->chrDstVSubSample); > > - FF_ALLOCZ_OR_GOTO(c, c->formatConvBuffer, FFALIGN(srcW*2+78, 16) * 2, fail); > + FF_ALLOCZ_OR_GOTO(c->formatConvBuffer, FFALIGN(srcW*2+78, 16) * 2, ret, goto fail); > > c->srcBpc = desc_src->comp[0].depth; > if (c->srcBpc < 8) > @@ -1655,10 +1655,10 @@ av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter, > return AVERROR(ENOMEM); > } > > - FF_ALLOCZ_OR_GOTO(c, c->hLumFilter, (dstW / 8 + 8) * sizeof(int16_t), fail); > - FF_ALLOCZ_OR_GOTO(c, c->hChrFilter, (c->chrDstW / 4 + 8) * sizeof(int16_t), fail); > - FF_ALLOCZ_OR_GOTO(c, c->hLumFilterPos, (dstW / 2 / 8 + 8) * sizeof(int32_t), fail); > - FF_ALLOCZ_OR_GOTO(c, c->hChrFilterPos, (c->chrDstW / 2 / 4 + 8) * sizeof(int32_t), fail); > + FF_ALLOCZ_OR_GOTO(c->hLumFilter, (dstW / 8 + 8) * sizeof(int16_t), ret, goto fail); > + FF_ALLOCZ_OR_GOTO(c->hChrFilter, (c->chrDstW / 4 + 8) * sizeof(int16_t), ret, goto fail); > + FF_ALLOCZ_OR_GOTO(c->hLumFilterPos, (dstW / 2 / 8 + 8) * sizeof(int32_t), ret, goto fail); > + FF_ALLOCZ_OR_GOTO(c->hChrFilterPos, (c->chrDstW / 2 / 4 + 8) * sizeof(int32_t), ret, goto fail); > > ff_init_hscaler_mmxext( dstW, c->lumXInc, c->lumMmxextFilterCode, > c->hLumFilter, (uint32_t*)c->hLumFilterPos, 8); > @@ -1726,8 +1726,8 @@ av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter, > goto fail; > > #if HAVE_ALTIVEC > - FF_ALLOC_OR_GOTO(c, c->vYCoeffsBank, sizeof(vector signed short) * c->vLumFilterSize * c->dstH, fail); > - FF_ALLOC_OR_GOTO(c, c->vCCoeffsBank, sizeof(vector signed short) * c->vChrFilterSize * c->chrDstH, fail); > + FF_ALLOC_OR_GOTO(c->vYCoeffsBank, sizeof(vector signed short) * c->vLumFilterSize * c->dstH, ret, goto fail); > + FF_ALLOC_OR_GOTO(c->vCCoeffsBank, sizeof(vector signed short) * c->vChrFilterSize * c->chrDstH, ret, goto fail); > > for (i = 0; i < c->vLumFilterSize * c->dstH; i++) { > int j; > @@ -1746,7 +1746,7 @@ av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter, > } > > for (i = 0; i < 4; i++) > - FF_ALLOCZ_OR_GOTO(c, c->dither_error[i], (c->dstW+2) * sizeof(int), fail); > + FF_ALLOCZ_OR_GOTO(c->dither_error[i], (c->dstW+2) * sizeof(int), ret, goto fail); > > c->needAlpha = (CONFIG_SWSCALE_ALPHA && isALPHA(c->srcFormat) && isALPHA(c->dstFormat)) ? 1 : 0; > > -- > 2.6.4 > > _______________________________________________ > ffmpeg-devel mailing list > ffmpeg-devel@ffmpeg.org > https://ffmpeg.org/mailman/listinfo/ffmpeg-devel > > To unsubscribe, visit link above, or email > ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".
Marton Balint (12020-05-12): > > - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->buffer.samples, s->channels, 3 * 1024 * sizeof(s->buffer.samples[0]), alloc_fail); > > - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->cpe, s->chan_map[0], sizeof(ChannelElement), alloc_fail); > > + int ret, ch; > > + FF_ALLOCZ_ARRAY_OR_GOTO(s->buffer.samples, s->channels, 3 * 1024 * sizeof(s->buffer.samples[0]), ret, return ret); > > + FF_ALLOCZ_ARRAY_OR_GOTO(s->cpe, s->chan_map[0], sizeof(ChannelElement), ret, return ret); > > If you want to change the existing macro, then you have to rename it, > because it no longer does goto... Indeed. But also, it must do the same. Replacing a goto with a direct return is not correct. > Also I kind of disagree with Nicholas that we should always assign a ret > variable, I think a single error statement is better. For example in the > case above a goto fail is a lot nicer (and returning ENOMEM) there. This is a mistake because you invent the error code on the call site. The function/macro knows what the error code, the caller uses the error code. Otherwise, changes in the function/macro can leave the error code invalid. We should never let the caller assume the error code. Regards,
On Tue, 12 May 2020, Nicolas George wrote: > Marton Balint (12020-05-12): >>> - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->buffer.samples, s->channels, 3 * 1024 * sizeof(s->buffer.samples[0]), alloc_fail); >>> - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->cpe, s->chan_map[0], sizeof(ChannelElement), alloc_fail); >>> + int ret, ch; >>> + FF_ALLOCZ_ARRAY_OR_GOTO(s->buffer.samples, s->channels, 3 * 1024 * sizeof(s->buffer.samples[0]), ret, return ret); >>> + FF_ALLOCZ_ARRAY_OR_GOTO(s->cpe, s->chan_map[0], sizeof(ChannelElement), ret, return ret); >> >> If you want to change the existing macro, then you have to rename it, >> because it no longer does goto... > > Indeed. But also, it must do the same. Replacing a goto with a direct > return is not correct. > >> Also I kind of disagree with Nicholas that we should always assign a ret >> variable, I think a single error statement is better. For example in the >> case above a goto fail is a lot nicer (and returning ENOMEM) there. > > This is a mistake because you invent the error code on the call site. > The function/macro knows what the error code, the caller uses the error > code. Otherwise, changes in the function/macro can leave the error code > invalid. > > We should never let the caller assume the error code. And you assume that I want to assign the error code to ret. Wrong. What if I want to return it as is? Or what if I want to return NULL beacuse the function returns a pointer? Using variables is complicated. Constants make the code more simple and readable. Regards, Marton
Marton Balint (12020-05-12): > And you assume that I want to assign the error code to ret. Wrong. What if I > want to return it as is? Assign it to ret and forward ret. > Or what if I want to return NULL beacuse the > function returns a pointer? Bad design, fix it. > Using variables is complicated. Constants make > the code more simple and readable. Simpler now, much more complex later to fix the incorrect error codes. Regards,
On Tue, 12 May 2020, Nicolas George wrote: > Marton Balint (12020-05-12): >> And you assume that I want to assign the error code to ret. Wrong. What if I >> want to return it as is? > > Assign it to ret and forward ret. > >> Or what if I want to return NULL beacuse the >> function returns a pointer? > > Bad design, fix it. > >> Using variables is complicated. Constants make >> the code more simple and readable. > > Simpler now, much more complex later to fix the incorrect error codes. I think you want to force your preferred pattern to cases which clearly do not benefit from it. I still have to disagree. I suggest we make multilpe macros, and the user can decide which one to use. Regards, Marton
Marton Balint (12020-05-12): > I think you want to force your preferred pattern to cases which clearly do > not benefit from it. I want to prevent any pattern where the error code is lost or invented. We already had enough work old cases where we were not careful enough with it, I oppose to anything that could give us more similar work. If you do not like my proposal, feel free to make counter-proposals, but if they pose the risk of losing the error code or let the caller invent it, I will oppose them. Regards,
On Tue, 12 May 2020, Nicolas George wrote: > Marton Balint (12020-05-12): >> I think you want to force your preferred pattern to cases which clearly do >> not benefit from it. > > I want to prevent any pattern where the error code is lost or invented. > We already had enough work old cases where we were not careful enough > with it, I oppose to anything that could give us more similar work. > > If you do not like my proposal, feel free to make counter-proposals, but > if they pose the risk of losing the error code or let the caller invent > it, I will oppose them. Then I guess this patch got bikeshedded to pieces with no clear resolution. It was a cleanup attempt anyway, so I suggest the author to simply abandon it. Regards, Marton
Marton Balint (12020-05-12): > Then I guess this patch got bikeshedded to pieces with no clear resolution. > It was a cleanup attempt anyway, so I suggest the author to simply abandon > it. Do you mean you prefer to kill the patch than reach a consensus? Regards,
On Tue, May 12, 2020 at 07:58:29PM +0200, Nicolas George wrote: > Marton Balint (12020-05-12): > > And you assume that I want to assign the error code to ret. Wrong. What if I > > want to return it as is? > > Assign it to ret and forward ret. > > > Or what if I want to return NULL beacuse the > > function returns a pointer? > > Bad design, fix it. I have notice one such condition: ff_iir_filter_init_coeffs() in iirfilter.c will return NULL without error code. > > > Using variables is complicated. Constants make > > the code more simple and readable. > > Simpler now, much more complex later to fix the incorrect error codes. > > Regards, > > -- > Nicolas George > _______________________________________________ > ffmpeg-devel mailing list > ffmpeg-devel@ffmpeg.org > https://ffmpeg.org/mailman/listinfo/ffmpeg-devel > > To unsubscribe, visit link above, or email > ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".
On Tue, May 12, 2020 at 06:58:34PM +0200, Marton Balint wrote: > > > On Wed, 13 May 2020, lance.lmwang@gmail.com wrote: > > >From: Limin Wang <lance.lmwang@gmail.com> > > > >Please refer to the details here: > >https://patchwork.ffmpeg.org/project/ffmpeg/patch/1589212343-8334-1-git-send-email-lance.lmwang@gmail.com/ > > > >Suggested-by: Nicolas George <george@nsup.org> > >Signed-off-by: Limin Wang <lance.lmwang@gmail.com> > >--- > >libavcodec/aacenc.c | 8 ++-- > >libavcodec/ac3enc.c | 102 +++++++++++++++++++++---------------------- > >libavcodec/ac3enc_template.c | 15 +++---- > >libavcodec/adpcmenc.c | 35 +++++---------- > >libavcodec/alac.c | 17 +++----- > >libavcodec/apedec.c | 9 ++-- > >libavcodec/dnxhdenc.c | 73 +++++++++++++++---------------- > >libavcodec/h264dec.c | 69 ++++++++++++++--------------- > >libavcodec/iirfilter.c | 12 ++--- > >libavcodec/mpegpicture.c | 11 ++--- > >libavcodec/mpegvideo.c | 78 +++++++++++++++------------------ > >libavcodec/mpegvideo_enc.c | 31 +++++-------- > >libavcodec/snow.c | 25 +++++------ > >libavcodec/twinvq.c | 23 +++++----- > >libavutil/internal.h | 24 +++++----- > >libswscale/utils.c | 40 ++++++++--------- > >16 files changed, 260 insertions(+), 312 deletions(-) > > > >diff --git a/libavcodec/aacenc.c b/libavcodec/aacenc.c > >index 4d0abb1..9855e40 100644 > >--- a/libavcodec/aacenc.c > >+++ b/libavcodec/aacenc.c > >@@ -939,16 +939,14 @@ static av_cold int dsp_init(AVCodecContext *avctx, AACEncContext *s) > > > >static av_cold int alloc_buffers(AVCodecContext *avctx, AACEncContext *s) > >{ > >- int ch; > >- FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->buffer.samples, s->channels, 3 * 1024 * sizeof(s->buffer.samples[0]), alloc_fail); > >- FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->cpe, s->chan_map[0], sizeof(ChannelElement), alloc_fail); > >+ int ret, ch; > >+ FF_ALLOCZ_ARRAY_OR_GOTO(s->buffer.samples, s->channels, 3 * 1024 * sizeof(s->buffer.samples[0]), ret, return ret); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(s->cpe, s->chan_map[0], sizeof(ChannelElement), ret, return ret); > > If you want to change the existing macro, then you have to rename > it, because it no longer does goto... > sorry, I forgot to change it > Also I kind of disagree with Nicholas that we should always assign a > ret variable, I think a single error statement is better. For > example in the case above a goto fail is a lot nicer (and returning > ENOMEM) there. > > Please wait a bit before a conclusion is reached about the macro, > and only implement it later. > > Also this patch is non-trivial now, and some changes are definitely > not OK (e.g removing ff_h264_free_tables(h) and similar cleanup > functions from the failure path). Yes, I notice it and it's better to keep goto without return first. If you're failed to disagree with Nicholas, I'll not update anymore. > > Regards, > Marton > > > > > > for(ch = 0; ch < s->channels; ch++) > > s->planar_samples[ch] = s->buffer.samples + 3 * 1024 * ch; > > > > return 0; > >-alloc_fail: > >- return AVERROR(ENOMEM); > >} > > > >static av_cold void aac_encode_init_tables(void) > >diff --git a/libavcodec/ac3enc.c b/libavcodec/ac3enc.c > >index ddbc7b2..19434d4 100644 > >--- a/libavcodec/ac3enc.c > >+++ b/libavcodec/ac3enc.c > >@@ -2322,60 +2322,60 @@ static av_cold void set_bandwidth(AC3EncodeContext *s) > > > >static av_cold int allocate_buffers(AC3EncodeContext *s) > >{ > >- AVCodecContext *avctx = s->avctx; > > int blk, ch; > > int channels = s->channels + 1; /* includes coupling channel */ > > int channel_blocks = channels * s->num_blocks; > > int total_coefs = AC3_MAX_COEFS * channel_blocks; > >+ int ret; > >+ > >+ if (ret = s->allocate_sample_buffers(s)) > >+ return ret; > > > >- if (s->allocate_sample_buffers(s)) > >- goto alloc_fail; > >- > >- FF_ALLOC_ARRAY_OR_GOTO(avctx, s->bap_buffer, total_coefs, > >- sizeof(*s->bap_buffer), alloc_fail); > >- FF_ALLOC_ARRAY_OR_GOTO(avctx, s->bap1_buffer, total_coefs, > >- sizeof(*s->bap1_buffer), alloc_fail); > >- FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->mdct_coef_buffer, total_coefs, > >- sizeof(*s->mdct_coef_buffer), alloc_fail); > >- FF_ALLOC_ARRAY_OR_GOTO(avctx, s->exp_buffer, total_coefs, > >- sizeof(*s->exp_buffer), alloc_fail); > >- FF_ALLOC_ARRAY_OR_GOTO(avctx, s->grouped_exp_buffer, channel_blocks, 128 * > >- sizeof(*s->grouped_exp_buffer), alloc_fail); > >- FF_ALLOC_ARRAY_OR_GOTO(avctx, s->psd_buffer, total_coefs, > >- sizeof(*s->psd_buffer), alloc_fail); > >- FF_ALLOC_ARRAY_OR_GOTO(avctx, s->band_psd_buffer, channel_blocks, 64 * > >- sizeof(*s->band_psd_buffer), alloc_fail); > >- FF_ALLOC_ARRAY_OR_GOTO(avctx, s->mask_buffer, channel_blocks, 64 * > >- sizeof(*s->mask_buffer), alloc_fail); > >- FF_ALLOC_ARRAY_OR_GOTO(avctx, s->qmant_buffer, total_coefs, > >- sizeof(*s->qmant_buffer), alloc_fail); > >+ FF_ALLOC_ARRAY_OR_GOTO(s->bap_buffer, total_coefs, > >+ sizeof(*s->bap_buffer), ret, return ret); > >+ FF_ALLOC_ARRAY_OR_GOTO(s->bap1_buffer, total_coefs, > >+ sizeof(*s->bap1_buffer), ret, return ret); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(s->mdct_coef_buffer, total_coefs, > >+ sizeof(*s->mdct_coef_buffer), ret, return ret); > >+ FF_ALLOC_ARRAY_OR_GOTO(s->exp_buffer, total_coefs, > >+ sizeof(*s->exp_buffer), ret, return ret); > >+ FF_ALLOC_ARRAY_OR_GOTO(s->grouped_exp_buffer, channel_blocks, 128 * > >+ sizeof(*s->grouped_exp_buffer), ret, return ret); > >+ FF_ALLOC_ARRAY_OR_GOTO(s->psd_buffer, total_coefs, > >+ sizeof(*s->psd_buffer), ret, return ret); > >+ FF_ALLOC_ARRAY_OR_GOTO(s->band_psd_buffer, channel_blocks, 64 * > >+ sizeof(*s->band_psd_buffer), ret, return ret); > >+ FF_ALLOC_ARRAY_OR_GOTO(s->mask_buffer, channel_blocks, 64 * > >+ sizeof(*s->mask_buffer), ret, return ret); > >+ FF_ALLOC_ARRAY_OR_GOTO(s->qmant_buffer, total_coefs, > >+ sizeof(*s->qmant_buffer), ret, return ret); > > if (s->cpl_enabled) { > >- FF_ALLOC_ARRAY_OR_GOTO(avctx, s->cpl_coord_exp_buffer, channel_blocks, 16 * > >- sizeof(*s->cpl_coord_exp_buffer), alloc_fail); > >- FF_ALLOC_ARRAY_OR_GOTO(avctx, s->cpl_coord_mant_buffer, channel_blocks, 16 * > >- sizeof(*s->cpl_coord_mant_buffer), alloc_fail); > >+ FF_ALLOC_ARRAY_OR_GOTO(s->cpl_coord_exp_buffer, channel_blocks, 16 * > >+ sizeof(*s->cpl_coord_exp_buffer), ret, return ret); > >+ FF_ALLOC_ARRAY_OR_GOTO(s->cpl_coord_mant_buffer, channel_blocks, 16 * > >+ sizeof(*s->cpl_coord_mant_buffer), ret, return ret); > > } > > for (blk = 0; blk < s->num_blocks; blk++) { > > AC3Block *block = &s->blocks[blk]; > >- FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->mdct_coef, channels, sizeof(*block->mdct_coef), > >- alloc_fail); > >- FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->exp, channels, sizeof(*block->exp), > >- alloc_fail); > >- FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->grouped_exp, channels, sizeof(*block->grouped_exp), > >- alloc_fail); > >- FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->psd, channels, sizeof(*block->psd), > >- alloc_fail); > >- FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->band_psd, channels, sizeof(*block->band_psd), > >- alloc_fail); > >- FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->mask, channels, sizeof(*block->mask), > >- alloc_fail); > >- FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->qmant, channels, sizeof(*block->qmant), > >- alloc_fail); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(block->mdct_coef, channels, sizeof(*block->mdct_coef), > >+ ret, return ret); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(block->exp, channels, sizeof(*block->exp), > >+ ret, return ret); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(block->grouped_exp, channels, sizeof(*block->grouped_exp), > >+ ret, return ret); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(block->psd, channels, sizeof(*block->psd), > >+ ret, return ret); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(block->band_psd, channels, sizeof(*block->band_psd), > >+ ret, return ret); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(block->mask, channels, sizeof(*block->mask), > >+ ret, return ret); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(block->qmant, channels, sizeof(*block->qmant), > >+ ret, return ret); > > if (s->cpl_enabled) { > >- FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->cpl_coord_exp, channels, sizeof(*block->cpl_coord_exp), > >- alloc_fail); > >- FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->cpl_coord_mant, channels, sizeof(*block->cpl_coord_mant), > >- alloc_fail); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(block->cpl_coord_exp, channels, sizeof(*block->cpl_coord_exp), > >+ ret, return ret); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(block->cpl_coord_mant, channels, sizeof(*block->cpl_coord_mant), > >+ ret, return ret); > > } > > > > for (ch = 0; ch < channels; ch++) { > >@@ -2397,28 +2397,26 @@ static av_cold int allocate_buffers(AC3EncodeContext *s) > > } > > > > if (!s->fixed_point) { > >- FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->fixed_coef_buffer, total_coefs, > >- sizeof(*s->fixed_coef_buffer), alloc_fail); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(s->fixed_coef_buffer, total_coefs, > >+ sizeof(*s->fixed_coef_buffer), ret, return ret); > > for (blk = 0; blk < s->num_blocks; blk++) { > > AC3Block *block = &s->blocks[blk]; > >- FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->fixed_coef, channels, > >- sizeof(*block->fixed_coef), alloc_fail); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(block->fixed_coef, channels, > >+ sizeof(*block->fixed_coef), ret, return ret); > > for (ch = 0; ch < channels; ch++) > > block->fixed_coef[ch] = &s->fixed_coef_buffer[AC3_MAX_COEFS * (s->num_blocks * ch + blk)]; > > } > > } else { > > for (blk = 0; blk < s->num_blocks; blk++) { > > AC3Block *block = &s->blocks[blk]; > >- FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->fixed_coef, channels, > >- sizeof(*block->fixed_coef), alloc_fail); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(block->fixed_coef, channels, > >+ sizeof(*block->fixed_coef), ret, return ret); > > for (ch = 0; ch < channels; ch++) > > block->fixed_coef[ch] = (int32_t *)block->mdct_coef[ch]; > > } > > } > > > > return 0; > >-alloc_fail: > >- return AVERROR(ENOMEM); > >} > > > > > >diff --git a/libavcodec/ac3enc_template.c b/libavcodec/ac3enc_template.c > >index be65987..ec4e984 100644 > >--- a/libavcodec/ac3enc_template.c > >+++ b/libavcodec/ac3enc_template.c > >@@ -39,21 +39,20 @@ > > > >int AC3_NAME(allocate_sample_buffers)(AC3EncodeContext *s) > >{ > >+ int ret; > > int ch; > > > >- FF_ALLOC_OR_GOTO(s->avctx, s->windowed_samples, AC3_WINDOW_SIZE * > >- sizeof(*s->windowed_samples), alloc_fail); > >- FF_ALLOC_ARRAY_OR_GOTO(s->avctx, s->planar_samples, s->channels, sizeof(*s->planar_samples), > >- alloc_fail); > >+ FF_ALLOC_OR_GOTO(s->windowed_samples, AC3_WINDOW_SIZE * > >+ sizeof(*s->windowed_samples), ret, return ret); > >+ FF_ALLOC_ARRAY_OR_GOTO(s->planar_samples, s->channels, sizeof(*s->planar_samples), > >+ ret, return ret); > > for (ch = 0; ch < s->channels; ch++) { > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->planar_samples[ch], > >+ FF_ALLOCZ_OR_GOTO(s->planar_samples[ch], > > (AC3_FRAME_SIZE+AC3_BLOCK_SIZE) * sizeof(**s->planar_samples), > >- alloc_fail); > >+ ret, return ret); > > } > > > > return 0; > >-alloc_fail: > >- return AVERROR(ENOMEM); > >} > > > > > >diff --git a/libavcodec/adpcmenc.c b/libavcodec/adpcmenc.c > >index 668939c..18d08fd 100644 > >--- a/libavcodec/adpcmenc.c > >+++ b/libavcodec/adpcmenc.c > >@@ -65,7 +65,7 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx) > > ADPCMEncodeContext *s = avctx->priv_data; > > uint8_t *extradata; > > int i; > >- int ret = AVERROR(ENOMEM); > >+ int ret; > > > > if (avctx->channels > 2) { > > av_log(avctx, AV_LOG_ERROR, "only stereo or mono is supported\n"); > >@@ -80,14 +80,10 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx) > > if (avctx->trellis) { > > int frontier = 1 << avctx->trellis; > > int max_paths = frontier * FREEZE_INTERVAL; > >- FF_ALLOC_OR_GOTO(avctx, s->paths, > >- max_paths * sizeof(*s->paths), error); > >- FF_ALLOC_OR_GOTO(avctx, s->node_buf, > >- 2 * frontier * sizeof(*s->node_buf), error); > >- FF_ALLOC_OR_GOTO(avctx, s->nodep_buf, > >- 2 * frontier * sizeof(*s->nodep_buf), error); > >- FF_ALLOC_OR_GOTO(avctx, s->trellis_hash, > >- 65536 * sizeof(*s->trellis_hash), error); > >+ FF_ALLOC_OR_GOTO(s->paths, max_paths * sizeof(*s->paths), ret, return ret); > >+ FF_ALLOC_OR_GOTO(s->node_buf, 2 * frontier * sizeof(*s->node_buf), ret, return ret); > >+ FF_ALLOC_OR_GOTO(s->nodep_buf, 2 * frontier * sizeof(*s->nodep_buf), ret, return ret); > >+ FF_ALLOC_OR_GOTO(s->trellis_hash, 65536 * sizeof(*s->trellis_hash), ret, return ret); > > } > > > > avctx->bits_per_coded_sample = av_get_bits_per_sample(avctx->codec->id); > >@@ -114,7 +110,7 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx) > > avctx->bits_per_coded_sample = 4; > > avctx->block_align = BLKSIZE; > > if (!(avctx->extradata = av_malloc(32 + AV_INPUT_BUFFER_PADDING_SIZE))) > >- goto error; > >+ return AVERROR(ENOMEM); > > avctx->extradata_size = 32; > > extradata = avctx->extradata; > > bytestream_put_le16(&extradata, avctx->frame_size); > >@@ -134,20 +130,15 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx) > > avctx->sample_rate != 44100) { > > av_log(avctx, AV_LOG_ERROR, "Sample rate must be 11025, " > > "22050 or 44100\n"); > >- ret = AVERROR(EINVAL); > >- goto error; > >+ return AVERROR(EINVAL); > > } > > avctx->frame_size = 512 * (avctx->sample_rate / 11025); > > break; > > default: > >- ret = AVERROR(EINVAL); > >- goto error; > >+ return AVERROR(EINVAL); > > } > > > > return 0; > >-error: > >- adpcm_encode_close(avctx); > >- return ret; > >} > > > >static av_cold int adpcm_encode_close(AVCodecContext *avctx) > >@@ -509,7 +500,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, > > > > /* stereo: 4 bytes (8 samples) for left, 4 bytes for right */ > > if (avctx->trellis > 0) { > >- FF_ALLOC_ARRAY_OR_GOTO(avctx, buf, avctx->channels, blocks * 8, error); > >+ FF_ALLOC_ARRAY_OR_GOTO(buf, avctx->channels, blocks * 8, ret, return ret); > > for (ch = 0; ch < avctx->channels; ch++) { > > adpcm_compress_trellis(avctx, &samples_p[ch][1], > > buf + ch * blocks * 8, &c->status[ch], > >@@ -588,7 +579,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, > > } > > > > if (avctx->trellis > 0) { > >- FF_ALLOC_OR_GOTO(avctx, buf, 2 * n, error); > >+ FF_ALLOC_OR_GOTO(buf, 2 * n, ret, return ret); > > adpcm_compress_trellis(avctx, samples + avctx->channels, buf, > > &c->status[0], n, avctx->channels); > > if (avctx->channels == 2) > >@@ -636,7 +627,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, > > > > if (avctx->trellis > 0) { > > n = avctx->block_align - 7 * avctx->channels; > >- FF_ALLOC_OR_GOTO(avctx, buf, 2 * n, error); > >+ FF_ALLOC_OR_GOTO(buf, 2 * n, ret, return ret); > > if (avctx->channels == 1) { > > adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n, > > avctx->channels); > >@@ -663,7 +654,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, > > case AV_CODEC_ID_ADPCM_YAMAHA: > > n = frame->nb_samples / 2; > > if (avctx->trellis > 0) { > >- FF_ALLOC_OR_GOTO(avctx, buf, 2 * n * 2, error); > >+ FF_ALLOC_OR_GOTO(buf, 2 * n * 2, ret, return ret); > > n *= 2; > > if (avctx->channels == 1) { > > adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n, > >@@ -694,8 +685,6 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, > > avpkt->size = pkt_size; > > *got_packet_ptr = 1; > > return 0; > >-error: > >- return AVERROR(ENOMEM); > >} > > > >static const enum AVSampleFormat sample_fmts[] = { > >diff --git a/libavcodec/alac.c b/libavcodec/alac.c > >index c8c0422..e7245b8 100644 > >--- a/libavcodec/alac.c > >+++ b/libavcodec/alac.c > >@@ -487,7 +487,7 @@ static av_cold int alac_decode_close(AVCodecContext *avctx) > > > >static int allocate_buffers(ALACContext *alac) > >{ > >- int ch; > >+ int ch, ret; > > unsigned buf_size = alac->max_samples_per_frame * sizeof(int32_t); > > > > for (ch = 0; ch < 2; ch++) { > >@@ -497,22 +497,19 @@ static int allocate_buffers(ALACContext *alac) > > } > > > > for (ch = 0; ch < FFMIN(alac->channels, 2); ch++) { > >- FF_ALLOC_OR_GOTO(alac->avctx, alac->predict_error_buffer[ch], > >- buf_size, buf_alloc_fail); > >+ FF_ALLOC_OR_GOTO(alac->predict_error_buffer[ch], > >+ buf_size, ret, return ret); > > > > alac->direct_output = alac->sample_size > 16; > > if (!alac->direct_output) { > >- FF_ALLOC_OR_GOTO(alac->avctx, alac->output_samples_buffer[ch], > >- buf_size + AV_INPUT_BUFFER_PADDING_SIZE, buf_alloc_fail); > >+ FF_ALLOC_OR_GOTO(alac->output_samples_buffer[ch], > >+ buf_size + AV_INPUT_BUFFER_PADDING_SIZE, ret, return ret); > > } > > > >- FF_ALLOC_OR_GOTO(alac->avctx, alac->extra_bits_buffer[ch], > >- buf_size + AV_INPUT_BUFFER_PADDING_SIZE, buf_alloc_fail); > >+ FF_ALLOC_OR_GOTO(alac->extra_bits_buffer[ch], > >+ buf_size + AV_INPUT_BUFFER_PADDING_SIZE, ret, return ret); > > } > > return 0; > >-buf_alloc_fail: > >- alac_decode_close(alac->avctx); > >- return AVERROR(ENOMEM); > >} > > > >static int alac_set_info(ALACContext *alac) > >diff --git a/libavcodec/apedec.c b/libavcodec/apedec.c > >index 2d19250..7db4467 100644 > >--- a/libavcodec/apedec.c > >+++ b/libavcodec/apedec.c > >@@ -215,7 +215,7 @@ static av_cold int ape_decode_close(AVCodecContext *avctx) > >static av_cold int ape_decode_init(AVCodecContext *avctx) > >{ > > APEContext *s = avctx->priv_data; > >- int i; > >+ int i, ret; > > > > if (avctx->extradata_size != 6) { > > av_log(avctx, AV_LOG_ERROR, "Incorrect extradata\n"); > >@@ -260,9 +260,9 @@ static av_cold int ape_decode_init(AVCodecContext *avctx) > > for (i = 0; i < APE_FILTER_LEVELS; i++) { > > if (!ape_filter_orders[s->fset][i]) > > break; > >- FF_ALLOC_OR_GOTO(avctx, s->filterbuf[i], > >+ FF_ALLOC_OR_GOTO(s->filterbuf[i], > > (ape_filter_orders[s->fset][i] * 3 + HISTORY_SIZE) * 4, > >- filter_alloc_fail); > >+ ret, return ret); > > } > > > > if (s->fileversion < 3860) { > >@@ -298,9 +298,6 @@ static av_cold int ape_decode_init(AVCodecContext *avctx) > > avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO; > > > > return 0; > >-filter_alloc_fail: > >- ape_decode_close(avctx); > >- return AVERROR(ENOMEM); > >} > > > >/** > >diff --git a/libavcodec/dnxhdenc.c b/libavcodec/dnxhdenc.c > >index 32ac90f..79d3f3f 100644 > >--- a/libavcodec/dnxhdenc.c > >+++ b/libavcodec/dnxhdenc.c > >@@ -205,15 +205,16 @@ static av_cold int dnxhd_init_vlc(DNXHDEncContext *ctx) > >{ > > int i, j, level, run; > > int max_level = 1 << (ctx->bit_depth + 2); > >+ int ret; > > > >- FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->orig_vlc_codes, > >- max_level, 4 * sizeof(*ctx->orig_vlc_codes), fail); > >- FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->orig_vlc_bits, > >- max_level, 4 * sizeof(*ctx->orig_vlc_bits), fail); > >- FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_codes, > >- 63 * 2, fail); > >- FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_bits, > >- 63, fail); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(ctx->orig_vlc_codes, > >+ max_level, 4 * sizeof(*ctx->orig_vlc_codes), ret, return ret); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(ctx->orig_vlc_bits, > >+ max_level, 4 * sizeof(*ctx->orig_vlc_bits), ret, return ret); > >+ FF_ALLOCZ_OR_GOTO(ctx->run_codes, > >+ 63 * 2, ret, return ret); > >+ FF_ALLOCZ_OR_GOTO(ctx->run_bits, > >+ 63, ret, return ret); > > > > ctx->vlc_codes = ctx->orig_vlc_codes + max_level * 2; > > ctx->vlc_bits = ctx->orig_vlc_bits + max_level * 2; > >@@ -258,8 +259,6 @@ static av_cold int dnxhd_init_vlc(DNXHDEncContext *ctx) > > ctx->run_bits[run] = ctx->cid_table->run_bits[i]; > > } > > return 0; > >-fail: > >- return AVERROR(ENOMEM); > >} > > > >static av_cold int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias) > >@@ -269,17 +268,18 @@ static av_cold int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias) > > int qscale, i; > > const uint8_t *luma_weight_table = ctx->cid_table->luma_weight; > > const uint8_t *chroma_weight_table = ctx->cid_table->chroma_weight; > >+ int ret; > > > >- FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l, > >- (ctx->m.avctx->qmax + 1), 64 * sizeof(int), fail); > >- FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c, > >- (ctx->m.avctx->qmax + 1), 64 * sizeof(int), fail); > >- FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l16, > >+ FF_ALLOCZ_ARRAY_OR_GOTO(ctx->qmatrix_l, > >+ (ctx->m.avctx->qmax + 1), 64 * sizeof(int), ret, return ret); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(ctx->qmatrix_c, > >+ (ctx->m.avctx->qmax + 1), 64 * sizeof(int), ret, return ret); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(ctx->qmatrix_l16, > > (ctx->m.avctx->qmax + 1), 64 * 2 * sizeof(uint16_t), > >- fail); > >- FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c16, > >+ ret, return ret); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(ctx->qmatrix_c16, > > (ctx->m.avctx->qmax + 1), 64 * 2 * sizeof(uint16_t), > >- fail); > >+ ret, return ret); > > > > if (ctx->bit_depth == 8) { > > for (i = 1; i < 64; i++) { > >@@ -338,27 +338,24 @@ static av_cold int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias) > > ctx->m.q_intra_matrix = ctx->qmatrix_l; > > > > return 0; > >-fail: > >- return AVERROR(ENOMEM); > >} > > > >static av_cold int dnxhd_init_rc(DNXHDEncContext *ctx) > >{ > >- FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->mb_rc, (ctx->m.avctx->qmax + 1), > >- ctx->m.mb_num * sizeof(RCEntry), fail); > >+ int ret; > >+ FF_ALLOCZ_ARRAY_OR_GOTO(ctx->mb_rc, (ctx->m.avctx->qmax + 1), > >+ ctx->m.mb_num * sizeof(RCEntry), ret, return ret); > > if (ctx->m.avctx->mb_decision != FF_MB_DECISION_RD) { > >- FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->mb_cmp, > >- ctx->m.mb_num, sizeof(RCCMPEntry), fail); > >- FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->mb_cmp_tmp, > >- ctx->m.mb_num, sizeof(RCCMPEntry), fail); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(ctx->mb_cmp, > >+ ctx->m.mb_num, sizeof(RCCMPEntry), ret, return ret); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(ctx->mb_cmp_tmp, > >+ ctx->m.mb_num, sizeof(RCCMPEntry), ret, return ret); > > } > > ctx->frame_bits = (ctx->coding_unit_size - > > ctx->data_offset - 4 - ctx->min_padding) * 8; > > ctx->qscale = 1; > > ctx->lambda = 2 << LAMBDA_FRAC_BITS; // qscale 2 > > return 0; > >-fail: > >- return AVERROR(ENOMEM); > >} > > > >static av_cold int dnxhd_encode_init(AVCodecContext *avctx) > >@@ -509,14 +506,14 @@ static av_cold int dnxhd_encode_init(AVCodecContext *avctx) > > if ((ret = dnxhd_init_rc(ctx)) < 0) > > return ret; > > > >- FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->slice_size, > >- ctx->m.mb_height * sizeof(uint32_t), fail); > >- FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->slice_offs, > >- ctx->m.mb_height * sizeof(uint32_t), fail); > >- FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_bits, > >- ctx->m.mb_num * sizeof(uint16_t), fail); > >- FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_qscale, > >- ctx->m.mb_num * sizeof(uint8_t), fail); > >+ FF_ALLOCZ_OR_GOTO(ctx->slice_size, > >+ ctx->m.mb_height * sizeof(uint32_t), ret, return ret); > >+ FF_ALLOCZ_OR_GOTO(ctx->slice_offs, > >+ ctx->m.mb_height * sizeof(uint32_t), ret, return ret); > >+ FF_ALLOCZ_OR_GOTO(ctx->mb_bits, > >+ ctx->m.mb_num * sizeof(uint16_t), ret, return ret); > >+ FF_ALLOCZ_OR_GOTO(ctx->mb_qscale, > >+ ctx->m.mb_num * sizeof(uint8_t), ret, return ret); > > > >#if FF_API_CODED_FRAME > >FF_DISABLE_DEPRECATION_WARNINGS > >@@ -542,14 +539,12 @@ FF_ENABLE_DEPRECATION_WARNINGS > > for (i = 1; i < avctx->thread_count; i++) { > > ctx->thread[i] = av_malloc(sizeof(DNXHDEncContext)); > > if (!ctx->thread[i]) > >- goto fail; > >+ return AVERROR(ENOMEM); > > memcpy(ctx->thread[i], ctx, sizeof(DNXHDEncContext)); > > } > > } > > > > return 0; > >-fail: // for FF_ALLOCZ_OR_GOTO > >- return AVERROR(ENOMEM); > >} > > > >static int dnxhd_write_header(AVCodecContext *avctx, uint8_t *buf) > >diff --git a/libavcodec/h264dec.c b/libavcodec/h264dec.c > >index 4c355fe..0bcc60f 100644 > >--- a/libavcodec/h264dec.c > >+++ b/libavcodec/h264dec.c > >@@ -181,39 +181,40 @@ int ff_h264_alloc_tables(H264Context *h) > > const int big_mb_num = h->mb_stride * (h->mb_height + 1); > > const int row_mb_num = 2*h->mb_stride*FFMAX(h->nb_slice_ctx, 1); > > int x, y; > >+ int ret; > > > >- FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->intra4x4_pred_mode, > >- row_mb_num, 8 * sizeof(uint8_t), fail) > >+ FF_ALLOCZ_ARRAY_OR_GOTO(h->intra4x4_pred_mode, > >+ row_mb_num, 8 * sizeof(uint8_t), ret, return ret) > > h->slice_ctx[0].intra4x4_pred_mode = h->intra4x4_pred_mode; > > > >- FF_ALLOCZ_OR_GOTO(h->avctx, h->non_zero_count, > >- big_mb_num * 48 * sizeof(uint8_t), fail) > >- FF_ALLOCZ_OR_GOTO(h->avctx, h->slice_table_base, > >- (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base), fail) > >- FF_ALLOCZ_OR_GOTO(h->avctx, h->cbp_table, > >- big_mb_num * sizeof(uint16_t), fail) > >- FF_ALLOCZ_OR_GOTO(h->avctx, h->chroma_pred_mode_table, > >- big_mb_num * sizeof(uint8_t), fail) > >- FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[0], > >- row_mb_num, 16 * sizeof(uint8_t), fail); > >- FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[1], > >- row_mb_num, 16 * sizeof(uint8_t), fail); > >+ FF_ALLOCZ_OR_GOTO(h->non_zero_count, > >+ big_mb_num * 48 * sizeof(uint8_t), ret, return ret) > >+ FF_ALLOCZ_OR_GOTO(h->slice_table_base, > >+ (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base), ret, return ret) > >+ FF_ALLOCZ_OR_GOTO(h->cbp_table, > >+ big_mb_num * sizeof(uint16_t), ret, return ret) > >+ FF_ALLOCZ_OR_GOTO(h->chroma_pred_mode_table, > >+ big_mb_num * sizeof(uint8_t), ret, return ret) > >+ FF_ALLOCZ_ARRAY_OR_GOTO(h->mvd_table[0], > >+ row_mb_num, 16 * sizeof(uint8_t), ret, return ret); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(h->mvd_table[1], > >+ row_mb_num, 16 * sizeof(uint8_t), ret, return ret); > > h->slice_ctx[0].mvd_table[0] = h->mvd_table[0]; > > h->slice_ctx[0].mvd_table[1] = h->mvd_table[1]; > > > >- FF_ALLOCZ_OR_GOTO(h->avctx, h->direct_table, > >- 4 * big_mb_num * sizeof(uint8_t), fail); > >- FF_ALLOCZ_OR_GOTO(h->avctx, h->list_counts, > >- big_mb_num * sizeof(uint8_t), fail) > >+ FF_ALLOCZ_OR_GOTO(h->direct_table, > >+ 4 * big_mb_num * sizeof(uint8_t), ret, return ret); > >+ FF_ALLOCZ_OR_GOTO(h->list_counts, > >+ big_mb_num * sizeof(uint8_t), ret, return ret) > > > > memset(h->slice_table_base, -1, > > (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base)); > > h->slice_table = h->slice_table_base + h->mb_stride * 2 + 1; > > > >- FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2b_xy, > >- big_mb_num * sizeof(uint32_t), fail); > >- FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2br_xy, > >- big_mb_num * sizeof(uint32_t), fail); > >+ FF_ALLOCZ_OR_GOTO(h->mb2b_xy, > >+ big_mb_num * sizeof(uint32_t), ret, return ret); > >+ FF_ALLOCZ_OR_GOTO(h->mb2br_xy, > >+ big_mb_num * sizeof(uint32_t), ret, return ret); > > for (y = 0; y < h->mb_height; y++) > > for (x = 0; x < h->mb_width; x++) { > > const int mb_xy = x + y * h->mb_stride; > >@@ -224,10 +225,6 @@ int ff_h264_alloc_tables(H264Context *h) > > } > > > > return 0; > >- > >-fail: > >- ff_h264_free_tables(h); > >- return AVERROR(ENOMEM); > >} > > > >/** > >@@ -242,6 +239,7 @@ int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl) > > int c_size = h->mb_stride * (h->mb_height + 1); > > int yc_size = y_size + 2 * c_size; > > int x, y, i; > >+ int ret; > > > > sl->ref_cache[0][scan8[5] + 1] = > > sl->ref_cache[0][scan8[7] + 1] = > >@@ -268,8 +266,8 @@ int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl) > > er->b8_stride = h->mb_width * 2 + 1; > > > > // error resilience code looks cleaner with this > >- FF_ALLOCZ_OR_GOTO(h->avctx, er->mb_index2xy, > >- (h->mb_num + 1) * sizeof(int), fail); > >+ FF_ALLOCZ_OR_GOTO(er->mb_index2xy, > >+ (h->mb_num + 1) * sizeof(int), ret, return ret); > > > > for (y = 0; y < h->mb_height; y++) > > for (x = 0; x < h->mb_width; x++) > >@@ -278,14 +276,14 @@ int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl) > > er->mb_index2xy[h->mb_height * h->mb_width] = (h->mb_height - 1) * > > h->mb_stride + h->mb_width; > > > >- FF_ALLOCZ_OR_GOTO(h->avctx, er->error_status_table, > >- mb_array_size * sizeof(uint8_t), fail); > >+ FF_ALLOCZ_OR_GOTO(er->error_status_table, > >+ mb_array_size * sizeof(uint8_t), ret, return ret); > > > >- FF_ALLOC_OR_GOTO(h->avctx, er->er_temp_buffer, > >- h->mb_height * h->mb_stride * (4*sizeof(int) + 1), fail); > >+ FF_ALLOC_OR_GOTO(er->er_temp_buffer, > >+ h->mb_height * h->mb_stride * (4*sizeof(int) + 1), ret, return ret); > > > >- FF_ALLOCZ_OR_GOTO(h->avctx, sl->dc_val_base, > >- yc_size * sizeof(int16_t), fail); > >+ FF_ALLOCZ_OR_GOTO(sl->dc_val_base, > >+ yc_size * sizeof(int16_t), ret, return ret); > > er->dc_val[0] = sl->dc_val_base + h->mb_width * 2 + 2; > > er->dc_val[1] = sl->dc_val_base + y_size + h->mb_stride + 1; > > er->dc_val[2] = er->dc_val[1] + c_size; > >@@ -294,9 +292,6 @@ int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl) > > } > > > > return 0; > >- > >-fail: > >- return AVERROR(ENOMEM); // ff_h264_free_tables will clean up for us > >} > > > >static int h264_init_context(AVCodecContext *avctx, H264Context *h) > >diff --git a/libavcodec/iirfilter.c b/libavcodec/iirfilter.c > >index b202515..e00cf39 100644 > >--- a/libavcodec/iirfilter.c > >+++ b/libavcodec/iirfilter.c > >@@ -171,12 +171,12 @@ av_cold struct FFIIRFilterCoeffs *ff_iir_filter_init_coeffs(void *avc, > > if (order <= 0 || order > MAXORDER || cutoff_ratio >= 1.0) > > return NULL; > > > >- FF_ALLOCZ_OR_GOTO(avc, c, sizeof(FFIIRFilterCoeffs), > >- init_fail); > >- FF_ALLOC_OR_GOTO(avc, c->cx, sizeof(c->cx[0]) * ((order >> 1) + 1), > >- init_fail); > >- FF_ALLOC_OR_GOTO(avc, c->cy, sizeof(c->cy[0]) * order, > >- init_fail); > >+ FF_ALLOCZ_OR_GOTO(c, sizeof(FFIIRFilterCoeffs), > >+ ret, goto init_fail); > >+ FF_ALLOC_OR_GOTO(c->cx, sizeof(c->cx[0]) * ((order >> 1) + 1), > >+ ret, goto init_fail); > >+ FF_ALLOC_OR_GOTO(c->cy, sizeof(c->cy[0]) * order, > >+ ret, goto init_fail); > > c->order = order; > > > > switch (filt_type) { > >diff --git a/libavcodec/mpegpicture.c b/libavcodec/mpegpicture.c > >index 5fce25e..7d70cc8 100644 > >--- a/libavcodec/mpegpicture.c > >+++ b/libavcodec/mpegpicture.c > >@@ -60,6 +60,7 @@ int ff_mpeg_framesize_alloc(AVCodecContext *avctx, MotionEstContext *me, > >{ > ># define EMU_EDGE_HEIGHT (4 * 70) > > int alloc_size = FFALIGN(FFABS(linesize) + 64, 32); > >+ int ret; > > > > if (avctx->hwaccel) > > return 0; > >@@ -78,11 +79,11 @@ int ff_mpeg_framesize_alloc(AVCodecContext *avctx, MotionEstContext *me, > > // at uvlinesize. It supports only YUV420 so 24x24 is enough > > // linesize * interlaced * MBsize > > // we also use this buffer for encoding in encode_mb_internal() needig an additional 32 lines > >- FF_ALLOCZ_ARRAY_OR_GOTO(avctx, sc->edge_emu_buffer, alloc_size, EMU_EDGE_HEIGHT, > >- fail); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(sc->edge_emu_buffer, alloc_size, EMU_EDGE_HEIGHT, > >+ ret, goto fail); > > > >- FF_ALLOCZ_ARRAY_OR_GOTO(avctx, me->scratchpad, alloc_size, 4 * 16 * 2, > >- fail) > >+ FF_ALLOCZ_ARRAY_OR_GOTO(me->scratchpad, alloc_size, 4 * 16 * 2, > >+ ret, goto fail) > > me->temp = me->scratchpad; > > sc->rd_scratchpad = me->scratchpad; > > sc->b_scratchpad = me->scratchpad; > >@@ -91,7 +92,7 @@ int ff_mpeg_framesize_alloc(AVCodecContext *avctx, MotionEstContext *me, > > return 0; > >fail: > > av_freep(&sc->edge_emu_buffer); > >- return AVERROR(ENOMEM); > >+ return ret; > >} > > > >/** > >diff --git a/libavcodec/mpegvideo.c b/libavcodec/mpegvideo.c > >index 49fd1c9..aaf1b40 100644 > >--- a/libavcodec/mpegvideo.c > >+++ b/libavcodec/mpegvideo.c > >@@ -360,6 +360,7 @@ static int init_duplicate_context(MpegEncContext *s) > > int c_size = s->mb_stride * (s->mb_height + 1); > > int yc_size = y_size + 2 * c_size; > > int i; > >+ int ret; > > > > if (s->mb_height & 1) > > yc_size += 2*s->b8_stride + 2*s->mb_stride; > >@@ -372,25 +373,22 @@ static int init_duplicate_context(MpegEncContext *s) > > s->sc.obmc_scratchpad = NULL; > > > > if (s->encoding) { > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map, > >- ME_MAP_SIZE * sizeof(uint32_t), fail) > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map, > >- ME_MAP_SIZE * sizeof(uint32_t), fail) > >+ FF_ALLOCZ_OR_GOTO(s->me.map, ME_MAP_SIZE * sizeof(uint32_t), ret, return ret) > >+ FF_ALLOCZ_OR_GOTO(s->me.score_map, ME_MAP_SIZE * sizeof(uint32_t), ret, return ret) > > if (s->noise_reduction) { > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum, > >- 2 * 64 * sizeof(int), fail) > >+ FF_ALLOCZ_OR_GOTO(s->dct_error_sum, 2 * 64 * sizeof(int), ret, return ret) > > } > > } > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(int16_t), fail) > >+ FF_ALLOCZ_OR_GOTO(s->blocks, 64 * 12 * 2 * sizeof(int16_t), ret, return ret) > > s->block = s->blocks[0]; > > > > for (i = 0; i < 12; i++) { > > s->pblocks[i] = &s->block[i]; > > } > > > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->block32, sizeof(*s->block32), fail) > >+ FF_ALLOCZ_OR_GOTO(s->block32, sizeof(*s->block32), ret, return ret) > > s->dpcm_direction = 0; > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->dpcm_macroblock, sizeof(*s->dpcm_macroblock), fail) > >+ FF_ALLOCZ_OR_GOTO(s->dpcm_macroblock, sizeof(*s->dpcm_macroblock), ret, return ret) > > > > if (s->avctx->codec_tag == AV_RL32("VCR2")) { > > // exchange uv > >@@ -399,16 +397,13 @@ static int init_duplicate_context(MpegEncContext *s) > > > > if (s->out_format == FMT_H263) { > > /* ac values */ > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base, > >- yc_size * sizeof(int16_t) * 16, fail); > >+ FF_ALLOCZ_OR_GOTO(s->ac_val_base, yc_size * sizeof(int16_t) * 16, ret, return ret); > > s->ac_val[0] = s->ac_val_base + s->b8_stride + 1; > > s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1; > > s->ac_val[2] = s->ac_val[1] + c_size; > > } > > > > return 0; > >-fail: > >- return AVERROR(ENOMEM); // free() through ff_mpv_common_end() > >} > > > >static void free_duplicate_context(MpegEncContext *s) > >@@ -687,6 +682,7 @@ void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx) > >static int init_context_frame(MpegEncContext *s) > >{ > > int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y; > >+ int ret; > > > > s->mb_width = (s->width + 15) / 16; > > s->mb_stride = s->mb_width + 1; > >@@ -715,8 +711,8 @@ static int init_context_frame(MpegEncContext *s) > > if (s->mb_height & 1) > > yc_size += 2*s->b8_stride + 2*s->mb_stride; > > > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), > >- fail); // error resilience code looks cleaner with this > >+ FF_ALLOCZ_OR_GOTO(s->mb_index2xy, (s->mb_num + 1) * sizeof(int), > >+ ret, return ret); // error resilience code looks cleaner with this > > for (y = 0; y < s->mb_height; y++) > > for (x = 0; x < s->mb_width; x++) > > s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride; > >@@ -725,12 +721,12 @@ static int init_context_frame(MpegEncContext *s) > > > > if (s->encoding) { > > /* Allocate MV tables */ > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail) > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail) > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail) > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail) > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail) > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail) > >+ FF_ALLOCZ_OR_GOTO(s->p_mv_table_base, mv_table_size * 2 * sizeof(int16_t), ret, return ret) > >+ FF_ALLOCZ_OR_GOTO(s->b_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), ret, return ret) > >+ FF_ALLOCZ_OR_GOTO(s->b_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), ret, return ret) > >+ FF_ALLOCZ_OR_GOTO(s->b_bidir_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), ret, return ret) > >+ FF_ALLOCZ_OR_GOTO(s->b_bidir_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), ret, return ret) > >+ FF_ALLOCZ_OR_GOTO(s->b_direct_mv_table_base, mv_table_size * 2 * sizeof(int16_t), ret, return ret) > > s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1; > > s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1; > > s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1; > >@@ -739,14 +735,14 @@ static int init_context_frame(MpegEncContext *s) > > s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1; > > > > /* Allocate MB type table */ > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size * sizeof(uint16_t), fail) // needed for encoding > >+ FF_ALLOCZ_OR_GOTO(s->mb_type, mb_array_size * sizeof(uint16_t), ret, return ret) // needed for encoding > > > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail) > >+ FF_ALLOCZ_OR_GOTO(s->lambda_table, mb_array_size * sizeof(int), ret, return ret) > > > >- FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab, > >- mb_array_size * sizeof(float), fail); > >- FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab, > >- mb_array_size * sizeof(float), fail); > >+ FF_ALLOC_OR_GOTO(s->cplx_tab, > >+ mb_array_size * sizeof(float), ret, return ret); > >+ FF_ALLOC_OR_GOTO(s->bits_tab, > >+ mb_array_size * sizeof(float), ret, return ret); > > > > } > > > >@@ -757,34 +753,33 @@ static int init_context_frame(MpegEncContext *s) > > int j, k; > > for (j = 0; j < 2; j++) { > > for (k = 0; k < 2; k++) { > >- FF_ALLOCZ_OR_GOTO(s->avctx, > >- s->b_field_mv_table_base[i][j][k], > >+ FF_ALLOCZ_OR_GOTO(s->b_field_mv_table_base[i][j][k], > > mv_table_size * 2 * sizeof(int16_t), > >- fail); > >+ ret, return ret); > > s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + > > s->mb_stride + 1; > > } > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail) > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail) > >+ FF_ALLOCZ_OR_GOTO(s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), ret, return ret) > >+ FF_ALLOCZ_OR_GOTO(s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), ret, return ret) > > s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1; > > } > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail) > >+ FF_ALLOCZ_OR_GOTO(s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), ret, return ret) > > } > > } > > if (s->out_format == FMT_H263) { > > /* cbp values */ > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size + (s->mb_height&1)*2*s->b8_stride, fail); > >+ FF_ALLOCZ_OR_GOTO(s->coded_block_base, y_size + (s->mb_height&1)*2*s->b8_stride, ret, return ret); > > s->coded_block = s->coded_block_base + s->b8_stride + 1; > > > > /* cbp, ac_pred, pred_dir */ > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table , mb_array_size * sizeof(uint8_t), fail); > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail); > >+ FF_ALLOCZ_OR_GOTO(s->cbp_table , mb_array_size * sizeof(uint8_t), ret, return ret); > >+ FF_ALLOCZ_OR_GOTO(s->pred_dir_table, mb_array_size * sizeof(uint8_t), ret, return ret); > > } > > > > if (s->h263_pred || s->h263_plus || !s->encoding) { > > /* dc values */ > > // MN: we need these for error resilience of intra-frames > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail); > >+ FF_ALLOCZ_OR_GOTO(s->dc_val_base, yc_size * sizeof(int16_t), ret, return ret); > > s->dc_val[0] = s->dc_val_base + s->b8_stride + 1; > > s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1; > > s->dc_val[2] = s->dc_val[1] + c_size; > >@@ -793,16 +788,14 @@ static int init_context_frame(MpegEncContext *s) > > } > > > > /* which mb is an intra block */ > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail); > >+ FF_ALLOCZ_OR_GOTO(s->mbintra_table, mb_array_size, ret, return ret); > > memset(s->mbintra_table, 1, mb_array_size); > > > > /* init macroblock skip table */ > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail); > >+ FF_ALLOCZ_OR_GOTO(s->mbskip_table, mb_array_size + 2, ret, return ret); > > // Note the + 1 is for a quicker MPEG-4 slice_end detection > > > > return ff_mpeg_er_init(s); > >-fail: > >- return AVERROR(ENOMEM); > >} > > > >static void clear_context(MpegEncContext *s) > >@@ -934,8 +927,7 @@ av_cold int ff_mpv_common_init(MpegEncContext *s) > > if (ret) > > return ret; > > > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->picture, > >- MAX_PICTURE_COUNT * sizeof(Picture), fail_nomem); > >+ FF_ALLOCZ_OR_GOTO(s->picture, MAX_PICTURE_COUNT * sizeof(Picture), ret, return ret); > > for (i = 0; i < MAX_PICTURE_COUNT; i++) { > > s->picture[i].f = av_frame_alloc(); > > if (!s->picture[i].f) > >diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c > >index 50ae57e..bc0fc4f 100644 > >--- a/libavcodec/mpegvideo_enc.c > >+++ b/libavcodec/mpegvideo_enc.c > >@@ -924,27 +924,23 @@ FF_ENABLE_DEPRECATION_WARNINGS > > ff_qpeldsp_init(&s->qdsp); > > > > if (s->msmpeg4_version) { > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, > >- 2 * 2 * (MAX_LEVEL + 1) * > >- (MAX_RUN + 1) * 2 * sizeof(int), fail); > >+ FF_ALLOCZ_OR_GOTO(s->ac_stats, 2 * 2 * (MAX_LEVEL + 1) * > >+ (MAX_RUN + 1) * 2 * sizeof(int), ret, return ret); > > } > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail); > >+ FF_ALLOCZ_OR_GOTO(s->avctx->stats_out, 256, ret, return ret); > > > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix, 64 * 32 * sizeof(int), fail); > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix, 64 * 32 * sizeof(int), fail); > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix, 64 * 32 * sizeof(int), fail); > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail); > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail); > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail); > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, > >- MAX_PICTURE_COUNT * sizeof(Picture *), fail); > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, > >- MAX_PICTURE_COUNT * sizeof(Picture *), fail); > >+ FF_ALLOCZ_OR_GOTO(s->q_intra_matrix, 64 * 32 * sizeof(int), ret, return ret); > >+ FF_ALLOCZ_OR_GOTO(s->q_chroma_intra_matrix, 64 * 32 * sizeof(int), ret, return ret); > >+ FF_ALLOCZ_OR_GOTO(s->q_inter_matrix, 64 * 32 * sizeof(int), ret, return ret); > >+ FF_ALLOCZ_OR_GOTO(s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), ret, return ret); > >+ FF_ALLOCZ_OR_GOTO(s->q_chroma_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), ret, return ret); > >+ FF_ALLOCZ_OR_GOTO(s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), ret, return ret); > >+ FF_ALLOCZ_OR_GOTO(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture *), ret, return ret); > >+ FF_ALLOCZ_OR_GOTO(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture *), ret, return ret); > > > > > > if (s->noise_reduction) { > >- FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, > >- 2 * 64 * sizeof(uint16_t), fail); > >+ FF_ALLOCZ_OR_GOTO(s->dct_offset, 2 * 64 * sizeof(uint16_t), ret, return ret); > > } > > > > ff_dct_encode_init(s); > >@@ -1059,9 +1055,6 @@ FF_ENABLE_DEPRECATION_WARNINGS > > cpb_props->buffer_size = avctx->rc_buffer_size; > > > > return 0; > >-fail: > >- ff_mpv_encode_end(avctx); > >- return AVERROR_UNKNOWN; > >} > > > >av_cold int ff_mpv_encode_end(AVCodecContext *avctx) > >diff --git a/libavcodec/snow.c b/libavcodec/snow.c > >index a3e6afc..07c3d5e 100644 > >--- a/libavcodec/snow.c > >+++ b/libavcodec/snow.c > >@@ -431,6 +431,7 @@ av_cold int ff_snow_common_init(AVCodecContext *avctx){ > > SnowContext *s = avctx->priv_data; > > int width, height; > > int i, j; > >+ int ret; > > > > s->avctx= avctx; > > s->max_ref_frames=1; //just make sure it's not an invalid value in case of no initial keyframe > >@@ -487,28 +488,26 @@ av_cold int ff_snow_common_init(AVCodecContext *avctx){ > > width= s->avctx->width; > > height= s->avctx->height; > > > >- FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->spatial_idwt_buffer, width, height * sizeof(IDWTELEM), fail); > >- FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->spatial_dwt_buffer, width, height * sizeof(DWTELEM), fail); //FIXME this does not belong here > >- FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->temp_dwt_buffer, width, sizeof(DWTELEM), fail); > >- FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->temp_idwt_buffer, width, sizeof(IDWTELEM), fail); > >- FF_ALLOC_ARRAY_OR_GOTO(avctx, s->run_buffer, ((width + 1) >> 1), ((height + 1) >> 1) * sizeof(*s->run_buffer), fail); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(s->spatial_idwt_buffer, width, height * sizeof(IDWTELEM), ret, return ret); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(s->spatial_dwt_buffer, width, height * sizeof(DWTELEM), ret, return ret); //FIXME this does not belong here > >+ FF_ALLOCZ_ARRAY_OR_GOTO(s->temp_dwt_buffer, width, sizeof(DWTELEM), ret, return ret); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(s->temp_idwt_buffer, width, sizeof(IDWTELEM), ret, return ret); > >+ FF_ALLOC_ARRAY_OR_GOTO(s->run_buffer, ((width + 1) >> 1), ((height + 1) >> 1) * sizeof(*s->run_buffer), ret, return ret); > > > > for(i=0; i<MAX_REF_FRAMES; i++) { > > for(j=0; j<MAX_REF_FRAMES; j++) > > ff_scale_mv_ref[i][j] = 256*(i+1)/(j+1); > > s->last_picture[i] = av_frame_alloc(); > > if (!s->last_picture[i]) > >- goto fail; > >+ return AVERROR(ENOMEM); > > } > > > > s->mconly_picture = av_frame_alloc(); > > s->current_picture = av_frame_alloc(); > > if (!s->mconly_picture || !s->current_picture) > >- goto fail; > >+ return AVERROR(ENOMEM); > > > > return 0; > >-fail: > >- return AVERROR(ENOMEM); > >} > > > >int ff_snow_common_init_after_header(AVCodecContext *avctx) { > >@@ -520,9 +519,9 @@ int ff_snow_common_init_after_header(AVCodecContext *avctx) { > > if ((ret = ff_get_buffer(s->avctx, s->mconly_picture, > > AV_GET_BUFFER_FLAG_REF)) < 0) > > return ret; > >- FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->scratchbuf, FFMAX(s->mconly_picture->linesize[0], 2*avctx->width+256), 7*MB_SIZE, fail); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(s->scratchbuf, FFMAX(s->mconly_picture->linesize[0], 2*avctx->width+256), 7*MB_SIZE, ret, return ret); > > emu_buf_size = FFMAX(s->mconly_picture->linesize[0], 2*avctx->width+256) * (2 * MB_SIZE + HTAPS_MAX - 1); > >- FF_ALLOC_OR_GOTO(avctx, s->emu_edge_buffer, emu_buf_size, fail); > >+ FF_ALLOC_OR_GOTO(s->emu_edge_buffer, emu_buf_size, ret, return ret); > > } > > > > if(s->mconly_picture->format != avctx->pix_fmt) { > >@@ -571,7 +570,7 @@ int ff_snow_common_init_after_header(AVCodecContext *avctx) { > > av_freep(&b->x_coeff); > > b->x_coeff=av_mallocz_array(((b->width+1) * b->height+1), sizeof(x_and_coeff)); > > if (!b->x_coeff) > >- goto fail; > >+ return AVERROR(ENOMEM); > > } > > w= (w+1)>>1; > > h= (h+1)>>1; > >@@ -579,8 +578,6 @@ int ff_snow_common_init_after_header(AVCodecContext *avctx) { > > } > > > > return 0; > >-fail: > >- return AVERROR(ENOMEM); > >} > > > >#define USE_HALFPEL_PLANE 0 > >diff --git a/libavcodec/twinvq.c b/libavcodec/twinvq.c > >index 34ca184..74a3ba7 100644 > >--- a/libavcodec/twinvq.c > >+++ b/libavcodec/twinvq.c > >@@ -546,24 +546,24 @@ static av_cold int init_mdct_win(TwinVQContext *tctx) > > return ret; > > } > > > >- FF_ALLOC_ARRAY_OR_GOTO(tctx->avctx, tctx->tmp_buf, > >- mtab->size, sizeof(*tctx->tmp_buf), alloc_fail); > >+ FF_ALLOC_ARRAY_OR_GOTO(tctx->tmp_buf, > >+ mtab->size, sizeof(*tctx->tmp_buf), ret, return ret); > > > >- FF_ALLOC_ARRAY_OR_GOTO(tctx->avctx, tctx->spectrum, > >+ FF_ALLOC_ARRAY_OR_GOTO(tctx->spectrum, > > 2 * mtab->size, channels * sizeof(*tctx->spectrum), > >- alloc_fail); > >- FF_ALLOC_ARRAY_OR_GOTO(tctx->avctx, tctx->curr_frame, > >+ ret, return ret); > >+ FF_ALLOC_ARRAY_OR_GOTO(tctx->curr_frame, > > 2 * mtab->size, channels * sizeof(*tctx->curr_frame), > >- alloc_fail); > >- FF_ALLOC_ARRAY_OR_GOTO(tctx->avctx, tctx->prev_frame, > >+ ret, return ret); > >+ FF_ALLOC_ARRAY_OR_GOTO(tctx->prev_frame, > > 2 * mtab->size, channels * sizeof(*tctx->prev_frame), > >- alloc_fail); > >+ ret, return ret); > > > > for (i = 0; i < 3; i++) { > > int m = 4 * mtab->size / mtab->fmode[i].sub; > > double freq = 2 * M_PI / m; > >- FF_ALLOC_ARRAY_OR_GOTO(tctx->avctx, tctx->cos_tabs[i], > >- (m / 4), sizeof(*tctx->cos_tabs[i]), alloc_fail); > >+ FF_ALLOC_ARRAY_OR_GOTO(tctx->cos_tabs[i], > >+ (m / 4), sizeof(*tctx->cos_tabs[i]), ret, return ret); > > > > for (j = 0; j <= m / 8; j++) > > tctx->cos_tabs[i][j] = cos((2 * j + 1) * freq); > >@@ -576,9 +576,6 @@ static av_cold int init_mdct_win(TwinVQContext *tctx) > > ff_init_ff_sine_windows(av_log2(mtab->size)); > > > > return 0; > >- > >-alloc_fail: > >- return AVERROR(ENOMEM); > >} > > > >/** > >diff --git a/libavutil/internal.h b/libavutil/internal.h > >index 4acbcf5..9cf5780 100644 > >--- a/libavutil/internal.h > >+++ b/libavutil/internal.h > >@@ -137,39 +137,39 @@ > ># define LOCAL_ALIGNED_32(t, v, ...) E1(LOCAL_ALIGNED_A(32, t, v, __VA_ARGS__,,)) > >#endif > > > >-#define FF_ALLOC_OR_GOTO(ctx, p, size, label)\ > >+#define FF_ALLOC_OR_GOTO(p, size, ret, errstatement)\ > >{\ > > p = av_malloc(size);\ > > if (!(p) && (size) != 0) {\ > >- av_log(ctx, AV_LOG_ERROR, "Cannot allocate memory.\n");\ > >- goto label;\ > >+ ret = AVERROR(ENOMEM);\ > >+ errstatement;\ > > }\ > >} > > > >-#define FF_ALLOCZ_OR_GOTO(ctx, p, size, label)\ > >+#define FF_ALLOCZ_OR_GOTO(p, size, ret, errstatement)\ > >{\ > > p = av_mallocz(size);\ > > if (!(p) && (size) != 0) {\ > >- av_log(ctx, AV_LOG_ERROR, "Cannot allocate memory.\n");\ > >- goto label;\ > >+ ret = AVERROR(ENOMEM);\ > >+ errstatement;\ > > }\ > >} > > > >-#define FF_ALLOC_ARRAY_OR_GOTO(ctx, p, nelem, elsize, label)\ > >+#define FF_ALLOC_ARRAY_OR_GOTO(p, nelem, elsize, ret, errstatement)\ > >{\ > > p = av_malloc_array(nelem, elsize);\ > > if (!p) {\ > >- av_log(ctx, AV_LOG_ERROR, "Cannot allocate memory.\n");\ > >- goto label;\ > >+ ret = AVERROR(ENOMEM);\ > >+ errstatement;\ > > }\ > >} > > > >-#define FF_ALLOCZ_ARRAY_OR_GOTO(ctx, p, nelem, elsize, label)\ > >+#define FF_ALLOCZ_ARRAY_OR_GOTO(p, nelem, elsize, ret, errstatement)\ > >{\ > > p = av_mallocz_array(nelem, elsize);\ > > if (!p) {\ > >- av_log(ctx, AV_LOG_ERROR, "Cannot allocate memory.\n");\ > >- goto label;\ > >+ ret = AVERROR(ENOMEM);\ > >+ errstatement;\ > > }\ > >} > > > >diff --git a/libswscale/utils.c b/libswscale/utils.c > >index 15c0a19..8ff6a9c 100644 > >--- a/libswscale/utils.c > >+++ b/libswscale/utils.c > >@@ -352,13 +352,13 @@ static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, > > emms_c(); // FIXME should not be required but IS (even for non-MMX versions) > > > > // NOTE: the +3 is for the MMX(+1) / SSE(+3) scaler which reads over the end > >- FF_ALLOC_ARRAY_OR_GOTO(NULL, *filterPos, (dstW + 3), sizeof(**filterPos), fail); > >+ FF_ALLOC_ARRAY_OR_GOTO(*filterPos, (dstW + 3), sizeof(**filterPos), ret, goto fail); > > > > if (FFABS(xInc - 0x10000) < 10 && srcPos == dstPos) { // unscaled > > int i; > > filterSize = 1; > >- FF_ALLOCZ_ARRAY_OR_GOTO(NULL, filter, > >- dstW, sizeof(*filter) * filterSize, fail); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(filter, > >+ dstW, sizeof(*filter) * filterSize, ret, goto fail); > > > > for (i = 0; i < dstW; i++) { > > filter[i * filterSize] = fone; > >@@ -368,8 +368,8 @@ static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, > > int i; > > int64_t xDstInSrc; > > filterSize = 1; > >- FF_ALLOC_ARRAY_OR_GOTO(NULL, filter, > >- dstW, sizeof(*filter) * filterSize, fail); > >+ FF_ALLOC_ARRAY_OR_GOTO(filter, > >+ dstW, sizeof(*filter) * filterSize, ret, goto fail); > > > > xDstInSrc = ((dstPos*(int64_t)xInc)>>8) - ((srcPos*0x8000LL)>>7); > > for (i = 0; i < dstW; i++) { > >@@ -384,8 +384,8 @@ static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, > > int i; > > int64_t xDstInSrc; > > filterSize = 2; > >- FF_ALLOC_ARRAY_OR_GOTO(NULL, filter, > >- dstW, sizeof(*filter) * filterSize, fail); > >+ FF_ALLOC_ARRAY_OR_GOTO(filter, > >+ dstW, sizeof(*filter) * filterSize, ret, goto fail); > > > > xDstInSrc = ((dstPos*(int64_t)xInc)>>8) - ((srcPos*0x8000LL)>>7); > > for (i = 0; i < dstW; i++) { > >@@ -425,8 +425,8 @@ static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, > > filterSize = FFMIN(filterSize, srcW - 2); > > filterSize = FFMAX(filterSize, 1); > > > >- FF_ALLOC_ARRAY_OR_GOTO(NULL, filter, > >- dstW, sizeof(*filter) * filterSize, fail); > >+ FF_ALLOC_ARRAY_OR_GOTO(filter, > >+ dstW, sizeof(*filter) * filterSize, ret, goto fail); > > > > xDstInSrc = ((dstPos*(int64_t)xInc)>>7) - ((srcPos*0x10000LL)>>7); > > for (i = 0; i < dstW; i++) { > >@@ -525,7 +525,7 @@ static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, > > if (dstFilter) > > filter2Size += dstFilter->length - 1; > > av_assert0(filter2Size > 0); > >- FF_ALLOCZ_ARRAY_OR_GOTO(NULL, filter2, dstW, filter2Size * sizeof(*filter2), fail); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(filter2, dstW, filter2Size * sizeof(*filter2), ret, goto fail); > > > > for (i = 0; i < dstW; i++) { > > int j, k; > >@@ -684,8 +684,8 @@ static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, > > > > // Note the +1 is for the MMX scaler which reads over the end > > /* align at 16 for AltiVec (needed by hScale_altivec_real) */ > >- FF_ALLOCZ_ARRAY_OR_GOTO(NULL, *outFilter, > >- (dstW + 3), *outFilterSize * sizeof(int16_t), fail); > >+ FF_ALLOCZ_ARRAY_OR_GOTO(*outFilter, > >+ (dstW + 3), *outFilterSize * sizeof(int16_t), ret, goto fail); > > > > /* normalize & store in outFilter */ > > for (i = 0; i < dstW; i++) { > >@@ -1415,7 +1415,7 @@ av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter, > > c->chrDstW = AV_CEIL_RSHIFT(dstW, c->chrDstHSubSample); > > c->chrDstH = AV_CEIL_RSHIFT(dstH, c->chrDstVSubSample); > > > >- FF_ALLOCZ_OR_GOTO(c, c->formatConvBuffer, FFALIGN(srcW*2+78, 16) * 2, fail); > >+ FF_ALLOCZ_OR_GOTO(c->formatConvBuffer, FFALIGN(srcW*2+78, 16) * 2, ret, goto fail); > > > > c->srcBpc = desc_src->comp[0].depth; > > if (c->srcBpc < 8) > >@@ -1655,10 +1655,10 @@ av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter, > > return AVERROR(ENOMEM); > > } > > > >- FF_ALLOCZ_OR_GOTO(c, c->hLumFilter, (dstW / 8 + 8) * sizeof(int16_t), fail); > >- FF_ALLOCZ_OR_GOTO(c, c->hChrFilter, (c->chrDstW / 4 + 8) * sizeof(int16_t), fail); > >- FF_ALLOCZ_OR_GOTO(c, c->hLumFilterPos, (dstW / 2 / 8 + 8) * sizeof(int32_t), fail); > >- FF_ALLOCZ_OR_GOTO(c, c->hChrFilterPos, (c->chrDstW / 2 / 4 + 8) * sizeof(int32_t), fail); > >+ FF_ALLOCZ_OR_GOTO(c->hLumFilter, (dstW / 8 + 8) * sizeof(int16_t), ret, goto fail); > >+ FF_ALLOCZ_OR_GOTO(c->hChrFilter, (c->chrDstW / 4 + 8) * sizeof(int16_t), ret, goto fail); > >+ FF_ALLOCZ_OR_GOTO(c->hLumFilterPos, (dstW / 2 / 8 + 8) * sizeof(int32_t), ret, goto fail); > >+ FF_ALLOCZ_OR_GOTO(c->hChrFilterPos, (c->chrDstW / 2 / 4 + 8) * sizeof(int32_t), ret, goto fail); > > > > ff_init_hscaler_mmxext( dstW, c->lumXInc, c->lumMmxextFilterCode, > > c->hLumFilter, (uint32_t*)c->hLumFilterPos, 8); > >@@ -1726,8 +1726,8 @@ av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter, > > goto fail; > > > >#if HAVE_ALTIVEC > >- FF_ALLOC_OR_GOTO(c, c->vYCoeffsBank, sizeof(vector signed short) * c->vLumFilterSize * c->dstH, fail); > >- FF_ALLOC_OR_GOTO(c, c->vCCoeffsBank, sizeof(vector signed short) * c->vChrFilterSize * c->chrDstH, fail); > >+ FF_ALLOC_OR_GOTO(c->vYCoeffsBank, sizeof(vector signed short) * c->vLumFilterSize * c->dstH, ret, goto fail); > >+ FF_ALLOC_OR_GOTO(c->vCCoeffsBank, sizeof(vector signed short) * c->vChrFilterSize * c->chrDstH, ret, goto fail); > > > > for (i = 0; i < c->vLumFilterSize * c->dstH; i++) { > > int j; > >@@ -1746,7 +1746,7 @@ av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter, > > } > > > > for (i = 0; i < 4; i++) > >- FF_ALLOCZ_OR_GOTO(c, c->dither_error[i], (c->dstW+2) * sizeof(int), fail); > >+ FF_ALLOCZ_OR_GOTO(c->dither_error[i], (c->dstW+2) * sizeof(int), ret, goto fail); > > > > c->needAlpha = (CONFIG_SWSCALE_ALPHA && isALPHA(c->srcFormat) && isALPHA(c->dstFormat)) ? 1 : 0; > > > >-- > >2.6.4 > > > >_______________________________________________ > >ffmpeg-devel mailing list > >ffmpeg-devel@ffmpeg.org > >https://ffmpeg.org/mailman/listinfo/ffmpeg-devel > > > >To unsubscribe, visit link above, or email > >ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe". > _______________________________________________ > ffmpeg-devel mailing list > ffmpeg-devel@ffmpeg.org > https://ffmpeg.org/mailman/listinfo/ffmpeg-devel > > To unsubscribe, visit link above, or email > ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".
diff --git a/libavcodec/aacenc.c b/libavcodec/aacenc.c index 4d0abb1..9855e40 100644 --- a/libavcodec/aacenc.c +++ b/libavcodec/aacenc.c @@ -939,16 +939,14 @@ static av_cold int dsp_init(AVCodecContext *avctx, AACEncContext *s) static av_cold int alloc_buffers(AVCodecContext *avctx, AACEncContext *s) { - int ch; - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->buffer.samples, s->channels, 3 * 1024 * sizeof(s->buffer.samples[0]), alloc_fail); - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->cpe, s->chan_map[0], sizeof(ChannelElement), alloc_fail); + int ret, ch; + FF_ALLOCZ_ARRAY_OR_GOTO(s->buffer.samples, s->channels, 3 * 1024 * sizeof(s->buffer.samples[0]), ret, return ret); + FF_ALLOCZ_ARRAY_OR_GOTO(s->cpe, s->chan_map[0], sizeof(ChannelElement), ret, return ret); for(ch = 0; ch < s->channels; ch++) s->planar_samples[ch] = s->buffer.samples + 3 * 1024 * ch; return 0; -alloc_fail: - return AVERROR(ENOMEM); } static av_cold void aac_encode_init_tables(void) diff --git a/libavcodec/ac3enc.c b/libavcodec/ac3enc.c index ddbc7b2..19434d4 100644 --- a/libavcodec/ac3enc.c +++ b/libavcodec/ac3enc.c @@ -2322,60 +2322,60 @@ static av_cold void set_bandwidth(AC3EncodeContext *s) static av_cold int allocate_buffers(AC3EncodeContext *s) { - AVCodecContext *avctx = s->avctx; int blk, ch; int channels = s->channels + 1; /* includes coupling channel */ int channel_blocks = channels * s->num_blocks; int total_coefs = AC3_MAX_COEFS * channel_blocks; + int ret; + + if (ret = s->allocate_sample_buffers(s)) + return ret; - if (s->allocate_sample_buffers(s)) - goto alloc_fail; - - FF_ALLOC_ARRAY_OR_GOTO(avctx, s->bap_buffer, total_coefs, - sizeof(*s->bap_buffer), alloc_fail); - FF_ALLOC_ARRAY_OR_GOTO(avctx, s->bap1_buffer, total_coefs, - sizeof(*s->bap1_buffer), alloc_fail); - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->mdct_coef_buffer, total_coefs, - sizeof(*s->mdct_coef_buffer), alloc_fail); - FF_ALLOC_ARRAY_OR_GOTO(avctx, s->exp_buffer, total_coefs, - sizeof(*s->exp_buffer), alloc_fail); - FF_ALLOC_ARRAY_OR_GOTO(avctx, s->grouped_exp_buffer, channel_blocks, 128 * - sizeof(*s->grouped_exp_buffer), alloc_fail); - FF_ALLOC_ARRAY_OR_GOTO(avctx, s->psd_buffer, total_coefs, - sizeof(*s->psd_buffer), alloc_fail); - FF_ALLOC_ARRAY_OR_GOTO(avctx, s->band_psd_buffer, channel_blocks, 64 * - sizeof(*s->band_psd_buffer), alloc_fail); - FF_ALLOC_ARRAY_OR_GOTO(avctx, s->mask_buffer, channel_blocks, 64 * - sizeof(*s->mask_buffer), alloc_fail); - FF_ALLOC_ARRAY_OR_GOTO(avctx, s->qmant_buffer, total_coefs, - sizeof(*s->qmant_buffer), alloc_fail); + FF_ALLOC_ARRAY_OR_GOTO(s->bap_buffer, total_coefs, + sizeof(*s->bap_buffer), ret, return ret); + FF_ALLOC_ARRAY_OR_GOTO(s->bap1_buffer, total_coefs, + sizeof(*s->bap1_buffer), ret, return ret); + FF_ALLOCZ_ARRAY_OR_GOTO(s->mdct_coef_buffer, total_coefs, + sizeof(*s->mdct_coef_buffer), ret, return ret); + FF_ALLOC_ARRAY_OR_GOTO(s->exp_buffer, total_coefs, + sizeof(*s->exp_buffer), ret, return ret); + FF_ALLOC_ARRAY_OR_GOTO(s->grouped_exp_buffer, channel_blocks, 128 * + sizeof(*s->grouped_exp_buffer), ret, return ret); + FF_ALLOC_ARRAY_OR_GOTO(s->psd_buffer, total_coefs, + sizeof(*s->psd_buffer), ret, return ret); + FF_ALLOC_ARRAY_OR_GOTO(s->band_psd_buffer, channel_blocks, 64 * + sizeof(*s->band_psd_buffer), ret, return ret); + FF_ALLOC_ARRAY_OR_GOTO(s->mask_buffer, channel_blocks, 64 * + sizeof(*s->mask_buffer), ret, return ret); + FF_ALLOC_ARRAY_OR_GOTO(s->qmant_buffer, total_coefs, + sizeof(*s->qmant_buffer), ret, return ret); if (s->cpl_enabled) { - FF_ALLOC_ARRAY_OR_GOTO(avctx, s->cpl_coord_exp_buffer, channel_blocks, 16 * - sizeof(*s->cpl_coord_exp_buffer), alloc_fail); - FF_ALLOC_ARRAY_OR_GOTO(avctx, s->cpl_coord_mant_buffer, channel_blocks, 16 * - sizeof(*s->cpl_coord_mant_buffer), alloc_fail); + FF_ALLOC_ARRAY_OR_GOTO(s->cpl_coord_exp_buffer, channel_blocks, 16 * + sizeof(*s->cpl_coord_exp_buffer), ret, return ret); + FF_ALLOC_ARRAY_OR_GOTO(s->cpl_coord_mant_buffer, channel_blocks, 16 * + sizeof(*s->cpl_coord_mant_buffer), ret, return ret); } for (blk = 0; blk < s->num_blocks; blk++) { AC3Block *block = &s->blocks[blk]; - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->mdct_coef, channels, sizeof(*block->mdct_coef), - alloc_fail); - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->exp, channels, sizeof(*block->exp), - alloc_fail); - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->grouped_exp, channels, sizeof(*block->grouped_exp), - alloc_fail); - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->psd, channels, sizeof(*block->psd), - alloc_fail); - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->band_psd, channels, sizeof(*block->band_psd), - alloc_fail); - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->mask, channels, sizeof(*block->mask), - alloc_fail); - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->qmant, channels, sizeof(*block->qmant), - alloc_fail); + FF_ALLOCZ_ARRAY_OR_GOTO(block->mdct_coef, channels, sizeof(*block->mdct_coef), + ret, return ret); + FF_ALLOCZ_ARRAY_OR_GOTO(block->exp, channels, sizeof(*block->exp), + ret, return ret); + FF_ALLOCZ_ARRAY_OR_GOTO(block->grouped_exp, channels, sizeof(*block->grouped_exp), + ret, return ret); + FF_ALLOCZ_ARRAY_OR_GOTO(block->psd, channels, sizeof(*block->psd), + ret, return ret); + FF_ALLOCZ_ARRAY_OR_GOTO(block->band_psd, channels, sizeof(*block->band_psd), + ret, return ret); + FF_ALLOCZ_ARRAY_OR_GOTO(block->mask, channels, sizeof(*block->mask), + ret, return ret); + FF_ALLOCZ_ARRAY_OR_GOTO(block->qmant, channels, sizeof(*block->qmant), + ret, return ret); if (s->cpl_enabled) { - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->cpl_coord_exp, channels, sizeof(*block->cpl_coord_exp), - alloc_fail); - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->cpl_coord_mant, channels, sizeof(*block->cpl_coord_mant), - alloc_fail); + FF_ALLOCZ_ARRAY_OR_GOTO(block->cpl_coord_exp, channels, sizeof(*block->cpl_coord_exp), + ret, return ret); + FF_ALLOCZ_ARRAY_OR_GOTO(block->cpl_coord_mant, channels, sizeof(*block->cpl_coord_mant), + ret, return ret); } for (ch = 0; ch < channels; ch++) { @@ -2397,28 +2397,26 @@ static av_cold int allocate_buffers(AC3EncodeContext *s) } if (!s->fixed_point) { - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->fixed_coef_buffer, total_coefs, - sizeof(*s->fixed_coef_buffer), alloc_fail); + FF_ALLOCZ_ARRAY_OR_GOTO(s->fixed_coef_buffer, total_coefs, + sizeof(*s->fixed_coef_buffer), ret, return ret); for (blk = 0; blk < s->num_blocks; blk++) { AC3Block *block = &s->blocks[blk]; - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->fixed_coef, channels, - sizeof(*block->fixed_coef), alloc_fail); + FF_ALLOCZ_ARRAY_OR_GOTO(block->fixed_coef, channels, + sizeof(*block->fixed_coef), ret, return ret); for (ch = 0; ch < channels; ch++) block->fixed_coef[ch] = &s->fixed_coef_buffer[AC3_MAX_COEFS * (s->num_blocks * ch + blk)]; } } else { for (blk = 0; blk < s->num_blocks; blk++) { AC3Block *block = &s->blocks[blk]; - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, block->fixed_coef, channels, - sizeof(*block->fixed_coef), alloc_fail); + FF_ALLOCZ_ARRAY_OR_GOTO(block->fixed_coef, channels, + sizeof(*block->fixed_coef), ret, return ret); for (ch = 0; ch < channels; ch++) block->fixed_coef[ch] = (int32_t *)block->mdct_coef[ch]; } } return 0; -alloc_fail: - return AVERROR(ENOMEM); } diff --git a/libavcodec/ac3enc_template.c b/libavcodec/ac3enc_template.c index be65987..ec4e984 100644 --- a/libavcodec/ac3enc_template.c +++ b/libavcodec/ac3enc_template.c @@ -39,21 +39,20 @@ int AC3_NAME(allocate_sample_buffers)(AC3EncodeContext *s) { + int ret; int ch; - FF_ALLOC_OR_GOTO(s->avctx, s->windowed_samples, AC3_WINDOW_SIZE * - sizeof(*s->windowed_samples), alloc_fail); - FF_ALLOC_ARRAY_OR_GOTO(s->avctx, s->planar_samples, s->channels, sizeof(*s->planar_samples), - alloc_fail); + FF_ALLOC_OR_GOTO(s->windowed_samples, AC3_WINDOW_SIZE * + sizeof(*s->windowed_samples), ret, return ret); + FF_ALLOC_ARRAY_OR_GOTO(s->planar_samples, s->channels, sizeof(*s->planar_samples), + ret, return ret); for (ch = 0; ch < s->channels; ch++) { - FF_ALLOCZ_OR_GOTO(s->avctx, s->planar_samples[ch], + FF_ALLOCZ_OR_GOTO(s->planar_samples[ch], (AC3_FRAME_SIZE+AC3_BLOCK_SIZE) * sizeof(**s->planar_samples), - alloc_fail); + ret, return ret); } return 0; -alloc_fail: - return AVERROR(ENOMEM); } diff --git a/libavcodec/adpcmenc.c b/libavcodec/adpcmenc.c index 668939c..18d08fd 100644 --- a/libavcodec/adpcmenc.c +++ b/libavcodec/adpcmenc.c @@ -65,7 +65,7 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx) ADPCMEncodeContext *s = avctx->priv_data; uint8_t *extradata; int i; - int ret = AVERROR(ENOMEM); + int ret; if (avctx->channels > 2) { av_log(avctx, AV_LOG_ERROR, "only stereo or mono is supported\n"); @@ -80,14 +80,10 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx) if (avctx->trellis) { int frontier = 1 << avctx->trellis; int max_paths = frontier * FREEZE_INTERVAL; - FF_ALLOC_OR_GOTO(avctx, s->paths, - max_paths * sizeof(*s->paths), error); - FF_ALLOC_OR_GOTO(avctx, s->node_buf, - 2 * frontier * sizeof(*s->node_buf), error); - FF_ALLOC_OR_GOTO(avctx, s->nodep_buf, - 2 * frontier * sizeof(*s->nodep_buf), error); - FF_ALLOC_OR_GOTO(avctx, s->trellis_hash, - 65536 * sizeof(*s->trellis_hash), error); + FF_ALLOC_OR_GOTO(s->paths, max_paths * sizeof(*s->paths), ret, return ret); + FF_ALLOC_OR_GOTO(s->node_buf, 2 * frontier * sizeof(*s->node_buf), ret, return ret); + FF_ALLOC_OR_GOTO(s->nodep_buf, 2 * frontier * sizeof(*s->nodep_buf), ret, return ret); + FF_ALLOC_OR_GOTO(s->trellis_hash, 65536 * sizeof(*s->trellis_hash), ret, return ret); } avctx->bits_per_coded_sample = av_get_bits_per_sample(avctx->codec->id); @@ -114,7 +110,7 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx) avctx->bits_per_coded_sample = 4; avctx->block_align = BLKSIZE; if (!(avctx->extradata = av_malloc(32 + AV_INPUT_BUFFER_PADDING_SIZE))) - goto error; + return AVERROR(ENOMEM); avctx->extradata_size = 32; extradata = avctx->extradata; bytestream_put_le16(&extradata, avctx->frame_size); @@ -134,20 +130,15 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx) avctx->sample_rate != 44100) { av_log(avctx, AV_LOG_ERROR, "Sample rate must be 11025, " "22050 or 44100\n"); - ret = AVERROR(EINVAL); - goto error; + return AVERROR(EINVAL); } avctx->frame_size = 512 * (avctx->sample_rate / 11025); break; default: - ret = AVERROR(EINVAL); - goto error; + return AVERROR(EINVAL); } return 0; -error: - adpcm_encode_close(avctx); - return ret; } static av_cold int adpcm_encode_close(AVCodecContext *avctx) @@ -509,7 +500,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, /* stereo: 4 bytes (8 samples) for left, 4 bytes for right */ if (avctx->trellis > 0) { - FF_ALLOC_ARRAY_OR_GOTO(avctx, buf, avctx->channels, blocks * 8, error); + FF_ALLOC_ARRAY_OR_GOTO(buf, avctx->channels, blocks * 8, ret, return ret); for (ch = 0; ch < avctx->channels; ch++) { adpcm_compress_trellis(avctx, &samples_p[ch][1], buf + ch * blocks * 8, &c->status[ch], @@ -588,7 +579,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, } if (avctx->trellis > 0) { - FF_ALLOC_OR_GOTO(avctx, buf, 2 * n, error); + FF_ALLOC_OR_GOTO(buf, 2 * n, ret, return ret); adpcm_compress_trellis(avctx, samples + avctx->channels, buf, &c->status[0], n, avctx->channels); if (avctx->channels == 2) @@ -636,7 +627,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, if (avctx->trellis > 0) { n = avctx->block_align - 7 * avctx->channels; - FF_ALLOC_OR_GOTO(avctx, buf, 2 * n, error); + FF_ALLOC_OR_GOTO(buf, 2 * n, ret, return ret); if (avctx->channels == 1) { adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n, avctx->channels); @@ -663,7 +654,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, case AV_CODEC_ID_ADPCM_YAMAHA: n = frame->nb_samples / 2; if (avctx->trellis > 0) { - FF_ALLOC_OR_GOTO(avctx, buf, 2 * n * 2, error); + FF_ALLOC_OR_GOTO(buf, 2 * n * 2, ret, return ret); n *= 2; if (avctx->channels == 1) { adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n, @@ -694,8 +685,6 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, avpkt->size = pkt_size; *got_packet_ptr = 1; return 0; -error: - return AVERROR(ENOMEM); } static const enum AVSampleFormat sample_fmts[] = { diff --git a/libavcodec/alac.c b/libavcodec/alac.c index c8c0422..e7245b8 100644 --- a/libavcodec/alac.c +++ b/libavcodec/alac.c @@ -487,7 +487,7 @@ static av_cold int alac_decode_close(AVCodecContext *avctx) static int allocate_buffers(ALACContext *alac) { - int ch; + int ch, ret; unsigned buf_size = alac->max_samples_per_frame * sizeof(int32_t); for (ch = 0; ch < 2; ch++) { @@ -497,22 +497,19 @@ static int allocate_buffers(ALACContext *alac) } for (ch = 0; ch < FFMIN(alac->channels, 2); ch++) { - FF_ALLOC_OR_GOTO(alac->avctx, alac->predict_error_buffer[ch], - buf_size, buf_alloc_fail); + FF_ALLOC_OR_GOTO(alac->predict_error_buffer[ch], + buf_size, ret, return ret); alac->direct_output = alac->sample_size > 16; if (!alac->direct_output) { - FF_ALLOC_OR_GOTO(alac->avctx, alac->output_samples_buffer[ch], - buf_size + AV_INPUT_BUFFER_PADDING_SIZE, buf_alloc_fail); + FF_ALLOC_OR_GOTO(alac->output_samples_buffer[ch], + buf_size + AV_INPUT_BUFFER_PADDING_SIZE, ret, return ret); } - FF_ALLOC_OR_GOTO(alac->avctx, alac->extra_bits_buffer[ch], - buf_size + AV_INPUT_BUFFER_PADDING_SIZE, buf_alloc_fail); + FF_ALLOC_OR_GOTO(alac->extra_bits_buffer[ch], + buf_size + AV_INPUT_BUFFER_PADDING_SIZE, ret, return ret); } return 0; -buf_alloc_fail: - alac_decode_close(alac->avctx); - return AVERROR(ENOMEM); } static int alac_set_info(ALACContext *alac) diff --git a/libavcodec/apedec.c b/libavcodec/apedec.c index 2d19250..7db4467 100644 --- a/libavcodec/apedec.c +++ b/libavcodec/apedec.c @@ -215,7 +215,7 @@ static av_cold int ape_decode_close(AVCodecContext *avctx) static av_cold int ape_decode_init(AVCodecContext *avctx) { APEContext *s = avctx->priv_data; - int i; + int i, ret; if (avctx->extradata_size != 6) { av_log(avctx, AV_LOG_ERROR, "Incorrect extradata\n"); @@ -260,9 +260,9 @@ static av_cold int ape_decode_init(AVCodecContext *avctx) for (i = 0; i < APE_FILTER_LEVELS; i++) { if (!ape_filter_orders[s->fset][i]) break; - FF_ALLOC_OR_GOTO(avctx, s->filterbuf[i], + FF_ALLOC_OR_GOTO(s->filterbuf[i], (ape_filter_orders[s->fset][i] * 3 + HISTORY_SIZE) * 4, - filter_alloc_fail); + ret, return ret); } if (s->fileversion < 3860) { @@ -298,9 +298,6 @@ static av_cold int ape_decode_init(AVCodecContext *avctx) avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO; return 0; -filter_alloc_fail: - ape_decode_close(avctx); - return AVERROR(ENOMEM); } /** diff --git a/libavcodec/dnxhdenc.c b/libavcodec/dnxhdenc.c index 32ac90f..79d3f3f 100644 --- a/libavcodec/dnxhdenc.c +++ b/libavcodec/dnxhdenc.c @@ -205,15 +205,16 @@ static av_cold int dnxhd_init_vlc(DNXHDEncContext *ctx) { int i, j, level, run; int max_level = 1 << (ctx->bit_depth + 2); + int ret; - FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->orig_vlc_codes, - max_level, 4 * sizeof(*ctx->orig_vlc_codes), fail); - FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->orig_vlc_bits, - max_level, 4 * sizeof(*ctx->orig_vlc_bits), fail); - FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_codes, - 63 * 2, fail); - FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_bits, - 63, fail); + FF_ALLOCZ_ARRAY_OR_GOTO(ctx->orig_vlc_codes, + max_level, 4 * sizeof(*ctx->orig_vlc_codes), ret, return ret); + FF_ALLOCZ_ARRAY_OR_GOTO(ctx->orig_vlc_bits, + max_level, 4 * sizeof(*ctx->orig_vlc_bits), ret, return ret); + FF_ALLOCZ_OR_GOTO(ctx->run_codes, + 63 * 2, ret, return ret); + FF_ALLOCZ_OR_GOTO(ctx->run_bits, + 63, ret, return ret); ctx->vlc_codes = ctx->orig_vlc_codes + max_level * 2; ctx->vlc_bits = ctx->orig_vlc_bits + max_level * 2; @@ -258,8 +259,6 @@ static av_cold int dnxhd_init_vlc(DNXHDEncContext *ctx) ctx->run_bits[run] = ctx->cid_table->run_bits[i]; } return 0; -fail: - return AVERROR(ENOMEM); } static av_cold int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias) @@ -269,17 +268,18 @@ static av_cold int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias) int qscale, i; const uint8_t *luma_weight_table = ctx->cid_table->luma_weight; const uint8_t *chroma_weight_table = ctx->cid_table->chroma_weight; + int ret; - FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l, - (ctx->m.avctx->qmax + 1), 64 * sizeof(int), fail); - FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c, - (ctx->m.avctx->qmax + 1), 64 * sizeof(int), fail); - FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l16, + FF_ALLOCZ_ARRAY_OR_GOTO(ctx->qmatrix_l, + (ctx->m.avctx->qmax + 1), 64 * sizeof(int), ret, return ret); + FF_ALLOCZ_ARRAY_OR_GOTO(ctx->qmatrix_c, + (ctx->m.avctx->qmax + 1), 64 * sizeof(int), ret, return ret); + FF_ALLOCZ_ARRAY_OR_GOTO(ctx->qmatrix_l16, (ctx->m.avctx->qmax + 1), 64 * 2 * sizeof(uint16_t), - fail); - FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c16, + ret, return ret); + FF_ALLOCZ_ARRAY_OR_GOTO(ctx->qmatrix_c16, (ctx->m.avctx->qmax + 1), 64 * 2 * sizeof(uint16_t), - fail); + ret, return ret); if (ctx->bit_depth == 8) { for (i = 1; i < 64; i++) { @@ -338,27 +338,24 @@ static av_cold int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias) ctx->m.q_intra_matrix = ctx->qmatrix_l; return 0; -fail: - return AVERROR(ENOMEM); } static av_cold int dnxhd_init_rc(DNXHDEncContext *ctx) { - FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->mb_rc, (ctx->m.avctx->qmax + 1), - ctx->m.mb_num * sizeof(RCEntry), fail); + int ret; + FF_ALLOCZ_ARRAY_OR_GOTO(ctx->mb_rc, (ctx->m.avctx->qmax + 1), + ctx->m.mb_num * sizeof(RCEntry), ret, return ret); if (ctx->m.avctx->mb_decision != FF_MB_DECISION_RD) { - FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->mb_cmp, - ctx->m.mb_num, sizeof(RCCMPEntry), fail); - FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->mb_cmp_tmp, - ctx->m.mb_num, sizeof(RCCMPEntry), fail); + FF_ALLOCZ_ARRAY_OR_GOTO(ctx->mb_cmp, + ctx->m.mb_num, sizeof(RCCMPEntry), ret, return ret); + FF_ALLOCZ_ARRAY_OR_GOTO(ctx->mb_cmp_tmp, + ctx->m.mb_num, sizeof(RCCMPEntry), ret, return ret); } ctx->frame_bits = (ctx->coding_unit_size - ctx->data_offset - 4 - ctx->min_padding) * 8; ctx->qscale = 1; ctx->lambda = 2 << LAMBDA_FRAC_BITS; // qscale 2 return 0; -fail: - return AVERROR(ENOMEM); } static av_cold int dnxhd_encode_init(AVCodecContext *avctx) @@ -509,14 +506,14 @@ static av_cold int dnxhd_encode_init(AVCodecContext *avctx) if ((ret = dnxhd_init_rc(ctx)) < 0) return ret; - FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->slice_size, - ctx->m.mb_height * sizeof(uint32_t), fail); - FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->slice_offs, - ctx->m.mb_height * sizeof(uint32_t), fail); - FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_bits, - ctx->m.mb_num * sizeof(uint16_t), fail); - FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_qscale, - ctx->m.mb_num * sizeof(uint8_t), fail); + FF_ALLOCZ_OR_GOTO(ctx->slice_size, + ctx->m.mb_height * sizeof(uint32_t), ret, return ret); + FF_ALLOCZ_OR_GOTO(ctx->slice_offs, + ctx->m.mb_height * sizeof(uint32_t), ret, return ret); + FF_ALLOCZ_OR_GOTO(ctx->mb_bits, + ctx->m.mb_num * sizeof(uint16_t), ret, return ret); + FF_ALLOCZ_OR_GOTO(ctx->mb_qscale, + ctx->m.mb_num * sizeof(uint8_t), ret, return ret); #if FF_API_CODED_FRAME FF_DISABLE_DEPRECATION_WARNINGS @@ -542,14 +539,12 @@ FF_ENABLE_DEPRECATION_WARNINGS for (i = 1; i < avctx->thread_count; i++) { ctx->thread[i] = av_malloc(sizeof(DNXHDEncContext)); if (!ctx->thread[i]) - goto fail; + return AVERROR(ENOMEM); memcpy(ctx->thread[i], ctx, sizeof(DNXHDEncContext)); } } return 0; -fail: // for FF_ALLOCZ_OR_GOTO - return AVERROR(ENOMEM); } static int dnxhd_write_header(AVCodecContext *avctx, uint8_t *buf) diff --git a/libavcodec/h264dec.c b/libavcodec/h264dec.c index 4c355fe..0bcc60f 100644 --- a/libavcodec/h264dec.c +++ b/libavcodec/h264dec.c @@ -181,39 +181,40 @@ int ff_h264_alloc_tables(H264Context *h) const int big_mb_num = h->mb_stride * (h->mb_height + 1); const int row_mb_num = 2*h->mb_stride*FFMAX(h->nb_slice_ctx, 1); int x, y; + int ret; - FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->intra4x4_pred_mode, - row_mb_num, 8 * sizeof(uint8_t), fail) + FF_ALLOCZ_ARRAY_OR_GOTO(h->intra4x4_pred_mode, + row_mb_num, 8 * sizeof(uint8_t), ret, return ret) h->slice_ctx[0].intra4x4_pred_mode = h->intra4x4_pred_mode; - FF_ALLOCZ_OR_GOTO(h->avctx, h->non_zero_count, - big_mb_num * 48 * sizeof(uint8_t), fail) - FF_ALLOCZ_OR_GOTO(h->avctx, h->slice_table_base, - (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base), fail) - FF_ALLOCZ_OR_GOTO(h->avctx, h->cbp_table, - big_mb_num * sizeof(uint16_t), fail) - FF_ALLOCZ_OR_GOTO(h->avctx, h->chroma_pred_mode_table, - big_mb_num * sizeof(uint8_t), fail) - FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[0], - row_mb_num, 16 * sizeof(uint8_t), fail); - FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[1], - row_mb_num, 16 * sizeof(uint8_t), fail); + FF_ALLOCZ_OR_GOTO(h->non_zero_count, + big_mb_num * 48 * sizeof(uint8_t), ret, return ret) + FF_ALLOCZ_OR_GOTO(h->slice_table_base, + (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base), ret, return ret) + FF_ALLOCZ_OR_GOTO(h->cbp_table, + big_mb_num * sizeof(uint16_t), ret, return ret) + FF_ALLOCZ_OR_GOTO(h->chroma_pred_mode_table, + big_mb_num * sizeof(uint8_t), ret, return ret) + FF_ALLOCZ_ARRAY_OR_GOTO(h->mvd_table[0], + row_mb_num, 16 * sizeof(uint8_t), ret, return ret); + FF_ALLOCZ_ARRAY_OR_GOTO(h->mvd_table[1], + row_mb_num, 16 * sizeof(uint8_t), ret, return ret); h->slice_ctx[0].mvd_table[0] = h->mvd_table[0]; h->slice_ctx[0].mvd_table[1] = h->mvd_table[1]; - FF_ALLOCZ_OR_GOTO(h->avctx, h->direct_table, - 4 * big_mb_num * sizeof(uint8_t), fail); - FF_ALLOCZ_OR_GOTO(h->avctx, h->list_counts, - big_mb_num * sizeof(uint8_t), fail) + FF_ALLOCZ_OR_GOTO(h->direct_table, + 4 * big_mb_num * sizeof(uint8_t), ret, return ret); + FF_ALLOCZ_OR_GOTO(h->list_counts, + big_mb_num * sizeof(uint8_t), ret, return ret) memset(h->slice_table_base, -1, (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base)); h->slice_table = h->slice_table_base + h->mb_stride * 2 + 1; - FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2b_xy, - big_mb_num * sizeof(uint32_t), fail); - FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2br_xy, - big_mb_num * sizeof(uint32_t), fail); + FF_ALLOCZ_OR_GOTO(h->mb2b_xy, + big_mb_num * sizeof(uint32_t), ret, return ret); + FF_ALLOCZ_OR_GOTO(h->mb2br_xy, + big_mb_num * sizeof(uint32_t), ret, return ret); for (y = 0; y < h->mb_height; y++) for (x = 0; x < h->mb_width; x++) { const int mb_xy = x + y * h->mb_stride; @@ -224,10 +225,6 @@ int ff_h264_alloc_tables(H264Context *h) } return 0; - -fail: - ff_h264_free_tables(h); - return AVERROR(ENOMEM); } /** @@ -242,6 +239,7 @@ int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl) int c_size = h->mb_stride * (h->mb_height + 1); int yc_size = y_size + 2 * c_size; int x, y, i; + int ret; sl->ref_cache[0][scan8[5] + 1] = sl->ref_cache[0][scan8[7] + 1] = @@ -268,8 +266,8 @@ int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl) er->b8_stride = h->mb_width * 2 + 1; // error resilience code looks cleaner with this - FF_ALLOCZ_OR_GOTO(h->avctx, er->mb_index2xy, - (h->mb_num + 1) * sizeof(int), fail); + FF_ALLOCZ_OR_GOTO(er->mb_index2xy, + (h->mb_num + 1) * sizeof(int), ret, return ret); for (y = 0; y < h->mb_height; y++) for (x = 0; x < h->mb_width; x++) @@ -278,14 +276,14 @@ int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl) er->mb_index2xy[h->mb_height * h->mb_width] = (h->mb_height - 1) * h->mb_stride + h->mb_width; - FF_ALLOCZ_OR_GOTO(h->avctx, er->error_status_table, - mb_array_size * sizeof(uint8_t), fail); + FF_ALLOCZ_OR_GOTO(er->error_status_table, + mb_array_size * sizeof(uint8_t), ret, return ret); - FF_ALLOC_OR_GOTO(h->avctx, er->er_temp_buffer, - h->mb_height * h->mb_stride * (4*sizeof(int) + 1), fail); + FF_ALLOC_OR_GOTO(er->er_temp_buffer, + h->mb_height * h->mb_stride * (4*sizeof(int) + 1), ret, return ret); - FF_ALLOCZ_OR_GOTO(h->avctx, sl->dc_val_base, - yc_size * sizeof(int16_t), fail); + FF_ALLOCZ_OR_GOTO(sl->dc_val_base, + yc_size * sizeof(int16_t), ret, return ret); er->dc_val[0] = sl->dc_val_base + h->mb_width * 2 + 2; er->dc_val[1] = sl->dc_val_base + y_size + h->mb_stride + 1; er->dc_val[2] = er->dc_val[1] + c_size; @@ -294,9 +292,6 @@ int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl) } return 0; - -fail: - return AVERROR(ENOMEM); // ff_h264_free_tables will clean up for us } static int h264_init_context(AVCodecContext *avctx, H264Context *h) diff --git a/libavcodec/iirfilter.c b/libavcodec/iirfilter.c index b202515..e00cf39 100644 --- a/libavcodec/iirfilter.c +++ b/libavcodec/iirfilter.c @@ -171,12 +171,12 @@ av_cold struct FFIIRFilterCoeffs *ff_iir_filter_init_coeffs(void *avc, if (order <= 0 || order > MAXORDER || cutoff_ratio >= 1.0) return NULL; - FF_ALLOCZ_OR_GOTO(avc, c, sizeof(FFIIRFilterCoeffs), - init_fail); - FF_ALLOC_OR_GOTO(avc, c->cx, sizeof(c->cx[0]) * ((order >> 1) + 1), - init_fail); - FF_ALLOC_OR_GOTO(avc, c->cy, sizeof(c->cy[0]) * order, - init_fail); + FF_ALLOCZ_OR_GOTO(c, sizeof(FFIIRFilterCoeffs), + ret, goto init_fail); + FF_ALLOC_OR_GOTO(c->cx, sizeof(c->cx[0]) * ((order >> 1) + 1), + ret, goto init_fail); + FF_ALLOC_OR_GOTO(c->cy, sizeof(c->cy[0]) * order, + ret, goto init_fail); c->order = order; switch (filt_type) { diff --git a/libavcodec/mpegpicture.c b/libavcodec/mpegpicture.c index 5fce25e..7d70cc8 100644 --- a/libavcodec/mpegpicture.c +++ b/libavcodec/mpegpicture.c @@ -60,6 +60,7 @@ int ff_mpeg_framesize_alloc(AVCodecContext *avctx, MotionEstContext *me, { # define EMU_EDGE_HEIGHT (4 * 70) int alloc_size = FFALIGN(FFABS(linesize) + 64, 32); + int ret; if (avctx->hwaccel) return 0; @@ -78,11 +79,11 @@ int ff_mpeg_framesize_alloc(AVCodecContext *avctx, MotionEstContext *me, // at uvlinesize. It supports only YUV420 so 24x24 is enough // linesize * interlaced * MBsize // we also use this buffer for encoding in encode_mb_internal() needig an additional 32 lines - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, sc->edge_emu_buffer, alloc_size, EMU_EDGE_HEIGHT, - fail); + FF_ALLOCZ_ARRAY_OR_GOTO(sc->edge_emu_buffer, alloc_size, EMU_EDGE_HEIGHT, + ret, goto fail); - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, me->scratchpad, alloc_size, 4 * 16 * 2, - fail) + FF_ALLOCZ_ARRAY_OR_GOTO(me->scratchpad, alloc_size, 4 * 16 * 2, + ret, goto fail) me->temp = me->scratchpad; sc->rd_scratchpad = me->scratchpad; sc->b_scratchpad = me->scratchpad; @@ -91,7 +92,7 @@ int ff_mpeg_framesize_alloc(AVCodecContext *avctx, MotionEstContext *me, return 0; fail: av_freep(&sc->edge_emu_buffer); - return AVERROR(ENOMEM); + return ret; } /** diff --git a/libavcodec/mpegvideo.c b/libavcodec/mpegvideo.c index 49fd1c9..aaf1b40 100644 --- a/libavcodec/mpegvideo.c +++ b/libavcodec/mpegvideo.c @@ -360,6 +360,7 @@ static int init_duplicate_context(MpegEncContext *s) int c_size = s->mb_stride * (s->mb_height + 1); int yc_size = y_size + 2 * c_size; int i; + int ret; if (s->mb_height & 1) yc_size += 2*s->b8_stride + 2*s->mb_stride; @@ -372,25 +373,22 @@ static int init_duplicate_context(MpegEncContext *s) s->sc.obmc_scratchpad = NULL; if (s->encoding) { - FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map, - ME_MAP_SIZE * sizeof(uint32_t), fail) - FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map, - ME_MAP_SIZE * sizeof(uint32_t), fail) + FF_ALLOCZ_OR_GOTO(s->me.map, ME_MAP_SIZE * sizeof(uint32_t), ret, return ret) + FF_ALLOCZ_OR_GOTO(s->me.score_map, ME_MAP_SIZE * sizeof(uint32_t), ret, return ret) if (s->noise_reduction) { - FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum, - 2 * 64 * sizeof(int), fail) + FF_ALLOCZ_OR_GOTO(s->dct_error_sum, 2 * 64 * sizeof(int), ret, return ret) } } - FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(int16_t), fail) + FF_ALLOCZ_OR_GOTO(s->blocks, 64 * 12 * 2 * sizeof(int16_t), ret, return ret) s->block = s->blocks[0]; for (i = 0; i < 12; i++) { s->pblocks[i] = &s->block[i]; } - FF_ALLOCZ_OR_GOTO(s->avctx, s->block32, sizeof(*s->block32), fail) + FF_ALLOCZ_OR_GOTO(s->block32, sizeof(*s->block32), ret, return ret) s->dpcm_direction = 0; - FF_ALLOCZ_OR_GOTO(s->avctx, s->dpcm_macroblock, sizeof(*s->dpcm_macroblock), fail) + FF_ALLOCZ_OR_GOTO(s->dpcm_macroblock, sizeof(*s->dpcm_macroblock), ret, return ret) if (s->avctx->codec_tag == AV_RL32("VCR2")) { // exchange uv @@ -399,16 +397,13 @@ static int init_duplicate_context(MpegEncContext *s) if (s->out_format == FMT_H263) { /* ac values */ - FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base, - yc_size * sizeof(int16_t) * 16, fail); + FF_ALLOCZ_OR_GOTO(s->ac_val_base, yc_size * sizeof(int16_t) * 16, ret, return ret); s->ac_val[0] = s->ac_val_base + s->b8_stride + 1; s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1; s->ac_val[2] = s->ac_val[1] + c_size; } return 0; -fail: - return AVERROR(ENOMEM); // free() through ff_mpv_common_end() } static void free_duplicate_context(MpegEncContext *s) @@ -687,6 +682,7 @@ void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx) static int init_context_frame(MpegEncContext *s) { int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y; + int ret; s->mb_width = (s->width + 15) / 16; s->mb_stride = s->mb_width + 1; @@ -715,8 +711,8 @@ static int init_context_frame(MpegEncContext *s) if (s->mb_height & 1) yc_size += 2*s->b8_stride + 2*s->mb_stride; - FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), - fail); // error resilience code looks cleaner with this + FF_ALLOCZ_OR_GOTO(s->mb_index2xy, (s->mb_num + 1) * sizeof(int), + ret, return ret); // error resilience code looks cleaner with this for (y = 0; y < s->mb_height; y++) for (x = 0; x < s->mb_width; x++) s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride; @@ -725,12 +721,12 @@ static int init_context_frame(MpegEncContext *s) if (s->encoding) { /* Allocate MV tables */ - FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail) - FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail) - FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail) - FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail) - FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail) - FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail) + FF_ALLOCZ_OR_GOTO(s->p_mv_table_base, mv_table_size * 2 * sizeof(int16_t), ret, return ret) + FF_ALLOCZ_OR_GOTO(s->b_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), ret, return ret) + FF_ALLOCZ_OR_GOTO(s->b_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), ret, return ret) + FF_ALLOCZ_OR_GOTO(s->b_bidir_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), ret, return ret) + FF_ALLOCZ_OR_GOTO(s->b_bidir_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), ret, return ret) + FF_ALLOCZ_OR_GOTO(s->b_direct_mv_table_base, mv_table_size * 2 * sizeof(int16_t), ret, return ret) s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1; s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1; s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1; @@ -739,14 +735,14 @@ static int init_context_frame(MpegEncContext *s) s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1; /* Allocate MB type table */ - FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size * sizeof(uint16_t), fail) // needed for encoding + FF_ALLOCZ_OR_GOTO(s->mb_type, mb_array_size * sizeof(uint16_t), ret, return ret) // needed for encoding - FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail) + FF_ALLOCZ_OR_GOTO(s->lambda_table, mb_array_size * sizeof(int), ret, return ret) - FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab, - mb_array_size * sizeof(float), fail); - FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab, - mb_array_size * sizeof(float), fail); + FF_ALLOC_OR_GOTO(s->cplx_tab, + mb_array_size * sizeof(float), ret, return ret); + FF_ALLOC_OR_GOTO(s->bits_tab, + mb_array_size * sizeof(float), ret, return ret); } @@ -757,34 +753,33 @@ static int init_context_frame(MpegEncContext *s) int j, k; for (j = 0; j < 2; j++) { for (k = 0; k < 2; k++) { - FF_ALLOCZ_OR_GOTO(s->avctx, - s->b_field_mv_table_base[i][j][k], + FF_ALLOCZ_OR_GOTO(s->b_field_mv_table_base[i][j][k], mv_table_size * 2 * sizeof(int16_t), - fail); + ret, return ret); s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1; } - FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail) - FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail) + FF_ALLOCZ_OR_GOTO(s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), ret, return ret) + FF_ALLOCZ_OR_GOTO(s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), ret, return ret) s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1; } - FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail) + FF_ALLOCZ_OR_GOTO(s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), ret, return ret) } } if (s->out_format == FMT_H263) { /* cbp values */ - FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size + (s->mb_height&1)*2*s->b8_stride, fail); + FF_ALLOCZ_OR_GOTO(s->coded_block_base, y_size + (s->mb_height&1)*2*s->b8_stride, ret, return ret); s->coded_block = s->coded_block_base + s->b8_stride + 1; /* cbp, ac_pred, pred_dir */ - FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table , mb_array_size * sizeof(uint8_t), fail); - FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail); + FF_ALLOCZ_OR_GOTO(s->cbp_table , mb_array_size * sizeof(uint8_t), ret, return ret); + FF_ALLOCZ_OR_GOTO(s->pred_dir_table, mb_array_size * sizeof(uint8_t), ret, return ret); } if (s->h263_pred || s->h263_plus || !s->encoding) { /* dc values */ // MN: we need these for error resilience of intra-frames - FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail); + FF_ALLOCZ_OR_GOTO(s->dc_val_base, yc_size * sizeof(int16_t), ret, return ret); s->dc_val[0] = s->dc_val_base + s->b8_stride + 1; s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1; s->dc_val[2] = s->dc_val[1] + c_size; @@ -793,16 +788,14 @@ static int init_context_frame(MpegEncContext *s) } /* which mb is an intra block */ - FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail); + FF_ALLOCZ_OR_GOTO(s->mbintra_table, mb_array_size, ret, return ret); memset(s->mbintra_table, 1, mb_array_size); /* init macroblock skip table */ - FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail); + FF_ALLOCZ_OR_GOTO(s->mbskip_table, mb_array_size + 2, ret, return ret); // Note the + 1 is for a quicker MPEG-4 slice_end detection return ff_mpeg_er_init(s); -fail: - return AVERROR(ENOMEM); } static void clear_context(MpegEncContext *s) @@ -934,8 +927,7 @@ av_cold int ff_mpv_common_init(MpegEncContext *s) if (ret) return ret; - FF_ALLOCZ_OR_GOTO(s->avctx, s->picture, - MAX_PICTURE_COUNT * sizeof(Picture), fail_nomem); + FF_ALLOCZ_OR_GOTO(s->picture, MAX_PICTURE_COUNT * sizeof(Picture), ret, return ret); for (i = 0; i < MAX_PICTURE_COUNT; i++) { s->picture[i].f = av_frame_alloc(); if (!s->picture[i].f) diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c index 50ae57e..bc0fc4f 100644 --- a/libavcodec/mpegvideo_enc.c +++ b/libavcodec/mpegvideo_enc.c @@ -924,27 +924,23 @@ FF_ENABLE_DEPRECATION_WARNINGS ff_qpeldsp_init(&s->qdsp); if (s->msmpeg4_version) { - FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, - 2 * 2 * (MAX_LEVEL + 1) * - (MAX_RUN + 1) * 2 * sizeof(int), fail); + FF_ALLOCZ_OR_GOTO(s->ac_stats, 2 * 2 * (MAX_LEVEL + 1) * + (MAX_RUN + 1) * 2 * sizeof(int), ret, return ret); } - FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail); + FF_ALLOCZ_OR_GOTO(s->avctx->stats_out, 256, ret, return ret); - FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix, 64 * 32 * sizeof(int), fail); - FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix, 64 * 32 * sizeof(int), fail); - FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix, 64 * 32 * sizeof(int), fail); - FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail); - FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail); - FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail); - FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, - MAX_PICTURE_COUNT * sizeof(Picture *), fail); - FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, - MAX_PICTURE_COUNT * sizeof(Picture *), fail); + FF_ALLOCZ_OR_GOTO(s->q_intra_matrix, 64 * 32 * sizeof(int), ret, return ret); + FF_ALLOCZ_OR_GOTO(s->q_chroma_intra_matrix, 64 * 32 * sizeof(int), ret, return ret); + FF_ALLOCZ_OR_GOTO(s->q_inter_matrix, 64 * 32 * sizeof(int), ret, return ret); + FF_ALLOCZ_OR_GOTO(s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), ret, return ret); + FF_ALLOCZ_OR_GOTO(s->q_chroma_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), ret, return ret); + FF_ALLOCZ_OR_GOTO(s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), ret, return ret); + FF_ALLOCZ_OR_GOTO(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture *), ret, return ret); + FF_ALLOCZ_OR_GOTO(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture *), ret, return ret); if (s->noise_reduction) { - FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, - 2 * 64 * sizeof(uint16_t), fail); + FF_ALLOCZ_OR_GOTO(s->dct_offset, 2 * 64 * sizeof(uint16_t), ret, return ret); } ff_dct_encode_init(s); @@ -1059,9 +1055,6 @@ FF_ENABLE_DEPRECATION_WARNINGS cpb_props->buffer_size = avctx->rc_buffer_size; return 0; -fail: - ff_mpv_encode_end(avctx); - return AVERROR_UNKNOWN; } av_cold int ff_mpv_encode_end(AVCodecContext *avctx) diff --git a/libavcodec/snow.c b/libavcodec/snow.c index a3e6afc..07c3d5e 100644 --- a/libavcodec/snow.c +++ b/libavcodec/snow.c @@ -431,6 +431,7 @@ av_cold int ff_snow_common_init(AVCodecContext *avctx){ SnowContext *s = avctx->priv_data; int width, height; int i, j; + int ret; s->avctx= avctx; s->max_ref_frames=1; //just make sure it's not an invalid value in case of no initial keyframe @@ -487,28 +488,26 @@ av_cold int ff_snow_common_init(AVCodecContext *avctx){ width= s->avctx->width; height= s->avctx->height; - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->spatial_idwt_buffer, width, height * sizeof(IDWTELEM), fail); - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->spatial_dwt_buffer, width, height * sizeof(DWTELEM), fail); //FIXME this does not belong here - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->temp_dwt_buffer, width, sizeof(DWTELEM), fail); - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->temp_idwt_buffer, width, sizeof(IDWTELEM), fail); - FF_ALLOC_ARRAY_OR_GOTO(avctx, s->run_buffer, ((width + 1) >> 1), ((height + 1) >> 1) * sizeof(*s->run_buffer), fail); + FF_ALLOCZ_ARRAY_OR_GOTO(s->spatial_idwt_buffer, width, height * sizeof(IDWTELEM), ret, return ret); + FF_ALLOCZ_ARRAY_OR_GOTO(s->spatial_dwt_buffer, width, height * sizeof(DWTELEM), ret, return ret); //FIXME this does not belong here + FF_ALLOCZ_ARRAY_OR_GOTO(s->temp_dwt_buffer, width, sizeof(DWTELEM), ret, return ret); + FF_ALLOCZ_ARRAY_OR_GOTO(s->temp_idwt_buffer, width, sizeof(IDWTELEM), ret, return ret); + FF_ALLOC_ARRAY_OR_GOTO(s->run_buffer, ((width + 1) >> 1), ((height + 1) >> 1) * sizeof(*s->run_buffer), ret, return ret); for(i=0; i<MAX_REF_FRAMES; i++) { for(j=0; j<MAX_REF_FRAMES; j++) ff_scale_mv_ref[i][j] = 256*(i+1)/(j+1); s->last_picture[i] = av_frame_alloc(); if (!s->last_picture[i]) - goto fail; + return AVERROR(ENOMEM); } s->mconly_picture = av_frame_alloc(); s->current_picture = av_frame_alloc(); if (!s->mconly_picture || !s->current_picture) - goto fail; + return AVERROR(ENOMEM); return 0; -fail: - return AVERROR(ENOMEM); } int ff_snow_common_init_after_header(AVCodecContext *avctx) { @@ -520,9 +519,9 @@ int ff_snow_common_init_after_header(AVCodecContext *avctx) { if ((ret = ff_get_buffer(s->avctx, s->mconly_picture, AV_GET_BUFFER_FLAG_REF)) < 0) return ret; - FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->scratchbuf, FFMAX(s->mconly_picture->linesize[0], 2*avctx->width+256), 7*MB_SIZE, fail); + FF_ALLOCZ_ARRAY_OR_GOTO(s->scratchbuf, FFMAX(s->mconly_picture->linesize[0], 2*avctx->width+256), 7*MB_SIZE, ret, return ret); emu_buf_size = FFMAX(s->mconly_picture->linesize[0], 2*avctx->width+256) * (2 * MB_SIZE + HTAPS_MAX - 1); - FF_ALLOC_OR_GOTO(avctx, s->emu_edge_buffer, emu_buf_size, fail); + FF_ALLOC_OR_GOTO(s->emu_edge_buffer, emu_buf_size, ret, return ret); } if(s->mconly_picture->format != avctx->pix_fmt) { @@ -571,7 +570,7 @@ int ff_snow_common_init_after_header(AVCodecContext *avctx) { av_freep(&b->x_coeff); b->x_coeff=av_mallocz_array(((b->width+1) * b->height+1), sizeof(x_and_coeff)); if (!b->x_coeff) - goto fail; + return AVERROR(ENOMEM); } w= (w+1)>>1; h= (h+1)>>1; @@ -579,8 +578,6 @@ int ff_snow_common_init_after_header(AVCodecContext *avctx) { } return 0; -fail: - return AVERROR(ENOMEM); } #define USE_HALFPEL_PLANE 0 diff --git a/libavcodec/twinvq.c b/libavcodec/twinvq.c index 34ca184..74a3ba7 100644 --- a/libavcodec/twinvq.c +++ b/libavcodec/twinvq.c @@ -546,24 +546,24 @@ static av_cold int init_mdct_win(TwinVQContext *tctx) return ret; } - FF_ALLOC_ARRAY_OR_GOTO(tctx->avctx, tctx->tmp_buf, - mtab->size, sizeof(*tctx->tmp_buf), alloc_fail); + FF_ALLOC_ARRAY_OR_GOTO(tctx->tmp_buf, + mtab->size, sizeof(*tctx->tmp_buf), ret, return ret); - FF_ALLOC_ARRAY_OR_GOTO(tctx->avctx, tctx->spectrum, + FF_ALLOC_ARRAY_OR_GOTO(tctx->spectrum, 2 * mtab->size, channels * sizeof(*tctx->spectrum), - alloc_fail); - FF_ALLOC_ARRAY_OR_GOTO(tctx->avctx, tctx->curr_frame, + ret, return ret); + FF_ALLOC_ARRAY_OR_GOTO(tctx->curr_frame, 2 * mtab->size, channels * sizeof(*tctx->curr_frame), - alloc_fail); - FF_ALLOC_ARRAY_OR_GOTO(tctx->avctx, tctx->prev_frame, + ret, return ret); + FF_ALLOC_ARRAY_OR_GOTO(tctx->prev_frame, 2 * mtab->size, channels * sizeof(*tctx->prev_frame), - alloc_fail); + ret, return ret); for (i = 0; i < 3; i++) { int m = 4 * mtab->size / mtab->fmode[i].sub; double freq = 2 * M_PI / m; - FF_ALLOC_ARRAY_OR_GOTO(tctx->avctx, tctx->cos_tabs[i], - (m / 4), sizeof(*tctx->cos_tabs[i]), alloc_fail); + FF_ALLOC_ARRAY_OR_GOTO(tctx->cos_tabs[i], + (m / 4), sizeof(*tctx->cos_tabs[i]), ret, return ret); for (j = 0; j <= m / 8; j++) tctx->cos_tabs[i][j] = cos((2 * j + 1) * freq); @@ -576,9 +576,6 @@ static av_cold int init_mdct_win(TwinVQContext *tctx) ff_init_ff_sine_windows(av_log2(mtab->size)); return 0; - -alloc_fail: - return AVERROR(ENOMEM); } /** diff --git a/libavutil/internal.h b/libavutil/internal.h index 4acbcf5..9cf5780 100644 --- a/libavutil/internal.h +++ b/libavutil/internal.h @@ -137,39 +137,39 @@ # define LOCAL_ALIGNED_32(t, v, ...) E1(LOCAL_ALIGNED_A(32, t, v, __VA_ARGS__,,)) #endif -#define FF_ALLOC_OR_GOTO(ctx, p, size, label)\ +#define FF_ALLOC_OR_GOTO(p, size, ret, errstatement)\ {\ p = av_malloc(size);\ if (!(p) && (size) != 0) {\ - av_log(ctx, AV_LOG_ERROR, "Cannot allocate memory.\n");\ - goto label;\ + ret = AVERROR(ENOMEM);\ + errstatement;\ }\ } -#define FF_ALLOCZ_OR_GOTO(ctx, p, size, label)\ +#define FF_ALLOCZ_OR_GOTO(p, size, ret, errstatement)\ {\ p = av_mallocz(size);\ if (!(p) && (size) != 0) {\ - av_log(ctx, AV_LOG_ERROR, "Cannot allocate memory.\n");\ - goto label;\ + ret = AVERROR(ENOMEM);\ + errstatement;\ }\ } -#define FF_ALLOC_ARRAY_OR_GOTO(ctx, p, nelem, elsize, label)\ +#define FF_ALLOC_ARRAY_OR_GOTO(p, nelem, elsize, ret, errstatement)\ {\ p = av_malloc_array(nelem, elsize);\ if (!p) {\ - av_log(ctx, AV_LOG_ERROR, "Cannot allocate memory.\n");\ - goto label;\ + ret = AVERROR(ENOMEM);\ + errstatement;\ }\ } -#define FF_ALLOCZ_ARRAY_OR_GOTO(ctx, p, nelem, elsize, label)\ +#define FF_ALLOCZ_ARRAY_OR_GOTO(p, nelem, elsize, ret, errstatement)\ {\ p = av_mallocz_array(nelem, elsize);\ if (!p) {\ - av_log(ctx, AV_LOG_ERROR, "Cannot allocate memory.\n");\ - goto label;\ + ret = AVERROR(ENOMEM);\ + errstatement;\ }\ } diff --git a/libswscale/utils.c b/libswscale/utils.c index 15c0a19..8ff6a9c 100644 --- a/libswscale/utils.c +++ b/libswscale/utils.c @@ -352,13 +352,13 @@ static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, emms_c(); // FIXME should not be required but IS (even for non-MMX versions) // NOTE: the +3 is for the MMX(+1) / SSE(+3) scaler which reads over the end - FF_ALLOC_ARRAY_OR_GOTO(NULL, *filterPos, (dstW + 3), sizeof(**filterPos), fail); + FF_ALLOC_ARRAY_OR_GOTO(*filterPos, (dstW + 3), sizeof(**filterPos), ret, goto fail); if (FFABS(xInc - 0x10000) < 10 && srcPos == dstPos) { // unscaled int i; filterSize = 1; - FF_ALLOCZ_ARRAY_OR_GOTO(NULL, filter, - dstW, sizeof(*filter) * filterSize, fail); + FF_ALLOCZ_ARRAY_OR_GOTO(filter, + dstW, sizeof(*filter) * filterSize, ret, goto fail); for (i = 0; i < dstW; i++) { filter[i * filterSize] = fone; @@ -368,8 +368,8 @@ static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, int i; int64_t xDstInSrc; filterSize = 1; - FF_ALLOC_ARRAY_OR_GOTO(NULL, filter, - dstW, sizeof(*filter) * filterSize, fail); + FF_ALLOC_ARRAY_OR_GOTO(filter, + dstW, sizeof(*filter) * filterSize, ret, goto fail); xDstInSrc = ((dstPos*(int64_t)xInc)>>8) - ((srcPos*0x8000LL)>>7); for (i = 0; i < dstW; i++) { @@ -384,8 +384,8 @@ static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, int i; int64_t xDstInSrc; filterSize = 2; - FF_ALLOC_ARRAY_OR_GOTO(NULL, filter, - dstW, sizeof(*filter) * filterSize, fail); + FF_ALLOC_ARRAY_OR_GOTO(filter, + dstW, sizeof(*filter) * filterSize, ret, goto fail); xDstInSrc = ((dstPos*(int64_t)xInc)>>8) - ((srcPos*0x8000LL)>>7); for (i = 0; i < dstW; i++) { @@ -425,8 +425,8 @@ static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, filterSize = FFMIN(filterSize, srcW - 2); filterSize = FFMAX(filterSize, 1); - FF_ALLOC_ARRAY_OR_GOTO(NULL, filter, - dstW, sizeof(*filter) * filterSize, fail); + FF_ALLOC_ARRAY_OR_GOTO(filter, + dstW, sizeof(*filter) * filterSize, ret, goto fail); xDstInSrc = ((dstPos*(int64_t)xInc)>>7) - ((srcPos*0x10000LL)>>7); for (i = 0; i < dstW; i++) { @@ -525,7 +525,7 @@ static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, if (dstFilter) filter2Size += dstFilter->length - 1; av_assert0(filter2Size > 0); - FF_ALLOCZ_ARRAY_OR_GOTO(NULL, filter2, dstW, filter2Size * sizeof(*filter2), fail); + FF_ALLOCZ_ARRAY_OR_GOTO(filter2, dstW, filter2Size * sizeof(*filter2), ret, goto fail); for (i = 0; i < dstW; i++) { int j, k; @@ -684,8 +684,8 @@ static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, // Note the +1 is for the MMX scaler which reads over the end /* align at 16 for AltiVec (needed by hScale_altivec_real) */ - FF_ALLOCZ_ARRAY_OR_GOTO(NULL, *outFilter, - (dstW + 3), *outFilterSize * sizeof(int16_t), fail); + FF_ALLOCZ_ARRAY_OR_GOTO(*outFilter, + (dstW + 3), *outFilterSize * sizeof(int16_t), ret, goto fail); /* normalize & store in outFilter */ for (i = 0; i < dstW; i++) { @@ -1415,7 +1415,7 @@ av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter, c->chrDstW = AV_CEIL_RSHIFT(dstW, c->chrDstHSubSample); c->chrDstH = AV_CEIL_RSHIFT(dstH, c->chrDstVSubSample); - FF_ALLOCZ_OR_GOTO(c, c->formatConvBuffer, FFALIGN(srcW*2+78, 16) * 2, fail); + FF_ALLOCZ_OR_GOTO(c->formatConvBuffer, FFALIGN(srcW*2+78, 16) * 2, ret, goto fail); c->srcBpc = desc_src->comp[0].depth; if (c->srcBpc < 8) @@ -1655,10 +1655,10 @@ av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter, return AVERROR(ENOMEM); } - FF_ALLOCZ_OR_GOTO(c, c->hLumFilter, (dstW / 8 + 8) * sizeof(int16_t), fail); - FF_ALLOCZ_OR_GOTO(c, c->hChrFilter, (c->chrDstW / 4 + 8) * sizeof(int16_t), fail); - FF_ALLOCZ_OR_GOTO(c, c->hLumFilterPos, (dstW / 2 / 8 + 8) * sizeof(int32_t), fail); - FF_ALLOCZ_OR_GOTO(c, c->hChrFilterPos, (c->chrDstW / 2 / 4 + 8) * sizeof(int32_t), fail); + FF_ALLOCZ_OR_GOTO(c->hLumFilter, (dstW / 8 + 8) * sizeof(int16_t), ret, goto fail); + FF_ALLOCZ_OR_GOTO(c->hChrFilter, (c->chrDstW / 4 + 8) * sizeof(int16_t), ret, goto fail); + FF_ALLOCZ_OR_GOTO(c->hLumFilterPos, (dstW / 2 / 8 + 8) * sizeof(int32_t), ret, goto fail); + FF_ALLOCZ_OR_GOTO(c->hChrFilterPos, (c->chrDstW / 2 / 4 + 8) * sizeof(int32_t), ret, goto fail); ff_init_hscaler_mmxext( dstW, c->lumXInc, c->lumMmxextFilterCode, c->hLumFilter, (uint32_t*)c->hLumFilterPos, 8); @@ -1726,8 +1726,8 @@ av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter, goto fail; #if HAVE_ALTIVEC - FF_ALLOC_OR_GOTO(c, c->vYCoeffsBank, sizeof(vector signed short) * c->vLumFilterSize * c->dstH, fail); - FF_ALLOC_OR_GOTO(c, c->vCCoeffsBank, sizeof(vector signed short) * c->vChrFilterSize * c->chrDstH, fail); + FF_ALLOC_OR_GOTO(c->vYCoeffsBank, sizeof(vector signed short) * c->vLumFilterSize * c->dstH, ret, goto fail); + FF_ALLOC_OR_GOTO(c->vCCoeffsBank, sizeof(vector signed short) * c->vChrFilterSize * c->chrDstH, ret, goto fail); for (i = 0; i < c->vLumFilterSize * c->dstH; i++) { int j; @@ -1746,7 +1746,7 @@ av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter, } for (i = 0; i < 4; i++) - FF_ALLOCZ_OR_GOTO(c, c->dither_error[i], (c->dstW+2) * sizeof(int), fail); + FF_ALLOCZ_OR_GOTO(c->dither_error[i], (c->dstW+2) * sizeof(int), ret, goto fail); c->needAlpha = (CONFIG_SWSCALE_ALPHA && isALPHA(c->srcFormat) && isALPHA(c->dstFormat)) ? 1 : 0;