Change bit_reader to construct with num_bits

Change flush and checksum to use number of bits instead of bytes

Author: KredeGC

README.md

@@ -254,10 +254,10 @@ uint32_t value = 27; // We can choose any value below 2^5. Otherwise we need mor
 writer.serialize_bits(value, 5);
 
 // Flush the writer's remaining state into the buffer
-uint32_t num_bytes = writer.flush();
+uint32_t num_bits = writer.flush();
 
 // Create a reader, referencing the buffer and bytes written
-bit_reader reader(buffer, num_bytes);
+bit_reader reader(buffer, num_bits);
 
 // Read the value back
 uint32_t out_value; // We don't have to initialize it yet
@@ -275,10 +275,10 @@ int32_t value = -45; // We can choose any value within the range below
 writer.serialize<int32_t>(value, -90, 40); // A lower and upper bound which the value will be quantized between
 
 // Flush the writer's remaining state into the buffer
-uint32_t num_bytes = writer.flush();
+uint32_t num_bits = writer.flush();
 
 // Create a reader by moving and invalidating the writer
-bit_reader reader(buffer, num_bytes);
+bit_reader reader(buffer, num_bits);
 
 // Read the value back
 int32_t out_value; // We don't have to initialize it yet
@@ -296,10 +296,10 @@ const char* value = "Hello world!";
 writer.serialize<const char*>(value, 32U); // The second argument is the maximum size we expect the string to be
 
 // Flush the writer's remaining state into the buffer
-uint32_t num_bytes = writer.flush();
+uint32_t num_bits = writer.flush();
 
 // Create a reader by moving and invalidating the writer
-bit_reader reader(buffer, num_bytes);
+bit_reader reader(buffer, num_bits);
 
 // Read the value back
 char out_value[32]; // Set the size to the max size
@@ -317,10 +317,10 @@ std::string value = "Hello world!";
 writer.serialize<std::string>(value, 32U); // The second argument is the maximum size we expect the string to be
 
 // Flush the writer's remaining state into the buffer
-uint32_t num_bytes = writer.flush();
+uint32_t num_bits = writer.flush();
 
 // Create a reader by moving and invalidating the writer
-bit_reader reader(buffer, num_bytes);
+bit_reader reader(buffer, num_bits);
 
 // Read the value back
 std::string out_value; // The string will be resized if the output doesn't fit
@@ -339,10 +339,10 @@ float value = 1.2345678f;
 writer.serialize<bounded_range>(range, value);
 
 // Flush the writer's remaining state into the buffer
-uint32_t num_bytes = writer.flush();
+uint32_t num_bits = writer.flush();
 
 // Create a reader by moving and invalidating the writer
-bit_reader reader(buffer, num_bytes);
+bit_reader reader(buffer, num_bits);
 
 // Read the value back
 float out_value;

include/bitstream/stream/bit_reader.h

@@ -36,28 +36,28 @@ namespace bitstream
 			m_WordIndex(0) {}
 
 		/**
-		 * @brief Construct a reader pointing to the given byte array with @p num_bytes size
+		 * @brief Construct a reader pointing to the given byte array with @p num_bits
 		 * @param bytes The byte array to read from. Should be 4-byte aligned if possible. The size of the array must be a multiple of 4
-		 * @param num_bytes The maximum number of bytes that we can read
+		 * @param num_bits The maximum number of bits that we can read
 		*/
-		explicit bit_reader(const void* bytes, uint32_t num_bytes) noexcept :
+		explicit bit_reader(const void* bytes, uint32_t num_bits) noexcept :
 			m_Buffer(static_cast<const uint32_t*>(bytes)),
 			m_NumBitsRead(0),
-			m_TotalBits(num_bytes * 8),
+			m_TotalBits(num_bits),
 			m_Scratch(0),
 			m_ScratchBits(0),
 			m_WordIndex(0) {}
 
 		/**
 		 * @brief Construct a reader pointing to the given @p buffer
 		 * @param buffer The buffer to read from
-		 * @param num_bytes The maximum number of bytes that we can read
+		 * @param num_bits The maximum number of bits that we can read
 		*/
 		template<size_t Size>
-		explicit bit_reader(byte_buffer<Size>& buffer, uint32_t num_bytes) noexcept :
+		explicit bit_reader(byte_buffer<Size>& buffer, uint32_t num_bits) noexcept :
 			m_Buffer(reinterpret_cast<uint32_t*>(buffer.Bytes)),
 			m_NumBitsRead(0),
