Added bitbuf from source sdk 2013
This commit is contained in:
parent
0fe0ac912a
commit
cd6badfe1f
1490
external/bitbuf/bitbuf.cpp
vendored
Normal file
1490
external/bitbuf/bitbuf.cpp
vendored
Normal file
File diff suppressed because it is too large
Load Diff
809
external/bitbuf/bitbuf.h
vendored
Normal file
809
external/bitbuf/bitbuf.h
vendored
Normal 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
|
||||
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user