bit_reader.h

Go to the documentation of this file.

#pragma once
#include "../utility/assert.h"
#include "../utility/crc.h"
#include "../utility/endian.h"
#include "../utility/meta.h"
 
#include "byte_buffer.h"
#include "serialize_traits.h"
#include "stream_traits.h"
 
#include <cstdint>
#include <cstring>
#include <string>
#include <type_traits>
 
namespace bitstream
{
    template<typename Policy>
    class bit_reader
    {
    public:
        static constexpr bool writing = false;
        static constexpr bool reading = true;
 
        template<typename... Ts,
            typename = std::enable_if_t<std::is_constructible_v<Policy, Ts...>>>
        bit_reader(Ts&&... args)
            noexcept(std::is_nothrow_constructible_v<Policy, Ts...>) :
            m_Policy(std::forward<Ts>(args) ...),
            m_Scratch(0),
            m_ScratchBits(0),
            m_WordIndex(0) {}
 
        bit_reader(const bit_reader&) = delete;
        
        bit_reader(bit_reader&& other) noexcept :
            m_Policy(std::move(other.m_Policy)),
            m_Scratch(other.m_Scratch),
            m_ScratchBits(other.m_ScratchBits),
            m_WordIndex(other.m_WordIndex)
        {
            other.m_Scratch = 0;
            other.m_ScratchBits = 0;
            other.m_WordIndex = 0;
        }
 
        bit_reader& operator=(const bit_reader&) = delete;
 
        bit_reader& operator=(bit_reader&& rhs) noexcept
        {
            m_Policy = std::move(rhs.m_Policy);
            m_Scratch = rhs.m_Scratch;
            m_ScratchBits = rhs.m_ScratchBits;
            m_WordIndex = rhs.m_WordIndex;
 
            rhs.m_Scratch = 0;
            rhs.m_ScratchBits = 0;
            rhs.m_WordIndex = 0;
            
            return *this;
        }
 
        [[nodiscard]] const uint8_t* get_buffer() const noexcept { return reinterpret_cast<const uint8_t*>(m_Policy.get_buffer()); }
 
        [[nodiscard]] uint32_t get_num_bits_serialized() const noexcept { return m_Policy.get_num_bits_serialized(); }
 
        [[nodiscard]] uint32_t get_num_bytes_serialized() const noexcept { return get_num_bits_serialized() > 0U ? ((get_num_bits_serialized() - 1U) / 8U + 1U) : 0U; }
 
        [[nodiscard]] bool can_serialize_bits(uint32_t num_bits) const noexcept { return m_Policy.can_serialize_bits(num_bits); }
 
        [[nodiscard]] uint32_t get_remaining_bits() const noexcept { return get_total_bits() - get_num_bits_serialized(); }
 
        [[nodiscard]] uint32_t get_total_bits() const noexcept { return m_Policy.get_total_bits(); }
 
        [[nodiscard]] bool serialize_checksum(uint32_t protocol_version) noexcept
        {
            BS_ASSERT(get_num_bits_serialized() == 0);
 
            BS_ASSERT(can_serialize_bits(32U));
 
            uint32_t num_bytes = (get_total_bits() - 1U) / 8U + 1U;
            const uint32_t* buffer = m_Policy.get_buffer();
 
            // Generate checksum to compare against
            uint32_t generated_checksum = utility::crc_uint32(reinterpret_cast<const uint8_t*>(&protocol_version), reinterpret_cast<const uint8_t*>(buffer + 1), num_bytes - 4);
 
            // Advance the reader by the size of the checksum (32 bits / 1 word)
            m_WordIndex++;
 
            BS_ASSERT(m_Policy.extend(32U));
 
            // Read the checksum
            uint32_t checksum = *buffer;
 
            // Compare the checksum
            return generated_checksum == checksum;
        }
 
        [[nodiscard]] bool pad_to_size(uint32_t num_bytes) noexcept
        {
            uint32_t num_bits_read = get_num_bits_serialized();
 
            BS_ASSERT(num_bytes * 8U >= num_bits_read);
 
            BS_ASSERT(can_serialize_bits(num_bytes * 8U - num_bits_read));
 
            uint32_t remainder = (num_bytes * 8U - num_bits_read) % 32U;
            uint32_t zero;
 
            // Test the last word more carefully, as it may have data
            if (remainder != 0U)
            {
                bool status = serialize_bits(zero, remainder);
                BS_ASSERT(status && zero == 0);
            }
 
            uint32_t offset = get_num_bits_serialized() / 32;
            uint32_t max = num_bytes / 4;
 
            // Test for zeros in padding
            for (uint32_t i = offset; i < max; i++)
            {
                bool status = serialize_bits(zero, 32);
                BS_ASSERT(status && zero == 0);
            }
 
            return true;
        }
 
