Source code
Revision control
Copy as Markdown
Other Tools
// Copyright (c) the JPEG XL Project Authors. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
#ifndef LIB_JXL_BASE_BYTE_ORDER_H_
#define LIB_JXL_BASE_BYTE_ORDER_H_
#include <jxl/types.h>
#include <stdint.h>
#include <string.h> // memcpy
#include "lib/jxl/base/compiler_specific.h"
#if JXL_COMPILER_MSVC
#include <intrin.h> // _byteswap_*
#endif
#if (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
#define JXL_BYTE_ORDER_LITTLE 1
#else
// This means that we don't know that the byte order is little endian, in
// this case we use endian-neutral code that works for both little- and
// big-endian.
#define JXL_BYTE_ORDER_LITTLE 0
#endif
// Returns whether the system is little-endian (least-significant byte first).
#if JXL_BYTE_ORDER_LITTLE
static constexpr bool IsLittleEndian() { return true; }
#else
static inline bool IsLittleEndian() {
const uint32_t multibyte = 1;
uint8_t byte;
memcpy(&byte, &multibyte, 1);
return byte == 1;
}
#endif
static inline bool SwapEndianness(JxlEndianness endianness) {
return ((endianness == JXL_BIG_ENDIAN && IsLittleEndian()) ||
(endianness == JXL_LITTLE_ENDIAN && !IsLittleEndian()));
}
#if JXL_COMPILER_MSVC
#define JXL_BSWAP16(x) _byteswap_ushort(x)
#define JXL_BSWAP32(x) _byteswap_ulong(x)
#define JXL_BSWAP64(x) _byteswap_uint64(x)
#else
#define JXL_BSWAP16(x) __builtin_bswap16(x)
#define JXL_BSWAP32(x) __builtin_bswap32(x)
#define JXL_BSWAP64(x) __builtin_bswap64(x)
#endif
static JXL_INLINE uint32_t LoadBE16(const uint8_t* p) {
const uint32_t byte1 = p[0];
const uint32_t byte0 = p[1];
return (byte1 << 8) | byte0;
}
static JXL_INLINE uint32_t LoadLE16(const uint8_t* p) {
const uint32_t byte0 = p[0];
const uint32_t byte1 = p[1];
return (byte1 << 8) | byte0;
}
static JXL_INLINE uint32_t LoadBE32(const uint8_t* p) {
#if JXL_BYTE_ORDER_LITTLE
uint32_t big;
memcpy(&big, p, 4);
return JXL_BSWAP32(big);
#else
// Byte-order-independent - can't assume this machine is big endian.
const uint32_t byte3 = p[0];
const uint32_t byte2 = p[1];
const uint32_t byte1 = p[2];
const uint32_t byte0 = p[3];
return (byte3 << 24) | (byte2 << 16) | (byte1 << 8) | byte0;
#endif
}
static JXL_INLINE uint64_t LoadBE64(const uint8_t* p) {
#if JXL_BYTE_ORDER_LITTLE
uint64_t big;
memcpy(&big, p, 8);
return JXL_BSWAP64(big);
#else
// Byte-order-independent - can't assume this machine is big endian.
const uint64_t byte7 = p[0];
const uint64_t byte6 = p[1];
const uint64_t byte5 = p[2];
const uint64_t byte4 = p[3];
const uint64_t byte3 = p[4];
const uint64_t byte2 = p[5];
const uint64_t byte1 = p[6];
const uint64_t byte0 = p[7];
return (byte7 << 56ull) | (byte6 << 48ull) | (byte5 << 40ull) |
(byte4 << 32ull) | (byte3 << 24ull) | (byte2 << 16ull) |
(byte1 << 8ull) | byte0;
#endif
}
static JXL_INLINE uint32_t LoadLE32(const uint8_t* p) {
#if JXL_BYTE_ORDER_LITTLE
uint32_t little;
memcpy(&little, p, 4);
return little;
#else
// Byte-order-independent - can't assume this machine is big endian.
const uint32_t byte0 = p[0];
const uint32_t byte1 = p[1];
const uint32_t byte2 = p[2];
const uint32_t byte3 = p[3];
return (byte3 << 24) | (byte2 << 16) | (byte1 << 8) | byte0;
#endif
}
static JXL_INLINE uint64_t LoadLE64(const uint8_t* p) {
#if JXL_BYTE_ORDER_LITTLE
uint64_t little;
memcpy(&little, p, 8);
return little;
#else
// Byte-order-independent - can't assume this machine is big endian.
const uint64_t byte0 = p[0];
const uint64_t byte1 = p[1];
const uint64_t byte2 = p[2];
const uint64_t byte3 = p[3];
const uint64_t byte4 = p[4];
const uint64_t byte5 = p[5];
const uint64_t byte6 = p[6];
const uint64_t byte7 = p[7];
return (byte7 << 56) | (byte6 << 48) | (byte5 << 40) | (byte4 << 32) |
(byte3 << 24) | (byte2 << 16) | (byte1 << 8) | byte0;
#endif
}
// Loads a Big-Endian float
static JXL_INLINE float LoadBEFloat(const uint8_t* p) {
uint32_t u = LoadBE32(p);
float result;
memcpy(&result, &u, 4);
return result;
}
// Loads a Little-Endian float
static JXL_INLINE float LoadLEFloat(const uint8_t* p) {
uint32_t u = LoadLE32(p);
float result;
memcpy(&result, &u, 4);
return result;
}
static JXL_INLINE void StoreBE16(const uint32_t native, uint8_t* p) {
p[0] = (native >> 8) & 0xFF;
p[1] = native & 0xFF;
}
static JXL_INLINE void StoreLE16(const uint32_t native, uint8_t* p) {
p[1] = (native >> 8) & 0xFF;
p[0] = native & 0xFF;
}
static JXL_INLINE void StoreBE32(const uint32_t native, uint8_t* p) {
#if JXL_BYTE_ORDER_LITTLE
const uint32_t big = JXL_BSWAP32(native);
memcpy(p, &big, 4);
#else
// Byte-order-independent - can't assume this machine is big endian.
p[0] = native >> 24;
p[1] = (native >> 16) & 0xFF;
p[2] = (native >> 8) & 0xFF;
p[3] = native & 0xFF;
#endif
}
static JXL_INLINE void StoreBE64(const uint64_t native, uint8_t* p) {
#if JXL_BYTE_ORDER_LITTLE
const uint64_t big = JXL_BSWAP64(native);
memcpy(p, &big, 8);
#else
// Byte-order-independent - can't assume this machine is big endian.
p[0] = native >> 56ull;
p[1] = (native >> 48ull) & 0xFF;
p[2] = (native >> 40ull) & 0xFF;
p[3] = (native >> 32ull) & 0xFF;
p[4] = (native >> 24ull) & 0xFF;
p[5] = (native >> 16ull) & 0xFF;
p[6] = (native >> 8ull) & 0xFF;
p[7] = native & 0xFF;
#endif
}
static JXL_INLINE void StoreLE32(const uint32_t native, uint8_t* p) {
#if JXL_BYTE_ORDER_LITTLE
const uint32_t little = native;
memcpy(p, &little, 4);
#else
// Byte-order-independent - can't assume this machine is big endian.
p[3] = native >> 24;
p[2] = (native >> 16) & 0xFF;
p[1] = (native >> 8) & 0xFF;
p[0] = native & 0xFF;
#endif
}
static JXL_INLINE void StoreLE64(const uint64_t native, uint8_t* p) {
#if JXL_BYTE_ORDER_LITTLE
const uint64_t little = native;
memcpy(p, &little, 8);
#else
// Byte-order-independent - can't assume this machine is big endian.
p[7] = native >> 56;
p[6] = (native >> 48) & 0xFF;
p[5] = (native >> 40) & 0xFF;
p[4] = (native >> 32) & 0xFF;
p[3] = (native >> 24) & 0xFF;
p[2] = (native >> 16) & 0xFF;
p[1] = (native >> 8) & 0xFF;
p[0] = native & 0xFF;
#endif
}
static JXL_INLINE float BSwapFloat(float x) {
uint32_t u;
memcpy(&u, &x, 4);
uint32_t uswap = JXL_BSWAP32(u);
float xswap;
memcpy(&xswap, &uswap, 4);
return xswap;
}
// Big/Little Endian order.
struct OrderBE {};
struct OrderLE {};
// Wrappers for calling from generic code.
static JXL_INLINE void Store16(OrderBE /*tag*/, const uint32_t native,
uint8_t* p) {
StoreBE16(native, p);
}
static JXL_INLINE void Store16(OrderLE /*tag*/, const uint32_t native,
uint8_t* p) {
StoreLE16(native, p);
}
static JXL_INLINE void Store32(OrderBE /*tag*/, const uint32_t native,
uint8_t* p) {
StoreBE32(native, p);
}
static JXL_INLINE void Store32(OrderLE /*tag*/, const uint32_t native,
uint8_t* p) {
StoreLE32(native, p);
}
static JXL_INLINE uint32_t Load16(OrderBE /*tag*/, const uint8_t* p) {
return LoadBE16(p);
}
static JXL_INLINE uint32_t Load16(OrderLE /*tag*/, const uint8_t* p) {
return LoadLE16(p);
}
static JXL_INLINE uint32_t Load32(OrderBE /*tag*/, const uint8_t* p) {
return LoadBE32(p);
}
static JXL_INLINE uint32_t Load32(OrderLE /*tag*/, const uint8_t* p) {
return LoadLE32(p);
}
#endif // LIB_JXL_BASE_BYTE_ORDER_H_