binaryconversion.h

Go to the documentation of this file.

#ifndef CONVERSION_UTILITIES_BINARY_CONVERSION_H
#define CONVERSION_UTILITIES_BINARY_CONVERSION_H
 
#include "../global.h"
#include "../misc/traits.h"
 
#include <cstdint>
#include <cstring>
 
// use helpers from bits header if available instead of custom code using bit operations
#if __cplusplus >= 202002L
#include <bit>
#endif
 
// detect byte order according to __BYTE_ORDER__
#if defined(__BYTE_ORDER__)
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
#define CONVERSION_UTILITIES_IS_BYTE_ORDER_LITTLE_ENDIAN false
#define CONVERSION_UTILITIES_IS_BYTE_ORDER_BIG_ENDIAN true
#define CONVERSION_UTILITIES_BYTE_ORDER_BIG_ENDIAN
#elif __BYTE_ORDER__ == __ORDER_PDP_ENDIAN__
#define CONVERSION_UTILITIES_IS_BYTE_ORDER_LITTLE_ENDIAN false
#define CONVERSION_UTILITIES_IS_BYTE_ORDER_BIG_ENDIAN false
#define CONVERSION_UTILITIES_BYTE_ORDER_MIDDLE_ENDIAN
#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
#define CONVERSION_UTILITIES_IS_BYTE_ORDER_LITTLE_ENDIAN true
#define CONVERSION_UTILITIES_IS_BYTE_ORDER_BIG_ENDIAN false
#define CONVERSION_UTILITIES_BYTE_ORDER_LITTLE_ENDIAN
#endif
#endif // defined(__BYTE_ORDER__)
 
// detect float byte order according to __FLOAT_WORD_ORDER__
#if defined(__FLOAT_WORD_ORDER__)
#if __FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__
#define CONVERSION_UTILITIES_FLOAT_BYTE_ORDER_BIG_ENDIAN
#elif __FLOAT_WORD_ORDER__ == __ORDER_PDP_ENDIAN__
#define CONVERSION_UTILITIES_FLOAT_BYTE_ORDER_MIDDLE_ENDIAN
#elif __FLOAT_WORD_ORDER__ == __ORDER_LITTLE_ENDIAN__
#define CONVERSION_UTILITIES_FLOAT_BYTE_ORDER_LITTLE_ENDIAN
#endif
#endif // defined(__FLOAT_WORD_ORDER__)
 
// detect (float) byte order according to other macros
#if !defined(__BYTE_ORDER__) || !defined(__FLOAT_WORD_ORDER__)
 
// assume little endian from the presence of several macros
#if defined(__i386) || defined(__i386__) || defined(_M_IX86) || defined(__x86_64) || defined(__x86_64__) || defined(__amd64) || defined(_M_X64)      \
    || defined(__LITTLE_ENDIAN__) || defined(_little_endian__) || defined(_LITTLE_ENDIAN) || defined(_WIN32_WCE) || defined(WINAPI_FAMILY)
#if !defined(__BYTE_ORDER__)
#define CONVERSION_UTILITIES_IS_BYTE_ORDER_LITTLE_ENDIAN true
#define CONVERSION_UTILITIES_IS_BYTE_ORDER_BIG_ENDIAN false
#define CONVERSION_UTILITIES_BYTE_ORDER_LITTLE_ENDIAN
#endif
#if !defined(__FLOAT_WORD_ORDER__)
#define CONVERSION_UTILITIES_FLOAT_BYTE_ORDER_LITTLE_ENDIAN
#endif
 
// assume big endian from the presence of several macros
#elif defined(__MIPSEB__) || defined(__s390__) || defined(__BIG_ENDIAN__) || defined(_big_endian__) || defined(_BIG_ENDIAN)
#if !defined(__BYTE_ORDER__)
#define CONVERSION_UTILITIES_IS_BYTE_ORDER_LITTLE_ENDIAN false
#define CONVERSION_UTILITIES_IS_BYTE_ORDER_BIG_ENDIAN true
#define CONVERSION_UTILITIES_BYTE_ORDER_BIG_ENDIAN
#endif
#if !defined(__FLOAT_WORD_ORDER__)
#define CONVERSION_UTILITIES_FLOAT_BYTE_ORDER_BIG_ENDIAN
#endif
 
// fail if unable to detect endianness
#else
#error "Unable to determine byte order!"
#endif
 
#endif // !defined(__BYTE_ORDER__) || !defined(__FLOAT_WORD_ORDER__)
 
// fail if middle endian detected
#if defined(CONVERSION_UTILITIES_BYTE_ORDER_MIDDLE_ENDIAN) || defined(CONVERSION_UTILITIES_FLOAT_BYTE_ORDER_MIDDLE_ENDIAN)
#error "Middle endian byte order is not supported!"
#endif
 
