//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============// // // Purpose: // // $NoKeywords: $ // //=============================================================================// #include "bitbuf.h" #include "coordsize.h" #include "mathlib/vector.h" #include "mathlib/mathlib.h" #include "tier1/strtools.h" #include "bitvec.h" #include "vstdlib/random.h" // FIXME: Can't use this until we get multithreaded allocations in tier0 working for tools // This is used by VVIS and fails to link // NOTE: This must be the last file included!!! //#include "tier0/memdbgon.h" #ifdef _X360 // mandatory ... wary of above comment and isolating, tier0 is built as MT though #include "tier0/memdbgon.h" #endif #include "stdio.h" #ifndef NDEBUG static volatile char const *pDebugString; #define DEBUG_LINK_CHECK pDebugString = "tier1.lib built debug!" #else #define DEBUG_LINK_CHECK #endif void CBitWrite::StartWriting( void *pData, int nBytes, int iStartBit, int nBits ) { // Make sure it's dword aligned and padded. DEBUG_LINK_CHECK; Assert( (nBytes % 4) == 0 ); Assert(((uintp)pData & 3) == 0); Assert( iStartBit == 0 ); m_pData = (uint32 *) pData; m_pDataOut = m_pData; m_nDataBytes = nBytes; if ( nBits == -1 ) { m_nDataBits = nBytes << 3; } else { Assert( nBits <= nBytes*8 ); m_nDataBits = nBits; } m_bOverflow = false; m_nOutBufWord = 0; m_nOutBitsAvail = 32; m_pBufferEnd = m_pDataOut + ( nBytes >> 2 ); } const uint32 CBitBuffer::s_nMaskTable[33] = { 0, ( 1 << 1 ) - 1, ( 1 << 2 ) - 1, ( 1 << 3 ) - 1, ( 1 << 4 ) - 1, ( 1 << 5 ) - 1, ( 1 << 6 ) - 1, ( 1 << 7 ) - 1, ( 1 << 8 ) - 1, ( 1 << 9 ) - 1, ( 1 << 10 ) - 1, ( 1 << 11 ) - 1, ( 1 << 12 ) - 1, ( 1 << 13 ) - 1, ( 1 << 14 ) - 1, ( 1 << 15 ) - 1, ( 1 << 16 ) - 1, ( 1 << 17 ) - 1, ( 1 << 18 ) - 1, ( 1 << 19 ) - 1, ( 1 << 20 ) - 1, ( 1 << 21 ) - 1, ( 1 << 22 ) - 1, ( 1 << 23 ) - 1, ( 1 << 24 ) - 1, ( 1 << 25 ) - 1, ( 1 << 26 ) - 1, ( 1 << 27 ) - 1, ( 1 << 28 ) - 1, ( 1 << 29 ) - 1, ( 1 << 30 ) - 1, 0x7fffffff, 0xffffffff, }; bool CBitWrite::WriteString( const char *pStr ) { if(pStr) { while( *pStr ) { WriteChar( * ( pStr++ ) ); } } WriteChar( 0 ); return !IsOverflowed(); } void CBitWrite::WriteLongLong(int64 val) { uint *pLongs = (uint*)&val; // Insert the two DWORDS according to network endian const short endianIndex = 0x0100; byte *idx = (byte*)&endianIndex; WriteUBitLong(pLongs[*idx++], sizeof(int32) << 3); WriteUBitLong(pLongs[*idx], sizeof(int32) << 3); } bool CBitWrite::WriteBits(const void *pInData, int nBits) { unsigned char *pOut = (unsigned char*)pInData; int nBitsLeft = nBits; // Bounds checking.. if ( ( GetNumBitsWritten() + nBits) > m_nDataBits ) { SetOverflowFlag(); CallErrorHandler( BITBUFERROR_BUFFER_OVERRUN, m_pDebugName ); return false; } // !! speed!! need fast paths // write remaining bytes while ( nBitsLeft >= 8 ) { WriteUBitLong( *pOut, 8, false ); ++pOut; nBitsLeft -= 8; } // write remaining bits if ( nBitsLeft ) { WriteUBitLong( *pOut, nBitsLeft, false ); } return !IsOverflowed(); } void CBitWrite::WriteBytes( const void *pBuf, int nBytes ) { WriteBits(pBuf, nBytes << 3); } void CBitWrite::WriteBitCoord (const float f) { int signbit = (f <= -COORD_RESOLUTION); int intval = (int)abs(f); int fractval = abs((int)(f*COORD_DENOMINATOR)) & (COORD_DENOMINATOR-1); // Send the bit flags that indicate whether we have an integer part and/or a fraction part. WriteOneBit( intval ); WriteOneBit( fractval ); if ( intval || fractval ) { // Send the sign bit WriteOneBit( signbit ); // Send the integer if we have one. if ( intval ) { // Adjust the integers from [1..MAX_COORD_VALUE] to [0..MAX_COORD_VALUE-1] intval--; WriteUBitLong( (unsigned int)intval, COORD_INTEGER_BITS ); } // Send the fraction if we have one if ( fractval ) { WriteUBitLong( (unsigned int)fractval, COORD_FRACTIONAL_BITS ); } } } void CBitWrite::WriteBitCoordMP (const float f, EBitCoordType coordType ) { bool bIntegral = ( coordType == kCW_Integral ); bool bLowPrecision = ( coordType == kCW_LowPrecision ); int signbit = (f <= -( bLowPrecision ? COORD_RESOLUTION_LOWPRECISION : COORD_RESOLUTION )); int intval = (int)abs(f); int fractval = bLowPrecision ? ( abs((int)(f*COORD_DENOMINATOR_LOWPRECISION)) & (COORD_DENOMINATOR_LOWPRECISION-1) ) : ( abs((int)(f*COORD_DENOMINATOR)) & (COORD_DENOMINATOR-1) ); bool bInBounds = intval < (1 << COORD_INTEGER_BITS_MP ); WriteOneBit( bInBounds ); if ( bIntegral ) { // Send the sign bit WriteOneBit( intval ); if ( intval ) { WriteOneBit( signbit ); // Send the integer if we have one. // Adjust the integers from [1..MAX_COORD_VALUE] to [0..MAX_COORD_VALUE-1] intval--; if ( bInBounds ) { WriteUBitLong( (unsigned int)intval, COORD_INTEGER_BITS_MP ); } else { WriteUBitLong( (unsigned int)intval, COORD_INTEGER_BITS ); } } } else { // Send the bit flags that indicate whether we have an integer part and/or a fraction part. WriteOneBit( intval ); // Send the sign bit WriteOneBit( signbit ); // Send the integer if we have one. if ( intval ) { // Adjust the integers from [1..MAX_COORD_VALUE] to [0..MAX_COORD_VALUE-1] intval--; if ( bInBounds ) { WriteUBitLong( (unsigned int)intval, COORD_INTEGER_BITS_MP ); } else { WriteUBitLong( (unsigned int)intval, COORD_INTEGER_BITS ); } } WriteUBitLong( (unsigned int)fractval, bLowPrecision ? COORD_FRACTIONAL_BITS_MP_LOWPRECISION : COORD_FRACTIONAL_BITS ); } } void CBitWrite::WriteBitCellCoord( const float f, int bits, EBitCoordType coordType ) { Assert( f >= 0.0f ); // cell coords can't be negative Assert( f < ( 1 << bits ) ); bool bIntegral = ( coordType == kCW_Integral ); bool bLowPrecision = ( coordType == kCW_LowPrecision ); int intval = (int)abs(f); int fractval = bLowPrecision ? ( abs((int)(f*COORD_DENOMINATOR_LOWPRECISION)) & (COORD_DENOMINATOR_LOWPRECISION-1) ) : ( abs((int)(f*COORD_DENOMINATOR)) & (COORD_DENOMINATOR-1) ); if ( bIntegral ) { WriteUBitLong( (unsigned int)intval, bits ); } else { WriteUBitLong( (unsigned int)intval, bits ); WriteUBitLong( (unsigned int)fractval, bLowPrecision ? COORD_FRACTIONAL_BITS_MP_LOWPRECISION : COORD_FRACTIONAL_BITS ); } } void CBitWrite::SeekToBit( int nBit ) { TempFlush(); m_pDataOut = m_pData + ( nBit / 32 ); m_nOutBufWord = LoadLittleDWord( m_pDataOut, 0 ); m_nOutBitsAvail = 32 - ( nBit & 31 ); } void CBitWrite::WriteBitVec3Coord( const Vector& fa ) { int xflag, yflag, zflag; xflag = (fa[0] >= COORD_RESOLUTION) || (fa[0] <= -COORD_RESOLUTION); yflag = (fa[1] >= COORD_RESOLUTION) || (fa[1] <= -COORD_RESOLUTION); zflag = (fa[2] >= COORD_RESOLUTION) || (fa[2] <= -COORD_RESOLUTION); WriteOneBit( xflag ); WriteOneBit( yflag ); WriteOneBit( zflag ); if ( xflag ) WriteBitCoord( fa[0] ); if ( yflag ) WriteBitCoord( fa[1] ); if ( zflag ) WriteBitCoord( fa[2] ); } void CBitWrite::WriteBitNormal( float f ) { int signbit = (f <= -NORMAL_RESOLUTION); // NOTE: Since +/-1 are valid values for a normal, I'm going to encode that as all ones unsigned int fractval = abs( (int)(f*NORMAL_DENOMINATOR) ); // clamp.. if (fractval > NORMAL_DENOMINATOR) fractval = NORMAL_DENOMINATOR; // Send the sign bit WriteOneBit( signbit ); // Send the fractional component WriteUBitLong( fractval, NORMAL_FRACTIONAL_BITS ); } void CBitWrite::WriteBitVec3Normal( const Vector& fa ) { int xflag, yflag; xflag = (fa[0] >= NORMAL_RESOLUTION) || (fa[0] <= -NORMAL_RESOLUTION); yflag = (fa[1] >= NORMAL_RESOLUTION) || (fa[1] <= -NORMAL_RESOLUTION); WriteOneBit( xflag ); WriteOneBit( yflag ); if ( xflag ) WriteBitNormal( fa[0] ); if ( yflag ) WriteBitNormal( fa[1] ); // Write z sign bit int signbit = (fa[2] <= -NORMAL_RESOLUTION); WriteOneBit( signbit ); } void CBitWrite::WriteBitAngle( float fAngle, int numbits ) { unsigned int shift = GetBitForBitnum(numbits); unsigned int mask = shift - 1; int d = (int)( (fAngle / 360.0) * shift ); d &= mask; WriteUBitLong((unsigned int)d, numbits); } bool CBitWrite::WriteBitsFromBuffer( bf_read *pIn, int nBits ) { // This could be optimized a little by while ( nBits > 32 ) { WriteUBitLong( pIn->ReadUBitLong( 32 ), 32 ); nBits -= 32; } WriteUBitLong( pIn->ReadUBitLong( nBits ), nBits ); return !IsOverflowed() && !pIn->IsOverflowed(); } void CBitWrite::WriteBitAngles( const QAngle& fa ) { // FIXME: Vector tmp( fa.x, fa.y, fa.z ); WriteBitVec3Coord( tmp ); } bool CBitRead::Seek( int nPosition ) { bool bSucc = true; if ( nPosition < 0 || nPosition > m_nDataBits) { SetOverflowFlag(); bSucc = false; nPosition = m_nDataBits; } int nHead = m_nDataBytes & 3; // non-multiple-of-4 bytes at head of buffer. We put the "round off" // at the head to make reading and detecting the end efficient. int nByteOfs = nPosition / 8; if ( ( m_nDataBytes < 4 ) || ( nHead && ( nByteOfs < nHead ) ) ) { // partial first dword uint8 const *pPartial = ( uint8 const *) m_pData; if ( m_pData ) { m_nInBufWord = *( pPartial++ ); if ( nHead > 1 ) m_nInBufWord |= ( *pPartial++ ) << 8; if ( nHead > 2 ) m_nInBufWord |= ( *pPartial++ ) << 16; } m_pDataIn = ( uint32 const * ) pPartial; m_nInBufWord >>= ( nPosition & 31 ); m_nBitsAvail = ( nHead << 3 ) - ( nPosition & 31 ); } else { int nAdjPosition = nPosition - ( nHead << 3 ); m_pDataIn = reinterpret_cast ( reinterpret_cast( m_pData ) + ( ( nAdjPosition / 32 ) << 2 ) + nHead ); if ( m_pData ) { m_nBitsAvail = 32; GrabNextDWord(); } else { m_nInBufWord = 0; m_nBitsAvail = 1; } m_nInBufWord >>= ( nAdjPosition & 31 ); m_nBitsAvail = MIN( m_nBitsAvail, 32 - ( nAdjPosition & 31 ) ); // in case grabnextdword overflowed } return bSucc; } void CBitRead::StartReading( const void *pData, int nBytes, int iStartBit, int nBits ) { DEBUG_LINK_CHECK; // Make sure it's dword aligned and padded. Assert(((uintp)pData & 3) == 0); m_pData = (uint32 *) pData; m_pDataIn = m_pData; m_nDataBytes = nBytes; if ( nBits == -1 ) { m_nDataBits = nBytes << 3; } else { Assert( nBits <= nBytes*8 ); m_nDataBits = nBits; } m_bOverflow = false; m_pBufferEnd = reinterpret_cast ( reinterpret_cast< uint8 const *> (m_pData) + nBytes ); if ( m_pData ) Seek( iStartBit ); } bool CBitRead::ReadString( char *pStr, int maxLen, bool bLine, int *pOutNumChars ) { Assert( maxLen != 0 ); bool bTooSmall = false; int iChar = 0; while(1) { char val = ReadChar(); if ( val == 0 ) break; else if ( bLine && val == '\n' ) break; if ( iChar < (maxLen-1) ) { pStr[iChar] = val; ++iChar; } else { bTooSmall = true; } } // Make sure it's null-terminated. Assert( iChar < maxLen ); pStr[iChar] = 0; if ( pOutNumChars ) *pOutNumChars = iChar; return !IsOverflowed() && !bTooSmall; } bool CBitRead::ReadWString( OUT_Z_CAP(maxLenInChars) wchar_t *pStr, int maxLenInChars, bool bLine, int *pOutNumChars ) { Assert( maxLenInChars != 0 ); bool bTooSmall = false; int iChar = 0; while(1) { wchar val = ReadShort(); if ( val == 0 ) break; else if ( bLine && val == L'\n' ) break; if ( iChar < (maxLenInChars-1) ) { pStr[iChar] = val; ++iChar; } else { bTooSmall = true; } } // Make sure it's null-terminated. Assert( iChar < maxLenInChars ); pStr[iChar] = 0; if ( pOutNumChars ) *pOutNumChars = iChar; return !IsOverflowed() && !bTooSmall; } char* CBitRead::ReadAndAllocateString( bool *pOverflow ) { char str[2048]; int nChars; bool bOverflow = !ReadString( str, sizeof( str ), false, &nChars ); if ( pOverflow ) *pOverflow = bOverflow; // Now copy into the output and return it; char *pRet = new char[ nChars + 1 ]; for ( int i=0; i <= nChars; i++ ) pRet[i] = str[i]; return pRet; } int64 CBitRead::ReadLongLong( void ) { int64 retval; uint *pLongs = (uint*)&retval; // Read the two DWORDs according to network endian const short endianIndex = 0x0100; byte *idx = (byte*)&endianIndex; pLongs[*idx++] = ReadUBitLong(sizeof(int32) << 3); pLongs[*idx] = ReadUBitLong(sizeof(int32) << 3); return retval; } // Read 1-5 bytes in order to extract a 32-bit unsigned value from the // stream. 7 data bits are extracted from each byte with the 8th bit used // to indicate whether the loop should continue. // This allows variable size numbers to be stored with tolerable // efficiency. Numbers sizes that can be stored for various numbers of // encoded bits are: // 8-bits: 0-127 // 16-bits: 128-16383 // 24-bits: 16384-2097151 // 32-bits: 2097152-268435455 // 40-bits: 268435456-0xFFFFFFFF uint32 CBitRead::ReadVarInt32() { uint32 result = 0; int count = 0; uint32 b; do { if ( count == bitbuf::kMaxVarint32Bytes ) { return result; } b = ReadUBitLong( 8 ); result |= (b & 0x7F) << (7 * count); ++count; } while (b & 0x80); return result; } uint64 CBitRead::ReadVarInt64() { uint64 result = 0; int count = 0; uint64 b; do { if ( count == bitbuf::kMaxVarintBytes ) { return result; } b = ReadUBitLong( 8 ); result |= static_cast(b & 0x7F) << (7 * count); ++count; } while (b & 0x80); return result; } void CBitRead::ReadBits(void *pOutData, int nBits) { unsigned char *pOut = (unsigned char*)pOutData; int nBitsLeft = nBits; // align output to dword boundary while( ((uintp)pOut & 3) != 0 && nBitsLeft >= 8 ) { *pOut = (unsigned char)ReadUBitLong(8); ++pOut; nBitsLeft -= 8; } // X360TBD: Can't read dwords in ReadBits because they'll get swapped if ( IsPC() ) { // read dwords while ( nBitsLeft >= 32 ) { *((uint32*)pOut) = ReadUBitLong(32); pOut += sizeof(uint32); nBitsLeft -= 32; } } // read remaining bytes while ( nBitsLeft >= 8 ) { *pOut = ReadUBitLong(8); ++pOut; nBitsLeft -= 8; } // read remaining bits if ( nBitsLeft ) { *pOut = ReadUBitLong(nBitsLeft); } } bool CBitRead::ReadBytes(void *pOut, int nBytes) { ReadBits(pOut, nBytes << 3); return !IsOverflowed(); } float CBitRead::ReadBitAngle( int numbits ) { float shift = (float)( GetBitForBitnum(numbits) ); int i = ReadUBitLong( numbits ); float fReturn = (float)i * (360.0 / shift); return fReturn; } // Basic Coordinate Routines (these contain bit-field size AND fixed point scaling constants) float CBitRead::ReadBitCoord (void) { int intval=0,fractval=0,signbit=0; float value = 0.0; // Read the required integer and fraction flags intval = ReadOneBit(); fractval = ReadOneBit(); // If we got either parse them, otherwise it's a zero. if ( intval || fractval ) { // Read the sign bit signbit = ReadOneBit(); // If there's an integer, read it in if ( intval ) { // Adjust the integers from [0..MAX_COORD_VALUE-1] to [1..MAX_COORD_VALUE] intval = ReadUBitLong( COORD_INTEGER_BITS ) + 1; } // If there's a fraction, read it in if ( fractval ) { fractval = ReadUBitLong( COORD_FRACTIONAL_BITS ); } // Calculate the correct floating point value value = intval + ((float)fractval * COORD_RESOLUTION); // Fixup the sign if negative. if ( signbit ) value = -value; } return value; } float CBitRead::ReadBitCoordMP( EBitCoordType coordType ) { bool bIntegral = ( coordType == kCW_Integral ); bool bLowPrecision = ( coordType == kCW_LowPrecision ); int intval=0,fractval=0,signbit=0; float value = 0.0; bool bInBounds = ReadOneBit() ? true : false; if ( bIntegral ) { // Read the required integer and fraction flags intval = ReadOneBit(); // If we got either parse them, otherwise it's a zero. if ( intval ) { // Read the sign bit signbit = ReadOneBit(); // If there's an integer, read it in // Adjust the integers from [0..MAX_COORD_VALUE-1] to [1..MAX_COORD_VALUE] if ( bInBounds ) { value = ReadUBitLong( COORD_INTEGER_BITS_MP ) + 1; } else { value = ReadUBitLong( COORD_INTEGER_BITS ) + 1; } } } else { // Read the required integer and fraction flags intval = ReadOneBit(); // Read the sign bit signbit = ReadOneBit(); // If we got either parse them, otherwise it's a zero. if ( intval ) { if ( bInBounds ) { intval = ReadUBitLong( COORD_INTEGER_BITS_MP ) + 1; } else { intval = ReadUBitLong( COORD_INTEGER_BITS ) + 1; } } // If there's a fraction, read it in fractval = ReadUBitLong( bLowPrecision ? COORD_FRACTIONAL_BITS_MP_LOWPRECISION : COORD_FRACTIONAL_BITS ); // Calculate the correct floating point value value = intval + ((float)fractval * ( bLowPrecision ? COORD_RESOLUTION_LOWPRECISION : COORD_RESOLUTION ) ); } // Fixup the sign if negative. if ( signbit ) value = -value; return value; } float CBitRead::ReadBitCellCoord( int bits, EBitCoordType coordType ) { #if defined( BB_PROFILING ) VPROF( "bf_write::ReadBitCoordMP" ); #endif bool bIntegral = ( coordType == kCW_Integral ); bool bLowPrecision = ( coordType == kCW_LowPrecision ); int intval=0,fractval=0; float value = 0.0; if ( bIntegral ) { value = ReadUBitLong( bits ); } else { intval = ReadUBitLong( bits ); // If there's a fraction, read it in fractval = ReadUBitLong( bLowPrecision ? COORD_FRACTIONAL_BITS_MP_LOWPRECISION : COORD_FRACTIONAL_BITS ); // Calculate the correct floating point value value = intval + ((float)fractval * ( bLowPrecision ? COORD_RESOLUTION_LOWPRECISION : COORD_RESOLUTION ) ); } return value; } void CBitRead::ReadBitVec3Coord( Vector& fa ) { int xflag, yflag, zflag; // This vector must be initialized! Otherwise, If any of the flags aren't set, // the corresponding component will not be read and will be stack garbage. fa.Init( 0, 0, 0 ); xflag = ReadOneBit(); yflag = ReadOneBit(); zflag = ReadOneBit(); if ( xflag ) fa[0] = ReadBitCoord(); if ( yflag ) fa[1] = ReadBitCoord(); if ( zflag ) fa[2] = ReadBitCoord(); } float CBitRead::ReadBitNormal (void) { // Read the sign bit int signbit = ReadOneBit(); // Read the fractional part unsigned int fractval = ReadUBitLong( NORMAL_FRACTIONAL_BITS ); // Calculate the correct floating point value float value = (float)fractval * NORMAL_RESOLUTION; // Fixup the sign if negative. if ( signbit ) value = -value; return value; } void CBitRead::ReadBitVec3Normal( Vector& fa ) { int xflag = ReadOneBit(); int yflag = ReadOneBit(); if (xflag) fa[0] = ReadBitNormal(); else fa[0] = 0.0f; if (yflag) fa[1] = ReadBitNormal(); else fa[1] = 0.0f; // The first two imply the third (but not its sign) int znegative = ReadOneBit(); float fafafbfb = fa[0] * fa[0] + fa[1] * fa[1]; if (fafafbfb < 1.0f) fa[2] = sqrt( 1.0f - fafafbfb ); else fa[2] = 0.0f; if (znegative) fa[2] = -fa[2]; } void CBitRead::ReadBitAngles( QAngle& fa ) { Vector tmp; ReadBitVec3Coord( tmp ); fa.Init( tmp.x, tmp.y, tmp.z ); } //-------------------------------------------------------------------------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------------------------------------------------------------------------- /* // Tests #define TEST_BITBUF #ifndef TEST_BITBUF void TestBitBufs() { } #else //TEST_BITBUF enum EBitBufTestFields { kBBTF_ULONG, kBBTF_BYTES, #if 0 // kBBTF_UBVAR, kBBTF_FLOAT, kBBTF_CHAR, kBBTF_BYTE, kBBTF_SHORT, kBBTF_STRING, kBBTF_LONGLONG, #endif kBBTF_Count }; static char bitbuf_string[] = "Life's but a walking shadow, a poor player."; static char bitsbuf[ sizeof( bitbuf_string ) ]; template < class TWriter > float TestBitBufferWriter( void *buffer, int bufsize, int seed, int numtests, bool log = false ) { CFastTimer timer; timer.Start(); TWriter writer( "TestBufferWriter", buffer, bufsize ); // Fill it up with the writer RandomSeed( seed ); int bitTotal = 0; for ( int i = 0; i < numtests; ++i ) { if ( writer.IsOverflowed() ) { printf("writer: OVERFLOW!" ); } if ( writer.GetNumBitsWritten() != bitTotal ) { printf("writer: bitTotal MISMATCH!\n"); } int testtype = RandomInt( 0, kBBTF_Count - 1 ); switch ( testtype ) { case kBBTF_ULONG: { int bits = RandomInt( 0, ( sizeof( uint32 ) << 3 ) - 1 ); uint32 n = (uint32)RandomInt( 0, 0x7fff ); if ( bits ) { n &= (1 << bits) - 1; } else { bits = 32; } if (log) printf("\t%3d: write ULONG: %u, %d bits\n", i, n, bits ); writer.WriteUBitLong( n, bits ); bitTotal += bits; } break; case kBBTF_BYTES: { int bytes = RandomInt( 1, sizeof( bitsbuf ) ); if (log) printf("\t%3d: write BYTES: %d bytes\n", i, bytes ); writer.WriteBytes( bitsbuf, bytes ); bitTotal += bytes << 3; } break; #if 0 case kBBTF_SLONG: { int bits = RandomInt( 2, sizeof( int32 ) << 3 ); int32 n = (int32)RandomInt( 0, 0x7fff ) & ( ( 1 << ( bits - 1 ) ) - 1 ); if ( RandomInt( 0, 1 ) < 1 ) { n = -n; } if (log) printf("\t%3d: write SLONG: %d, %d bits\n", i, n, bits ); writer.WriteSBitLong( n, bits ); bitTotal += bits; } break; case kBBTF_UBVAR: { unsigned int n = (unsigned int)RandomInt( 0, 0x7fff ); if (log) printf("\t%3d: write UBVAR: %u\n", i, n ); writer.WriteUBitVar( n ); } break; case kBBTF_FLOAT: { float n = RandomFloat( 0.0f, FLT_MAX ); if (log) printf("\t%3d: write FLOAT: %f\n", i, n ); writer.WriteFloat( n ); bitTotal += sizeof(float)<<3;; } break; case kBBTF_CHAR: { char n = (char)RandomInt( 0, 0x7f ); if (log) printf("\t%3d: write CHAR: %d\n", i, n ); writer.WriteChar( n ); bitTotal += sizeof(char)<<3;; } break; case kBBTF_BYTE: { unsigned char n = (unsigned char)RandomInt( 0, 0xff ); if (log) printf("\t%3d: write BYTE: %d\n", i, n ); writer.WriteByte( n ); bitTotal += sizeof(unsigned char)<<3;; } break; case kBBTF_SHORT: { short n = (short)RandomInt( 0, 0x7fff ); if (log) printf("\t%3d: write SHORT: %d\n", i, n ); writer.WriteShort( n ); bitTotal += sizeof(short)<<3;; } break; case kBBTF_STRING: { writer.WriteString( bitbuf_string ); if (log) printf("\t%3d: write STRING\n", i ); bitTotal += (sizeof(char)<<3) * ( strlen( bitbuf_string ) + 1 ); } break; case kBBTF_LONGLONG: { int64 low = RandomInt( 0, 0x7fff ); int64 high = RandomInt( 0, 0x7fff ); int64 n = (high << 32) | low; if (log) printf("\t%3d: write LONGLONG: %lld\n", i, n ); writer.WriteLongLong( n ); bitTotal += sizeof(int64)<<3; } break; #endif } } writer.GetData(); // insure a flush timer.End(); return timer.GetDuration().GetMicrosecondsF(); } template < class TReader > float TestBitBufferReader( void *buffer, int bufsize, int seed, int numtests, bool log = false ) { CFastTimer timer; timer.Start(); TReader reader( "TestBufferReader", buffer, bufsize ); // And let's read it back to ensure it all got written correctly // Fill it up with the writer RandomSeed( seed ); for ( int i = 0; i < numtests; ++i ) { int testtype = RandomInt( 0, kBBTF_Count - 1 ); switch ( testtype ) { case kBBTF_ULONG: { int bits = RandomInt( 0, ( sizeof( uint32 ) << 3 ) - 1 ); uint32 n = (uint32)RandomInt( 0, 0x7fff ); if ( bits ) { n &= (1 << bits) - 1; } else { bits = 32; } uint32 v = reader.ReadUBitLong( bits ); if (log) printf("\t%3d: read ULONG: %u, %d bits, GOT: %u\n", i, n, bits, v ); if ( v != n ) { printf("\t%3d: Mismatched ULONG: read %u instead of %u\n", i, v, n ); } } break; case kBBTF_BYTES: { int bytes = RandomInt( 1, sizeof( bitsbuf ) ); char readbuf[ sizeof( bitsbuf ) ]; reader.ReadBytes( readbuf, bytes ); if (log) printf("\t%3d: read BYTES: %d bytes\n", i, bytes ); if ( Q_memcmp( bitsbuf, readbuf, bytes ) ) { printf("\t%3d: Mismatched BYTES\n", i); } } break; #if 0 case kBBTF_BYTE: { unsigned char n = (unsigned char)RandomInt( 0, 0xff ); unsigned char v = reader.ReadByte(); if (log) printf("\t%3d: read BYTE: %d, GOT: %d\n", i, n, v ); if ( v != n ) { printf("\t%3d: Mismatched BYTE: read %d instead of %d\n", i, v, n ); } } break; case kBBTF_SLONG: { int bits = RandomInt( 2, sizeof( int32 ) << 3 ); int32 n = (int32)RandomInt( 0, 0x7fff ) & ( ( 1 << ( bits - 1 ) ) - 1 ); if ( RandomInt( 0, 1 ) < 1 ) { n = -n; } int32 v = reader.ReadSBitLong( bits ); if (log) printf("\t%3d: read SLONG: %d, %d bits, GOT: %d\n", i, n, bits, v ); if ( v != n ) { printf("\t%3d: Mismatched SLONG: read %d instead of %d\n", i, v, n ); } } break; case kBBTF_UBVAR: { unsigned int n = (unsigned int)RandomInt( 0, 0x7fff ); unsigned int v = reader.ReadUBitVar(); if (log) printf("\t%3d: read UBVAR: %u, GOT: %u\n", i, n, v ); if ( v != n ) { printf("\t%3d: Mismatched UBVAR: read %u instead of %u\n", i, v, n ); } } break; case kBBTF_FLOAT: { float n = RandomFloat( 0.0f, FLT_MAX ); float v = reader.ReadFloat(); if (log) printf("\t%3d: read FLOAT: %f, GOT: %f\n", i, n, v ); // if ( v != n ) // { // printf("\t%3d: Mismatched FLOAT: read %f instead of %f (d=%f)\n", i, v, n, v - n ); // } } break; case kBBTF_CHAR: { char n = (char)RandomInt( 0, 0x7f ); char v = reader.ReadChar(); if (log) printf("\t%3d: read CHAR: %d, GOT: %d\n", i, n, v ); if ( v != n ) { printf("\t%3d: Mismatched CHAR: read %d instead of %d\n", i, v, n ); } } break; case kBBTF_SHORT: { short n = (short)RandomInt( 0, 0x7fff ); short v = reader.ReadShort(); if (log) printf("\t%3d: read SHORT: %d, GOT: %d\n", i, n, v ); if ( v != n ) { printf("\t%3d: Mismatched SHORT: read %d instead of %d\n", i, v, n ); } } break; case kBBTF_STRING: { char readbuf[ sizeof( bitbuf_string ) ]; reader.ReadString( readbuf, sizeof( readbuf ) ); if (log) printf("\t%3d: read STRING\n", i ); if ( Q_strcmp( bitbuf_string, readbuf ) ) { printf("\t%3d: Mismatched STRING\n", i); } } break; case kBBTF_LONGLONG: { int64 low = RandomInt( 0, 0x7fff ); int64 high = RandomInt( 0, 0x7fff ); int64 n = (high << 32) | low; int64 v = reader.ReadLongLong(); if (log) printf("\t%3d: read LONGLONG: %lld, GOT: %lld\n", i, n, v ); if ( v != n ) { printf("\t%3d: Mismatched LONGLONG: read %lld instead of %lld\n", i, v, n ); } } break; #endif } } timer.End(); return timer.GetDuration().GetMicrosecondsF(); } //----------------------------------------------------------------------------- void TestBitBufs() { const int repeatCount = 1024; const int testItemCount = 1024; const bool debugWriteReads = false; size_t bufsize = 1024*1024; unsigned char *buffer = (unsigned char *)malloc( bufsize ); { bf_write bitsbuf_writer( bitsbuf, sizeof(bitsbuf) ); bitsbuf_writer.WriteBytes( bitbuf_string, sizeof(bitsbuf) ); } { CFastTimer timer; printf("TestBuffer< bf_write, bf_read >: START\n" ); timer.Start(); float avgTotalWrite = 0.0f; float avgTotalRead = 0.0f; int seed = 1; for ( int count = 0; count < repeatCount; ++count, ++seed ) { V_memset( buffer, 0, bufsize ); avgTotalWrite += TestBitBufferWriter< bf_write >( buffer, bufsize, seed, testItemCount, debugWriteReads ); avgTotalRead += TestBitBufferReader< bf_read >( buffer, bufsize, seed, testItemCount, debugWriteReads ); } timer.End(); printf("TestBuffer< bf_write, bf_read >: END: %d times, total %4.4fus, average write %4.4f, average read %4.4f\n", repeatCount, timer.GetDuration().GetMicrosecondsF(), avgTotalWrite / repeatCount, avgTotalRead / repeatCount ); } if ( 1 ) { CFastTimer timer; printf("TestBuffer< CBitWrite, bf_read >: START\n" ); timer.Start(); float avgTotalWrite = 0.0f; float avgTotalRead = 0.0f; int seed = 1; for ( int count = 0; count < repeatCount; ++count, ++seed ) { V_memset( buffer, 0, bufsize ); avgTotalWrite += TestBitBufferWriter< CBitWrite >( buffer, bufsize, seed, testItemCount, debugWriteReads ); avgTotalRead += TestBitBufferReader< bf_read >( buffer, bufsize, seed, testItemCount, debugWriteReads ); } timer.End(); printf("TestBuffer< CBitWrite, bf_read >: END: %d times, total %4.4fus, average write %4.4f, average read %4.4f\n", repeatCount, timer.GetDuration().GetMicrosecondsF(), avgTotalWrite / repeatCount, avgTotalRead / repeatCount ); } free( buffer ); } #endif //TEST_BITBUF */