endian.h

Go to the documentation of this file.

 
#pragma once
 
#include <bit>
#include <cstdint>
#include <cstring>
#include <stdexcept>
#include <string>
#include <string_view>
#include <type_traits>
 
#include <rex/platform.h>
#include <rex/assert.h>
#include <rex/types.h>
 
namespace rex::memory {

REX_API void Copy128Aligned(void* dest, const void* src, size_t count);

REX_API void copy_and_swap_16_aligned(void* dest, const void* src, size_t count);

REX_API void copy_and_swap_16_unaligned(void* dest, const void* src, size_t count);

REX_API void copy_and_swap_32_aligned(void* dest, const void* src, size_t count);

REX_API void copy_and_swap_32_unaligned(void* dest, const void* src, size_t count);

REX_API void copy_and_swap_64_aligned(void* dest, const void* src, size_t count);

REX_API void copy_and_swap_64_unaligned(void* dest, const void* src, size_t count);

REX_API void copy_and_swap_16_in_32_aligned(void* dest, const void* src, size_t count);

REX_API void copy_and_swap_16_in_32_unaligned(void* dest, const void* src, size_t count);

template <typename T>
void copy_and_swap(T* dest, const T* src, size_t count) {
  bool is_aligned =
      reinterpret_cast<uintptr_t>(dest) % 32 == 0 && reinterpret_cast<uintptr_t>(src) % 32 == 0;
  if (sizeof(T) == 1) {
    std::memcpy(dest, src, count);
  } else if (sizeof(T) == 2) {
    auto ps = reinterpret_cast<const u16*>(src);
    auto pd = reinterpret_cast<u16*>(dest);
    if (is_aligned) {
      copy_and_swap_16_aligned(pd, ps, count);
    } else {
      copy_and_swap_16_unaligned(pd, ps, count);
    }
  } else if (sizeof(T) == 4) {
    auto ps = reinterpret_cast<const u32*>(src);
    auto pd = reinterpret_cast<u32*>(dest);
    if (is_aligned) {
      copy_and_swap_32_aligned(pd, ps, count);
    } else {
      copy_and_swap_32_unaligned(pd, ps, count);
    }
  } else if (sizeof(T) == 8) {
    auto ps = reinterpret_cast<const u64*>(src);
    auto pd = reinterpret_cast<u64*>(dest);
    if (is_aligned) {
      copy_and_swap_64_aligned(pd, ps, count);
    } else {
      copy_and_swap_64_unaligned(pd, ps, count);
    }
  } else {
    REX_ASSERT_ALWAYS("Invalid memory::copy_and_swap size");
  }
}

template <typename T>
inline T load(const void* mem) {
  static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
  T result;
  std::memcpy(&result, mem, sizeof(T));
  return result;
}

template <typename T>
inline T load_and_swap(const void* mem) {
  return byte_swap(load<T>(mem));
}

template <>
inline std::string load_and_swap<std::string>(const void* mem) {
  std::string value;
  for (i32 i = 0;; ++i) {
    auto c = load_and_swap<u8>(reinterpret_cast<const u8*>(mem) + i);
    if (!c) {
      break;
    }
    value.push_back(static_cast<char>(c));
  }
  return value;
}

template <>
inline std::u16string load_and_swap<std::u16string>(const void* mem) {
  std::u16string value;
  for (i32 i = 0;; ++i) {
    auto c = load_and_swap<u16>(reinterpret_cast<const u16*>(mem) + i);
    if (!c) {
      break;
    }
    value.push_back(static_cast<wchar_t>(c));
  }
  return value;
}

template <typename T>
inline void store(void* mem, const T& value) {
  static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
  std::memcpy(mem, &value, sizeof(T));
}

template <typename T>
inline void store_and_swap(void* mem, const T& value) {
  store(mem, byte_swap(value));
}

template <>
inline void store_and_swap<std::string_view>(void* mem, const std::string_view& value) {
  for (size_t i = 0; i < value.size(); ++i) {
    store_and_swap<u8>(reinterpret_cast<u8*>(mem) + i, value[i]);
  }
}

template <>
inline void store_and_swap<std::string>(void* mem, const std::string& value) {
  return store_and_swap<std::string_view>(mem, value);
}

template <>
inline void store_and_swap<std::u16string_view>(void* mem, const std::u16string_view& value) {
  for (size_t i = 0; i < value.size(); ++i) {
    store_and_swap<u16>(reinterpret_cast<u16*>(mem) + i, value[i]);
  }
}

template <>
inline void store_and_swap<std::u16string>(void* mem, const std::u16string& value) {
  return store_and_swap<std::u16string_view>(mem, value);
}

constexpr u32 LoadUint24BE(const u8* p) {
  return (static_cast<u32>(p[0]) << 16) | (static_cast<u32>(p[1]) << 8) | static_cast<u32>(p[2]);
}

constexpr u32 LoadUint24LE(const u8* p) {
  return (static_cast<u32>(p[2]) << 16) | (static_cast<u32>(p[1]) << 8) | static_cast<u32>(p[0]);
}

constexpr void StoreUint24LE(u8* p, u32 value) {
  p[2] = static_cast<u8>((value >> 16) & 0xFF);
  p[1] = static_cast<u8>((value >> 8) & 0xFF);
  p[0] = static_cast<u8>(value & 0xFF);
}

using FourCCT = u32;

constexpr FourCCT make_fourcc(char a, char b, char c, char d) {
  return ((static_cast<FourCCT>(a) << 24) | (static_cast<FourCCT>(b) << 16) |
          (static_cast<FourCCT>(c) << 8) | static_cast<FourCCT>(d));
}

constexpr FourCCT make_fourcc(const std::string_view fourcc) {
  if (fourcc.length() != 4) {
    throw std::runtime_error("Invalid fourcc length");
  }
  return make_fourcc(fourcc[0], fourcc[1], fourcc[2], fourcc[3]);
}
 
}  // namespace rex::memory