@@ -245,7 +245,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;

@@ -538,13 +538,13 @@ static void video_decode_example(const char *outfilename, const char *filename)

     int frame_count;

     FILE *f;

     AVFrame *frame;

-    uint8_t inbuf[INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];

+    uint8_t inbuf[INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];

     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("Decode video file %s to %s\n", filename, outfilename);

@@ -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;

@@ -643,7 +643,7 @@ static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)

     int ret;

     if (!ost->st->codec->extradata_size && ost->enc_ctx->extradata_size) {

-        ost->st->codec->extradata = av_mallocz(ost->enc_ctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);

+        ost->st->codec->extradata = av_mallocz(ost->enc_ctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);

         if (ost->st->codec->extradata) {

             memcpy(ost->st->codec->extradata, ost->enc_ctx->extradata, ost->enc_ctx->extradata_size);

             ost->st->codec->extradata_size = ost->enc_ctx->extradata_size;

@@ -688,10 +688,10 @@ static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)

                                            pkt->data, pkt->size,

                                            pkt->flags & AV_PKT_FLAG_KEY);

         if(a == 0 && new_pkt.data != pkt->data && new_pkt.destruct) {

-            uint8_t *t = av_malloc(new_pkt.size + FF_INPUT_BUFFER_PADDING_SIZE); //the new should be a subset of the old so cannot overflow

+            uint8_t *t = av_malloc(new_pkt.size + AV_INPUT_BUFFER_PADDING_SIZE); //the new should be a subset of the old so cannot overflow

             if(t) {

                 memcpy(t, new_pkt.data, new_pkt.size);

-                memset(t + new_pkt.size, 0, FF_INPUT_BUFFER_PADDING_SIZE);

+                memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);

                 new_pkt.data = t;

                 new_pkt.buf = NULL;

                 a = 1;

@@ -2811,7 +2811,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);

@@ -3510,7 +3510,7 @@ static void extract_mpeg4_header(AVFormatContext *infile)

                 if (p[0] == 0x00 && p[1] == 0x00 &&

                     p[2] == 0x01 && p[3] == 0xb6) {

                     size = p - pkt.data;

-                    st->codec->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);

+                    st->codec->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);

                     st->codec->extradata_size = size;

                     memcpy(st->codec->extradata, pkt.data, size);

                     break;

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

         }

         cfrm = &f->cfrm[i];

-        if (data_size > UINT_MAX -  cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)

+        if (data_size > UINT_MAX -  cfrm->size - AV_INPUT_BUFFER_PADDING_SIZE)

             return AVERROR_INVALIDDATA;

         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\n");

@@ -235,7 +235,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);

     }

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

         }

         av_free(avctx->extradata);

         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) {

             avctx->extradata_size = 0;

             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);

@@ -322,14 +322,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);

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

     if (new_extradata && 0) {

         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;

@@ -817,7 +817,7 @@ 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);

-    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;

@@ -166,7 +166,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, *phdr = &hdr;

     GetBitContext gbc;

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

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

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

     DECLARE_ALIGNED(32, SHORTFLOAT, 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;

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

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

         avctx->bits_per_coded_sample = 4;

         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;

@@ -531,7 +531,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;

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

     }

     if ((ret = ff_alloc_packet2(avctx, pkt, a->mb_height * a->mb_width * MAX_MB_SIZE +

-                                FF_MIN_BUFFER_SIZE, 0)) < 0)

+                                AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)

         return ret;

     init_put_bits(&a->pb, pkt->data, pkt->size);

@@ -886,7 +886,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);

@@ -632,15 +632,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 32

+#define AV_INPUT_BUFFER_PADDING_SIZE 32

 /**

  * @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 32

+/**

+ * @deprecated use AV_INPUT_BUFFER_MIN_SIZE instead

+ */

+#define FF_MIN_BUFFER_SIZE 16384

 /**

  * @ingroup lavc_encoding

@@ -1595,7 +1604,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 problems 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.

@@ -4062,7 +4071,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

  */

