{

public:

CByteswap()

{

// Default behavior sets the target endian to match the machine native endian (no swap).

SetTargetBigEndian( IsMachineBigEndian() );

}

//-----------------------------------------------------------------------------

// Write a single field.

//-----------------------------------------------------------------------------

void SwapFieldToTargetEndian( void* pOutputBuffer, void *pData, typedescription_t *pField );

//-----------------------------------------------------------------------------

// Write a block of fields. Works a bit like the saverestore code.

//-----------------------------------------------------------------------------

void SwapFieldsToTargetEndian( void *pOutputBuffer, void *pBaseData, datamap_t *pDataMap );

// Swaps fields for the templated type to the output buffer.

template<typename T> inline void SwapFieldsToTargetEndian( T* pOutputBuffer, void *pBaseData, unsigned int objectCount = 1 )

{

for ( unsigned int i = 0; i < objectCount; ++i, ++pOutputBuffer )

{

SwapFieldsToTargetEndian( (void*)pOutputBuffer, pBaseData, &T::m_DataMap );

pBaseData = (byte*)pBaseData + sizeof(T);

}

}

// Swaps fields for the templated type in place.

template<typename T> inline void SwapFieldsToTargetEndian( T* pOutputBuffer, unsigned int objectCount = 1 )

{

SwapFieldsToTargetEndian<T>( pOutputBuffer, (void*)pOutputBuffer, objectCount );

}

//-----------------------------------------------------------------------------

// True if the current machine is detected as big endian.

// (Endienness is effectively detected at compile time when optimizations are

// enabled)

//-----------------------------------------------------------------------------

static bool IsMachineBigEndian()

{

short nIsBigEndian = 1;

// if we are big endian, the first byte will be a 0, if little endian, it will be a one.

return (bool)(0 == *(char *)&nIsBigEndian );

}

//-----------------------------------------------------------------------------

// Sets the target byte ordering we are swapping to or from.

//

// Braindead Endian Reference:

// x86 is LITTLE Endian

// PowerPC is BIG Endian

//-----------------------------------------------------------------------------

inline void SetTargetBigEndian( bool bigEndian )

{

m_bBigEndian = bigEndian;

m_bSwapBytes = IsMachineBigEndian() != bigEndian;

}

// Changes target endian

inline void FlipTargetEndian( void )

{

m_bSwapBytes = !m_bSwapBytes;

m_bBigEndian = !m_bBigEndian;

}

// Forces byte swapping state, regardless of endianess

inline void ActivateByteSwapping( bool bActivate )

{

SetTargetBigEndian( IsMachineBigEndian() != bActivate );

}

//-----------------------------------------------------------------------------

// Returns true if the target machine is the same as this one in endianness.

//

// Used to determine when a byteswap needs to take place.

//-----------------------------------------------------------------------------

inline bool IsSwappingBytes( void ) // Are bytes being swapped?

{

return m_bSwapBytes;

}

inline bool IsTargetBigEndian( void ) // What is the current target endian?

{

return m_bBigEndian;

}

//-----------------------------------------------------------------------------

// IsByteSwapped()

//

// When supplied with a chunk of input data and a constant or magic number

// (in native format) determines the endienness of the current machine in

// relation to the given input data.

//

// Returns:

// 1 if input is the same as nativeConstant.

// 0 if input is byteswapped relative to nativeConstant.

// -1 if input is not the same as nativeConstant and not byteswapped either.

//

// ( This is useful for detecting byteswapping in magic numbers in structure

// headers for example. )

//-----------------------------------------------------------------------------

template<typename T> inline int SourceIsNativeEndian( T input, T nativeConstant )

{

// If it's the same, it isn't byteswapped:

if( input == nativeConstant )

return 1;

int output;

LowLevelByteSwap<T>( &output, &input );

if( output == nativeConstant )

return 0;

assert( 0 ); // if we get here, input is neither a swapped nor unswapped version of nativeConstant.

return -1;

}

//-----------------------------------------------------------------------------

// Swaps an input buffer full of type T into the given output buffer.

//

// Swaps [count] items from the inputBuffer to the outputBuffer.

// If inputBuffer is omitted or NULL, then it is assumed to be the same as

// outputBuffer - effectively swapping the contents of the buffer in place.

//-----------------------------------------------------------------------------

template<typename T> inline void SwapBuffer( T* outputBuffer, T* inputBuffer = NULL, int count = 1 )

{

assert( count >= 0 );

assert( outputBuffer );

// Fail gracefully in release:

if( count <=0 || !outputBuffer )

return;

// Optimization for the case when we are swapping in place.

if( inputBuffer == NULL )

{

inputBuffer = outputBuffer;

}

// Swap everything in the buffer:

for( int i = 0; i < count; i++ )

{

LowLevelByteSwap<T>( &outputBuffer[i], &inputBuffer[i] );

}

}

//-----------------------------------------------------------------------------

// Swaps an input buffer full of type T into the given output buffer.

//

// Swaps [count] items from the inputBuffer to the outputBuffer.

// If inputBuffer is omitted or NULL, then it is assumed to be the same as

// outputBuffer - effectively swapping the contents of the buffer in place.

//-----------------------------------------------------------------------------

template<typename T> inline void SwapBufferToTargetEndian( T* outputBuffer, T* inputBuffer = NULL, int count = 1 )

{

assert( count >= 0 );

assert( outputBuffer );

// Fail gracefully in release:

if( count <=0 || !outputBuffer )

return;

// Optimization for the case when we are swapping in place.

if( inputBuffer == NULL )

{

inputBuffer = outputBuffer;

}

// Are we already the correct endienness? ( or are we swapping 1 byte items? )

if( !m_bSwapBytes || ( sizeof(T) == 1 ) )

{

// If we were just going to swap in place then return.

if( !inputBuffer )

return;

// Otherwise copy the inputBuffer to the outputBuffer:

memcpy( outputBuffer, inputBuffer, count * sizeof( T ) );

return;

}

// Swap everything in the buffer:

for( int i = 0; i < count; i++ )

{

LowLevelByteSwap<T>( &outputBuffer[i], &inputBuffer[i] );

}

}

private:

//-----------------------------------------------------------------------------

// The lowest level byte swapping workhorse of doom. output always contains the

// swapped version of input. ( Doesn't compare machine to target endianness )

//-----------------------------------------------------------------------------

template<typename T> static void LowLevelByteSwap( T *output, T *input )

{

T temp = *output;

#if defined( _X360 )

// Intrinsics need the source type to be fixed-point

DWORD* word = (DWORD*)input;

switch( sizeof(T) )

{

case 8:

{

__storewordbytereverse( *word, 0, &temp );

__storewordbytereverse( *(word+1), 4, &temp );

}

break;

case 4:

__storewordbytereverse( *word, 0, &temp );

break;

case 2:

__storeshortbytereverse( *input, 0, &temp );

break;

default:

Assert( "Invalid size in CByteswap::LowLevelByteSwap" && 0 );

}

#else

for( int i = 0; i < sizeof(T); i++ )

{

((unsigned char* )&temp)[i] = ((unsigned char*)input)[sizeof(T)-(i+1)];

}

#endif

Q_memcpy( output, &temp, sizeof(T) );

}

unsigned int m_bSwapBytes : 1;

unsigned int m_bBigEndian : 1;