Initial checkin

BeefySysLib/DataStream.cpp

@@ -0,0 +1,281 @@
+#include "DataStream.h"
+
+USING_NS_BF;
+
+DataStream::DataStream()
+{
+	mBigEndian = false;
+	mBitPos = 0;
+	mReadBitIntPos = -1000;
+}
+
+int8 DataStream::ReadInt8()
+{
+	int8 anInt8;
+	Read(&anInt8, sizeof(int8));
+	return anInt8;
+}
+
+uint8 DataStream::ReadUInt8()
+{
+	return (uint8) ReadInt8();
+}
+
+int16 DataStream::ReadInt16()
+{
+	int16 anInt16;
+	Read(&anInt16, sizeof(int16));
+	if (mBigEndian)
+		return FromBigEndian(anInt16);
+	return anInt16;
+}
+
+uint16 DataStream::ReadUInt16()
+{
+	return (uint16) ReadInt16();
+}
+
+int32 DataStream::ReadInt32()
+{
+	int32 anInt32;
+	Read(&anInt32, sizeof(int32));
+	if (mBigEndian)
+		return FromBigEndian(anInt32);
+	return anInt32;
+}
+
+int64 Beefy::DataStream::ReadInt64()
+{
+	int64 anInt64;
+	Read(&anInt64, sizeof(int64));
+	//if (mBigEndian)
+		//return FromBigEndian(anInt32);
+	return anInt64;
+}
+
+
+float DataStream::ReadFloat()
+{
+	if (mBigEndian)
+	{
+		int32 anInt32;
+		Read(&anInt32, sizeof(int32));
+		anInt32 = FromBigEndian(anInt32);
+		return *((float*) &anInt32);
+	}
+	else
+	{
+		float aFloat;
+		Read(&aFloat, sizeof(float));
+		return aFloat;
+	}
+}
+
+double DataStream::ReadDouble()
+{
+	if (mBigEndian)
+	{
+		int64 anInt64;
+		Read(&anInt64, sizeof(int64));
+		anInt64 = FromBigEndian(anInt64);
+		return *((double*) &anInt64);
+	}
+	else
+	{
+		double aDouble;
+		Read(&aDouble, sizeof(double));
+		return aDouble;
+	}
+}
+
+String DataStream::ReadAscii8SizedString()
+{
+	int size = (int) (uint8) ReadInt8();
+
+	String aString;
+	aString.Append(' ', size);
+	Read((void*) aString.c_str(), size);
+
+	return aString;
+}
+
+String DataStream::ReadAscii32SizedString()
+{
+	int size = (int) ReadInt32();
+	if (size == 0)
+		return String();
+
+	String aString;
+	aString.Append(' ', size);
+	Read((void*) aString.c_str(), size);
+
+	return aString;
+}
+
+String DataStream::ReadUnicode32SizedString()
+{
+	int size = ReadInt32();
+
+	UTF16String aString;	
+	aString.ResizeRaw(size + 1);
+	aString[size] = 0;
+	Read((void*)aString.c_str(), size * 2);
+
+	if (mBigEndian)
+		for (int i = 0; i < (int) aString.length(); i++)
+			aString[i] = FromBigEndian((int16) aString[i]);
+
+	return UTF8Encode(aString);
+}
+
+String DataStream::ReadSZ()
+{
+	String str;
+	while (true)
+	{
+		char c = (char)ReadUInt8();
+		if (c == 0)
+			break;
+		str += c;
+	}
+	return str;
+}
+
+void DataStream::SyncBitPos()
+{
+	mBitPos = GetPos() * 8;
+}
+
+void DataStream::SyncBytePos()
+{
+	SetPos((mBitPos+7) / 8);
+}
+
+
+//int bitMaskR[32] = {
+static int LowerBitMask[33] = {0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 
+	0xFFFF, 0x1FFFF, 0x3FFFF, 0x7FFFF, 0xFFFFF, 0x1FFFFF, 0x3FFFFF, 0x7FFFFF, 0xFFFFFF, 0x1FFFFFF, 0x3FFFFFF, 0x7FFFFFF, 0xFFFFFFF, 0x1FFFFFFF, 0x3FFFFFFF, 
+	0x7FFFFFFF, (int)0xFFFFFFFF};
+
+int DataStream::ReadUBits(int bits)
+{
+	int val = 0;
+	int valBitPos = 0;
+
+	while (true)
+	{
+		int bitsAvail = (mReadBitIntPos + 32) - mBitPos;
+		if ((bitsAvail > 0) && (bitsAvail <= 32))
+		{
+			int copyBits = std::min(bits - valBitPos, bitsAvail);
+			val |= ((mCurBitInt >> (32 - bitsAvail)) & LowerBitMask[copyBits]) << valBitPos;
+			valBitPos += copyBits;
+			mBitPos += copyBits;
+		}
+
+		if (valBitPos == bits)
+			break;
+		
+		mReadBitIntPos = mBitPos & ~7;
+		SetPos(mReadBitIntPos / 8);
+		Read(&mCurBitInt, 4);		
+	}
+
+	return val;
+}
+
+void DataStream::SeekBits(int bits)
+{
+	mBitPos += bits;
+}
+
+void Beefy::DataStream::Write(int32 val)
+{
+	Write(&val, sizeof(int32));
+}
+
+void Beefy::DataStream::Write(int64 val)
+{
+	Write(&val, sizeof(int64));
+}
+
+void Beefy::DataStream::Write(const StringImpl& val)
+{
+	Write((int)val.length());
+	Write((void*)val.c_str(), (int)val.length());
+}
+
+void DataStream::Write(DataStream& refStream)
+{
+	int size = refStream.GetSize();
+	uint8* data = new uint8[size];
+	refStream.SetPos(0);
+	refStream.Read(data, size);
+	Write(data, size);
+	delete data;
+}
+
+void DataStream::WriteSNZ(const StringImpl& val)
+{
+	Write((void*)val.c_str(), (int)val.length());
+}
+
+void DataStream::WriteSZ(const StringImpl& val)
+{
+	Write((void*)val.c_str(), (int)val.length() + 1);
+}
+
+void Beefy::DataStream::Write(float val)
+{
+	Write(&val, sizeof(float));
+}
+
+void DataStream::Write(uint8 val)
+{
+	Write(&val, 1);
+}
+
+void DataStream::Write(int8 val)
+{
+	Write((uint8)val);
+}
+
+void DataStream::Write(int16 val)
+{
+	Write(&val, 2);
+}
+
+void DataStream::WriteZeros(int size)
+{
+	int sizeLeft = size;
+	while (sizeLeft > 0)
+	{
+		if (sizeLeft >= 8)
+		{
+			Write((int64)0);
+			sizeLeft -= 8;
+		}
+		else if (sizeLeft >= 4)
+		{
+			Write((int32)0);
+			sizeLeft -= 4;
+		}
+		else if (sizeLeft >= 2)
+		{
+			Write((int16)0);
+			sizeLeft -= 2;
+		}
+		else
+		{
+			Write((int8)0);
+			sizeLeft -= 1;
+		}
+	}
+}
+
+void DataStream::Align(int alignSize)
+{
+	int curPos = GetPos();
+	int alignBytesLeft = (alignSize - (curPos % alignSize)) % alignSize;
+	WriteZeros(alignBytesLeft);	
+}