根据C++版的改编，刚刚改完，估计使用会有问题，对于uint8处理的不好
关于使用：
BitStream bs = new BitStream( );
bs.WriteInt32( ); int a = bs.ReadInt32( );
非常简单
BitStream.cs
public class BitStream
{
#if __BITSTREAM_BIG_END
// Set up the read/write routines to produce Big-End network streams.
private const int B16_1 = ;
private const int B16_0 = ; private const int B32_3 = ;
private const int B32_2 = ;
private const int B32_1 = ;
private const int B32_0 = ; private const int B64_7 = ;
private const int B64_6 = ;
private const int B64_5 = ;
private const int B64_4 = ;
private const int B64_3 = ;
private const int B64_2 = ;
private const int B64_1 = ;
private const int B64_0 = ; #else
// Default to producing Little-End network streams.
private const int B16_1 = ;
private const int B16_0 = ; private const int B32_3 = ;
private const int B32_2 = ;
private const int B32_1 = ;
private const int B32_0 = ; private const int B64_7 = ;
private const int B64_6 = ;
private const int B64_5 = ;
private const int B64_4 = ;
private const int B64_3 = ;
private const int B64_2 = ;
private const int B64_1 = ;
private const int B64_0 = ;
#endif
public const int BITSTREAM_STACK_ALLOCATION_SIZE = ; /// Default Constructor
public static int BITS_TO_BYTES(int x)
{
return (((x) + ) >> );
} public static int BYTES_TO_BITS(int x)
{
return (x << );
} /**
* @brief Packets encoding and decoding facilities
*
* Helper class to encode and decode packets.
*
*/ /**
* Default Constructor
*/ public BitStream()
{
numberOfBitsUsed = ;
//numberOfBitsAllocated = 32 * 8;
numberOfBitsAllocated = BITSTREAM_STACK_ALLOCATION_SIZE*;
readOffset = ;
//data = ( unsigned char* ) malloc( 32 );
data = stackData;
copyData = true;
} /**
* Preallocate some memory for the construction of the packet
* @param initialBytesToAllocate the amount of byte to pre-allocate.
*/ public BitStream(int initialBytesToAllocate)
{
numberOfBitsUsed = ;
readOffset = ;
if (initialBytesToAllocate <= BITSTREAM_STACK_ALLOCATION_SIZE)
{
data = stackData;
numberOfBitsAllocated = BITSTREAM_STACK_ALLOCATION_SIZE*;
}
else
{
data = new Byte[initialBytesToAllocate];
numberOfBitsAllocated = initialBytesToAllocate << ;
}
copyData = true;
} /**
* Initialize the BitStream object using data from the network.
* Set _copyData to true if you want to make an internal copy of
* the data you are passing. You can then Write and do all other
* operations Set it to false if you want to just use a pointer to
* the data you are passing, in order to save memory and speed.
* You should only then do read operations.
* @param _data An array of bytes.
* @param lengthInBytes Size of the @em _data.
* @param _copyData Does a copy of the input data.
*/ public BitStream(Byte[] _data, int lengthInBytes, bool _copyData)
{
numberOfBitsUsed = lengthInBytes << ;
readOffset = ;
copyData = _copyData;
numberOfBitsAllocated = lengthInBytes << ; if (copyData)
{
if (lengthInBytes > )
{
if (lengthInBytes < BITSTREAM_STACK_ALLOCATION_SIZE)
{
data = stackData;
numberOfBitsAllocated = BITSTREAM_STACK_ALLOCATION_SIZE << ;
}
else
{
data = new Byte[lengthInBytes];
}
_data.CopyTo(data, );
}
else
data = null;
}
else
{
data = _data;
numberOfBitsUsed = ;
}
} //
public BitStream(Byte[] _data, int lengthInBytes, int datasize)
{
numberOfBitsUsed = datasize << ;
readOffset = ;
numberOfBitsAllocated = lengthInBytes << ;
data = _data;
copyData = false;
} /**
* Destructor
*/
//~BitStream(){}
/**
* Reset the bitstream for reuse
*/ private void Reset()
{
if (numberOfBitsUsed > )
{
// memset(data, 0, BITS_TO_BYTES(numberOfBitsUsed));
}
// Don't free memory here for speed efficiency
//free(data); // Use realloc and free so we are more efficient than delete and new for resizing
numberOfBitsUsed = ;
//numberOfBitsAllocated=8;
readOffset = ;
} public void SetBuffer(Byte[] _data, int lengthInBytes, int datasize)
{
numberOfBitsUsed = datasize << ;
readOffset = ;
numberOfBitsAllocated = lengthInBytes << ;
data = _data;
copyData = false;
} public void ClearBuffer()
{
numberOfBitsUsed = ;
readOffset = ;
numberOfBitsAllocated = ;
data = null;
} /**
* Write the native types to the end of the buffer
* without any compression mecanism.
* @param input The data
*/ public void WriteBool(bool input)
{
if (input)
WriteInt8();
else
WriteInt8();
} /**
* Write the native types to the end of the buffer
* without any compression mecanism.
* @param input The data
*/ public void WriteUInt8(Byte input)
{
WriteBits(BitConverter.GetBytes(input), sizeof (Byte)*, true);
} // /**
* Write the native types to the end of the buffer
* without any compression mecanism.
* @param input The data
*/ public void WriteInt8(SByte input)
{
WriteBits(BitConverter.GetBytes(input), sizeof (SByte)*, true);
} /**
* Write the native types to the end of the buffer
* without any compression mecanism.
* @param input The data
*/ public void WriteUInt16(UInt16 input)
{
var uint16w = new Byte[];
uint16w[B16_1] = (Byte) ((Byte) (input >> ) & (0xff));
uint16w[B16_0] = (Byte) (input & (0xff)); WriteBits(uint16w, sizeof (UInt16)*, true);
} /**
* Write the native types to the end of the buffer
* without any compression mecanism.
* @param input The data
*/ public void WriteInt16(Int16 input)
{
var int16w = new Byte[];
int16w[B16_1] = (Byte) ((Byte) (input >> ) & (0xff));
int16w[B16_0] = (Byte) (input & (0xff)); WriteBits(int16w, sizeof (Int16)*, true);
} /**
* Write the native types to the end of the buffer
* without any compression mecanism.
* @param input The data
*/ public void WriteUInt32(UInt32 input)
{
var uint32w = new Byte[];
uint32w[B32_3] = (Byte) ((Byte) (input >> ) & (0x000000ff));
uint32w[B32_2] = (Byte) ((Byte) (input >> ) & (0x000000ff));
uint32w[B32_1] = (Byte) ((Byte) (input >> ) & (0x000000ff));
uint32w[B32_0] = (Byte) ((input) & (0x000000ff)); WriteBits(uint32w, sizeof (UInt32)*, true);
} /**
* Write the native types to the end of the buffer
* without any compression mecanism.
* @param input The data
*/ public void WriteInt32(int input)
{
var int32w = new Byte[];
int32w[B32_3] = (Byte) ((Byte) (input >> ) & (0x000000ff));
int32w[B32_2] = (Byte) ((Byte) (input >> ) & (0x000000ff));
int32w[B32_1] = (Byte) ((Byte) (input >> ) & (0x000000ff));
int32w[B32_0] = (Byte) ((input) & (0x000000ff)); WriteBits(int32w, sizeof (int)*, true);
} //#if HAS_INT64
/**
* Write the native types to the end of the buffer
* without any compression mecanism.
* @param input The data
*/ public void WriteUInt64(UInt64 input)
{
var uint64w = new Byte[];
uint64w[B64_7] = (Byte) ((input >> ) & 0xff);
uint64w[B64_6] = (Byte) ((input >> ) & 0xff);
uint64w[B64_5] = (Byte) ((input >> ) & 0xff);
uint64w[B64_4] = (Byte) ((input >> ) & 0xff);
uint64w[B64_3] = (Byte) ((input >> ) & 0xff);
uint64w[B64_2] = (Byte) ((input >> ) & 0xff);
uint64w[B64_1] = (Byte) ((input >> ) & 0xff);
uint64w[B64_0] = (Byte) (input & 0xff); WriteBits(uint64w, sizeof (UInt64)*, true);
} /**
* Write the native types to the end of the buffer
* without any compression mecanism.
* @param input The data
*/ public void WriteInt64(Int64 input)
{
var int64w = new Byte[];
int64w[B64_7] = (Byte) ((input >> ) & 0xff);
int64w[B64_6] = (Byte) ((input >> ) & 0xff);
int64w[B64_5] = (Byte) ((input >> ) & 0xff);
int64w[B64_4] = (Byte) ((input >> ) & 0xff);
int64w[B64_3] = (Byte) ((input >> ) & 0xff);
int64w[B64_2] = (Byte) ((input >> ) & 0xff);
int64w[B64_1] = (Byte) ((input >> ) & 0xff);
int64w[B64_0] = (Byte) (input & 0xff); WriteBits(int64w, sizeof (Int64)*, true);
} //#endif /**
* Write the native types to the end of the buffer
* without any compression mecanism.
* @param input The data
*/ public void WriteFloat(float input)
{
WriteBits(BitConverter.GetBytes(input), sizeof (float)*, true);
} /**
* Write the native types to the end of the buffer
* without any compression mechanism.
* @param input The data
*/ public void WriteDouble(double input)
{
WriteBits(BitConverter.GetBytes(input), sizeof (double)*, true);
} /**
* Write an array or casted stream. It is supposed to
* be raw data. It is also not possible to deal with endian problem
* @param input a byte buffer
* @param numberOfBytes the size of the byte buffer
*/ public void WriteBytes(Byte[] input, int numberOfBytes)
{
WriteBits(input, numberOfBytes*, true);
} /**
* write multi bytes string
* @param input
*/ public void WriteStr(string input)
{
var len = (short) input.Length;
WriteUInt16((ushort) len);
if (len > )
{
WriteBytes(Encoding.Default.GetBytes(input), len);
}
} /// **
// * write standard string
// * @param input
// */
// public void WriteStr(
// const std::
// string
//&
// input
//){}
/**
* Copy from another bitstream
* @bitStream the bitstream to copy from
*/
public void WriteBS(BitStream bitStream)
{
WriteBits(bitStream.GetData(), bitStream.GetWriteOffset(), false);
} /**
* Write the native types with simple compression.
* Best used with negatives and positives close to 0
* @param input The data.
*/ public void WriteCompUInt8(Byte input)
{
WriteCompressed(BitConverter.GetBytes(input), sizeof (Byte)*, true);
} /**
* Write the native types with simple compression.
* Best used with negatives and positives close to 0
* @param input The data.
*/ public void WriteCompInt8(SByte input)
{
WriteCompressed(BitConverter.GetBytes(input), sizeof (SByte)*, false);
} /**
* Write the native types with simple compression.
* Best used with negatives and positives close to 0
* @param input The data.
*/ public void WriteCompUInt16(UInt16 input)
{
var uint16wc = new Byte[];
uint16wc[B16_1] = (byte) ((Byte) (input >> ) & (0xff));
uint16wc[B16_0] = (byte) (input & (0xff)); WriteCompressed(uint16wc, sizeof (UInt16)*, true);
} /**
* Write the native types with simple compression.
* Best used with negatives and positives close to 0
* @param input The data.
*/ public void WriteCompInt16(Int16 input)
{
var int16wc = new Byte[];
int16wc[B16_1] = (Byte) ((input >> ) & (0xff));
int16wc[B16_0] = (Byte) (input & (0xff)); WriteCompressed(int16wc, sizeof (Int16)*, false);
} /**
* Write the native types with simple compression.
* Best used with negatives and positives close to 0
* @param input The data.
*/ public void WriteCompUInt32(UInt32 input)
{
var uint32wc = new Byte[];
uint32wc[B32_3] = (Byte) ((input >> ) & (0x000000ff));
uint32wc[B32_2] = (Byte) ((input >> ) & (0x000000ff));
uint32wc[B32_1] = (Byte) ((input >> ) & (0x000000ff));
uint32wc[B32_0] = (Byte) ((input) & (0x000000ff)); WriteCompressed(uint32wc, sizeof (UInt32)*, true);
} /**
* Write the native types with simple compression.
* Best used with negatives and positives close to 0
* @param input The data.
*/ public void WriteCompInt32(int input)
{
var int32wc = new Byte[];
int32wc[B32_3] = (Byte) ((input >> ) & (0x000000ff));
int32wc[B32_2] = (Byte) ((input >> ) & (0x000000ff));
int32wc[B32_1] = (Byte) ((input >> ) & (0x000000ff));
int32wc[B32_0] = (Byte) ((input) & (0x000000ff)); WriteCompressed(int32wc, sizeof (int)*, false);
} //#ifdef HAS_INT64
/**
* Write the native types with simple compression.
* Best used with negatives and positives close to 0
* @param input The data.
*/ public void WriteCompUInt64(UInt64 input)
{
var uint64wc = new Byte[];
uint64wc[B64_7] = (Byte) ((input >> ) & 0xff);
uint64wc[B64_6] = (Byte) ((input >> ) & 0xff);
uint64wc[B64_5] = (Byte) ((input >> ) & 0xff);
uint64wc[B64_4] = (Byte) ((input >> ) & 0xff);
uint64wc[B64_3] = (Byte) ((input >> ) & 0xff);
uint64wc[B64_2] = (Byte) ((input >> ) & 0xff);
uint64wc[B64_1] = (Byte) ((input >> ) & 0xff);
uint64wc[B64_0] = (Byte) (input & 0xff); WriteCompressed(uint64wc, sizeof (UInt64)*, true);
} /**
* Write the native types with simple compression.
* Best used with negatives and positives close to 0
* @param input The data.
*/ public void WriteCompInt64(Int64 input)
{
var int64wc = new Byte[];
int64wc[B64_7] = (Byte) ((input >> ) & 0xff);
int64wc[B64_6] = (Byte) ((input >> ) & 0xff);
int64wc[B64_5] = (Byte) ((input >> ) & 0xff);
int64wc[B64_4] = (Byte) ((input >> ) & 0xff);
int64wc[B64_3] = (Byte) ((input >> ) & 0xff);
int64wc[B64_2] = (Byte) ((input >> ) & 0xff);
int64wc[B64_1] = (Byte) ((input >> ) & 0xff);
int64wc[B64_0] = (Byte) (input & 0xff); WriteCompressed(int64wc, sizeof (Int64)*, false);
} //#endif
/**
* Write the native types with simple compression.
* Best used with negatives and positives close to 0
* @param input The data.
*/ public void WriteCompFloat(float input)
{
WriteFloat(input);
} /**
* Write the native types with simple compression.
* Best used with negatives and positives close to 0
* @param input The data.
*/ public void WriteCompDouble(double input)
{
WriteDouble(input);
} /**
* Read the native types from the front of the buffer
* @param output The readed value.
* @return true on success false otherwise. The result of a reading
* can only be wrong in the case we reach the end of the BitStream
* with some missing bits.
*/ public bool ReadBool()
{
if (readOffset + > numberOfBitsUsed)
return false; //if (ReadBit()) // Check that bit
if ((data[readOffset >> ] & (0x80 >> (readOffset++%))) != ) // Is it faster to just write it out here?
return true; return false;
} /**
* Read the native types from the front of the buffer
* @param output The readed value.
* @return true on success false otherwise. The result of a reading
* can only be wrong in the case we reach the end of the BitStream
* with some missing bits.
*/ public SByte ReadUInt8()
{
var x = new Byte[sizeof (SByte)];
if (ReadBits(ref x, sizeof (SByte)*))
{
return (SByte) BitConverter.ToChar(x, );
}
return ;
} /**
* Read the native types from the front of the buffer
* @param output The readed value.
* @return true on success false otherwise. The result of a reading
* can only be wrong in the case we reach the end of the BitStream
* with some missing bits.
*/ public Byte ReadInt8()
{
var x = new Byte[sizeof (Byte)];
if (ReadBits(ref x, sizeof (Byte)*))
{
return (Byte) BitConverter.ToChar(x, );
;
}
return ;
} /**
* Read the native types from the front of the buffer
* @param output The readed value.
* @return true on success false otherwise. The result of a reading
* can only be wrong in the case we reach the end of the BitStream
* with some missing bits.
*/ public UInt16 ReadUInt16()
{
var uint16r = new Byte[];
if (ReadBits(ref uint16r, sizeof (UInt16)*) != true)
return ;
return (ushort) ((uint16r[B16_1] << ) | uint16r[B16_0]);
} /**
* Read the native types from the front of the buffer
* @param output The readed value.
* @return true on success false otherwise. The result of a reading
* can only be wrong in the case we reach the end of the BitStream
* with some missing bits.
*/ public short ReadInt16()
{
var int16r = new Byte[];
if (ReadBits(ref int16r, sizeof (short)*) != true)
return ; return (short) ((int16r[B16_1] << ) | int16r[B16_0]);
} /**
* Read the native types from the front of the buffer
* @param output The readed value.
* @return true on success false otherwise. The result of a reading
* can only be wrong in the case we reach the end of the BitStream
* with some missing bits.
*/ public UInt32 ReadUInt32()
{
var uint32r = new Byte[];
if (ReadBits(ref uint32r, sizeof (UInt32)*) != true)
return ;
return (((UInt32) uint32r[B32_3]) << ) |
(((UInt32) uint32r[B32_2]) << ) |
(((UInt32) uint32r[B32_1]) << ) |
uint32r[B32_0];
} /**
* Read the native types from the front of the buffer
* @param output The readed value.
* @return true on success false otherwise. The result of a reading
* can only be wrong in the case we reach the end of the BitStream
* with some missing bits.
*/ public int ReadInt32()
{
var int32r = new Byte[];
if (ReadBits(ref int32r, sizeof (int)*) != true)
return ;
return (int32r[B32_3] << ) |
(int32r[B32_2] << ) |
(int32r[B32_1] << ) |
int32r[B32_0];
} //#ifdef HAS_INT64
/**
* Read the native types from the front of the buffer
* @param output The readed value.
* @return true on success false otherwise. The result of a reading
* can only be wrong in the case we reach the end of the BitStream
* with some missing bits.
*/ public UInt64 ReadUInt64()
{
var uint64r = new Byte[];
if (ReadBits(ref uint64r, sizeof (UInt64)*) != true)
return ;
return (((UInt64) uint64r[B64_7]) << ) | (((UInt64) uint64r[B64_6]) << ) |
(((UInt64) uint64r[B64_5]) << ) | (((UInt64) uint64r[B64_4]) << ) |
(((UInt64) uint64r[B64_3]) << ) | (((UInt64) uint64r[B64_2]) << ) |
(((UInt64) uint64r[B64_1]) << ) | uint64r[B64_0];
} /**
* Read the native types from the front of the buffer
* @param output The readed value.
* @return true on success false otherwise. The result of a reading
* can only be wrong in the case we reach the end of the BitStream
* with some missing bits.
*/ public Int64 ReadInt64()
{
var int64r = new Byte[];
if (ReadBits(ref int64r, sizeof (Int64)*) != true)
return ;
return (Int64) ((((UInt64) int64r[B64_7]) << ) | (((UInt64) int64r[B64_6]) << ) |
(((UInt64) int64r[B64_5]) << ) | (((UInt64) int64r[B64_4]) << ) |
(((UInt64) int64r[B64_3]) << ) | (((UInt64) int64r[B64_2]) << ) |
(((UInt64) int64r[B64_1]) << ) | int64r[B64_0]);
} //#endif
/**
* Read the native types from the front of the buffer
* @param output The readed value.
* @return true on success false otherwise. The result of a reading
* can only be wrong in the case we reach the end of the BitStream
* with some missing bits.
*/ public float ReadFloat()
{
uint val = ReadUInt32();
return BitConverter.ToSingle(BitConverter.GetBytes(val), );
} /**
* Read the native types from the front of the buffer
* @param output The readed value.
* @return true on success false otherwise. The result of a reading
* can only be wrong in the case we reach the end of the BitStream
* with some missing bits.
*/ public double ReadDouble()
{
UInt64 val = ReadUInt64();
return BitConverter.ToDouble(BitConverter.GetBytes(val), );
} /**
* Read an array or casted stream of byte. The array
* is raw data. There is no automatic conversion on
* big endian arch
* @param output The result byte array. It should be larger than @em numberOfBytes.
* @param numberOfBytes The number of byte to read
* @return true on success false if there is some missing bytes.
*/ public bool ReadBytes(ref Byte[] output, int numberOfBytes)
{
return ReadBits(ref output, numberOfBytes*);
} /**
* Read standard string
* @return
*/ public string ReadStr()
{
string strs;
ushort len = ReadUInt16();
if (len > )
{
var str = new Byte[len + ];
if (ReadBytes(ref str, len))
{
str[len] = ;
strs = Encoding.Default.GetString(str);
return strs;
}
}
return string.Empty;
} /**
* Read the types you wrote with WriteCompressed
* @param output The read value
* @return true on success, false on not enough data to read
*/ public SByte ReadCompUInt8()
{
var uint8rc = new Byte[sizeof (Byte)]; if (ReadCompressed(ref uint8rc, sizeof (Byte)*, true))
{
return (SByte) uint8rc[];
}
return ;
} /**
* Read the types you wrote with WriteCompressed
* @param output The read value
* @return true on success, false on not enough data to read
*/ public Byte ReadCompInt8()
{
var uint8rc = new Byte[sizeof (Byte)]; if (ReadCompressed(ref uint8rc, sizeof (Byte)*, true))
{
return uint8rc[];
}
return ;
} /**
* Read the types you wrote with WriteCompressed
* @param output The read value
* @return true on success, false on not enough data to read
*/ public UInt16 ReadCompUInt16()
{
var uint16rc = new Byte[];
if (ReadCompressed(ref uint16rc, sizeof (UInt16)*, true) != true)
return ;
return (ushort) ((uint16rc[B16_1] << ) |
uint16rc[B16_0]);
} /**
* Read the types you wrote with WriteCompressed
* @param output The read value
* @return true on success, false on not enough data to read
*/ public short ReadCompInt16()
{
var int16rc = new byte[];
if (ReadCompressed(ref int16rc, sizeof (short)*, false) != true) return ;
return (short) ((int16rc[B16_1] << ) | int16rc[B16_0]);
} /**
* Read the types you wrote with WriteCompressed
* @param output The read value
* @return true on success, false on not enough data to read
*/ public UInt32 ReadCompUInt32()
{
var uint32rc = new Byte[];
if (ReadCompressed(ref uint32rc, sizeof (UInt32)*, true) != true)
return ;
return (((UInt32) uint32rc[B32_3]) << ) |
(((UInt32) uint32rc[B32_2]) << ) |
(((UInt32) uint32rc[B32_1]) << ) |
uint32rc[B32_0];
} /**
* Read the types you wrote with WriteCompressed
* @param output The read value
* @return true on success, false on not enough data to read
*/ public int ReadCompInt32()
{
var int32rc = new Byte[];
if (ReadCompressed(ref int32rc, sizeof (int)*, false) != true)
return ;
return (int) ((((UInt32) int32rc[B32_3]) << ) |
(((UInt32) int32rc[B32_2]) << ) |
(((UInt32) int32rc[B32_1]) << ) |
int32rc[B32_0]);
} //#ifdef HAS_INT64
/**
* Read the types you wrote with WriteCompressed
* @param output The read value
* @return true on success, false on not enough data to read
*/ public UInt64 ReadCompUInt64()
{
var uint64rc = new Byte[];
if (ReadCompressed(ref uint64rc, sizeof (UInt64)*, true) != true)
return ;
return (((UInt64) uint64rc[B64_7]) << ) | (((UInt64) uint64rc[B64_6]) << ) |
(((UInt64) uint64rc[B64_5]) << ) | (((UInt64) uint64rc[B64_4]) << ) |
(((UInt64) uint64rc[B64_3]) << ) | (((UInt64) uint64rc[B64_2]) << ) |
(((UInt64) uint64rc[B64_1]) << ) | uint64rc[B64_0];
} /**
* Read the types you wrote with WriteCompressed
* @param output The read value
* @return true on success, false on not enough data to read
*/ public Int64 ReadCompInt64()
{
var int64rc = new Byte[];
if (ReadCompressed(ref int64rc, sizeof (Int64)*, false) != true)
return ;
return (Int64) ((((UInt64) int64rc[B64_7]) << ) | (((UInt64) int64rc[B64_6]) << ) |
(((UInt64) int64rc[B64_5]) << ) | (((UInt64) int64rc[B64_4]) << ) |
(((UInt64) int64rc[B64_3]) << ) | (((UInt64) int64rc[B64_2]) << ) |
(((UInt64) int64rc[B64_1]) << ) | int64rc[B64_0]);
} //#endif
/**
* Read the types you wrote with WriteCompressed
* @param output The read value
* @return true on success, false on not enough data to read
*/ public float ReadCompFloat()
{
return ReadFloat();
} /**
* Read the types you wrote with WriteCompressed
* @param output The read value
* @return true on success, false on not enough data to read
*/ public double ReadCompDouble()
{
return ReadDouble();
} /**
* Read a normalized 3D vector, using (at most) 4 bytes + 3 bits instead of 12 bytes. Will further compress y or z axis aligned vectors.
* Accurate to 1/32767.5.
* @param x x
* @param y y
* @param z z
*/ /**
* This is good to call when you are done with the stream to make
* sure you didn't leave any data left over void
*/ public void AssertStreamEmpty()
{
if (readOffset == numberOfBitsUsed)
throw new Exception();
} // * print to the standard output the state of the stream bit by bit
// */ //public void PrintBits()
//{ //}
/// **
/// **
// * Ignore data we don't intend to read
// * @param numberOfBits The number of bits to ignore
// */
public void IgnoreBits(int numberOfBits)
{
readOffset += numberOfBits;
} /**
* Move the write pointer to a position on the array.
* @param offset the offset from the start of the array.
* @attention
* Dangerous if you don't know what you are doing!
*
*/ public void SetWriteOffset(int offset)
{
numberOfBitsUsed = offset;
} /**
* Returns the length in bits of the stream
*/ public int GetWriteOffset()
{
return numberOfBitsUsed;
} /**
* Returns the length in bytes of the stream
*/ public int GetNumberOfBytesUsed()
{
return BITS_TO_BYTES(numberOfBitsUsed);
} public int GetNumberOfBytesRead()
{
return BITS_TO_BYTES(readOffset);
} /**
* Move the read pointer to a position on the array.
* @param offset
*/ public void SetReadOffset(int offset)
{
readOffset = offset;
} public void SetByteReadOffSet(int offset)
{
readOffset = BYTES_TO_BITS(offset);
} /**
* Returns the number of bits into the stream that we have read
*/ public int GetReadOffset()
{
return readOffset;
} /**
* Returns the number of bits left in the stream that haven't been read
*/ public int GetNumberOfUnreadBits()
{
return numberOfBitsUsed - readOffset;
} /**
* Makes a copy of the internal data for you Data will point to
* the stream. Returns the length in bits of the stream. Partial
* bytes are left aligned
* @param _data the resulting byte copy of the internal state.
*/ public int CopyData(Byte[] _data)
{
_data = new Byte[BITS_TO_BYTES(numberOfBitsUsed)];
data.CopyTo(_data, );
return numberOfBitsUsed;
} /**
* Set the stream to some initial data. For internal use
* Partial bytes are left aligned
* @param input The data
* @param numberOfBits the number of bits set in the data buffer
*/ public void SetData(Byte[] input, int numberOfBits)
{
if (numberOfBits <= )
return;
AddBitsAndReallocate(numberOfBits);
input.CopyTo(data, );
numberOfBitsUsed = numberOfBits;
} /**
* Exposes the internal data.
* Partial bytes are left aligned.
* @return A pointer to the internal state
*/ public Byte[] GetData()
{
return data;
} /**
* Write numberToWrite bits from the input source Right aligned
* data means in the case of a partial byte, the bits are aligned
* from the right (bit 0) rather than the left (as in the normal
* internal representation) You would set this to true when
* writing user data, and false when copying bitstream data, such
* as writing one bitstream to another
* @param input The data
* @param numberOfBitsToWrite The number of bits to write
* @param rightAlignedBits if true data will be right aligned
*/ public void WriteBits(Byte[] input, int numberOfBitsToWrite, bool rightAlignedBits = true)
{
AddBitsAndReallocate(numberOfBitsToWrite);
int offset = ;
Byte dataByte;
int numberOfBitsUsedMod8; numberOfBitsUsedMod8 = numberOfBitsUsed%; // Faster to put the while at the top surprisingly enough
while (numberOfBitsToWrite > )
//do
{
dataByte = input[offset]; //*( input + offset ); if (numberOfBitsToWrite < && rightAlignedBits)
// rightAlignedBits means in the case of a partial byte, the bits are aligned from the right (bit 0) rather than the left (as in the normal internal representation)
dataByte <<= - numberOfBitsToWrite;
// shift left to get the bits on the left, as in our internal representation // Writing to a new byte each time
if (numberOfBitsUsedMod8 == )
data[numberOfBitsUsed >> ] = dataByte; //*( data + ( numberOfBitsUsed >> 3 ) ) = dataByte;
else
{
// Copy over the new data.
data[numberOfBitsUsed >> ] |= (Byte) (dataByte >> (numberOfBitsUsedMod8));
//*( data + ( numberOfBitsUsed >> 3 ) ) |= dataByte >> ( numberOfBitsUsedMod8 ); // First half if ( - (numberOfBitsUsedMod8) < && - (numberOfBitsUsedMod8) < numberOfBitsToWrite)
// If we didn't write it all out in the first half (8 - (numberOfBitsUsed%8) is the number we wrote in the first half)
{
//*( data + ( numberOfBitsUsed >> 3 ) + 1 ) = (unsigned char) ( dataByte << ( 8 - ( numberOfBitsUsedMod8 ) ) ); // Second half (overlaps byte boundary)
data[(numberOfBitsUsed >> ) + ] = (Byte) (dataByte << ( - (numberOfBitsUsedMod8)));
}
} if (numberOfBitsToWrite >= )
numberOfBitsUsed += ;
else
numberOfBitsUsed += numberOfBitsToWrite; numberOfBitsToWrite -= ; offset++;
}
} /**
* Align the bitstream to the byte boundary and then write the
* specified number of bits. This is faster than WriteBits but
* wastes the bits to do the alignment and requires you to call
* ReadAlignedBits at the corresponding read position.
* @param input The data
* @param numberOfBytesToWrite The size of data.
*/ public void WriteAlignedBytes(Byte[] input, int numberOfBytesToWrite)
{
AlignWriteToByteBoundary();
// Allocate enough memory to hold everything
AddBitsAndReallocate(numberOfBytesToWrite << ); // Write the data
//memcpy( data + ( numberOfBitsUsed >> 3 ), input, numberOfBytesToWrite );
input.CopyTo(data, (numberOfBitsUsed >> ));
numberOfBitsUsed += numberOfBytesToWrite << ;
} /**
* Read bits, starting at the next aligned bits. Note that the
* modulus 8 starting offset of the sequence must be the same as
* was used with WriteBits. This will be a problem with packet
* coalescence unless you byte align the coalesced packets.
* @param output The byte array larger than @em numberOfBytesToRead
* @param numberOfBytesToRead The number of byte to read from the internal state
* @return true if there is enough byte.
*/ public bool ReadAlignedBytes(out Byte[] output, int numberOfBytesToRead)
{
if (numberOfBytesToRead <= )
{
output = null;
return false;
}
// Byte align
AlignReadToByteBoundary();
if (readOffset + (numberOfBytesToRead << ) > numberOfBitsUsed)
{
output = null;
return false;
} // Write the data
//memcpy( output, data + ( readOffset >> 3 ), numberOfBytesToRead );
output = new byte[] {};
Array.Copy(data, readOffset >> , output, , numberOfBytesToRead);
readOffset += numberOfBytesToRead << ;
return true;
} /**
* Align the next write and/or read to a byte boundary. This can
* be used to 'waste' bits to byte align for efficiency reasons It
* can also be used to force coalesced bitstreams to start on byte
* boundaries so so WriteAlignedBits and ReadAlignedBits both
* calculate the same offset when aligning.
*/ public void AlignWriteToByteBoundary()
{
if (numberOfBitsUsed > )
numberOfBitsUsed += - ((numberOfBitsUsed - )% + );
} /**
* Align the next write and/or read to a byte boundary. This can
* be used to 'waste' bits to byte align for efficiency reasons It
* can also be used to force coalesced bitstreams to start on byte
* boundaries so so WriteAlignedBits and ReadAlignedBits both
* calculate the same offset when aligning.
*/ public void AlignReadToByteBoundary()
{
if (readOffset > )
readOffset += - ((readOffset - )% + );
} /**
* Read numberOfBitsToRead bits to the output source
* alignBitsToRight should be set to true to convert internal
* bitstream data to userdata It should be false if you used
* WriteBits with rightAlignedBits false
* @param output The resulting bits array
* @param numberOfBitsToRead The number of bits to read
* @param alignsBitsToRight if true bits will be right aligned.
* @return true if there is enough bits to read
*/ public bool ReadBits(ref Byte[] output, int numberOfBitsToRead, bool alignBitsToRight = true)
{
if (readOffset + numberOfBitsToRead > numberOfBitsUsed)
{
output = null;
return false;
} int readOffsetMod8;
int offset = ;
//memset( output, 0, BITS_TO_BYTES( numberOfBitsToRead ) );
readOffsetMod8 = readOffset%; // do
// Faster to put the while at the top surprisingly enough
while (numberOfBitsToRead > )
{
//*( output + offset ) |= *( data + ( readOffset >> 3 ) ) << ( readOffsetMod8 ); // First half
output[offset] |= (Byte) (data[readOffset >> ] << (readOffsetMod8));
if (readOffsetMod8 > && numberOfBitsToRead > - (readOffsetMod8))
// If we have a second half, we didn't read enough bytes in the first half
//*(output + offset) |= *(data + (readOffset >> 3) + 1) >> (8 - (readOffsetMod8));
output[offset] |= (Byte) (data[(readOffset >> ) + ] >> ( - (readOffsetMod8)));
// Second half (overlaps byte boundary) numberOfBitsToRead -= ; if (numberOfBitsToRead < )
// Reading a partial byte for the last byte, shift right so the data is aligned on the right
{
if (alignBitsToRight)
output[offset] >>= -numberOfBitsToRead;
//*(output + offset) >>= -numberOfBitsToRead; readOffset += + numberOfBitsToRead;
}
else
readOffset += ; offset++;
}
return true;
} /**
* --- Low level functions ---
* These are for when you want to deal
* with bits and don't care about type checking
* Write a 0
*/ public void Write0()
{
AddBitsAndReallocate(); // New bytes need to be zeroed if ((numberOfBitsUsed%) == )
data[numberOfBitsUsed >> ] = ; numberOfBitsUsed++;
} /**
* --- Low level functions ---
* These are for when you want to deal
* with bits and don't care about type checking
* Write a 1
*/ public void Write1()
{
AddBitsAndReallocate(); int numberOfBitsMod8 = numberOfBitsUsed%; if (numberOfBitsMod8 == )
data[numberOfBitsUsed >> ] = 0x80;
else
data[numberOfBitsUsed >> ] |= (Byte) (0x80 >> (numberOfBitsMod8));
//data[ numberOfBitsUsed >> 3 ] |= 0x80 >> ( numberOfBitsMod8 ); // Set the bit to 1 numberOfBitsUsed++;
} /**
* --- Low level functions ---
* These are for when you want to deal
* with bits and don't care about type checking
* Reads 1 bit and returns true if that bit is 1 and false if it is 0
*/ public bool ReadBit()
{
return (data[readOffset >> ] & (0x80 >> (readOffset++%))) == ;
} /**
* If we used the constructor version with copy data off, this
* makes sure it is set to on and the data pointed to is copied.
*/ public void AssertCopyData()
{
if (copyData == false)
{
copyData = true; if (numberOfBitsAllocated > )
{
var newdata = new Byte[BITS_TO_BYTES(numberOfBitsAllocated)];
data.CopyTo(newdata, );
data = newdata;
}
else
data = null;
}
} /**
* Use this if you pass a pointer copy to the constructor
* (_copyData==false) and want to overallocate to prevent
* reallocation
*/ public void SetNumberOfBitsAllocated(int lengthInBits)
{
numberOfBitsAllocated = lengthInBits;
} /**
* Assume the input source points to a native type, compress and write it.
*/ public void WriteCompressed(Byte[] input, int size, bool unsignedData)
{
int currentByte = (size >> ) - ; // PCs Byte byteMatch; if (unsignedData)
{
byteMatch = ;
} else
{
byteMatch = 0xFF;
} // Write upper bytes with a single 1
// From high byte to low byte, if high byte is a byteMatch then write a 1 bit. Otherwise write a 0 bit and then write the remaining bytes
while (currentByte > )
{
if (input[currentByte] == byteMatch)
// If high byte is byteMatch (0 of 0xff) then it would have the same value shifted
{
bool b = true;
WriteBool(b);
}
else
{
// Write the remainder of the data after writing 0
bool b = false;
WriteBool(b); WriteBits(input, (currentByte + ) << , true);
// currentByte--; return;
} currentByte--;
} // If the upper half of the last byte is a 0 (positive) or 16 (negative) then write a 1 and the remaining 4 bits. Otherwise write a 0 and the 8 bites.
if ((unsignedData && (((input[currentByte])) & 0xF0) == 0x00) ||
(unsignedData == false && (((input[currentByte])) & 0xF0) == 0xF0))
{
bool b = true;
WriteBool(b);
var bs = new byte[];
Array.Copy(input, currentByte, bs, , );
WriteBits(bs, , true);
} else
{
bool b = false;
WriteBool(b);
var bs = new byte[];
Array.Copy(input, currentByte, bs, , );
WriteBits(bs, , true);
}
} /**
* Assume the input source points to a compressed native type.
* Decompress and read it.
*/ public bool ReadCompressed(ref Byte[] output, int size, bool unsignedData)
{
int currentByte = (size >> ) - ; Byte byteMatch, halfByteMatch; if (unsignedData)
{
byteMatch = ;
halfByteMatch = ;
} else
{
byteMatch = 0xFF;
halfByteMatch = 0xF0;
} // Upper bytes are specified with a single 1 if they match byteMatch
// From high byte to low byte, if high byte is a byteMatch then write a 1 bit. Otherwise write a 0 bit and then write the remaining bytes
while (currentByte > )
{
// If we read a 1 then the data is byteMatch. bool b = ReadBool(); if (b) // Check that bit
{
output[currentByte] = byteMatch;
currentByte--;
}
else
{
// Read the rest of the bytes if (ReadBits(ref output, (currentByte + ) << ) == false)
return false; return true;
}
}
return false;
} /**
* Reallocates (if necessary) in preparation of writing
* numberOfBitsToWrite
*/ public void AddBitsAndReallocate(int numberOfBitsToWrite)
{
if (numberOfBitsToWrite <= )
return; int newNumberOfBitsAllocated = numberOfBitsToWrite + numberOfBitsUsed; if (numberOfBitsToWrite + numberOfBitsUsed > &&
((numberOfBitsAllocated - ) >> ) < ((newNumberOfBitsAllocated - ) >> ))
// If we need to allocate 1 or more new bytes
{
// Less memory efficient but saves on news and deletes
newNumberOfBitsAllocated = (numberOfBitsToWrite + numberOfBitsUsed)*;
// int newByteOffset = BITS_TO_BYTES( numberOfBitsAllocated );
// Use realloc and free so we are more efficient than delete and new for resizing
int amountToAllocate = BITS_TO_BYTES(newNumberOfBitsAllocated);
if (data == stackData)
{
if (amountToAllocate > BITSTREAM_STACK_ALLOCATION_SIZE)
{
data = new byte[amountToAllocate]; // need to copy the stack data over to our new memory area too
stackData.CopyTo(data, );
}
}
else
{
data = data.Concat(new Byte[amountToAllocate - data.Length]).ToArray();
//data = ( unsigned char* ) realloc( data, amountToAllocate );
}
// memset(data+newByteOffset, 0, ((newNumberOfBitsAllocated-1)>>3) - ((numberOfBitsAllocated-1)>>3)); // Set the new data block to 0
} if (newNumberOfBitsAllocated > numberOfBitsAllocated)
numberOfBitsAllocated = newNumberOfBitsAllocated;
} /**
* Number of bits currently used
*/
private int numberOfBitsUsed;
/**
* Number of bits currently allocated
*/ private
int numberOfBitsAllocated; /**
* Current readOffset
*/ private
int readOffset; /**
* array of byte storing the data. Points to stackData or if is bigger than that then is allocated
*/ private
Byte[] data; /**
* true if the internal buffer is copy of the data passed to the
* constructor
*/ private
bool copyData; private Byte[] stackData = new Byte[BITSTREAM_STACK_ALLOCATION_SIZE];
}
const