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

lavc: remove disabled FF_API_OLD_ENCODE_AUDIO cruft

Browse Source
pull/12/merge
Anton Khirnov 12 years ago
parent 5d606863c3
commit f073b1500e
28 changed files with 0 additions and 375 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 8
      libavcodec/aacenc.c
  2. 11
      libavcodec/ac3enc.c
  3. 8
      libavcodec/adpcmenc.c
  4. 16
      libavcodec/adxenc.c
  5. 30
      libavcodec/avcodec.h
  6. 9
      libavcodec/flacenc.c
  7. 11
      libavcodec/g722enc.c
  8. 18
      libavcodec/g726.c
  9. 8
      libavcodec/internal.h
  10. 11
      libavcodec/libfaac.c
  11. 10
      libavcodec/libfdk-aacenc.c
  12. 11
      libavcodec/libgsm.c
  13. 14
      libavcodec/libilbc.c
  14. 11
      libavcodec/libmp3lame.c
  15. 8
      libavcodec/libopencore-amr.c
  16. 13
      libavcodec/libspeexenc.c
  17. 8
      libavcodec/libvo-aacenc.c
  18. 6
      libavcodec/libvo-amrwbenc.c
  19. 11
      libavcodec/libvorbis.c
  20. 15
      libavcodec/mpegaudioenc.c
  21. 11
      libavcodec/nellymoserenc.c
  22. 11
      libavcodec/ra144enc.c
  23. 11
      libavcodec/roqaudioenc.c
  24. 81
      libavcodec/utils.c
  25. 3
      libavcodec/version.h
  26. 11
      libavcodec/vorbisenc.c
  27. 5
      libavcodec/wma.c
  28. 5
      libavcodec/wmaenc.c

8
libavcodec/aacenc.c
Unescape View File

@ -683,9 +683,6 @@ static av_cold int aac_encode_end(AVCodecContext *avctx)
av_freep(&s->buffer.samples); av_freep(&s->buffer.samples);
av_freep(&s->cpe); av_freep(&s->cpe);
ff_af_queue_close(&s->afq); ff_af_queue_close(&s->afq);
#if FF_API_OLD_ENCODE_AUDIO
av_freep(&avctx->coded_frame);
#endif
return 0; return 0;
} }
@ -719,11 +716,6 @@ static av_cold int alloc_buffers(AVCodecContext *avctx, AACEncContext *s)
for(ch = 0; ch < s->channels; ch++) for(ch = 0; ch < s->channels; ch++)
s->planar_samples[ch] = s->buffer.samples + 3 * 1024 * ch; s->planar_samples[ch] = s->buffer.samples + 3 * 1024 * ch;
#if FF_API_OLD_ENCODE_AUDIO
if (!(avctx->coded_frame = avcodec_alloc_frame()))
goto alloc_fail;
#endif
return 0; return 0;
alloc_fail: alloc_fail:
return AVERROR(ENOMEM); return AVERROR(ENOMEM);

11
libavcodec/ac3enc.c
Unescape View File

@ -2052,9 +2052,6 @@ av_cold int ff_ac3_encode_close(AVCodecContext *avctx)
s->mdct_end(s); s->mdct_end(s);
#if FF_API_OLD_ENCODE_AUDIO
av_freep(&avctx->coded_frame);
#endif
return 0; return 0;
} }
@ -2484,14 +2481,6 @@ av_cold int ff_ac3_encode_init(AVCodecContext *avctx)
if (ret) if (ret)
goto init_fail; goto init_fail;
#if FF_API_OLD_ENCODE_AUDIO
avctx->coded_frame= avcodec_alloc_frame();
if (!avctx->coded_frame) {
ret = AVERROR(ENOMEM);
goto init_fail;
}
#endif
ff_dsputil_init(&s->dsp, avctx); ff_dsputil_init(&s->dsp, avctx);
avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT); avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT); ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);

8
libavcodec/adpcmenc.c
Unescape View File