@@ -4399,7 +4408,7 @@ attribute_deprecated int avcodec_decode_audio3(AVCodecContext *avctx, int16_t *s

  * 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.

  *

@@ -4439,7 +4448,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.

  *

@@ -5447,7 +5456,7 @@ AVBitStreamFilter *av_bitstream_filter_next(const AVBitStreamFilter *f);

 /**

  * Same behaviour av_fast_malloc but the buffer has additional

- * FF_INPUT_BUFFER_PADDING_SIZE at the end which will always be 0.

+ * AV_INPUT_BUFFER_PADDING_SIZE at the end which will always be 0.

  *

  * In addition the whole buffer will initially and after resizes

  * be 0-initialized so that no uninitialized data will ever appear.

@@ -68,14 +68,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;

 }

@@ -105,20 +105,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)

@@ -136,17 +136,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);

@@ -174,9 +174,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);                                          \

         }                                                               \

@@ -185,7 +185,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)

@@ -303,7 +303,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,

@@ -311,7 +311,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_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);

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

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

         return NULL;

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

@@ -366,7 +366,7 @@ int av_packet_merge_side_data(AVPacket *pkt){

         AVBufferRef *buf;

         int i;

         uint8_t *p;

-        uint64_t size= pkt->size + 8LL + FF_INPUT_BUFFER_PADDING_SIZE;

+        uint64_t size= pkt->size + 8LL + AV_INPUT_BUFFER_PADDING_SIZE;

         AVPacket old= *pkt;

         for (i=0; i<old.side_data_elems; i++) {

             size += old.side_data[i].size + 5LL;

@@ -383,7 +383,7 @@ FF_DISABLE_DEPRECATION_WARNINGS

         pkt->destruct = dummy_destruct_packet;

 FF_ENABLE_DEPRECATION_WARNINGS

 #endif

-        pkt->size = size - FF_INPUT_BUFFER_PADDING_SIZE;

+        pkt->size = size - AV_INPUT_BUFFER_PADDING_SIZE;

         bytestream_put_buffer(&p, old.data, old.size);

         for (i=old.side_data_elems-1; i>=0; i--) {

             bytestream_put_buffer(&p, old.side_data[i].data, old.side_data[i].size);

@@ -392,7 +392,7 @@ FF_ENABLE_DEPRECATION_WARNINGS

         }

         bytestream_put_be64(&p, FF_MERGE_MARKER);

         av_assert0(p-pkt->data == pkt->size);

-        memset(p, 0, FF_INPUT_BUFFER_PADDING_SIZE);

+        memset(p, 0, AV_INPUT_BUFFER_PADDING_SIZE);

         av_free_packet(&old);

         pkt->side_data_elems = 0;

         pkt->side_data = NULL;

@@ -425,7 +425,7 @@ int av_packet_split_side_data(AVPacket *pkt){

         for (i=0; ; i++){

             size= AV_RB32(p);

             av_assert0(size<=INT_MAX && p - pkt->data >= size);

-            pkt->side_data[i].data = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);

+            pkt->side_data[i].data = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);

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

             pkt->side_data[i].type = p[4]&127;

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

@@ -30,7 +30,7 @@ static av_cold int avui_encode_init(AVCodecContext *avctx)

         av_log(avctx, AV_LOG_ERROR, "Only 720x486 and 720x576 are supported.\n");

         return AVERROR(EINVAL);

     }

-    if (!(avctx->extradata = av_mallocz(144 + FF_INPUT_BUFFER_PADDING_SIZE)))

+    if (!(avctx->extradata = av_mallocz(144 + AV_INPUT_BUFFER_PADDING_SIZE)))

         return AVERROR(ENOMEM);

     avctx->extradata_size = 144;

     memcpy(avctx->extradata, "\0\0\0\x18""APRGAPRG0001", 16);

@@ -302,10 +302,10 @@ 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);

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

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

         s->packet_buffer = buf;

         memcpy(s->packet_buffer, avpkt->data, avpkt->size);

         if ((ret = init_get_bits8(gb, s->packet_buffer, avpkt->size)) < 0)

@@ -272,7 +272,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)

@@ -1232,11 +1232,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);

@@ -422,7 +422,7 @@ static av_cold int init(AVCodecContext *avctx)

             int dummy_int;

             /* Back up the extradata so it can be restored at close time. */

-            priv->orig_extradata = av_malloc(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);

+            priv->orig_extradata = av_malloc(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);

             if (!priv->orig_extradata) {

                 av_log(avctx, AV_LOG_ERROR,

                        "Failed to allocate copy of extradata\n");

@@ -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)

@@ -66,7 +66,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;

         }

     }

@@ -287,8 +287,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-s->avctx->lowres;

     int is_field_mode[5];

     int vs_bit_buffer_damaged = 0;

