---

ByteOrder.h

//
// ByteOrder.h
//
// Copyright (c) 2001 Virtual Terrain Project
// Free for all uses, see license.txt for details.
//

#ifndef BYTEORDERH
#define BYTEORDERH

#include <stdio.h>
#include <assert.h>

enum ByteOrder 
{
    BO_LITTLE_ENDIAN,                   /*  Intel  */
    BO_BIG_ENDIAN,                      /*  Motorola, MIPS, Sun, etc.  */
    BO_MACHINE,
  BO_LE  = BO_LITTLE_ENDIAN,
  BO_BE  = BO_BIG_ENDIAN,
  BO_CPU = BO_MACHINE
};

enum DataType 
{
    DT_SHORT, DT_INT, DT_LONG, DT_FLOAT, DT_DOUBLE
};

inline ByteOrder NativeByteOrder( void ) 
{
    static int iByteOrderTest = 0x1;

    if ( *((char *) &iByteOrderTest) == 0x1 )
        return BO_LITTLE_ENDIAN;
    else
        return BO_BIG_ENDIAN;
}

/*
 * Various macros that always swap byte order.  Expanded in-line for
 *   maximum speed when processing arrays.
 * 
 */
inline short SwapShort( short data )
{
    assert( sizeof(short) == 2 );
    return (data << 8) | (data >> 8);
}
inline long SwapLong( long data )
{
    assert( sizeof(long) == 4 );
    return ( data << 24 )                 | (( data << 8 ) & 0x00FF0000 ) |
           (( data >> 24 ) & 0x000000FF ) | (( data >> 8 ) & 0x0000FF00 );
}
inline int SwapInt( int data )
{
    assert( sizeof(int) == sizeof(short) || sizeof(int) == sizeof(long) );
    if ( sizeof(int) == sizeof(short) )
        return SwapShort( (short)data );
    else
        return SwapLong( (long)data );
}
inline float SwapFloat( float data )
{
    assert( sizeof(float) == sizeof(long) );
    long s = SwapLong( *((long *)&data) );
    return *((float *)&s);
}
inline double SwapDouble( double data )
{
    assert( sizeof(double) == 2*sizeof(long) );
    char *p  = (char *)&data;
    long  l1 = *((long *)( p + 0            )), 
          l2 = *((long *)( p + sizeof(long) )); 
    *((long *)( p + 0            )) = SwapLong( l2 );
    *((long *)( p + sizeof(long) )) = SwapLong( l1 );
    return data;
}

inline short SwapBytes( short     data, 
                        ByteOrder data_order,   
                        ByteOrder desired_order )
{
    if ( data_order    == BO_MACHINE ) data_order    = NativeByteOrder();
    if ( desired_order == BO_MACHINE ) desired_order = NativeByteOrder();
    if ( data_order == desired_order ) 
        return data;
    else
        return SwapShort( data );
}

inline long SwapBytes( long      data, 
                       ByteOrder data_order,   
                       ByteOrder desired_order )
{
    if ( data_order    == BO_MACHINE ) data_order    = NativeByteOrder();
    if ( desired_order == BO_MACHINE ) desired_order = NativeByteOrder();
    if ( data_order == desired_order )
        return data;
    else
        return SwapLong( data );
}

inline int SwapBytes( int        data, 
                      ByteOrder data_order,   
                      ByteOrder desired_order )
{
    if ( data_order    == BO_MACHINE ) data_order    = NativeByteOrder();
    if ( desired_order == BO_MACHINE ) desired_order = NativeByteOrder();
    if ( data_order == desired_order )
        return data;
    else
        return SwapInt( data );
}

inline float SwapBytes( float     data, 
                        ByteOrder data_order,   
                        ByteOrder desired_order )
{
    if ( data_order    == BO_MACHINE ) data_order    = NativeByteOrder();
    if ( desired_order == BO_MACHINE ) desired_order = NativeByteOrder();
    if ( data_order == desired_order )
        return data;
    else
        return SwapFloat( data );
}

inline double SwapBytes( double    data, 
                         ByteOrder data_order,   
                         ByteOrder desired_order )
{
    if ( data_order    == BO_MACHINE ) data_order    = NativeByteOrder();
    if ( desired_order == BO_MACHINE ) desired_order = NativeByteOrder();
    if ( data_order == desired_order )
        return data;
    else
        return SwapDouble( data );
}

void SwapMemBytes( void *items, DataType type, size_t count,
                   ByteOrder file_order, ByteOrder desired_order );

size_t FRead( void *ptr, DataType type, size_t nitems, FILE *stream,
              ByteOrder file_order, ByteOrder desired_order = BO_MACHINE );

#endif

---