unsafe private static void Increment(HuffmanTree huff, HuffmanNode *node)
{
HuffmanNode *lnode;
if (node == null)
{
return;
}
if (node->next != null && node->next->weight == node->weight)
{
// lnode = (HuffmanNode)Marshal.PtrToStructure(node->head, typeof(HuffmanNode)) ;
lnode = *node->head;
if (lnode != node->parent)
{
Swap(huff, lnode, node);
}
Swaplist(lnode, node);
}
if (node->prev != null && node->prev->weight == node->weight)
{
// Marshal.StructureToPtr(node->prev, node->head.ptr, false) ;
*node->head = node->prev;
}
else
{
*node->head = null;
FreePPNode(huff, node->head);
}
node->weight++;
if (node->next != null && node->next->weight == node->weight)
{
node->head = node->next->head;
}
else
{
node->head = GetPPNode(huff);
// node.head.ptr = node;
// Marshal.StructureToPtr(node, node.head.ptr, false) ;
*node->head = node;
}
if (node->parent != null)
{
Increment(huff, node->parent);
if (node->prev == node->parent)
{
Swaplist(node, node->parent);
// var ptr = new IntPtr();
// Marshal.StructureToPtr(node,ptr,false);
if (*node->head == node)
{
// Marshal.StructureToPtr(node.parent,node.head.ptr,false) ;
*node->head = node->parent;
}
}
}
}
unsafe public HuffmanTree(bool isCompresser)
{
loc = new HuffmanNode *[CConstVar.HUFF_MAX + 1];
// for(int i = 0; i < CConstVar.HUFF_MAX+1; i ++){
// loc[i] = new HuffmanNode();
// }
blocNode = 0;
blocPtrs = 0;
nodeList = new HuffmanNode[768];
for (int i = 0; i < 768; i++)
{
nodeList[i] = new HuffmanNode();
}
nodePtrs = new HuffmanNode *[768];
// for(int i = 0; i < 768; i++){
// nodePtrs[i] = new HuffNodePtr();
// }
// huffmanMsg.compresser.loc = new HuffmanNode[768];
fixed(HuffmanNode *tmp = &nodeList[blocNode++])
{
if (isCompresser)
{
tree = lhead = loc[CConstVar.HUFF_MAX] = tmp;
ltail = null;
}
else
{
tree = lhead = ltail = loc[CConstVar.HUFF_MAX] = tmp;
}
}
freeList = null;
// freeList = new HuffNodePtr();
tree->symbol = CConstVar.HUFF_MAX;
tree->weight = 0;
lhead->next = lhead->prev = null;
tree->parent = tree->left = tree->right = null;
if (isCompresser)
{
loc[CConstVar.HUFF_MAX] = tree;
}
}
unsafe private static void Send(HuffmanNode *node, HuffmanNode *child, byte[] fout)
{
if (node->parent != null)
{
Send(node->parent, node, fout);
}
if (child != null)
{
if (node->right == child)
{
AddBit((char)1, fout);
}
else
{
AddBit((char)0, fout);
}
}
}
unsafe private static void Swap(HuffmanTree huff, HuffmanNode *node1, HuffmanNode *node2)
{
HuffmanNode *par1;
HuffmanNode *par2;
par1 = node1->parent;
par2 = node2->parent;
if (par1 != null)
{
if (par1->left == node1)
{
par1->left = node2;
}
else
{
par1->right = node2;
}
}
else
{
huff.tree = node2;
}
if (par2 != null)
{
if (par2->left == node2)
{
par2->left = node1;
}
else
{
par2->right = node1;
}
}
else
{
huff.tree = node1;
}
node1->parent = par2;
node1->parent = par1;
}
unsafe public static void OffsetReceive(HuffmanNode *node, ref int ch, byte[] fin, ref int offset)
{
bloc = offset;
while (node != null && node->symbol == CConstVar.HUFF_INTERNAL_NODE)
{
if (GetBit(fin) != 0)
{
node = node->right;
}
else
{
node = node->left;
}
}
if (node == null)
{
ch = 0;
return;
}
ch = node->symbol;
offset = bloc;
}
unsafe private static void Swaplist(HuffmanNode *node1, HuffmanNode *node2)
{
HuffmanNode *par1;
par1 = node1->next;
node1->next = node2->next;
node2->next = par1;
par1 = node1->prev;
node1->prev = node2->prev;
node2->prev = par1;
if (node1->next == node1)
{
node1->next = node2;
}
if (node2->next == node2)
{
node2->next = node1;
}
if (node1->next != null)
{
node1->next->prev = node1;
}
if (node2->next != null)
{
node2->next->prev = node2;
}
if (node1->prev != null)
{
node1->prev->next = node1;
}
if (node2->prev != null)
{
node2->prev->next = node2;
}
}
