ref: 84cacd2391b7dbd372f63149ca733f34d0713550
parent: f50c73dd6597ed3050866dadf417c016a1234c98
author: Werner Lemberg <[email protected]>
date: Sun Oct 23 15:25:41 EDT 2005
formatting, comment clean-up
--- a/src/lzw/ftlzw2.c
+++ b/src/lzw/ftlzw2.c
@@ -61,9 +61,9 @@
/***************************************************************************/
/***************************************************************************/
-#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 */
@@ -70,8 +70,8 @@
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 )
@@ -387,6 +387,7 @@
Exit:
return error;
}
+
#include "ftzopen.c"
--- 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 ) );
+ int result = -1;
- 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;
-}
+ if ( !state->in_eof )
+ {+ 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 ) );
-/* 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;
+ if ( count > 0 )
+ result = 0;
+ }
+ return result;
+ }
- while ( num_bits > pad_bits )
+
+ /* return new code of 'num_bits', or -1 if eof */
+ static FT_Int32
+ ft_lzwstate_get_code( FT_LzwState state,
+ FT_UInt num_bits )
{- if ( state->in_cursor >= state->in_limit &&
- ft_lzwstate_refill( state ) < 0 )
- goto Exit;
+ FT_Int32 result = -1;
+ FT_UInt32 pad = state->pad;
+ FT_UInt pad_bits = state->pad_bits;
- 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;
+ while ( num_bits > pad_bits )
+ {+ if ( state->in_cursor >= state->in_limit &&
+ ft_lzwstate_refill( state ) < 0 )
+ goto Exit;
-Exit:
- return result;
-}
+ 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;
-/* 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;
+ Exit:
+ return result;
+ }
- new_size = new_size + (new_size >> 1) + 4;
- if ( state->stack == state->stack_0 )
+ /* grow the character stack */
+ static int
+ ft_lzwstate_stack_grow( FT_LzwState state )
+ {+ if ( state->stack_top >= state->stack_size )
{- state->stack = NULL;
- old_size = 0;
- }
+ FT_Memory memory = state->memory;
+ FT_Error error;
+ FT_UInt old_size = state->stack_size;
+ FT_UInt new_size = old_size;
- if ( FT_RENEW_ARRAY( state->stack, old_size, new_size ) )
- return -1;
+ new_size = new_size + ( new_size >> 1 ) + 4;
- state->stack_size = new_size;
+ 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;
}
- 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;
+ /* 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'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;
+ if ( new_size == 0 ) /* first allocation -> 9 bits */
+ new_size = 512;
+ else
+ new_size += new_size >> 2; /* don't grow too fast */
- /* now adjust 'suffix' and move the data accordingly */
- state->suffix = (FT_Byte*)(state->prefix + new_size);
+ /*
+ * 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;
- FT_MEM_MOVE( state->suffix,
- state->prefix + old_size,
- old_size * sizeof(FT_Byte) );
+ /* now adjust `suffix' and move the data accordingly */
+ state->suffix = (FT_Byte*)( state->prefix + new_size );
- state->prefix_size = new_size;
- return 0;
-}
+ FT_MEM_MOVE( state->suffix,
+ state->prefix + old_size,
+ old_size * sizeof ( FT_Byte ) );
+ state->prefix_size = new_size;
+ return 0;
+ }
-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;
- 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;
+ state->stack_top = 0;
+ state->num_bits = LZW_INIT_BITS;
+ state->phase = FT_LZW_PHASE_START;
+ }
-FT_LOCAL_DEF( void )
-ft_lzwstate_init( FT_LzwState state,
- FT_Stream source )
-{- FT_ZERO( state );
- state->source = source;
- state->memory = source->memory;
+ FT_LOCAL_DEF( void )
+ ft_lzwstate_init( FT_LzwState state,
+ FT_Stream source )
+ {+ FT_ZERO( state );
- state->prefix = NULL;
- state->suffix = NULL;
- state->prefix_size = 0;
+ state->source = source;
+ state->memory = source->memory;
- state->stack = state->stack_0;
- state->stack_size = sizeof(state->stack_0);
+ state->prefix = NULL;
+ state->suffix = NULL;
+ state->prefix_size = 0;
- ft_lzwstate_reset( state );
-}
+ 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_lzwstate_reset( state );
+ FT_LOCAL_DEF( void )
+ ft_lzwstate_done( FT_LzwState state )
+ {+ FT_Memory memory = state->memory;
- if ( state->stack != state->stack_0 )
- FT_FREE( state->stack );
- FT_FREE( state->prefix );
- state->suffix = NULL;
+ ft_lzwstate_reset( state );
- FT_ZERO( state );
-}
+ if ( state->stack != state->stack_0 )
+ FT_FREE( state->stack );
+ FT_FREE( state->prefix );
+ state->suffix = NULL;
-#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_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); \
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_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;
- 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;
+ if ( out_size == 0 )
+ goto Exit;
- switch ( state->phase )
- {+ 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 @@
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_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 @@
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 @@
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,8 +345,8 @@
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 )
{@@ -346,8 +353,8 @@
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 @@
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 */
--- a/src/lzw/ftzopen.h
+++ b/src/lzw/ftzopen.h
@@ -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
+#define LZW_BIT_MASK 0x1f
+#define LZW_BLOCK_MASK 0x80
+#define LZW_MASK( n ) ( ( 1U << (n) ) - 1U )
-} FT_LzwPhase;
+ typedef enum
+ {+ FT_LZW_PHASE_START = 0,
+ FT_LZW_PHASE_CODE,
+ FT_LZW_PHASE_STACK,
+ FT_LZW_PHASE_EOF
-/* 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;
+ } FT_LzwPhase;
- 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 */
+ /*
+ * 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_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 */
+ typedef struct _FT_LzwStateRec
+ {+ FT_LzwPhase phase;
- 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_Int in_eof;
+ FT_Byte* in_cursor; /* current buffer pos */
+ FT_Byte* in_limit; /* current buffer limit */
- 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_UInt32 pad; /* a pad value where incoming bits were read */
+ FT_Int pad_bits; /* number of meaningful bits in pad value */
- FT_Byte* stack; /* character stack */
- FT_UInt stack_top;
- FT_UInt stack_size;
+ 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_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_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_Stream source; /* source stream */
- FT_Memory memory;
+ 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_LzwStateRec, *FT_LzwState;
+ 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_LOCAL( void )
-ft_lzwstate_init( FT_LzwState state,
- FT_Stream source );
+ FT_Stream source; /* source stream */
+ FT_Memory memory;
-FT_LOCAL( void )
-ft_lzwstate_done( FT_LzwState state );
+ } 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 */