private void Insert(HuffmanCode <T> code)
{
Node currentNode = root;
for (int bitIndex = code.Length - 1; bitIndex >= 0; bitIndex--)
{
int bit = BitHelpers.ExtractBits(code.Code, 1, bitIndex);
if (bit == 1)
{
if (currentNode.Node1 == null)
{
currentNode.Node1 = new Node();
}
currentNode = currentNode.Node1;
}
else
{
if (currentNode.Node0 == null)
{
currentNode.Node0 = new Node();
}
currentNode = currentNode.Node0;
}
}
currentNode.Value = code.Value;
}
public void Unpack()
{
Input.Position = 0x20;
HuffmanCode[] hcodes = new HuffmanCode[512];
HuffmanNode[] hnodes = new HuffmanNode[1023];
int leaf_node_count = 0;
for (ushort i = 0; i < 512; i++)
{
int src = Input.ReadByte();
if (-1 == src)
{
throw new EndOfStreamException("Incomplete compressed stream");
}
byte depth = (byte)(src - UpdateKey());
if (0 != depth)
{
hcodes[leaf_node_count].Depth = depth;
hcodes[leaf_node_count].Code = i;
leaf_node_count++;
}
}
Array.Sort(hcodes, 0, leaf_node_count);
CreateHuffmanTree(hnodes, hcodes, leaf_node_count);
HuffmanDecompress(hnodes, m_dec_count);
}
static void ReplicateValue(HuffmanCode[] table, int offset, int step, int end, HuffmanCode code)
{
do
{
end -= step;
table[offset + end] = code;
}while (end > 0);
}
/* Stores code in table[0], table[step], table[2*step], ..., table[end] */
/* Assumes that end is an integer multiple of step */
private static unsafe void ReplicateValue(HuffmanCode *table,
int step, int end,
HuffmanCode code)
{
do
{
end -= step;
table[end] = code;
} while (end > 0);
}
static void Main()
{
byte[] bytes = new byte[]
{
255, 0, 20, 20, 13, 14, 18, 255, 0, 0, 0, 0, 1, 2, 1, 255, 255, 255, 255, 255, 255
};
HuffmanCode <byte> hCode = new HuffmanCode <byte>(bytes);
Application.Run(new Form1());
}
public void EncondeAndDecode_WithTextTest()
{
string text = "aabbbc";
var huffmanTree = new HuffmanCode(text);
string encode = huffmanTree.Encode(text);
string decode = huffmanTree.Decode(encode);
Assert.AreEqual("111100010", encode);
Assert.AreEqual(text, decode);
}
public void Write(byte[] cBytes, byte[] mBytes, byte[] yBytes, FileStream fStream)
{
byte[] fullBytes = new byte[cBytes.Length + mBytes.Length + yBytes.Length];
System.Buffer.BlockCopy(cBytes, 0, fullBytes, 0, cBytes.Length);
System.Buffer.BlockCopy(mBytes, 0, fullBytes, cBytes.Length, mBytes.Length);
System.Buffer.BlockCopy(yBytes, 0, fullBytes, cBytes.Length + mBytes.Length, yBytes.Length);
HuffmanCode <byte> fHComp = new HuffmanCode <byte>(fullBytes);
Dictionary <byte, HFCode> table = fHComp.GetWritingTable();
//Writing Dictionary Length
byte[] dictionaryHeader = new byte[2];
dictionaryHeader = BitConverter.GetBytes((short)table.Count);
fStream.Write(dictionaryHeader, 0, 2);
//Writing Value and Length foreach Dictionary entry
byte[] dictionaryBitLength = new byte[2];
foreach (KeyValuePair <byte, HFCode> pair in table)
{
fStream.WriteByte(pair.Key);
dictionaryBitLength = BitConverter.GetBytes((ushort)pair.Value.length);
fStream.Write(dictionaryBitLength, 0, 2);
}
//Writing Code for each Dictionary entry
BitStream bitStream = new BitStream(fStream);
foreach (KeyValuePair <byte, HFCode> pair in table)
{
bitStream.WriteBits(pair.Value.GetBitCode());
}
//Write Data
long dataLength = 0;
BitArray buffer;
for (int i = 0; i < cBytes.Length; ++i)
{
buffer = table[cBytes[i]].GetBitCode();
dataLength += buffer.Length;
bitStream.WriteBits(buffer);
}
for (int i = 0; i < mBytes.Length; ++i)
{
buffer = table[mBytes[i]].GetBitCode();
dataLength += buffer.Length;
bitStream.WriteBits(buffer);
}
for (int i = 0; i < yBytes.Length; ++i)
{
buffer = table[yBytes[i]].GetBitCode();
dataLength += buffer.Length;
bitStream.WriteBits(buffer);
}
Console.WriteLine($"Written bits: {dataLength}: bytes: {(dataLength / 8) + 1} : avgBytes: {((double)dataLength / (double)fullBytes.Length)}");
bitStream.Flush();
fStream.Close();
}
public void Coursework_Huffman_Test()
{
string text = "often this information is the individual identification";
var a = text.Length;
var huffmanTree = new HuffmanCode(text);
var b = huffmanTree.CodeTable.OrderBy(x => x.Value.Length).ToList();
string encode = huffmanTree.Encode(text);
string decode = huffmanTree.Decode(encode);
Assert.AreEqual(text, decode);
}
public static HTreeGroup[] New(int num_htree_groups, int table_size)
{
var tables = new HuffmanCode[num_htree_groups * table_size];
var htree_groups = new HTreeGroup[num_htree_groups];
for (int i = 0; i < num_htree_groups; ++i)
{
htree_groups[i] = new HTreeGroup();
htree_groups[i].tables = tables;
}
return(htree_groups);
}
public static void Main()
{
string input = Console.ReadLine();
Console.WriteLine(input);
var encoder = new HuffmanCode();
var res = encoder.Encode(input);
Console.WriteLine("" + res.Tree.Count + " " + res.Encoded.Length);
res.Tree
.Select(p => string.Format("{0}: {1}", "" + p.Key, p.Value))
.ForEach(Console.WriteLine);
Console.WriteLine(res.Encoded);
}
private void HUF_CreateCodeWorks()
{
byte[] scode = new byte[100];
uint i;
for (i = 0; i < num_leafs; i++)
{
HuffmanNode node = tree[i];
uint symbol = node.symbol;
uint nbits = 0;
while (node.dad != null)
{
scode[nbits++] = node.dad.lson == node ? (byte)HUF_LNODE : (byte)HUF_RNODE;
node = node.dad;
}
uint maxbytes = (nbits + 7) >> 3;
HuffmanCode code = new HuffmanCode();
codes[symbol] = code;
code.nbits = nbits;
code.codework = new byte[maxbytes];
uint j;
for (j = 0; j < maxbytes; j++)
{
code.codework[j] = 0;
}
byte mask = (byte)HUF_MASK;
j = 0;
uint nbit;
for (nbit = nbits; nbit != 0; nbit--)
{
if (scode[nbit - 1] != 0)
{
code.codework[j] |= mask;
}
if ((mask >>= HUF_SHIFT) == 0)
{
mask = (byte)HUF_MASK;
j++;
}
}
}
}
public void EncondeAndDecode_WithGivenFrequenciesTest()
{
string message = "aabbbc";
var alphabetFreq = new Dictionary <char, int>()
{
['a'] = 2,
['b'] = 3,
['c'] = 1
};
var huffmanTree = new HuffmanCode(alphabetFreq);
string encode = huffmanTree.Encode(message);
string decode = huffmanTree.Decode(encode);
Assert.AreEqual("111100010", encode);
Assert.AreEqual(message, decode);
}
static void HuffmanTest()
{
Console.WriteLine("Huffman encoding test");
HuffmanCode hc = new HuffmanCode();
hc.Frequencies["omri"] = 35;
hc.Frequencies["had"] = 3;
hc.Frequencies["a"] = 107;
hc.Frequencies["little"] = 53;
hc.Frequencies["lamb"] = 27;
hc.ComputeCodes();
foreach (var key in hc.Codes.Keys)
{
Console.WriteLine(String.Format("{0}: {1}", key, hc.Codes[key]));
}
}
static void HuffmanTestCLR()
{
Console.WriteLine("Huffman encoding test with CLR input");
HuffmanCode hc = new HuffmanCode();
hc.Frequencies["f"] = 5;
hc.Frequencies["e"] = 9;
hc.Frequencies["c"] = 12;
hc.Frequencies["b"] = 13;
hc.Frequencies["d"] = 16;
hc.Frequencies["a"] = 45;
hc.ComputeCodes();
foreach (var key in hc.Codes.Keys)
{
Console.WriteLine(String.Format("{0}: {1}", key, hc.Codes[key]));
}
}
public void Write(byte[] cBytes, byte[] mBytes, byte[] yBytes, FileStream fStream)
{
HuffmanCode <byte> cFHComp = new HuffmanCode <byte>(cBytes);
Dictionary <byte, HFCode> cTable = cFHComp.GetWritingTable();
HuffmanCode <byte> mFHComp = new HuffmanCode <byte>(mBytes);
Dictionary <byte, HFCode> mTable = mFHComp.GetWritingTable();
HuffmanCode <byte> yFHComp = new HuffmanCode <byte>(yBytes);
Dictionary <byte, HFCode> yTable = yFHComp.GetWritingTable();
//Writing C Dictionary Length
byte[] dictionaryHeader = new byte[2];
dictionaryHeader = BitConverter.GetBytes((short)cTable.Count);
fStream.Write(dictionaryHeader, 0, 2);
//Writing Value and Length foreach Dictionary entry
byte[] dictionaryBitLength = new byte[2];
foreach (KeyValuePair <byte, HFCode> pair in cTable)
{
fStream.WriteByte(pair.Key);
dictionaryBitLength = BitConverter.GetBytes((ushort)pair.Value.length);
fStream.Write(dictionaryBitLength, 0, 2);
}
//Writing M Dictionary Length
dictionaryHeader = BitConverter.GetBytes((short)mTable.Count);
fStream.Write(dictionaryHeader, 0, 2);
//Writing Value and Length foreach Dictionary entry
foreach (KeyValuePair <byte, HFCode> pair in mTable)
{
fStream.WriteByte(pair.Key);
dictionaryBitLength = BitConverter.GetBytes((ushort)pair.Value.length);
fStream.Write(dictionaryBitLength, 0, 2);
}
//Writing Y Dictionary Length
dictionaryHeader = BitConverter.GetBytes((short)yTable.Count);
fStream.Write(dictionaryHeader, 0, 2);
//Writing Value and Length foreach Dictionary entry
foreach (KeyValuePair <byte, HFCode> pair in yTable)
{
fStream.WriteByte(pair.Key);
dictionaryBitLength = BitConverter.GetBytes((ushort)pair.Value.length);
fStream.Write(dictionaryBitLength, 0, 2);
}
//Writing Code for each Dictionary entry
BitStream bitStream = new BitStream(fStream);
foreach (KeyValuePair <byte, HFCode> pair in cTable)
{
bitStream.WriteBits(pair.Value.GetBitCode());
}
foreach (KeyValuePair <byte, HFCode> pair in mTable)
{
bitStream.WriteBits(pair.Value.GetBitCode());
}
foreach (KeyValuePair <byte, HFCode> pair in yTable)
{
bitStream.WriteBits(pair.Value.GetBitCode());
}
//Write Data
long dataLength = 0;
BitArray buffer;
for (int i = 0; i < cBytes.Length; ++i)
{
buffer = cTable[cBytes[i]].GetBitCode();
dataLength += buffer.Length;
bitStream.WriteBits(buffer);
}
for (int i = 0; i < mBytes.Length; ++i)
{
buffer = mTable[mBytes[i]].GetBitCode();
dataLength += buffer.Length;
bitStream.WriteBits(buffer);
}
for (int i = 0; i < yBytes.Length; ++i)
{
buffer = yTable[yBytes[i]].GetBitCode();
dataLength += buffer.Length;
bitStream.WriteBits(buffer);
}
Console.WriteLine($"Written bits: {dataLength}: bytes: {(dataLength / 8) + 1} : avgBits: {((double)dataLength / (cBytes.Length + mBytes.Length + yBytes.Length))}");
bitStream.Flush();
fStream.Close();
}
public void SetCode(int meta, int index, HuffmanCode code)
{
tables[htrees[meta] + index] = code;
}
//------------------------------------------------------------------------------
// Decodes the next Huffman code from bit-stream.
// FillBitWindow(br) needs to be called at minimum every second call
// to ReadSymbol, in order to pre-fetch enough bits.
int ReadSymbol(HuffmanCode[] table, int index)
{
int val = (int)br_.PrefetchBits();
index += val & Huffman.TableMask;
int nbits = table[index].bits - Huffman.TableBits;
if (nbits > 0)
{
br_.SkipBits (Huffman.TableBits);
val = (int)br_.PrefetchBits();
index += table[index].value;
index += val & ((1 << nbits) - 1);
}
br_.SkipBits (table[index].bits);
return table[index].value;
}
int AccumulateHCode(HuffmanCode hcode, int shift, ref HuffmanCode32 huff)
{
huff.bits += hcode.bits;
huff.value |= (uint)hcode.value << shift;
return hcode.bits;
}
int ReadHuffmanCode(int alphabet_size, int[] code_lengths, HuffmanCode[] table, int index)
{
bool ok = false;
int size = 0;
bool simple_code = br_.ReadBits (1) != 0;
for (int i = 0; i < alphabet_size; ++i)
code_lengths[i] = 0;
if (simple_code) // Read symbols, codes & code lengths directly.
{
int num_symbols = (int)br_.ReadBits (1) + 1;
int first_symbol_len_code = (int)br_.ReadBits (1);
// The first code is either 1 bit or 8 bit code.
int symbol = (int)br_.ReadBits ((first_symbol_len_code == 0) ? 1 : 8);
code_lengths[symbol] = 1;
// The second code (if present), is always 8 bit long.
if (2 == num_symbols)
{
symbol = (int)br_.ReadBits (8);
code_lengths[symbol] = 1;
}
ok = true;
}
else // Decode Huffman-coded code lengths.
{
var code_length_code_lengths = new int[NumCodeLengthCodes];
int num_codes = (int)br_.ReadBits (4) + 4;
if (num_codes > NumCodeLengthCodes)
{
status_ = VP8StatusCode.BitstreamError;
return 0;
}
for (int i = 0; i < num_codes; ++i)
{
code_length_code_lengths[kCodeLengthCodeOrder[i]] = (int)br_.ReadBits (3);
}
ok = ReadHuffmanCodeLengths (code_length_code_lengths, alphabet_size, code_lengths);
}
ok = ok && !br_.EoS;
if (ok)
size = Huffman.BuildTable (table, index, Huffman.TableBits, code_lengths, alphabet_size);
if (!ok || size == 0)
{
status_ = VP8StatusCode.BitstreamError;
return 0;
}
return size;
}
bool ReadHuffmanCodeLengths(int[] code_length_code_lengths, int num_symbols, int[] code_lengths)
{
int prev_code_len = Huffman.DefaultCodeLength;
var table = new HuffmanCode[1 << Huffman.LengthsTableBits];
if (0 == Huffman.BuildTable (table, 0, Huffman.LengthsTableBits, code_length_code_lengths, NumCodeLengthCodes))
{
status_ = VP8StatusCode.BitstreamError;
return false;
}
int max_symbol;
if (0 != br_.ReadBits (1)) // use length
{
int length_nbits = 2 + 2 * (int)br_.ReadBits (3);
max_symbol = 2 + (int)br_.ReadBits (length_nbits);
if (max_symbol > num_symbols)
{
status_ = VP8StatusCode.BitstreamError;
return false;
}
}
else
{
max_symbol = num_symbols;
}
int symbol = 0;
while (symbol < num_symbols)
{
if (max_symbol-- == 0) break;
br_.FillBitWindow();
int p = (int)br_.PrefetchBits() & Huffman.LengthsTableMask;
br_.SkipBits (table[p].bits);
int code_len = table[p].value;
if (code_len < kCodeLengthLiterals)
{
code_lengths[symbol++] = code_len;
if (code_len != 0) prev_code_len = code_len;
}
else
{
bool use_prev = (code_len == kCodeLengthRepeatCode);
int slot = code_len - kCodeLengthLiterals;
int extra_bits = kCodeLengthExtraBits[slot];
int repeat_offset = kCodeLengthRepeatOffsets[slot];
int repeat = (int)br_.ReadBits(extra_bits) + repeat_offset;
if (symbol + repeat > num_symbols)
{
status_ = VP8StatusCode.BitstreamError;
return false;
}
else
{
int length = use_prev ? prev_code_len : 0;
while (repeat-- > 0)
code_lengths[symbol++] = length;
}
}
}
return true;
}
public byte[] Compress(byte[] data)
{
uint pk4_pos = 0;
num_bits = 8;
uint raw_len = (uint)data.Length;
byte[] pbuf = new byte[HUF_MAXIM + 1];
Array.Copy(BitConverter.GetBytes((CMD_CODE) | (raw_len << 8)), pbuf, 4);
uint pak_pos = 4;
uint raw_pos = 0;
HUF_InitFreqs();
HUF_CreateFreqs(data, data.Length);
HUF_InitTree();
HUF_CreateTree();
HUF_InitCodeTree();
HUF_CreateCodeTree();
HUF_InitCodeWorks();
HUF_CreateCodeWorks();
uint cod_pos = 0;
uint len = (uint)((codetree[cod_pos] + 1) << 1);
while (len-- != 0)
{
pbuf[pak_pos++] = codetree[cod_pos++];
}
uint mask4 = 0;
while (raw_pos < data.Length)
{
uint ch = data[raw_pos++];
int nbits;
for (nbits = 8; nbits != 0; nbits -= num_bits)
{
HuffmanCode code = codes[ch & ((1 << num_bits) - 1)];
//// code = codes[ch >> (8 - num_bits)];
len = code.nbits;
int cwork = 0;
byte mask = (byte)HUF_MASK;
while (len-- != 0)
{
if ((mask4 >>= HUF_SHIFT) == 0)
{
mask4 = HUF_MASK4;
pk4_pos = pak_pos;
Array.Copy(BitConverter.GetBytes(0), 0, pbuf, pk4_pos, 4);
pak_pos += 4;
}
if ((code.codework[cwork] & mask) != 0)
{
Array.Copy(BitConverter.GetBytes(BitConverter.ToUInt32(pbuf, (int)pk4_pos) | mask4), 0, pbuf, pk4_pos, 4);
}
if ((mask >>= HUF_SHIFT) == 0)
{
mask = (byte)HUF_MASK;
cwork++;
}
}
ch >>= num_bits;
//// ch = (ch << num_bits) & 0xFF;
}
}
uint pak_len = pak_pos;
return(pbuf.Take((int)pak_len).ToArray());
}
