CSSZombieEscape/demboyz
7
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Added bitbuf from source sdk 2013

Browse Source
This commit is contained in:
Jordan Cristiano 2015-05-09 23:23:06 -04:00
parent 0fe0ac912a
commit cd6badfe1f
2 changed files with 2299 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1490
external/bitbuf/bitbuf.cpp vendored Normal file
View File

File diff suppressed because it is too large Load Diff

809
external/bitbuf/bitbuf.h vendored Normal file
View File

@ -0,0 +1,809 @@
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//=============================================================================//
// NOTE: bf_read is guaranteed to return zeros if it overflows.
#ifndef BITBUF_H
#define BITBUF_H
#ifdef _WIN32
#pragma once
#endif
#include "mathlib/mathlib.h"
#include "mathlib/vector.h"
#include "basetypes.h"
#include "tier0/dbg.h"
#if _DEBUG
#define BITBUF_INLINE inline
#else
#define BITBUF_INLINE FORCEINLINE
#endif
//-----------------------------------------------------------------------------
// Forward declarations.
//-----------------------------------------------------------------------------
class Vector;
class QAngle;
//-----------------------------------------------------------------------------
// You can define a handler function that will be called in case of
// out-of-range values and overruns here.
//
// NOTE: the handler is only called in debug mode.
//
// Call SetBitBufErrorHandler to install a handler.
//-----------------------------------------------------------------------------
typedef enum
{
BITBUFERROR_VALUE_OUT_OF_RANGE=0, // Tried to write a value with too few bits.
BITBUFERROR_BUFFER_OVERRUN, // Was about to overrun a buffer.
BITBUFERROR_NUM_ERRORS
} BitBufErrorType;
typedef void (*BitBufErrorHandler)( BitBufErrorType errorType, const char *pDebugName );
#if defined( _DEBUG )
extern void InternalBitBufErrorHandler( BitBufErrorType errorType, const char *pDebugName );
#define CallErrorHandler( errorType, pDebugName ) InternalBitBufErrorHandler( errorType, pDebugName );
#else
#define CallErrorHandler( errorType, pDebugName )
#endif
// Use this to install the error handler. Call with NULL to uninstall your error handler.
void SetBitBufErrorHandler( BitBufErrorHandler fn );
//-----------------------------------------------------------------------------
// Helpers.
//-----------------------------------------------------------------------------
inline int BitByte( int bits )
{
// return PAD_NUMBER( bits, 8 ) >> 3;
return (bits + 7) >> 3;
}
//-----------------------------------------------------------------------------
// namespaced helpers
//-----------------------------------------------------------------------------
namespace bitbuf
{
// ZigZag Transform: Encodes signed integers so that they can be
// effectively used with varint encoding.
//
// varint operates on unsigned integers, encoding smaller numbers into
// fewer bytes. If you try to use it on a signed integer, it will treat
// this number as a very large unsigned integer, which means that even
// small signed numbers like -1 will take the maximum number of bytes
// (10) to encode. ZigZagEncode() maps signed integers to unsigned
// in such a way that those with a small absolute value will have smaller
// encoded values, making them appropriate for encoding using varint.
//
// int32 -> uint32
// -------------------------
// 0 -> 0
// -1 -> 1
// 1 -> 2
// -2 -> 3
// ... -> ...
// 2147483647 -> 4294967294
// -2147483648 -> 4294967295
//
// >> encode >>
// << decode <<
inline uint32 ZigZagEncode32(int32 n)
{
// Note: the right-shift must be arithmetic
return(n << 1) ^ (n >> 31);
}
inline int32 ZigZagDecode32(uint32 n)
{
return(n >> 1) ^ -static_cast<int32>(n & 1);
}
inline uint64 ZigZagEncode64(int64 n)
{
// Note: the right-shift must be arithmetic
return(n << 1) ^ (n >> 63);
}
inline int64 ZigZagDecode64(uint64 n)
{
return(n >> 1) ^ -static_cast<int64>(n & 1);
}
const int kMaxVarintBytes = 10;
const int kMaxVarint32Bytes = 5;
}
//-----------------------------------------------------------------------------
// Used for serialization
//-----------------------------------------------------------------------------
class bf_write
{
public:
bf_write();
// nMaxBits can be used as the number of bits in the buffer.
// It must be <= nBytes*8. If you leave it at -1, then it's set to nBytes * 8.
bf_write( void *pData, int nBytes, int nMaxBits = -1 );
bf_write( const char *pDebugName, void *pData, int nBytes, int nMaxBits = -1 );
// Start writing to the specified buffer.
// nMaxBits can be used as the number of bits in the buffer.
// It must be <= nBytes*8. If you leave it at -1, then it's set to nBytes * 8.
void StartWriting( void *pData, int nBytes, int iStartBit = 0, int nMaxBits = -1 );
// Restart buffer writing.
void Reset();
// Get the base pointer.
unsigned char* GetBasePointer() { return (unsigned char*) m_pData; }
// Enable or disable assertion on overflow. 99% of the time, it's a bug that we need to catch,
// but there may be the occasional buffer that is allowed to overflow gracefully.
void SetAssertOnOverflow( bool bAssert );
// This can be set to assign a name that gets output if the buffer overflows.
const char* GetDebugName();
void SetDebugName( const char *pDebugName );
// Seek to a specific position.
public:
void SeekToBit( int bitPos );
// Bit functions.
public:
void WriteOneBit(int nValue);
void WriteOneBitNoCheck(int nValue);
void WriteOneBitAt( int iBit, int nValue );
// Write signed or unsigned. Range is only checked in debug.
void WriteUBitLong( unsigned int data, int numbits, bool bCheckRange=true );
void WriteSBitLong( int data, int numbits );
// Tell it whether or not the data is unsigned. If it's signed,
// cast to unsigned before passing in (it will cast back inside).
void WriteBitLong(unsigned int data, int numbits, bool bSigned);
// Write a list of bits in.
bool WriteBits(const void *pIn, int nBits);
// writes an unsigned integer with variable bit length
void WriteUBitVar( unsigned int data );
// writes a varint encoded integer
void WriteVarInt32( uint32 data );
void WriteVarInt64( uint64 data );
void WriteSignedVarInt32( int32 data );
void WriteSignedVarInt64( int64 data );
int ByteSizeVarInt32( uint32 data );
int ByteSizeVarInt64( uint64 data );
int ByteSizeSignedVarInt32( int32 data );
int ByteSizeSignedVarInt64( int64 data );
// Copy the bits straight out of pIn. This seeks pIn forward by nBits.
// Returns an error if this buffer or the read buffer overflows.
bool WriteBitsFromBuffer( class bf_read *pIn, int nBits );
void WriteBitAngle( float fAngle, int numbits );
void WriteBitCoord (const float f);
void WriteBitCoordMP( const float f, bool bIntegral, bool bLowPrecision );
void WriteBitFloat(float val);
void WriteBitVec3Coord( const Vector& fa );
void WriteBitNormal( float f );
void WriteBitVec3Normal( const Vector& fa );
void WriteBitAngles( const QAngle& fa );
// Byte functions.
public:
void WriteChar(int val);
void WriteByte(int val);
void WriteShort(int val);
void WriteWord(int val);
void WriteLong(long val);
void WriteLongLong(int64 val);
void WriteFloat(float val);
bool WriteBytes( const void *pBuf, int nBytes );
// Returns false if it overflows the buffer.
bool WriteString(const char *pStr);
// Status.
public:
// How many bytes are filled in?
int GetNumBytesWritten() const;
int GetNumBitsWritten() const;
int GetMaxNumBits();
int GetNumBitsLeft();
int GetNumBytesLeft();
unsigned char* GetData();
const unsigned char* GetData() const;
// Has the buffer overflowed?
bool CheckForOverflow(int nBits);
inline bool IsOverflowed() const {return m_bOverflow;}
void SetOverflowFlag();
public:
// The current buffer.
unsigned long* RESTRICT m_pData;
int m_nDataBytes;
int m_nDataBits;
// Where we are in the buffer.
int m_iCurBit;
private:
// Errors?
bool m_bOverflow;
bool m_bAssertOnOverflow;
const char *m_pDebugName;
};
//-----------------------------------------------------------------------------
// Inlined methods
//-----------------------------------------------------------------------------
// How many bytes are filled in?
inline int bf_write::GetNumBytesWritten() const
{
return BitByte(m_iCurBit);
}
inline int bf_write::GetNumBitsWritten() const
{
return m_iCurBit;
}
inline int bf_write::GetMaxNumBits()
{
return m_nDataBits;
}
inline int bf_write::GetNumBitsLeft()
{
return m_nDataBits - m_iCurBit;
}
inline int bf_write::GetNumBytesLeft()
{
return GetNumBitsLeft() >> 3;
}
inline unsigned char* bf_write::GetData()
{
return (unsigned char*) m_pData;
}
inline const unsigned char* bf_write::GetData() const
{
return (unsigned char*) m_pData;
}
BITBUF_INLINE bool bf_write::CheckForOverflow(int nBits)
{
if ( m_iCurBit + nBits > m_nDataBits )
{
SetOverflowFlag();
CallErrorHandler( BITBUFERROR_BUFFER_OVERRUN, GetDebugName() );
}
return m_bOverflow;
}
BITBUF_INLINE void bf_write::SetOverflowFlag()
{
#ifdef DBGFLAG_ASSERT
if ( m_bAssertOnOverflow )
{
Assert( false );
}
#endif
m_bOverflow = true;
}
BITBUF_INLINE void bf_write::WriteOneBitNoCheck(int nValue)
{
#if __i386__
if(nValue)
m_pData[m_iCurBit >> 5] |= 1u << (m_iCurBit & 31);
else
m_pData[m_iCurBit >> 5] &= ~(1u << (m_iCurBit & 31));
#else
extern unsigned long g_LittleBits[32];
if(nValue)
m_pData[m_iCurBit >> 5] |= g_LittleBits[m_iCurBit & 31];
else
m_pData[m_iCurBit >> 5] &= ~g_LittleBits[m_iCurBit & 31];
#endif
++m_iCurBit;
}
inline void bf_write::WriteOneBit(int nValue)
{
if( m_iCurBit >= m_nDataBits )
{
SetOverflowFlag();
CallErrorHandler( BITBUFERROR_BUFFER_OVERRUN, GetDebugName() );
return;
}
WriteOneBitNoCheck( nValue );
}
inline void bf_write::WriteOneBitAt( int iBit, int nValue )
{
if( iBit >= m_nDataBits )
{
SetOverflowFlag();
CallErrorHandler( BITBUFERROR_BUFFER_OVERRUN, GetDebugName() );
return;
}
#if __i386__
if(nValue)
m_pData[iBit >> 5] |= 1u << (iBit & 31);
else
m_pData[iBit >> 5] &= ~(1u << (iBit & 31));
#else
extern unsigned long g_LittleBits[32];
if(nValue)
m_pData[iBit >> 5] |= g_LittleBits[iBit & 31];
else
m_pData[iBit >> 5] &= ~g_LittleBits[iBit & 31];
#endif
}
BITBUF_INLINE void bf_write::WriteUBitLong( unsigned int curData, int numbits, bool bCheckRange ) RESTRICT
{
#ifdef _DEBUG
// Make sure it doesn't overflow.
if ( bCheckRange && numbits < 32 )
{
if ( curData >= (unsigned long)(1 << numbits) )
{
CallErrorHandler( BITBUFERROR_VALUE_OUT_OF_RANGE, GetDebugName() );
}
}
Assert( numbits >= 0 && numbits <= 32 );
#endif
if ( GetNumBitsLeft() < numbits )
{
m_iCurBit = m_nDataBits;
SetOverflowFlag();
CallErrorHandler( BITBUFERROR_BUFFER_OVERRUN, GetDebugName() );
return;
}
int iCurBitMasked = m_iCurBit & 31;
int iDWord = m_iCurBit >> 5;
m_iCurBit += numbits;
// Mask in a dword.
Assert( (iDWord*4 + sizeof(long)) <= (unsigned int)m_nDataBytes );
unsigned long * RESTRICT pOut = &m_pData[iDWord];
// Rotate data into dword alignment
curData = (curData << iCurBitMasked) | (curData >> (32 - iCurBitMasked));
// Calculate bitmasks for first and second word
unsigned int temp = 1 << (numbits-1);
unsigned int mask1 = (temp*2-1) << iCurBitMasked;
unsigned int mask2 = (temp-1) >> (31 - iCurBitMasked);
// Only look beyond current word if necessary (avoid access violation)
int i = mask2 & 1;
unsigned long dword1 = LoadLittleDWord( pOut, 0 );
unsigned long dword2 = LoadLittleDWord( pOut, i );
// Drop bits into place
dword1 ^= ( mask1 & ( curData ^ dword1 ) );
dword2 ^= ( mask2 & ( curData ^ dword2 ) );
// Note reversed order of writes so that dword1 wins if mask2 == 0 && i == 0
StoreLittleDWord( pOut, i, dword2 );
StoreLittleDWord( pOut, 0, dword1 );
}
// writes an unsigned integer with variable bit length
BITBUF_INLINE void bf_write::WriteUBitVar( unsigned int data )
{
/* Reference:
if ( data < 0x10u )
WriteUBitLong( 0, 2 ), WriteUBitLong( data, 4 );
else if ( data < 0x100u )
WriteUBitLong( 1, 2 ), WriteUBitLong( data, 8 );
else if ( data < 0x1000u )
WriteUBitLong( 2, 2 ), WriteUBitLong( data, 12 );
else
WriteUBitLong( 3, 2 ), WriteUBitLong( data, 32 );
*/
// a < b ? -1 : 0 translates into a CMP, SBB instruction pair
// with no flow control. should also be branchless on consoles.
int n = (data < 0x10u ? -1 : 0) + (data < 0x100u ? -1 : 0) + (data < 0x1000u ? -1 : 0);
WriteUBitLong( data*4 + n + 3, 6 + n*4 + 12 );
if ( data >= 0x1000u )
{
WriteUBitLong( data >> 16, 16 );
}
}
// write raw IEEE float bits in little endian form
BITBUF_INLINE void bf_write::WriteBitFloat(float val)
{
long intVal;
Assert(sizeof(long) == sizeof(float));
Assert(sizeof(float) == 4);
intVal = *((long*)&val);
WriteUBitLong( intVal, 32 );
}
//-----------------------------------------------------------------------------
// This is useful if you just want a buffer to write into on the stack.
//-----------------------------------------------------------------------------
template<int SIZE>
class old_bf_write_static : public bf_write
{
public:
inline old_bf_write_static() : bf_write(m_StaticData, SIZE) {}
char m_StaticData[SIZE];
};
//-----------------------------------------------------------------------------
// Used for unserialization
//-----------------------------------------------------------------------------
class bf_read
{
public:
bf_read();
// nMaxBits can be used as the number of bits in the buffer.
// It must be <= nBytes*8. If you leave it at -1, then it's set to nBytes * 8.
bf_read( const void *pData, int nBytes, int nBits = -1 );
bf_read( const char *pDebugName, const void *pData, int nBytes, int nBits = -1 );
// Start reading from the specified buffer.
// pData's start address must be dword-aligned.
// nMaxBits can be used as the number of bits in the buffer.
// It must be <= nBytes*8. If you leave it at -1, then it's set to nBytes * 8.
void StartReading( const void *pData, int nBytes, int iStartBit = 0, int nBits = -1 );
// Restart buffer reading.
void Reset();
// Enable or disable assertion on overflow. 99% of the time, it's a bug that we need to catch,
// but there may be the occasional buffer that is allowed to overflow gracefully.
void SetAssertOnOverflow( bool bAssert );
// This can be set to assign a name that gets output if the buffer overflows.
const char* GetDebugName() const { return m_pDebugName; }
void SetDebugName( const char *pName );
void ExciseBits( int startbit, int bitstoremove );
// Bit functions.
public:
// Returns 0 or 1.
int ReadOneBit();
protected:
unsigned int CheckReadUBitLong(int numbits); // For debugging.
int ReadOneBitNoCheck(); // Faster version, doesn't check bounds and is inlined.
bool CheckForOverflow(int nBits);
public:
// Get the base pointer.
const unsigned char* GetBasePointer() { return m_pData; }
BITBUF_INLINE int TotalBytesAvailable( void ) const
{
return m_nDataBytes;
}
// Read a list of bits in.
void ReadBits(void *pOut, int nBits);
// Read a list of bits in, but don't overrun the destination buffer.
// Returns the number of bits read into the buffer. The remaining
// bits are skipped over.
int ReadBitsClamped_ptr(void *pOut, size_t outSizeBytes, size_t nBits);
// Helper 'safe' template function that infers the size of the destination
// array. This version of the function should be preferred.
// Usage: char databuffer[100];
// ReadBitsClamped( dataBuffer, msg->m_nLength );
template <typename T, size_t N>
int ReadBitsClamped( T (&pOut)[N], size_t nBits )
{
return ReadBitsClamped_ptr( pOut, N * sizeof(T), nBits );
}
float ReadBitAngle( int numbits );
unsigned int ReadUBitLong( int numbits ) RESTRICT;
unsigned int ReadUBitLongNoInline( int numbits ) RESTRICT;
unsigned int PeekUBitLong( int numbits );
int ReadSBitLong( int numbits );
// reads an unsigned integer with variable bit length
unsigned int ReadUBitVar();
unsigned int ReadUBitVarInternal( int encodingType );
// reads a varint encoded integer
uint32 ReadVarInt32();
uint64 ReadVarInt64();
int32 ReadSignedVarInt32();
int64 ReadSignedVarInt64();
// You can read signed or unsigned data with this, just cast to
// a signed int if necessary.
unsigned int ReadBitLong(int numbits, bool bSigned);
float ReadBitCoord();
float ReadBitCoordMP( bool bIntegral, bool bLowPrecision );
float ReadBitFloat();
float ReadBitNormal();
void ReadBitVec3Coord( Vector& fa );
void ReadBitVec3Normal( Vector& fa );
void ReadBitAngles( QAngle& fa );
// Faster for comparisons but do not fully decode float values
unsigned int ReadBitCoordBits();
unsigned int ReadBitCoordMPBits( bool bIntegral, bool bLowPrecision );
// Byte functions (these still read data in bit-by-bit).
public:
BITBUF_INLINE int ReadChar() { return (char)ReadUBitLong(8); }
BITBUF_INLINE int ReadByte() { return ReadUBitLong(8); }
BITBUF_INLINE int ReadShort() { return (short)ReadUBitLong(16); }
BITBUF_INLINE int ReadWord() { return ReadUBitLong(16); }
BITBUF_INLINE long ReadLong() { return ReadUBitLong(32); }
int64 ReadLongLong();
float ReadFloat();
bool ReadBytes(void *pOut, int nBytes);
// Returns false if bufLen isn't large enough to hold the
// string in the buffer.
//
// Always reads to the end of the string (so you can read the
// next piece of data waiting).
//
// If bLine is true, it stops when it reaches a '\n' or a null-terminator.
//
// pStr is always null-terminated (unless bufLen is 0).
//
// pOutNumChars is set to the number of characters left in pStr when the routine is
// complete (this will never exceed bufLen-1).
//
bool ReadString( char *pStr, int bufLen, bool bLine=false, int *pOutNumChars=NULL );
// Reads a string and allocates memory for it. If the string in the buffer
// is > 2048 bytes, then pOverflow is set to true (if it's not NULL).
char* ReadAndAllocateString( bool *pOverflow = 0 );
// Returns nonzero if any bits differ
int CompareBits( bf_read * RESTRICT other, int bits ) RESTRICT;
int CompareBitsAt( int offset, bf_read * RESTRICT other, int otherOffset, int bits ) RESTRICT;
// Status.
public:
int GetNumBytesLeft();
int GetNumBytesRead();
int GetNumBitsLeft();
int GetNumBitsRead() const;
// Has the buffer overflowed?
inline bool IsOverflowed() const {return m_bOverflow;}
inline bool Seek(int iBit); // Seek to a specific bit.
inline bool SeekRelative(int iBitDelta); // Seek to an offset from the current position.
// Called when the buffer is overflowed.
void SetOverflowFlag();
public:
// The current buffer.
const unsigned char* RESTRICT m_pData;
int m_nDataBytes;
int m_nDataBits;
// Where we are in the buffer.
int m_iCurBit;
private:
// Errors?
bool m_bOverflow;
// For debugging..
bool m_bAssertOnOverflow;
const char *m_pDebugName;
};
//-----------------------------------------------------------------------------
// Inlines.
//-----------------------------------------------------------------------------
inline int bf_read::GetNumBytesRead()
{
return BitByte(m_iCurBit);
}
inline int bf_read::GetNumBitsLeft()
{
return m_nDataBits - m_iCurBit;
}
inline int bf_read::GetNumBytesLeft()
{
return GetNumBitsLeft() >> 3;
}
inline int bf_read::GetNumBitsRead() const
{
return m_iCurBit;
}
inline bool bf_read::Seek(int iBit)
{
if(iBit < 0 || iBit > m_nDataBits)
{
SetOverflowFlag();
m_iCurBit = m_nDataBits;
return false;
}
else
{
m_iCurBit = iBit;
return true;
}
}
// Seek to an offset from the current position.
inline bool bf_read::SeekRelative(int iBitDelta)
{
return Seek(m_iCurBit+iBitDelta);
}
inline bool bf_read::CheckForOverflow(int nBits)
{
if( m_iCurBit + nBits > m_nDataBits )
{
SetOverflowFlag();
CallErrorHandler( BITBUFERROR_BUFFER_OVERRUN, GetDebugName() );
}
return m_bOverflow;
}
inline int bf_read::ReadOneBitNoCheck()
{
#if VALVE_LITTLE_ENDIAN
unsigned int value = ((unsigned long * RESTRICT)m_pData)[m_iCurBit >> 5] >> (m_iCurBit & 31);
#else
unsigned char value = m_pData[m_iCurBit >> 3] >> (m_iCurBit & 7);
#endif
++m_iCurBit;
return value & 1;
}
inline int bf_read::ReadOneBit()
{
if( GetNumBitsLeft() <= 0 )
{
SetOverflowFlag();
CallErrorHandler( BITBUFERROR_BUFFER_OVERRUN, GetDebugName() );
return 0;
}
return ReadOneBitNoCheck();
}
inline float bf_read::ReadBitFloat()
{
union { uint32 u; float f; } c = { ReadUBitLong(32) };
return c.f;
}
BITBUF_INLINE unsigned int bf_read::ReadUBitVar()
{
// six bits: low 2 bits for encoding + first 4 bits of value
unsigned int sixbits = ReadUBitLong(6);
unsigned int encoding = sixbits & 3;
if ( encoding )
{
// this function will seek back four bits and read the full value
return ReadUBitVarInternal( encoding );
}
return sixbits >> 2;
}
BITBUF_INLINE unsigned int bf_read::ReadUBitLong( int numbits ) RESTRICT
{
Assert( numbits > 0 && numbits <= 32 );
if ( GetNumBitsLeft() < numbits )
{
m_iCurBit = m_nDataBits;
SetOverflowFlag();
CallErrorHandler( BITBUFERROR_BUFFER_OVERRUN, GetDebugName() );
return 0;
}
unsigned int iStartBit = m_iCurBit & 31u;
int iLastBit = m_iCurBit + numbits - 1;
unsigned int iWordOffset1 = m_iCurBit >> 5;
unsigned int iWordOffset2 = iLastBit >> 5;
m_iCurBit += numbits;
#if __i386__
unsigned int bitmask = (2 << (numbits-1)) - 1;
#else
extern unsigned long g_ExtraMasks[33];
unsigned int bitmask = g_ExtraMasks[numbits];
#endif
unsigned int dw1 = LoadLittleDWord( (unsigned long* RESTRICT)m_pData, iWordOffset1 ) >> iStartBit;
unsigned int dw2 = LoadLittleDWord( (unsigned long* RESTRICT)m_pData, iWordOffset2 ) << (32 - iStartBit);
return (dw1 | dw2) & bitmask;
}
BITBUF_INLINE int bf_read::CompareBits( bf_read * RESTRICT other, int numbits ) RESTRICT
{
return (ReadUBitLong(numbits) != other->ReadUBitLong(numbits));
}
#endif