@@ -1732,7 +1732,7 @@ static int transcode_init(void)

             av_assert0(ist && !ost->filter);

-            extra_size = (uint64_t)dec_ctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;

+            extra_size = (uint64_t)dec_ctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE;

             if (extra_size > INT_MAX) {

                 return AVERROR(EINVAL);

@@ -226,7 +226,7 @@ static void audio_decode_example(const char *outfilename, const char *filename)

     AVCodecContext *c= NULL;

     int len;

     FILE *f, *outfile;

-    uint8_t inbuf[AUDIO_INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];

+    uint8_t inbuf[AUDIO_INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];

     AVPacket avpkt;

     AVFrame *decoded_frame = NULL;

@@ -459,14 +459,14 @@ static void video_decode_example(const char *outfilename, const char *filename)

     int frame, got_picture, len;

     FILE *f;

     AVFrame *picture;

-    uint8_t inbuf[INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];

+    uint8_t inbuf[INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];

     char buf[1024];

     AVPacket avpkt;

     av_init_packet(&avpkt);

     /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */

-    memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);

+    memset(inbuf + INBUF_SIZE, 0, AV_INPUT_BUFFER_PADDING_SIZE);

     printf("Video decoding\n");

@@ -405,7 +405,7 @@ int main(int argc, char **argv)

     decoder_ctx->codec_id = AV_CODEC_ID_H264;

     if (video_st->codec->extradata_size) {

         decoder_ctx->extradata = av_mallocz(video_st->codec->extradata_size +

-                                            FF_INPUT_BUFFER_PADDING_SIZE);

+                                            AV_INPUT_BUFFER_PADDING_SIZE);

         if (!decoder_ctx->extradata) {

             ret = AVERROR(ENOMEM);

             goto finish;

@@ -446,13 +446,13 @@ static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)

     }

     av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,

-                   bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);

+                   bitstream_size + AV_INPUT_BUFFER_PADDING_SIZE);

     if (!f->bitstream_buffer)

         return AVERROR(ENOMEM);

     f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) (buf + extra),

                        bitstream_size / 4);

     memset((uint8_t*)f->bitstream_buffer + bitstream_size,

-           0, FF_INPUT_BUFFER_PADDING_SIZE);

+           0, AV_INPUT_BUFFER_PADDING_SIZE);

     init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);

     wordstream_offset = extra + bitstream_size;

@@ -769,13 +769,13 @@ static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)

     prestream_size = length + buf - prestream;

     av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,

-                   prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);

+                   prestream_size + AV_INPUT_BUFFER_PADDING_SIZE);

     if (!f->bitstream_buffer)

         return AVERROR(ENOMEM);

     f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) prestream,

                        prestream_size / 4);

     memset((uint8_t*)f->bitstream_buffer + prestream_size,

-           0, FF_INPUT_BUFFER_PADDING_SIZE);

+           0, AV_INPUT_BUFFER_PADDING_SIZE);

     init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);

     f->last_dc = 0 * 128 * 8 * 8;

@@ -849,7 +849,7 @@ static int decode_frame(AVCodecContext *avctx, void *data,

         cfrm = &f->cfrm[i];

         cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,

-                                     cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);

+                                     cfrm->size + data_size + AV_INPUT_BUFFER_PADDING_SIZE);

         // explicit check needed as memcpy below might not catch a NULL

         if (!cfrm->data) {

             av_log(f->avctx, AV_LOG_ERROR, "realloc failure");

@@ -209,7 +209,7 @@ static av_cold int a64multi_encode_init(AVCodecContext *avctx)

     }

     /* set up extradata */

-    if (!(avctx->extradata = av_mallocz(8 * 4 + FF_INPUT_BUFFER_PADDING_SIZE))) {

+    if (!(avctx->extradata = av_mallocz(8 * 4 + AV_INPUT_BUFFER_PADDING_SIZE))) {

         av_log(avctx, AV_LOG_ERROR, "Failed to allocate memory for extradata.\n");

         return AVERROR(ENOMEM);

     }

@@ -88,7 +88,7 @@ static int aac_adtstoasc_filter(AVBitStreamFilterContext *bsfc,

             buf      += get_bits_count(&gb)/8;

         }

         avctx->extradata_size = 2 + pce_size;

-        avctx->extradata = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);

+        avctx->extradata = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);

         if (!avctx->extradata)

             return AVERROR(ENOMEM);

@@ -34,7 +34,7 @@ static int aac_sync(uint64_t state, AACAC3ParseContext *hdr_info,

     int size;

     union {

         uint64_t u64;

-        uint8_t  u8[8 + FF_INPUT_BUFFER_PADDING_SIZE];

+        uint8_t  u8[8 + AV_INPUT_BUFFER_PADDING_SIZE];

     } tmp;

     tmp.u64 = av_be2ne64(state);

@@ -2969,7 +2969,7 @@ static int aac_decode_frame(AVCodecContext *avctx, void *data,

     if (new_extradata) {

         av_free(avctx->extradata);

         avctx->extradata = av_mallocz(new_extradata_size +

-                                      FF_INPUT_BUFFER_PADDING_SIZE);

+                                      AV_INPUT_BUFFER_PADDING_SIZE);

         if (!avctx->extradata)

             return AVERROR(ENOMEM);

         avctx->extradata_size = new_extradata_size;

@@ -3089,14 +3089,14 @@ static int latm_decode_audio_specific_config(struct LATMContext *latmctx,

         if (avctx->extradata_size < esize) {

             av_free(avctx->extradata);

-            avctx->extradata = av_malloc(esize + FF_INPUT_BUFFER_PADDING_SIZE);

+            avctx->extradata = av_malloc(esize + AV_INPUT_BUFFER_PADDING_SIZE);

             if (!avctx->extradata)

                 return AVERROR(ENOMEM);

         }

         avctx->extradata_size = esize;

         memcpy(avctx->extradata, gb->buffer + (config_start_bit/8), esize);

-        memset(avctx->extradata+esize, 0, FF_INPUT_BUFFER_PADDING_SIZE);

+        memset(avctx->extradata+esize, 0, AV_INPUT_BUFFER_PADDING_SIZE);

     }

     skip_bits_long(gb, bits_consumed);

@@ -711,7 +711,7 @@ static av_cold int alloc_buffers(AVCodecContext *avctx, AACEncContext *s)

     int ch;

     FF_ALLOCZ_OR_GOTO(avctx, s->buffer.samples, 3 * 1024 * s->channels * sizeof(s->buffer.samples[0]), alloc_fail);

     FF_ALLOCZ_OR_GOTO(avctx, s->cpe, sizeof(ChannelElement) * s->chan_map[0], alloc_fail);

-    FF_ALLOCZ_OR_GOTO(avctx, avctx->extradata, 5 + FF_INPUT_BUFFER_PADDING_SIZE, alloc_fail);

+    FF_ALLOCZ_OR_GOTO(avctx, avctx->extradata, 5 + AV_INPUT_BUFFER_PADDING_SIZE, alloc_fail);

     for(ch = 0; ch < s->channels; ch++)

         s->planar_samples[ch] = s->buffer.samples + 3 * 1024 * ch;

@@ -150,7 +150,7 @@ static int ac3_sync(uint64_t state, AACAC3ParseContext *hdr_info,

     int err;

     union {

         uint64_t u64;

-        uint8_t  u8[8 + FF_INPUT_BUFFER_PADDING_SIZE];

+        uint8_t  u8[8 + AV_INPUT_BUFFER_PADDING_SIZE];

     } tmp = { av_be2ne64(state) };

     AC3HeaderInfo hdr;

     GetBitContext gbc;

@@ -217,7 +217,7 @@ typedef struct AC3DecodeContext {

     DECLARE_ALIGNED(32, float, window)[AC3_BLOCK_SIZE];                              ///< window coefficients

     DECLARE_ALIGNED(32, float, tmp_output)[AC3_BLOCK_SIZE];                          ///< temporary storage for output before windowing

     DECLARE_ALIGNED(32, float, output)[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE];            ///< output after imdct transform and windowing

-    DECLARE_ALIGNED(32, uint8_t, input_buffer)[AC3_FRAME_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE]; ///< temp buffer to prevent overread

+    DECLARE_ALIGNED(32, uint8_t, input_buffer)[AC3_FRAME_BUFFER_SIZE + AV_INPUT_BUFFER_PADDING_SIZE]; ///< temp buffer to prevent overread

 ///@}

 } AC3DecodeContext;

@@ -111,7 +111,7 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx)

         avctx->frame_size = (BLKSIZE - 7 * avctx->channels) * 2 /

                              avctx->channels + 2;

         avctx->block_align    = BLKSIZE;

-        if (!(avctx->extradata = av_malloc(32 + FF_INPUT_BUFFER_PADDING_SIZE)))

+        if (!(avctx->extradata = av_malloc(32 + AV_INPUT_BUFFER_PADDING_SIZE)))

             goto error;

         avctx->extradata_size = 32;

         extradata = avctx->extradata;

@@ -519,7 +519,7 @@ static av_cold int alac_encode_init(AVCodecContext *avctx)

                                                  avctx->channels,

                                                  avctx->bits_per_raw_sample);

-    avctx->extradata = av_mallocz(ALAC_EXTRADATA_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);

+    avctx->extradata = av_mallocz(ALAC_EXTRADATA_SIZE + AV_INPUT_BUFFER_PADDING_SIZE);

     if (!avctx->extradata) {

         ret = AVERROR(ENOMEM);

         goto error;

@@ -223,7 +223,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,

     if (!pkt->data &&

         (ret = av_new_packet(pkt, a->mb_height * a->mb_width * MAX_MB_SIZE +

-                             FF_MIN_BUFFER_SIZE)) < 0) {

+                             AV_INPUT_BUFFER_MIN_SIZE)) < 0) {

         av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");

         return ret;

     }

@@ -879,7 +879,7 @@ static av_cold int atrac3_decode_init(AVCodecContext *avctx)

         return AVERROR(EINVAL);

     q->decoded_bytes_buffer = av_mallocz(FFALIGN(avctx->block_align, 4) +

-                                         FF_INPUT_BUFFER_PADDING_SIZE);