@@ -312,7 +312,7 @@ static int decode_frame(AVCodecContext *avctx,

         return AVERROR(ENOMEM);

     s->bbdsp.bswap16_buf(s->bitstream_buf, (const uint16_t *)(buf + bytestream2_tell(&gb)),

                          bytestream2_get_bytes_left(&gb) / 2);

-    memset((uint8_t*)s->bitstream_buf + bytestream2_get_bytes_left(&gb), 0, FF_INPUT_BUFFER_PADDING_SIZE);

+    memset((uint8_t*)s->bitstream_buf + bytestream2_get_bytes_left(&gb), 0, AV_INPUT_BUFFER_PADDING_SIZE);

     init_get_bits(&s->gb, s->bitstream_buf, 8*(bytestream2_get_bytes_left(&gb)));

     for (s->mb_y=0; s->mb_y < (avctx->height+15)/16; s->mb_y++)

@@ -550,7 +550,7 @@ static int write_extradata(FFV1Context *f)

     f->avctx->extradata_size = 10000 + 4 +

                                     (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;

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

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

     if (!f->avctx->extradata)

         return AVERROR(ENOMEM);

     ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);

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

     uint8_t keystate    = 128;

     uint8_t *buf_p;

     int i, ret;

-    int64_t maxsize =   FF_MIN_BUFFER_SIZE

+    int64_t maxsize =   AV_INPUT_BUFFER_MIN_SIZE

                       + avctx->width*avctx->height*35LL*4;

     if(!pict) {

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

     }

     if (f->version > 3)

-        maxsize = FF_MIN_BUFFER_SIZE + avctx->width*avctx->height*3LL*4;

+        maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;

     if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)

         return ret;

@@ -854,7 +854,7 @@ static int flashsv2_encode_frame(AVCodecContext *avctx, AVPacket *pkt,

     int res;

     int keyframe = 0;

-    if ((res = ff_alloc_packet2(avctx, pkt, s->frame_size + FF_MIN_BUFFER_SIZE, 0)) < 0)

+    if ((res = ff_alloc_packet2(avctx, pkt, s->frame_size + AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)

         return res;

     /* First frame needs to be a keyframe */

@@ -193,7 +193,7 @@ static int flic_decode_frame_8BPP(AVCodecContext *avctx,

     pixels = s->frame->data[0];

     pixel_limit = s->avctx->height * s->frame->linesize[0];

-    if (buf_size < 16 || buf_size > INT_MAX - (3 * 256 + FF_INPUT_BUFFER_PADDING_SIZE))

+    if (buf_size < 16 || buf_size > INT_MAX - (3 * 256 + AV_INPUT_BUFFER_PADDING_SIZE))

         return AVERROR_INVALIDDATA;

     frame_size = bytestream2_get_le32(&g2);

     if (frame_size > buf_size)

@@ -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);

     if((ret = init_get_bits8(&gb, c->buf, unesc_size)) < 0)

         return ret;

@@ -1185,7 +1185,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)

@@ -401,7 +401,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

@@ -432,7 +432,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

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

     const uint32_t *palette = NULL;

     int ret;

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

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

         return ret;

     outbuf_ptr = pkt->data;

     end        = pkt->data + pkt->size;

@@ -324,7 +324,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

@@ -57,7 +57,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;

     }

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

         if (args && strstr(args, "private_spspps_buf"))

             ctx->private_spspps = 1;

-        ret = h264_extradata_to_annexb(ctx, avctx, FF_INPUT_BUFFER_PADDING_SIZE);

+        ret = h264_extradata_to_annexb(ctx, avctx, AV_INPUT_BUFFER_PADDING_SIZE);

         if (ret < 0)

             return ret;

         ctx->length_size      = ret;

@@ -349,8 +349,8 @@ static void sao_filter_CTB(HEVCContext *s, int x, int y)

             int sh = s->ps.sps->pixel_shift;

             int left_pixels, right_pixels;

-            stride_dst = 2*MAX_PB_SIZE + FF_INPUT_BUFFER_PADDING_SIZE;

-            dst = lc->edge_emu_buffer + stride_dst + FF_INPUT_BUFFER_PADDING_SIZE;

+            stride_dst = 2*MAX_PB_SIZE + AV_INPUT_BUFFER_PADDING_SIZE;

+            dst = lc->edge_emu_buffer + stride_dst + AV_INPUT_BUFFER_PADDING_SIZE;

             if (!top_edge) {

                 int left = 1 - left_edge;

@@ -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);

         }

     }

@@ -91,7 +91,7 @@ int ff_hevc_extract_rbsp(HEVCContext *s, 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);

