Added signed int support to bitstream

Author: bjackson312006

middleware/include/bitstream.h

@@ -5,8 +5,11 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdbool.h>
+#include <stddef.h>
 #include <math.h>
 
+#define STATIC_ASSERT _Static_assert // Compile-time assertion (C11 thing)
+
 typedef struct {
 	uint8_t *data; // The bitstream data, stored as bytes
 	size_t bytes; // The number of bytes in the bitstream
@@ -24,21 +27,33 @@ void bitstream_init(bitstream_t *bitstream, uint8_t *data, size_t bytes);
 
 /**
  * @brief Adds data to a bitstream. The data is added to the end of the bitstream.
- * @param *bitstream The bitstream to add data to.
- * @param value The data to add to the bitstream.
+ * @param *bitstream The bitstream to add data to. Must be of type: bitstream_t.
+ * @param value The data to add to the bitstream. Must be of type: uint8_t, uint16_t, uint32_t, int8_t, int16_t, or int32_t.
  * @param num_bits The length of the data in bits.
  * @return Returns 0 if successful, -1 if there is insufficient space in the bitstream, and 1 if overflow occurs.
  */
-int bitstream_add(bitstream_t *bitstream, uint32_t value, size_t num_bits);
+#define bitstream_add(bitstream, value, num_bits)                                                                                     \
+	/* Check bitstream parameter type */                                                                                          \
+	STATIC_ASSERT(                                                                                                                \
+		__builtin_types_compatible_p(typeof(bitstream),                                                                       \
+					     bitstream_t *),                                                                          \
+		"First argument of bitstream_add() must be a pointer to bitstream_t."), /* Check num_bits parameter type */           \
+		STATIC_ASSERT(                                                                                                        \
+			__builtin_types_compatible_p(typeof(num_bits),                                                                \
+						     size_t),                                                                         \
+			"Third argument of bitstream_add() must be size_t."), /* Check value type and call the necessary function. */ \
+		_Generic((value),                                                                                                     \
+		uint8_t: bitstream_add_uint,                                                                                          \
+		uint16_t: bitstream_add_uint,                                                                                         \
+		uint32_t: bitstream_add_uint,                                                                                         \
+		int8_t: bitstream_add_int,                                                                                            \
+		int16_t: bitstream_add_int,                                                                                           \
+		int32_t: bitstream_add_int default: (void (*)(                                                                        \
+			void))_invalid_type_error)(bitstream, value, num_bits)
 
-/**
- * @brief Reads info from the bitstream.
- * @param *bitstream The bitstream to read from.
- * @param start_bit The bit to start reading from.
- * @param num_bits The amount of bits to read. The maximum is 32 bits, and (start_bit + num_bits) must be less than the total number of bits in the bitstream.
- * @return Returns 1 if failed, and 0 if successful.
- */
-uint32_t bitstream_read(bitstream_t *bitstream, uint32_t start_bit,
-			size_t num_bits);
+/* Internal functions (not meant to be called directly). */
+/* Used by the bitstream_add() macro depending on the input data type. */
+int bitstream_add_uint(bitstream_t *bitstream, uint32_t value, size_t num_bits);
+int bitstream_add_int(bitstream_t *bitstream, int32_t value, size_t num_bits);
 
 #endif // BITSTREAM_H

middleware/src/bitstream.c

@@ -9,7 +9,9 @@ void bitstream_init(bitstream_t *bitstream, uint8_t *data, size_t bytes)
 	memset(bitstream->data, 0, bytes); // Zero out the buffer
 }
 
-int bitstream_add(bitstream_t *bitstream, uint32_t value, size_t num_bits)
+/* Adds an unsigned int to a bitstream. */
+static int bitstream_add_uint(bitstream_t *bitstream, uint32_t value,
+			      size_t num_bits)
 {
 	if (bitstream->total_bits + num_bits > (bitstream->bytes * 8)) {
 		return -1; // Error: not enough space in the bitstream
@@ -18,9 +20,8 @@ int bitstream_add(bitstream_t *bitstream, uint32_t value, size_t num_bits)
 	bool overflow = false;
 	if (value >= pow(2, num_bits)) {
 		overflow =
-			true; // Error: value is too large for the number of bits, so set overflow to true.
-		value = pow(2, num_bits) -
-			1; // Cap value to the maximum value that can be stored in the number of bits.
+			true; // Error: value is too large for the number of bits
+		value = pow(2, num_bits) - 1; // Cap value to maximum
 	}
 
 	for (int i = 0; i < num_bits; ++i) {
@@ -34,27 +35,53 @@ int bitstream_add(bitstream_t *bitstream, uint32_t value, size_t num_bits)
 
 	if (overflow) {
 		bitstream->overflow = true;
-		return 1; // Overflow occurred
+		return 1; // Error: Overflow occurred
 	}
 
 	return 0; // Success
 }
 
-uint32_t bitstream_read(bitstream_t *bitstream, uint32_t start_bit,
-			size_t num_bits)
+/* Adds a signed int to a bitstream. */
+static int bitstream_add_int(bitstream_t *bitstream, int32_t value,
+			     size_t num_bits)
 {
-	uint32_t result = 0;
+	if (bitstream->total_bits + num_bits > (bitstream->bytes * 8)) {
+		return -1; // Error: not enough space in the bitstream
+	}
+
+	bool overflow = false;
+	/* For a signed int, 'value' must be in between -2^(num_bits - 1) and 2^(num_bits-1) - 1. */
+	/* For example, an 6-bit input value must be in-between -32 and 31. */
+	int32_t max_value = (1LL << (num_bits - 1)) - 1;
+	int32_t min_value = -(1LL << (num_bits - 1));
 
-	if (start_bit + num_bits > bitstream->total_bits) {
-		return -1; // Error: trying to read beyond bit length
+	if (value > max_value || value < min_value) {
+		overflow = true; // Error: value is too large or too small
+
+		/* Cap value to maximum or minimum */
+		if (value > max_value) {
+			value = max_value;
+		} else {
+			value = min_value;
+		}
 	}
 
+	/* Convert to unsigned representation for bit manipulation */
+	uint32_t unsigned_value = (uint32_t)value;
+
 	for (int i = 0; i < num_bits; ++i) {
-		if (bitstream->data[(start_bit + i) / 8] &
-		    (1 << (7 - ((start_bit + i) % 8)))) {
-			result |= (1 << (num_bits - 1 - i));
+		if (unsigned_value & (1u << (num_bits - 1 - i))) {
+			bitstream->data[(bitstream->total_bits + i) / 8] |=
+				(1 << (7 - ((bitstream->total_bits + i) % 8)));
 		}
 	}
 
-	return result;
+	bitstream->total_bits += num_bits;
+
+	if (overflow) {
+		bitstream->overflow = true;
+		return 1; // Error: Overflow occurred
+	}
+
+	return 0; // Success
 }