Create a gist now

Instantly share code, notes, and snippets.

Delta Compression
/*
Delta Compression by Glenn Fiedler.
This source code is placed in the public domain.
http://gafferongames.com/2015/03/14/the-networked-physics-data-compression-challenge/
*/
#include <stdint.h>
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <math.h>
static const int MaxContexts = 8;
static const int NumCubes = 901;
static const int MaxPacketSize = 4 * 1024;
static const int UnitsPerMeter = 512;
static const int OrientationBits = 9;
static const int PositionBoundXY = 32;
static const int PositionBoundZ = 16;
static const int QuantizedPositionBoundXY = UnitsPerMeter * PositionBoundXY - 1;
static const int QuantizedPositionBoundZ = UnitsPerMeter * PositionBoundZ - 1;
template <uint32_t x> struct PopCount
{
enum { a = x - ( ( x >> 1 ) & 0x55555555 ),
b = ( ( ( a >> 2 ) & 0x33333333 ) + ( a & 0x33333333 ) ),
c = ( ( ( b >> 4 ) + b ) & 0x0f0f0f0f ),
d = c + ( c >> 8 ),
e = d + ( d >> 16 ),
result = e & 0x0000003f
};
};
template <uint32_t x> struct Log2
{
enum { a = x | ( x >> 1 ),
b = a | ( a >> 2 ),
c = b | ( b >> 4 ),
d = c | ( c >> 8 ),
e = d | ( d >> 16 ),
f = e >> 1,
result = PopCount<f>::result
};
};
template <int64_t min, int64_t max> struct BitsRequired
{
static const uint32_t result = ( min == max ) ? 0 : Log2<uint32_t(max-min)>::result + 1;
};
inline uint32_t popcount( uint32_t x )
{
const uint32_t a = x - ( ( x >> 1 ) & 0x55555555 );
const uint32_t b = ( ( ( a >> 2 ) & 0x33333333 ) + ( a & 0x33333333 ) );
const uint32_t c = ( ( ( b >> 4 ) + b ) & 0x0f0f0f0f );
const uint32_t d = c + ( c >> 8 );
const uint32_t e = d + ( d >> 16 );
const uint32_t result = e & 0x0000003f;
return result;
}
#ifdef __GNUC__
inline int bits_required( uint32_t min, uint32_t max )
{
return 32 - __builtin_clz( max - min );
}
#else
inline uint32_t log2( uint32_t x )
{
const uint32_t a = x | ( x >> 1 );
const uint32_t b = a | ( a >> 2 );
const uint32_t c = b | ( b >> 4 );
const uint32_t d = c | ( c >> 8 );
const uint32_t e = d | ( d >> 16 );
const uint32_t f = e >> 1;
return popcount( f );
}
inline int bits_required( uint32_t min, uint32_t max )
{
return ( min == max ) ? 0 : log2( max-min ) + 1;
}
#endif
template <typename T> const T & min( const T & a, const T & b )
{
return ( a < b ) ? a : b;
}
template <typename T> const T & max( const T & a, const T & b )
{
return ( a > b ) ? a : b;
}
template <typename T> T clamp( const T & value, const T & min, const T & max )
{
if ( value < min )
return min;
else if ( value > max )
return max;
else
return value;
}
template <typename T> void swap( T & a, T & b )
{
T tmp = a;
a = b;
b = tmp;
};
template <typename T> T abs( const T & value )
{
return ( value < 0 ) ? -value : value;
}
#define CPU_LITTLE_ENDIAN 1
#define CPU_BIG_ENDIAN 2
#if defined(__386__) || defined(i386) || defined(__i386__) \
|| defined(__X86) || defined(_M_IX86) \
|| defined(_M_X64) || defined(__x86_64__) \
|| defined(alpha) || defined(__alpha) || defined(__alpha__) \
|| defined(_M_ALPHA) \
|| defined(ARM) || defined(_ARM) || defined(__arm__) \
|| defined(WIN32) || defined(_WIN32) || defined(__WIN32__) \
|| defined(_WIN32_WCE) || defined(__NT__) \
|| defined(__MIPSEL__)
#define CPU_ENDIAN CPU_LITTLE_ENDIAN
#else
#define CPU_ENDIAN CPU_BIG_ENDIAN
#endif
inline uint32_t host_to_network( uint32_t value )
{
#if CPU_ENDIAN == CPU_BIG_ENDIAN
return __builtin_bswap32( value );
#else
return value;
#endif
}
inline uint32_t network_to_host( uint32_t value )
{
#if CPU_ENDIAN == CPU_BIG_ENDIAN
return __builtin_bswap32( value );
#else
return value;
#endif
}
class BitWriter
{
public:
BitWriter( void * data, int bytes ) : m_data( (uint32_t*)data ), m_numWords( bytes / 4 )
{
assert( data );
assert( ( bytes % 4 ) == 0 ); // IMPORTANT: buffer size must be a multiple of four!
m_numBits = m_numWords * 32;
m_bitsWritten = 0;
m_scratch = 0;
m_bitIndex = 0;
m_wordIndex = 0;
m_overflow = false;
memset( m_data, 0, bytes );
}
void WriteBits( uint32_t value, int bits )
{
assert( bits > 0 );
assert( bits <= 32 );
assert( m_bitsWritten + bits <= m_numBits );
if ( m_bitsWritten + bits > m_numBits )
{
m_overflow = true;
return;
}
value &= ( uint64_t( 1 ) << bits ) - 1;
m_scratch |= uint64_t( value ) << ( 64 - m_bitIndex - bits );
m_bitIndex += bits;
if ( m_bitIndex >= 32 )
{
assert( m_wordIndex < m_numWords );
m_data[m_wordIndex] = host_to_network( uint32_t( m_scratch >> 32 ) );
m_scratch <<= 32;
m_bitIndex -= 32;
m_wordIndex++;
}
m_bitsWritten += bits;
}
void WriteAlign()
{
const int remainderBits = m_bitsWritten % 8;
if ( remainderBits != 0 )
{
uint32_t zero = 0;
WriteBits( zero, 8 - remainderBits );
assert( m_bitsWritten % 8 == 0 );
}
}
void WriteBytes( const uint8_t * data, int bytes )
{
assert( GetAlignBits() == 0 );
if ( m_bitsWritten + bytes * 8 >= m_numBits )
{
m_overflow = true;
return;
}
assert( m_bitIndex == 0 || m_bitIndex == 8 || m_bitIndex == 16 || m_bitIndex == 24 );
int headBytes = ( 4 - m_bitIndex / 8 ) % 4;
if ( headBytes > bytes )
headBytes = bytes;
for ( int i = 0; i < headBytes; ++i )
WriteBits( data[i], 8 );
if ( headBytes == bytes )
return;
assert( GetAlignBits() == 0 );
int numWords = ( bytes - headBytes ) / 4;
if ( numWords > 0 )
{
assert( m_bitIndex == 0 );
memcpy( &m_data[m_wordIndex], data + headBytes, numWords * 4 );
m_bitsWritten += numWords * 32;
m_wordIndex += numWords;
m_scratch = 0;
}
assert( GetAlignBits() == 0 );
int tailStart = headBytes + numWords * 4;
int tailBytes = bytes - tailStart;
assert( tailBytes >= 0 && tailBytes < 4 );
for ( int i = 0; i < tailBytes; ++i )
WriteBits( data[tailStart+i], 8 );
assert( GetAlignBits() == 0 );
assert( headBytes + numWords * 4 + tailBytes == bytes );
}
void FlushBits()
{
if ( m_bitIndex != 0 )
{
assert( m_wordIndex < m_numWords );
if ( m_wordIndex >= m_numWords )
{
m_overflow = true;
return;
}
m_data[m_wordIndex++] = host_to_network( uint32_t( m_scratch >> 32 ) );
}
}
int GetAlignBits() const
{
return ( 8 - m_bitsWritten % 8 ) % 8;
}
int GetBitsWritten() const
{
return m_bitsWritten;
}
int GetBitsAvailable() const
{
return m_numBits - m_bitsWritten;
}
const uint8_t * GetData() const
{
return (uint8_t*) m_data;
}
int GetBytesWritten() const
{
return m_wordIndex * 4;
}
int GetTotalBytes() const
{
return m_numWords * 4;
}
bool IsOverflow() const
{
return m_overflow;
}
private:
uint32_t * m_data;
uint64_t m_scratch;
int m_numBits;
int m_numWords;
int m_bitsWritten;
int m_bitIndex;
int m_wordIndex;
bool m_overflow;
};
class BitReader
{
public:
BitReader( const void * data, int bytes ) : m_data( (const uint32_t*)data ), m_numWords( bytes / 4 )
{
assert( data );
assert( ( bytes % 4 ) == 0 ); // IMPORTANT: buffer size must be a multiple of four!
m_numBits = m_numWords * 32;
m_bitsRead = 0;
m_bitIndex = 0;
m_wordIndex = 0;
m_scratch = network_to_host( m_data[0] );
m_overflow = false;
}
uint32_t ReadBits( int bits )
{
assert( bits > 0 );
assert( bits <= 32 );
assert( m_bitsRead + bits <= m_numBits );
if ( m_bitsRead + bits > m_numBits )
{
m_overflow = true;
return 0;
}
m_bitsRead += bits;
assert( m_bitIndex < 32 );
if ( m_bitIndex + bits < 32 )
{
m_scratch <<= bits;
m_bitIndex += bits;
}
else
{
m_wordIndex++;
assert( m_wordIndex < m_numWords );
const uint32_t a = 32 - m_bitIndex;
const uint32_t b = bits - a;
m_scratch <<= a;
m_scratch |= network_to_host( m_data[m_wordIndex] );
m_scratch <<= b;
m_bitIndex = b;
}
const uint32_t output = uint32_t( m_scratch >> 32 );
m_scratch &= 0xFFFFFFFF;
return output;
}
void ReadAlign()
{
const int remainderBits = m_bitsRead % 8;
if ( remainderBits != 0 )
{
#ifdef NDEBUG
ReadBits( 8 - remainderBits );
#else
uint32_t value = ReadBits( 8 - remainderBits );
assert( value == 0 );
assert( m_bitsRead % 8 == 0 );
#endif
}
}
void ReadBytes( uint8_t * data, int bytes )
{
assert( GetAlignBits() == 0 );
if ( m_bitsRead + bytes * 8 >= m_numBits )
{
memset( data, 0, bytes );
m_overflow = true;
return;
}
assert( m_bitIndex == 0 || m_bitIndex == 8 || m_bitIndex == 16 || m_bitIndex == 24 );
int headBytes = ( 4 - m_bitIndex / 8 ) % 4;
if ( headBytes > bytes )
headBytes = bytes;
for ( int i = 0; i < headBytes; ++i )
data[i] = ReadBits( 8 );
if ( headBytes == bytes )
return;
assert( GetAlignBits() == 0 );
int numWords = ( bytes - headBytes ) / 4;
if ( numWords > 0 )
{
assert( m_bitIndex == 0 );
memcpy( data + headBytes, &m_data[m_wordIndex], numWords * 4 );
m_bitsRead += numWords * 32;
m_wordIndex += numWords;
m_scratch = network_to_host( m_data[m_wordIndex] );
}
assert( GetAlignBits() == 0 );
int tailStart = headBytes + numWords * 4;
int tailBytes = bytes - tailStart;
assert( tailBytes >= 0 && tailBytes < 4 );
for ( int i = 0; i < tailBytes; ++i )
data[tailStart+i] = ReadBits( 8 );
assert( GetAlignBits() == 0 );
assert( headBytes + numWords * 4 + tailBytes == bytes );
}
int GetAlignBits() const
{
return ( 8 - m_bitsRead % 8 ) % 8;
}
int GetBitsRead() const
{
return m_bitsRead;
}
int GetBytesRead() const
{
return ( m_wordIndex + 1 ) * 4;
}
int GetBitsRemaining() const
{
return m_numBits - m_bitsRead;
}
int GetTotalBits() const
{
return m_numBits;
}
int GetTotalBytes() const
{
return m_numBits * 8;
}
bool IsOverflow() const
{
return m_overflow;
}
private:
const uint32_t * m_data;
uint64_t m_scratch;
int m_numBits;
int m_numWords;
int m_bitsRead;
int m_bitIndex;
int m_wordIndex;
bool m_overflow;
};
class WriteStream
{
public:
enum { IsWriting = 1 };
enum { IsReading = 0 };
WriteStream( uint8_t * buffer, int bytes ) : m_writer( buffer, bytes ), m_context( nullptr ), m_aborted( false ) {}
void SerializeInteger( int32_t value, int32_t min, int32_t max )
{
assert( min < max );
assert( value >= min );
assert( value <= max );
const int bits = bits_required( min, max );
uint32_t unsigned_value = value - min;
m_writer.WriteBits( unsigned_value, bits );
}
void SerializeBits( uint32_t value, int bits )
{
assert( bits > 0 );
assert( bits <= 32 );
m_writer.WriteBits( value, bits );
}
void SerializeBytes( const uint8_t * data, int bytes )
{
Align();
m_writer.WriteBytes( data, bytes );
}
void Align()
{
m_writer.WriteAlign();
}
int GetAlignBits() const
{
return m_writer.GetAlignBits();
}
bool Check( uint32_t magic )
{
Align();
SerializeBits( magic, 32 );
return true;
}
void Flush()
{
m_writer.FlushBits();
}
const uint8_t * GetData() const
{
return m_writer.GetData();
}
int GetBytesProcessed() const
{
return m_writer.GetBytesWritten();
}
int GetBitsProcessed() const
{
return m_writer.GetBitsWritten();
}
int GetBitsRemaining() const
{
return GetTotalBits() - GetBitsProcessed();
}
int GetTotalBits() const
{
return m_writer.GetTotalBytes() * 8;
}
int GetTotalBytes() const
{
return m_writer.GetTotalBytes();
}
bool IsOverflow() const
{
return m_writer.IsOverflow();
}
void SetContext( const void ** context )
{
m_context = context;
}
const void * GetContext( int index ) const
{
assert( index >= 0 );
assert( index < MaxContexts );
return m_context ? m_context[index] : nullptr;
}
void Abort()
{
m_aborted = true;
}
bool Aborted() const
{
return m_aborted;
}
private:
BitWriter m_writer;
const void ** m_context;
bool m_aborted;
};
class ReadStream
{
public:
enum { IsWriting = 0 };
enum { IsReading = 1 };
ReadStream( uint8_t * buffer, int bytes ) : m_bitsRead(0), m_reader( buffer, bytes ), m_context( nullptr ), m_aborted( false ) {}
void SerializeInteger( int32_t & value, int32_t min, int32_t max )
{
assert( min < max );
const int bits = bits_required( min, max );
uint32_t unsigned_value = m_reader.ReadBits( bits );
value = (int32_t) unsigned_value + min;
m_bitsRead += bits;
}
void SerializeBits( uint32_t & value, int bits )
{
assert( bits > 0 );
assert( bits <= 32 );
uint32_t read_value = m_reader.ReadBits( bits );
value = read_value;
m_bitsRead += bits;
}
void SerializeBytes( uint8_t * data, int bytes )
{
Align();
m_reader.ReadBytes( data, bytes );
m_bitsRead += bytes * 8;
}
void Align()
{
m_reader.ReadAlign();
}
int GetAlignBits() const
{
return m_reader.GetAlignBits();
}
bool Check( uint32_t magic )
{
Align();
uint32_t value = 0;
SerializeBits( value, 32 );
assert( value == magic );
return value == magic;
}
int GetBitsProcessed() const
{
return m_bitsRead;
}
int GetBytesProcessed() const
{
return m_bitsRead / 8 + ( m_bitsRead % 8 ? 1 : 0 );
}
bool IsOverflow() const
{
return m_reader.IsOverflow();
}
void SetContext( const void ** context )
{
m_context = context;
}
const void * GetContext( int index ) const
{
assert( index >= 0 );
assert( index < MaxContexts );
return m_context ? m_context[index] : nullptr;
}
void Abort()
{
m_aborted = true;
}
bool Aborted() const
{
return m_aborted;
}
int GetBytesRead() const
{
return m_reader.GetBytesRead();
}
private:
int m_bitsRead;
BitReader m_reader;
const void ** m_context;
bool m_aborted;
};
class MeasureStream
{
public:
enum { IsWriting = 1 };
enum { IsReading = 0 };
MeasureStream( int bytes ) : m_totalBytes( bytes ), m_bitsWritten(0), m_context( nullptr ), m_aborted( false ) {}
void SerializeInteger( int32_t value, int32_t min, int32_t max )
{
assert( min < max );
assert( value >= min );
assert( value <= max );
const int bits = bits_required( min, max );
m_bitsWritten += bits;
}
void SerializeBits( uint32_t value, int bits )
{
assert( bits > 0 );
assert( bits <= 32 );
m_bitsWritten += bits;
}
void SerializeBytes( const uint8_t * data, int bytes )
{
Align();
m_bitsWritten += bytes * 8;
}
void Align()
{
const int alignBits = GetAlignBits();
m_bitsWritten += alignBits;
}
int GetAlignBits() const
{
return 7; // worst case
}
bool Check( uint32_t magic )
{
Align();
m_bitsWritten += 32;
return true;
}
int GetBitsProcessed() const
{
return m_bitsWritten;
}
int GetBytesProcessed() const
{
return m_bitsWritten / 8 + ( m_bitsWritten % 8 ? 1 : 0 );
}
int GetTotalBytes() const
{
return m_totalBytes;
}
int GetTotalBits() const
{
return m_totalBytes * 8;
}
bool IsOverflow() const
{
return m_bitsWritten > m_totalBytes * 8;
}
void SetContext( const void ** context )
{
m_context = context;
}
const void * GetContext( int index ) const
{
assert( index >= 0 );
assert( index < MaxContexts );
return m_context ? m_context[index] : nullptr;
}
void Abort()
{
m_aborted = true;
}
bool Aborted() const
{
return m_aborted;
}
private:
int m_totalBytes;
int m_bitsWritten;
const void ** m_context;
bool m_aborted;
};
template <typename T> void serialize_object( ReadStream & stream, T & object )
{
object.SerializeRead( stream );
}
template <typename T> void serialize_object( WriteStream & stream, T & object )
{
object.SerializeWrite( stream );
}
template <typename T> void serialize_object( MeasureStream & stream, T & object )
{
object.SerializeMeasure( stream );
}
#define serialize_int( stream, value, min, max ) \
do \
{ \
assert( min < max ); \
int32_t int32_value; \
if ( Stream::IsWriting ) \
{ \
assert( value >= min ); \
assert( value <= max ); \
int32_value = (int32_t) value; \
} \
stream.SerializeInteger( int32_value, min, max ); \
if ( Stream::IsReading ) \
{ \
value = (decltype(value)) int32_value; \
assert( value >= min ); \
assert( value <= max ); \
} \
} while (0)
#define serialize_bits( stream, value, bits ) \
do \
{ \
assert( bits > 0 ); \
assert( bits <= 32 ); \
uint32_t uint32_value; \
if ( Stream::IsWriting ) \
uint32_value = (uint32_t) value; \
stream.SerializeBits( uint32_value, bits ); \
if ( Stream::IsReading ) \
value = (decltype(value)) uint32_value; \
} while (0)
#define serialize_bool( stream, value ) serialize_bits( stream, value, 1 )
template <typename Stream> void serialize_uint16( Stream & stream, uint16_t & value )
{
serialize_bits( stream, value, 16 );
}
template <typename Stream> void serialize_uint32( Stream & stream, uint32_t & value )
{
serialize_bits( stream, value, 32 );
}
template <typename Stream> void serialize_uint64( Stream & stream, uint64_t & value )
{
uint32_t hi,lo;
if ( Stream::IsWriting )
{
lo = value & 0xFFFFFFFF;
hi = value >> 32;
}
serialize_bits( stream, lo, 32 );
serialize_bits( stream, hi, 32 );
if ( Stream::IsReading )
value = ( uint64_t(hi) << 32 ) | lo;
}
template <typename Stream> void serialize_int16( Stream & stream, int16_t & value )
{
serialize_bits( stream, value, 16 );
}
template <typename Stream> void serialize_int32( Stream & stream, int32_t & value )
{
serialize_bits( stream, value, 32 );
}
template <typename Stream> void serialize_int64( Stream & stream, int64_t & value )
{
uint32_t hi,lo;
if ( Stream::IsWriting )
{
lo = uint64_t(value) & 0xFFFFFFFF;
hi = uint64_t(value) >> 32;
}
serialize_bits( stream, lo, 32 );
serialize_bits( stream, hi, 32 );
if ( Stream::IsReading )
value = ( int64_t(hi) << 32 ) | lo;
}
template <typename Stream> void serialize_float( Stream & stream, float & value )
{
union FloatInt
{
float float_value;
uint32_t int_value;
};
FloatInt tmp;
if ( Stream::IsWriting )
tmp.float_value = value;
serialize_uint32( stream, tmp.int_value );
if ( Stream::IsReading )
value = tmp.float_value;
}
template <typename Stream> inline void internal_serialize_float( Stream & stream, float & value, float min, float max, float res )
{
const float delta = max - min;
const float values = delta / res;
const uint32_t maxIntegerValue = (uint32_t) ceil( values );
const int bits = bits_required( 0, maxIntegerValue );
uint32_t integerValue = 0;
if ( Stream::IsWriting )
{
float normalizedValue = clamp( ( value - min ) / delta, 0.0f, 1.0f );
integerValue = (uint32_t) floor( normalizedValue * maxIntegerValue + 0.5f );
}
stream.SerializeBits( integerValue, bits );
if ( Stream::IsReading )
{
const float normalizedValue = integerValue / float( maxIntegerValue );
value = normalizedValue * delta + min;
}
}
#define serialize_compressed_float( stream, value, min, max, res ) \
do \
{ \
internal_serialize_float( stream, value, min, max, res ); \
} \
while(0)
template <typename Stream> void serialize_double( Stream & stream, double & value )
{
union DoubleInt
{
double double_value;
uint64_t int_value;
};
DoubleInt tmp;
if ( Stream::IsWriting )
tmp.double_value = value;
serialize_uint64( stream, tmp.int_value );
if ( Stream::IsReading )
value = tmp.double_value;
}
template <typename Stream> void serialize_bytes( Stream & stream, uint8_t * data, int bytes )
{
stream.SerializeBytes( data, bytes );
}
template <typename Stream> void serialize_string( Stream & stream, char * string, int buffer_size )
{
uint32_t length;
if ( Stream::IsWriting )
length = strlen( string );
stream.Align();
stream.SerializeBits( length, 32 );
assert( length < buffer_size - 1 );
stream.SerializeBytes( (uint8_t*)string, length );
if ( Stream::IsReading )
string[length] = '\0';
}
template <typename Stream> bool serialize_check( Stream & stream, uint32_t magic )
{
return stream.Check( magic );
}
#define SERIALIZE_OBJECT( stream ) \
void SerializeRead( class ReadStream & stream ) { Serialize( stream ); }; \
void SerializeWrite( class WriteStream & stream ) { Serialize( stream ); }; \
void SerializeMeasure( class MeasureStream & stream ) { Serialize( stream ); }; \
template <typename Stream> void Serialize( Stream & stream )
template <int bits> struct compressed_quaternion
{
enum { max_value = (1<<bits)-1 };
uint32_t largest : 2;
uint32_t integer_a : bits;
uint32_t integer_b : bits;
uint32_t integer_c : bits;
void Load( float x, float y, float z, float w )
{
assert( bits > 1 );
assert( bits <= 10 );
const float minimum = - 1.0f / 1.414214f; // 1.0f / sqrt(2)
const float maximum = + 1.0f / 1.414214f;
const float scale = float( ( 1 << bits ) - 1 );
const float abs_x = fabs( x );
const float abs_y = fabs( y );
const float abs_z = fabs( z );
const float abs_w = fabs( w );
largest = 0;
float largest_value = abs_x;
if ( abs_y > largest_value )
{
largest = 1;
largest_value = abs_y;
}
if ( abs_z > largest_value )
{
largest = 2;
largest_value = abs_z;
}
if ( abs_w > largest_value )
{
largest = 3;
largest_value = abs_w;
}
float a = 0;
float b = 0;
float c = 0;
switch ( largest )
{
case 0:
if ( x >= 0 )
{
a = y;
b = z;
c = w;
}
else
{
a = -y;
b = -z;
c = -w;
}
break;
case 1:
if ( y >= 0 )
{
a = x;
b = z;
c = w;
}
else
{
a = -x;
b = -z;
c = -w;
}
break;
case 2:
if ( z >= 0 )
{
a = x;
b = y;
c = w;
}
else
{
a = -x;
b = -y;
c = -w;
}
break;
case 3:
if ( w >= 0 )
{
a = x;
b = y;
c = z;
}
else
{
a = -x;
b = -y;
c = -z;
}
break;
default:
assert( false );
}
const float normal_a = ( a - minimum ) / ( maximum - minimum );
const float normal_b = ( b - minimum ) / ( maximum - minimum );
const float normal_c = ( c - minimum ) / ( maximum - minimum );
integer_a = floor( normal_a * scale + 0.5f );
integer_b = floor( normal_b * scale + 0.5f );
integer_c = floor( normal_c * scale + 0.5f );
}
void Save( float & x, float & y, float & z, float & w ) const
{
// note: you're going to want to normalize the quaternion returned from this function
assert( bits > 1 );
assert( bits <= 10 );
const float minimum = - 1.0f / 1.414214f; // 1.0f / sqrt(2)
const float maximum = + 1.0f / 1.414214f;
const float scale = float( ( 1 << bits ) - 1 );
const float inverse_scale = 1.0f / scale;
const float a = integer_a * inverse_scale * ( maximum - minimum ) + minimum;
const float b = integer_b * inverse_scale * ( maximum - minimum ) + minimum;
const float c = integer_c * inverse_scale * ( maximum - minimum ) + minimum;
switch ( largest )
{
case 0:
{
x = sqrtf( 1 - a*a - b*b - c*c );
y = a;
z = b;
w = c;
}
break;
case 1:
{
x = a;
y = sqrtf( 1 - a*a - b*b - c*c );
z = b;
w = c;
}
break;
case 2:
{
x = a;
y = b;
z = sqrtf( 1 - a*a - b*b - c*c );
w = c;
}
break;
case 3:
{
x = a;
y = b;
z = c;
w = sqrtf( 1 - a*a - b*b - c*c );
}
break;
default:
{
assert( false );
x = 0;
y = 0;
z = 0;
w = 1;
}
}
}
SERIALIZE_OBJECT( stream )
{
serialize_bits( stream, largest, 2 );
serialize_bits( stream, integer_a, bits );
serialize_bits( stream, integer_b, bits );
serialize_bits( stream, integer_c, bits );
}
bool operator == ( const compressed_quaternion & other ) const
{
if ( largest != other.largest )
return false;
if ( integer_a != other.integer_a )
return false;
if ( integer_b != other.integer_b )
return false;
if ( integer_c != other.integer_c )
return false;
return true;
}
bool operator != ( const compressed_quaternion & other ) const
{
return ! ( *this == other );
}
};
inline int count_relative_index_bits( bool * changed )
{
int bits = 8; // 0..255 num changed
bool first = true;
int previous_index = 0;
for ( int i = 0; i < NumCubes; ++i )
{
if ( !changed[i] )
continue;
if ( first )
{
bits += 10;
first = false;
previous_index = i;
}
else
{
const int difference = i - previous_index;
if ( difference == 1 )
{
bits += 1;
}
else if ( difference <= 6 )
{
bits += 1 + 1 + 2;
}
else if ( difference <= 14 )
{
bits += 1 + 1 + 1 + 3;
}
else if ( difference <= 30 )
{
bits += 1 + 1 + 1 + 1 + 4;
}
else if ( difference <= 62 )
{
bits += 1 + 1 + 1 + 1 + 1 + 5;
}
else if ( difference <= 126 )
{
bits += 1 + 1 + 1 + 1 + 1 + 1 + 6;
}
else
{
bits += 1 + 1 + 1 + 1 + 1 + 1 + 1 + 10;
}
previous_index = i;
}
}
return bits;
}
template <typename Stream> void serialize_relative_index( Stream & stream, int previous, int & current )
{
uint32_t difference;
if ( Stream::IsWriting )
{
assert( previous < current );
difference = current - previous;
assert( difference > 0 );
}
// +1 (1 bit)
bool plusOne;
if ( Stream::IsWriting )
plusOne = difference == 1;
serialize_bool( stream, plusOne );
if ( plusOne )
{
current = previous + 1;
return;
}
// [+2,6] (2 bits)
bool twoBits;
if ( Stream::IsWriting )
twoBits = difference <= 6;
serialize_bool( stream, twoBits );
if ( twoBits )
{
serialize_int( stream, difference, 2, 6 );
if ( Stream::IsReading )
current = previous + difference;
return;
}
// [7,14] -> [0,7] (3 bits)
bool threeBits;
if ( Stream::IsWriting )
threeBits = difference <= 14;
serialize_bool( stream, threeBits );
if ( threeBits )
{
serialize_int( stream, difference, 7, 14 );
if ( Stream::IsReading )
current = previous + difference;
return;
}
// [15,30] -> [0,15] (4 bits)
bool fourBits;
if ( Stream::IsWriting )
fourBits = difference <= 30;
serialize_bool( stream, fourBits );
if ( fourBits )
{
serialize_int( stream, difference, 15, 30 );
if ( Stream::IsReading )
current = previous + difference;
return;
}
// [31,62] -> [0,31] (5 bits)
bool fiveBits;
if ( Stream::IsWriting )
fiveBits = difference <= 62;
serialize_bool( stream, fiveBits );
if ( fiveBits )
{
serialize_int( stream, difference, 31, 62 );
if ( Stream::IsReading )
current = previous + difference;
return;
}
// [63,126] -> [0,63] (6 bits)
bool sixBits;
if ( Stream::IsWriting )
sixBits = difference <= 126;
serialize_bool( stream, sixBits );
if ( sixBits )
{
serialize_int( stream, difference, 63, 126 );
if ( Stream::IsReading )
current = previous + difference;
return;
}
// [127,NumCubes]
serialize_int( stream, difference, 127, NumCubes - 1 );
if ( Stream::IsReading )
current = previous + difference;
}
struct QuantizedCubeState
{
bool interacting;
int position_x;
int position_y;
int position_z;
compressed_quaternion<OrientationBits> orientation;
bool operator == ( const QuantizedCubeState & other ) const
{
if ( interacting != other.interacting )
return false;
if ( position_x != other.position_x )
return false;
if ( position_y != other.position_y )
return false;
if ( position_z != other.position_z )
return false;
if ( orientation != other.orientation )
return false;
return true;
}
bool operator != ( const QuantizedCubeState & other ) const
{
return ! ( *this == other );
}
};
struct QuantizedSnapshot
{
QuantizedCubeState cubes[NumCubes];
bool operator == ( const QuantizedSnapshot & other ) const
{
for ( int i = 0; i < NumCubes; ++i )
{
if ( cubes[i] != other.cubes[i] )
return false;
}
return true;
}
bool operator != ( const QuantizedSnapshot & other ) const
{
return ! ( *this == other );
}
};
inline int signed_to_unsigned( int n )
{
return ( n << 1 ) ^ ( n >> 31 );
}
inline int unsigned_to_signed( uint32_t n )
{
return ( n >> 1 ) ^ ( -( n & 1 ) );
}
template <typename Stream> void serialize_unsigned_range( Stream & stream, uint32_t & value, int num_ranges, const int * range_bits )
{
assert( num_ranges > 0 );
int range_min = 0;
for ( int i = 0; i < num_ranges - 1; ++i )
{
const int range_max = range_min + ( ( 1 << range_bits[i] ) - 1 );
bool in_range = Stream::IsWriting && value <= range_max;
serialize_bool( stream, in_range );
if ( in_range )
{
serialize_int( stream, value, range_min, range_max );
return;
}
range_min += ( 1 << range_bits[i] );
}
serialize_int( stream, value, range_min, range_min + ( ( 1 << range_bits[num_ranges-1] ) - 1 ) );
}
inline int unsigned_range_limit( int num_ranges, const int * range_bits )
{
int range_limit = 0;
for ( int i = 0; i < num_ranges; ++i )
range_limit += ( 1 << range_bits[i] );
return range_limit;
}
template <typename Stream> void serialize_relative_position( Stream & stream,
int & position_x,
int & position_y,
int & position_z,
int base_position_x,
int base_position_y,
int base_position_z )
{
bool all_small;
bool too_large;
uint32_t dx,dy,dz;
const int range_bits[] = { 5, 6, 7 };
const int num_ranges = sizeof( range_bits ) / sizeof( int );
const int small_limit = 15;
const int large_limit = unsigned_range_limit( num_ranges, range_bits );
const int max_delta = 2047;
if ( Stream::IsWriting )
{
dx = signed_to_unsigned( position_x - base_position_x );
dy = signed_to_unsigned( position_y - base_position_y );
dz = signed_to_unsigned( position_z - base_position_z );
all_small = dx <= small_limit && dy <= small_limit && dz <= small_limit;
too_large = dx >= large_limit || dy >= large_limit || dz >= large_limit;
}
serialize_bool( stream, all_small );
if ( all_small )
{
serialize_int( stream, dx, 0, small_limit );
serialize_int( stream, dy, 0, small_limit );
serialize_int( stream, dz, 0, small_limit );
}
else
{
serialize_bool( stream, too_large );
if ( !too_large )
{
serialize_unsigned_range( stream, dx, num_ranges, range_bits );
serialize_unsigned_range( stream, dy, num_ranges, range_bits );
serialize_unsigned_range( stream, dz, num_ranges, range_bits );
}
else
{
serialize_int( stream, dx, 0, max_delta );
serialize_int( stream, dy, 0, max_delta );
serialize_int( stream, dz, 0, max_delta );
}
}
if ( Stream::IsReading )
{
int signed_dx = unsigned_to_signed( dx );
int signed_dy = unsigned_to_signed( dy );
int signed_dz = unsigned_to_signed( dz );
position_x = base_position_x + signed_dx;
position_y = base_position_y + signed_dy;
position_z = base_position_z + signed_dz;
}
}
template <typename Stream> void serialize_relative_orientation( Stream & stream,
compressed_quaternion<OrientationBits> & orientation,
const compressed_quaternion<OrientationBits> & base_orientation )
{
const int range_bits[] = { 4, 5, 7 };
const int num_ranges = sizeof( range_bits ) / sizeof( int );
const int small_limit = 3;
const int large_limit = unsigned_range_limit( num_ranges, range_bits );
uint32_t da,db,dc;
bool all_small = false;
bool relative_orientation = false;
if ( Stream::IsWriting && orientation.largest == base_orientation.largest )
{
da = signed_to_unsigned( orientation.integer_a - base_orientation.integer_a );
db = signed_to_unsigned( orientation.integer_b - base_orientation.integer_b );
dc = signed_to_unsigned( orientation.integer_c - base_orientation.integer_c );
all_small = da <= small_limit && db <= small_limit && dc <= small_limit;
relative_orientation = da < large_limit && db < large_limit && dc < large_limit;
}
serialize_bool( stream, relative_orientation );
if ( relative_orientation )
{
serialize_bool( stream, all_small );
if ( all_small )
{
serialize_int( stream, da, 0, small_limit );
serialize_int( stream, db, 0, small_limit );
serialize_int( stream, dc, 0, small_limit );
}
else
{
serialize_unsigned_range( stream, da, num_ranges, range_bits );
serialize_unsigned_range( stream, db, num_ranges, range_bits );
serialize_unsigned_range( stream, dc, num_ranges, range_bits );
}
if ( Stream::IsReading )
{
int signed_da = unsigned_to_signed( da );
int signed_db = unsigned_to_signed( db );
int signed_dc = unsigned_to_signed( dc );
orientation.largest = base_orientation.largest;
orientation.integer_a = base_orientation.integer_a + signed_da;
orientation.integer_b = base_orientation.integer_b + signed_db;
orientation.integer_c = base_orientation.integer_c + signed_dc;
}
}
else
{
serialize_object( stream, orientation );
}
}
template <typename Stream> void serialize_cube_relative_to_base( Stream & stream, QuantizedCubeState & cube, const QuantizedCubeState & base, int base_dx, int base_dy, int base_dz )
{
serialize_bool( stream, cube.interacting );
bool position_changed;
if ( Stream::IsWriting )
position_changed = cube.position_x != base.position_x || cube.position_y != base.position_y || cube.position_z != base.position_z;
serialize_bool( stream, position_changed );
if ( position_changed )
{
const int gravity = 3;
const int ground_limit = 105;
const int drag_x = - ceil( base_dx * 0.062f );
const int drag_y = - ceil( base_dy * 0.062f );
const int drag_z = - ceil( base_dz * 0.062f );
const int position_estimate_x = base.position_x + base_dx + drag_x;
const int position_estimate_y = base.position_y + base_dy + drag_y;
const int position_estimate_z = max( base.position_z + base_dz - gravity + drag_z, ground_limit );
serialize_relative_position( stream, cube.position_x, cube.position_y, cube.position_z, position_estimate_x, position_estimate_y, position_estimate_z );
}
else if ( Stream::IsReading )
{
cube.position_x = base.position_x;
cube.position_y = base.position_y;
cube.position_z = base.position_z;
}
serialize_relative_orientation( stream, cube.orientation, base.orientation );
}
struct CompressionState
{
float delta_x[NumCubes];
float delta_y[NumCubes];
float delta_z[NumCubes];
};
void calculate_compression_state( CompressionState & compression_state, QuantizedSnapshot & current_snapshot, QuantizedSnapshot & baseline_snapshot )
{
for ( int i = 0; i < NumCubes; ++i )
{
compression_state.delta_x[i] = current_snapshot.cubes[i].position_x - baseline_snapshot.cubes[i].position_x;
compression_state.delta_y[i] = current_snapshot.cubes[i].position_y - baseline_snapshot.cubes[i].position_y;
compression_state.delta_z[i] = current_snapshot.cubes[i].position_z - baseline_snapshot.cubes[i].position_z;
}
}
template <typename Stream> void serialize_snapshot_relative_to_baseline( Stream & stream, CompressionState & compression_state, QuantizedSnapshot & current_snapshot, QuantizedSnapshot & baseline_snapshot )
{
QuantizedCubeState * quantized_cubes = &current_snapshot.cubes[0];
QuantizedCubeState * quantized_base_cubes = &baseline_snapshot.cubes[0];
const int MaxChanged = 256;
int num_changed = 0;
bool use_indices = false;
bool changed[NumCubes];
if ( Stream::IsWriting )
{
for ( int i = 0; i < NumCubes; ++i )
{
changed[i] = quantized_cubes[i] != quantized_base_cubes[i];
if ( changed[i] )
num_changed++;
}
if ( num_changed > 0 )
{
int relative_index_bits = count_relative_index_bits( changed );
if ( num_changed <= MaxChanged && relative_index_bits <= NumCubes )
use_indices = true;
}
}
serialize_bool( stream, use_indices );
if ( use_indices )
{
serialize_int( stream, num_changed, 1, MaxChanged );
if ( Stream::IsWriting )
{
int num_written = 0;
bool first = true;
int previous_index = 0;
for ( int i = 0; i < NumCubes; ++i )
{
if ( changed[i] )
{
if ( first )
{
serialize_int( stream, i, 0, NumCubes - 1 );
first = false;
}
else
{
serialize_relative_index( stream, previous_index, i );
}
serialize_cube_relative_to_base( stream, quantized_cubes[i], quantized_base_cubes[i], compression_state.delta_x[i], compression_state.delta_y[i], compression_state.delta_z[i] );
num_written++;
previous_index = i;
}
}
assert( num_written == num_changed );
}
else
{
memset( changed, 0, sizeof( changed ) );
int previous_index = 0;
for ( int j = 0; j < num_changed; ++j )
{
int i;
if ( j == 0 )
serialize_int( stream, i, 0, NumCubes - 1 );
else
serialize_relative_index( stream, previous_index, i );
serialize_cube_relative_to_base( stream, quantized_cubes[i], quantized_base_cubes[i], compression_state.delta_x[i], compression_state.delta_y[i], compression_state.delta_z[i] );
changed[i] = true;
previous_index = i;
}
for ( int i = 0; i < NumCubes; ++i )
{
if ( !changed[i] )
memcpy( &quantized_cubes[i], &quantized_base_cubes[i], sizeof( QuantizedCubeState ) );
}
}
}
else
{
for ( int i = 0; i < NumCubes; ++i )
{
serialize_bool( stream, changed[i] );
if ( changed[i] )
{
serialize_cube_relative_to_base( stream, quantized_cubes[i], quantized_base_cubes[i], compression_state.delta_x[i], compression_state.delta_y[i], compression_state.delta_z[i] );
}
else if ( Stream::IsReading )
{
memcpy( &quantized_cubes[i], &quantized_base_cubes[i], sizeof( QuantizedCubeState ) );
}
}
}
}
struct FrameCubeData
{
int orientation_largest;
int orientation_a;
int orientation_b;
int orientation_c;
int position_x;
int position_y;
int position_z;
int interacting;
};
struct Frame
{
FrameCubeData cubes[NumCubes];
};
struct Packet
{
int size;
uint8_t data[MaxPacketSize];
};
void convert_frame_to_snapshot( const Frame & frame, QuantizedSnapshot & snapshot )
{
for ( int j = 0; j < NumCubes; ++j )
{
assert( frame.cubes[j].orientation_largest >= 0 );
assert( frame.cubes[j].orientation_largest <= 3 );
snapshot.cubes[j].orientation.largest = frame.cubes[j].orientation_largest;
assert( frame.cubes[j].orientation_a >= 0 );
assert( frame.cubes[j].orientation_b >= 0 );
assert( frame.cubes[j].orientation_c >= 0 );
assert( frame.cubes[j].orientation_a <= ( 1 << OrientationBits ) - 1 );
assert( frame.cubes[j].orientation_b <= ( 1 << OrientationBits ) - 1 );
assert( frame.cubes[j].orientation_c <= ( 1 << OrientationBits ) - 1 );
snapshot.cubes[j].orientation.integer_a = frame.cubes[j].orientation_a;
snapshot.cubes[j].orientation.integer_b = frame.cubes[j].orientation_b;
snapshot.cubes[j].orientation.integer_c = frame.cubes[j].orientation_c;
assert( frame.cubes[j].position_x >= -QuantizedPositionBoundXY );
assert( frame.cubes[j].position_y >= -QuantizedPositionBoundXY );
assert( frame.cubes[j].position_z >= 0 );
assert( frame.cubes[j].position_x <= QuantizedPositionBoundXY );
assert( frame.cubes[j].position_y <= QuantizedPositionBoundXY );
assert( frame.cubes[j].position_z <= QuantizedPositionBoundZ );
snapshot.cubes[j].position_x = frame.cubes[j].position_x;
snapshot.cubes[j].position_y = frame.cubes[j].position_y;
snapshot.cubes[j].position_z = frame.cubes[j].position_z;
assert( frame.cubes[j].interacting == 0 || frame.cubes[j].interacting == 1 );
snapshot.cubes[j].interacting = frame.cubes[j].interacting;
}
}
int main( int argc, char ** argv )
{
FILE * file = fopen( "delta_data.bin", "rb" );
if ( !file )
{
printf( "error: can't open file\n" );
return 1;
}
// count number of frames in file
fseek( file, 0L, SEEK_END );
uint64_t file_size = ftell( file );
fseek( file, 0L, SEEK_SET );
const int num_frames = (int) floor( double(file_size) / sizeof( Frame ) );
printf( "%d input frames\n", num_frames );
assert( num_frames > 6 );
// read in frames
Frame * frames = new Frame[num_frames];
uint64_t frames_read = fread( frames, sizeof( Frame ), num_frames, file );
assert( frames_read == num_frames );
fclose( file );
// convert frames to snapshots
QuantizedSnapshot * snapshots = new QuantizedSnapshot[num_frames];
for ( int i = 0; i < num_frames; ++i )
convert_frame_to_snapshot( frames[i], snapshots[i] );
// write packets
const int num_packets = num_frames - 6;
printf( "writing %d packets\n", num_packets );
assert( num_packets > 0 );
CompressionState * compression_state = new CompressionState[num_frames];
int packet_index = 0;
Packet * packets = new Packet[num_packets];
uint64_t total_bytes = 0;
for ( int i = 6; i < num_frames; ++i )
{
Packet & packet = packets[packet_index];
WriteStream stream( packet.data, MaxPacketSize );
QuantizedSnapshot & current_snapshot = snapshots[i];
QuantizedSnapshot & baseline_snapshot = snapshots[i-6];
calculate_compression_state( compression_state[i], current_snapshot, baseline_snapshot );
serialize_snapshot_relative_to_baseline( stream, compression_state[i-6], current_snapshot, baseline_snapshot );
stream.Flush();
int bits_written = stream.GetBitsProcessed();
int bytes_written = ( bits_written / 8 ) + ( ( bits_written % 8 ) ? 1 : 0 );
while ( packet.data[bytes_written] == 0 && bytes_written > 0 )
--bytes_written;
assert( bytes_written >= 0 );
packet.size = bytes_written;
total_bytes += bytes_written;
++packet_index;
}
// read packets and verify reconstruction of snapshot
printf( "reading %d packets\n", num_packets );
for ( int i = 0; i < num_packets; ++i )
{
Packet & packet = packets[i];
ReadStream stream( packet.data, MaxPacketSize );
QuantizedSnapshot current_snapshot;
QuantizedSnapshot & baseline_snapshot = snapshots[i];
serialize_snapshot_relative_to_baseline( stream, compression_state[i], current_snapshot, baseline_snapshot );
assert( current_snapshot == snapshots[i+6] );
}
printf( "all packets verify ok!\n" );
// print results
printf( "total packet bytes: %llu\n", total_bytes );
printf( "average bytes per-packet: %f\n", total_bytes / double(num_packets) );
printf( "average bytes per-second: %f\n", total_bytes / double(num_packets) * 60 * 8 );
printf( "average kilobits per-second: %f\n", total_bytes / double(num_packets) * 60 * 8 / 1000.0 );
printf( "compression ratio: %.2f%% of original size\n", total_bytes / ( num_packets * ( 4 + 3 + 3 ) * 32 * NumCubes / 8.0 ) * 100.0 );
// clean up everything
delete [] snapshots;
delete [] packets;
delete [] frames;
return 0;
}
/*
2837 input frames
writing 2831 packets
reading 2831 packets
all packets verify ok!
total packet bytes: 1505956
average bytes per-packet: 531.951960
average bytes per-second: 255336.941010
average kilobits per-second: 255.336941
compression ratio: 1.48% of original size
*/
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment