/// <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 void Finish() { if (_valueIndex != 0) { FinishBlock(); } _bitWriter.Write(0, 32); _bitWriter.Flush(); }
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; }
/// <summary> /// Writes a value to the stored bit-writer. Will write the value as huffman representation if possible. Otherwise, the value is written as normal value /// </summary> /// <param name="num"></param> public void Write(ushort num) { var occurencePlace = _indexMapper[num]; if (occurencePlace == 0) { _writer.WriteByte(0, 1); // isHuffman flag _writer.Write(num, _defaultBitCount); // Writing the normal value, NO huffman representation } else { _writer.WriteByte(1, 1); // isHuffman flag _writer.Write(OccurenceNum[occurencePlace], occurencePlace); // Writing huffman representation } }
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); }
/// <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 ... }
/// <summary> /// Will write everything to the given Stream/Writer. Call "Compress" first! /// </summary> public void Write() //Bug: Actually, finding all blocks and then writing all blocks is pretty stupid. By doing this we first have a CPU / RAM bottleneck, and here we get a Harddrive bottleneck. Doesn't matter if master weed does good parallel stuff though { var currentBlockIndex = 0; var valueCount = Values.Count; var blockCount = Blocks.Count; var nextStop = blockCount == 0 ? valueCount : Blocks[currentBlockIndex].Index; var hasExponent = !Metadata.NoExponent; var huffmanWriter = _huffman?.CreateWriter(Metadata.MaxNeededBitsExponent, _writer); var shouldUseHuffman = hasExponent && huffmanWriter != null && huffmanWriter.IsBetterThanDefault(valueCount - _totalPostCompressionOptimisationBlockValues, _huffman); // Writing global header Metadata.Write(_writer); shouldUseHuffman = false; //debug _writer.WriteByte(shouldUseHuffman ? (byte)1 : (byte)0, 1); if (shouldUseHuffman) { huffmanWriter.WriteDictionary(); } for (var i = 0; i < valueCount;) { for (; nextStop > i; i++) // writing values until the next block is here { var value = Values[i]; //Todo: is the loop below really nessecary with the new changes? while (value.NeededBitsNumber > Metadata.MaxNeededBitsNumber) //Todo: check how often this case appears. (This is a "bug" created by the blockfinding, which "corrects" the value to fit with the exp of a block that might get created ... { value.Number /= 10; value.Exponent++; value.NeededBitsNumber = value.Number.GetNeededBits(); } _writer.WriteByte(0, 1); if (!Metadata.IsAbsolute) { _writer.WriteByte((byte)(value.IsNegative ? 1 : 0), 1); } _writer.Write((ulong)value.Number, Metadata.MaxNeededBitsNumber); if (hasExponent) { _writer.WriteByte((byte)(value.Exponent < 0 ? 1 : 0), 1); if (shouldUseHuffman) { huffmanWriter.Write((ushort)Math.Abs(value.Exponent)); } else { _writer.Write((ulong)Math.Abs(value.Exponent), Metadata.MaxNeededBitsExponent); } } } if (++currentBlockIndex < blockCount) { // Console.WriteLine(Blocks[currentBlockIndex - 1]); Blocks[currentBlockIndex - 1].Method.Write(_writer, Blocks[currentBlockIndex - 1], ref i); nextStop = Blocks[currentBlockIndex].Index; } else { nextStop = valueCount; } } _writer.Flush(); // This is nessecary. Will write the last buffered byte may only be partially complete! }