-			m_TotalBits(num_bytes * 8),
+			m_TotalBits(num_bits),
 			m_Scratch(0),
 			m_ScratchBits(0),
 			m_WordIndex(0) {}
@@ -113,6 +113,12 @@ namespace bitstream
 		*/
 		uint32_t get_num_bits_serialized() const noexcept { return m_NumBitsRead; }
 
+		/**
+		 * @brief Returns the number of bytes which have been read from the buffer
+		 * @return The number of bytes which have been read
+		*/
+		uint32_t get_num_bytes_serialized() const noexcept { return m_NumBitsRead > 0U ? ((m_NumBitsRead - 1U) / 8U + 1U) : 0U; }
+
 		/**
 		 * @brief Returns whether the @p num_bits be read from the buffer
 		 * @param num_bits The number of bits to test

include/bitstream/stream/bit_writer.h

@@ -42,22 +42,16 @@ namespace bitstream
 
 		/**
 		 * @brief Construct a writer pointing to the given byte array with @p num_bytes size
-		 * @param bytes The byte array to write to. Should be 4-byte aligned if possible
-		 * @param num_bytes The number of bytes in the array. Must be a multiple of 4
+		 * @param bytes The byte array to write to. Must be 4-byte aligned and the size must be a multiple of 4
+		 * @param num_bytes The number of bytes in the array
 		*/
 		explicit bit_writer(void* bytes, uint32_t num_bytes) noexcept :
 			m_Buffer(static_cast<uint32_t*>(bytes)),
 			m_NumBitsWritten(0),
 			m_TotalBits(num_bytes * 8),
 			m_Scratch(0),
 			m_ScratchBits(0),
-			m_WordIndex(0)
-		{
-#ifdef BS_DEBUG_BREAK
-			if (num_bytes % 4 != 0)
-                BS_BREAKPOINT();
-#endif
-		}
+			m_WordIndex(0) {}
 
 		/**
 		 * @brief Construct a writer pointing to the given @p buffer
@@ -123,6 +117,12 @@ namespace bitstream
 		*/
 		uint32_t get_num_bits_serialized() const noexcept { return m_NumBitsWritten; }
 
