Description

Functions and macros for endian conversions and byteswap conversions.

SWAP_BYTES_??(a) - Reverse byte order
SWAP_CONSTANT_??(a) - Reverse byte order, implemented as a macro. Use with compile-time constants only, the result will be a compile-time constant as well. Unlike most other functions, these can be used for e.g. switch-case labels.
READ_UINT??(a) - Read native value from pointer a.
READ_??_UINT??(a) - Read LE/BE value from pointer a and convert it to native.
WRITE_??_UINT??(a, v) - Write a native value v to pointer a with LE/BE encoding.
TO_??_??(a) - Convert native value v to LE/BE.
FROM_??_??(a) - Convert LE/BE value v to native.
CONSTANT_??_??(a) - Convert LE/BE value v to native, implemented as a macro. Use with compile-time constants only, the result will be a compile-time constant as well. Unlike most other functions these, can be used for e.g. switch-case labels.

Classes
union	SwapFloat

union	SwapDouble

Macros
#define	SWAP_CONSTANT_64(a)

#define	SWAP_CONSTANT_32(a)

#define	SWAP_CONSTANT_16(a)

#define	MKTAG(a0, a1, a2, a3) ((uint32)((a3) \| ((a2) << 8) \| ((a1) << 16) \| ((a0) << 24)))

#define	MKTAG16(a0, a1) ((uint16)((a1) \| ((a0) << 8)))

Functions
uint16	SWAP_BYTES_16 (const uint16 a)

uint32	SWAP_BYTES_32 (uint32 a)

uint64	SWAP_BYTES_64 (uint64 a)

Functions for reading and writing native integers
Functions for reading and writing native integer values. They also transparently handle the need for alignment.
uint16	READ_UINT16 (const void *ptr)

uint32	READ_UINT32 (const void *ptr)

void	WRITE_UINT16 (void *ptr, uint16 value)

void	WRITE_UINT32 (void *ptr, uint32 value)

uint64	READ_UINT64 (const void *ptr)

void	WRITE_UINT64 (void *ptr, uint64 value)

Map functions for reading/writing BE/LE integers depending on native endianess
#define	READ_LE_UINT16(a) READ_UINT16(a)

#define	READ_LE_UINT32(a) READ_UINT32(a)

#define	WRITE_LE_UINT16(a, v) WRITE_UINT16(a, v)

#define	WRITE_LE_UINT32(a, v) WRITE_UINT32(a, v)

#define	FROM_LE_32(a) ((uint32)(a))

#define	FROM_LE_16(a) ((uint16)(a))

#define	FROM_BE_32(a) SWAP_BYTES_32(a)

#define	FROM_BE_16(a) SWAP_BYTES_16(a)

#define	TO_LE_32(a) ((uint32)(a))

#define	TO_LE_16(a) ((uint16)(a))

#define	TO_BE_32(a) SWAP_BYTES_32(a)

#define	TO_BE_16(a) SWAP_BYTES_16(a)

#define	CONSTANT_LE_32(a) ((uint32)(a))

#define	CONSTANT_LE_16(a) ((uint16)(a))

#define	CONSTANT_BE_32(a) SWAP_CONSTANT_32(a)

#define	CONSTANT_BE_16(a) SWAP_CONSTANT_16(a)

#define	READ_LE_UINT64(a) READ_UINT64(a)

#define	WRITE_LE_UINT64(a, v) WRITE_UINT64(a, v)

#define	FROM_LE_64(a) ((uint64)(a))

#define	FROM_BE_64(a) SWAP_BYTES_64(a)

#define	TO_LE_64(a) ((uint64)(a))

#define	TO_BE_64(a) SWAP_BYTES_64(a)

#define	CONSTANT_LE_64(a) ((uint64)(a))

#define	CONSTANT_BE_64(a) SWAP_CONSTANT_64(a)

Functions for directly reading/writing and inverting
Use these in case the unaligned load and byteswap take a lot of instructions.
uint16	READ_BE_UINT16 (const void *ptr)

uint32	READ_BE_UINT32 (const void *ptr)

void	WRITE_BE_UINT16 (void *ptr, uint16 value)

void	WRITE_BE_UINT32 (void *ptr, uint32 value)

uint64	READ_BE_UINT64 (const void *ptr)

void	WRITE_BE_UINT64 (void *ptr, uint64 value)

uint32	READ_LE_UINT24 (const void *ptr)

void	WRITE_LE_UINT24 (void *ptr, uint32 value)

uint32	READ_BE_UINT24 (const void *ptr)

void	WRITE_BE_UINT24 (void *ptr, uint32 value)

float	READ_LE_FLOAT32 (const void *ptr)

void	WRITE_LE_FLOAT32 (void *ptr, float value)

float	READ_BE_FLOAT32 (const void *ptr)

void	WRITE_BE_FLOAT32 (void *ptr, float value)

template<size_t n>
double	READ_DOUBLE (const SwapDouble &sw)

template<size_t n>
void	WRITE_DOUBLE (SwapDouble &sw, double d)

template<>
double	READ_DOUBLE< sizeof(uint64)> (const SwapDouble &sd)

template<>
void	WRITE_DOUBLE< sizeof(uint64)> (SwapDouble &sd, double d)

template<>
double	READ_DOUBLE< sizeof(uint32)> (const SwapDouble &sd)

template<>
void	WRITE_DOUBLE< sizeof(uint32)> (SwapDouble &sd, double d)

double	READ_LE_FLOAT64 (const void *ptr)

void	WRITE_LE_FLOAT64 (void *ptr, double value)

double	READ_BE_FLOAT64 (const void *ptr)

void	WRITE_BE_FLOAT64 (void *ptr, double value)

double	READ_FPA_FLOAT64 (const void *ptr)

void	WRITE_FPA_FLOAT64 (void *ptr, double value)

double	READ_FLOAT64 (const void *ptr)

void	WRITE_FLOAT64 (void *ptr, double value)

int16	READ_LE_INT16 (const void *ptr)

void	WRITE_LE_INT16 (void *ptr, int16 value)

int16	READ_BE_INT16 (const void *ptr)

void	WRITE_BE_INT16 (void *ptr, int16 value)

int32	READ_LE_INT32 (const void *ptr)

void	WRITE_LE_INT32 (void *ptr, int32 value)

int32	READ_BE_INT32 (const void *ptr)

void	WRITE_BE_INT32 (void *ptr, int32 value)

#define	READ_UINT24(a) READ_LE_UINT24(a)

#define	WRITE_UINT24(a, b) WRITE_LE_UINT24(a,b)

#define	READ_FLOAT32(a) READ_LE_FLOAT32(a)

#define	WRITE_FLOAT32(a, b) WRITE_LE_FLOAT32(a,b)

Macro Definition Documentation

◆ SWAP_CONSTANT_64

#define SWAP_CONSTANT_64 ( a )

Value:

((uint64)((((a) >> 56) & 0x000000FF) | \
              (((a) >> 40) & 0x0000FF00) | \
              (((a) >> 24) & 0x00FF0000) | \
              (((a) >>  8) & 0xFF000000) | \
              (((a) & 0xFF000000) <<  8) | \
              (((a) & 0x00FF0000) << 24) | \
              (((a) & 0x0000FF00) << 40) | \
              (((a) & 0x000000FF) << 56) ))

Swap the bytes in a 64-bit word in order to convert LE encoded data to BE and vice versa. Use with compile-time constants only.

◆ SWAP_CONSTANT_32

#define SWAP_CONSTANT_32 ( a )

Value:

((uint32)((((a) >> 24) & 0x00FF) | \
              (((a) >>  8) & 0xFF00) | \
              (((a) & 0xFF00) <<  8) | \
              (((a) & 0x00FF) << 24) ))

Swap the bytes in a 32-bit word in order to convert LE encoded data to BE and vice versa. Use with compile-time constants only.

◆ SWAP_CONSTANT_16

#define SWAP_CONSTANT_16 ( a )

Value:

((uint16)((((a) >> 8) & 0x00FF) | \

(((a) << 8) & 0xFF00) ))

Swap the bytes in a 16-bit word in order to convert LE encoded data to BE and vice versa. Use with compile-time constants only.

◆ MKTAG

#define MKTAG	(	a0,
		a1,
		a2,
		a3
	)	((uint32)((a3) \| ((a2) << 8) \| ((a1) << 16) \| ((a0) << 24)))

A wrapper macro used around four character constants, like 'DATA', to ensure portability. Typical usage: MKTAG('D','A','T','A').

This is required because the C/C++ standard does not define the endianess to be used for character constants. Hence, if one uses multi-byte character constants, a potential portability problem opens up.

◆ MKTAG16

#define MKTAG16	(	a0,
		a1
	)	((uint16)((a1) \| ((a0) << 8)))

A wrapper macro used around two character constants, like 'wb', to ensure portability. Typical usage: MKTAG16('w','b').

Function Documentation

◆ SWAP_BYTES_16()

uint16 SWAP_BYTES_16 ( const uint16 a )

inline

Swap the bytes in a 16-bit word in order to convert LE encoded data to BE and vice versa.

◆ SWAP_BYTES_32()

uint32 SWAP_BYTES_32 ( uint32 a )

inline

Swap the bytes in a 32-bit word in order to convert LE encoded data to BE and vice versa.

◆ SWAP_BYTES_64()

uint64 SWAP_BYTES_64 ( uint64 a )

inline

Swap the bytes in a 64-bit word in order to convert LE encoded data to BE and vice versa.

Description

Classes

Macros

Functions

Functions for reading and writing native integers

Map functions for reading/writing BE/LE integers depending on native endianess

Functions for directly reading/writing and inverting

Macro Definition Documentation

◆ SWAP_CONSTANT_64

◆ SWAP_CONSTANT_32

◆ SWAP_CONSTANT_16

◆ MKTAG

◆ MKTAG16

Function Documentation

◆ SWAP_BYTES_16()

◆ SWAP_BYTES_32()

◆ SWAP_BYTES_64()