diff --git a/doc/APIchanges b/doc/APIchanges
index f2769d4165..0b179c30e5 100644
--- a/doc/APIchanges
+++ b/doc/APIchanges
@@ -19,7 +19,7 @@ API changes, most recent first:
   Operations on FIFOs created with this function on these elements
   rather than bytes.
   Add av_fifo_elem_size(), av_fifo_can_read(), av_fifo_can_write(),
-  av_fifo_grow2(), av_fifo_drain2().
+  av_fifo_grow2(), av_fifo_drain2(), av_fifo_write(), av_fifo_write_from_cb().
 
 2022-01-xx - xxxxxxxxxx - lavu fifo.h
   Access to all AVFifoBuffer members is deprecated. The struct will
diff --git a/libavutil/fifo.c b/libavutil/fifo.c
index e9f439e219..1d94fff457 100644
--- a/libavutil/fifo.c
+++ b/libavutil/fifo.c
@@ -207,6 +207,64 @@ void av_fifo_drain2(AVFifoBuffer *f, size_t size)
 #endif
 }
 
+static int fifo_write_common(AVFifoBuffer *f, const uint8_t *buf, size_t *nb_elems,
+                             AVFifoCB read_cb, void *opaque)
+{
+    FifoBuffer  *fb = (FifoBuffer*)f;
+    size_t to_write = *nb_elems;
+    size_t offset_w = fb->offset_w;
+    int         ret = 0;
+#if FF_API_FIFO_PUBLIC
+    uint32_t wndx= f->wndx;
+#endif
+
+    if (to_write > av_fifo_can_write(f))
+        return AVERROR(ENOSPC);
+
+    do {
+        size_t    len = FFMIN(fb->nb_elems - offset_w, to_write);
+        uint8_t *wptr = f->buffer + offset_w * fb->elem_size;
+
+        if (read_cb) {
+            ret = read_cb(opaque, wptr, &len);
+            if (ret < 0 || len == 0)
+                break;
+        } else {
+            memcpy(wptr, buf, len * fb->elem_size);
+            buf += len * fb->elem_size;
+        }
+        offset_w += len;
+        if (offset_w >= fb->nb_elems)
+            offset_w = 0;
+#if FF_API_FIFO_PUBLIC
+        wndx    += len;
+#endif
+        to_write    -= len;
+    } while (to_write > 0);
+#if FF_API_FIFO_PUBLIC
+    f->wndx= wndx;
+    f->wptr= f->buffer + offset_w * fb->elem_size;
+#endif
+    fb->offset_w = offset_w;
+
+    if (*nb_elems - to_write > 0)
+        fb->is_empty = 0;
+    *nb_elems -= to_write;
+
+    return ret;
+}
+
+int av_fifo_write(AVFifoBuffer *f, const void *buf, size_t nb_elems)
+{
+    return fifo_write_common(f, buf, &nb_elems, NULL, NULL);
+}
+
+int av_fifo_write_from_cb(AVFifoBuffer *f, AVFifoCB read_cb,
+                          void *opaque, size_t *nb_elems)
+{
+    return fifo_write_common(f, NULL, nb_elems, read_cb, opaque);
+}
+
 int av_fifo_realloc2(AVFifoBuffer *f, unsigned int new_size)
 {
     FifoBuffer *fb = (FifoBuffer*)f;
diff --git a/libavutil/fifo.h b/libavutil/fifo.h
index d593304edb..ac1245ff39 100644
--- a/libavutil/fifo.h
+++ b/libavutil/fifo.h
@@ -44,6 +44,24 @@ typedef struct AVFifoBuffer
 #endif
 AVFifoBuffer;
 
+/**
+ * Callback for writing or reading from a FIFO, passed to (and invoked from) the
+ * av_fifo_*_cb() functions. It may be invoked multiple times from a single
+ * av_fifo_*_cb() call and may process less data than the maximum size indicated
+ * by nb_elems.
+ *
+ * @param opaque the opaque pointer provided to the av_fifo_*_cb() function
+ * @param buf the buffer for reading or writing the data, depending on which
+ *            av_fifo_*_cb function is called
+ * @param nb_elems On entry contains the maximum number of elements that can be
+ *                 read from / written into buf. On success, the callback should
+ *                 update it to contain the number of elements actually written.
+ *
+ * @return 0 on success, a negative error code on failure (will be returned from
+ *         the invoking av_fifo_*_cb() function)
+ */
+typedef int AVFifoCB(void *opaque, void *buf, size_t *nb_elems);
+
 /**
  * Initialize an AVFifoBuffer.
  * @param size of FIFO
@@ -143,6 +161,34 @@ size_t av_fifo_can_write(const AVFifoBuffer *f);
  */
 int av_fifo_grow2(AVFifoBuffer *f, size_t inc);
 
+/**
+ * Write data into a FIFO.
+ *
+ * @param f the FIFO buffer
+ * @param buf Data to be written. nb_elems * av_fifo_elem_size(f) bytes will be
+ *            read from buf.
+ * @param nb_elems number of elements to write into FIFO
+ *
+ * @return a non-negative number on success, a negative error code on failure
+ */
+int av_fifo_write(AVFifoBuffer *f, const void *buf, size_t nb_elems);
+
+/**
+ * Write data from a user-provided callback into a FIFO.
+ *
+ * @param f the FIFO buffer
+ * @param read_cb Callback supplying the data to the FIFO. May be called
+ *                multiple times.
+ * @param opaque opaque user data to be provided to read_cb
+ * @param nb_elems Should point to the maximum number of elements that can be
+ *                 written. Will be updated to contain the number of elements
+ *                 actually written.
+ *
+ * @return non-negative number on success, a negative error code on failure
+ */
+int av_fifo_write_from_cb(AVFifoBuffer *f, AVFifoCB read_cb,
+                          void *opaque, size_t *nb_elems);
+
 /**
  * Discard the specified amount of data from an AVFifoBuffer.
  * @param size number of elements to discard, MUST NOT be larger than
