public override int Read(IOfcNumberWriter writer, Block block, StreamBitReader reader)
{
// ReSharper disable once AssignmentInConditionalExpression
if (block.OverrideGlobalNb = reader.ReadByte(1) > 0)
{
block.NeededBits = reader.ReadByte(Metadata.MaxNeededBitsNeededBitsNumber);
}
// ReSharper disable once AssignmentInConditionalExpression
if (!Metadata.IsAbsolute)
{
if (block.AbsoluteSign = reader.ReadByte(1) > 0)
{
block.IsSignNegative = reader.ReadByte(1) > 0;
}
}
var hasAbsoluteSign = block.AbsoluteSign || Metadata.IsAbsolute;
var isNegative = block.AbsoluteSign && block.IsSignNegative || Metadata.IsAbsolute && Metadata.IsNegative;
for (var i = 0; i < block.Length; i++)
{
var num = new OfcNumber();
if (!hasAbsoluteSign)
{
isNegative = reader.ReadByte(1) > 0;
}
num.Number = ((long)reader.Read(Metadata.MaxNeededBitsNumber)) * (isNegative ? -1 : 1);
writer.Write(num);
}
return(block.Length);
}
public void ReadBitsTest()
{
var Stream = new MemoryStream(new byte[] { 0x00, 0x00, 0x01, 0xBA, 0x44, 0x00, 0x05, 0x3D, 0x1D, 0x11, 0x01, 0x86, 0xA3, 0xF8, 0x00, 0x00 });
var StreamBitReader = new StreamBitReader(Stream);
//Assert.AreEqual((uint)0, (uint)StreamBitReader.ReadBits(8));
Assert.AreEqual((uint)0x000001BA, (uint)StreamBitReader.ReadBits(32));
Assert.AreEqual((uint)0, (uint)StreamBitReader.ReadBits(2));
}
public override int Read(IOfcNumberWriter writer, Block block, StreamBitReader reader)
{
var value = ReadSingleValueWithoutControlBit(reader, Metadata);
for (var i = 0; i < block.Length; i++)
{
writer.Write(value);
}
return(block.Length);
}
public override int Read(IOfcNumberWriter writer, Block block, StreamBitReader reader)
{
var val1 = ReadSingleValueWithoutControlBit(reader, Metadata);
var val2 = ReadSingleValueWithoutControlBit(reader, Metadata);
var ppLength = reader.ReadByte(8);
var total = ppLength * block.Length;
for (var i = 0; i < total; i++)
{
writer.Write(i % (ppLength * 2) >= ppLength ? val2 : val1);
}
return(total);
}
protected BlockyDecompression([NotNull] Stream reader)
{
_bitReader = new StreamBitReader(reader);
Metadata = BlockyMetadata.FromBitStream(_bitReader);
_decompressionMethods[(int)Blockfinding.Blockfinding.Methods.PatternSame] = new PatternSameDecompression(Metadata);
_decompressionMethods[(int)Blockfinding.Blockfinding.Methods.PatternPingPong] = new PatternPingPongDecompression(Metadata);
_decompressionMethods[(int)Blockfinding.Blockfinding.Methods.FloatSimmilar] = new FloatSimmilarDecompression(Metadata);
_decompressionMethods[(int)Blockfinding.Blockfinding.Methods.NumbersNoExp] = new NumbersNoExpDecompression(Metadata);
_decompressionMethods[(int)Blockfinding.Blockfinding.Methods.PatternOffset] = new PatternOffsetDecompression(Metadata);
if (_bitReader.ReadByte(1) > 0) // use huffman
{
throw new NotImplementedException();
}
}
public override int Read(IOfcNumberWriter writer, Block block, StreamBitReader reader)
{
var val1 = ReadSingleValueWithoutControlBit(reader, Metadata);
var val2 = ReadSingleValueWithoutControlBit(reader, Metadata);
writer.Write(val1);
writer.Write(val2);
var difference = val2.SubtractEach(val1);
for (var i = 1; i < block.Length - 1; i++)
{
writer.Write(difference.LinearMultiplyEach(i).AddEach(val2));
}
return(block.Length);
}
/// <summary>
/// Reads the metadata in its binary form
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
public static BlockyMetadata FromBitStream(StreamBitReader reader)
{
var metadata = new BlockyMetadata {
ValueCount = (int)reader.Read(31)
};
// ReSharper disable once AssignmentInConditionalExpression
if (metadata.IsAbsolute = reader.ReadByte(1) > 0)
{
metadata.IsNegative = reader.ReadByte(1) > 0;
}
metadata.MaxNeededBitsExponent = reader.ReadByte(4);
metadata.MaxNeededBitsNumber = reader.ReadByte(6);
metadata.MaxNeededBitsNeededBitsNumber = Utility.GetNeededBits(metadata.MaxNeededBitsNumber);
metadata.LargestPossibleValue = Utility.GetMaxValue(metadata.MaxNeededBitsNumber);
return(metadata);
}
/// <summary>
/// Reads a Single Value from its binary representation without the control bit (isBlock)
/// </summary>
/// <param name="reader"></param>
/// <param name="metadata"></param>
/// <returns></returns>
public static OfcNumber ReadSingleValueWithoutControlBit(StreamBitReader reader, BlockyMetadata metadata)
{
var value = new OfcNumber();
if (!metadata.IsAbsolute)
{
value.IsNegative = reader.ReadByte(1) > 0;
}
else
{
value.IsNegative = metadata.IsNegative;
}
value.Number = (long)reader.Read(metadata.MaxNeededBitsNumber);
var isExpNegative = reader.ReadByte(1) > 0;
value.Exponent = (short)reader.Read(metadata.MaxNeededBitsExponent); // Bug: Potentually reading exp even though NoExp is set. Same in writing method! (Ineffizient)
if (isExpNegative)
{
value.Exponent *= -1;
}
return(value);
}
/// <summary>
/// Exclusive IsBlock
/// </summary>
/// <param name="reader"></param>
/// <param name="metadata"></param>
/// <returns></returns>
public static Block ReadDefaultBlockHeader(StreamBitReader reader, BlockyMetadata metadata)
{
var block = new Block();
// ReSharper disable once AssignmentInConditionalExpression
if (block.HasExponent = reader.ReadByte(1) > 0)
{
var negative = reader.ReadByte(1) > 0;
block.Exponent = (short)reader.Read(metadata.MaxNeededBitsExponent);
if (negative)
{
block.Exponent *= -1;
}
}
// ReSharper disable once AssignmentInConditionalExpression
if (block.HasPattern = reader.ReadByte(1) > 0)
{
block.Pattern = (Block.PatternType)reader.ReadByte(2);
}
block.Length = reader.ReadByte(8);
return(block);
}
public ZettyDecompression(Stream input, IReporter <string> output)
{
_output = output;
_stream = input;
_streamBitReader = new StreamBitReader(input);
}
public abstract int Read(IOfcNumberWriter writer, Block block, StreamBitReader reader);