+                                         AV_INPUT_BUFFER_PADDING_SIZE);

     if (!q->decoded_bytes_buffer)

         return AVERROR(ENOMEM);

@@ -535,15 +535,24 @@ typedef struct AVCodecDescriptor {

  * Note: If the first 23 bits of the additional bytes are not 0, then damaged

  * MPEG bitstreams could cause overread and segfault.

  */

-#define FF_INPUT_BUFFER_PADDING_SIZE 8

+#define AV_INPUT_BUFFER_PADDING_SIZE 8

 /**

  * @ingroup lavc_encoding

  * minimum encoding buffer size

  * Used to avoid some checks during header writing.

  */

-#define FF_MIN_BUFFER_SIZE 16384

+#define AV_INPUT_BUFFER_MIN_SIZE 16384

+/**

+ * @deprecated use AV_INPUT_BUFFER_PADDING_SIZE instead

+ */

+#define FF_INPUT_BUFFER_PADDING_SIZE 8

+

+/**

+ * @deprecated use AV_INPUT_BUFFER_MIN_SIZE instead

+ */

+#define FF_MIN_BUFFER_SIZE 16384

 /**

  * @ingroup lavc_encoding

@@ -1362,7 +1371,7 @@ typedef struct AVCodecContext {

      * mjpeg: Huffman tables

      * rv10: additional flags

      * mpeg4: global headers (they can be in the bitstream or here)

-     * The allocated memory should be FF_INPUT_BUFFER_PADDING_SIZE bytes larger

+     * The allocated memory should be AV_INPUT_BUFFER_PADDING_SIZE bytes larger

      * than extradata_size to avoid prolems if it is read with the bitstream reader.

      * The bytewise contents of extradata must not depend on the architecture or CPU endianness.

      * - encoding: Set/allocated/freed by libavcodec.

@@ -3627,7 +3636,7 @@ int av_grow_packet(AVPacket *pkt, int grow_by);

  *        function returns successfully, the data is owned by the underlying AVBuffer.

  *        The caller may not access the data through other means.

  * @param size size of data in bytes, without the padding. I.e. the full buffer

- *        size is assumed to be size + FF_INPUT_BUFFER_PADDING_SIZE.

+ *        size is assumed to be size + AV_INPUT_BUFFER_PADDING_SIZE.

  *

  * @return 0 on success, a negative AVERROR on error

  */

@@ -3843,7 +3852,7 @@ void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,

  * returning samples. It is safe to flush even those decoders that are not

  * marked with AV_CODEC_CAP_DELAY, then no samples will be returned.

  *

- * @warning The input buffer, avpkt->data must be FF_INPUT_BUFFER_PADDING_SIZE

+ * @warning The input buffer, avpkt->data must be AV_INPUT_BUFFER_PADDING_SIZE

  *          larger than the actual read bytes because some optimized bitstream

  *          readers read 32 or 64 bits at once and could read over the end.

  *

@@ -3883,7 +3892,7 @@ int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame,

  * Some decoders may support multiple frames in a single AVPacket, such

  * decoders would then just decode the first frame.

  *

- * @warning The input buffer must be FF_INPUT_BUFFER_PADDING_SIZE larger than

+ * @warning The input buffer must be AV_INPUT_BUFFER_PADDING_SIZE larger than

  * the actual read bytes because some optimized bitstream readers read 32 or 64

  * bits at once and could read over the end.

  *

@@ -4612,7 +4621,7 @@ AVBitStreamFilter *av_bitstream_filter_next(const AVBitStreamFilter *f);

  * Allocate a buffer with padding, reusing the given one if large enough.

  *

  * Same behaviour av_fast_malloc but the buffer has additional

- * FF_INPUT_PADDING_SIZE at the end which will always memset to 0.

+ * AV_INPUT_PADDING_SIZE at the end which will always memset to 0.

  *

  */

 void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size);

@@ -66,14 +66,14 @@ FF_ENABLE_DEPRECATION_WARNINGS

 static int packet_alloc(AVBufferRef **buf, int size)

 {

     int ret;

-    if ((unsigned)size >= (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)

+    if ((unsigned)size >= (unsigned)size + AV_INPUT_BUFFER_PADDING_SIZE)

         return AVERROR(EINVAL);

-    ret = av_buffer_realloc(buf, size + FF_INPUT_BUFFER_PADDING_SIZE);

+    ret = av_buffer_realloc(buf, size + AV_INPUT_BUFFER_PADDING_SIZE);

     if (ret < 0)

         return ret;

-    memset((*buf)->data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);

+    memset((*buf)->data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);

     return 0;

 }

@@ -103,20 +103,20 @@ void av_shrink_packet(AVPacket *pkt, int size)

     if (pkt->size <= size)

         return;

     pkt->size = size;

-    memset(pkt->data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);

+    memset(pkt->data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);

 }

 int av_grow_packet(AVPacket *pkt, int grow_by)

 {

     int new_size;

-    av_assert0((unsigned)pkt->size <= INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE);

+    av_assert0((unsigned)pkt->size <= INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE);

     if (!pkt->size)

         return av_new_packet(pkt, grow_by);

     if ((unsigned)grow_by >

-        INT_MAX - (pkt->size + FF_INPUT_BUFFER_PADDING_SIZE))

+        INT_MAX - (pkt->size + AV_INPUT_BUFFER_PADDING_SIZE))

         return -1;

