void Read(IO.BitStream bs)
{
int uncompressed_size;
bool is_compressed;
bs.Read(out uncompressed_size, mOwner.kInfo.BufferSizeBitLength); int size = uncompressed_size;
if (uncompressed_size > mOwner.kInfo.BufferMaxSize)
{
throw new System.IO.InvalidDataException("Input string table buffer size too large by (bytes): " +
(uncompressed_size - mOwner.kInfo.BufferMaxSize).ToString());
}
bs.Read(out is_compressed);
if (is_compressed)
{
bs.Read(out size, mOwner.kInfo.BufferSizeBitLength);
}
Buffer = new byte[size];
bs.Read(Buffer);
if (is_compressed)
{
Buffer = IO.Compression.ZLib.LowLevelDecompress(Buffer, uncompressed_size);
}
}
/// <remarks>Used for indexes which *are not* typically NONE (-1)</remarks>
public static void StreamIndexPos(this IO.BitStream s, ref int value, int bitCount = Bits.kInt32BitCount)
{
Contract.Requires(bitCount <= Bits.kInt32BitCount);
if (s.IsReading)
{
bool not_none = s.ReadBoolean();
if (not_none)
{
s.Read(out value, bitCount);
}
else
{
value = TypeExtensions.kNone;
}
}
else if (s.IsWriting)
{
bool not_none = value.IsNotNone();
s.Write(not_none);
if (not_none)
{
s.Write(value, bitCount);
}
}
}
static uint Read(IO.BitStream s, out float real, float min, float max, int bitCount, bool isSigned, bool unknown)
{
uint raw_bits;
s.Read(out raw_bits, bitCount);
real = DecodeSingle(raw_bits, min, max, bitCount, isSigned, unknown);
return(raw_bits);
}
void Read(IO.BitStream s)
{
int count; s.Read(out count, kInfo.CountBitLength);
ReferencesRead(s, count);
if (HasStrings)
{
var string_data = new LocaleStringTableBuffer(this);
s.StreamObject(string_data);
ReadStringsFromBuffer(string_data);
}
}
void Read(IO.BitStream bs)
{
for (int x = 0, mask = 1; x < kInfo.kLength; x++, mask <<= 1)
{
bool has_value;
bs.Read(out has_value);
if (has_value)
{
mValidFlags |= (uint)mask;
bs.Stream(ref mArray[x],
kInfo.kRangeMin, kInfo.kRangeMax, kInfo.kBitCount, kInfo.kSigned, kInfo.kUnknown);
}
}
}
/// <summary>Read a multi-byte CString from an endian stream</summary>
/// <param name="s">Bitstream to read from</param>
/// <param name="ms">Stream to write the character's bytes to</param>
/// <param name="maxLength">Optional maximum length of this specific string</param>
void ReadCStringMultiByte(IO.BitStream s, System.IO.MemoryStream ms, int maxLength)
{
byte[] characters;
if (maxLength > 0)
{
int x = 0;
characters = new byte[mNullCharacterSize];
while (!ReadStringMultiByteIsNull(mStorage.ByteOrder, s.Read(characters), 0) && ++x <= maxLength)
{
ms.Write(characters, 0, characters.Length);
}
}
else if (!mStorage.IsFixedLength)
{
characters = new byte[mNullCharacterSize];
while (!ReadStringMultiByteIsNull(mStorage.ByteOrder, s.Read(characters), 0))
{
ms.Write(characters, 0, characters.Length);
}
}
else
{
characters = s.ReadBytes(mFixedLengthByteLength);
int x;
for (x = 0; x < characters.Length - mNullCharacterSize; x += mNullCharacterSize)
{
if (ReadStringMultiByteIsNull(mStorage.ByteOrder, characters, x))
{
break;
}
}
ms.Write(characters, 0, x);
}
}
/// <summary>Streams an integer which is >= -1, but when streamed out the value is added by 1 (so it will be >= 0)</summary>
/// <param name="s"></param>
/// <param name="value"></param>
/// <param name="bitCount"></param>
public static void StreamNoneable(this IO.BitStream s, ref int value, int bitCount = Bits.kInt32BitCount)
{
Contract.Requires(bitCount <= Bits.kInt32BitCount);
if (s.IsReading)
{
s.Read(out value, bitCount);
value--;
}
else if (s.IsWriting)
{
Contract.Assert(value.IsNoneOrPositive());
s.Write(value + 1, bitCount);
}
}
/// <summary>Streams an integer which is >= -1, but when streamed out the value is added by 1 (so it will be >= 0)</summary>
/// <param name="s"></param>
/// <param name="value"></param>
/// <param name="bitCount"></param>
public static void StreamNoneable(this IO.BitStream s, ref short value, int bitCount = Bits.kInt16BitCount)
{
Contract.Requires(bitCount <= Bits.kInt16BitCount);
if (s.IsReading)
{
s.Read(out value, bitCount);
value--;
}
else if (s.IsWriting)
{
Contract.Assert(value >= TypeExtensions.kNone);
s.Write(value + 1, bitCount);
}
}
public void IO_BitStreamLogicTest()
{
var values = new KeyValuePair <uint, int>[] {
new KeyValuePair <uint, int>(10, 7),
new KeyValuePair <uint, int>(0xBEEFBEEF, 32),
new KeyValuePair <uint, int>(12, 7),
new KeyValuePair <uint, int>(0x13371337, 32),
new KeyValuePair <uint, int>(123, 7),
new KeyValuePair <uint, int>(0xDEADC0DE, 32),
new KeyValuePair <uint, int>(0, 7),
new KeyValuePair <uint, int>(111, 7),
new KeyValuePair <uint, int>(1, 1),
new KeyValuePair <uint, int>(2, 2),
new KeyValuePair <uint, int>(7, 3),
new KeyValuePair <uint, int>(14, 4),
new KeyValuePair <uint, int>(21, 5),
new KeyValuePair <uint, int>(42, 6),
new KeyValuePair <uint, int>(14406, 15),
};
using (var ms = new MemoryStream())
{
using (var bs = new IO.BitStream(ms, FileAccess.Write))
{
int expected_bit_position = 0;
bs.StreamMode = FileAccess.Write;
foreach (var kv in values)
{
bs.WriteWord(kv.Key, kv.Value);
expected_bit_position += kv.Value;
Assert.AreEqual(expected_bit_position, bs.BitPosition, "Value=" + kv.Key);
}
}
Text.Util.ByteArrayToStream(ms.ToArray(), System.Console.Out);
System.Console.WriteLine();
ms.Position = 0;
using (var bs_old = new BKSystem.IO.BitStream(ms))
{
foreach (var kv in values)
{
bs_old.Read(out uint word, 0, kv.Value);
Assert.AreEqual(kv.Key, word);
}
}
}
using (var ms = new MemoryStream())
{
using (var bs_old = new BKSystem.IO.BitStream())
{
foreach (var kv in values)
{
bs_old.Write(kv.Key, 0, kv.Value);
}
bs_old.WriteTo(ms);
}
Text.Util.ByteArrayToStream(ms.ToArray(), System.Console.Out);
System.Console.WriteLine();
ms.Position = 0;
using (var bs = new IO.BitStream(ms, FileAccess.Read))
{
bs.StreamMode = FileAccess.Read;
foreach (var kv in values)
{
bs.ReadWord(out uint word, kv.Value);
Assert.AreEqual(kv.Key, word);
}
}
}
using (var ms = new MemoryStream())
{
using (var bs = new IO.BitStream(ms, FileAccess.Write))
{
bs.StreamMode = FileAccess.Write;
bs.Write((int)1337, 15);
bs.Write(-21474836480L, 60);
bs.Write(-1, 30);
bs.Write(false);
bs.Write((int)0xDEDEAD, 27);
}
Text.Util.ByteArrayToStream(ms.ToArray(), System.Console.Out);
System.Console.WriteLine();
ms.Position = 0;
// using (var bs_old = new BKSystem.IO.BitStream(ms))
using (var bs_old = new IO.BitStream(ms, FileAccess.Read))
{
bs_old.StreamMode = FileAccess.Read;
//bs_old.Read(out _int, 0, 15);
bs_old.Read(out int _int, 15);
Assert.AreEqual(1337, _int);
bs_old.Read(out long _long, 60, signExtend: true);
Assert.AreEqual(-21474836480L, _long);
//bs_old.Read(out _int, 0, 30);
bs_old.Read(out _int, 30, signExtend: true);
Assert.AreEqual(-1, _int);
bs_old.Read(out bool _bool);
Assert.AreEqual(false, _bool);
//bs_old.Read(out _int, 0, 27);
bs_old.Read(out _int, 27);
Assert.AreEqual((int)0xDEDEAD, _int);
}
}
}