        [[nodiscard]] bool pad(uint32_t num_bytes) noexcept
        {
            return pad_to_size(get_num_bytes_serialized() + num_bytes);
        }
 
        [[nodiscard]] bool align() noexcept
        {
            uint32_t remainder = get_num_bits_serialized() % 8U;
            if (remainder != 0U)
            {
                uint32_t zero;
                bool status = serialize_bits(zero, 8U - remainder);
 
                BS_ASSERT(status && zero == 0U && get_num_bits_serialized() % 8U == 0U);
            }
 
            return true;
        }
 
        [[nodiscard]] bool serialize_bits(uint32_t& value, uint32_t num_bits) noexcept
        {
            BS_ASSERT(num_bits > 0U && num_bits <= 32U);
 
            BS_ASSERT(m_Policy.extend(num_bits));
 
            // Fast path
            if (num_bits == 32U && m_ScratchBits == 0U)
            {
                const uint32_t* ptr = m_Policy.get_buffer() + m_WordIndex;
 
                value = utility::to_big_endian32(*ptr);
 
                m_WordIndex++;
 
                return true;
            }
 
            if (m_ScratchBits < num_bits)
            {
                const uint32_t* ptr = m_Policy.get_buffer() + m_WordIndex;
 
                uint64_t ptr_value = static_cast<uint64_t>(utility::to_big_endian32(*ptr)) << (32U - m_ScratchBits);
                m_Scratch |= ptr_value;
                m_ScratchBits += 32U;
                m_WordIndex++;
            }
 
            uint32_t offset = 64U - num_bits;
            value = static_cast<uint32_t>(m_Scratch >> offset);
 
            m_Scratch <<= num_bits;
            m_ScratchBits -= num_bits;
 
            return true;
        }
 
        [[nodiscard]] bool serialize_bytes(uint8_t* bytes, uint32_t num_bits) noexcept
        {
            BS_ASSERT(num_bits > 0U);
            
            BS_ASSERT(can_serialize_bits(num_bits));
            
            // Read the byte array as words
            uint32_t* word_buffer = reinterpret_cast<uint32_t*>(bytes);
            uint32_t num_words = num_bits / 32U;
            
            if (m_ScratchBits % 32U == 0U && num_words > 0U)
            {
                BS_ASSERT(m_Policy.extend(num_words * 32U));
 
                // If the read buffer is word-aligned, just memcpy it
                std::memcpy(word_buffer, m_Policy.get_buffer() + m_WordIndex, num_words * 4U);
                
                m_WordIndex += num_words;
            }
            else
            {
                // If the buffer is not word-aligned, serialize a word at a time
                for (uint32_t i = 0U; i < num_words; i++)
                {
                    uint32_t value;
                    BS_ASSERT(serialize_bits(value, 32U));
                    
                    // Casting a byte-array to an int is wrong on little-endian systems
                    // We have to swap the bytes around
                    word_buffer[i] = utility::to_big_endian32(value);
                }
            }
            
            // Early exit if the word-count matches
            if (num_bits % 32 == 0)
                return true;
            
            uint32_t remaining_bits = num_bits - num_words * 32U;
            
            uint32_t num_bytes = (remaining_bits - 1U) / 8U + 1U;
            for (uint32_t i = 0; i < num_bytes; i++)
            {
                uint32_t value;
                BS_ASSERT(serialize_bits(value, (std::min)(remaining_bits - i * 8U, 8U)));
                
                bytes[num_words * 4 + i] = static_cast<uint8_t>(value);
            }
 
            return true;
        }
 
        template<typename Trait, typename... Args, typename = utility::has_serialize_t<Trait, bit_reader, Args...>>
        [[nodiscard]] bool serialize(Args&&... args) noexcept(utility::is_serialize_noexcept_v<Trait, bit_reader, Args...>)
        {
            return serialize_traits<Trait>::serialize(*this, std::forward<Args>(args)...);
        }
 
        template<typename... Args, typename Trait, typename = utility::has_deduce_serialize_t<Trait, bit_reader, Args...>>
        [[nodiscard]] bool serialize(Trait&& arg, Args&&... args) noexcept(utility::is_deduce_serialize_noexcept_v<Trait, bit_reader, Args...>)
        {
            return serialize_traits<utility::deduce_trait_t<Trait, bit_reader, Args...>>::serialize(*this, std::forward<Trait>(arg), std::forward<Args>(args)...);
        }
 
    private:
        Policy m_Policy;
 
        uint64_t m_Scratch;
        uint32_t m_ScratchBits;
        uint32_t m_WordIndex;
    };
 
    using fixed_bit_reader = bit_reader<fixed_policy>;
}