Display and control your Android device
Introduce bytebuf util
Romain Vimont20d41fdd7e23
diff --git a/app/meson.build b/app/meson.buildindex 2ea3b317..8be917e9 100644--- a/app/meson.build+++ b/app/meson.build@@ -30,6 +30,7 @@ src = ['src/version.c','src/video_buffer.c','src/util/acksync.c',+ 'src/util/bytebuf.c','src/util/file.c','src/util/intmap.c','src/util/intr.c',@@ -254,6 +255,10 @@ if get_option('buildtype') == 'debug'['test_binary', ['tests/test_binary.c',]],+ ['test_bytebuf', [+ 'tests/test_bytebuf.c',+ 'src/util/bytebuf.c',+ ]],['test_cbuf', ['tests/test_cbuf.c',]],diff --git a/app/src/util/bytebuf.c b/app/src/util/bytebuf.cnew file mode 100644index 00000000..61814376--- /dev/null+++ b/app/src/util/bytebuf.c@@ -0,0 +1,75 @@+#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);+ 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(len <= sc_bytebuf_read_available(buf));+ 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(len <= sc_bytebuf_read_available(buf));+ 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);+ assert(len <= sc_bytebuf_write_available(buf));++ size_t right_len = buf->alloc_size - 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);+ }++ buf->head = (buf->head + len) % buf->alloc_size;+}diff --git a/app/src/util/bytebuf.h b/app/src/util/bytebuf.hnew file mode 100644index 00000000..fcebc2d3--- /dev/null+++ b/app/src/util/bytebuf.h@@ -0,0 +1,90 @@+#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; // writter cursor+ size_t tail; // reader cursor+ // empty: tail == head+ // full: ((tail + 1) % alloc_size) == 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 <= sc_bytebuf_read_available() (it is an+ * error to attempt to read more bytes than available).+ *+ * This function is guaranteed not to write to buf->head.+ */+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 <= sc_bytebuf_read_available() (it is an+ * error to attempt to skip more bytes than available).+ *+ * This function is guaranteed not to write to buf->head.+ *+ * It is equivalent to call sc_bytebuf_read() to some array and discard the+ * array (but this function is 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 caller must check that len <= sc_bytebuf_write_available() (it is an+ * error to write more bytes than the remaining available space).+ *+ * This function is guaranteed not to write to buf->tail.+ */+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_available(struct sc_bytebuf *buf) {+ return (buf->alloc_size + buf->head - buf->tail) % buf->alloc_size;+}++/**+ * Return the number of bytes which can be written+ *+ * It is an error to write more bytes than available.+ */+static inline size_t+sc_bytebuf_write_available(struct sc_bytebuf *buf) {+ return (buf->alloc_size + buf->tail - buf->head - 1) % buf->alloc_size;+}++/**+ * Return the actual capacity of the buffer (read available + write available)+ */+static inline size_t+sc_bytebuf_capacity(struct sc_bytebuf *buf) {+ return buf->alloc_size - 1;+}++void+sc_bytebuf_destroy(struct sc_bytebuf *buf);++#endifdiff --git a/app/tests/test_bytebuf.c b/app/tests/test_bytebuf.cnew file mode 100644index 00000000..fbb33765--- /dev/null+++ b/app/tests/test_bytebuf.c@@ -0,0 +1,82 @@+#include "common.h"++#include <assert.h>+#include <string.h>++#include "util/bytebuf.h"++void test_bytebuf_simple(void) {+ struct sc_bytebuf buf;+ uint8_t data[20];++ bool ok = sc_bytebuf_init(&buf, 20);+ assert(ok);++ sc_bytebuf_write(&buf, (uint8_t *) "hello", sizeof("hello") - 1);+ assert(sc_bytebuf_read_available(&buf) == 5);++ sc_bytebuf_read(&buf, data, 4);+ assert(!strncmp((char *) data, "hell", 4));++ sc_bytebuf_write(&buf, (uint8_t *) " world", sizeof(" world") - 1);+ assert(sc_bytebuf_read_available(&buf) == 7);++ sc_bytebuf_write(&buf, (uint8_t *) "!", 1);+ assert(sc_bytebuf_read_available(&buf) == 8);++ sc_bytebuf_read(&buf, &data[4], 8);+ assert(sc_bytebuf_read_available(&buf) == 0);++ data[12] = '\0';+ assert(!strcmp((char *) data, "hello world!"));+ assert(sc_bytebuf_read_available(&buf) == 0);++ sc_bytebuf_destroy(&buf);+}++void test_bytebuf_boundaries(void) {+ struct sc_bytebuf buf;+ uint8_t data[20];++ bool ok = sc_bytebuf_init(&buf, 20);+ assert(ok);++ sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);+ assert(sc_bytebuf_read_available(&buf) == 6);++ sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);+ assert(sc_bytebuf_read_available(&buf) == 12);++ sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);+ assert(sc_bytebuf_read_available(&buf) == 18);++ sc_bytebuf_read(&buf, data, 9);+ assert(!strncmp((char *) data, "hello hel", 9));+ assert(sc_bytebuf_read_available(&buf) == 9);++ sc_bytebuf_write(&buf, (uint8_t *) "world", sizeof("world") - 1);+ assert(sc_bytebuf_read_available(&buf) == 14);++ sc_bytebuf_write(&buf, (uint8_t *) "!", 1);+ assert(sc_bytebuf_read_available(&buf) == 15);++ sc_bytebuf_skip(&buf, 3);+ assert(sc_bytebuf_read_available(&buf) == 12);++ sc_bytebuf_read(&buf, data, 12);+ data[12] = '\0';+ assert(!strcmp((char *) data, "hello world!"));+ assert(sc_bytebuf_read_available(&buf) == 0);++ sc_bytebuf_destroy(&buf);+}++int main(int argc, char *argv[]) {+ (void) argc;+ (void) argv;++ test_bytebuf_simple();+ test_bytebuf_boundaries();++ return 0;+}