namespace CppUtilities {
 
CPP_UTILITIES_EXPORT constexpr std::uint16_t toFixed8(float float32value)
{
    return static_cast<std::uint16_t>(float32value * 256.0f);
}
 
CPP_UTILITIES_EXPORT constexpr float toFloat32(std::uint16_t fixed8value)
{
    return static_cast<float>(fixed8value) / 256.0f;
}
 
CPP_UTILITIES_EXPORT constexpr std::uint32_t toFixed16(float float32value)
{
    return static_cast<std::uint32_t>(float32value * 65536.0f);
}
 
CPP_UTILITIES_EXPORT constexpr float toFloat32(std::uint32_t fixed16value)
{
    return static_cast<float>(fixed16value) / 65536.0f;
}
 
CPP_UTILITIES_EXPORT constexpr std::uint32_t toSynchsafeInt(std::uint32_t normalInt)
{
    return ((normalInt & 0x0000007fu)) | ((normalInt & 0x00003f80u) << 1) | ((normalInt & 0x001fc000u) << 2) | ((normalInt & 0x0fe00000u) << 3);
}
 
CPP_UTILITIES_EXPORT constexpr std::uint32_t toNormalInt(std::uint32_t synchsafeInt)
{
    return ((synchsafeInt & 0x0000007fu)) | ((synchsafeInt & 0x00007f00u) >> 1) | ((synchsafeInt & 0x007f0000u) >> 2)
        | ((synchsafeInt & 0x7f000000u) >> 3);
}
 
// define helpers for byte swapping
#ifdef __cpp_lib_byteswap // in C++ 23 we can just use the stdlib
template <class T, Traits::EnableIf<std::is_integral<T>> * = nullptr> CPP_UTILITIES_EXPORT constexpr T swapOrder(T value)
{
    return std::byteswap(value);
}
 
#else // provide custom code for C++ 20 and older (will also be optimized by GCC and Clang to use bswap)
 
CPP_UTILITIES_EXPORT constexpr std::uint16_t swapOrder(std::uint16_t value)
{
    return static_cast<std::uint16_t>(((value >> 8) & 0x00FF) | ((value << 8) & 0xFF00));
}
 
CPP_UTILITIES_EXPORT constexpr std::uint32_t swapOrder(std::uint32_t value)
{
    return (value >> 24) | ((value & 0x00FF0000) >> 8) | ((value & 0x0000FF00) << 8) | (value << 24);
}
 
CPP_UTILITIES_EXPORT constexpr std::uint64_t swapOrder(std::uint64_t value)
{
    return (value >> (7 * 8)) | ((value & 0x00FF000000000000) >> (5 * 8)) | ((value & 0x0000FF0000000000) >> (3 * 8))
        | ((value & 0x000000FF00000000) >> (1 * 8)) | ((value & 0x00000000FF000000) << (1 * 8)) | ((value & 0x0000000000FF0000) << (3 * 8))
        | ((value & 0x000000000000FF00) << (5 * 8)) | ((value) << (7 * 8));
}
 
CPP_UTILITIES_EXPORT constexpr std::int16_t swapOrder(std::int16_t value)
{
    return static_cast<std::int16_t>(((static_cast<std::uint16_t>(value) >> 8) & 0x00FF) | ((static_cast<std::uint16_t>(value) << 8) & 0xFF00));
}
 
CPP_UTILITIES_EXPORT constexpr std::int32_t swapOrder(std::int32_t value)
{
    return static_cast<std::int32_t>((static_cast<std::uint32_t>(value) >> 24) | ((static_cast<std::uint32_t>(value) & 0x00FF0000) >> 8)
        | ((static_cast<std::uint32_t>(value) & 0x0000FF00) << 8) | (static_cast<std::uint32_t>(value) << 24));
}
 
CPP_UTILITIES_EXPORT constexpr std::int64_t swapOrder(std::int64_t value)
{
    return static_cast<std::int64_t>((static_cast<std::uint64_t>(value) >> (7 * 8))
        | ((static_cast<std::uint64_t>(value) & 0x00FF000000000000) >> (5 * 8))
        | ((static_cast<std::uint64_t>(value) & 0x0000FF0000000000) >> (3 * 8))
        | ((static_cast<std::uint64_t>(value) & 0x000000FF00000000) >> (1 * 8))
        | ((static_cast<std::uint64_t>(value) & 0x00000000FF000000) << (1 * 8))
        | ((static_cast<std::uint64_t>(value) & 0x0000000000FF0000) << (3 * 8))
        | ((static_cast<std::uint64_t>(value) & 0x000000000000FF00) << (5 * 8)) | ((static_cast<std::uint64_t>(value)) << (7 * 8)));
}
#endif
 
namespace BE {
 
#define CONVERSION_UTILITIES_BINARY_CONVERSION_INTERNAL 0
#include "./binaryconversionprivate.h"
#undef CONVERSION_UTILITIES_BINARY_CONVERSION_INTERNAL
} // namespace BE
 
namespace LE {
 
#define CONVERSION_UTILITIES_BINARY_CONVERSION_INTERNAL 1
#include "./binaryconversionprivate.h"
#undef CONVERSION_UTILITIES_BINARY_CONVERSION_INTERNAL
} // namespace LE
 
} // namespace CppUtilities
 
#endif // CONVERSION_UTILITIES_BINARY_CONVERSION_H