@ -142,11 +142,6 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx)
goto error; goto error;
} }
#if FF_API_OLD_ENCODE_AUDIO
if (!(avctx->coded_frame = avcodec_alloc_frame()))
goto error;
#endif
return 0; return 0;
error: error:
av_freep(&s->paths); av_freep(&s->paths);
@ -159,9 +154,6 @@ error:
static av_cold int adpcm_encode_close(AVCodecContext *avctx) static av_cold int adpcm_encode_close(AVCodecContext *avctx)
{ {
ADPCMEncodeContext *s = avctx->priv_data; ADPCMEncodeContext *s = avctx->priv_data;
#if FF_API_OLD_ENCODE_AUDIO
av_freep(&avctx->coded_frame);
#endif
av_freep(&s->paths); av_freep(&s->paths);
av_freep(&s->node_buf); av_freep(&s->node_buf);
av_freep(&s->nodep_buf); av_freep(&s->nodep_buf);

16
libavcodec/adxenc.c
Unescape View File

@ -107,14 +107,6 @@ static int adx_encode_header(AVCodecContext *avctx, uint8_t *buf, int bufsize)
return HEADER_SIZE; return HEADER_SIZE;
} }
#if FF_API_OLD_ENCODE_AUDIO
static av_cold int adx_encode_close(AVCodecContext *avctx)
{
av_freep(&avctx->coded_frame);
return 0;
}
#endif
static av_cold int adx_encode_init(AVCodecContext *avctx) static av_cold int adx_encode_init(AVCodecContext *avctx)
{ {
ADXContext *c = avctx->priv_data; ADXContext *c = avctx->priv_data;
@ -125,11 +117,6 @@ static av_cold int adx_encode_init(AVCodecContext *avctx)
} }
avctx->frame_size = BLOCK_SAMPLES; avctx->frame_size = BLOCK_SAMPLES;
#if FF_API_OLD_ENCODE_AUDIO
if (!(avctx->coded_frame = avcodec_alloc_frame()))
return AVERROR(ENOMEM);
#endif
/* the cutoff can be adjusted, but this seems to work pretty well */ /* the cutoff can be adjusted, but this seems to work pretty well */
c->cutoff = 500; c->cutoff = 500;
ff_adx_calculate_coeffs(c->cutoff, avctx->sample_rate, COEFF_BITS, c->coeff); ff_adx_calculate_coeffs(c->cutoff, avctx->sample_rate, COEFF_BITS, c->coeff);
@ -177,9 +164,6 @@ AVCodec ff_adpcm_adx_encoder = {
.id = AV_CODEC_ID_ADPCM_ADX, .id = AV_CODEC_ID_ADPCM_ADX,
.priv_data_size = sizeof(ADXContext), .priv_data_size = sizeof(ADXContext),
.init = adx_encode_init, .init = adx_encode_init,
#if FF_API_OLD_ENCODE_AUDIO
.close = adx_encode_close,
#endif
.encode2 = adx_encode_frame, .encode2 = adx_encode_frame,
.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16, .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
AV_SAMPLE_FMT_NONE }, AV_SAMPLE_FMT_NONE },

30
libavcodec/avcodec.h
Unescape View File

