crc.hpp

#pragma once
 
#include <cstdint>
#include <cstdio>
#include <cstring>
 
#include "libxr_def.hpp"
 
namespace LibXR
{
class CRC8
{
 private:
  static const uint8_t INIT = 0xFF;  
 
 public:
  static inline uint8_t tab_[256];  
  static inline bool inited_ =
      false;  
 
  CRC8() {}
 
  static void GenerateTable()
  {
    uint8_t crc = 0;
 
    for (int i = 0; i < 256; i++)
    {
      tab_[i] = i;
    }
 
    for (int i = 0; i < 256; i++)
    {
      for (int j = 7; j >= 0; j--)
      {
        crc = tab_[i] & 0x01;
 
        if (crc)
        {
          tab_[i] = tab_[i] >> 1;
          tab_[i] ^= 0x8c;
        }
        else
        {
          tab_[i] = tab_[i] >> 1;
        }
      }
    }
    inited_ = true;
  }
 
  static uint8_t Calculate(const void* raw, size_t len);
 
  static bool Verify(const void* raw, size_t len)
  {
    const uint8_t* buf = reinterpret_cast<const uint8_t*>(raw);
    if (!inited_)
    {
      GenerateTable();
    }
 
    if (len < 2)
    {
      return false;
    }
    uint8_t expected = Calculate(buf, len - sizeof(uint8_t));
    return expected == buf[len - sizeof(uint8_t)];
  }
};
 
class CRC16
{
 private:
  static const uint16_t INIT = 0xFFFF;  
 
 public:
  static inline uint16_t tab_[256];  
  static inline bool inited_ =
      false;  
  CRC16() {}
 
  static void GenerateTable()
  {
    uint16_t crc = 0;
    for (int i = 0; i < 256; ++i)
    {
      crc = i;
      for (int j = 0; j < 8; ++j)
      {
        if (crc & 1)
        {
          crc = (crc >> 1) ^ 0x8408;
        }
        else
        {
          crc >>= 1;
        }
      }
      tab_[i] = crc;
    }
    inited_ = true;
  }
 
  static uint16_t Calculate(const void* raw, size_t len);
 
  static bool Verify(const void* raw, size_t len)
  {
    const uint8_t* buf = reinterpret_cast<const uint8_t*>(raw);
    if (!inited_)
    {
      GenerateTable();
    }
 
    if (len < 2)
    {
      return false;
    }
 
    uint16_t actual = 0;
    std::memcpy(&actual, buf + len - sizeof(actual), sizeof(actual));
 
    uint16_t expected = Calculate(buf, len - sizeof(uint16_t));
    return expected == actual;
  }
};
 
class CRC32
{
 private:
  static const uint32_t INIT = 0xFFFFFFFF;  
 
 public:
  static inline uint32_t tab_[256];  
  static inline bool inited_ =
      false;  
 
  CRC32() {}
 
  static void GenerateTable()
  {
    uint32_t crc = 0;
    for (int i = 0; i < 256; ++i)
    {
      crc = i;
      for (int j = 0; j < 8; ++j)
      {
        if (crc & 1)
        {
          crc = (crc >> 1) ^ 0xEDB88320;
        }
        else
        {
          crc >>= 1;
        }
      }
      tab_[i] = crc;
    }
    inited_ = true;
  }
 
  static uint32_t Calculate(const void* raw, size_t len);
 
  static bool Verify(const void* raw, size_t len)
  {
    const uint8_t* buf = reinterpret_cast<const uint8_t*>(raw);
    if (!inited_)
    {
      GenerateTable();
    }
 
    if (len < 2)
    {
      return false;
    }
 
    uint32_t actual = 0;
    std::memcpy(&actual, buf + len - sizeof(actual), sizeof(actual));
 
    uint32_t expected = Calculate(buf, len - sizeof(uint32_t));
    return expected == actual;
  }
};
 
class CRC64
{
 private:
  static const uint64_t INIT =
      0xFFFFFFFFFFFFFFFFULL;  
 
 public:
  static inline uint64_t tab_[256];  
  static inline bool inited_ =
      false;  
 
  CRC64() {}
 
  static void GenerateTable()
  {
    uint64_t crc = 0;
    for (int i = 0; i < 256; ++i)
    {
      crc = static_cast<uint64_t>(i);
      for (int j = 0; j < 8; ++j)
      {
        if (crc & 1ULL)
        {
          crc = (crc >> 1U) ^ 0xC96C5795D7870F42ULL;
        }
        else
        {
          crc >>= 1U;
        }
      }
      tab_[i] = crc;
    }
    inited_ = true;
  }
 
  static uint64_t Calculate(const void* raw, size_t len);
};
}  // namespace LibXR