@@ -137,7 +137,7 @@ int ff_hevc_extract_rbsp(HEVCContext *s, 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;

@@ -61,7 +61,7 @@ typedef struct HEVCDSPContext {

     void (*sao_band_filter[5])(uint8_t *_dst, uint8_t *_src, ptrdiff_t _stride_dst, ptrdiff_t _stride_src,

                                int16_t *sao_offset_val, int sao_left_class, int width, int height);

-    /* implicit stride_src parameter has value of 2 * MAX_PB_SIZE + FF_INPUT_BUFFER_PADDING_SIZE */

+    /* implicit stride_src parameter has value of 2 * MAX_PB_SIZE + AV_INPUT_BUFFER_PADDING_SIZE */

     void (*sao_edge_filter[5])(uint8_t *_dst /* align 16 */, uint8_t *_src /* align 32 */, ptrdiff_t stride_dst,

                                int16_t *sao_offset_val, int sao_eo_class, int width, int height);

@@ -341,7 +341,7 @@ static void FUNC(sao_edge_filter)(uint8_t *_dst, uint8_t *_src, ptrdiff_t stride

     pixel *src = (pixel *)_src;

     int a_stride, b_stride;

     int x, y;

-    ptrdiff_t stride_src = (2*MAX_PB_SIZE + FF_INPUT_BUFFER_PADDING_SIZE) / sizeof(pixel);

+    ptrdiff_t stride_src = (2*MAX_PB_SIZE + AV_INPUT_BUFFER_PADDING_SIZE) / sizeof(pixel);

     stride_dst /= sizeof(pixel);

     a_stride = pos[eo][0][0] + pos[eo][0][1] * stride_src;

@@ -41,7 +41,7 @@

 #include "libavutil/pixdesc.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,

@@ -49,7 +49,7 @@ static const unsigned char classic_shift_luma[classic_shift_luma_table_size + FF

 };

 #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,

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

     const AVFrame * const p = pict;

     int i, j, size = 0, ret;

-    if ((ret = ff_alloc_packet2(avctx, pkt, width * height * 3 * 4 + FF_MIN_BUFFER_SIZE, 0)) < 0)

+    if ((ret = ff_alloc_packet2(avctx, pkt, width * height * 3 * 4 + AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)

         return ret;

     if (s->context) {

@@ -240,7 +240,7 @@ static int extract_header(AVCodecContext *const avctx,

                 avctx->pix_fmt = AV_PIX_FMT_RGB32;

                 av_freep(&s->mask_buf);

                 av_freep(&s->mask_palbuf);

-                s->mask_buf = av_malloc((s->planesize * 32) + FF_INPUT_BUFFER_PADDING_SIZE);

+                s->mask_buf = av_malloc((s->planesize * 32) + AV_INPUT_BUFFER_PADDING_SIZE);

                 if (!s->mask_buf)

                     return AVERROR(ENOMEM);

                 if (s->bpp > 16) {

@@ -248,7 +248,7 @@ static int extract_header(AVCodecContext *const avctx,

                     av_freep(&s->mask_buf);

                     return AVERROR(ENOMEM);

                 }

-                s->mask_palbuf = av_malloc((2 << s->bpp) * sizeof(uint32_t) + FF_INPUT_BUFFER_PADDING_SIZE);

+                s->mask_palbuf = av_malloc((2 << s->bpp) * sizeof(uint32_t) + AV_INPUT_BUFFER_PADDING_SIZE);

                 if (!s->mask_palbuf) {

                     av_freep(&s->mask_buf);

                     return AVERROR(ENOMEM);

@@ -275,12 +275,12 @@ static int extract_header(AVCodecContext *const avctx,

             int ham_count;

             const uint8_t *const palette = avctx->extradata + AV_RB16(avctx->extradata);

-            s->ham_buf = av_malloc((s->planesize * 8) + FF_INPUT_BUFFER_PADDING_SIZE);

+            s->ham_buf = av_malloc((s->planesize * 8) + AV_INPUT_BUFFER_PADDING_SIZE);

             if (!s->ham_buf)

                 return AVERROR(ENOMEM);

             ham_count = 8 * (1 << s->ham);

-            s->ham_palbuf = av_malloc((ham_count << !!(s->masking == MASK_HAS_MASK)) * sizeof (uint32_t) + FF_INPUT_BUFFER_PADDING_SIZE);

+            s->ham_palbuf = av_malloc((ham_count << !!(s->masking == MASK_HAS_MASK)) * sizeof (uint32_t) + AV_INPUT_BUFFER_PADDING_SIZE);