bit_stream.hpp

Go to the documentation of this file.

#pragma once

 
#include <cstddef>
#include <cstdint>
#include <cstring>
 
namespace wowlib::db::wdc {
  class BitReader {
  public:
    BitReader(const std::byte* base, std::size_t limit) : _base(base), _limit(limit) {}

    std::uint64_t read(std::size_t bitOffset, std::size_t bits) const {
      if (bits == 0 || bits > 64) return 0;
      const std::size_t byte = bitOffset / 8;
      const std::size_t shift = bitOffset % 8;
      const std::size_t spanBytes = (shift + bits + 7) / 8;
      if (byte + spanBytes > _limit) return 0;
      // Load the touched bytes as two little-endian halves: `lo` holds the
      // first eight, `hi` the ninth when the value straddles that far.
      std::uint64_t lo = 0, hi = 0;
      const std::size_t loBytes = spanBytes > 8 ? 8 : spanBytes;
      std::memcpy(&lo, _base + byte, loBytes);
      if (spanBytes > 8) std::memcpy(&hi, _base + byte + 8, spanBytes - 8);
      // Drop the leading bits that belong to the previous field, then splice
      // the high half's contribution in above them.
      std::uint64_t raw = lo >> shift;
      if (shift != 0 && spanBytes > 8) raw |= hi << (64 - shift);
      if (bits < 64) raw &= (std::uint64_t{1} << bits) - 1;
      return raw;
    }
 
  private:
    const std::byte* _base;
    std::size_t _limit;
  };

  class BitWriter {
  public:
    BitWriter(std::byte* base, std::size_t limit) : _base(base), _limit(limit) {}

    void write(std::size_t bitOffset, std::size_t bits, std::uint64_t value) {
      for (std::size_t i = 0; i < bits; ++i) {
        const std::size_t bo = bitOffset + i;
        if (bo / 8 >= _limit) return;
        const std::byte mask{static_cast<unsigned char>(1u << (bo % 8))};
        if ((value >> i) & 1) _base[bo / 8] |= mask;
        else _base[bo / 8] &= ~mask;
      }
    }
 
  private:
    std::byte* _base;
    std::size_t _limit;
  };
}