-    new_size = pkt->size + grow_by + FF_INPUT_BUFFER_PADDING_SIZE;

+    new_size = pkt->size + grow_by + AV_INPUT_BUFFER_PADDING_SIZE;

     if (pkt->buf) {

         int ret = av_buffer_realloc(&pkt->buf, new_size);

         if (ret < 0)

@@ -134,17 +134,17 @@ FF_ENABLE_DEPRECATION_WARNINGS

     }

     pkt->data  = pkt->buf->data;

     pkt->size += grow_by;

-    memset(pkt->data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);

+    memset(pkt->data + pkt->size, 0, AV_INPUT_BUFFER_PADDING_SIZE);

     return 0;

 }

 int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size)

 {

-    if (size >= INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE)

+    if (size >= INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)

         return AVERROR(EINVAL);

-    pkt->buf = av_buffer_create(data, size + FF_INPUT_BUFFER_PADDING_SIZE,

+    pkt->buf = av_buffer_create(data, size + AV_INPUT_BUFFER_PADDING_SIZE,

                                 av_buffer_default_free, NULL, 0);

     if (!pkt->buf)

         return AVERROR(ENOMEM);

@@ -172,9 +172,9 @@ do {                                         \

         void *data;                                                     \

         if (padding) {                                                  \

             if ((unsigned)(size) >                                      \

-                (unsigned)(size) + FF_INPUT_BUFFER_PADDING_SIZE)        \

+                (unsigned)(size) + AV_INPUT_BUFFER_PADDING_SIZE)        \

                 goto failed_alloc;                                      \

-            ALLOC(data, size + FF_INPUT_BUFFER_PADDING_SIZE);           \

+            ALLOC(data, size + AV_INPUT_BUFFER_PADDING_SIZE);           \

         } else {                                                        \

             ALLOC(data, size);                                          \

         }                                                               \

@@ -183,7 +183,7 @@ do {                                         \

         memcpy(data, src, size);                                        \

         if (padding)                                                    \

             memset((uint8_t *)data + size, 0,                           \

-                   FF_INPUT_BUFFER_PADDING_SIZE);                       \

+                   AV_INPUT_BUFFER_PADDING_SIZE);                       \

         dst = data;                                                     \

     } while (0)

@@ -266,7 +266,7 @@ uint8_t *av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,

     if ((unsigned)elems + 1 > INT_MAX / sizeof(*pkt->side_data))

         return NULL;

-    if ((unsigned)size > INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE)

+    if ((unsigned)size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)

         return NULL;

     pkt->side_data = av_realloc(pkt->side_data,

@@ -274,7 +274,7 @@ uint8_t *av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,

     if (!pkt->side_data)

         return NULL;

-    pkt->side_data[elems].data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);

+    pkt->side_data[elems].data = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);

     if (!pkt->side_data[elems].data)

         return NULL;

     pkt->side_data[elems].size = size;

@@ -302,7 +302,7 @@ static int decode_frame(AVCodecContext *avctx, void *data,

             av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");

             return AVERROR_INVALIDDATA;

         }

-        buf = av_realloc(s->packet_buffer, avpkt->size + FF_INPUT_BUFFER_PADDING_SIZE);

+        buf = av_realloc(s->packet_buffer, avpkt->size + AV_INPUT_BUFFER_PADDING_SIZE);

         if (!buf)

             return AVERROR(ENOMEM);

         s->packet_buffer = buf;

@@ -263,7 +263,7 @@ static int cdxl_decode_frame(AVCodecContext *avctx, void *data,

     if (encoding) {

         av_fast_padded_malloc(&c->new_video, &c->new_video_size,

-                              h * w + FF_INPUT_BUFFER_PADDING_SIZE);

+                              h * w + AV_INPUT_BUFFER_PADDING_SIZE);

         if (!c->new_video)

             return AVERROR(ENOMEM);

         if (c->bpp == 8)

@@ -1213,11 +1213,11 @@ static av_cold int cook_decode_init(AVCodecContext *avctx)

     /* Pad the databuffer with:

        DECODE_BYTES_PAD1 or DECODE_BYTES_PAD2 for decode_bytes(),

-       FF_INPUT_BUFFER_PADDING_SIZE, for the bitstreamreader. */

+       AV_INPUT_BUFFER_PADDING_SIZE, for the bitstreamreader. */

     q->decoded_bytes_buffer =

         av_mallocz(avctx->block_align

                    + DECODE_BYTES_PAD1(avctx->block_align)

-                   + FF_INPUT_BUFFER_PADDING_SIZE);

+                   + AV_INPUT_BUFFER_PADDING_SIZE);

     if (!q->decoded_bytes_buffer)

         return AVERROR(ENOMEM);

