225 lines
5.4 KiB
C
225 lines
5.4 KiB
C
|
/*
|
||
|
|
* Table-building routines
|
||
|
|
*
|
||
|
|
* make_table() is based on ** Public Domain ** source "AR001.ZIP".
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <memory.h>
|
||
|
|
#pragma intrinsic(memset)
|
||
|
|
|
||
|
|
#include "decoder.h"
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Make a decoding table for decoding nchar possible Huffman elements
|
||
|
|
* with bit lengths given by bitlen.
|
||
|
|
*
|
||
|
|
* Output the main lookup table into table[] and use leftright[] for
|
||
|
|
* supplementary information (for bitlengths > tablebits).
|
||
|
|
*
|
||
|
|
* The size of table[] is tablebits elements.
|
||
|
|
*/
|
||
|
|
#ifndef ASM_MAKE_TABLE
|
||
|
|
bool NEAR __cdecl make_table(
|
||
|
|
t_decoder_context *context,
|
||
|
|
int nchar,
|
||
|
|
const byte *bitlen,
|
||
|
|
byte tablebits,
|
||
|
|
short *table,
|
||
|
|
short *leftright
|
||
|
|
)
|
||
|
|
{
|
||
|
|
uint i;
|
||
|
|
int ch;
|
||
|
|
short * p;
|
||
|
|
uint count[17], weight[17], start[18];
|
||
|
|
int avail;
|
||
|
|
uint nextcode;
|
||
|
|
uint k;
|
||
|
|
byte len;
|
||
|
|
byte jutbits;
|
||
|
|
|
||
|
|
for (i = 1; i <= 16; i++)
|
||
|
|
count[i] = 0;
|
||
|
|
|
||
|
|
/* count the number of elements of each bit length */
|
||
|
|
for (i = 0; i < (uint) nchar; i++)
|
||
|
|
count[bitlen[i]]++;
|
||
|
|
|
||
|
|
start[1] = 0;
|
||
|
|
|
||
|
|
for (i = 1; i <= 16; i++)
|
||
|
|
start[i + 1] = start[i] + (count[i] << (16 - i));
|
||
|
|
|
||
|
|
#ifdef BIT16
|
||
|
|
if (start[17])
|
||
|
|
{
|
||
|
|
return false; /* bad table */
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
if (start[17] != 65536)
|
||
|
|
{
|
||
|
|
if (start[17] == 0)
|
||
|
|
{
|
||
|
|
/*
|
||
|
|
* All elements are length zero
|
||
|
|
*/
|
||
|
|
memset(table, 0, sizeof(ushort)*(1 << tablebits));
|
||
|
|
return true; /* success */
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return false; /* bad table */
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
jutbits = 16 - tablebits;
|
||
|
|
|
||
|
|
for (i = 1; i <= tablebits; i++)
|
||
|
|
{
|
||
|
|
start[i] >>= jutbits;
|
||
|
|
weight[i] = 1 << (tablebits - i);
|
||
|
|
}
|
||
|
|
|
||
|
|
while (i <= 16)
|
||
|
|
{
|
||
|
|
weight[i] = 1 << (16 - i);
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
|
||
|
|
i = start[tablebits+1] >> jutbits;
|
||
|
|
|
||
|
|
#ifdef BIT16
|
||
|
|
if (i)
|
||
|
|
#else
|
||
|
|
if (i != 65536)
|
||
|
|
#endif
|
||
|
|
{
|
||
|
|
memset(
|
||
|
|
&table[i],
|
||
|
|
0,
|
||
|
|
sizeof(ushort)*((1 << tablebits)-i)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
avail = nchar;
|
||
|
|
|
||
|
|
for (ch = 0; ch < nchar; ch++)
|
||
|
|
{
|
||
|
|
if ((len = bitlen[ch]) == 0)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
nextcode = start[len] + weight[len];
|
||
|
|
|
||
|
|
if (len <= tablebits)
|
||
|
|
{
|
||
|
|
if (nextcode > (uint) (1 << tablebits))
|
||
|
|
return false; /* bad table */
|
||
|
|
|
||
|
|
for (i = start[len]; i < nextcode; i++)
|
||
|
|
table[i] = (short)ch;
|
||
|
|
|
||
|
|
start[len] = nextcode;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
byte i;
|
||
|
|
|
||
|
|
k = start[len];
|
||
|
|
start[len] = nextcode;
|
||
|
|
p = &table[k >> jutbits];
|
||
|
|
|
||
|
|
i = len - tablebits;
|
||
|
|
k <<= tablebits;
|
||
|
|
|
||
|
|
do
|
||
|
|
{
|
||
|
|
if (*p == 0)
|
||
|
|
{
|
||
|
|
leftright[avail*2] = leftright[avail*2+1] = 0;
|
||
|
|
*p = (short) -avail;
|
||
|
|
avail++;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ((signed short) k < 0) // if (k & 32768)
|
||
|
|
p = &leftright[-(*p)*2+1];
|
||
|
|
else
|
||
|
|
p = &leftright[-(*p)*2];
|
||
|
|
|
||
|
|
k <<= 1;
|
||
|
|
i--;
|
||
|
|
} while (i);
|
||
|
|
|
||
|
|
*p = (short)ch;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Specialised make table routine where it is known that there are
|
||
|
|
* only 8 elements (nchar=8) and tablebits=7 (128 byte lookup table).
|
||
|
|
*
|
||
|
|
* Since there can be no overflow, this will be a direct lookup.
|
||
|
|
*
|
||
|
|
* Important difference; the lookup table returns a byte, not a ushort.
|
||
|
|
*/
|
||
|
|
bool NEAR make_table_8bit(t_decoder_context *context, byte bitlen[], byte table[])
|
||
|
|
{
|
||
|
|
ushort count[17], weight[17], start[18];
|
||
|
|
ushort i;
|
||
|
|
ushort nextcode;
|
||
|
|
byte len;
|
||
|
|
byte ch;
|
||
|
|
|
||
|
|
for (i = 1; i <= 16; i++)
|
||
|
|
count[i] = 0;
|
||
|
|
|
||
|
|
for (i = 0; i < 8; i++)
|
||
|
|
count[bitlen[i]]++;
|
||
|
|
|
||
|
|
start[1] = 0;
|
||
|
|
|
||
|
|
for (i = 1; i <= 16; i++)
|
||
|
|
start[i + 1] = start[i] + (count[i] << (16 - i));
|
||
|
|
|
||
|
|
if (start[17] != 0)
|
||
|
|
return false; /* bad table */
|
||
|
|
|
||
|
|
for (i = 1; i <= 7; i++)
|
||
|
|
{
|
||
|
|
start[i] >>= 9;
|
||
|
|
weight[i] = 1 << (7 - i);
|
||
|
|
}
|
||
|
|
|
||
|
|
while (i <= 16)
|
||
|
|
{
|
||
|
|
weight[i] = 1 << (16 - i);
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
|
||
|
|
memset(table, 0, 1<<7);
|
||
|
|
|
||
|
|
for (ch = 0; ch < 8; ch++)
|
||
|
|
{
|
||
|
|
if ((len = bitlen[ch]) == 0)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
nextcode = start[len] + weight[len];
|
||
|
|
|
||
|
|
if (nextcode > (1 << 7))
|
||
|
|
return false; /* bad table */
|
||
|
|
|
||
|
|
for (i = start[len]; i < nextcode; i++)
|
||
|
|
table[i] = ch;
|
||
|
|
|
||
|
|
start[len] = nextcode;
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|