303 lines
9.8 KiB
C
303 lines
9.8 KiB
C
/* DEC/CMS REPLACEMENT HISTORY, Element CompPirv.H */
|
|
/* *1 14-NOV-1996 10:26:00 ANIGBOGU "[113914]Private declarations for all compression/decompression functions" */
|
|
/* DEC/CMS REPLACEMENT HISTORY, Element CompPirv.H */
|
|
/* PUBLIC FILE
|
|
******************************************************************************
|
|
**
|
|
** (c) Copyright Schlumberger Technology Corp., unpublished work, created 1996.
|
|
**
|
|
** This computer program includes Confidential, Proprietary Information and is
|
|
** a Trade Secret of Schlumberger Technology Corp. All use, disclosure, and/or
|
|
** reproduction is prohibited unless authorized in writing by Schlumberger.
|
|
** All Rights Reserved.
|
|
**
|
|
******************************************************************************
|
|
**
|
|
** compress/CompPirv.h
|
|
**
|
|
** PURPOSE
|
|
**
|
|
** Common declarations for all compression/decompression modules
|
|
**
|
|
** SPECIAL REQUIREMENTS & NOTES
|
|
**
|
|
** AUTHOR
|
|
**
|
|
** J. C. Anigbogu
|
|
** Austin Systems Center
|
|
** Nov 1996
|
|
**
|
|
******************************************************************************
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include "CompPub.h"
|
|
|
|
#include "slbCrc32.h"
|
|
|
|
#if defined(VMS)
|
|
#define OS_CODE 0x02
|
|
#endif
|
|
|
|
#if defined(Unix)
|
|
#define OS_CODE 0x03
|
|
#endif
|
|
|
|
/* Common defaults */
|
|
|
|
#ifndef OS_CODE
|
|
#define OS_CODE 0x0b /* assume WindowsNT or Windows95*/
|
|
#endif
|
|
|
|
#include <string.h>
|
|
|
|
#define memzero(String, Size) memset ((void *)(String), 0, (Size))
|
|
|
|
#define STORED 0
|
|
/* methods 1 to 7 reserved */
|
|
#define DEFLATED 8
|
|
#define MAX_METHODS 9
|
|
|
|
/*
|
|
* For compression, input is done in window[]. For decompression, output
|
|
* is done in window.
|
|
*/
|
|
|
|
#ifndef INBUFSIZ
|
|
#define INBUFSIZ 0x8000 /* input buffer size */
|
|
#endif
|
|
|
|
#ifndef OUTBUFSIZ
|
|
#define OUTBUFSIZ 16384 /* output buffer size */
|
|
#endif
|
|
|
|
#ifndef DISTBUFSIZE
|
|
#define DISTBUFSIZE 0x8000 /* buffer for distances, see Trees.c */
|
|
#endif
|
|
|
|
#ifndef WSIZE
|
|
#define WSIZE 0x8000 /* window size--must be a power of two, and */
|
|
#endif /* at least 32K for zip's deflate method */
|
|
|
|
#ifndef DWSIZE
|
|
#define DWSIZE 0x10000 /* 2L * WSIZE */
|
|
#endif
|
|
|
|
#ifndef BITS
|
|
#define BITS 16
|
|
#endif
|
|
|
|
typedef struct CompData
|
|
{
|
|
unsigned char *Data;
|
|
int Size;
|
|
struct CompData *next;
|
|
} CompData_t;
|
|
|
|
typedef struct CompParam
|
|
{
|
|
unsigned long InputSize; /* valid bytes in inbuf */
|
|
unsigned long Index; /* index of next byte to be processed in inbuf */
|
|
unsigned long OutBytes; /* bytes in output buffer */
|
|
unsigned long GlobalSize; /* bytes in inbut g_inbuf */
|
|
unsigned long BytesIn; /* number of input bytes */
|
|
unsigned long BytesOut; /* number of output bytes */
|
|
unsigned long HeaderBytes; /* number of bytes in gzip header */
|
|
unsigned long WindowSize; /* window size, 2*WSIZE */
|
|
Crc32 *pCRC; /* Cyclic Redundancy Check */
|
|
unsigned long BitBuffer; /* Global bit buffer */
|
|
unsigned int BitsInBitBuffer; /* bits in global bit buffer */
|
|
unsigned short DistBuffer[DISTBUFSIZE]; /* buffer for distances, see trees.c */
|
|
unsigned short HashLink[1L<<BITS]; /* hash link (see deflate.c) */
|
|
unsigned char InputBuffer[INBUFSIZ]; /* input buffer */
|
|
unsigned char *Input; /* pointer to input buffer */
|
|
unsigned char Output[OUTBUFSIZ]; /* output buffer */
|
|
unsigned char Window[DWSIZE]; /* Sliding window */
|
|
unsigned char *GlobalInput; /* global input buffer */
|
|
CompData_t *CompressedOutput; /* compressed output list */
|
|
CompData_t *PtrOutput; /* pointer to compressed output list */
|
|
} CompParam_t;
|
|
|
|
typedef struct DeflateParam
|
|
{
|
|
long BlockStart;
|
|
unsigned int PrevLength;
|
|
unsigned int StringStart; /* start of string to insert */
|
|
unsigned int MatchStart; /* start of matching string */
|
|
unsigned int MaxChainLength;
|
|
unsigned int MaxLazyMatch;
|
|
unsigned int GoodMatch;
|
|
int NiceMatch; /* Stop searching when current match exceeds this */
|
|
} DeflateParam_t;
|
|
|
|
/* long BlockStart:
|
|
* window position at the beginning of the current output block. Gets
|
|
* negative when the window is moved backwards.
|
|
*/
|
|
|
|
/* PrevLength:
|
|
* Length of the best match at previous step. Matches not greater than this
|
|
* are discarded. This is used in the lazy match evaluation.
|
|
*/
|
|
|
|
/* MaxChainLength:
|
|
* To speed up deflation, hash chains are never searched beyond this length.
|
|
* A higher limit improves compression ratio but degrades the speed.
|
|
*/
|
|
|
|
/* MaxLazyMatch:
|
|
* Attempt to find a better match only when the current match is strictly
|
|
* smaller than this value. This mechanism is used only for compression
|
|
* levels >= 4.
|
|
*/
|
|
|
|
/* GoodMatch: */
|
|
/* Use a faster search when the previous match is longer than this */
|
|
|
|
|
|
/* Values for MaxLazyMatch, GoodMatch and MaxChainLength, depending on
|
|
* the desired pack level (0..9). The values given below have been tuned to
|
|
* exclude worst case performance for pathological data. Better values may be
|
|
* found for specific data.
|
|
*/
|
|
|
|
/* ===========================================================================
|
|
* Data used by the "bit string" routines (Bits.c) and zip (Zip.c)
|
|
*/
|
|
|
|
typedef struct LocalBits
|
|
{
|
|
unsigned int BitBuffer;
|
|
unsigned int ValidBits;
|
|
} LocalBits_t;
|
|
|
|
/* BitBuffer: Output buffer. bits are inserted starting at the bottom
|
|
* (least significant bits).
|
|
*/
|
|
/* ValidBits: Number of valid bits in BitBuffer. All bits above the last valid bit
|
|
* are always zero.
|
|
*/
|
|
|
|
typedef struct LocalDef
|
|
{
|
|
unsigned int HashIndex; /* hash index of string to be inserted */
|
|
int EndOfInput; /* flag set at end of input buffer */
|
|
unsigned int Lookahead; /* number of valid bytes ahead in window */
|
|
int CompLevel; /* compression level (1..9) */
|
|
} LocalDef_t;
|
|
|
|
/* for compatibility with old zip sources (to be cleaned) */
|
|
|
|
#define GZIP_MAGIC "\037\213" /* Magic header for gzip format, 1F 8B */
|
|
|
|
#define MIN_MATCH 3
|
|
#define MAX_MATCH 258
|
|
/* The minimum and maximum match lengths */
|
|
|
|
#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
|
|
/* Minimum amount of lookahead, except at the end of the input file.
|
|
* See Deflate.c for comments about the MIN_MATCH+1.
|
|
*/
|
|
|
|
#define MAX_DIST (WSIZE-MIN_LOOKAHEAD)
|
|
/* In order to simplify the code, particularly on 16 bit machines, match
|
|
* distances are limited to MAX_DIST instead of WSIZE.
|
|
*/
|
|
|
|
#define STORED_BLOCK 0
|
|
#define STATIC_TREES 1
|
|
#define DYN_TREES 2
|
|
/* The three kinds of block type */
|
|
|
|
#define GetByte(c) \
|
|
(c->Index < c->InputSize ? c->Input[c->Index++] : FillInputBuffer(0,c))
|
|
#define TryByte(c) \
|
|
(c->Index < c->InputSize ? c->Input[c->Index++] : FillInputBuffer(1,c))
|
|
|
|
/* PutByte is used for the compressed output
|
|
*/
|
|
#define PutByte(c,o) {o->Output[o->OutBytes++]=(unsigned char)(c); \
|
|
if (o->OutBytes==OUTBUFSIZ) \
|
|
FlushOutputBuffer(o);}
|
|
|
|
/* Output a 16 bit value, lsb first */
|
|
#define PutShort(w,c) \
|
|
{ if (c->OutBytes < OUTBUFSIZ-2) { \
|
|
c->Output[c->OutBytes++] = (unsigned char) ((w) & 0xff); \
|
|
c->Output[c->OutBytes++] = (unsigned char) ((unsigned short)(w) >> 8); \
|
|
} else { \
|
|
PutByte((unsigned char)((w) & 0xff),c); \
|
|
PutByte((unsigned char)((unsigned short)(w) >> 8),c); \
|
|
} \
|
|
}
|
|
|
|
/* Output a 32 bit value to the bit stream, LSB first */
|
|
#define PutLong(n,c) { \
|
|
PutShort(((n) & 0xffff),c); \
|
|
PutShort(((unsigned long)(n)) >> 16,c); \
|
|
}
|
|
|
|
/* Macros for getting two-byte and four-byte header values */
|
|
#define SH(p) ((unsigned short)(unsigned char)((p)[0]) | ((unsigned short)(unsigned char)((p)[1]) << 8))
|
|
#define LG(p) ((unsigned long)(SH(p)) | ((unsigned long)(SH((p)+2)) << 16))
|
|
|
|
/* Diagnostic functions */
|
|
#ifdef DEBUG
|
|
# define Assert(cond,msg) {if(!(cond)) error(msg);}
|
|
#else
|
|
# define Assert(cond,msg)
|
|
#endif
|
|
|
|
#ifndef MAX
|
|
#define MAX(a,b) (((a)>(b))?(a):(b))
|
|
#endif
|
|
|
|
#ifndef MIN
|
|
#define MIN(a,b) (((a)<(b))?(a):(b))
|
|
#endif
|
|
|
|
/* in Zip.c: */
|
|
extern CompressStatus_t Zip(int Level, CompParam_t *Comp);
|
|
extern int FillBuffer(unsigned char *Buffer, unsigned int Size, CompParam_t *Comp);
|
|
int ReadBuffer(char *Buffer, unsigned int Size, CompParam_t *Comp);
|
|
|
|
/* in Unzip.c */
|
|
extern CompressStatus_t Unzip(int Method, CompParam_t *Comp);
|
|
|
|
/* in Deflate.c */
|
|
CompressStatus_t InitLongestMatch(int PackLevel, unsigned short
|
|
*Flags, DeflateParam_t *Defl,
|
|
LocalDef_t *Deflt, CompParam_t *Comp);
|
|
unsigned long Deflate(int Level, LocalBits_t *Bits, DeflateParam_t *Defl,
|
|
LocalDef_t *Deflt, CompParam_t *Comp);
|
|
|
|
/* in Trees.c */
|
|
void InitMatchBuffer(void);
|
|
int TallyFrequencies(int Dist, int LengthC, int Level,
|
|
DeflateParam_t *Defl, CompParam_t *Comp);
|
|
unsigned long FlushBlock(char *Buffer, unsigned long stored_len, int Eof,
|
|
LocalBits_t *Bits, CompParam_t *Comp);
|
|
|
|
/* in Bits.c */
|
|
void InitializeBits(LocalBits_t *Bits);
|
|
void SendBits(int Value, int Length, LocalBits_t *Bits,
|
|
CompParam_t *Comp);
|
|
unsigned int ReverseBits(unsigned int Value, int Length);
|
|
void WindupBits(LocalBits_t *Bits, CompParam_t *Comp);
|
|
void CopyBlock(char *Input, unsigned int Length, int Header,
|
|
LocalBits_t *Bits, CompParam_t *Comp);
|
|
|
|
/* in Util.c: */
|
|
extern unsigned long UpdateCRC(CompParam_t *Comp, unsigned char *Input,
|
|
unsigned int Size);
|
|
extern void ClearBuffers(CompParam_t *Comp);
|
|
extern int FillInputBuffer(int EOF_OK, CompParam_t *Comp);
|
|
extern CompressStatus_t FlushOutputBuffer(CompParam_t *Comp);
|
|
extern CompressStatus_t FlushWindow(CompParam_t *Comp);
|
|
extern CompressStatus_t WriteBuffer(CompParam_t *Comp, void *Buffer,
|
|
unsigned int Count);
|
|
|
|
/* in Inflate.c */
|
|
extern CompressStatus_t Inflate(CompParam_t *Comp);
|