@@ -113,7 +113,7 @@ static int dca_parse_params(const uint8_t *buf, int buf_size, int *duration,

                             int *sample_rate, int *framesize)

 {

     GetBitContext gb;

-    uint8_t hdr[12 + FF_INPUT_BUFFER_PADDING_SIZE] = { 0 };

+    uint8_t hdr[12 + AV_INPUT_BUFFER_PADDING_SIZE] = { 0 };

     int ret, sample_blocks, sr_code;

     if (buf_size < 12)

@@ -65,7 +65,7 @@ typedef struct DssSpContext {

     int pulse_dec_mode;

     DECLARE_ALIGNED(16, uint8_t, bits)[DSS_SP_FRAME_SIZE +

-                                       FF_INPUT_BUFFER_PADDING_SIZE];

+                                       AV_INPUT_BUFFER_PADDING_SIZE];

 } DssSpContext;

 /*

@@ -36,12 +36,12 @@ static int dump_extradata(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx,

             /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){

             int size= buf_size + avctx->extradata_size;

             *poutbuf_size= size;

-            *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);

+            *poutbuf= av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);

             if (!*poutbuf)

                 return AVERROR(ENOMEM);

             memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);

-            memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);

+            memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + AV_INPUT_BUFFER_PADDING_SIZE);

             return 1;

         }

     }

@@ -167,8 +167,8 @@ static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)

     GetBitContext gb;

     BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;

     LOCAL_ALIGNED_16(int16_t, sblock, [5 * DV_MAX_BPM], [64]);

-    LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80     + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */

-    LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */

+    LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80     + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */

+    LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */

     const int log2_blocksize = 3;

     int is_field_mode[5];

@@ -940,7 +940,7 @@ static int ffv1_encode_frame(AVCodecContext *avctx, AVPacket *pkt,

     if ((ret = ff_alloc_packet(pkt, avctx->width * avctx->height *

                              ((8 * 2 + 1 + 1) * 4) / 8 +

-                             FF_MIN_BUFFER_SIZE)) < 0) {

+                             AV_INPUT_BUFFER_MIN_SIZE)) < 0) {

         av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");

         return ret;

     }

@@ -294,10 +294,10 @@ static int jpg_decode_data(JPGContext *c, int width, int height,

     const int ridx = swapuv ? 2 : 0;

     if ((ret = av_reallocp(&c->buf,

-                           src_size + FF_INPUT_BUFFER_PADDING_SIZE)) < 0)

+                           src_size + AV_INPUT_BUFFER_PADDING_SIZE)) < 0)

         return ret;

     jpg_unescape(src, src_size, c->buf, &unesc_size);

-    memset(c->buf + unesc_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);

+    memset(c->buf + unesc_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);

     init_get_bits(&gb, c->buf, unesc_size * 8);

     width = FFALIGN(width, 16);

@@ -1170,7 +1170,7 @@ static int g2m_init_buffers(G2MContext *c)

         c->synth_tile  = av_mallocz(c->tile_stride      * aligned_height);

         c->jpeg_tile   = av_mallocz(c->tile_stride      * aligned_height);

         c->kempf_buf   = av_mallocz((c->tile_width + 1) * aligned_height +

-                                    FF_INPUT_BUFFER_PADDING_SIZE);

+                                    AV_INPUT_BUFFER_PADDING_SIZE);

         c->kempf_flags = av_mallocz(c->tile_width       * aligned_height);

         if (!c->synth_tile || !c->jpeg_tile ||

             !c->kempf_buf || !c->kempf_flags)

