diff --git a/fftools/ffmpeg_mux.c b/fftools/ffmpeg_mux.c
index 52986b002a..e97d7d50c6 100644
--- a/fftools/ffmpeg_mux.c
+++ b/fftools/ffmpeg_mux.c
@@ -126,11 +126,11 @@ static int queue_packet(OutputFile *of, OutputStream *ost, AVPacket *pkt)
     AVPacket *tmp_pkt;
     int ret;
 
-    if (!av_fifo_space(ms->muxing_queue)) {
-        size_t cur_size = av_fifo_size(ms->muxing_queue);
+    if (!av_fifo_can_write(ms->muxing_queue)) {
+        size_t cur_size = av_fifo_can_read(ms->muxing_queue);
         unsigned int are_we_over_size =
             (ms->muxing_queue_data_size + pkt->size) > ost->muxing_queue_data_threshold;
-        size_t limit    = are_we_over_size ? ost->max_muxing_queue_size : INT_MAX;
+        size_t limit    = are_we_over_size ? ost->max_muxing_queue_size : SIZE_MAX;
         size_t new_size = FFMIN(2 * cur_size, limit);
 
         if (new_size <= cur_size) {
@@ -139,7 +139,7 @@ static int queue_packet(OutputFile *of, OutputStream *ost, AVPacket *pkt)
                    ost->file_index, ost->st->index);
             return AVERROR(ENOSPC);
         }
-        ret = av_fifo_realloc2(ms->muxing_queue, new_size);
+        ret = av_fifo_grow2(ms->muxing_queue, new_size - cur_size);
         if (ret < 0)
             return ret;
     }
@@ -154,7 +154,7 @@ static int queue_packet(OutputFile *of, OutputStream *ost, AVPacket *pkt)
 
     av_packet_move_ref(tmp_pkt, pkt);
     ms->muxing_queue_data_size += tmp_pkt->size;
-    av_fifo_generic_write(ms->muxing_queue, &tmp_pkt, sizeof(tmp_pkt), NULL);
+    av_fifo_write(ms->muxing_queue, &tmp_pkt, 1);
 
     return 0;
 }
@@ -369,12 +369,12 @@ int of_check_init(OutputFile *of)
         OutputStream *ost = output_streams[of->ost_index + i];
 
         /* try to improve muxing time_base (only possible if nothing has been written yet) */
-        if (!av_fifo_size(ms->muxing_queue))
+        if (!av_fifo_can_read(ms->muxing_queue))
             ost->mux_timebase = ost->st->time_base;
 