@ -3685,36 +3685,6 @@ AVCodec *avcodec_find_encoder(enum AVCodecID id);
*/ */
AVCodec *avcodec_find_encoder_by_name(const char *name); AVCodec *avcodec_find_encoder_by_name(const char *name);
#if FF_API_OLD_ENCODE_AUDIO
/**
* Encode an audio frame from samples into buf.
*
* @deprecated Use avcodec_encode_audio2 instead.
*
* @note The output buffer should be at least FF_MIN_BUFFER_SIZE bytes large.
* However, for codecs with avctx->frame_size equal to 0 (e.g. PCM) the user
* will know how much space is needed because it depends on the value passed
* in buf_size as described below. In that case a lower value can be used.
*
* @param avctx the codec context
* @param[out] buf the output buffer
* @param[in] buf_size the output buffer size
* @param[in] samples the input buffer containing the samples
* The number of samples read from this buffer is frame_size*channels,
* both of which are defined in avctx.
* For codecs which have avctx->frame_size equal to 0 (e.g. PCM) the number of
* samples read from samples is equal to:
* buf_size * 8 / (avctx->channels * av_get_bits_per_sample(avctx->codec_id))
* This also implies that av_get_bits_per_sample() must not return 0 for these
* codecs.
* @return On error a negative value is returned, on success zero or the number
* of bytes used to encode the data read from the input buffer.
*/
int attribute_deprecated avcodec_encode_audio(AVCodecContext *avctx,
uint8_t *buf, int buf_size,
const short *samples);
#endif
/** /**
* Encode a frame of audio. * Encode a frame of audio.
* *

9
libavcodec/flacenc.c
Unescape View File

@ -394,12 +394,6 @@ static av_cold int flac_encode_init(AVCodecContext *avctx)
s->frame_count = 0; s->frame_count = 0;
s->min_framesize = s->max_framesize; s->min_framesize = s->max_framesize;
#if FF_API_OLD_ENCODE_AUDIO
avctx->coded_frame = avcodec_alloc_frame();
if (!avctx->coded_frame)
return AVERROR(ENOMEM);
#endif
ret = ff_lpc_init(&s->lpc_ctx, avctx->frame_size, ret = ff_lpc_init(&s->lpc_ctx, avctx->frame_size,
s->options.max_prediction_order, FF_LPC_TYPE_LEVINSON); s->options.max_prediction_order, FF_LPC_TYPE_LEVINSON);
@ -1285,9 +1279,6 @@ static av_cold int flac_encode_close(AVCodecContext *avctx)
} }
av_freep(&avctx->extradata); av_freep(&avctx->extradata);
avctx->extradata_size = 0; avctx->extradata_size = 0;
#if FF_API_OLD_ENCODE_AUDIO
av_freep(&avctx->coded_frame);
#endif
return 0; return 0;
} }

11
libavcodec/g722enc.c
Unescape View File

@ -52,9 +52,6 @@ static av_cold int g722_encode_close(AVCodecContext *avctx)
av_freep(&c->node_buf[i]); av_freep(&c->node_buf[i]);
av_freep(&c->nodep_buf[i]); av_freep(&c->nodep_buf[i]);
} }
#if FF_API_OLD_ENCODE_AUDIO
av_freep(&avctx->coded_frame);
#endif
return 0; return 0;
} }
@ -122,14 +119,6 @@ static av_cold int g722_encode_init(AVCodecContext * avctx)
} }
} }
#if FF_API_OLD_ENCODE_AUDIO
avctx->coded_frame = avcodec_alloc_frame();
if (!avctx->coded_frame) {
ret = AVERROR(ENOMEM);
goto error;
}
#endif
return 0; return 0;
error: error:
g722_encode_close(avctx); g722_encode_close(avctx);

18
libavcodec/g726.c
Unescape View File

@ -331,13 +331,6 @@ static av_cold int g726_encode_init(AVCodecContext *avctx)
g726_reset(c); g726_reset(c);
#if FF_API_OLD_ENCODE_AUDIO
avctx->coded_frame = avcodec_alloc_frame();
if (!avctx->coded_frame)
return AVERROR(ENOMEM);
avctx->coded_frame->key_frame = 1;
#endif
/* select a frame size that will end on a byte boundary and have a size of /* select a frame size that will end on a byte boundary and have a size of
approximately 1024 bytes */ approximately 1024 bytes */
avctx->frame_size = ((int[]){ 4096, 2736, 2048, 1640 })[c->code_size - 2]; avctx->frame_size = ((int[]){ 4096, 2736, 2048, 1640 })[c->code_size - 2];
@ -345,14 +338,6 @@ static av_cold int g726_encode_init(AVCodecContext *avctx)
return 0; return 0;
} }
#if FF_API_OLD_ENCODE_AUDIO
static av_cold int g726_encode_close(AVCodecContext *avctx)
{
av_freep(&avctx->coded_frame);
return 0;
}
#endif
static int g726_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, static int g726_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
const AVFrame *frame, int *got_packet_ptr) const AVFrame *frame, int *got_packet_ptr)
{ {
@ -404,9 +389,6 @@ AVCodec ff_adpcm_g726_encoder = {
.priv_data_size = sizeof(G726Context), .priv_data_size = sizeof(G726Context),
.init = g726_encode_init, .init = g726_encode_init,
.encode2 = g726_encode_frame, .encode2 = g726_encode_frame,
#if FF_API_OLD_ENCODE_AUDIO
.close = g726_encode_close,
#endif
.capabilities = CODEC_CAP_SMALL_LAST_FRAME, .capabilities = CODEC_CAP_SMALL_LAST_FRAME,
.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16, .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
AV_SAMPLE_FMT_NONE }, AV_SAMPLE_FMT_NONE },

8
libavcodec/internal.h
Unescape View File

@ -76,14 +76,6 @@ typedef struct AVCodecInternal {
*/ */
int allocate_progress; int allocate_progress;
#if FF_API_OLD_ENCODE_AUDIO
/**
* Internal sample count used by avcodec_encode_audio() to fabricate pts.
* Can be removed along with avcodec_encode_audio().
*/
int sample_count;
#endif
/** /**
* An audio frame with less than required samples has been submitted and * An audio frame with less than required samples has been submitted and
* padded with silence. Reject all subsequent frames. * padded with silence. Reject all subsequent frames.

11
libavcodec/libfaac.c
Unescape View File

@ -46,9 +46,6 @@ static av_cold int Faac_encode_close(AVCodecContext *avctx)
{ {
FaacAudioContext *s = avctx->priv_data; FaacAudioContext *s = avctx->priv_data;
#if FF_API_OLD_ENCODE_AUDIO
av_freep(&avctx->coded_frame);
#endif
av_freep(&avctx->extradata); av_freep(&avctx->extradata);
ff_af_queue_close(&s->afq); ff_af_queue_close(&s->afq);
@ -133,14 +130,6 @@ static av_cold int Faac_encode_init(AVCodecContext *avctx)
avctx->frame_size = samples_input / avctx->channels; avctx->frame_size = samples_input / avctx->channels;
#if FF_API_OLD_ENCODE_AUDIO
avctx->coded_frame= avcodec_alloc_frame();
if (!avctx->coded_frame) {
ret = AVERROR(ENOMEM);
goto error;
}
#endif
/* Set decoder specific info */ /* Set decoder specific info */
avctx->extradata_size = 0; avctx->extradata_size = 0;
if (avctx->flags & CODEC_FLAG_GLOBAL_HEADER) { if (avctx->flags & CODEC_FLAG_GLOBAL_HEADER) {

10
libavcodec/libfdk-aacenc.c
Unescape View File

@ -97,9 +97,6 @@ static int aac_encode_close(AVCodecContext *avctx)
if (s->handle) if (s->handle)
aacEncClose(&s->handle); aacEncClose(&s->handle);
#if FF_API_OLD_ENCODE_AUDIO
av_freep(&avctx->coded_frame);
#endif
av_freep(&avctx->extradata); av_freep(&avctx->extradata);
ff_af_queue_close(&s->afq); ff_af_queue_close(&s->afq);
@ -275,13 +272,6 @@ static av_cold int aac_encode_init(AVCodecContext *avctx)
goto error; goto error;
} }
#if FF_API_OLD_ENCODE_AUDIO
avctx->coded_frame = avcodec_alloc_frame();
if (!avctx->coded_frame) {
ret = AVERROR(ENOMEM);
goto error;
}
#endif
avctx->frame_size = info.frameLength; avctx->frame_size = info.frameLength;
avctx->delay = info.encoderDelay; avctx->delay = info.encoderDelay;
ff_af_queue_init(avctx, &s->afq); ff_af_queue_init(avctx, &s->afq);

11
libavcodec/libgsm.c
Unescape View File

@ -77,21 +77,10 @@ static av_cold int libgsm_encode_init(AVCodecContext *avctx) {
} }
} }
#if FF_API_OLD_ENCODE_AUDIO
avctx->coded_frame= avcodec_alloc_frame();
if (!avctx->coded_frame) {
gsm_destroy(avctx->priv_data);
return AVERROR(ENOMEM);
}
#endif
return 0; return 0;
} }
static av_cold int libgsm_encode_close(AVCodecContext *avctx) { static av_cold int libgsm_encode_close(AVCodecContext *avctx) {
#if FF_API_OLD_ENCODE_AUDIO
av_freep(&avctx->coded_frame);
#endif
gsm_destroy(avctx->priv_data); gsm_destroy(avctx->priv_data);
avctx->priv_data = NULL; avctx->priv_data = NULL;
return 0; return 0;

14
libavcodec/libilbc.c
Unescape View File

@ -153,23 +153,10 @@ static av_cold int ilbc_encode_init(AVCodecContext *avctx)
avctx->block_align = s->encoder.no_of_bytes; avctx->block_align = s->encoder.no_of_bytes;
avctx->frame_size = s->encoder.blockl; avctx->frame_size = s->encoder.blockl;
#if FF_API_OLD_ENCODE_AUDIO
avctx->coded_frame = avcodec_alloc_frame();
if (!avctx->coded_frame)
return AVERROR(ENOMEM);
#endif
return 0; return 0;
} }
static av_cold int ilbc_encode_close(AVCodecContext *avctx)
{
#if FF_API_OLD_ENCODE_AUDIO
av_freep(&avctx->coded_frame);
#endif
return 0;
}
static int ilbc_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, static int ilbc_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
const AVFrame *frame, int *got_packet_ptr) const AVFrame *frame, int *got_packet_ptr)
{ {
@ -200,7 +187,6 @@ AVCodec ff_libilbc_encoder = {
.priv_data_size = sizeof(ILBCEncContext), .priv_data_size = sizeof(ILBCEncContext),
.init = ilbc_encode_init, .init = ilbc_encode_init,
.encode2 = ilbc_encode_frame, .encode2 = ilbc_encode_frame,
.close = ilbc_encode_close,
.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16, .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
AV_SAMPLE_FMT_NONE }, AV_SAMPLE_FMT_NONE },
.long_name = NULL_IF_CONFIG_SMALL("iLBC (Internet Low Bitrate Codec)"), .long_name = NULL_IF_CONFIG_SMALL("iLBC (Internet Low Bitrate Codec)"),

11
libavcodec/libmp3lame.c
Unescape View File

@ -78,9 +78,6 @@ static av_cold int mp3lame_encode_close(AVCodecContext *avctx)
{ {
LAMEContext *s = avctx->priv_data; LAMEContext *s = avctx->priv_data;
#if FF_API_OLD_ENCODE_AUDIO
av_freep(&avctx->coded_frame);
#endif
av_freep(&s->samples_flt[0]); av_freep(&s->samples_flt[0]);
av_freep(&s->samples_flt[1]); av_freep(&s->samples_flt[1]);
av_freep(&s->buffer); av_freep(&s->buffer);
@ -142,14 +139,6 @@ static av_cold int mp3lame_encode_init(AVCodecContext *avctx)
avctx->frame_size = lame_get_framesize(s->gfp); avctx->frame_size = lame_get_framesize(s->gfp);
#if FF_API_OLD_ENCODE_AUDIO
avctx->coded_frame = avcodec_alloc_frame();
if (!avctx->coded_frame) {
ret = AVERROR(ENOMEM);
goto error;
}
#endif
/* allocate float sample buffers */ /* allocate float sample buffers */
if (avctx->sample_fmt == AV_SAMPLE_FMT_FLTP) { if (avctx->sample_fmt == AV_SAMPLE_FMT_FLTP) {
int ch; int ch;

8
libavcodec/libopencore-amr.c
Unescape View File

@ -202,11 +202,6 @@ static av_cold int amr_nb_encode_init(AVCodecContext *avctx)
avctx->frame_size = 160; avctx->frame_size = 160;
avctx->delay = 50; avctx->delay = 50;
ff_af_queue_init(avctx, &s->afq); ff_af_queue_init(avctx, &s->afq);
#if FF_API_OLD_ENCODE_AUDIO
avctx->coded_frame = avcodec_alloc_frame();
if (!avctx->coded_frame)
return AVERROR(ENOMEM);
#endif
s->enc_state = Encoder_Interface_init(s->enc_dtx); s->enc_state = Encoder_Interface_init(s->enc_dtx);
if (!s->enc_state) { if (!s->enc_state) {
@ -227,9 +222,6 @@ static av_cold int amr_nb_encode_close(AVCodecContext *avctx)
Encoder_Interface_exit(s->enc_state); Encoder_Interface_exit(s->enc_state);
ff_af_queue_close(&s->afq); ff_af_queue_close(&s->afq);
#if FF_API_OLD_ENCODE_AUDIO
av_freep(&avctx->coded_frame);
#endif
return 0; return 0;
} }

13
libavcodec/libspeexenc.c
Unescape View File

@ -251,16 +251,6 @@ static av_cold int encode_init(AVCodecContext *avctx)
av_log(avctx, AV_LOG_ERROR, "memory allocation error\n"); av_log(avctx, AV_LOG_ERROR, "memory allocation error\n");
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
#if FF_API_OLD_ENCODE_AUDIO
avctx->coded_frame = avcodec_alloc_frame();
if (!avctx->coded_frame) {
av_freep(&avctx->extradata);
speex_header_free(header_data);
speex_encoder_destroy(s->enc_state);
av_log(avctx, AV_LOG_ERROR, "memory allocation error\n");
return AVERROR(ENOMEM);
}
#endif
/* copy header packet to extradata */ /* copy header packet to extradata */
memcpy(avctx->extradata, header_data, header_size); memcpy(avctx->extradata, header_data, header_size);
@ -329,9 +319,6 @@ static av_cold int encode_close(AVCodecContext *avctx)
speex_encoder_destroy(s->enc_state); speex_encoder_destroy(s->enc_state);
ff_af_queue_close(&s->afq); ff_af_queue_close(&s->afq);
#if FF_API_OLD_ENCODE_AUDIO
av_freep(&avctx->coded_frame);
#endif
av_freep(&avctx->extradata); av_freep(&avctx->extradata);
return 0; return 0;

8
libavcodec/libvo-aacenc.c
Unescape View File

@ -47,9 +47,6 @@ static int aac_encode_close(AVCodecContext *avctx)
AACContext *s = avctx->priv_data; AACContext *s = avctx->priv_data;
s->codec_api.Uninit(s->handle); s->codec_api.Uninit(s->handle);
#if FF_API_OLD_ENCODE_AUDIO
av_freep(&avctx->coded_frame);
#endif
av_freep(&avctx->extradata); av_freep(&avctx->extradata);
ff_af_queue_close(&s->afq); ff_af_queue_close(&s->afq);
av_freep(&s->end_buffer); av_freep(&s->end_buffer);
@ -63,11 +60,6 @@ static av_cold int aac_encode_init(AVCodecContext *avctx)
AACENC_PARAM params = { 0 }; AACENC_PARAM params = { 0 };
int index, ret; int index, ret;
#if FF_API_OLD_ENCODE_AUDIO
avctx->coded_frame = avcodec_alloc_frame();
if (!avctx->coded_frame)
return AVERROR(ENOMEM);
#endif
avctx->frame_size = FRAME_SIZE; avctx->frame_size = FRAME_SIZE;
avctx->delay = ENC_DELAY; avctx->delay = ENC_DELAY;
s->last_frame = 2; s->last_frame = 2;

6
libavcodec/libvo-amrwbenc.c
Unescape View File

@ -94,11 +94,6 @@ static av_cold int amr_wb_encode_init(AVCodecContext *avctx)
avctx->frame_size = 320; avctx->frame_size = 320;
avctx->delay = 80; avctx->delay = 80;
#if FF_API_OLD_ENCODE_AUDIO
avctx->coded_frame = avcodec_alloc_frame();
if (!avctx->coded_frame)
return AVERROR(ENOMEM);
#endif
s->state = E_IF_init(); s->state = E_IF_init();
@ -110,7 +105,6 @@ static int amr_wb_encode_close(AVCodecContext *avctx)
AMRWBContext *s = avctx->priv_data; AMRWBContext *s = avctx->priv_data;
E_IF_exit(s->state); E_IF_exit(s->state);
av_freep(&avctx->coded_frame);
return 0; return 0;
} }

11
libavcodec/libvorbis.c
Unescape View File

@ -162,9 +162,6 @@ static av_cold int oggvorbis_encode_close(AVCodecContext *avctx)
av_fifo_free(s->pkt_fifo); av_fifo_free(s->pkt_fifo);
ff_af_queue_close(&s->afq); ff_af_queue_close(&s->afq);
#if FF_API_OLD_ENCODE_AUDIO
av_freep(&avctx->coded_frame);
#endif
av_freep(&avctx->extradata); av_freep(&avctx->extradata);
return 0; return 0;
@ -241,14 +238,6 @@ static av_cold int oggvorbis_encode_init(AVCodecContext *avctx)
goto error; goto error;
} }
#if FF_API_OLD_ENCODE_AUDIO
avctx->coded_frame = avcodec_alloc_frame();
if (!avctx->coded_frame) {
ret = AVERROR(ENOMEM);
goto error;
}
#endif
return 0; return 0;
error: error:
oggvorbis_encode_close(avctx); oggvorbis_encode_close(avctx);

15
libavcodec/mpegaudioenc.c
Unescape View File

@ -184,12 +184,6 @@ static av_cold int MPA_encode_init(AVCodecContext *avctx)
total_quant_bits[i] = 12 * v; total_quant_bits[i] = 12 * v;
} }
#if FF_API_OLD_ENCODE_AUDIO
avctx->coded_frame= avcodec_alloc_frame();
if (!avctx->coded_frame)
return AVERROR(ENOMEM);
#endif
return 0; return 0;
} }
@ -771,14 +765,6 @@ static int MPA_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
return 0; return 0;
} }
static av_cold int MPA_encode_close(AVCodecContext *avctx)
{
#if FF_API_OLD_ENCODE_AUDIO
av_freep(&avctx->coded_frame);
#endif
return 0;
}
static const AVCodecDefault mp2_defaults[] = { static const AVCodecDefault mp2_defaults[] = {
{ "b", "128k" }, { "b", "128k" },
{ NULL }, { NULL },
@ -791,7 +777,6 @@ AVCodec ff_mp2_encoder = {
.priv_data_size = sizeof(MpegAudioContext), .priv_data_size = sizeof(MpegAudioContext),
.init = MPA_encode_init, .init = MPA_encode_init,
.encode2 = MPA_encode_frame, .encode2 = MPA_encode_frame,
.close = MPA_encode_close,
.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16, .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
AV_SAMPLE_FMT_NONE }, AV_SAMPLE_FMT_NONE },
.supported_samplerates = (const int[]){ .supported_samplerates = (const int[]){

11
libavcodec/nellymoserenc.c
Unescape View File

@ -140,9 +140,6 @@ static av_cold int encode_end(AVCodecContext *avctx)
av_free(s->path); av_free(s->path);
} }
ff_af_queue_close(&s->afq); ff_af_queue_close(&s->afq);
#if FF_API_OLD_ENCODE_AUDIO
av_freep(&avctx->coded_frame);
#endif
return 0; return 0;
} }
@ -187,14 +184,6 @@ static av_cold int encode_init(AVCodecContext *avctx)
} }
} }
#if FF_API_OLD_ENCODE_AUDIO
avctx->coded_frame = avcodec_alloc_frame();
if (!avctx->coded_frame) {
ret = AVERROR(ENOMEM);
goto error;
}
#endif
return 0; return 0;
error: error:
encode_end(avctx); encode_end(avctx);