@@ -367,7 +367,7 @@ static inline int check_marker(GetBitContext *s, const char *msg)

 /**

  * Initialize GetBitContext.

- * @param buffer bitstream buffer, must be FF_INPUT_BUFFER_PADDING_SIZE bytes

+ * @param buffer bitstream buffer, must be AV_INPUT_BUFFER_PADDING_SIZE bytes

  *        larger than the actual read bits because some optimized bitstream

  *        readers read 32 or 64 bit at once and could read over the end

  * @param bit_size the size of the buffer in bits

@@ -400,7 +400,7 @@ static inline int init_get_bits(GetBitContext *s, const uint8_t *buffer,

 /**

  * Initialize GetBitContext.

- * @param buffer bitstream buffer, must be FF_INPUT_BUFFER_PADDING_SIZE bytes

+ * @param buffer bitstream buffer, must be AV_INPUT_BUFFER_PADDING_SIZE bytes

  *        larger than the actual read bits because some optimized bitstream

  *        readers read 32 or 64 bit at once and could read over the end

  * @param byte_size the size of the buffer in bytes

@@ -153,7 +153,7 @@ static int gif_encode_frame(AVCodecContext *avctx, AVPacket *pkt,

     uint8_t *outbuf_ptr, *end;

     int ret;

-    if ((ret = ff_alloc_packet(pkt, avctx->width*avctx->height*7/5 + FF_MIN_BUFFER_SIZE)) < 0) {

+    if ((ret = ff_alloc_packet(pkt, avctx->width*avctx->height*7/5 + AV_INPUT_BUFFER_MIN_SIZE)) < 0) {

         av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");

         return ret;

     }

@@ -275,7 +275,7 @@ const uint8_t *ff_h264_decode_nal(H264Context *h, H264SliceContext *sl,

     }

     av_fast_malloc(&sl->rbsp_buffer, &sl->rbsp_buffer_size,

-                   length + FF_INPUT_BUFFER_PADDING_SIZE);

+                   length + AV_INPUT_BUFFER_PADDING_SIZE);

     dst = sl->rbsp_buffer;

     if (!dst)

@@ -304,7 +304,7 @@ const uint8_t *ff_h264_decode_nal(H264Context *h, H264SliceContext *sl,

         dst[di++] = src[si++];

 nsc:

-    memset(dst + di, 0, FF_INPUT_BUFFER_PADDING_SIZE);

+    memset(dst + di, 0, AV_INPUT_BUFFER_PADDING_SIZE);

     *dst_length = di;

     *consumed   = si + 1; // +1 for the header

@@ -41,7 +41,7 @@ static int alloc_and_copy(uint8_t **poutbuf, int *poutbuf_size,

     *poutbuf_size += sps_pps_size + in_size + nal_header_size;

     if ((err = av_reallocp(poutbuf,

-                           *poutbuf_size + FF_INPUT_BUFFER_PADDING_SIZE)) < 0) {

+                           *poutbuf_size + AV_INPUT_BUFFER_PADDING_SIZE)) < 0) {

         *poutbuf_size = 0;

         return err;

     }

@@ -109,7 +109,7 @@ static int h264_extradata_to_annexb(AVCodecContext *avctx, const int padding)

     }

     if (out)

-        memset(out + total_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);

+        memset(out + total_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);

     if (!sps_seen)

         av_log(avctx, AV_LOG_WARNING,

@@ -150,7 +150,7 @@ static int h264_mp4toannexb_filter(AVBitStreamFilterContext *bsfc,

     /* retrieve sps and pps NAL units from extradata */

     if (!ctx->extradata_parsed) {

-        ret = h264_extradata_to_annexb(avctx, FF_INPUT_BUFFER_PADDING_SIZE);

+        ret = h264_extradata_to_annexb(avctx, AV_INPUT_BUFFER_PADDING_SIZE);

         if (ret < 0)

             return ret;

         ctx->length_size      = ret;

@@ -67,18 +67,18 @@ static int hevc_extradata_to_annexb(AVCodecContext *avctx)

         for (j = 0; j < cnt; j++) {

             int nalu_len = bytestream2_get_be16(&gb);

-            if (4 + FF_INPUT_BUFFER_PADDING_SIZE + nalu_len > SIZE_MAX - new_extradata_size) {

+            if (4 + AV_INPUT_BUFFER_PADDING_SIZE + nalu_len > SIZE_MAX - new_extradata_size) {

                 ret = AVERROR_INVALIDDATA;

                 goto fail;

             }

-            ret = av_reallocp(&new_extradata, new_extradata_size + nalu_len + 4 + FF_INPUT_BUFFER_PADDING_SIZE);

+            ret = av_reallocp(&new_extradata, new_extradata_size + nalu_len + 4 + AV_INPUT_BUFFER_PADDING_SIZE);

             if (ret < 0)

                 goto fail;

             AV_WB32(new_extradata + new_extradata_size, 1); // add the startcode

             bytestream2_get_buffer(&gb, new_extradata + new_extradata_size + 4, nalu_len);

             new_extradata_size += 4 + nalu_len;

-            memset(new_extradata + new_extradata_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);

+            memset(new_extradata + new_extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);

         }

     }

@@ -89,7 +89,7 @@ int ff_hevc_extract_rbsp(const uint8_t *src, int length,

     }

     av_fast_malloc(&nal->rbsp_buffer, &nal->rbsp_buffer_size,

-                   length + FF_INPUT_BUFFER_PADDING_SIZE);

+                   length + AV_INPUT_BUFFER_PADDING_SIZE);

     if (!nal->rbsp_buffer)

         return AVERROR(ENOMEM);

