public HuffmanWriter(byte[] indexMapper, uint[] reversedIndexMapper, byte defaultBitCount, short offset, StreamBitWriter writer)
{
_indexMapper = indexMapper;
_reversedIndexMapper = reversedIndexMapper;
_defaultBitCount = defaultBitCount;
_writer = writer;
}
public BlockyCompression(int capacity, Stream writer, IConfiguaration config)
{
Configuaration = config;
_writer = new StreamBitWriter(writer);
Values = capacity > 0 ? new List <OfcNumber>(capacity) : new List <OfcNumber>();
Blocks = new List <Block>();
}
public override void Write(StreamBitWriter writer, Block block, ref int valueIndex)
{
WriteDefaultBlockHeader(writer, block);
WriteSingleValueWithoutControlBit(writer, Values[block.Index]);
valueIndex += block.Length;
}
protected void WriteDefaultBlockHeader(StreamBitWriter writer, Block block)
{
writer.WriteByte(1, 1); // IsBlock
if (block.HasExponent)
{
writer.WriteByte(1, 1);
writer.WriteByte((byte)(block.Exponent < 0 ? 1 : 0), 1);
writer.Write((ushort)Math.Abs(block.Exponent), Context.Metadata.MaxNeededBitsExponent);
}
else
{
writer.WriteByte(0, 1);
}
if (block.HasPattern)
{
writer.WriteByte(1, 1);
writer.WriteByte((byte)block.Pattern, 2);
}
else
{
writer.WriteByte(0, 1);
}
writer.WriteByte(block.Length, 8);
}
public override void Write(StreamBitWriter writer, Block block, ref int valueIndex)
{
WriteDefaultBlockHeader(writer, block);
if (_probabilityMetadataIndex > PingPongPatternLengths.Count)
{
_probabilityMetadataIndex = 0;
}
var meta = PingPongPatternLengths[_probabilityMetadataIndex++];
if (meta.BlockIndex != block.Index)
{
for (var i = 0; i < PingPongPatternLengths.Count; i++)
{
if (PingPongPatternLengths[i].BlockIndex == block.Index)
{
meta = PingPongPatternLengths[i];
_probabilityMetadataIndex = i++;
break;
}
}
}
WriteSingleValueWithoutControlBit(writer, Values[block.Index]);
WriteSingleValueWithoutControlBit(writer, Values[block.Index + meta.Length]);
writer.WriteByte(meta.Length, 8);
valueIndex += meta.Length * block.Length;
}
/// <summary>
/// Writes Number + (Sign) + Exponent + Sign
/// </summary>
/// <param name="writer"></param>
/// <param name="value"></param>
protected void WriteSingleValueWithoutControlBit(StreamBitWriter writer, OfcNumber value)
{
if (!Context.Metadata.IsAbsolute)
{
writer.WriteByte(value.IsNegative ? (byte)1 : (byte)0, 1);
}
writer.Write((ulong)Math.Abs(value.Number), Context.Metadata.MaxNeededBitsNumber);
writer.WriteByte(value.Exponent < 0 ? (byte)1 : (byte)0, 1); // Bug: potentually writing exponent even though NoExp is set to true
writer.Write((ushort)Math.Abs(value.Exponent), Context.Metadata.MaxNeededBitsExponent);
}
public HuffmanWriter CreateWriter(byte defaultBitCount, StreamBitWriter writer)
{
var length = OccurenceCount.Length;
var indexMapper = new byte[length]; // number, place
var reversedIndexMapper = new uint[defaultBitCount]; // place, number
var buffer = new uint[length]; // buffer for all places woth the same occurenceCount, temporary stuff
var smallerThan = int.MaxValue;
byte mapperIndex = 0;
while (true)
{
var highest = 0;
byte bufferCount = 0;
for (uint i = 0; i < length; i++)
{
var val = OccurenceCount[i];
if (val >= smallerThan)
{
continue;
}
if (val > highest)
{
bufferCount = 1;
highest = val;
buffer[0] = i;
continue;
}
if (val == highest)
{
buffer[bufferCount++] = i;
}
}
if (bufferCount == 0 || highest == 0)
{
break;
}
smallerThan = highest;
for (var i = 0; i < bufferCount; i++)
{
reversedIndexMapper[mapperIndex] = buffer[i];
indexMapper[buffer[i]] = ++mapperIndex;
if (mapperIndex == defaultBitCount)
{
return(new HuffmanWriter(indexMapper, reversedIndexMapper, defaultBitCount, _offset, writer));
}
}
}
return(new HuffmanWriter(indexMapper, reversedIndexMapper, defaultBitCount, _offset, writer));
}
public ZettyCompression(Stream outStream, int maxBlockSize = 102400)
{
if (maxBlockSize <= 0)
{
throw new ArgumentException($"{nameof(maxBlockSize) + " must not be <= 0!"}");
}
_bitWriter = new StreamBitWriter(outStream);
_maxBlockSize = maxBlockSize;
_values = new string[maxBlockSize];
}
/// <summary>
/// Writes the metadata in binary form
/// </summary>
/// <param name="writer"></param>
public void Write(StreamBitWriter writer)
{
writer.Write((ulong)ValueCount, 31);
writer.WriteByte(IsAbsolute ? (byte)1 : (byte)0, 1);
if (IsAbsolute)
{
writer.WriteByte(IsNegative ? (byte)1 : (byte)0, 1);
}
writer.WriteByte(MaxNeededBitsExponent, 4);
writer.WriteByte(MaxNeededBitsNumber, 6); // The MaxNeededBitsNeededBitsNumber and LargestPossibleNumber can be calculated from that ...
}
public override void Write(StreamBitWriter writer, Block block, ref int valueIndex) //Todo: this method is redundant: same as NoExp. Need more common methods
{
WriteDefaultBlockHeader(writer, block);
if (block.OverrideGlobalNb)
{
writer.WriteByte(1, 1);
writer.Write(Context.Metadata.MaxNeededBitsNumber, Context.Metadata.MaxNeededBitsNeededBitsNumber);
}
else
{
writer.WriteByte(0, 1);
}
if (!Context.Metadata.IsAbsolute)
{
if (block.AbsoluteSign)
{
writer.WriteByte(1, 1);
writer.WriteByte(block.IsSignNegative ? (byte)1 : (byte)0, 1);
}
else
{
writer.WriteByte(0, 1);
}
}
var end = block.Index + block.Length;
for (var i = block.Index; i < end; i++)
{
var value = Values[i];
if (!block.AbsoluteSign)
{
writer.WriteByte(value.IsNegative ? (byte)1 : (byte)0, 1);
}
if (value.Exponent > block.Exponent)
{
writer.Write((ulong)(Math.Pow(10, value.Exponent - block.Exponent) * value.Number), Context.Metadata.MaxNeededBitsNumber);
}
else
{
writer.Write((ulong)value.Number, Context.Metadata.MaxNeededBitsNumber);
}
}
valueIndex += block.Length;
}
public abstract void Write(StreamBitWriter writer, Block block, ref int valueIndex);