11
libavcodec/ra144enc.c
Unescape View File

@ -40,9 +40,6 @@ static av_cold int ra144_encode_close(AVCodecContext *avctx)
RA144Context *ractx = avctx->priv_data; RA144Context *ractx = avctx->priv_data;
ff_lpc_end(&ractx->lpc_ctx); ff_lpc_end(&ractx->lpc_ctx);
ff_af_queue_close(&ractx->afq); ff_af_queue_close(&ractx->afq);
#if FF_API_OLD_ENCODE_AUDIO
av_freep(&avctx->coded_frame);
#endif
return 0; return 0;
} }
@ -71,14 +68,6 @@ static av_cold int ra144_encode_init(AVCodecContext * avctx)
ff_af_queue_init(avctx, &ractx->afq); ff_af_queue_init(avctx, &ractx->afq);
#if FF_API_OLD_ENCODE_AUDIO
avctx->coded_frame = avcodec_alloc_frame();
if (!avctx->coded_frame) {
ret = AVERROR(ENOMEM);
goto error;
}
#endif
return 0; return 0;
error: error:
ra144_encode_close(avctx); ra144_encode_close(avctx);

11
libavcodec/roqaudioenc.c
Unescape View File

@ -46,9 +46,6 @@ static av_cold int roq_dpcm_encode_close(AVCodecContext *avctx)
{ {
ROQDPCMContext *context = avctx->priv_data; ROQDPCMContext *context = avctx->priv_data;
#if FF_API_OLD_ENCODE_AUDIO
av_freep(&avctx->coded_frame);
#endif
av_freep(&context->frame_buffer); av_freep(&context->frame_buffer);
return 0; return 0;
@ -81,14 +78,6 @@ static av_cold int roq_dpcm_encode_init(AVCodecContext *avctx)
context->lastSample[0] = context->lastSample[1] = 0; context->lastSample[0] = context->lastSample[1] = 0;
#if FF_API_OLD_ENCODE_AUDIO
avctx->coded_frame= avcodec_alloc_frame();
if (!avctx->coded_frame) {
ret = AVERROR(ENOMEM);
goto error;
}
#endif
return 0; return 0;
error: error:
roq_dpcm_encode_close(avctx); roq_dpcm_encode_close(avctx);

81
libavcodec/utils.c
Unescape View File

@ -1245,87 +1245,6 @@ end:
return ret; return ret;
} }
#if FF_API_OLD_ENCODE_AUDIO
int attribute_align_arg avcodec_encode_audio(AVCodecContext *avctx,
uint8_t *buf, int buf_size,
const short *samples)
{
AVPacket pkt;
AVFrame frame0 = { { 0 } };
AVFrame *frame;
int ret, samples_size, got_packet;
av_init_packet(&pkt);
pkt.data = buf;
pkt.size = buf_size;
if (samples) {
frame = &frame0;
avcodec_get_frame_defaults(frame);
if (avctx->frame_size) {
frame->nb_samples = avctx->frame_size;
} else {
/* if frame_size is not set, the number of samples must be
* calculated from the buffer size */
int64_t nb_samples;
if (!av_get_bits_per_sample(avctx->codec_id)) {
av_log(avctx, AV_LOG_ERROR, "avcodec_encode_audio() does not "
"support this codec\n");
return AVERROR(EINVAL);
}
nb_samples = (int64_t)buf_size * 8 /
(av_get_bits_per_sample(avctx->codec_id) *
avctx->channels);
if (nb_samples >= INT_MAX)
return AVERROR(EINVAL);
frame->nb_samples = nb_samples;
}
/* it is assumed that the samples buffer is large enough based on the
* relevant parameters */
samples_size = av_samples_get_buffer_size(NULL, avctx->channels,
frame->nb_samples,
avctx->sample_fmt, 1);
if ((ret = avcodec_fill_audio_frame(frame, avctx->channels,
avctx->sample_fmt,
(const uint8_t *)samples,
samples_size, 1)))
return ret;
/* fabricate frame pts from sample count.
* this is needed because the avcodec_encode_audio() API does not have
* a way for the user to provide pts */
frame->pts = ff_samples_to_time_base(avctx,
avctx->internal->sample_count);
avctx->internal->sample_count += frame->nb_samples;
} else {
frame = NULL;
}
got_packet = 0;
ret = avcodec_encode_audio2(avctx, &pkt, frame, &got_packet);
if (!ret && got_packet && avctx->coded_frame) {
avctx->coded_frame->pts = pkt.pts;
avctx->coded_frame->key_frame = !!(pkt.flags & AV_PKT_FLAG_KEY);
}
/* free any side data since we cannot return it */
if (pkt.side_data_elems > 0) {
int i;
for (i = 0; i < pkt.side_data_elems; i++)
av_free(pkt.side_data[i].data);
av_freep(&pkt.side_data);
pkt.side_data_elems = 0;
}
if (frame && frame->extended_data != frame->data)
av_free(frame->extended_data);
return ret ? ret : pkt.size;
}
#endif
#if FF_API_OLD_ENCODE_VIDEO #if FF_API_OLD_ENCODE_VIDEO
int attribute_align_arg avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size, int attribute_align_arg avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size,
const AVFrame *pict) const AVFrame *pict)

