Add 32 and 64 bit float readers.

Author: sorsarre

bitreader/include/bitreader/bitreader-utils.hpp

@@ -22,9 +22,6 @@ namespace brcpp
     template<> struct integral_by_size<4>: id_t<uint32_t> {};
     template<> struct integral_by_size<8>: id_t<uint64_t> {};
 
-    template<typename Enum>
-    using fitting_integral = typename integral_by_size<sizeof(Enum)>::type;
-
     struct binary_codec_base {};
 
     template<typename T>
@@ -40,6 +37,12 @@ namespace brcpp
     using std::signed_integral;
     using std::floating_point;
 
+    template<typename T>
+    concept bit_readable = integral<T> || floating_point<T>;
+
+    template<bit_readable T>
+    using fitting_integral = typename integral_by_size<sizeof(T)>::type;
+
     template<typename T>
     struct bit_read_helper {};
 

bitreader/include/bitreader/bitreader.hpp

@@ -80,12 +80,14 @@ namespace brcpp {
          * @param bits  Number of bits to read
          * @return      The data read from the stream
          */
-        template<integral T>
+        template<bit_readable T>
         T read(size_t bits)
         {
+            using FT = fitting_integral<T>;
             _validate_read_dynamic<T>(bits);
-            T ret = T(0);
-            _read(_state, bits, ret);
+            T ret = zero<T>;
+            auto& raw = reinterpret_cast<FT&>(ret);
+            _read(_state, bits, raw);
             return _sign_extend(ret, bits);
         }
 
@@ -158,6 +160,13 @@ namespace brcpp {
             return raw;
         }
 
+        //----------------------------------------------------------------------
+        template<floating_point T>
+        T _sign_extend(T raw, size_t bits)
+        {
+            return raw;
+        }
+
         //----------------------------------------------------------------------
         void _next(internal_state& state) const
         {
@@ -277,8 +286,10 @@ namespace brcpp {
         template <typename T>
         void _validate_read_dynamic(size_t size) const
         {
-            assert(size <= bit_read_helper<T>::max_bits);
-            assert(size >= bit_read_helper<T>::min_bits);
+            if (size < bit_read_helper<T>::min_bits || size > bit_read_helper<T>::max_bits)
+            {
+                throw std::runtime_error("Invalid read size");
+            }
         }
 
         internal_state _state;

bitreader/include/bitreader/bitwriter.hpp

@@ -52,15 +52,18 @@ namespace brcpp {
         }
 
         //----------------------------------------------------------------------
-        template<integral T>
+        template<bit_readable T>
         void write(T data, size_t bits)
         {
             size_t written = 0;
             size_t to_write = bits;
 
+            using FT = fitting_integral<T>;
+            const auto bit_data = *reinterpret_cast<const FT*>(&data);
+
             while (written < bits) {
                 size_t post = std::min<uint64_t>(_state.avail, to_write);
-                T portion = (data >> (bits - written - post)) & _mask<T>(post);
+                FT portion = (bit_data >> (bits - written - post)) & _mask<FT>(post);
                 size_t diff = _state.avail - post;
                 _state.buffer |= static_cast<internal_state::buffer_type>(portion << diff);
                 _state.avail -= post;

bitreader/test/bitreader_gtest.cpp

@@ -416,3 +416,113 @@ TEST(bitreaderTest, align_to_non_byte_boundary)
     EXPECT_EQ(5, br.position());
     EXPECT_EQ(11, br.available());
 }
+
+//------------------------------------------------------------------------------
+TEST(bitreaderTest, read_float_aligned)
+{
+    const uint8_t data[] = {0x41, 0x48, 0xF5, 0xC3};
+    auto source = std::make_shared<source_t>(data, sizeof(data));
+    bitreader<source_t> br(source);
+
+    const uint32_t raw_expected = 0x4148F5C3;
+    const auto expected = *reinterpret_cast<const float*>(&raw_expected);
+    EXPECT_EQ(expected, br.read<float>(32));
+    EXPECT_EQ(32, br.position());
+    EXPECT_EQ(0, br.available());
+}
+
+//------------------------------------------------------------------------------
+TEST(bitreaderTest, read_double_aligned)
+{
+    const uint8_t data[] = {0x40, 0x05, 0xBF, 0x0A, 0x8B, 0x14, 0x57, 0x62};
+    auto source = std::make_shared<source_t>(data, sizeof(data));
+    bitreader<source_t> br(source);
+    
+    const uint64_t raw_expected = 0x4005BF0A8B145762;
+    const auto expected = *reinterpret_cast<const double*>(&raw_expected);
+    EXPECT_EQ(expected, br.read<double>(64));
+    EXPECT_EQ(64, br.position());
+    EXPECT_EQ(0, br.available());
+}
+
+//------------------------------------------------------------------------------
+TEST(bitreaderTest, read_float_unaligned)
+{
+    const uint8_t data[] = {0x10, 0x20, 0x30, 0x40, 0x50};
+    auto source = std::make_shared<source_t>(data, sizeof(data));
+    bitreader<source_t> br(source);
+    
+    br.skip(4);
+    
+    const uint32_t raw_expected = 0x02030405;
+    const auto expected = *reinterpret_cast<const float*>(&raw_expected);
+    EXPECT_EQ(expected, br.read<float>(32)); // exact eq
+    EXPECT_EQ(36, br.position());
+    EXPECT_EQ(4, br.available());
+}
+
+//------------------------------------------------------------------------------
+TEST(bitreaderTest, read_double_unaligned)
+{
+    const uint8_t data[] = {0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90};
+    auto source = std::make_shared<source_t>(data, sizeof(data));
+    bitreader<source_t> br(source);
+
+    br.skip(4);
+    
+    const uint64_t raw_expected = 0x0203'0405'0607'0809;
+    const auto expected = *reinterpret_cast<const double*>(&raw_expected);
+    EXPECT_EQ(expected, br.read<double>(64));
+    EXPECT_EQ(68, br.position());
+    EXPECT_EQ(4, br.available());
+}
+
+//------------------------------------------------------------------------------
+TEST(bitreaderTest, read_double_wrong_size)
+{
+    const uint8_t data[] = {0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90};
+    auto source = std::make_shared<source_t>(data, sizeof(data));
+    bitreader<source_t> br(source);
+
+    br.skip(4);
+    
+    EXPECT_THROW(br.read<double>(63), std::exception); // wrong size
+    EXPECT_EQ(4, br.position());
+}
+
+//------------------------------------------------------------------------------
+TEST(bitreaderTest, read_float_wrong_size)
+{
+    const uint8_t data[] = {0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90};
+    auto source = std::make_shared<source_t>(data, sizeof(data));
+    bitreader<source_t> br(source);
+
+    br.skip(4);
+    
+    EXPECT_THROW(br.read<float>(31), std::exception); // wrong size
+    EXPECT_EQ(4, br.position());
+}
+
+//------------------------------------------------------------------------------
+TEST(bitreaderTest, read_float_insufficient_data)
+{
+    const uint8_t data[] = {0x41, 0x48, 0xF5}; // Only 3 bytes for float
+    auto source = std::make_shared<source_t>(data, sizeof(data));
+    bitreader<source_t> br(source);
+    
+    EXPECT_THROW(br.read<float>(32), std::exception);
+    EXPECT_EQ(0, br.position());
+    EXPECT_EQ(24, br.available());
+}
+
+//------------------------------------------------------------------------------
+TEST(bitreaderTest, read_double_insufficient_data)
+{
+    const uint8_t data[] = {0x40, 0x05, 0xBF, 0x0A, 0x8B, 0x14, 0x57}; // Only 7 bytes for double
+    auto source = std::make_shared<source_t>(data, sizeof(data));
+    bitreader<source_t> br(source);
+    
+    EXPECT_THROW(br.read<double>(64), std::exception);
+    EXPECT_EQ(0, br.position());
+    EXPECT_EQ(56, br.available());
+}