-        while (av_fifo_size(ms->muxing_queue)) {
+        while (av_fifo_can_read(ms->muxing_queue)) {
             AVPacket *pkt;
-            av_fifo_generic_read(ms->muxing_queue, &pkt, sizeof(pkt), NULL);
+            av_fifo_read(ms->muxing_queue, &pkt, 1);
             ms->muxing_queue_data_size -= pkt->size;
             write_packet(of, ost, pkt);
             av_packet_free(&pkt);
@@ -429,9 +429,9 @@ static void mux_free(Muxer **pmux, int nb_streams)
         if (!ms->muxing_queue)
             continue;
 
-        while (av_fifo_size(ms->muxing_queue)) {
+        while (av_fifo_can_read(ms->muxing_queue)) {
             AVPacket *pkt;
-            av_fifo_generic_read(ms->muxing_queue, &pkt, sizeof(pkt), NULL);
+            av_fifo_read(ms->muxing_queue, &pkt, 1);
             av_packet_free(&pkt);
         }
         av_fifo_freep(&ms->muxing_queue);
@@ -479,7 +479,7 @@ int of_muxer_init(OutputFile *of, AVDictionary *opts, int64_t limit_filesize)
 
     for (int i = 0; i < of->ctx->nb_streams; i++) {
         MuxStream *ms = &mux->streams[i];
-        ms->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket*));
+        ms->muxing_queue = av_fifo_alloc2(8, sizeof(AVPacket*), 0);
         if (!ms->muxing_queue) {
             ret = AVERROR(ENOMEM);
             goto fail;
diff --git a/fftools/ffmpeg_opt.c b/fftools/ffmpeg_opt.c
index cb21a6a42c..4fede8471e 100644
--- a/fftools/ffmpeg_opt.c
+++ b/fftools/ffmpeg_opt.c
@@ -1610,8 +1610,6 @@ static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, e
 
     ost->max_muxing_queue_size = 128;
     MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
-    ost->max_muxing_queue_size = FFMIN(ost->max_muxing_queue_size, INT_MAX / sizeof(ost->pkt));
-    ost->max_muxing_queue_size *= sizeof(ost->pkt);
 
     ost->muxing_queue_data_threshold = 50*1024*1024;
     MATCH_PER_STREAM_OPT(muxing_queue_data_threshold, i, ost->muxing_queue_data_threshold, oc, st);
diff --git a/libavcodec/amfenc.c b/libavcodec/amfenc.c
index fb23ed738c..3a8dd2b007 100644
--- a/libavcodec/amfenc.c
+++ b/libavcodec/amfenc.c
@@ -117,8 +117,9 @@ static int amf_load_library(AVCodecContext *avctx)
     if (!ctx->delayed_frame) {
         return AVERROR(ENOMEM);
     }
-    // hardcoded to current HW queue size - will realloc in timestamp_queue_enqueue() if too small
-    ctx->timestamp_list = av_fifo_alloc((avctx->max_b_frames + 16) * sizeof(int64_t));
+    // hardcoded to current HW queue size - will auto-realloc if too small
+    ctx->timestamp_list = av_fifo_alloc2(avctx->max_b_frames + 16, sizeof(int64_t),
+                                         AV_FIFO_FLAG_AUTO_GROW);
     if (!ctx->timestamp_list) {
         return AVERROR(ENOMEM);
     }
@@ -432,18 +433,6 @@ static int amf_copy_surface(AVCodecContext *avctx, const AVFrame *frame,
     return 0;
 }
 
-static inline int timestamp_queue_enqueue(AVCodecContext *avctx, int64_t timestamp)
-{
-    AmfContext         *ctx = avctx->priv_data;
-    if (av_fifo_space(ctx->timestamp_list) < sizeof(timestamp)) {
-        if (av_fifo_grow(ctx->timestamp_list, sizeof(timestamp)) < 0) {
-            return AVERROR(ENOMEM);
-        }
-    }
-    av_fifo_generic_write(ctx->timestamp_list, &timestamp, sizeof(timestamp), NULL);
-    return 0;
-}
-
 static int amf_copy_buffer(AVCodecContext *avctx, AVPacket *pkt, AMFBuffer *buffer)
 {
     AmfContext      *ctx = avctx->priv_data;
@@ -479,21 +468,19 @@ static int amf_copy_buffer(AVCodecContext *avctx, AVPacket *pkt, AMFBuffer *buff
     pkt->pts = var.int64Value; // original pts
 
 
-    AMF_RETURN_IF_FALSE(ctx, av_fifo_size(ctx->timestamp_list) > 0, AVERROR_UNKNOWN, "timestamp_list is empty\n");
+    AMF_RETURN_IF_FALSE(ctx, av_fifo_can_read(ctx->timestamp_list) > 0, AVERROR_UNKNOWN, "timestamp_list is empty\n");
 
-    av_fifo_generic_read(ctx->timestamp_list, &timestamp, sizeof(timestamp), NULL);
+    av_fifo_read(ctx->timestamp_list, &timestamp, 1);
 
     // calc dts shift if max_b_frames > 0
     if (avctx->max_b_frames > 0 && ctx->dts_delay == 0) {
         int64_t timestamp_last = AV_NOPTS_VALUE;
-        AMF_RETURN_IF_FALSE(ctx, av_fifo_size(ctx->timestamp_list) > 0, AVERROR_UNKNOWN,
+        AMF_RETURN_IF_FALSE(ctx, av_fifo_can_read(ctx->timestamp_list) > 0, AVERROR_UNKNOWN,
             "timestamp_list is empty while max_b_frames = %d\n", avctx->max_b_frames);
-        av_fifo_generic_peek_at(
+        av_fifo_peek(
             ctx->timestamp_list,
-            &timestamp_last,
-            (av_fifo_size(ctx->timestamp_list) / sizeof(timestamp) - 1) * sizeof(timestamp_last),
-            sizeof(timestamp_last),
-            NULL);
+            &timestamp_last, 1,
+            (av_fifo_can_read(ctx->timestamp_list) - 1));
         if (timestamp < 0 || timestamp_last < AV_NOPTS_VALUE) {
             return AVERROR(ERANGE);
         }
@@ -710,9 +697,9 @@ int ff_amf_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
             AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR_UNKNOWN, "SubmitInput() failed with error %d\n", res);
 
             av_frame_unref(frame);
-            if ((ret = timestamp_queue_enqueue(avctx, pts)) < 0) {
+            ret = av_fifo_write(ctx->timestamp_list, &pts, 1);
+            if (ret < 0)
                 return ret;
-            }
         }
     }
 
@@ -751,9 +738,9 @@ int ff_amf_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
                     av_frame_unref(ctx->delayed_frame);
                     AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR_UNKNOWN, "Repeated SubmitInput() failed with error %d\n", res);
 
-                    if ((ret = timestamp_queue_enqueue(avctx, pts)) < 0) {
+                    ret = av_fifo_write(ctx->timestamp_list, &pts, 1);
+                    if (ret < 0)
                         return ret;
-                    }
                 } else {
                     av_log(avctx, AV_LOG_WARNING, "Data acquired but delayed frame submission got AMF_INPUT_FULL- should not happen\n");
                 }