3
libavcodec/version.h
Unescape View File

@ -49,9 +49,6 @@
#ifndef FF_API_REQUEST_CHANNELS #ifndef FF_API_REQUEST_CHANNELS
#define FF_API_REQUEST_CHANNELS (LIBAVCODEC_VERSION_MAJOR < 56) #define FF_API_REQUEST_CHANNELS (LIBAVCODEC_VERSION_MAJOR < 56)
#endif #endif
#ifndef FF_API_OLD_ENCODE_AUDIO
#define FF_API_OLD_ENCODE_AUDIO (LIBAVCODEC_VERSION_MAJOR < 55)
#endif
#ifndef FF_API_OLD_ENCODE_VIDEO #ifndef FF_API_OLD_ENCODE_VIDEO
#define FF_API_OLD_ENCODE_VIDEO (LIBAVCODEC_VERSION_MAJOR < 55) #define FF_API_OLD_ENCODE_VIDEO (LIBAVCODEC_VERSION_MAJOR < 55)
#endif #endif

11
libavcodec/vorbisenc.c
Unescape View File

@ -1156,9 +1156,6 @@ static av_cold int vorbis_encode_close(AVCodecContext *avctx)
ff_mdct_end(&venc->mdct[0]); ff_mdct_end(&venc->mdct[0]);
ff_mdct_end(&venc->mdct[1]); ff_mdct_end(&venc->mdct[1]);
#if FF_API_OLD_ENCODE_AUDIO
av_freep(&avctx->coded_frame);
#endif
av_freep(&avctx->extradata); av_freep(&avctx->extradata);
return 0 ; return 0 ;
@ -1190,14 +1187,6 @@ static av_cold int vorbis_encode_init(AVCodecContext *avctx)
avctx->frame_size = 1 << (venc->log2_blocksize[0] - 1); avctx->frame_size = 1 << (venc->log2_blocksize[0] - 1);
#if FF_API_OLD_ENCODE_AUDIO
avctx->coded_frame = avcodec_alloc_frame();
if (!avctx->coded_frame) {
ret = AVERROR(ENOMEM);
goto error;
}
#endif
return 0; return 0;
error: error:
vorbis_encode_close(avctx); vorbis_encode_close(avctx);

5
libavcodec/wma.c
Unescape View File

@ -386,11 +386,6 @@ int ff_wma_end(AVCodecContext *avctx)
av_free(s->int_table[i]); av_free(s->int_table[i]);
} }
#if FF_API_OLD_ENCODE_AUDIO
if (av_codec_is_encoder(avctx->codec))
av_freep(&avctx->coded_frame);
#endif
return 0; return 0;
} }

5
libavcodec/wmaenc.c
Unescape View File

@ -52,11 +52,6 @@ static int encode_init(AVCodecContext * avctx){
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
#if FF_API_OLD_ENCODE_AUDIO
if (!(avctx->coded_frame = avcodec_alloc_frame()))
return AVERROR(ENOMEM);
#endif
/* extract flag infos */ /* extract flag infos */
flags1 = 0; flags1 = 0;
flags2 = 1; flags2 = 1;

Write Preview
Loading…
Cancel
Save