lavu/fifo: add a flag for automatically growing the FIFO as needed

This will not increase the FIFO beyond 1MB, unless the caller explicitly specifies otherwise.

Anton Khirnov committed 4 years ago

Commit 14429f81 parent 7329b223 files · +52 −4Browse files

Unified · Split

3 files

doc/APIchanges +1 −1
libavutil/fifo.c +37 −2
libavutil/fifo.h +14 −1

@@ -21,7 +21,7 @@ API changes, most recent first: · 20 unmodified lines
21	av_fifo_can_write(), av_fifo_grow2(), av_fifo_drain2(), av_fifo_write(),	21	av_fifo_can_write(), av_fifo_grow2(), av_fifo_drain2(), av_fifo_write(),
22	av_fifo_write_from_cb(), av_fifo_read(), av_fifo_read_to_cb(),	22	av_fifo_write_from_cb(), av_fifo_read(), av_fifo_read_to_cb(),
23	av_fifo_peek(), av_fifo_peek_to_cb(), av_fifo_drain2(), av_fifo_reset2(),	23	av_fifo_peek(), av_fifo_peek_to_cb(), av_fifo_drain2(), av_fifo_reset2(),
24	av_fifo_freep2().	24	av_fifo_freep2(), av_fifo_auto_grow_limit().
25		25
26	2022-01-26 - af94ab7c7c0 - lavu 57.19.100 - tx.h	26	2022-01-26 - af94ab7c7c0 - lavu 57.19.100 - tx.h
27	Add AV_TX_FLOAT_RDFT, AV_TX_DOUBLE_RDFT and AV_TX_INT32_RDFT.	27	Add AV_TX_FLOAT_RDFT, AV_TX_DOUBLE_RDFT and AV_TX_INT32_RDFT.

libavutil/fifo.c+37−2

 #include "common.h"
 #include "fifo.h"
+// by default the FIFO can be auto-grown to 1MB
+#define AUTO_GROW_DEFAULT_BYTES (1024 * 1024)
 struct AVFifo {
     uint8_t *buffer;
     size_t offset_r, offset_w;
     // distinguishes the ambiguous situation offset_r == offset_w
     int    is_empty;
+    unsigned int flags;
+    size_t       auto_grow_limit;
 };
 AVFifo *av_fifo_alloc2(size_t nb_elems, size_t elem_size,
     f->elem_size = elem_size;
     f->is_empty  = 1;
+    f->flags           = flags;
+    f->auto_grow_limit = FFMAX(AUTO_GROW_DEFAULT_BYTES / elem_size, 1);
     return f;
 }
+void av_fifo_auto_grow_limit(AVFifo *f, size_t max_elems)
+{
+    f->auto_grow_limit = max_elems;
+}
 size_t av_fifo_elem_size(const AVFifo *f)
 {
     return f->elem_size;
     return 0;
 }
+static int fifo_check_space(AVFifo *f, size_t to_write)
+{
+    const size_t can_write = av_fifo_can_write(f);
+    const size_t need_grow = to_write > can_write ? to_write - can_write : 0;
+    size_t can_grow;
+    if (!need_grow)
+        return 0;
+    can_grow = f->auto_grow_limit > f->nb_elems ?
+               f->auto_grow_limit - f->nb_elems : 0;
+    if ((f->flags & AV_FIFO_FLAG_AUTO_GROW) && need_grow <= can_grow) {
+        // allocate a bit more than necessary, if we can
+        const size_t inc = (need_grow < can_grow / 2 ) ? need_grow * 2 : can_grow;
+        return av_fifo_grow2(f, inc);
+    }
+    return AVERROR(ENOSPC);
+}
 static int fifo_write_common(AVFifo *f, const uint8_t *buf, size_t *nb_elems,
                              AVFifoCB read_cb, void *opaque)
 {
     size_t offset_w = f->offset_w;
     int         ret = 0;
-    if (to_write > av_fifo_can_write(f))
+    ret = fifo_check_space(f, to_write);
-        return AVERROR(ENOSPC);
+    if (ret < 0)
+        return ret;
     while (to_write > 0) {
         size_t    len = FFMIN(f->nb_elems - offset_w, to_write);

libavutil/fifo.h+14−1

  */
 typedef int AVFifoCB(void *opaque, void *buf, size_t *nb_elems);
+/**
+ * Automatically resize the FIFO on writes, so that the data fits. This
+ * automatic resizing happens up to a limit that can be modified with
+ * av_fifo_auto_grow_limit().
+ */
+#define AV_FIFO_FLAG_AUTO_GROW      (1 << 0)
 /**
  * Allocate and initialize an AVFifo with a given element size.
  *
  * @param elems     initial number of elements that can be stored in the FIFO
  * @param elem_size Size in bytes of a single element. Further operations on
  *                  the returned FIFO will implicitly use this element size.
- * @param flags currently unused, must be 0
+ * @param flags a combination of AV_FIFO_FLAG_*
  *
  * @return newly-allocated AVFifo on success, a negative error code on failure
  */
  */
 size_t av_fifo_elem_size(const AVFifo *f);
+/**
+ * Set the maximum size (in elements) to which the FIFO can be resized
+ * automatically. Has no effect unless AV_FIFO_FLAG_AUTO_GROW is used.
+ */
+void av_fifo_auto_grow_limit(AVFifo *f, size_t max_elems);
 /**
  * @return number of elements available for reading from the given FIFO.
  */

lavu/fifo: add a flag for automatically growing the FIFO as needed

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code