+		/**
+		 * @brief Returns the number of bytes which have been written to the buffer
+		 * @return The number of bytes which have been written
+		*/
+		uint32_t get_num_bytes_serialized() const noexcept { return m_NumBitsWritten > 0U ? ((m_NumBitsWritten - 1U) / 8U + 1U) : 0U; }
+
 		/**
 		 * @brief Returns whether the @p num_bits can fit in the buffer
 		 * @param num_bits The number of bits to test
@@ -160,10 +160,7 @@ namespace bitstream
 				m_WordIndex++;
 			}
 
-			if (m_NumBitsWritten > 0U)
-				return (m_NumBitsWritten - 1U) / 8U + 1U;
-			else
-				return 0U;
+			return m_NumBitsWritten;
 		}
 
 		/**
@@ -190,18 +187,18 @@ namespace bitstream
 		*/
 		uint32_t serialize_checksum(uint32_t protocol_version) noexcept
 		{
-			uint32_t num_bytes = flush();
+			uint32_t num_bits = flush();
 
 			// Copy protocol version to buffer
 			*m_Buffer = protocol_version;
 
 			// Generate checksum of version + data
-			uint32_t checksum = utility::crc_uint32(reinterpret_cast<uint8_t*>(m_Buffer), num_bytes);
+			uint32_t checksum = utility::crc_uint32(reinterpret_cast<uint8_t*>(m_Buffer), get_num_bytes_serialized());
 
 			// Put checksum at beginning
 			*m_Buffer = checksum;
 
-			return num_bytes;
+			return num_bits;
 		}
 
 		/**

src/test/examples_test.cpp

@@ -23,12 +23,12 @@ namespace bitstream::test::example
         BS_TEST_ASSERT(writer.serialize_bits(value, 5));
 
         // Flush the writer's remaining state into the buffer
-        uint32_t num_bytes = writer.flush();
+        uint32_t num_bits = writer.flush();
 
-		BS_TEST_ASSERT_OPERATION(num_bytes, == , 1);
+		BS_TEST_ASSERT_OPERATION(num_bits, == , 5);
 
         // Create a reader, referencing the buffer and bytes written
-        bit_reader reader(buffer, num_bytes);
+        bit_reader reader(buffer, num_bits);
 
         // Read the value back
         uint32_t out_value; // We don't have to initialize it yet
@@ -49,12 +49,12 @@ namespace bitstream::test::example
         BS_TEST_ASSERT(writer.serialize<int32_t>(value, -90, 40)); // A lower and upper bound which the value will be quantized between
 
         // Flush the writer's remaining state into the buffer
-        uint32_t num_bytes = writer.flush();
+        uint32_t num_bits = writer.flush();
 
-		BS_TEST_ASSERT_OPERATION(num_bytes, <= , 4);
+		BS_TEST_ASSERT_OPERATION(num_bits, <= , 32);
 
         // Create a reader by moving and invalidating the writer
-        bit_reader reader(buffer, num_bytes);
+        bit_reader reader(buffer, num_bits);
 
         // Read the value back
         int32_t out_value; // We don't have to initialize it yet
@@ -75,10 +75,10 @@ namespace bitstream::test::example
         BS_TEST_ASSERT(writer.serialize<const char*>(value, 32U)); // The second argument is the maximum size we expect the string to be
 
         // Flush the writer's remaining state into the buffer
-        uint32_t num_bytes = writer.flush();
+        uint32_t num_bits = writer.flush();
 
         // Create a reader by moving and invalidating the writer
-        bit_reader reader(buffer, num_bytes);
+        bit_reader reader(buffer, num_bits);
 
         // Read the value back
         char out_value[32]; // Set the size to the max size
@@ -99,10 +99,10 @@ namespace bitstream::test::example
         BS_TEST_ASSERT(writer.serialize<std::string>(value, 32U)); // The second argument is the maximum size we expect the string to be
 
         // Flush the writer's remaining state into the buffer
-        uint32_t num_bytes = writer.flush();
+        uint32_t num_bits = writer.flush();
 
         // Create a reader by moving and invalidating the writer
-        bit_reader reader(buffer, num_bytes);
+        bit_reader reader(buffer, num_bits);
 
         // Read the value back
         std::string out_value; // The string will be resized if the output doesn't fit
@@ -124,12 +124,12 @@ namespace bitstream::test::example
         writer.serialize<bounded_range>(range, value);
 
         // Flush the writer's remaining state into the buffer
-        uint32_t num_bytes = writer.flush();
+        uint32_t num_bits = writer.flush();
 
-		BS_TEST_ASSERT_OPERATION(num_bytes, <= , 4);
+		BS_TEST_ASSERT_OPERATION(num_bits, <= , 32);
 
         // Create a reader by moving and invalidating the writer
-        bit_reader reader(buffer, num_bytes);
+        bit_reader reader(buffer, num_bits);
 
         // Read the value back
         float out_value;

src/test/serialize_array_traits.cpp

@@ -31,13 +31,13 @@ namespace bitstream::test::traits
 		bit_writer writer(buffer);
 
 		BS_TEST_ASSERT(writer.serialize<trait>(values_in, 6, compare)); // Use bounded_int for writing
-		uint32_t num_bytes = writer.flush();
+		uint32_t num_bits = writer.flush();
 
-		BS_TEST_ASSERT_OPERATION(num_bytes, == , 6);
+		BS_TEST_ASSERT_OPERATION(writer.get_num_bytes_serialized(), == , 6);
 
 
 		uint32_t values_out[6];
-		bit_reader reader(buffer, num_bytes);
+		bit_reader reader(buffer, num_bits);
 
 		BS_TEST_ASSERT(reader.serialize<array_subset<uint32_t>>(values_out, 6, compare, 0U, 2048U)); // Use min, max arguments for reading
 

src/test/serialize_bool_test.cpp

@@ -18,13 +18,13 @@ namespace bitstream::test::traits
 		bit_writer writer(buffer);
 
 		BS_TEST_ASSERT(writer.serialize<bool>(value));
-		uint32_t num_bytes = writer.flush();
+		uint32_t num_bits = writer.flush();
 
-		BS_TEST_ASSERT_OPERATION(num_bytes, == , 1);
+		BS_TEST_ASSERT_OPERATION(num_bits, == , 1);
 
 		// Read the bool back and validate
 		bool out_value;
-		bit_reader reader(buffer, num_bytes);
+		bit_reader reader(buffer, num_bits);
 
 		BS_TEST_ASSERT(reader.serialize<bool>(out_value));
 
@@ -43,14 +43,14 @@ namespace bitstream::test::traits
 
 		BS_TEST_ASSERT(writer.serialize_bits(padding, 5U));
 		BS_TEST_ASSERT(writer.serialize<bool>(value));
-		uint32_t num_bytes = writer.flush();
+		uint32_t num_bits = writer.flush();
 
-		BS_TEST_ASSERT_OPERATION(num_bytes, == , 1);
+		BS_TEST_ASSERT_OPERATION(num_bits, == , 6);
 
 		// Read the bool back and validate
 		uint32_t out_padding;
 		bool out_value;
-		bit_reader reader(buffer, num_bytes);
+		bit_reader reader(buffer, num_bits);
 
 		BS_TEST_ASSERT(reader.serialize_bits(out_padding, 5U));
 		BS_TEST_ASSERT(reader.serialize<bool>(out_value));

src/test/serialize_deduction_test.cpp

@@ -22,12 +22,12 @@ namespace bitstream::test::deduction
         BS_TEST_ASSERT(writer.serialize(value, -90, 40)); // A lower and upper bound which the value will be quantized between
 
         // Flush the writer's remaining state into the buffer
-        uint32_t num_bytes = writer.flush();
+        uint32_t num_bits = writer.flush();
 
-        BS_TEST_ASSERT_OPERATION(num_bytes, <= , 4);
+        BS_TEST_ASSERT_OPERATION(num_bits, <= , 32);
 
         // Create a reader by moving and invalidating the writer
-        bit_reader reader(buffer, num_bytes);
+        bit_reader reader(buffer, num_bits);
 
         // Read the value back
         int32_t out_value; // We don't have to initialize it yet
@@ -47,10 +47,10 @@ namespace bitstream::test::deduction
         BS_TEST_ASSERT(writer.serialize(value, 32U)); // The second argument is the maximum size we expect the string to be
 
         // Flush the writer's remaining state into the buffer
-        uint32_t num_bytes = writer.flush();
+        uint32_t num_bits = writer.flush();
 
         // Create a reader by moving and invalidating the writer
-        bit_reader reader(buffer, num_bytes);
+        bit_reader reader(buffer, num_bits);
 
         // Read the value back
         char out_value[32]; // Set the size to the max size
@@ -70,10 +70,10 @@ namespace bitstream::test::deduction
         BS_TEST_ASSERT(writer.serialize(value, 32U)); // The second argument is the maximum size we expect the string to be
 
         // Flush the writer's remaining state into the buffer
-        uint32_t num_bytes = writer.flush();
+        uint32_t num_bits = writer.flush();
 
         // Create a reader by moving and invalidating the writer
-        bit_reader reader(buffer, num_bytes);
+        bit_reader reader(buffer, num_bits);
 
         // Read the value back
         std::string out_value; // The string will be resized if the output doesn't fit
@@ -94,12 +94,12 @@ namespace bitstream::test::deduction
         writer.serialize(range, value);
 
         // Flush the writer's remaining state into the buffer
-        uint32_t num_bytes = writer.flush();
+        uint32_t num_bits = writer.flush();
 
-        BS_TEST_ASSERT_OPERATION(num_bytes, <= , 4);
+        BS_TEST_ASSERT_OPERATION(num_bits, <= , 32);
 
         // Create a reader by moving and invalidating the writer
-        bit_reader reader(buffer, num_bytes);
+        bit_reader reader(buffer, num_bits);
 
         // Read the value back
         float out_value;

src/test/serialize_enum_test.cpp

@@ -19,13 +19,13 @@ namespace bitstream::test::traits
 		bit_writer writer(buffer);
 
 		BS_TEST_ASSERT(writer.serialize<test_enum>(value, 1, 3));
-		uint32_t num_bytes = writer.flush();
+		uint32_t num_bits = writer.flush();
 
-		BS_TEST_ASSERT_OPERATION(num_bytes, == , 1);
+		BS_TEST_ASSERT_OPERATION(num_bits, == , 2);
 
 		// Read the enum back and validate
 		test_enum out_value;
-		bit_reader reader(buffer, num_bytes);
+		bit_reader reader(buffer, num_bits);
 
 		BS_TEST_ASSERT(reader.serialize<test_enum>(out_value, 1, 3));