From 84cacd2391b7dbd372f63149ca733f34d0713550 Mon Sep 17 00:00:00 2001 From: Werner Lemberg Date: Sun, 23 Oct 2005 19:25:41 +0000 Subject: [PATCH] formatting, comment clean-up --- src/lzw/ftlzw2.c | 33 ++-- src/lzw/ftzopen.c | 413 ++++++++++++++++++++++++---------------------- src/lzw/ftzopen.h | 245 ++++++++++++++------------- 3 files changed, 357 insertions(+), 334 deletions(-) diff --git a/src/lzw/ftlzw2.c b/src/lzw/ftlzw2.c index 1e3bda8b5..b1239dd22 100644 --- a/src/lzw/ftlzw2.c +++ b/src/lzw/ftlzw2.c @@ -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" diff --git a/src/lzw/ftzopen.c b/src/lzw/ftzopen.c index af6c211b6..4105cfa1e 100644 --- a/src/lzw/ftzopen.c +++ b/src/lzw/ftzopen.c @@ -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 */ diff --git a/src/lzw/ftzopen.h b/src/lzw/ftzopen.h index 9fb68be0f..8678241a0 100644 --- a/src/lzw/ftzopen.h +++ b/src/lzw/ftzopen.h @@ -24,139 +24,150 @@ #include #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 */