static private byte[] HuffmanDecode(byte[] packed, int unpacked_size)
{
var dst = new byte[unpacked_size];
var decoder = new HuffmanDecoder(packed, dst);
return(decoder.Unpack());
}
public DefaultFileDecoder(WeightsTable weightsTable, IDecodingInputStream inputStream, long length, HuffmanDecoder decoder)
{
this.weightsTable = weightsTable;
this.inputStream = inputStream;
this.length = length;
this.decoder = decoder;
}
private void button2_Click(object sender, EventArgs e)
{
if (openFileDialog2.ShowDialog() == DialogResult.OK)
{
var decoder = new HuffmanDecoder(openFileDialog2.FileName);
decoder.Decode();
}
}
private static void roundTrip(HuffmanEncoder encoder, HuffmanDecoder decoder, byte[] buf)
{
using(var baos = new MemoryStream()) {
using(var dos = new BinaryWriter(baos)) {
encoder.Encode(dos, buf);
var actualBytes = decoder.Decode(baos.ToArray());
Assert.IsTrue(buf.SequenceEqual(actualBytes));
}
}
}
public SourceFile Run(EncodedFile encoded, string outputPath)
{
var rleDecoder = new RleDecoder();
var huffmanDecoder = new HuffmanDecoder(encoded.Header.HuffmanMetadata);
var bytes = encoded.Content.ToArray();
var decoded = huffmanDecoder.Decode(bytes);
var outRle = rleDecoder.Decode(decoded);
return(new SourceFile(outputPath, outRle, encoded.Header.SourceExtension));
}
public SourceFile Run(EncodedFile encoded, string outputPath)
{
var lzwDecoder = new LZWDecompress();
var huffmanDecoder = new HuffmanDecoder(encoded.Header.HuffmanMetadata);
var bytes = encoded.Content.ToArray();
var decoded = huffmanDecoder.Decode(bytes);
var input = Encoding.ASCII.GetString(decoded);
var outLzw = lzwDecoder.Decompress(input);
return(new SourceFile(outputPath, outLzw, encoded.Header.SourceExtension));
}
public UserControlHuffman()
{
InitializeComponent();
var dependencyResolver = new DependencyResolver();
huffmanEncoder = (HuffmanEncoder)dependencyResolver.GetObject <IHuffmanEncoder>();
huffmanDecoder = (HuffmanDecoder)dependencyResolver.GetObject <IHuffmanDecoder>();
textBoxCodes.Font = new Font(FontFamily.GenericMonospace, textBoxCodes.Font.Size);
UpdateButtonsEnabledProperty();
}
public void Setup()
{
var dependencyResolver = new DependencyResolver();
huffmanEncoder = (HuffmanEncoder)dependencyResolver.GetObject <IHuffmanEncoder>();
huffmanDecoder = (HuffmanDecoder)dependencyResolver.GetObject <IHuffmanDecoder>();
filePathSource = $"{Environment.CurrentDirectory}\\temp.png";
filePathEncodedFile = $"{Environment.CurrentDirectory}\\temp.png.hs";
filePathDecodedFile = $"{Environment.CurrentDirectory}\\temp.png.hs.png";
TestMethods.CreateBmpFileFromImage(filePathSource, Resources.Capture);
}
private static string DecodeWithHuffman(string dictFilename, byte[] bytes)
{
var serializedDict = File.ReadAllText(dictFilename);
var rates = serializedDict.Split('操').Select(x =>
{
var chr = x[0];
var rate = int.Parse(x.Substring(1, x.Length - 1));
return(new { chr, rate });
}).ToDictionary(x => x.chr, x => x.rate);
var huffmanTree = new HuffmanDecoder();
huffmanTree.BuildWithRates(rates);
return(huffmanTree.Decode(new BitArray(bytes)));
}
public void Setup()
{
characterStatisticsFromMock = ConstantsEncodingSystems.TextCharacterStatistics1;
encodedBytesFromMock = ConstantsEncodingSystems.EncodedBytes1();
huffmanReaderMock = new Mock <IHuffmanHeaderReader>();
huffmanEncodedBytesManagerMock = new Mock <IHuffmanEncodedBytesManager>();
fileReaderMock = new Mock <IFileReader>();
fileWriterMock = new Mock <IFileWriter>();
huffmanDecoder = new HuffmanDecoder(huffmanReaderMock.Object, huffmanEncodedBytesManagerMock.Object);
SetupHuffmanReaderMock();
SetupHuffmanEncodedBytesManagerMock();
SetupFileReaderMock();
}
public void Decode_FourSymbols_DeepTree()
{
//given
var tree = MockHuffmanTreeBuilder.Build('a', '#', 'b', '#', 'c', 'd');
var decoder = new HuffmanDecoder <char>(tree);
var input = new MockDecoderInput(new List <int> {
0, 1, 0, 1, 1, 0, 1, 1, 1
});
var output = new MockDecoderOutput(new List <char> {
'a', 'b', 'c', 'd'
});
//when
decoder.Decode(input, output);
//then
output.AssertCorrectOutput();
}
public void Decode_ThreeSymbols_TwoAreRight()
{
//given
var tree = MockHuffmanTreeBuilder.Build('c', '#', 'x', 'a');
var decoder = new HuffmanDecoder <char>(tree);
var input = new MockDecoderInput(new List <int> {
0, 1, 1, 1, 0
});
var output = new MockDecoderOutput(new List <char> {
'c', 'a', 'x'
});
//when
decoder.Decode(input, output);
//then
output.AssertCorrectOutput();
}
public override Stream OpenEntry(ArcFile arc, Entry entry)
{
var aent = entry as PackedEntry;
if (null == aent || !aent.IsPacked)
{
return(base.OpenEntry(arc, entry));
}
aent.UnpackedSize = arc.File.View.ReadUInt32(entry.Offset);
var packed = arc.File.View.ReadBytes(entry.Offset + 4, entry.Size - 4);
var unpacked = new byte[aent.UnpackedSize];
var decoder = new HuffmanDecoder(packed, unpacked);
decoder.Unpack();
return(new BinMemoryStream(unpacked, entry.Name));
}
public override object Decode(Stream stream)
{
byte num = stream.CreateSuitableBinaryReader().ReadByte();
byte[] numArray;
try
{
numArray = HuffmanDecoder.Decode(stream);
}
catch (Exception ex)
{
throw new CodecException("Unable to decode", ex);
}
byte[] buffer = numArray != null ? new byte[numArray.Length + 1] : throw new CodecException("Unable to decode");
buffer[0] = num;
Buffer.BlockCopy(numArray, 0, buffer, 1, numArray.Length);
using (MemoryStream memoryStream = new MemoryStream(buffer))
return(base.Decode(memoryStream));
}
public override Stream OpenEntry(ArcFile arc, Entry entry)
{
var aent = entry as AosEntry;
if (null == aent || !aent.IsCompressed)
{
return(base.OpenEntry(arc, entry));
}
uint unpacked_size = arc.File.View.ReadUInt32(entry.Offset);
var packed = new byte[entry.Size - 4];
arc.File.View.Read(entry.Offset + 4, packed, 0, (uint)packed.Length);
var unpacked = new byte[unpacked_size];
var decoder = new HuffmanDecoder(packed, unpacked);
decoder.Unpack();
return(new BinMemoryStream(unpacked, entry.Name));
}
public DefaultStreamParser()
{
this.decoder = new HuffmanDecoder();
}
private static void roundTrip(HuffmanEncoder encoder, HuffmanDecoder decoder, string s)
{
roundTrip(encoder, decoder, Encoding.UTF8.GetBytes(s));
}
internal static void DecompressHuffman(IBinaryStream input, byte[] output)
{
var decomp = new HuffmanDecoder(input);
decomp.Unpack(output);
}
