diff --git a/libavcodec/nvenc.c b/libavcodec/nvenc.c
index 850c46022b..ae57399e96 100644
--- a/libavcodec/nvenc.c
+++ b/libavcodec/nvenc.c
@@ -1568,7 +1568,7 @@ static av_cold int nvenc_alloc_surface(AVCodecContext *avctx, int idx)
 
     ctx->surfaces[idx].output_surface = allocOut.bitstreamBuffer;
 
-    av_fifo_generic_write(ctx->unused_surface_queue, &tmp_surface, sizeof(tmp_surface), NULL);
+    av_fifo_write(ctx->unused_surface_queue, &tmp_surface, 1);
 
     return 0;
 }
@@ -1582,18 +1582,18 @@ static av_cold int nvenc_setup_surfaces(AVCodecContext *avctx)
     if (!ctx->surfaces)
         return AVERROR(ENOMEM);
 
-    ctx->timestamp_list = av_fifo_alloc(ctx->nb_surfaces * sizeof(int64_t));
+    ctx->timestamp_list = av_fifo_alloc2(ctx->nb_surfaces, sizeof(int64_t), 0);
     if (!ctx->timestamp_list)
         return AVERROR(ENOMEM);
 
-    ctx->unused_surface_queue = av_fifo_alloc(ctx->nb_surfaces * sizeof(NvencSurface*));
+    ctx->unused_surface_queue = av_fifo_alloc2(ctx->nb_surfaces, sizeof(NvencSurface*), 0);
     if (!ctx->unused_surface_queue)
         return AVERROR(ENOMEM);
 
-    ctx->output_surface_queue = av_fifo_alloc(ctx->nb_surfaces * sizeof(NvencSurface*));
+    ctx->output_surface_queue = av_fifo_alloc2(ctx->nb_surfaces, sizeof(NvencSurface*), 0);
     if (!ctx->output_surface_queue)
         return AVERROR(ENOMEM);
-    ctx->output_surface_ready_queue = av_fifo_alloc(ctx->nb_surfaces * sizeof(NvencSurface*));
+    ctx->output_surface_ready_queue = av_fifo_alloc2(ctx->nb_surfaces, sizeof(NvencSurface*), 0);
     if (!ctx->output_surface_ready_queue)
         return AVERROR(ENOMEM);
 
@@ -1777,11 +1777,11 @@ static NvencSurface *get_free_frame(NvencContext *ctx)
 {
     NvencSurface *tmp_surf;
 
-    if (!(av_fifo_size(ctx->unused_surface_queue) > 0))
+    if (!av_fifo_can_read(ctx->unused_surface_queue))
         // queue empty
         return NULL;
 
-    av_fifo_generic_read(ctx->unused_surface_queue, &tmp_surf, sizeof(tmp_surf), NULL);
+    av_fifo_read(ctx->unused_surface_queue, &tmp_surf, 1);
     return tmp_surf;
 }
 
@@ -2000,14 +2000,14 @@ static void nvenc_codec_specific_pic_params(AVCodecContext *avctx,
 
 static inline void timestamp_queue_enqueue(AVFifoBuffer* queue, int64_t timestamp)
 {
-    av_fifo_generic_write(queue, &timestamp, sizeof(timestamp), NULL);
+    av_fifo_write(queue, &timestamp, 1);
 }
 
 static inline int64_t timestamp_queue_dequeue(AVFifoBuffer* queue)
 {
     int64_t timestamp = AV_NOPTS_VALUE;
-    if (av_fifo_size(queue) > 0)
-        av_fifo_generic_read(queue, &timestamp, sizeof(timestamp), NULL);
+    if (av_fifo_can_read(queue))
+        av_fifo_read(queue, &timestamp, 1);
 
     return timestamp;
 }
@@ -2152,8 +2152,8 @@ static int output_ready(AVCodecContext *avctx, int flush)
     NvencContext *ctx = avctx->priv_data;
     int nb_ready, nb_pending;
 
-    nb_ready   = av_fifo_size(ctx->output_surface_ready_queue)   / sizeof(NvencSurface*);
-    nb_pending = av_fifo_size(ctx->output_surface_queue)         / sizeof(NvencSurface*);
+    nb_ready   = av_fifo_can_read(ctx->output_surface_ready_queue);
+    nb_pending = av_fifo_can_read(ctx->output_surface_queue);
     if (flush)
         return nb_ready > 0;
     return (nb_ready > 0) && (nb_ready + nb_pending >= ctx->async_depth);
@@ -2442,15 +2442,15 @@ static int nvenc_send_frame(AVCodecContext *avctx, const AVFrame *frame)
         return nvenc_print_error(avctx, nv_status, "EncodePicture failed!");
 
     if (frame && frame->buf[0]) {
-        av_fifo_generic_write(ctx->output_surface_queue, &in_surf, sizeof(in_surf), NULL);
+        av_fifo_write(ctx->output_surface_queue, &in_surf, 1);
         timestamp_queue_enqueue(ctx->timestamp_list, frame->pts);
     }
 
     /* all the pending buffers are now ready for output */
     if (nv_status == NV_ENC_SUCCESS) {
-        while (av_fifo_size(ctx->output_surface_queue) > 0) {
-            av_fifo_generic_read(ctx->output_surface_queue, &tmp_out_surf, sizeof(tmp_out_surf), NULL);
-            av_fifo_generic_write(ctx->output_surface_ready_queue, &tmp_out_surf, sizeof(tmp_out_surf), NULL);
+        while (av_fifo_can_read(ctx->output_surface_queue)) {
+            av_fifo_read (ctx->output_surface_queue,       &tmp_out_surf, 1);
+            av_fifo_write(ctx->output_surface_ready_queue, &tmp_out_surf, 1);
         }
     }
 
@@ -2483,7 +2483,7 @@ int ff_nvenc_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
         av_frame_unref(frame);
 
     if (output_ready(avctx, avctx->internal->draining)) {
-        av_fifo_generic_read(ctx->output_surface_ready_queue, &tmp_out_surf, sizeof(tmp_out_surf), NULL);
+        av_fifo_read(ctx->output_surface_ready_queue, &tmp_out_surf, 1);
 
         res = nvenc_push_context(avctx);
         if (res < 0)
@@ -2498,7 +2498,7 @@ int ff_nvenc_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
         if (res)
             return res;
 
-        av_fifo_generic_write(ctx->unused_surface_queue, &tmp_out_surf, sizeof(tmp_out_surf), NULL);
+        av_fifo_write(ctx->unused_surface_queue, &tmp_out_surf, 1);
     } else if (avctx->internal->draining) {
         return AVERROR_EOF;
     } else {