@@ -119,7 +119,7 @@ int ff_hevc_extract_rbsp(const uint8_t *src, int length,

         dst[di++] = src[si++];

 nsc:

-    memset(dst + di, 0, FF_INPUT_BUFFER_PADDING_SIZE);

+    memset(dst + di, 0, AV_INPUT_BUFFER_PADDING_SIZE);

     nal->data = dst;

     nal->size = di;

@@ -35,14 +35,14 @@

 #include "thread.h"

 #define classic_shift_luma_table_size 42

-static const unsigned char classic_shift_luma[classic_shift_luma_table_size + FF_INPUT_BUFFER_PADDING_SIZE] = {

+static const unsigned char classic_shift_luma[classic_shift_luma_table_size + AV_INPUT_BUFFER_PADDING_SIZE] = {

     34, 36, 35, 69, 135, 232,   9, 16, 10, 24,  11,  23,  12,  16, 13, 10,

     14,  8, 15,  8,  16,   8,  17, 20, 16, 10, 207, 206, 205, 236, 11,  8,

     10, 21,  9, 23,   8,   8, 199, 70, 69, 68,   0

 };

 #define classic_shift_chroma_table_size 59

-static const unsigned char classic_shift_chroma[classic_shift_chroma_table_size + FF_INPUT_BUFFER_PADDING_SIZE] = {

+static const unsigned char classic_shift_chroma[classic_shift_chroma_table_size + AV_INPUT_BUFFER_PADDING_SIZE] = {

     66, 36,  37,  38, 39, 40,  41,  75,  76,  77, 110, 239, 144, 81, 82,  83,

     84, 85, 118, 183, 56, 57,  88,  89,  56,  89, 154,  57,  58, 57, 26, 141,

     57, 56,  58,  57, 58, 57, 184, 119, 214, 245, 116,  83,  82, 49, 80,  79,

@@ -511,11 +511,11 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

     av_fast_malloc(&s->bitstream_buffer,

                    &s->bitstream_buffer_size,

-                   buf_size + FF_INPUT_BUFFER_PADDING_SIZE);

+                   buf_size + AV_INPUT_BUFFER_PADDING_SIZE);

     if (!s->bitstream_buffer)

         return AVERROR(ENOMEM);

-    memset(s->bitstream_buffer + buf_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);

+    memset(s->bitstream_buffer + buf_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);

     s->bdsp.bswap_buf((uint32_t *) s->bitstream_buffer,

                       (const uint32_t *) buf, buf_size / 4);

@@ -453,7 +453,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,

     int i, j, size = 0, ret;

     if (!pkt->data &&

-        (ret = av_new_packet(pkt, width * height * 3 * 4 + FF_MIN_BUFFER_SIZE)) < 0) {

+        (ret = av_new_packet(pkt, width * height * 3 * 4 + AV_INPUT_BUFFER_MIN_SIZE)) < 0) {

         av_log(avctx, AV_LOG_ERROR, "Error allocating output packet.\n");

         return ret;

     }

@@ -172,7 +172,7 @@ static av_cold int decode_init(AVCodecContext *avctx)

     if ((err = av_image_check_size(avctx->width, avctx->height, 0, avctx)))

         return err;

     s->planesize = FFALIGN(avctx->width, 16) >> 3; // Align plane size in bits to word-boundary

-    s->planebuf  = av_malloc(s->planesize + FF_INPUT_BUFFER_PADDING_SIZE);

+    s->planebuf  = av_malloc(s->planesize + AV_INPUT_BUFFER_PADDING_SIZE);

     if (!s->planebuf)

         return AVERROR(ENOMEM);

@@ -997,7 +997,7 @@ static int imc_decode_frame(AVCodecContext *avctx, void *data,

     IMCContext *q = avctx->priv_data;

-    LOCAL_ALIGNED_16(uint16_t, buf16, [(IMC_BLOCK_SIZE + FF_INPUT_BUFFER_PADDING_SIZE) / 2]);

+    LOCAL_ALIGNED_16(uint16_t, buf16, [(IMC_BLOCK_SIZE + AV_INPUT_BUFFER_PADDING_SIZE) / 2]);

     if (buf_size < IMC_BLOCK_SIZE * avctx->channels) {

         av_log(avctx, AV_LOG_ERROR, "frame too small!\n");

@@ -42,7 +42,7 @@ static int imx_dump_header(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx

         return 0;

     }

-    *poutbuf = av_malloc(buf_size + 20 + FF_INPUT_BUFFER_PADDING_SIZE);

+    *poutbuf = av_malloc(buf_size + 20 + AV_INPUT_BUFFER_PADDING_SIZE);

     if (!*poutbuf)

         return AVERROR(ENOMEM);

     poutbufp = *poutbuf;

@@ -157,7 +157,7 @@ int avpriv_unlock_avformat(void);

  * This value was chosen such that every bit of the buffer is

  * addressable by a 32-bit signed integer as used by get_bits.

  */

-#define FF_MAX_EXTRADATA_SIZE ((1 << 28) - FF_INPUT_BUFFER_PADDING_SIZE)

+#define FF_MAX_EXTRADATA_SIZE ((1 << 28) - AV_INPUT_BUFFER_PADDING_SIZE)

 /**

  * Check AVPacket size and/or allocate data.

@@ -268,7 +268,7 @@ static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt,

         comps = 3;

     if ((ret = ff_alloc_packet(pkt, avctx->width * avctx->height * comps * 4 +

-                               FF_MIN_BUFFER_SIZE)) < 0) {

+                               AV_INPUT_BUFFER_MIN_SIZE)) < 0) {

         av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");

         return ret;

     }

@@ -54,7 +54,7 @@ static int dcadec_decode_frame(AVCodecContext *avctx, void *data,

     }

     mrk = AV_RB32(input);

     if (mrk != DCA_SYNCWORD_CORE_BE && mrk != DCA_SYNCWORD_SUBSTREAM) {

-        s->buffer = av_fast_realloc(s->buffer, &s->buffer_size, avpkt->size + FF_INPUT_BUFFER_PADDING_SIZE);

+        s->buffer = av_fast_realloc(s->buffer, &s->buffer_size, avpkt->size + AV_INPUT_BUFFER_PADDING_SIZE);

         if (!s->buffer)

             return AVERROR(ENOMEM);

@@ -139,7 +139,7 @@ static av_cold int Faac_encode_init(AVCodecContext *avctx)

         if (!faacEncGetDecoderSpecificInfo(s->faac_handle, &buffer,

                                            &decoder_specific_info_size)) {

-            avctx->extradata = av_malloc(decoder_specific_info_size + FF_INPUT_BUFFER_PADDING_SIZE);

+            avctx->extradata = av_malloc(decoder_specific_info_size + AV_INPUT_BUFFER_PADDING_SIZE);

             if (!avctx->extradata) {

                 ret = AVERROR(ENOMEM);

                 goto error;

@@ -292,7 +292,7 @@ static av_cold int aac_encode_init(AVCodecContext *avctx)

     if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {

         avctx->extradata_size = info.confSize;

         avctx->extradata      = av_mallocz(avctx->extradata_size +

-                                           FF_INPUT_BUFFER_PADDING_SIZE);

+                                           AV_INPUT_BUFFER_PADDING_SIZE);

         if (!avctx->extradata) {

             ret = AVERROR(ENOMEM);

             goto error;

@@ -143,7 +143,7 @@ static av_cold int svc_encode_init(AVCodecContext *avctx)

         (*s->encoder)->EncodeParameterSets(s->encoder, &fbi);

         for (i = 0; i < fbi.sLayerInfo[0].iNalCount; i++)

             size += fbi.sLayerInfo[0].pNalLengthInByte[i];

-        avctx->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);

+        avctx->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);

         if (!avctx->extradata) {

             err = AVERROR(ENOMEM);

             goto fail;

@@ -262,7 +262,7 @@ static int av_cold libopus_encode_init(AVCodecContext *avctx)

     }

     header_size = 19 + (avctx->channels > 2 ? 2 + avctx->channels : 0);

-    avctx->extradata = av_malloc(header_size + FF_INPUT_BUFFER_PADDING_SIZE);

+    avctx->extradata = av_malloc(header_size + AV_INPUT_BUFFER_PADDING_SIZE);

     if (!avctx->extradata) {

         av_log(avctx, AV_LOG_ERROR, "Failed to allocate extradata.\n");

         ret = AVERROR(ENOMEM);

@@ -244,7 +244,7 @@ static av_cold int encode_init(AVCodecContext *avctx)

     header_data = speex_header_to_packet(&s->header, &header_size);

     /* allocate extradata */

-    avctx->extradata = av_malloc(header_size + FF_INPUT_BUFFER_PADDING_SIZE);

+    avctx->extradata = av_malloc(header_size + AV_INPUT_BUFFER_PADDING_SIZE);

     if (!avctx->extradata) {

         speex_header_free(header_data);

         speex_encoder_destroy(s->enc_state);

@@ -105,7 +105,7 @@ static av_cold int aac_encode_init(AVCodecContext *avctx)

     if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {

         avctx->extradata_size = 2;

         avctx->extradata      = av_mallocz(avctx->extradata_size +

-                                           FF_INPUT_BUFFER_PADDING_SIZE);

+                                           AV_INPUT_BUFFER_PADDING_SIZE);

         if (!avctx->extradata) {

             ret = AVERROR(ENOMEM);

             goto error;

@@ -206,7 +206,7 @@ static av_cold int libvorbis_encode_init(AVCodecContext *avctx)

                                 xiph_len(header_comm.bytes) +

                                 header_code.bytes;

     p = avctx->extradata = av_malloc(avctx->extradata_size +

-                                     FF_INPUT_BUFFER_PADDING_SIZE);

+                                     AV_INPUT_BUFFER_PADDING_SIZE);

     if (!p) {

         ret = AVERROR(ENOMEM);

         goto error;

@@ -225,7 +225,7 @@ static av_cold int libx265_encode_init(AVCodecContext *avctx)

             return AVERROR_INVALIDDATA;

         }

-        avctx->extradata = av_malloc(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);

+        avctx->extradata = av_malloc(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);

         if (!avctx->extradata) {

             av_log(avctx, AV_LOG_ERROR,

                    "Cannot allocate HEVC header of size %d.\n", avctx->extradata_size);

@@ -81,7 +81,7 @@ static int encode_nals(AVCodecContext *ctx, AVPacket *pkt,

 {

     XavsContext *x4 = ctx->priv_data;

     uint8_t *p;

-    int i, s, ret, size = x4->sei_size + FF_MIN_BUFFER_SIZE;

+    int i, s, ret, size = x4->sei_size + AV_INPUT_BUFFER_MIN_SIZE;

     if (!nnal)

         return 0;

@@ -688,7 +688,7 @@ static int xvid_encode_frame(AVCodecContext *avctx, AVPacket *pkt,

     xvid_enc_stats_t xvid_enc_stats = { 0 };