public void TestEncodeDecodeWithCompression()
{
var input =
"He paused for a moment, many recollections overpowering him. Then he went on telling her the history of his life, unfolding to her the story of his hopes and ambitions, describing to her the very home where he was born, and the dark-eyed sister whom he had loved, and with whom he had played over the daisied fields, and through the carpeted woods, and all among the richly tinted bracken. One day he was told she was dead, and that he must never speak her name; but he spoke it all the day and all the night, Beryl, nothing but Beryl, and he looked for her in the fields and in the woods and among the bracken. It seemed as if he had unlocked the casket of his heart, closed for so many years, and as if all the memories of the past and all the secrets of his life were rushing out, glad to be free once more, and grateful for the open air of sympathy.";
var dict = CharacterFrequencyDictionary.CreateDictionary(input);
var encodeTree = new HuffmanTree<char>(dict);
var encode = encodeTree.Encode(input);
var encodeAsByte = CompressUtil.ConvertToByteArray(encode);
var secondDict = CharacterFrequencyDictionary.CreateDictionary(
dict.GetKeysAsByteArray(), dict.GetValuesAsByteArray());
var encodeAsByteArray = new List<byte>();
foreach (var b in encodeAsByte)
encodeAsByteArray.AddRange(CompressUtil.ConvertToBitArray(b));
if (encode.Length < encodeAsByteArray.ToArray().Length)
encodeAsByteArray.RemoveRange(encode.Length, encodeAsByteArray.ToArray().Length - encode.Length);
CollectionAssert.AreEqual(dict, secondDict);
CollectionAssert.AreEqual(encode, encodeAsByteArray.ToArray());
var decodeTree = new HuffmanTree<char>(secondDict);
var decode = decodeTree.Decode(encodeAsByteArray);
Assert.AreEqual(input, decode);
}
// Проверка правильности строки для кода Хаффмана
public static ReturnResult CheckString04(string reply, string generated)
{
try
{
bool yes = true;
string input = generated;
if (input.CompareTo("") == 0)
{
return new ReturnResult(false, "Вы не ввели текст!");
}
HuffmanTree huffmanTree = new HuffmanTree();
// Строим дерево Хаффмана по весам слов
huffmanTree.Build(input);
// Кодируем
BitArray encoded = (BitArray)huffmanTree.Encode(input);
if (huffmanTree.str != reply)
yes = false;
if (yes)
return new ReturnResult(true, "Абсолютно верное решение! ");
return new ReturnResult(false, "Это не оптимальный код Хаффмана. Вот он: " + huffmanTree.str);
}
catch (Exception e)
{
return new ReturnResult(false, "Ошибка ввода! " + e.Message);
}
}
private void Form1_Load(object sender, EventArgs e)
{
htree = new HuffmanTree();
textBox1.Width = this.Size.Width - 50;
richTextBox1.Width = this.Size.Width - 50;
richTextBox2.Width = this.Size.Width - 50;
richTextBox3.Width = this.Size.Width - 50;
}
void BuildHuffmanTree()
{
tree = new HuffmanTree<int>();
for( int i = 0; i < codewordLengths.Length; i++ ) {
byte length = codewordLengths[i];
HuffmanNode<int> node = tree.RootNode;
nodeFound = false;
InsertNode( i, node, length, "" );
if( !nodeFound )
throw new InvalidOperationException( "Could not find empty branch in huffman tree!" );
}
}
public void TestEncodeDecode()
{
var input = "abcdef 123 a test string baba abba 234";
var dict = CharacterFrequencyDictionary.CreateDictionary(input);
var encodeTree = new HuffmanTree<char>(dict);
var z = encodeTree.Encode(input);
var decodeTree = new HuffmanTree<char>(dict);
var decode = decodeTree.Decode(z);
Assert.AreEqual(input, decode);
}
public static void DecompressFile(string inputfilename, string outputFilename)
{
Console.WriteLine("Decompressing file {0} to {1}", inputfilename, outputFilename);
HuffmanTree<char> huffmanTree;
var encodedStream = new List<byte>();
using (var fs = new FileStream(inputfilename, FileMode.Open, FileAccess.Read))
{
var keyLengthArray = new byte[4];
var valueLengthArray = new byte[4];
fs.Read(keyLengthArray, 0, 4);
fs.Read(valueLengthArray, 0, 4);
var keyLength = BitConverter.ToInt32(keyLengthArray, 0);
var valueLength = BitConverter.ToInt32(valueLengthArray, 0);
var keyArray = new byte[keyLength];
var valueArray = new byte[valueLength];
fs.Read(keyArray, 0, keyLength);
fs.Read(valueArray, 0, valueLength);
var compressedLengthArray = new byte[4];
fs.Read(compressedLengthArray, 0, 4);
var compressedLength = BitConverter.ToInt32(compressedLengthArray, 0);
var dict = CharacterFrequencyDictionary.CreateDictionary(keyArray, valueArray);
huffmanTree = new HuffmanTree<char>(dict);
int record;
while ((record = fs.ReadByte()) != -1)
encodedStream.AddRange(CompressUtil.ConvertToBitArray((byte)record));
if (encodedStream.Count() > compressedLength)
encodedStream.RemoveRange(compressedLength, encodedStream.Count() - compressedLength);
}
using (var fsw = new FileStream(outputFilename, FileMode.Create, FileAccess.Write))
using (var sr = new StreamWriter(fsw))
sr.Write(huffmanTree.Decode(encodedStream));
Console.WriteLine("Compression complete.");
}
private void ReadMainTree()
{
uint[] lengths;
if (_mainTree == null)
{
lengths = new uint[256 + (8 * _numPositionSlots)];
}
else
{
lengths = _mainTree.Lengths;
}
HuffmanTree preTree = ReadFixedHuffmanTree(20, 4);
ReadLengths(preTree, lengths, 0, 256);
preTree = ReadFixedHuffmanTree(20, 4);
ReadLengths(preTree, lengths, 256, 8 * _numPositionSlots);
_mainTree = new HuffmanTree(lengths);
}
public void FillTree()
{
weights = new List <int>(5);
weights.Clear();
for (int i = 1; i < 5; i++)
{
weights.Add(i);
}
huffmanTree = new HuffmanTree(weights);
huffmanTree.Create();
HuffmanTreeNode huffTreeNode = huffmanTree[huffmanTree.Data.Count - 1];
TreeNode root = new TreeNode("huffman Tree");
FillTreeNodes(huffTreeNode, root);
treeView1.Nodes.Add(root);
}
public static HuffmanTree <T> ReconstructFromTable(Dictionary <HFCode, T> table)
{
HuffmanTree <T> hfTree = new HuffmanTree <T>();
hfTree.root = new HuffmanTreeNode(-1);
foreach (KeyValuePair <HFCode, T> pair in table)
{
BitArray bitCode = pair.Key.GetBitCode();
HuffmanTreeNode curNode = hfTree.root;
HuffmanTreeNode prevNode = curNode;
for (int i = 0; i < bitCode.Length; ++i)
{
//Go left or right depending on bitCode
prevNode = curNode;
curNode = (bitCode[i]) ? curNode.right : curNode.left;
if (curNode == null)
{
if (i == bitCode.Length - 1) //Create leaf
{
HuffmanLeafNode <T> hfLeafNode = new HuffmanLeafNode <T>(pair.Value, 0);
curNode = hfLeafNode;
}
else
{
curNode = new HuffmanTreeNode(i);
}
if (bitCode[i])
{
prevNode.right = curNode;
}
else
{
prevNode.left = curNode;
}
}
}
}
return(hfTree);
}
private int Decode(HuffmanTree /*!*/ tree)
{
int code = 0;
int first = 0;
int index = 0;
for (int len = 1; len <= 15; len++)
{
code |= GetBits(1);
int count = tree.Count[len];
if (code < (first + count))
{
return(tree.Symbol[index + (code - first)]);
}
index += count;
first += count;
first <<= 1;
code <<= 1;
}
return(-9);
}
private HuffmanTree InitializeHuffmanTree()
{
/*
* List<string> items = new List<string>();
* foreach(TXTRow row in ArmorTXT.Rows)
* {
* items.Add(row["code"]);
* }
* foreach (TXTRow row in WeaponsTXT.Rows)
* {
* items.Add(row["code"]);
* }
* foreach (TXTRow row in MiscTXT.Rows)
* {
* items.Add(row["code"]);
* }
*/
var itemCodeTree = new HuffmanTree();
itemCodeTree.Build(new List <string>());
return(itemCodeTree);
}
unsafe private static HuffmanNode **GetPPNode(HuffmanTree huff)
{
// CLog.Info("get ppnode",huff.freeList.ptr);
HuffmanNode **tppnode;
if (huff.freeList == null)
{
// CLog.Info("getppnode:ptr:{0}, node:{1}", huff.blocPtrs, huff.blocNode);
// try{
fixed(HuffmanNode **retVal = &huff.nodePtrs[huff.blocPtrs++])
{
return(retVal);
}
// }catch(System.Exception e){
// CLog.Info("error:", e.Message);
// return null;
// }
}
else
{
// CLog.Info("getppnode ex:ptr:{0}, node:{1}", huff.blocPtrs, huff.blocNode);
// typedef struct nodetype {
// struct nodetype *left, *right, *parent; /* tree structure */
// struct nodetype *next, *prev; /* doubly-linked list */
// struct nodetype **head; /* highest ranked node in block */
// int weight;
// int symbol;
// } node_t;
// tppnode = huff->freelist;
// huff->freelist = (node_t **)*tppnode;
tppnode = huff.freeList; //new HuffNodePtr();
huff.freeList = (HuffmanNode **)*tppnode;
return(tppnode);
}
}
// adds the tree to the list such that the list remains sorted by the frequency of its trees
public void Add(HuffmanTree tree)
{
ListNode newNode = new ListNode(tree);
if (First == null)
{
First = newNode;
}
else if (tree.Frequency < First.Tree.Frequency)
{
// min frequency
// add newNode at the top of the list
newNode.Next = First;
First = newNode;
}
else
{
ListNode curNode;
for (curNode = First; curNode.Next != null; curNode = curNode.Next)
{
if (tree.Frequency < curNode.Next.Tree.Frequency)
{
// add newNode after curNode
newNode.Next = curNode.Next;
curNode.Next = newNode;
break;
}
}
// if newNode was not added to the list (max frequency)
if (newNode.Next == null)
{
// add newNode at the bottom of the list
// curNode is now the last node
curNode.Next = newNode;
}
}
}
public void BuildTreeFromCharFrequenciesTest()
{
var tree = new HuffmanTree(freq);
Assert.AreEqual(100, tree.Root.Frequency);
Assert.AreEqual('f', tree.Root.Left.Symbol);
Assert.AreEqual(45, tree.Root.Left.Frequency);
Assert.AreEqual(55, tree.Root.Right.Frequency);
Assert.AreEqual(25, tree.Root.Right.Left.Frequency);
Assert.AreEqual(30, tree.Root.Right.Right.Frequency);
Assert.AreEqual('c', tree.Root.Right.Left.Left.Symbol);
Assert.AreEqual(12, tree.Root.Right.Left.Left.Frequency);
Assert.AreEqual('d', tree.Root.Right.Left.Right.Symbol);
Assert.AreEqual(13, tree.Root.Right.Left.Right.Frequency);
Assert.AreEqual(14, tree.Root.Right.Right.Left.Frequency);
Assert.AreEqual('e', tree.Root.Right.Right.Right.Symbol);
Assert.AreEqual(16, tree.Root.Right.Right.Right.Frequency);
Assert.AreEqual('a', tree.Root.Right.Right.Left.Left.Symbol);
Assert.AreEqual(5, tree.Root.Right.Right.Left.Left.Frequency);
Assert.AreEqual('b', tree.Root.Right.Right.Left.Right.Symbol);
Assert.AreEqual(9, tree.Root.Right.Right.Left.Right.Frequency);
}
private void button3_Click(object sender, EventArgs e)
{
var watch = new System.Diagnostics.Stopwatch();
var watch2 = new System.Diagnostics.Stopwatch();
for (int s = min; s < max; s += step)
{
generatingbench(s);
BitArray temp = null;
for (int i = 0; i < nor; i++)
{
watch.Restart();
huffmanTree = new HuffmanTree();
huffmanTree.Build(inputbench.ToString());
BitArray encoded2 = huffmanTree.Encode(inputbench.ToString());
benchmarktime1 += watch.Elapsed.TotalMilliseconds;
if (i == 0)
{
temp = huffmanTree.Encode(inputbench.ToString());
}
watch.Stop();
}
//==================================================================================================
for (int i = 0; i < nor; i++)
{
watch2.Restart();
string decoded = huffmanTree.Decode(temp);
benchmarktime2 += watch2.Elapsed.TotalMilliseconds;
watch2.Stop();
}
if (s == min)
{
this.richTextBox5.Text = "Data Size \t" + "Compress time \t" + "Decompress Time \t" + "\n" + "=====================================================" + "\n";
}
this.richTextBox5.Text += s + "\t\t" + Math.Round((benchmarktime1 / nor), 3).ToString() + "\t\t" + Math.Round((benchmarktime2 / nor), 3).ToString() + "\n";
benchmarktime1 = 0;
benchmarktime2 = 0;
}
}
// Проверка правильности строки для кода Хаффмана
public static string CheckString04(string reply, string generated)
{
try
{
bool yes = true;
string input = generated;
if (input.CompareTo("") == 0)
{
return("Вы не ввели текст!");
}
HuffmanTree huffmanTree = new HuffmanTree();
// Строим дерево Хаффмана по весам слов
huffmanTree.Build(input);
// Кодируем
BitArray encoded = (BitArray)huffmanTree.Encode(input);
if (huffmanTree.str != reply)
{
yes = false;
}
if (yes)
{
return("Абсолютно верное решение! ");
}
return("Это не оптимальный код Хаффмана. Вот он: " + huffmanTree.str);
}
catch (Exception e)
{
return("Ошибка ввода! " + e.Message);
}
}
protected static Dictionary <byte[], BitArray> GetCodeBook(IEnumerable <Stream> streams, byte compressLevel)
{
var weightDictionary = new Dictionary <byte[], ulong>(new ByteArrayEqualityComparer());
foreach (var stream in streams)
{
// 移动输入流的位置到开头
stream.Seek(0, SeekOrigin.Begin);
// 循环读取单位字节数到缓冲数组中，之后进行计数操作
while (stream.Position < stream.Length)
{
int readByte;
// 建立一个具有合适大小的字节缓存数组
var buffer = new byte[Math.Min(compressLevel, stream.Length - stream.Position)];
for (var i = 0; i < compressLevel && (readByte = stream.ReadByte()) >= 0; i++)
{
buffer[i] = (byte)readByte;
}
if (weightDictionary.ContainsKey(buffer))
{
weightDictionary[buffer]++;
}
else
{
weightDictionary[buffer] = 1;
}
}
}
// 创建哈夫曼树
var huffmanTree =
HuffmanTree <byte[]> .CreateFromWeightDictionary(weightDictionary, new ByteArrayEqualityComparer());
// 获取编码本
var codeBook = huffmanTree.CodeBook;
return(codeBook);
}
private byte[] ReadData(HuffmanTree huffTree, char[] bitArray, int lastByteOffset)
{
string data = "";
for (int i = 0; i < bitArray.Length - lastByteOffset;)
{
HuffNode currentNode = huffTree.root;
while (true)
{
if (bitArray[i] == '0')
{
currentNode = ((InternalNode)currentNode).leftChild;
}
else if (bitArray[i] == '1')
{
currentNode = ((InternalNode)currentNode).rightChild;
}
i++;
if (currentNode is LeafNode)
{
data += ((LeafNode)currentNode).E;
Console.Write(Convert.ToInt32(((LeafNode)currentNode).E) + " ");
break;
}
}
}
char[] ca = data.ToCharArray();
byte[] result = new byte[data.Length];
for (int i = 0; i < result.Length; i++)
{
result[i] = (byte)ca[i];
}
return(result);
}
public static FrequencyRecord[] GetFrequencyDictionary(string text)
{
var result = new List <FrequencyRecord>();
var huffmanTree = new HuffmanTree();
huffmanTree.Build(text);
_entropy = 0;
for (int i = 0; i < huffmanTree.Frequencies.Count; i++)
{
var record = new FrequencyRecord();
record._char = huffmanTree.Frequencies.ElementAt(i).Key;
record._freq = huffmanTree.Frequencies.ElementAt(i).Value;
record._freqPercent = Math.Round(record._freq / ((float)text.Length), 2);
foreach (var item in huffmanTree.EncodeChar(record._char))
{
record._code += (item ? 1 : 0);
}
result.Add(record);
_entropy += Math.Round((-(result[i]._freqPercent * Math.Log(result[i]._freqPercent, 2))), 2);
}
BitArray encoded = huffmanTree.Encode(text);
Console.Write("Encoded: ");
var str = "";
foreach (bool bit in encoded)
{
str += (bit ? 1 : 0);
}
_avg = Math.Round((float)str.Length / (float)text.Length, 2);
_lenght = str.Length;
return(result.ToArray());
}
static void Main(string[] args)
{
// ------------------- Variable Declarations
string inputText = ""; // text to be encoded and decoded.
// ------------------- Input
Console.Write("Enter a string to be huffman encoded: ");
inputText = Console.ReadLine();
Console.WriteLine("The text you entered is: \"{0}\"", inputText);
// ------------------- Processing
// Group the characters into a collection of Keys (the characters) and Counts (frequencies)
var aggregatedCharacters = inputText.GroupBy(character => character).Select(group => new { character = group.Key, frequency = group.Count() });
// Priority Queue of HuffmanNodes of CharFreqPairs
var charFreqPriorityQueue = new PriorityQueue<HuffmanNode<CharFreqPair>>(aggregatedCharacters.Count());
// Add the Character:Frequency pairs to the Priority Queue
foreach (var aggregatedCharacter in aggregatedCharacters)
charFreqPriorityQueue.Add(new HuffmanNode<CharFreqPair>(new CharFreqPair(aggregatedCharacter.frequency, aggregatedCharacter.character)));
// Create HuffmanTree object
var huffmanTree = new HuffmanTree(charFreqPriorityQueue);
string testing = huffmanTree.EncodeText(inputText);
Console.WriteLine("The encoded text is: \"{0}\"", testing);
testing = huffmanTree.DecodeText(testing);
Console.WriteLine("The decoded text is: \"{0}\"", testing);
//huffmanTree.Print();
// Pause before exiting
Console.WriteLine("Press return to exit...");
Console.ReadLine();
}
public void TestEncodeDecodeWithCompression()
{
var input =
"He paused for a moment, many recollections overpowering him. Then he went on telling her the history of his life, unfolding to her the story of his hopes and ambitions, describing to her the very home where he was born, and the dark-eyed sister whom he had loved, and with whom he had played over the daisied fields, and through the carpeted woods, and all among the richly tinted bracken. One day he was told she was dead, and that he must never speak her name; but he spoke it all the day and all the night, Beryl, nothing but Beryl, and he looked for her in the fields and in the woods and among the bracken. It seemed as if he had unlocked the casket of his heart, closed for so many years, and as if all the memories of the past and all the secrets of his life were rushing out, glad to be free once more, and grateful for the open air of sympathy.";
var dict = CharacterFrequencyDictionary.CreateDictionary(input);
var encodeTree = new HuffmanTree <char>(dict);
var encode = encodeTree.Encode(input);
var encodeAsByte = CompressUtil.ConvertToByteArray(encode);
var secondDict = CharacterFrequencyDictionary.CreateDictionary(
dict.GetKeysAsByteArray(), dict.GetValuesAsByteArray());
var encodeAsByteArray = new List <byte>();
foreach (var b in encodeAsByte)
{
encodeAsByteArray.AddRange(CompressUtil.ConvertToBitArray(b));
}
if (encode.Length < encodeAsByteArray.ToArray().Length)
{
encodeAsByteArray.RemoveRange(encode.Length, encodeAsByteArray.ToArray().Length - encode.Length);
}
CollectionAssert.AreEqual(dict, secondDict);
CollectionAssert.AreEqual(encode, encodeAsByteArray.ToArray());
var decodeTree = new HuffmanTree <char>(secondDict);
var decode = decodeTree.Decode(encodeAsByteArray);
Assert.AreEqual(input, decode);
}
static void Main(string[] args)
{
HuffmanTree<string> tree = new HuffmanTree<string>();
BST index = new BST();
//string rhyme = "Jack, be nimble, Jack, be quick, Jack, jump over the candlestick. Jack jumped high. Jack jumped low. Jack jumped over and burned his toe.";
Dictionary<string,long> codes = new Dictionary<string,long>();
codes.Add("Jack", 0);
codes.Add("jumped", 10);
codes.Add("over", 110);
codes.Add("be", 1110);
codes.Add("nimble", 11110);
codes.Add("quick", 111110);
codes.Add("jumped", 1111110);
codes.Add("the", 11111110);
codes.Add("candlestick", 111111110);
codes.Add("high", 1111111110);
codes.Add("low", 11111111110);
codes.Add("and", 111111111110);
codes.Add("burned", 1111111111110);
codes.Add("toe", 11111111111110);
codes.Add("his", 111111111111110);
}
public void InsertTree(HuffmanTree hTemp)
{
Node eTemp = new Node(hTemp);
if (first == null)
{
first = eTemp;
}
else
{
Node p = first;
while (!(p.link == null))
{
if ((p.data.GetFreq() <= hTemp.GetFreq()) && (p.link.data.GetFreq() >= hTemp.GetFreq()))
{
break;
}
p = p.link;
}
eTemp.link = p.link;
p.link = eTemp;
}
count++;
}
private static ReadBuffer UnpackVLE(ReadBuffer packedData)
{
var widthsCount = packedData[0];
var widths = packedData.Slice(1, widthsCount);
var alphabetCount = widths.Select(val => (int)val).Sum();
var alphabet = packedData.Slice(1 + widthsCount, alphabetCount);
var dictionary = new HuffmanTree(widths, alphabet);
var stream = EnumerateBits(packedData.Drop(1 + widthsCount + alphabetCount));
var result = new WriteBuffer();
while (true)
{
int value = dictionary.DecodeByte(stream);
if (value < 0)
{
break;
}
result.Append((byte)value);
}
return(result.ToReadBuffer());
}
public static byte[] Encode(string text)
{
HuffmanTree tree = HuffmanTree.Build(text); // budowa drzewa
var dict = tree.Dictionary; // słownik kodów
var(encoded, padding) = Encode(text, dict); // zakodowanie wiadomośc
int maxLen = 4;
int estimatedBufferSize = 1 + dict.Count * (1 + 1 + maxLen) + 1 + encoded.Length; // przewidywany rozmiar pliku wyjściowego
var buff = new byte[estimatedBufferSize]; // utworzenie bufora
using var ms = new MemoryStream(buff);
// zapis kolejnych składowych formatu
ms.WriteByte((byte)dict.Count); // liczba znaków
foreach (var kvp in dict)
{
ms.WriteByte((byte)kvp.Key); // znak
ms.WriteByte((byte)kvp.Value.Length); // długośc kodu
ms.Write(kvp.Value.GetBytes().Item1); // kod
}
ms.WriteByte((byte)padding); // przesuniecie (margines do 8 bitów)
ms.Write(encoded); // zapis danych
return(buff.AsSpan(0, (int)ms.Position).ToArray());
}
private static void CompressFile(string inputFile, string outputFilename)
{
Console.WriteLine("Compressing file {0} to {1}", inputFile, outputFilename);
var input = String.Join(Environment.NewLine, File.ReadAllText(inputFile, Encoding));
var dict = CharacterFrequencyDictionary.CreateDictionary(input);
var fileHeader = CharacterFrequencyDictionary.GetHeaderByteArray(dict);
var compressed = new HuffmanTree<char>(dict).Encode(input);
var fileByteArray = CompressUtil.GetFileByteArray(fileHeader, compressed);
using (var fs = new FileStream(outputFilename, FileMode.Create, FileAccess.Write))
fs.Write(fileByteArray, 0, fileByteArray.Length);
Console.WriteLine("Compression complete.");
}
private HuffmanTree ReadDynamicHuffmanTree(int count, HuffmanTree preTree, HuffmanTree oldTree)
{
uint[] lengths;
if (oldTree == null)
{
lengths = new uint[256 + (8 * _numPositionSlots)];
}
else
{
lengths = oldTree.Lengths;
}
ReadLengths(preTree, lengths, 0, count);
return new HuffmanTree(lengths);
}
private static IList <HuffmanTree <T> > ReadHuffmanTrees <T>(IMarkedBitReader reader, Category category, int treeCount, HuffmanTree <T> .Context context) where T : IComparable <T>
{
return(reader.ReadStructureArray(treeCount, HuffmanTree <T> .Deserialize, context, "HTREE" + category.Id()));
}
private void ReadLengthTree()
{
HuffmanTree preTree = ReadFixedHuffmanTree(20, 4);
_lengthTree = ReadDynamicHuffmanTree(249, preTree, _lengthTree);
}
public void Load(BinaryReader Input)
{
this.Huffman = new HuffmanTree ();
this.Huffman.Load (Input);
}
public void Read(byte[] cBytes, byte[] mBytes, byte[] yBytes, FileStream fStream)
{
//Reading Dictionary Length
//C
byte[] dictionaryHeader = new byte[2];
fStream.Read(dictionaryHeader, 0, 2);
short cDictLength = BitConverter.ToInt16(dictionaryHeader, 0);
Dictionary <HFCode, byte> cReadTable = new Dictionary <HFCode, byte>();
//Reading Values and Code Lengths
byte[] cValueAndCodeLength = new byte[3 * cDictLength];
fStream.Read(cValueAndCodeLength, 0, 3 * cDictLength);
//M
dictionaryHeader = new byte[2];
fStream.Read(dictionaryHeader, 0, 2);
short mDictLength = BitConverter.ToInt16(dictionaryHeader, 0);
Dictionary <HFCode, byte> mReadTable = new Dictionary <HFCode, byte>();
//Reading Values and Code Lengths
byte[] mValueAndCodeLength = new byte[3 * mDictLength];
fStream.Read(mValueAndCodeLength, 0, 3 * mDictLength);
//M
dictionaryHeader = new byte[2];
fStream.Read(dictionaryHeader, 0, 2);
short yDictLength = BitConverter.ToInt16(dictionaryHeader, 0);
Dictionary <HFCode, byte> yReadTable = new Dictionary <HFCode, byte>();
//Reading Values and Code Lengths
byte[] yValueAndCodeLength = new byte[3 * yDictLength];
fStream.Read(yValueAndCodeLength, 0, 3 * yDictLength);
//Reading Values and Codes
BitStream bitStream = new BitStream(fStream);
//C
for (int i = 0; i < cDictLength; ++i)
{
byte value = cValueAndCodeLength[3 * i];
ushort codeLength = BitConverter.ToUInt16(cValueAndCodeLength, 3 * i + 1);
BitArray bits = bitStream.ReadBits(codeLength);
HFCode code = HFCode.FromBits(bits);
cReadTable.Add(code, value);
}
//M
for (int i = 0; i < mDictLength; ++i)
{
byte value = mValueAndCodeLength[3 * i];
ushort codeLength = BitConverter.ToUInt16(mValueAndCodeLength, 3 * i + 1);
BitArray bits = bitStream.ReadBits(codeLength);
HFCode code = HFCode.FromBits(bits);
mReadTable.Add(code, value);
}
//Y
for (int i = 0; i < yDictLength; ++i)
{
byte value = yValueAndCodeLength[3 * i];
ushort codeLength = BitConverter.ToUInt16(yValueAndCodeLength, 3 * i + 1);
BitArray bits = bitStream.ReadBits(codeLength);
HFCode code = HFCode.FromBits(bits);
yReadTable.Add(code, value);
//Console.WriteLine($"{value}:{code.length}:{code.GetStringCode()}");
}
//Reconstruct tree
//C
HuffmanTree <byte> cTree = HuffmanTree <byte> .ReconstructFromTable(cReadTable);
HuffmanTree <byte> mTree = HuffmanTree <byte> .ReconstructFromTable(mReadTable);
HuffmanTree <byte> yTree = HuffmanTree <byte> .ReconstructFromTable(yReadTable);
//Read values to bytes
int bufferSize = 128;
BitArray buffer = bitStream.ReadBits(bufferSize);
int bufferIndex = 0;
for (int i = 0; i < cBytes.Length; ++i)
{
HuffmanTreeNode curNode = cTree.root;
while (!(curNode is HuffmanLeafNode <byte>))
{
if (bufferIndex == buffer.Length)
{
buffer = bitStream.ReadBits(buffer.Length);
bufferIndex = 0;
}
curNode = (buffer[bufferIndex]) ? curNode.right : curNode.left;
bufferIndex++;
}
cBytes[i] = ((HuffmanLeafNode <byte>)curNode).info;
}
for (int i = 0; i < mBytes.Length; ++i)
{
HuffmanTreeNode curNode = mTree.root;
while (!(curNode is HuffmanLeafNode <byte>))
{
if (bufferIndex == buffer.Length)
{
buffer = bitStream.ReadBits(buffer.Length);
bufferIndex = 0;
}
curNode = (buffer[bufferIndex]) ? curNode.right : curNode.left;
bufferIndex++;
}
mBytes[i] = ((HuffmanLeafNode <byte>)curNode).info;
}
for (int i = 0; i < yBytes.Length; ++i)
{
HuffmanTreeNode curNode = yTree.root;
while (!(curNode is HuffmanLeafNode <byte>))
{
if (bufferIndex == buffer.Length)
{
buffer = bitStream.ReadBits(buffer.Length);
bufferIndex = 0;
}
curNode = (buffer[bufferIndex]) ? curNode.right : curNode.left;
bufferIndex++;
}
yBytes[i] = ((HuffmanLeafNode <byte>)curNode).info;
}
fStream.Close();
}
private void DecodeCompressedBlock(BlockType blockType, int blockSize)
{
if (blockType == BlockType.AlignedOffset)
{
_alignedOffsetTree = ReadFixedHuffmanTree(8, 3);
}
ReadMainTree();
ReadLengthTree();
uint numRead = 0;
while (numRead < (uint)blockSize)
{
uint symbol = _mainTree.NextSymbol(_bitStream);
if (symbol < 256)
{
_buffer[_bufferCount + numRead++] = (byte)symbol;
}
else
{
uint lengthHeader = (symbol - 256) & 7;
uint matchLength = lengthHeader + 2 + ((lengthHeader == 7) ? _lengthTree.NextSymbol(_bitStream) : 0);
uint positionSlot = (symbol - 256) >> 3;
uint matchOffset;
if (positionSlot == 0)
{
matchOffset = _repeatedOffsets[0];
}
else if (positionSlot == 1)
{
matchOffset = _repeatedOffsets[1];
_repeatedOffsets[1] = _repeatedOffsets[0];
_repeatedOffsets[0] = matchOffset;
}
else if (positionSlot == 2)
{
matchOffset = _repeatedOffsets[2];
_repeatedOffsets[2] = _repeatedOffsets[0];
_repeatedOffsets[0] = matchOffset;
}
else
{
int extra = (int)s_extraBits[positionSlot];
uint formattedOffset;
if (blockType == BlockType.AlignedOffset)
{
uint verbatimBits = 0;
uint alignedBits = 0;
if (extra >= 3)
{
verbatimBits = _bitStream.Read(extra - 3) << 3;
alignedBits = _alignedOffsetTree.NextSymbol(_bitStream);
}
else if (extra > 0)
{
verbatimBits = _bitStream.Read(extra);
}
formattedOffset = s_positionSlots[positionSlot] + verbatimBits + alignedBits;
}
else
{
uint verbatimBits = (extra > 0) ? _bitStream.Read(extra) : 0;
formattedOffset = s_positionSlots[positionSlot] + verbatimBits;
}
matchOffset = formattedOffset - 2;
_repeatedOffsets[2] = _repeatedOffsets[1];
_repeatedOffsets[1] = _repeatedOffsets[0];
_repeatedOffsets[0] = matchOffset;
}
int destOffset = _bufferCount + (int)numRead;
int srcOffset = destOffset - (int)matchOffset;
for (int i = 0; i < matchLength; ++i)
{
_buffer[destOffset + i] = _buffer[srcOffset + i];
}
numRead += matchLength;
}
}
}
public HuffmanTreeForm(HuffmanTree tree)
{
InitializeComponent();
Tree = tree;
}
public override void LoadRaw()
{
ushort[,] vpred = new ushort[2, 2];
ushort[] hpred = new ushort[2];
ushort csize;
int step = 0;
int huff = 0;
int split = 0;
int row;
RawStream ifp = state.ifp;
ifp.Seek(state.meta_offset, SeekOrigin.Begin);
ushort ver0 = (ushort)ifp.ReadByte();
ushort ver1 = (ushort)ifp.ReadByte();
if (ver0 == 0x49 || ver1 == 0x58)
{
ifp.Seek(2110, SeekOrigin.Current);
}
if (ver0 == 0x46)
{
huff = 2;
}
if (state.tiff_bps == 14)
{
huff += 3;
}
vpred[0, 0] = ifp.get2();
vpred[0, 1] = ifp.get2();
vpred[1, 0] = ifp.get2();
vpred[1, 1] = ifp.get2();
int max = 1 << state.tiff_bps & 0x7fff;
if ((csize = ifp.get2()) > 1)
{
step = max / (csize - 1);
}
if (ver0 == 0x44 && ver1 == 0x20 && step > 0)
{
int i;
for (i = 0; i < csize; i++)
{
state.curve[i * step] = ifp.get2();
}
for (i = 0; i < max; i++)
{
state.curve[i] = (ushort)((state.curve[i - i % step] * (step - i % step) + state.curve[i - i % step + step] * (i % step)) / step);
}
ifp.Seek(state.meta_offset + 562, SeekOrigin.Begin);
split = ifp.get2();
}
else if (ver0 != 0x46 && csize <= 0x4001)
{
max = csize;
ifp.ReadShorts(state.curve, max);
}
int tempIdx = 0;
HuffmanTree htree = new HuffmanTree(nikon_tree[huff], ref tempIdx);
ifp.Seek(state.data_offset, SeekOrigin.Begin);
ifp.ResetBits();
for (row = 0; row < state.height; row++)
{
if (split != 0 && row == split)
{
tempIdx = 0;
htree = new HuffmanTree(nikon_tree[huff], ref tempIdx);
}
for (int col = 0; col < state.raw_width; col++)
{
int leaf = htree.ReadNextSymbolLength(ifp);
int len = leaf & 15;
int shl = leaf >> 4;
int diff = (((int)ifp.GetBits(len - shl) << 1) + 1) << shl >> 1;
if ((diff & (1 << (len - 1))) == 0)
{
diff -= (1 << len) - (shl == 0 ? 1 : 0);
}
if (col < 2)
{
vpred[row & 1, col] = (ushort)(vpred[row & 1, col] + diff);
hpred[col] = vpred[row & 1, col];
}
else
{
hpred[col & 1] = (ushort)(hpred[col & 1] + diff);
}
if (hpred[col & 1] >= max)
{
throw new Exception("derror()");
}
if ((uint)(col - state.left_margin) < state.width)
{
state.BAYER_set(row, col - state.left_margin, state.curve[hpred[col & 1] & 0x3fff]);
}
}
}
}
// Format of the dynamic block header:
// 5 Bits: HLIT, # of Literal/Length codes - 257 (257 - 286)
// 5 Bits: HDIST, # of Distance codes - 1 (1 - 32)
// 4 Bits: HCLEN, # of Code Length codes - 4 (4 - 19)
//
// (HCLEN + 4) x 3 bits: code lengths for the code length
// alphabet given just above, in the order: 16, 17, 18,
// 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
//
// These code lengths are interpreted as 3-bit integers
// (0-7); as above, a code length of 0 means the
// corresponding symbol (literal/length or distance code
// length) is not used.
//
// HLIT + 257 code lengths for the literal/length alphabet,
// encoded using the code length Huffman code
//
// HDIST + 1 code lengths for the distance alphabet,
// encoded using the code length Huffman code
//
// The code length repeat codes can cross from HLIT + 257 to the
// HDIST + 1 code lengths. In other words, all code lengths form
// a single sequence of HLIT + HDIST + 258 values.
private bool DecodeDynamicBlockHeader()
{
switch (_state)
{
case InflaterState.ReadingNumLitCodes:
_literalLengthCodeCount = _input.GetBits(5);
if (_literalLengthCodeCount < 0)
{
return false;
}
_literalLengthCodeCount += 257;
_state = InflaterState.ReadingNumDistCodes;
goto case InflaterState.ReadingNumDistCodes;
case InflaterState.ReadingNumDistCodes:
_distanceCodeCount = _input.GetBits(5);
if (_distanceCodeCount < 0)
{
return false;
}
_distanceCodeCount += 1;
_state = InflaterState.ReadingNumCodeLengthCodes;
goto case InflaterState.ReadingNumCodeLengthCodes;
case InflaterState.ReadingNumCodeLengthCodes:
_codeLengthCodeCount = _input.GetBits(4);
if (_codeLengthCodeCount < 0)
{
return false;
}
_codeLengthCodeCount += 4;
_loopCounter = 0;
_state = InflaterState.ReadingCodeLengthCodes;
goto case InflaterState.ReadingCodeLengthCodes;
case InflaterState.ReadingCodeLengthCodes:
while (_loopCounter < _codeLengthCodeCount)
{
var bits = _input.GetBits(3);
if (bits < 0)
{
return false;
}
_codeLengthTreeCodeLength[_codeOrder[_loopCounter]] = (byte)bits;
++_loopCounter;
}
for (var i = _codeLengthCodeCount; i < _codeOrder.Length; i++)
{
_codeLengthTreeCodeLength[_codeOrder[i]] = 0;
}
// create huffman tree for code length
_codeLengthTree = new HuffmanTree(_codeLengthTreeCodeLength);
_codeArraySize = _literalLengthCodeCount + _distanceCodeCount;
_loopCounter = 0; // reset loop count
_state = InflaterState.ReadingTreeCodesBefore;
goto case InflaterState.ReadingTreeCodesBefore;
case InflaterState.ReadingTreeCodesBefore:
case InflaterState.ReadingTreeCodesAfter:
while (_loopCounter < _codeArraySize)
{
if (_state == InflaterState.ReadingTreeCodesBefore)
{
if ((_lengthCode = _codeLengthTree.GetNextSymbol(_input)) < 0)
{
return false;
}
}
// The alphabet for code lengths is as follows:
// 0 - 15: Represent code lengths of 0 - 15
// 16: Copy the previous code length 3 - 6 times.
// The next 2 bits indicate repeat length
// (0 = 3, ... , 3 = 6)
// Example: Codes 8, 16 (+2 bits 11),
// 16 (+2 bits 10) will expand to
// 12 code lengths of 8 (1 + 6 + 5)
// 17: Repeat a code length of 0 for 3 - 10 times.
// (3 bits of length)
// 18: Repeat a code length of 0 for 11 - 138 times
// (7 bits of length)
if (_lengthCode <= 15)
{
_codeList[_loopCounter++] = (byte)_lengthCode;
}
else
{
if (!_input.EnsureBitsAvailable(7))
{ // it doesn't matter if we require more bits here
_state = InflaterState.ReadingTreeCodesAfter;
return false;
}
int repeatCount;
switch (_lengthCode)
{
case 16:
{
if (_loopCounter == 0)
throw new InvalidDataContractException();
var previousCode = _codeList[_loopCounter - 1];
repeatCount = _input.GetBits(2) + 3;
if (_loopCounter + repeatCount > _codeArraySize)
throw new InvalidDataContractException();
for (var j = 0; j < repeatCount; j++)
_codeList[_loopCounter++] = previousCode;
}
break;
case 17:
repeatCount = _input.GetBits(3) + 3;
if (_loopCounter + repeatCount > _codeArraySize)
throw new InvalidDataContractException();
for (var j = 0; j < repeatCount; j++)
_codeList[_loopCounter++] = 0;
break;
default:
repeatCount = _input.GetBits(7) + 11;
if (_loopCounter + repeatCount > _codeArraySize)
throw new InvalidDataContractException();
for (var j = 0; j < repeatCount; j++)
_codeList[_loopCounter++] = 0;
break;
}
}
_state = InflaterState.ReadingTreeCodesBefore; // we want to read the next code.
}
break;
default:
throw new InvalidDataContractException("Unknown state.");
}
var literalTreeCodeLength = new byte[HuffmanTree.MaxLiteralTreeElements];
var distanceTreeCodeLength = new byte[HuffmanTree.MaxDistTreeElements];
// Create literal and distance tables
Array.Copy(_codeList, literalTreeCodeLength, _literalLengthCodeCount);
Array.Copy(_codeList, _literalLengthCodeCount, distanceTreeCodeLength, 0, _distanceCodeCount);
// Make sure there is an end-of-block code, otherwise how could we ever end?
if (literalTreeCodeLength[HuffmanTree.EndOfBlockCode] == 0)
throw new InvalidDataContractException();
_literalLengthTree = new HuffmanTree(literalTreeCodeLength);
_distanceTree = new HuffmanTree(distanceTreeCodeLength);
_state = InflaterState.DecodeTop;
return true;
}
//Each block of compressed data begins with 3 header bits
// containing the following data:
// first bit BFINAL
// next 2 bits BTYPE
// Note that the header bits do not necessarily begin on a byte
// boundary, since a block does not necessarily occupy an integral
// number of bytes.
// BFINAL is set if and only if this is the last block of the data
// set.
// BTYPE specifies how the data are compressed, as follows:
// 00 - no compression
// 01 - compressed with fixed Huffman codes
// 10 - compressed with dynamic Huffman codes
// 11 - reserved (error)
// The only difference between the two compressed cases is how the
// Huffman codes for the literal/length and distance alphabets are
// defined.
//
// This function returns true for success (end of block or output window is full,)
// false if we are short of input
//
private bool Decode()
{
var eob = false;
var result = false;
if (Finished())
{
return true;
}
if (_hasFormatReader)
{
switch (_state)
{
case InflaterState.ReadingHeader:
if (!_formatReader.ReadHeader(_input))
{
return false;
}
_state = InflaterState.ReadingBFinal;
break;
case InflaterState.ReadingFooter:
case InflaterState.StartReadingFooter:
if (!_formatReader.ReadFooter(_input))
return false;
_state = InflaterState.VerifyingFooter;
return true;
}
}
if (_state == InflaterState.ReadingBFinal)
{ // reading bfinal bit
// Need 1 bit
if (!_input.EnsureBitsAvailable(1))
return false;
_bfinal = _input.GetBits(1);
_state = InflaterState.ReadingBType;
}
if (_state == InflaterState.ReadingBType)
{
// Need 2 bits
if (!_input.EnsureBitsAvailable(2))
{
_state = InflaterState.ReadingBType;
return false;
}
_blockType = (BlockType)_input.GetBits(2);
switch (_blockType)
{
case BlockType.Dynamic:
_state = InflaterState.ReadingNumLitCodes;
break;
case BlockType.Static:
_literalLengthTree = HuffmanTree.StaticLiteralLengthTree;
_distanceTree = HuffmanTree.StaticDistanceTree;
_state = InflaterState.DecodeTop;
break;
case BlockType.Uncompressed:
_state = InflaterState.UncompressedAligning;
break;
default:
throw new InvalidDataContractException("Unknown block type.");
}
}
switch (_blockType)
{
case BlockType.Dynamic:
result = _state < InflaterState.DecodeTop ? DecodeDynamicBlockHeader() : DecodeBlock(out eob);
break;
case BlockType.Static:
result = DecodeBlock(out eob);
break;
case BlockType.Uncompressed:
result = DecodeUncompressedBlock(out eob);
break;
default:
throw new InvalidDataContractException("Unknown block type.");
}
//
// If we reached the end of the block and the block we were decoding had
// bfinal=1 (final block)
//
if (!eob || (_bfinal == 0))
return result;
_state = _hasFormatReader ? InflaterState.StartReadingFooter : InflaterState.Done;
return result;
}
public VisualisationHandler(VisualiseOptions options)
{
_options = options;
_tree = new HuffmanTree();
}
private void ReadMainTree()
{
uint[] lengths;
if (_mainTree == null)
{
lengths = new uint[256 + (8 * _numPositionSlots)];
}
else
{
lengths = _mainTree.Lengths;
}
HuffmanTree preTree = ReadFixedHuffmanTree(20, 4);
ReadLengths(preTree, lengths, 0, 256);
preTree = ReadFixedHuffmanTree(20, 4);
ReadLengths(preTree, lengths, 256, 8 * _numPositionSlots);
_mainTree = new HuffmanTree(lengths);
}
public HuffmanCoding(HuffmanTree huffmantree)
{
this.Huffman = huffmantree;
}
private void ReadLengthTree()
{
HuffmanTree preTree = ReadFixedHuffmanTree(20, 4);
_lengthTree = ReadDynamicHuffmanTree(249, preTree, _lengthTree);
}
unsafe private static void AddRef(HuffmanTree huff, byte ch)
{
if (huff.loc[ch] == null)
{
fixed(HuffmanNode *tnode = &huff.nodeList[huff.blocNode++])
{
fixed(HuffmanNode *tnode2 = &huff.nodeList[huff.blocNode++])
{
tnode2->symbol = CConstVar.HUFF_INTERNAL_NODE;
tnode2->weight = 1;
tnode2->next = huff.lhead->next;
if (huff.lhead->next != null)
{
huff.lhead->next->prev = tnode2;
if (huff.lhead->next->weight == 1)
{
tnode2->head = huff.lhead->next->head;
}
else
{
tnode2->head = GetPPNode(huff);
*tnode2->head = tnode2;
}
}
else
{
tnode2->head = GetPPNode(huff);
// tnode2.head.ptr = tnode2;
// Marshal.StructureToPtr(tnode2, tnode2.head.ptr, false) ;
*tnode2->head = tnode2;
}
huff.lhead->next = tnode2;
tnode2->prev = huff.lhead;
tnode->symbol = ch;
tnode->weight = 1;
tnode->next = huff.lhead->next;
if (huff.lhead->next != null)
{
huff.lhead->next->prev = tnode;
// CLog.Info("weight:{0}", huff.lhead->next->weight);
if (huff.lhead->next->weight == 1)
{
tnode->head = huff.lhead->next->head;
}
else
{
CLog.Error("should never happen 1");
tnode->head = GetPPNode(huff);
// tnode.head.ptr = tnode2;
// Marshal.StructureToPtr(tnode2, tnode->head.ptr, false) ;
*tnode->head = tnode2;
}
}
else
{
CLog.Error("should never happen 2");
tnode->head = GetPPNode(huff);
// tnode.head.ptr = tnode;
// Marshal.StructureToPtr(tnode, tnode.head.ptr, false) ;
*tnode->head = tnode;
}
huff.lhead->next = tnode;
tnode->prev = huff.lhead;
tnode->left = tnode->right = null;
if (huff.lhead->parent != null)
{
if (huff.lhead->parent->left == huff.lhead)
{
huff.lhead->parent->left = tnode2;
}
else
{
huff.lhead->parent->right = tnode2;
}
}
else
{
huff.tree = tnode2;
}
tnode2->right = tnode;
tnode2->left = huff.lhead;
tnode2->parent = huff.lhead->parent;
huff.lhead->parent = tnode->parent = tnode2;
huff.loc[ch] = tnode;
Increment(huff, tnode2->parent);
}
}
}
else
{
Increment(huff, huff.loc[ch]);
}
}
private void ReadLengths(HuffmanTree preTree, uint[] lengths, int offset, int count)
{
int i = 0;
while (i < count)
{
uint value = preTree.NextSymbol(_bitStream);
if (value == 17)
{
uint numZeros = 4 + _bitStream.Read(4);
for (uint j = 0; j < numZeros; ++j)
{
lengths[offset + i] = 0;
++i;
}
}
else if (value == 18)
{
uint numZeros = 20 + _bitStream.Read(5);
for (uint j = 0; j < numZeros; ++j)
{
lengths[offset + i] = 0;
++i;
}
}
else if (value == 19)
{
uint same = _bitStream.Read(1);
value = preTree.NextSymbol(_bitStream);
if (value > 16)
{
throw new InvalidDataException("Invalid table encoding");
}
uint symbol = (17 + lengths[offset + i] - value) % 17;
for (uint j = 0; j < 4 + same; ++j)
{
lengths[offset + i] = symbol;
++i;
}
}
else
{
lengths[offset + i] = (17 + lengths[offset + i] - value) % 17;
++i;
}
}
}
unsafe public static void OffsetTransmit(HuffmanTree huff, int ch, byte[] fout, ref int offset)
{
bloc = offset;
Send(huff.loc[ch], null, fout);
offset = bloc;
}
private void DecodeCompressedBlock(BlockType blockType, int blockSize)
{
if (blockType == BlockType.AlignedOffset)
{
_alignedOffsetTree = ReadFixedHuffmanTree(8, 3);
}
ReadMainTree();
ReadLengthTree();
uint numRead = 0;
while (numRead < (uint)blockSize)
{
uint symbol = _mainTree.NextSymbol(_bitStream);
if (symbol < 256)
{
_buffer[_bufferCount + numRead++] = (byte)symbol;
}
else
{
uint lengthHeader = (symbol - 256) & 7;
uint matchLength = lengthHeader + 2 + ((lengthHeader == 7) ? _lengthTree.NextSymbol(_bitStream) : 0);
uint positionSlot = (symbol - 256) >> 3;
uint matchOffset;
if (positionSlot == 0)
{
matchOffset = _repeatedOffsets[0];
}
else if (positionSlot == 1)
{
matchOffset = _repeatedOffsets[1];
_repeatedOffsets[1] = _repeatedOffsets[0];
_repeatedOffsets[0] = matchOffset;
}
else if (positionSlot == 2)
{
matchOffset = _repeatedOffsets[2];
_repeatedOffsets[2] = _repeatedOffsets[0];
_repeatedOffsets[0] = matchOffset;
}
else
{
int extra = (int)s_extraBits[positionSlot];
uint formattedOffset;
if (blockType == BlockType.AlignedOffset)
{
uint verbatimBits = 0;
uint alignedBits = 0;
if (extra >= 3)
{
verbatimBits = _bitStream.Read(extra - 3) << 3;
alignedBits = _alignedOffsetTree.NextSymbol(_bitStream);
}
else if (extra > 0)
{
verbatimBits = _bitStream.Read(extra);
}
formattedOffset = s_positionSlots[positionSlot] + verbatimBits + alignedBits;
}
else
{
uint verbatimBits = (extra > 0) ? _bitStream.Read(extra) : 0;
formattedOffset = s_positionSlots[positionSlot] + verbatimBits;
}
matchOffset = formattedOffset - 2;
_repeatedOffsets[2] = _repeatedOffsets[1];
_repeatedOffsets[1] = _repeatedOffsets[0];
_repeatedOffsets[0] = matchOffset;
}
int destOffset = _bufferCount + (int)numRead;
int srcOffset = destOffset - (int)matchOffset;
for (int i = 0; i < matchLength; ++i)
{
_buffer[destOffset + i] = _buffer[srcOffset + i];
}
numRead += matchLength;
}
}
}
public void Read(byte[] cBytes, byte[] mBytes, byte[] yBytes, FileStream fStream)
{
//Reading Dictionary Length
byte[] dictionaryHeader = new byte[2];
fStream.Read(dictionaryHeader, 0, 2);
short dictionaryLength = BitConverter.ToInt16(dictionaryHeader, 0);
Dictionary <HFCode, byte> readTable = new Dictionary <HFCode, byte>();
//Reading Values and Code Lengths
byte[] valueAndCodeLength = new byte[3 * dictionaryLength];
fStream.Read(valueAndCodeLength, 0, 3 * dictionaryLength);
//Reading Values and Codes
BitStream bitStream = new BitStream(fStream);
for (int i = 0; i < dictionaryLength; ++i)
{
byte value = valueAndCodeLength[3 * i];
ushort codeLength = BitConverter.ToUInt16(valueAndCodeLength, 3 * i + 1);
BitArray bits = bitStream.ReadBits(codeLength);
HFCode code = HFCode.FromBits(bits);
readTable.Add(code, value);
}
//Reconstruct tree
HuffmanTree <byte> hfTree = HuffmanTree <byte> .ReconstructFromTable(readTable);
//hfTree.PrintTree();
//Read values to bytes
int bufferSize = 128;
BitArray buffer = bitStream.ReadBits(bufferSize);
int bufferIndex = 0;
for (int i = 0; i < cBytes.Length; ++i)
{
HuffmanTreeNode curNode = hfTree.root;
while (!(curNode is HuffmanLeafNode <byte>))
{
if (bufferIndex == buffer.Length)
{
buffer = bitStream.ReadBits(buffer.Length);
bufferIndex = 0;
}
curNode = (buffer[bufferIndex]) ? curNode.right : curNode.left;
bufferIndex++;
}
cBytes[i] = ((HuffmanLeafNode <byte>)curNode).info;
}
for (int i = 0; i < mBytes.Length; ++i)
{
HuffmanTreeNode curNode = hfTree.root;
while (!(curNode is HuffmanLeafNode <byte>))
{
if (bufferIndex == buffer.Length)
{
buffer = bitStream.ReadBits(buffer.Length);
bufferIndex = 0;
}
curNode = (buffer[bufferIndex]) ? curNode.right : curNode.left;
bufferIndex++;
}
mBytes[i] = ((HuffmanLeafNode <byte>)curNode).info;
}
for (int i = 0; i < yBytes.Length; ++i)
{
HuffmanTreeNode curNode = hfTree.root;
while (!(curNode is HuffmanLeafNode <byte>))
{
if (bufferIndex == buffer.Length)
{
buffer = bitStream.ReadBits(buffer.Length);
bufferIndex = 0;
}
curNode = (buffer[bufferIndex]) ? curNode.right : curNode.left;
bufferIndex++;
}
yBytes[i] = ((HuffmanLeafNode <byte>)curNode).info;
}
fStream.Close();
}
static void Main(string[] args)
{
Console.WriteLine("Veuillez entrer les éléments de facturation du client :");
string input = Console.ReadLine();
HuffmanTree huffmanTree = new HuffmanTree();
// Construire l'arbre de huffman
huffmanTree.Build(input);
// Encoder
BitArray encoded = huffmanTree.Encode(input);
//on retourne le nombre d'octets du message lu au clavier
Console.WriteLine();
Console.WriteLine("Votre texte est de " + input.Length + " octets");
//on ouvre une session de connexion sur gmail à travers smtp
try
{
MailMessage mail = new MailMessage();
SmtpClient SmtpServer = new SmtpClient("smtp.gmail.com");
mail.From = new MailAddress("*****@*****.**"); //expéditeur
mail.To.Add("*****@*****.**"); //recepteur
mail.Subject = "Informations client"; //objet
//ic on affiche d'abord le message compréssé chez l'expéditeur
Console.WriteLine();
int cpt = 0; //j'initialise un compte ici pour avoir le nombre de bit à la fin de la compression
Console.Write("Compressé: ");
foreach (bool bit in encoded)
{
Console.Write((bit ? 1 : 0) + "");
cpt = cpt + 1;
}
Console.WriteLine();
Console.WriteLine("le texte compréssé est de " + (cpt / 8 + 1) + " octets");
Console.WriteLine();
Console.WriteLine("En cours d'envoi à " + mail.To + "...");
/*foreach (bool bit in encoded)
* {
* mail.Body = (bit ? 1 : 0) + "";
* }
* Console.WriteLine();*/
string chaine;
string message = "";
foreach (bool bit in encoded)
{
chaine = (bit ? 1 : 0) + "";
message = $"{message}{chaine}";
}
mail.Body = message;
SmtpServer.Port = 587;
SmtpServer.Credentials = new System.Net.NetworkCredential("*****@*****.**", "testisj2019");
SmtpServer.EnableSsl = true;
Console.WriteLine();
SmtpServer.Send(mail);
Console.WriteLine("Votre mail à été envoyé avec succes!!!");//Message succes
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
//cette partie du code permet de lire les mails de l'adresse passée en paramètre
try
{
using (Pop3 pop3 = new Pop3())
{
pop3.ConnectSSL("pop.gmail.com"); // or ConnectSSL for SSL
pop3.Login("*****@*****.**", "mayelle2010");
List <string> uids = pop3.GetAll();
foreach (string uid in uids)
{
IMail email = new MailBuilder()
.CreateFromEml(pop3.GetMessageByUID(uid));
Console.WriteLine("");
Console.WriteLine(email.Date);
Console.WriteLine(email.From);
Console.WriteLine(email.Subject);
}
pop3.Close();
}
}
catch (Limilabs.Client.ServerException e)
{
Console.WriteLine(e.ToString());
}
}
private byte[] Buffer(int count)
{
byte[] buffer = new byte[count];
int numRead = 0;
HuffmanTree tree = ReadHuffmanTree();
XpressBitStream bitStream = new XpressBitStream(_compressedStream);
while (numRead < count)
{
uint symbol = tree.NextSymbol(bitStream);
if (symbol < 256)
{
// The first 256 symbols are literal byte values
buffer[numRead] = (byte)symbol;
numRead++;
}
else
{
// The next 256 symbols are 4 bits each for offset and length.
int offsetBits = (int)((symbol - 256) / 16);
int len = (int)((symbol - 256) % 16);
// The actual offset
int offset = (int)((1 << offsetBits) - 1 + bitStream.Read(offsetBits));
// Lengths up to 15 bytes are stored directly in the symbol bits, beyond that
// the length is stored in the compression stream.
if (len == 15)
{
// Note this access is directly to the underlying stream - we're not going
// through the bit stream. This makes the precise behaviour of the bit stream,
// in terms of read-ahead critical.
int b = ReadCompressedByte();
if (b == 0xFF)
{
// Again, note this access is directly to the underlying stream - we're not going
// through the bit stream.
len = ReadCompressedUShort();
}
else
{
len += b;
}
}
// Minimum length for a match is 3 bytes, so all lengths are stored as an offset
// from 3.
len += 3;
// Simply do the copy
for (int i = 0; i < len; ++i)
{
buffer[numRead] = buffer[numRead - offset - 1];
numRead++;
}
}
}
return(buffer);
}
static void Main(string[] args)
{
int action;
string inputFilePath;
string inputFileName;
string outputFileName;
int.TryParse(args[0], out action);
if (args.Length < 4 || (args.Length == 4 && action != 1 && action != 2))
{
action = 0;
Console.WriteLine("Please choose option:");
Console.WriteLine("1 - encode");
Console.WriteLine("2 - decode");
string option = Console.ReadLine();
action = int.Parse(option);
while (action != 1 && action != 2)
{
Console.WriteLine("there is no such option");
Console.WriteLine("1 - encode");
Console.WriteLine("2 - decode");
option = Console.ReadLine();
action = int.Parse(option);
}
Console.WriteLine("Please enter the full path of the input file");
inputFilePath = Console.ReadLine();
Console.WriteLine("Please enter the name of the input file");
inputFileName = Console.ReadLine();
Console.WriteLine("Please enter the name of the output file");
outputFileName = Console.ReadLine();
}
else
{
action = int.Parse(args[0]);
inputFilePath = args[1];
inputFileName = args[2];
outputFileName = args[3];
}
string inputFileFullName = inputFilePath + "\\" + inputFileName;
string outputFileFullName = inputFilePath + "\\" + outputFileName;
bool isSucceeded;
if (action == 1 || action == 2)
{
if (action == 1)
{
isSucceeded = HuffmanTree.Encode(inputFileFullName, outputFileFullName);
}
else
{
isSucceeded = HuffmanTree.Decode(inputFileFullName, outputFileFullName);
}
Console.WriteLine(isSucceeded ? "The operation was successful" : "Operation failed, check if the input file exist");
}
}
