byte_swap.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#ifndef PACS_ENCODING_BYTE_SWAP_HPP
#define PACS_ENCODING_BYTE_SWAP_HPP
 
#include <cstdint>
#include <cstring>
#include <span>
#include <vector>
 
#include "simd/simd_utils.h"
 
namespace kcenon::pacs::encoding {
 
 
[[nodiscard]] constexpr uint16_t byte_swap16(uint16_t value) noexcept {
    return static_cast<uint16_t>((value >> 8) | (value << 8));
}
 
[[nodiscard]] constexpr uint32_t byte_swap32(uint32_t value) noexcept {
    return ((value >> 24) & 0x000000FF) |
           ((value >> 8)  & 0x0000FF00) |
           ((value << 8)  & 0x00FF0000) |
           ((value << 24) & 0xFF000000);
}
 
[[nodiscard]] constexpr uint64_t byte_swap64(uint64_t value) noexcept {
    return ((value >> 56) & 0x00000000000000FF) |
           ((value >> 40) & 0x000000000000FF00) |
           ((value >> 24) & 0x0000000000FF0000) |
           ((value >> 8)  & 0x00000000FF000000) |
           ((value << 8)  & 0x000000FF00000000) |
           ((value << 24) & 0x0000FF0000000000) |
           ((value << 40) & 0x00FF000000000000) |
           ((value << 56) & 0xFF00000000000000);
}
 
 
 
[[nodiscard]] constexpr uint16_t read_be16(const uint8_t* data) noexcept {
    return (static_cast<uint16_t>(data[0]) << 8) |
           static_cast<uint16_t>(data[1]);
}
 
[[nodiscard]] constexpr uint32_t read_be32(const uint8_t* data) noexcept {
    return (static_cast<uint32_t>(data[0]) << 24) |
           (static_cast<uint32_t>(data[1]) << 16) |
           (static_cast<uint32_t>(data[2]) << 8) |
           static_cast<uint32_t>(data[3]);
}
 
[[nodiscard]] constexpr uint64_t read_be64(const uint8_t* data) noexcept {
    return (static_cast<uint64_t>(data[0]) << 56) |
           (static_cast<uint64_t>(data[1]) << 48) |
           (static_cast<uint64_t>(data[2]) << 40) |
           (static_cast<uint64_t>(data[3]) << 32) |
           (static_cast<uint64_t>(data[4]) << 24) |
           (static_cast<uint64_t>(data[5]) << 16) |
           (static_cast<uint64_t>(data[6]) << 8) |
           static_cast<uint64_t>(data[7]);
}
 
inline void write_be16(std::vector<uint8_t>& buffer, uint16_t value) {
    buffer.push_back(static_cast<uint8_t>((value >> 8) & 0xFF));
    buffer.push_back(static_cast<uint8_t>(value & 0xFF));
}
 
inline void write_be32(std::vector<uint8_t>& buffer, uint32_t value) {
    buffer.push_back(static_cast<uint8_t>((value >> 24) & 0xFF));
    buffer.push_back(static_cast<uint8_t>((value >> 16) & 0xFF));
    buffer.push_back(static_cast<uint8_t>((value >> 8) & 0xFF));
    buffer.push_back(static_cast<uint8_t>(value & 0xFF));
}
 
inline void write_be64(std::vector<uint8_t>& buffer, uint64_t value) {
    buffer.push_back(static_cast<uint8_t>((value >> 56) & 0xFF));
    buffer.push_back(static_cast<uint8_t>((value >> 48) & 0xFF));
    buffer.push_back(static_cast<uint8_t>((value >> 40) & 0xFF));
    buffer.push_back(static_cast<uint8_t>((value >> 32) & 0xFF));
    buffer.push_back(static_cast<uint8_t>((value >> 24) & 0xFF));
    buffer.push_back(static_cast<uint8_t>((value >> 16) & 0xFF));
    buffer.push_back(static_cast<uint8_t>((value >> 8) & 0xFF));
    buffer.push_back(static_cast<uint8_t>(value & 0xFF));
}
 
 
 
[[nodiscard]] inline std::vector<uint8_t> swap_ow_bytes(
    std::span<const uint8_t> data) {
    std::vector<uint8_t> result(data.size());
    simd::swap_bytes_16_simd(data.data(), result.data(), data.size());
    return result;
}
 
[[nodiscard]] inline std::vector<uint8_t> swap_ol_bytes(
    std::span<const uint8_t> data) {
    std::vector<uint8_t> result(data.size());
    simd::swap_bytes_32_simd(data.data(), result.data(), data.size());
    return result;
}
 
[[nodiscard]] inline std::vector<uint8_t> swap_of_bytes(
    std::span<const uint8_t> data) {
    return swap_ol_bytes(data);  // Same as OL (32-bit values)
}
 
[[nodiscard]] inline std::vector<uint8_t> swap_od_bytes(
    std::span<const uint8_t> data) {
    std::vector<uint8_t> result(data.size());
    simd::swap_bytes_64_simd(data.data(), result.data(), data.size());
    return result;
}
 
[[nodiscard]] inline std::vector<uint8_t> swap_at_bytes(
    std::span<const uint8_t> data) {
    return swap_ow_bytes(data);  // Each 16-bit part swapped individually
}
 
 
 
[[nodiscard]] inline std::vector<uint8_t> swap_us_bytes(
    std::span<const uint8_t> data) {
    return swap_ow_bytes(data);
}
 
[[nodiscard]] inline std::vector<uint8_t> swap_ss_bytes(
    std::span<const uint8_t> data) {
    return swap_ow_bytes(data);
}
 
[[nodiscard]] inline std::vector<uint8_t> swap_ul_bytes(
    std::span<const uint8_t> data) {
    return swap_ol_bytes(data);
}
 
[[nodiscard]] inline std::vector<uint8_t> swap_sl_bytes(
    std::span<const uint8_t> data) {
    return swap_ol_bytes(data);
}
 
[[nodiscard]] inline std::vector<uint8_t> swap_fl_bytes(
    std::span<const uint8_t> data) {
    return swap_ol_bytes(data);
}
 
[[nodiscard]] inline std::vector<uint8_t> swap_fd_bytes(
    std::span<const uint8_t> data) {
    return swap_od_bytes(data);
}
 
 
}  // namespace kcenon::pacs::encoding
 
#endif  // PACS_ENCODING_BYTE_SWAP_HPP