byte_order.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
/*
 * Project: RAVENNAKIT (RAVENNA / AES67 / ST2110-30 SDK)
 * Copyright (c) 2024-2025 Sound on Digital
 *
 * This file is part of RAVENNAKIT.
 *
 * RAVENNAKIT is dual-licensed:
 *   1) Under the terms of the GNU Affero General Public License as published by
 *      the Free Software Foundation, either version 3 of the License, or
 *      (at your option) any later version (the "AGPL License"); and
 *   2) Under a commercial license from Sound on Digital, for customers who
 *      cannot (or do not wish to) comply with the AGPL License terms.
 *
 * If you obtained this file under the AGPL License, you may redistribute it
 * and/or modify it under the terms of the AGPL License. See the LICENSE
 * file in the project root for details.
 *
 * For commercial licensing, support, and other inquiries, please visit:
 *
 *     https://ravennakit.com
 *
 */
 
#pragma once
 
#include <cstdint>
#include <cstring>
 
#include "ravennakit/core/exception.hpp"
 
// This defines RAV_LITTLE_ENDIAN and RAV_BIG_ENDIAN macros indicating the byte order of the system.
#if (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)) || (defined(__BIG_ENDIAN__) && __BIG_ENDIAN__)
    #define RAV_LITTLE_ENDIAN 0
    #define RAV_BIG_ENDIAN 1
 
namespace rav {
static constexpr bool little_endian = false;
static constexpr bool big_endian = true;
}  // namespace rav
 
    #warning "Big endian systems have not been tested yet"
#else
    #define RAV_LITTLE_ENDIAN 1
    #define RAV_BIG_ENDIAN 0
 
namespace rav {
static constexpr bool little_endian = true;
static constexpr bool big_endian = false;
}  // namespace rav
#endif
 
// This defines the byte swap functions for 16, 32, and 64 bit integers, using platform-specific implementations if
// possible.
#if defined(__clang__) || defined(__GNUC__)
    #define RAV_BYTE_SWAP_16(x) __builtin_bswap16(x)
    #define RAV_BYTE_SWAP_32(x) __builtin_bswap32(x)
    #define RAV_BYTE_SWAP_64(x) __builtin_bswap64(x)
#elif defined(_MSC_VER)
    #include <intrin.h>
    #define RAV_BYTE_SWAP_16(x) _byteswap_ushort(x)
    #define RAV_BYTE_SWAP_32(x) _byteswap_ulong(x)
    #define RAV_BYTE_SWAP_64(x) _byteswap_uint64(x)
#else
    #error "Unsupported compiler"
#endif
 
namespace rav {

inline void swap_bytes(uint8_t* data, const size_t size) {
    // Check for null data pointer or zero size
    if (data == nullptr || size == 0) {
        return;
    }
 
    for (size_t i = 0; i < size / 2; ++i) {
        std::swap(data[i], data[size - i - 1]);
    }
}

inline void swap_bytes(uint8_t* data, const size_t size, const size_t stride) {
    // Check for null data pointer or zero size
    if (data == nullptr || size == 0 || stride <= 1) {
        return;
    }
 
    for (size_t i = 0; i < size; i += stride) {
        for (size_t j = 0; j < stride / 2; ++j) {
            std::swap(data[i + j], data[i + stride - j - 1]);
        }
    }
}

template<typename Type, std::enable_if_t<std::is_trivially_copyable_v<Type>, bool> = true>
Type swap_bytes(Type value) {
    // Note: this function hasn't been benchmarked.
    if constexpr (sizeof(Type) == 1) {
        return value;
    } else if constexpr (sizeof(Type) == 2) {
        return static_cast<Type>(RAV_BYTE_SWAP_16(static_cast<uint16_t>(value)));
    } else if constexpr (sizeof(Type) == 4) {
        return static_cast<Type>(RAV_BYTE_SWAP_32(static_cast<uint32_t>(value)));
    } else if constexpr (sizeof(Type) == 8) {
        return static_cast<Type>(RAV_BYTE_SWAP_64(static_cast<uint64_t>(value)));
    } else {
        swap_bytes(reinterpret_cast<uint8_t*>(&value), sizeof(value));
        return value;
    }
}

template<>
inline float swap_bytes<float>(const float value) {
    static_assert(sizeof(float) == sizeof(uint32_t), "Float must be 32 bits");
 
    union {
        float f;
        uint32_t i;
    } u = {value};
 
    u.i = RAV_BYTE_SWAP_32(u.i);
    return u.f;
}

template<>
inline double swap_bytes<double>(const double value) {
    static_assert(sizeof(double) == sizeof(uint64_t), "Double must be 64 bits");
 
    union {
        double f;
        uint64_t i;
    } u = {value};
 
    u.i = RAV_BYTE_SWAP_64(u.i);
    return u.f;
}

template<typename Type, std::enable_if_t<std::is_trivially_copyable_v<Type>, bool> = true>
Type swap_if_le(const Type value) {
    if constexpr (little_endian) {
        return swap_bytes(value);
    } else {
        return value;
    }
}

template<typename Type, std::enable_if_t<std::is_trivially_copyable_v<Type>, bool> = true>
Type swap_if_be(const Type value) {
    if constexpr (big_endian) {
        return swap_bytes(value);
    } else {
        return value;
    }
}

template<typename Type, std::enable_if_t<std::is_trivially_copyable_v<Type>, bool> = true>
Type read_ne(const uint8_t* data) {
    Type value;
    std::memcpy(std::addressof(value), data, sizeof(Type));
    return value;
}

template<typename Type, std::enable_if_t<std::is_trivially_copyable_v<Type>, bool> = true>
Type read_be(const uint8_t* data) {
    return swap_if_le(read_ne<Type>(data));
}

template<typename Type, std::enable_if_t<std::is_trivially_copyable_v<Type>, bool> = true>
Type read_le(const uint8_t* data) {
    return swap_if_be(read_ne<Type>(data));
}

template<typename Type, std::enable_if_t<std::is_trivially_copyable_v<Type>, bool> = true>
void write_ne(uint8_t* dst, const Type value) {
    std::memcpy(dst, std::addressof(value), sizeof(Type));
}

template<typename Type, std::enable_if_t<std::is_trivially_copyable_v<Type>, bool> = true>
void write_be(uint8_t* dst, const Type value) {
    write_ne(dst, swap_if_le(value));
}

template<typename Type, std::enable_if_t<std::is_trivially_copyable_v<Type>, bool> = true>
void write_le(uint8_t* dst, const Type value) {
    write_ne(dst, swap_if_be(value));
}

inline bool is_little_endian_at_runtime() noexcept {
    static size_t native_one = 1;
    return reinterpret_cast<uint8_t*>(&native_one)[0] == 1;
}

inline void validate_byte_order() {
#if RAV_LITTLE_ENDIAN
    if (!is_little_endian_at_runtime()) {
        RAV_THROW_EXCEPTION("Compile-time and runtime byte order do not match");
    }
#else
    if (is_little_endian_runtime()) {
        RAV_THROW_EXCEPTION("Compile-time and runtime byte order do not match");
    }
#endif
}
 
}  // namespace rav