Introduce bytebuf util

Add a ring-buffer for bytes. It will be useful for buffering audio.

app/src/util/bytebuf.c

@@ -0,0 +1,88 @@
+#include "bytebuf.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "util/log.h"
+
+bool
+sc_bytebuf_init(struct sc_bytebuf *buf, size_t alloc_size) {
+    assert(alloc_size);
+    // sufficient, but use more for alignment.
+    buf->data = malloc(alloc_size);
+    if (!buf->data) {
+        LOG_OOM();
+        return false;
+    }
+
+    buf->alloc_size = alloc_size;
+    buf->head = 0;
+    buf->tail = 0;
+
+    return true;
+}
+
+void
+sc_bytebuf_destroy(struct sc_bytebuf *buf) {
+    free(buf->data);
+}
+
+void
+sc_bytebuf_read(struct sc_bytebuf *buf, uint8_t *to, size_t len) {
+    assert(len);
+    assert(sc_bytebuf_read_remaining(buf) >= len);
+    assert(buf->tail != buf->head); // the buffer could not be empty
+
+    size_t right_limit = buf->tail < buf->head ? buf->head : buf->alloc_size;
+    size_t right_len = right_limit - buf->tail;
+    if (len < right_len) {
+        right_len = len;
+    }
+    memcpy(to, buf->data + buf->tail, right_len);
+
+    if (len > right_len) {
+        memcpy(to + right_len, buf->data, len - right_len);
+    }
+
+    buf->tail = (buf->tail + len) % buf->alloc_size;
+}
+
+void
+sc_bytebuf_skip(struct sc_bytebuf *buf, size_t len) {
+    assert(len);
+    assert(sc_bytebuf_read_remaining(buf) >= len);
+    assert(buf->tail != buf->head); // the buffer could not be empty
+
+    buf->tail = (buf->tail + len) % buf->alloc_size;
+}
+
+void
+sc_bytebuf_write(struct sc_bytebuf *buf, const uint8_t *from, size_t len) {
+    assert(len);
+
+    size_t max_len = buf->alloc_size - 1;
+    if (len >= max_len) {
+        // Copy only the right-most bytes
+        memcpy(buf->data, from + len - max_len, max_len);
+        buf->tail = 0;
+        buf->head = max_len;
+        return;
+    }
+
+    size_t right_limit = buf->head < buf->tail ? buf->tail : buf->alloc_size;
+    size_t right_len = right_limit - buf->head;
+    if (len < right_len) {
+        right_len = len;
+    }
+    memcpy(buf->data + buf->head, from, right_len);
+    if (len > right_len) {
+        memcpy(buf->data, from + right_len, len - right_len);
+    }
+
+    size_t empty_space = sc_bytebuf_write_remaining(buf);
+    if (len > empty_space) {
+        buf->tail = (buf->tail + len - empty_space) % buf->alloc_size;
+    }
+    buf->head = (buf->head + len) % buf->alloc_size;
+}

app/src/util/bytebuf.h

@@ -0,0 +1,78 @@
+#ifndef SC_BYTEBUF_H
+#define SC_BYTEBUF_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+
+struct sc_bytebuf {
+    uint8_t *data;
+    // The actual capacity is (allocated - 1) so that head == tail is
+    // non-ambiguous
+    size_t alloc_size;
+    size_t head;
+    size_t tail;
+    // empty: tail == head
+    // full: (tail + 1) % allocated == head
+};
+
+bool
+sc_bytebuf_init(struct sc_bytebuf *buf, size_t alloc_size);
+
+/**
+ * Copy from the bytebuf to a user-provided array
+ *
+ * The caller must check that len <= buf->len (it is an error to attempt to read
+ * more bytes than available).
+ */
+void
+sc_bytebuf_read(struct sc_bytebuf *buf, uint8_t *to, size_t len);
+
+/**
+ * Drop len bytes from the buffer
+ *
+ * The caller must check that len <= buf->len (it is an error to attempt to skip
+ * more bytes than available).
+ *
+ * It is equivalent to call sc_bytebuf_read() to some array and discard the
+ * array (but more efficient since there is no copy).
+ */
+void
+sc_bytebuf_skip(struct sc_bytebuf *buf, size_t len);
+
+/**
+ * Copy the user-provided array to the bytebuf
+ *
+ * The length of the input array is not restricted:
+ * if len >= sc_bytebuf_write_remaining(buf), then the excessive input bytes
+ * will overwrite the oldest bytes in the buffer.
+ */
+void
+sc_bytebuf_write(struct sc_bytebuf *buf, const uint8_t *from, size_t len);
+
+/**
+ * Return the number of bytes which can be read
+ *
+ * It is an error to read more bytes than available.
+ */
+static inline size_t
+sc_bytebuf_read_remaining(struct sc_bytebuf *buf) {
+    return (buf->alloc_size + buf->head - buf->tail) % buf->alloc_size;
+}
+
+/**
+ * Return the number of bytes which can be written without overwriting
+ *
+ * It is not an error to write more bytes than the available space, but this
+ * would overwrite the oldest bytes in the buffer.
+ */
+static inline size_t
+sc_bytebuf_write_remaining(struct sc_bytebuf *buf) {
+    return (buf->alloc_size + buf->tail - buf->head - 1) % buf->alloc_size;
+}
+
+void
+sc_bytebuf_destroy(struct sc_bytebuf *buf);
+
+#endif