Skip to content

V
vlc-gpu
Commit 9ff7bdc4 authored by Rémi Denis-Courmont's avatar Rémi Denis-Courmont
Browse files
Options

Improve byte order inline functions 

 * Use GCC built-ins for 32-bits and 64-bits byte swap where available.
 * Load/store with single memcpy() instead of many byte operations.
 * Do not use bits operations for the local byte order.
 * Do not use reserved C keywords with leading underscores.
parent f7db1e80
Show whitespace changes
Inline Side-by-side
Showing with 135 additions and 78 deletions
include/vlc_common.h
View file @ 9ff7bdc4
...@@ -630,6 +630,46 @@ static inline unsigned popcount (unsigned x) ...@@ -630,6 +630,46 @@ static inline unsigned popcount (unsigned x)
#endif #endif
} }
/** Byte swap (16 bits) */
VLC_USED
static inline uint16_t bswap16 (uint16_t x)
{
return (x << 8) | (x >> 8);
}
/** Byte swap (32 bits) */
VLC_USED
static inline uint32_t bswap32 (uint32_t x)
{
#if VLC_GCC_VERSION(4,3)
return __builtin_bswap32 (x);
#else
return ((x & 0x000000FF) << 24)
| ((x & 0x0000FF00) << 8)
| ((x & 0x00FF0000) >> 8)
| ((x & 0xFF000000) >> 24);
#endif
}
/** Byte swap (64 bits) */
VLC_USED
static inline uint64_t bswap64 (uint64_t x)
{
#if VLC_GCC_VERSION(4,3)
return __builtin_bswap64 (x);
#else
return ((x & 0x00000000000000FF) << 56)
| ((x & 0x000000000000FF00) << 40)
| ((x & 0x0000000000FF0000) << 24)
| ((x & 0x00000000FF000000) << 8)
| ((x & 0x000000FF00000000) >> 8)
| ((x & 0x0000FF0000000000) >> 24)
| ((x & 0x00FF000000000000) >> 40)
| ((x & 0xFF00000000000000) >> 56);
#endif
}
/* Free and set set the variable to NULL */ /* Free and set set the variable to NULL */
#define FREENULL(a) do { free( a ); a = NULL; } while(0) #define FREENULL(a) do { free( a ); a = NULL; } while(0)
...@@ -641,123 +681,140 @@ VLC_API char const * vlc_error( int ) VLC_USED; ...@@ -641,123 +681,140 @@ VLC_API char const * vlc_error( int ) VLC_USED;
/* MSB (big endian)/LSB (little endian) conversions - network order is always /* MSB (big endian)/LSB (little endian) conversions - network order is always
* MSB, and should be used for both network communications and files. */ * MSB, and should be used for both network communications and files. */
#ifdef WORDS_BIGENDIAN
# define hton16(i) ((uint16_t)(i))
# define hton32(i) ((uint32_t)(i))
# define hton64(i) ((uint32_t)(i))
#else
# define hton16(i) bswap16(i)
# define hton32(i) bswap32(i)
# define hton64(i) bswap64(i)
#endif
#define ntoh16(i) hton16(i)
#define ntoh32(i) hton32(i)
#define ntoh64(i) hton64(i)
/** Reads 16 bits in network byte order */
VLC_USED VLC_USED
static inline uint16_t U16_AT( const void * _p ) static inline uint16_t U16_AT (const void *p)
{ {
const uint8_t * p = (const uint8_t *)_p; uint16_t x;
return ( ((uint16_t)p[0] << 8) | p[1] );
memcpy (&x, p, sizeof (x));
return ntoh16 (x);
} }
/** Reads 32 bits in network byte order */
VLC_USED VLC_USED
static inline uint32_t U32_AT( const void * _p ) static inline uint32_t U32_AT (const void *p)
{ {
const uint8_t * p = (const uint8_t *)_p; uint32_t x;
return ( ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16)
| ((uint32_t)p[2] << 8) | p[3] ); memcpy (&x, p, sizeof (x));
return ntoh32 (x);
} }
/** Reads 64 bits in network byte order */
VLC_USED VLC_USED
static inline uint64_t U64_AT( const void * _p ) static inline uint64_t U64_AT (const void *p)
{ {
const uint8_t * p = (const uint8_t *)_p; uint64_t x;
return ( ((uint64_t)p[0] << 56) | ((uint64_t)p[1] << 48)
| ((uint64_t)p[2] << 40) | ((uint64_t)p[3] << 32) memcpy (&x, p, sizeof (x));
| ((uint64_t)p[4] << 24) | ((uint64_t)p[5] << 16) return ntoh64 (x);
| ((uint64_t)p[6] << 8) | p[7] );
} }
#define GetWBE(p) U16_AT(p)
#define GetDWBE(p) U32_AT(p)
#define GetQWBE(p) U64_AT(p)
/** Reads 16 bits in little-endian order */
VLC_USED VLC_USED
static inline uint16_t GetWLE( const void * _p ) static inline uint16_t GetWLE (const void *p)
{ {
const uint8_t * p = (const uint8_t *)_p; uint16_t x;
return ( ((uint16_t)p[1] << 8) | p[0] );
memcpy (&x, p, sizeof (x));
#ifdef WORDS_BIGENDIAN
x = bswap16 (x);
#endif
return x;
} }
/** Reads 32 bits in little-endian order */
VLC_USED VLC_USED
static inline uint32_t GetDWLE( const void * _p ) static inline uint32_t GetDWLE (const void *p)
{ {
const uint8_t * p = (const uint8_t *)_p; uint32_t x;
return ( ((uint32_t)p[3] << 24) | ((uint32_t)p[2] << 16)
| ((uint32_t)p[1] << 8) | p[0] ); memcpy (&x, p, sizeof (x));
#ifdef WORDS_BIGENDIAN
x = bswap32 (x);
#endif
return x;
} }
/** Reads 64 bits in little-endian order */
VLC_USED VLC_USED
static inline uint64_t GetQWLE( const void * _p ) static inline uint64_t GetQWLE (const void *p)
{ {
const uint8_t * p = (const uint8_t *)_p; uint64_t x;
return ( ((uint64_t)p[7] << 56) | ((uint64_t)p[6] << 48)
| ((uint64_t)p[5] << 40) | ((uint64_t)p[4] << 32)
| ((uint64_t)p[3] << 24) | ((uint64_t)p[2] << 16)
| ((uint64_t)p[1] << 8) | p[0] );
}
#define GetWBE( p ) U16_AT( p ) memcpy (&x, p, sizeof (x));
#define GetDWBE( p ) U32_AT( p ) #ifdef WORDS_BIGENDIAN
#define GetQWBE( p ) U64_AT( p ) x = bswap64 (x);
#endif
/* Helper writer functions */ return x;
#define SetWLE( p, v ) _SetWLE( (uint8_t*)(p), v)
static inline void _SetWLE( uint8_t *p, uint16_t i_dw )
{
p[1] = ( i_dw >> 8 )&0xff;
p[0] = ( i_dw )&0xff;
} }
#define SetDWLE( p, v ) _SetDWLE( (uint8_t*)(p), v) /** Writes 16 bits in network byte order */
static inline void _SetDWLE( uint8_t *p, uint32_t i_dw ) static inline void SetWLE (void *p, uint16_t w)
{ {
p[3] = ( i_dw >> 24 )&0xff; w = hton16 (w);
p[2] = ( i_dw >> 16 )&0xff; memcpy (p, &w, sizeof (w));
p[1] = ( i_dw >> 8 )&0xff;
p[0] = ( i_dw )&0xff;
} }
#define SetQWLE( p, v ) _SetQWLE( (uint8_t*)(p), v)
static inline void _SetQWLE( uint8_t *p, uint64_t i_qw ) /** Writes 32 bits in network byte order */
static inline void SetDWLE (void *p, uint32_t dw)
{ {
SetDWLE( p, i_qw&0xffffffff ); dw = hton32 (dw);
SetDWLE( p+4, ( i_qw >> 32)&0xffffffff ); memcpy (p, &dw, sizeof (dw));
} }
#define SetWBE( p, v ) _SetWBE( (uint8_t*)(p), v)
static inline void _SetWBE( uint8_t *p, uint16_t i_dw ) /** Writes 64 bits in network byte order */
static inline void SetQWLE (void *p, uint64_t qw)
{ {
p[0] = ( i_dw >> 8 )&0xff; qw = hton64 (qw);
p[1] = ( i_dw )&0xff; memcpy (p, &qw, sizeof (qw));
} }
#define SetDWBE( p, v ) _SetDWBE( (uint8_t*)(p), v) /** Writes 16 bits in little endian order */
static inline void _SetDWBE( uint8_t *p, uint32_t i_dw ) static inline void SetWBE (void *p, uint16_t w)
{ {
p[0] = ( i_dw >> 24 )&0xff; #ifdef WORDS_BIGENDIAN
p[1] = ( i_dw >> 16 )&0xff; w = bswap16 (w);
p[2] = ( i_dw >> 8 )&0xff; #endif
p[3] = ( i_dw )&0xff; memcpy (p, &w, sizeof (w));
} }
#define SetQWBE( p, v ) _SetQWBE( (uint8_t*)(p), v)
static inline void _SetQWBE( uint8_t *p, uint64_t i_qw ) /** Writes 32 bits in little endian order */
static inline void SetDWBE (void *p, uint32_t dw)
{ {
SetDWBE( p+4, i_qw&0xffffffff ); #ifdef WORDS_BIGENDIAN
SetDWBE( p, ( i_qw >> 32)&0xffffffff ); dw = bswap32 (dw);
#endif
memcpy (p, &dw, sizeof (dw));
} }
#define hton16(i) htons(i) /** Writes 64 bits in little endian order */
#define hton32(i) htonl(i) static inline void SetQWBE (void *p, uint64_t qw)
#define ntoh16(i) ntohs(i)
#define ntoh32(i) ntohl(i)
VLC_USED
static inline uint64_t ntoh64 (uint64_t ll)
{ {
union { uint64_t qw; uint8_t b[16]; } v = { ll }; #ifdef WORDS_BIGENDIAN
return ((uint64_t)v.b[0] << 56) qw = bswap32 (qw);
| ((uint64_t)v.b[1] << 48) #endif
| ((uint64_t)v.b[2] << 40) memcpy (p, &qw, sizeof (qw));
| ((uint64_t)v.b[3] << 32)
| ((uint64_t)v.b[4] << 24)
| ((uint64_t)v.b[5] << 16)
| ((uint64_t)v.b[6] << 8)
| ((uint64_t)v.b[7] << 0);
} }
#define hton64(i) ntoh64(i)
/* */ /* */
#define VLC_UNUSED(x) (void)(x) #define VLC_UNUSED(x) (void)(x)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment