mirror of
https://github.com/ZDoom/gzdoom.git
synced 2024-11-19 10:50:58 +00:00
403 lines
10 KiB
C++
403 lines
10 KiB
C++
/*
|
|
gunzip.c by Pasi Ojala, a1bert@iki.fi
|
|
http://www.iki.fi/a1bert/
|
|
|
|
A hopefully easier to understand guide to GZip
|
|
(deflate) decompression routine than the GZip
|
|
source code.
|
|
|
|
*/
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
|
|
#include <stdlib.h>
|
|
#include "ancientzip.h"
|
|
|
|
/****************************************************************
|
|
Bit-I/O variables and routines/macros
|
|
|
|
These routines work in the bit level because the target
|
|
environment does not have a barrel shifter. Trying to
|
|
handle several bits at once would've only made the code
|
|
slower.
|
|
|
|
If the environment supports multi-bit shifts, you should
|
|
write these routines again (see e.g. the GZIP sources).
|
|
|
|
[RH] Since the target environment is not a C64, I did as
|
|
suggested and rewrote these using zlib as a reference.
|
|
|
|
****************************************************************/
|
|
|
|
#define READBYTE(c) \
|
|
do { \
|
|
c = 0; \
|
|
if (InLeft) { \
|
|
InLeft--; \
|
|
if (bs < be) \
|
|
c = ReadBuf[bs++]; \
|
|
else { \
|
|
be = In->Read(&ReadBuf, sizeof(ReadBuf)); \
|
|
c = ReadBuf[0]; \
|
|
bs = 1; \
|
|
} \
|
|
} \
|
|
} while (0)
|
|
|
|
/* Get a byte of input into the bit accumulator. */
|
|
#define PULLBYTE() \
|
|
do { \
|
|
unsigned char next; \
|
|
READBYTE(next); \
|
|
Hold += (unsigned int)(next) << Bits; \
|
|
Bits += 8; \
|
|
} while (0)
|
|
|
|
/* Assure that there are at least n bits in the bit accumulator. */
|
|
#define NEEDBITS(n) \
|
|
do { \
|
|
while (Bits < (unsigned)(n)) \
|
|
PULLBYTE(); \
|
|
} while (0)
|
|
|
|
/* Return the low n bits of the bit accumulator (n < 16) */
|
|
#define BITS(n) \
|
|
((unsigned)Hold & ((1U << (n)) - 1))
|
|
|
|
/* Remove n bits from the bit accumulator */
|
|
#define DROPBITS(n) \
|
|
do { \
|
|
Hold >>= (n); \
|
|
Bits -= (unsigned)(n); \
|
|
} while (0)
|
|
|
|
#define READBITS(c, a) \
|
|
do { \
|
|
NEEDBITS(a); \
|
|
c = BITS(a); \
|
|
DROPBITS(a); \
|
|
} while (0)
|
|
|
|
/****************************************************************
|
|
Shannon-Fano tree routines
|
|
****************************************************************/
|
|
|
|
static const unsigned char BitReverse4[] = {
|
|
0x00, 0x08, 0x04, 0x0c, 0x02, 0x0a, 0x06, 0x0e,
|
|
0x01, 0x09, 0x05, 0x0d, 0x03, 0x0b, 0x07, 0x0f
|
|
};
|
|
|
|
#define FIRST_BIT_LEN 8
|
|
#define REST_BIT_LEN 4
|
|
|
|
void FZipExploder::InsertCode(TArray<HuffNode> &decoder, unsigned int pos, int bits, unsigned short code, int len, unsigned char value)
|
|
{
|
|
assert(len > 0);
|
|
unsigned int node = pos + (code & ((1 << bits) - 1));
|
|
|
|
if (len > bits)
|
|
{ // This code uses more bits than this level has room for. Store the bottom bits
|
|
// in this table, then proceed to the next one.
|
|
unsigned int child = decoder[node].ChildTable;
|
|
if (child == 0)
|
|
{ // Need to create child table.
|
|
child = InitTable(decoder, 1 << REST_BIT_LEN);
|
|
decoder[node].ChildTable = child;
|
|
decoder[node].Length = bits;
|
|
decoder[node].Value = 0;
|
|
}
|
|
else
|
|
{
|
|
assert(decoder[node].Length == bits);
|
|
assert(decoder[node].Value == 0);
|
|
}
|
|
InsertCode(decoder, child, REST_BIT_LEN, code >> bits, len - bits, value);
|
|
}
|
|
else
|
|
{ // If this code uses fewer bits than this level of the table, it is
|
|
// inserted repeatedly for each value that matches it at its lower
|
|
// bits.
|
|
for (int i = 1 << (bits - len); --i >= 0; node += 1 << len)
|
|
{
|
|
decoder[node].Length = len;
|
|
decoder[node].Value = value;
|
|
assert(decoder[node].ChildTable == 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
unsigned int FZipExploder::InitTable(TArray<HuffNode> &decoder, int numspots)
|
|
{
|
|
unsigned int start = decoder.Size();
|
|
decoder.Reserve(numspots);
|
|
memset(&decoder[start], 0, sizeof(HuffNode)*numspots);
|
|
return start;
|
|
}
|
|
|
|
int STACK_ARGS FZipExploder::buildercmp(const void *a, const void *b)
|
|
{
|
|
const TableBuilder *v1 = (const TableBuilder *)a;
|
|
const TableBuilder *v2 = (const TableBuilder *)b;
|
|
int d = v1->Length - v2->Length;
|
|
if (d == 0) {
|
|
d = v1->Value - v2->Value;
|
|
}
|
|
return d;
|
|
}
|
|
|
|
int FZipExploder::BuildDecoder(TArray<HuffNode> &decoder, TableBuilder *values, int numvals)
|
|
{
|
|
int i;
|
|
|
|
qsort(values, numvals, sizeof(*values), buildercmp);
|
|
|
|
// Generate the Shannon-Fano tree:
|
|
unsigned short code = 0;
|
|
unsigned short code_increment = 0;
|
|
unsigned short last_bit_length = 0;
|
|
for (i = numvals - 1; i >= 0; --i)
|
|
{
|
|
code += code_increment;
|
|
if (values[i].Length != last_bit_length)
|
|
{
|
|
last_bit_length = values[i].Length;
|
|
code_increment = 1 << (16 - last_bit_length);
|
|
}
|
|
// Reverse the order of the bits in the code before storing it.
|
|
values[i].Code = BitReverse4[code >> 12] |
|
|
(BitReverse4[(code >> 8) & 0xf] << 4) |
|
|
(BitReverse4[(code >> 4) & 0xf] << 8) |
|
|
(BitReverse4[code & 0xf] << 12);
|
|
}
|
|
|
|
// Insert each code into the hierarchical table. The top level is FIRST_BIT_LEN bits,
|
|
// and the other levels are REST_BIT_LEN bits. If a code does not completely fill
|
|
// a level, every permutation for the remaining bits is filled in to
|
|
// match this one.
|
|
InitTable(decoder, 1 << FIRST_BIT_LEN); // Set up the top level.
|
|
for (i = 0; i < numvals; ++i)
|
|
{
|
|
InsertCode(decoder, 0, FIRST_BIT_LEN, values[i].Code, values[i].Length, values[i].Value);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
int FZipExploder::DecodeSFValue(const TArray<HuffNode> &decoder)
|
|
{
|
|
unsigned int bits = FIRST_BIT_LEN, table = 0, code;
|
|
const HuffNode *pos;
|
|
do
|
|
{
|
|
NEEDBITS(bits);
|
|
code = BITS(bits);
|
|
bits = REST_BIT_LEN;
|
|
pos = &decoder[table + code];
|
|
DROPBITS(pos->Length);
|
|
table = pos->ChildTable;
|
|
}
|
|
while (table != 0);
|
|
return pos->Value;
|
|
}
|
|
|
|
|
|
int FZipExploder::DecodeSF(TArray<HuffNode> &decoder, int numvals)
|
|
{
|
|
TableBuilder builder[256];
|
|
unsigned char a, c;
|
|
int i, n, v = 0;
|
|
|
|
READBYTE(c);
|
|
n = c + 1;
|
|
for (i = 0; i < n; i++) {
|
|
int nv, bl;
|
|
READBYTE(a);
|
|
nv = ((a >> 4) & 15) + 1;
|
|
bl = (a & 15) + 1;
|
|
while (nv--) {
|
|
builder[v].Length = bl;
|
|
builder[v].Value = v;
|
|
v++;
|
|
}
|
|
}
|
|
if (v != numvals)
|
|
return 1; /* bad table */
|
|
return BuildDecoder(decoder, builder, v);
|
|
}
|
|
|
|
int FZipExploder::Explode(unsigned char *out, unsigned int outsize,
|
|
FileReader *in, unsigned int insize,
|
|
int flags)
|
|
{
|
|
int c, i, minMatchLen = 3, len, dist;
|
|
int lowDistanceBits;
|
|
unsigned int bIdx = 0;
|
|
|
|
Hold = 0;
|
|
Bits = 0;
|
|
In = in;
|
|
InLeft = insize;
|
|
bs = be = 0;
|
|
|
|
if ((flags & 4)) {
|
|
/* 3 trees: literals, lengths, distance top 6 */
|
|
minMatchLen = 3;
|
|
if (DecodeSF(LiteralDecoder, 256))
|
|
return 1;
|
|
} else {
|
|
/* 2 trees: lengths, distance top 6 */
|
|
minMatchLen = 2;
|
|
}
|
|
if (DecodeSF(LengthDecoder, 64))
|
|
return 1;
|
|
if (DecodeSF(DistanceDecoder, 64))
|
|
return 1;
|
|
|
|
lowDistanceBits = (flags & 2) ? /* 8k dictionary */ 7 : /* 4k dictionary */ 6;
|
|
while (bIdx < outsize)
|
|
{
|
|
READBITS(c, 1);
|
|
if (c) {
|
|
/* literal data */
|
|
if ((flags & 4)) {
|
|
c = DecodeSFValue(LiteralDecoder);
|
|
} else {
|
|
READBITS(c, 8);
|
|
}
|
|
out[bIdx++] = c;
|
|
} else {
|
|
READBITS(dist, lowDistanceBits);
|
|
c = DecodeSFValue(DistanceDecoder);
|
|
dist |= (c << lowDistanceBits);
|
|
len = DecodeSFValue(LengthDecoder);
|
|
if (len == 63) {
|
|
READBITS(c, 8);
|
|
len += c;
|
|
}
|
|
len += minMatchLen;
|
|
dist++;
|
|
if (bIdx + len > outsize) {
|
|
throw CExplosionError("Not enough output space");
|
|
}
|
|
if ((unsigned int)dist > bIdx) {
|
|
/* Anything before the first input byte is zero. */
|
|
int zeros = dist - bIdx;
|
|
if (len < zeros)
|
|
zeros = len;
|
|
for(i = zeros; i; i--)
|
|
out[bIdx++] = 0;
|
|
len -= zeros;
|
|
}
|
|
for(i = len; i; i--, bIdx++) {
|
|
out[bIdx] = out[bIdx - dist];
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* HSIZE is defined as 2^13 (8192) in unzip.h */
|
|
#define HSIZE 8192
|
|
#define BOGUSCODE 256
|
|
#define CODE_MASK (HSIZE - 1) /* 0x1fff (lower bits are parent's index) */
|
|
#define FREE_CODE HSIZE /* 0x2000 (code is unused or was cleared) */
|
|
#define HAS_CHILD (HSIZE << 1) /* 0x4000 (code has a child--do not clear) */
|
|
|
|
int ShrinkLoop(unsigned char *out, unsigned int outsize,
|
|
FileReader *In, unsigned int InLeft)
|
|
{
|
|
unsigned char ReadBuf[256];
|
|
unsigned short Parent[HSIZE];
|
|
unsigned char Value[HSIZE], Stack[HSIZE];
|
|
unsigned char *newstr;
|
|
int len;
|
|
int KwKwK, codesize = 9; /* start at 9 bits/code */
|
|
int code, oldcode, freecode, curcode;
|
|
unsigned int Bits = 0, Hold = 0;
|
|
unsigned int size = 0;
|
|
unsigned int bs = 0, be = 0;
|
|
|
|
freecode = BOGUSCODE;
|
|
for (code = 0; code < BOGUSCODE; code++)
|
|
{
|
|
Value[code] = code;
|
|
Parent[code] = BOGUSCODE;
|
|
}
|
|
for (code = BOGUSCODE+1; code < HSIZE; code++)
|
|
Parent[code] = FREE_CODE;
|
|
|
|
READBITS(oldcode, codesize);
|
|
if (size < outsize) {
|
|
out[size++] = oldcode;
|
|
}
|
|
|
|
while (size < outsize)
|
|
{
|
|
READBITS(code, codesize);
|
|
if (code == BOGUSCODE) { /* possible to have consecutive escapes? */
|
|
READBITS(code, codesize);
|
|
if (code == 1) {
|
|
codesize++;
|
|
} else if (code == 2) {
|
|
/* clear leafs (nodes with no children) */
|
|
/* first loop: mark each parent as such */
|
|
for (code = BOGUSCODE+1; code < HSIZE; ++code) {
|
|
curcode = (Parent[code] & CODE_MASK);
|
|
|
|
if (curcode > BOGUSCODE)
|
|
Parent[curcode] |= HAS_CHILD; /* set parent's child-bit */
|
|
}
|
|
|
|
/* second loop: clear all nodes *not* marked as parents; reset flag bits */
|
|
for (code = BOGUSCODE+1; code < HSIZE; ++code) {
|
|
if (Parent[code] & HAS_CHILD) { /* just clear child-bit */
|
|
Parent[code] &= ~HAS_CHILD;
|
|
} else { /* leaf: lose it */
|
|
Parent[code] = FREE_CODE;
|
|
}
|
|
}
|
|
freecode = BOGUSCODE;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
newstr = &Stack[HSIZE-1];
|
|
curcode = code;
|
|
|
|
if (Parent[curcode] == FREE_CODE) {
|
|
KwKwK = 1;
|
|
newstr--; /* last character will be same as first character */
|
|
curcode = oldcode;
|
|
len = 1;
|
|
} else {
|
|
KwKwK = 0;
|
|
len = 0;
|
|
}
|
|
|
|
do {
|
|
*newstr-- = Value[curcode];
|
|
len++;
|
|
curcode = (Parent[curcode] & CODE_MASK);
|
|
} while (curcode != BOGUSCODE);
|
|
|
|
newstr++;
|
|
if (KwKwK) {
|
|
Stack[HSIZE-1] = *newstr;
|
|
}
|
|
|
|
do {
|
|
freecode++;
|
|
} while (Parent[freecode] != FREE_CODE);
|
|
|
|
Parent[freecode] = oldcode;
|
|
Value[freecode] = *newstr;
|
|
oldcode = code;
|
|
|
|
while (len--) {
|
|
out[size++] = *newstr++;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|