rgraves
/
freetype2
forked from minhngoc25a/freetype2
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

formatting, comment clean-up

This commit is contained in:
Werner Lemberg 2005-10-23 19:25:41 +00:00
parent f50c73dd65
commit 84cacd2391
3 changed files with 357 additions and 334 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
src/lzw/ftlzw2.c
View File

@ -61,17 +61,17 @@
/***************************************************************************/
/***************************************************************************/
#define FT_LZW_BUFFER_SIZE 4096
#define FT_LZW_BUFFER_SIZE 4096
typedef struct FT_LZWFileRec_
typedef struct FT_LZWFileRec_
{
FT_Stream source; /* parent/source stream */
FT_Stream stream; /* embedding stream */
FT_Memory memory; /* memory allocator */
FT_LzwStateRec lzw; /* lzw decompressor state */
FT_Byte buffer[ FT_LZW_BUFFER_SIZE ]; /* output buffer */
FT_ULong pos; /* position in output */
FT_Byte buffer[FT_LZW_BUFFER_SIZE]; /* output buffer */
FT_ULong pos; /* position in output */
FT_Byte* cursor;
FT_Byte* limit;
@ -90,7 +90,7 @@
FT_STREAM_READ( head, 2 ) )
goto Exit;
/* head[0] && head[1] are the magic numbers */
/* head[0] && head[1] are the magic numbers */
if ( head[0] != 0x1f ||
head[1] != 0x9d )
error = LZW_Err_Invalid_File_Format;
@ -194,11 +194,12 @@
{
FT_Error error = LZW_Err_Ok;
/* first, we skip what we can from the output buffer
*/
/* first, we skip what we can from the output buffer */
{
FT_ULong delta = (FT_ULong)( zip->limit - zip->cursor );
if ( delta >= count )
delta = count;
@ -208,13 +209,13 @@
count -= delta;
}
/* next, we skip as many bytes remaining as possible
*/
/* next, we skip as many bytes remaining as possible */
while ( count > 0 )
{
FT_ULong delta = FT_LZW_BUFFER_SIZE;
FT_ULong numread;
if ( delta > count )
delta = count;
@ -247,12 +248,11 @@
/* seeking backwards. */
if ( pos < zip->pos )
{
/* if the new position is within the output buffer, simply
* decrement pointers, otherwise, we'll reset the stream completely !!
*/
if ( (zip->pos - pos) <= (FT_ULong)(zip->cursor - zip->buffer) )
/* If the new position is within the output buffer, simply */
/* decrement pointers, otherwise we reset the stream completely! */
if ( ( zip->pos - pos ) <= (FT_ULong)( zip->cursor - zip->buffer ) )
{
zip->cursor -= (zip->pos - pos);
zip->cursor -= zip->pos - pos;
zip->pos = pos;
}
else
@ -353,11 +353,11 @@
/*
* Check the header right now; this prevents allocation a huge
* Check the header right now; this prevents allocation of a huge
* LZWFile object (400 KByte of heap memory) if not necessary.
*
* Did I mention that you should never use .Z compressed font
* file?
* files?
*/
error = ft_lzw_check_header( source );
if ( error )
@ -388,6 +388,7 @@
return error;
}
#include "ftzopen.c"

413
src/lzw/ftzopen.c
View File

@ -23,212 +23,216 @@
#include FT_INTERNAL_STREAM_H
#include FT_INTERNAL_DEBUG_H
/* refill input buffer, return 0 on success, or -1 if eof
*/
static int
ft_lzwstate_refill( FT_LzwState state )
{
int result = -1;
if ( !state->in_eof )
/* refill input buffer, return 0 on success, or -1 if eof */
static int
ft_lzwstate_refill( FT_LzwState state )
{
FT_ULong count = FT_Stream_TryRead( state->source,
state->in_buff,
sizeof( state->in_buff ) );
state->in_cursor = state->in_buff;
state->in_limit = state->in_buff + count;
state->in_eof = FT_BOOL( count < sizeof( state->in_buff ) );
if ( count > 0 )
result = 0;
}
return result;
}
int result = -1;
/* return new code of 'num_bits', or -1 if eof
*/
static FT_Int32
ft_lzwstate_get_code( FT_LzwState state,
FT_UInt num_bits )
{
FT_Int32 result = -1;
FT_UInt32 pad = state->pad;
FT_UInt pad_bits = state->pad_bits;
while ( num_bits > pad_bits )
{
if ( state->in_cursor >= state->in_limit &&
ft_lzwstate_refill( state ) < 0 )
goto Exit;
pad |= (FT_UInt32)(*state->in_cursor++) << pad_bits;
pad_bits += 8;
}
result = (FT_Int32)( pad & LZW_MASK(num_bits) );
state->pad_bits = pad_bits - num_bits;
state->pad = pad >> num_bits;
Exit:
return result;
}
/* grow the character stack
*/
static int
ft_lzwstate_stack_grow( FT_LzwState state )
{
if ( state->stack_top >= state->stack_size )
{
FT_Memory memory = state->memory;
FT_Error error;
FT_UInt old_size = state->stack_size;
FT_UInt new_size = old_size;
new_size = new_size + (new_size >> 1) + 4;
if ( state->stack == state->stack_0 )
if ( !state->in_eof )
{
state->stack = NULL;
old_size = 0;
FT_ULong count = FT_Stream_TryRead( state->source,
state->in_buff,
sizeof ( state->in_buff ) );
state->in_cursor = state->in_buff;
state->in_limit = state->in_buff + count;
state->in_eof = FT_BOOL( count < sizeof ( state->in_buff ) );
if ( count > 0 )
result = 0;
}
return result;
}
/* return new code of 'num_bits', or -1 if eof */
static FT_Int32
ft_lzwstate_get_code( FT_LzwState state,
FT_UInt num_bits )
{
FT_Int32 result = -1;
FT_UInt32 pad = state->pad;
FT_UInt pad_bits = state->pad_bits;
while ( num_bits > pad_bits )
{
if ( state->in_cursor >= state->in_limit &&
ft_lzwstate_refill( state ) < 0 )
goto Exit;
pad |= (FT_UInt32)(*state->in_cursor++) << pad_bits;
pad_bits += 8;
}
if ( FT_RENEW_ARRAY( state->stack, old_size, new_size ) )
result = (FT_Int32)( pad & LZW_MASK( num_bits ) );
state->pad_bits = pad_bits - num_bits;
state->pad = pad >> num_bits;
Exit:
return result;
}
/* grow the character stack */
static int
ft_lzwstate_stack_grow( FT_LzwState state )
{
if ( state->stack_top >= state->stack_size )
{
FT_Memory memory = state->memory;
FT_Error error;
FT_UInt old_size = state->stack_size;
FT_UInt new_size = old_size;
new_size = new_size + ( new_size >> 1 ) + 4;
if ( state->stack == state->stack_0 )
{
state->stack = NULL;
old_size = 0;
}
if ( FT_RENEW_ARRAY( state->stack, old_size, new_size ) )
return -1;
state->stack_size = new_size;
}
return 0;
}
/* grow the prefix/suffix arrays */
static int
ft_lzwstate_prefix_grow( FT_LzwState state )
{
FT_UInt old_size = state->prefix_size;
FT_UInt new_size = old_size;
FT_Memory memory = state->memory;
FT_Error error;
if ( new_size == 0 ) /* first allocation -> 9 bits */
new_size = 512;
else
new_size += new_size >> 2; /* don't grow too fast */
/*
* Note that the `suffix' array is located in the same memory block
* pointed to by `prefix'.
*
* I know that sizeof(FT_Byte) == 1 by definition, but it is clearer
* to write it literally.
*
*/
if ( FT_REALLOC(
state->prefix,
old_size * (sizeof ( FT_UShort ) + sizeof ( FT_Byte ) ),
new_size * (sizeof ( FT_UShort ) + sizeof ( FT_Byte ) ) ) )
return -1;
state->stack_size = new_size;
/* now adjust `suffix' and move the data accordingly */
state->suffix = (FT_Byte*)( state->prefix + new_size );
FT_MEM_MOVE( state->suffix,
state->prefix + old_size,
old_size * sizeof ( FT_Byte ) );
state->prefix_size = new_size;
return 0;
}
return 0;
}
/* grow the prefix/suffix arrays
*/
static int
ft_lzwstate_prefix_grow( FT_LzwState state )
{
FT_UInt old_size = state->prefix_size;
FT_UInt new_size = old_size;
FT_Memory memory = state->memory;
FT_Error error;
FT_LOCAL_DEF( void )
ft_lzwstate_reset( FT_LzwState state )
{
state->in_cursor = state->in_buff;
state->in_limit = state->in_buff;
state->in_eof = 0;
state->pad_bits = 0;
state->pad = 0;
if ( new_size == 0 ) /* first allocation -> 9 bits */
new_size = 512;
else
new_size += (new_size >> 2); /* don't grow too fast */
/* note that the 'suffix' array is located in the same memory block
* pointed to by 'prefix'
*
* I know that sizeof(FT_Byte) == 1 by definition, but it's clearer
* to write it literally
*/
if ( FT_REALLOC( state->prefix,
old_size*(sizeof(FT_UShort)+sizeof(FT_Byte)),
new_size*(sizeof(FT_UShort)+sizeof(FT_Byte)) ) )
return -1;
/* now adjust 'suffix' and move the data accordingly */
state->suffix = (FT_Byte*)(state->prefix + new_size);
FT_MEM_MOVE( state->suffix,
state->prefix + old_size,
old_size * sizeof(FT_Byte) );
state->prefix_size = new_size;
return 0;
}
state->stack_top = 0;
state->num_bits = LZW_INIT_BITS;
state->phase = FT_LZW_PHASE_START;
}
FT_LOCAL_DEF( void )
ft_lzwstate_reset( FT_LzwState state )
{
state->in_cursor = state->in_buff;
state->in_limit = state->in_buff;
state->in_eof = 0;
state->pad_bits = 0;
state->pad = 0;
FT_LOCAL_DEF( void )
ft_lzwstate_init( FT_LzwState state,
FT_Stream source )
{
FT_ZERO( state );
state->stack_top = 0;
state->num_bits = LZW_INIT_BITS;
state->phase = FT_LZW_PHASE_START;
}
state->source = source;
state->memory = source->memory;
state->prefix = NULL;
state->suffix = NULL;
state->prefix_size = 0;
state->stack = state->stack_0;
state->stack_size = sizeof ( state->stack_0 );
ft_lzwstate_reset( state );
}
FT_LOCAL_DEF( void )
ft_lzwstate_init( FT_LzwState state,
FT_Stream source )
{
FT_ZERO( state );
state->source = source;
state->memory = source->memory;
state->prefix = NULL;
state->suffix = NULL;
state->prefix_size = 0;
state->stack = state->stack_0;
state->stack_size = sizeof(state->stack_0);
ft_lzwstate_reset( state );
}
FT_LOCAL_DEF( void )
ft_lzwstate_done( FT_LzwState state )
{
FT_Memory memory = state->memory;
FT_LOCAL_DEF( void )
ft_lzwstate_done( FT_LzwState state )
{
FT_Memory memory = state->memory;
ft_lzwstate_reset( state );
ft_lzwstate_reset( state );
if ( state->stack != state->stack_0 )
FT_FREE( state->stack );
if ( state->stack != state->stack_0 )
FT_FREE( state->stack );
FT_FREE( state->prefix );
state->suffix = NULL;
FT_FREE( state->prefix );
state->suffix = NULL;
FT_ZERO( state );
}
FT_ZERO( state );
}
#define FTLZW_STACK_PUSH(c) \
FT_BEGIN_STMNT \
if ( state->stack_top >= state->stack_size && \
ft_lzwstate_stack_grow( state ) < 0 ) \
goto Eof; \
\
state->stack[ state->stack_top++ ] = (FT_Byte)(c); \
#define FTLZW_STACK_PUSH( c ) \
FT_BEGIN_STMNT \
if ( state->stack_top >= state->stack_size && \
ft_lzwstate_stack_grow( state ) < 0 ) \
goto Eof; \
\
state->stack[ state->stack_top++ ] = (FT_Byte)(c); \
FT_END_STMNT
FT_LOCAL_DEF( FT_ULong )
ft_lzwstate_io( FT_LzwState state,
FT_Byte* buffer,
FT_ULong out_size )
{
FT_ULong result = 0;
FT_UInt num_bits = state->num_bits;
FT_UInt free_ent = state->free_ent;
FT_UInt old_char = state->old_char;
FT_UInt old_code = state->old_code;
FT_UInt in_code = state->in_code;
if ( out_size == 0 )
goto Exit;
switch ( state->phase )
FT_LOCAL_DEF( FT_ULong )
ft_lzwstate_io( FT_LzwState state,
FT_Byte* buffer,
FT_ULong out_size )
{
FT_ULong result = 0;
FT_UInt num_bits = state->num_bits;
FT_UInt free_ent = state->free_ent;
FT_UInt old_char = state->old_char;
FT_UInt old_code = state->old_code;
FT_UInt in_code = state->in_code;
if ( out_size == 0 )
goto Exit;
switch ( state->phase )
{
case FT_LZW_PHASE_START:
{
FT_Byte max_bits;
FT_Int32 c;
/* skip magic bytes, and read max_bits + block_flag */
if ( FT_Stream_Seek( state->source, 2 ) != 0 ||
FT_Stream_TryRead( state->source, &max_bits, 1 ) != 1 )
@ -236,18 +240,18 @@ ft_lzwstate_io( FT_LzwState state,
state->max_bits = max_bits & LZW_BIT_MASK;
state->block_mode = max_bits & LZW_BLOCK_MASK;
state->max_free = (FT_UInt)((1UL << state->max_bits) - 256);
state->max_free = (FT_UInt)( ( 1UL << state->max_bits ) - 256 );
if ( state->max_bits > LZW_MAX_BITS )
goto Eof;
num_bits = LZW_INIT_BITS;
free_ent = (state->block_mode ? LZW_FIRST : LZW_CLEAR) - 256;
free_ent = ( state->block_mode ? LZW_FIRST : LZW_CLEAR ) - 256;
in_code = 0;
state->free_bits = num_bits < state->max_bits
? (FT_UInt)((1UL << num_bits) - 256)
: state->max_free+1;
? (FT_UInt)( ( 1UL << num_bits ) - 256 )
: state->max_free + 1;
c = ft_lzwstate_get_code( state, num_bits );
if ( c < 0 )
@ -270,23 +274,26 @@ ft_lzwstate_io( FT_LzwState state,
FT_Int32 c;
FT_UInt code;
NextCode:
c = ft_lzwstate_get_code( state, num_bits );
if ( c < 0 ) goto Eof;
if ( c < 0 )
goto Eof;
code = (FT_UInt)c;
if ( code == LZW_CLEAR && state->block_mode )
{
free_ent = (LZW_FIRST-1)-256; /* why not LZW_FIRST-256 ? */
free_ent = ( LZW_FIRST - 1 ) - 256; /* why not LZW_FIRST-256 ? */
num_bits = LZW_INIT_BITS;
state->free_bits = num_bits < state->max_bits
? (FT_UInt)((1UL << num_bits) - 256)
: state->max_free+1;
? (FT_UInt)( ( 1UL << num_bits ) - 256 )
: state->max_free + 1;
c = ft_lzwstate_get_code( state, num_bits );
if ( c < 0 ) goto Eof;
if ( c < 0 )
goto Eof;
code = (FT_UInt)c;
}
@ -296,7 +303,7 @@ ft_lzwstate_io( FT_LzwState state,
if ( code >= 256U )
{
/* special case for KwKwKwK */
if ( code-256U >= free_ent )
if ( code - 256U >= free_ent )
{
FTLZW_STACK_PUSH( old_char );
code = old_code;
@ -304,13 +311,13 @@ ft_lzwstate_io( FT_LzwState state,
while ( code >= 256U )
{
FTLZW_STACK_PUSH( state->suffix[code-256] );
code = state->prefix[code-256];
FTLZW_STACK_PUSH( state->suffix[code - 256] );
code = state->prefix[code - 256];
}
}
old_char = code;
FTLZW_STACK_PUSH(old_char);
FTLZW_STACK_PUSH( old_char );
state->phase = FT_LZW_PHASE_STACK;
}
@ -338,16 +345,16 @@ ft_lzwstate_io( FT_LzwState state,
FT_ASSERT( free_ent < state->prefix_size );
state->prefix[free_ent] = (FT_UShort) old_code;
state->suffix[free_ent] = (FT_Byte) old_char;
state->prefix[free_ent] = (FT_UShort)old_code;
state->suffix[free_ent] = (FT_Byte) old_char;
if ( ++free_ent == state->free_bits )
{
num_bits++;
state->free_bits = num_bits < state->max_bits
? (FT_UInt)((1UL << num_bits)-256)
: state->max_free+1;
? (FT_UInt)( ( 1UL << num_bits ) - 256 )
: state->max_free + 1;
}
}
@ -359,17 +366,21 @@ ft_lzwstate_io( FT_LzwState state,
default: /* state == EOF */
;
}
Exit:
state->num_bits = num_bits;
state->free_ent = free_ent;
state->old_code = old_code;
state->old_char = old_char;
state->in_code = in_code;
return result;
Eof:
state->phase = FT_LZW_PHASE_EOF;
goto Exit;
}
Exit:
state->num_bits = num_bits;
state->free_ent = free_ent;
state->old_code = old_code;
state->old_char = old_char;
state->in_code = in_code;
return result;
Eof:
state->phase = FT_LZW_PHASE_EOF;
goto Exit;
}
/* END */

245
src/lzw/ftzopen.h
View File

@ -24,139 +24,150 @@
#include <ft2build.h>
#include FT_FREETYPE_H
/* this is a complete re-implementation of the LZW file reader,
* since the old one was incredibly badly written, and used
* 400 Kb of heap memory before decompressing anything.
*/
#define FT_LZW_IN_BUFF_SIZE 64
#define FT_LZW_DEFAULT_STACK_SIZE 64
/*
* This is a complete re-implementation of the LZW file reader,
* since the old one was incredibly badly written, using
* 400 KByte of heap memory before decompressing anything.
*
*/
#define LZW_INIT_BITS 9
#define LZW_MAX_BITS 16
#define FT_LZW_IN_BUFF_SIZE 64
#define FT_LZW_DEFAULT_STACK_SIZE 64
#define LZW_CLEAR 256
#define LZW_FIRST 257
#define LZW_INIT_BITS 9
#define LZW_MAX_BITS 16
#define LZW_BIT_MASK 0x1f
#define LZW_BLOCK_MASK 0x80
#define LZW_MASK(n) ((1U << (n)) - 1U)
#define LZW_CLEAR 256
#define LZW_FIRST 257
typedef enum
{
FT_LZW_PHASE_START = 0,
FT_LZW_PHASE_CODE,
FT_LZW_PHASE_STACK,
FT_LZW_PHASE_EOF
} FT_LzwPhase;
#define LZW_BIT_MASK 0x1f
#define LZW_BLOCK_MASK 0x80
#define LZW_MASK( n ) ( ( 1U << (n) ) - 1U )
/* state of LZW decompressor
*
* small technical note:
*
* we use a few tricks in this implementation that are explained here to
* ease debugging and maintenance.
*
* - first of all, the "prefix" and "suffix" arrays contain the
* suffix and prefix for codes over 256, this means that:
*
* prefix_of(code) == state->prefix[ code-256 ]
* suffix_of(code) == state->suffix[ code-256 ]
*
* each prefix is a 16-bit code, and each suffix an 8-bit byte
*
* both arrays are stored in a single memory block, pointed to by
* 'state->prefix', this means that the following equality is always
* true:
*
* state->suffix == (FT_Byte*)(state->prefix + state->prefix_size)
*
* of course, state->prefix_size is the number of prefix/suffix slots
* in the arrays, corresponding to codes 256..255+prefix_size
*
* - 'free_ent' is the index of the next free entry in the "prefix"
* and "suffix" arrays. This means that the corresponding "next free
* code" is really '256+free_ent'
*
* moreover, 'max_free' is the maximum value that 'free_ent' can reach.
*
* 'max_free' corresponds to "(1 << max_bits) - 256". Note that this value
* is always <= 0xFF00, which means that both 'free_ent' and 'max_free' can
* be stored in FT_UInt variable, even on 16-bit machines.
*
* if 'free_ent == max_free', you cannot add new codes to the prefix/suffix
* table.
*
* - 'num_bits' is the current number of code bits, starting at 9 and
* growing each time 'free_ent' reaches the value of 'free_bits'. the
* latter is computed as follows:
*
* if num_bits < max_bits:
* free_bits = (1 << num_bits)-256
* else:
* free_bits = max_free + 1
*
* since the value of 'max_free + 1' can never be reached by 'free_ent',
* 'num_bits' cannot grow larger than 'max_bits'
*/
typedef struct
{
FT_LzwPhase phase;
typedef enum
{
FT_LZW_PHASE_START = 0,
FT_LZW_PHASE_CODE,
FT_LZW_PHASE_STACK,
FT_LZW_PHASE_EOF
FT_Int in_eof;
FT_Byte* in_cursor; /* current buffer pos */
FT_Byte* in_limit; /* current buffer limit */
FT_UInt32 pad; /* a pad value where incoming bits were read */
FT_Int pad_bits; /* number of meaningful bits in pad value */
FT_UInt max_bits; /* max code bits, from file header */
FT_Int block_mode; /* block mode flag, from file header */
FT_UInt max_free; /* (1 << max_bits) - 256 */
FT_UInt num_bits; /* current code bit number */
FT_UInt free_ent; /* index of next free entry */
FT_UInt free_bits; /* if free_ent reaches this, increment num_bits */
FT_UInt old_code;
FT_UInt old_char;
FT_UInt in_code;
FT_UShort* prefix; /* always dynamically allocated / reallocated */
FT_Byte* suffix; /* suffix = (FT_Byte*)(prefix + prefix_size) */
FT_UInt prefix_size; /* number of slots in 'prefix' or 'suffix' */
FT_Byte* stack; /* character stack */
FT_UInt stack_top;
FT_UInt stack_size;
FT_Byte in_buff[ FT_LZW_IN_BUFF_SIZE ]; /* small buffer to read data */
FT_Byte stack_0[ FT_LZW_DEFAULT_STACK_SIZE ]; /* minimize heap alloc */
FT_Stream source; /* source stream */
FT_Memory memory;
} FT_LzwStateRec, *FT_LzwState;
} FT_LzwPhase;
FT_LOCAL( void )
ft_lzwstate_init( FT_LzwState state,
FT_Stream source );
/*
* state of LZW decompressor
*
* small technical note
* --------------------
*
* We use a few tricks in this implementation that are explained here to
* ease debugging and maintenance.
*
* - First of all, the `prefix' and `suffix' arrays contain the suffix
* and prefix for codes over 256; this means that
*
* prefix_of(code) == state->prefix[code-256]
* suffix_of(code) == state->suffix[code-256]
*
* Each prefix is a 16-bit code, and each suffix an 8-bit byte.
*
* Both arrays are stored in a single memory block, pointed to by
* `state->prefix'. This means that the following equality is always
* true:
*
* state->suffix == (FT_Byte*)(state->prefix + state->prefix_size)
*
* Of course, state->prefix_size is the number of prefix/suffix slots
* in the arrays, corresponding to codes 256..255+prefix_size.
*
* - `free_ent' is the index of the next free entry in the `prefix'
* and `suffix' arrays. This means that the corresponding `next free
* code' is really `256+free_ent'.
*
* Moreover, 'max_free' is the maximum value that 'free_ent' can reach.
*
* `max_free' corresponds to `(1 << max_bits) - 256'. Note that this
* value is always <= 0xFF00, which means that both `free_ent' and
* `max_free' can be stored in an FT_UInt variable, even on 16-bit
* machines.
*
* If `free_ent == max_free', you cannot add new codes to the
* prefix/suffix table.
*
* - `num_bits' is the current number of code bits, starting at 9 and
* growing each time `free_ent' reaches the value of `free_bits'. The
* latter is computed as follows
*
* if num_bits < max_bits:
* free_bits = (1 << num_bits)-256
* else:
* free_bits = max_free + 1
*
* Since the value of `max_free + 1' can never be reached by
* `free_ent', `num_bits' cannot grow larger than `max_bits'.
*/
FT_LOCAL( void )
ft_lzwstate_done( FT_LzwState state );
typedef struct _FT_LzwStateRec
{
FT_LzwPhase phase;
FT_Int in_eof;
FT_Byte* in_cursor; /* current buffer pos */
FT_Byte* in_limit; /* current buffer limit */
FT_UInt32 pad; /* a pad value where incoming bits were read */
FT_Int pad_bits; /* number of meaningful bits in pad value */
FT_UInt max_bits; /* max code bits, from file header */
FT_Int block_mode; /* block mode flag, from file header */
FT_UInt max_free; /* (1 << max_bits) - 256 */
FT_UInt num_bits; /* current code bit number */
FT_UInt free_ent; /* index of next free entry */
FT_UInt free_bits; /* if reached by free_ent, increment num_bits */
FT_UInt old_code;
FT_UInt old_char;
FT_UInt in_code;
FT_UShort* prefix; /* always dynamically allocated / reallocated */
FT_Byte* suffix; /* suffix = (FT_Byte*)(prefix + prefix_size) */
FT_UInt prefix_size; /* number of slots in `prefix' or `suffix' */
FT_Byte* stack; /* character stack */
FT_UInt stack_top;
FT_UInt stack_size;
FT_Byte in_buff[FT_LZW_IN_BUFF_SIZE]; /* small read-buffer */
FT_Byte stack_0[FT_LZW_DEFAULT_STACK_SIZE]; /* minimize heap alloc */
FT_Stream source; /* source stream */
FT_Memory memory;
} FT_LzwStateRec, *FT_LzwState;
FT_LOCAL( void )
ft_lzwstate_reset( FT_LzwState state );
FT_LOCAL( void )
ft_lzwstate_init( FT_LzwState state,
FT_Stream source );
FT_LOCAL( void )
ft_lzwstate_done( FT_LzwState state );
FT_LOCAL( FT_ULong )
ft_lzwstate_io( FT_LzwState state,
FT_Byte* buffer,
FT_ULong out_size );
FT_LOCAL( void )
ft_lzwstate_reset( FT_LzwState state );
FT_LOCAL( FT_ULong )
ft_lzwstate_io( FT_LzwState state,
FT_Byte* buffer,
FT_ULong out_size );
/* */
#endif /* __FT_ZOPEN_H__ */
/* END */