/* Do the increments */
static void increment(huff_t *huff, node_t *node)
{
node_t *lnode;
if (!node)
{
return;
}
if (node->next != NULL && node->next->weight == node->weight)
{
lnode = *node->head;
if (lnode != node->parent)
{
swap(huff, lnode, node);
}
swaplist(lnode, node);
}
if (node->prev && node->prev->weight == node->weight)
{
*node->head = node->prev;
}
else
{
*node->head = NULL;
free_ppnode(huff, node->head);
}
node->weight++;
if (node->next && node->next->weight == node->weight)
{
node->head = node->next->head;
}
else
{
node->head = get_ppnode(huff);
*node->head = node;
}
if (node->parent)
{
increment(huff, node->parent);
if (node->prev == node->parent)
{
swaplist(node, node->parent);
if (*node->head == node)
{
*node->head = node->parent;
}
}
}
}
static node_t **get_ppnode(huff_t *huff)
{
node_t **tppnode;
if (!huff->freelist)
{
return(&(huff->nodePtrs[huff->blocPtrs++]));
}
else
{
tppnode = huff->freelist;
huff->freelist = (node_t **)*tppnode;
return(tppnode);
}
}
/* Send a symbol */
void Huff_transmit(huff_t *huff, int ch, byte *fout)
{
int i;
if (huff->loc[ch] == NULL)
{
/* node_t hasn't been transmitted, send a NYT, then the symbol */
Huff_transmit(huff, NYT, fout);
for (i = 7; i >= 0; i--)
{
add_bit((char)((ch >> i) & 0x1), fout);
}
}
else
{
send(huff->loc[ch], NULL, fout);
}
}
/* Swap the location of these two nodes in the tree */
static void swap(huff_t *huff, node_t *node1, node_t *node2)
{
node_t *par1, *par2;
par1 = node1->parent;
par2 = node2->parent;
if (par1)
{
if (par1->left == node1)
{
par1->left = node2;
}
else
{
par1->right = node2;
}
}
else
{
huff->tree = node2;
}
if (par2)
{
if (par2->left == node2)
{
par2->left = node1;
}
else
{
par2->right = node1;
}
}
else
{
huff->tree = node1;
}
node1->parent = par2;
node2->parent = par1;
}
static void free_ppnode(huff_t *huff, node_t **ppnode)
{
*ppnode = (node_t *)huff->freelist;
huff->freelist = ppnode;
}
void Huff_offsetTransmit(huff_t *huff, int ch, byte *fout, int *offset)
{
bloc = *offset;
send(huff->loc[ch], NULL, fout);
*offset = bloc;
}
void Huff_addRef(huff_t *huff, byte ch)
{
node_t *tnode, *tnode2;
if (huff->loc[ch] == NULL) /* if this is the first transmission of this node */
{
tnode = &(huff->nodeList[huff->blocNode++]);
tnode2 = &(huff->nodeList[huff->blocNode++]);
tnode2->symbol = INTERNAL_NODE;
tnode2->weight = 1;
tnode2->next = huff->lhead->next;
if (huff->lhead->next)
{
huff->lhead->next->prev = tnode2;
if (huff->lhead->next->weight == 1)
{
tnode2->head = huff->lhead->next->head;
}
else
{
tnode2->head = get_ppnode(huff);
*tnode2->head = tnode2;
}
}
else
{
tnode2->head = get_ppnode(huff);
*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)
{
huff->lhead->next->prev = tnode;
if (huff->lhead->next->weight == 1)
{
tnode->head = huff->lhead->next->head;
}
else
{
/* this should never happen */
tnode->head = get_ppnode(huff);
*tnode->head = tnode2;
}
}
else
{
/* this should never happen */
tnode->head = get_ppnode(huff);
*tnode->head = tnode;
}
huff->lhead->next = tnode;
tnode->prev = huff->lhead;
tnode->left = tnode->right = NULL;
if (huff->lhead->parent)
{
if (huff->lhead->parent->left == huff->lhead) /* lhead is guaranteed to by the NYT */
{
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]);
}
}
