1 /***************************************************************************/
5 /* FreeType support for .Z compressed files. */
7 /* This optional component relies on NetBSD's zopen(). It should mainly */
8 /* be used to parse compressed PCF fonts, as found with many X11 server */
11 /* Copyright 2005-2007, 2009, 2011 by David Turner. */
13 /* This file is part of the FreeType project, and may only be used, */
14 /* modified, and distributed under the terms of the FreeType project */
15 /* license, LICENSE.TXT. By continuing to use, modify, or distribute */
16 /* this file you indicate that you have read the license and */
17 /* understand and accept it fully. */
19 /***************************************************************************/
22 #include FT_INTERNAL_MEMORY_H
23 #include FT_INTERNAL_STREAM_H
24 #include FT_INTERNAL_DEBUG_H
28 ft_lzwstate_refill( FT_LzwState state )
36 count = FT_Stream_TryRead( state->source,
38 state->num_bits ); /* WHY? */
40 state->buf_size = (FT_UInt)count;
41 state->buf_total += count;
42 state->in_eof = FT_BOOL( count < state->num_bits );
43 state->buf_offset = 0;
44 state->buf_size = ( state->buf_size << 3 ) - ( state->num_bits - 1 );
46 if ( count == 0 ) /* end of file */
54 ft_lzwstate_get_code( FT_LzwState state )
56 FT_UInt num_bits = state->num_bits;
57 FT_Int offset = state->buf_offset;
62 if ( state->buf_clear ||
63 offset >= state->buf_size ||
64 state->free_ent >= state->free_bits )
66 if ( state->free_ent >= state->free_bits )
68 state->num_bits = ++num_bits;
69 state->free_bits = state->num_bits < state->max_bits
70 ? (FT_UInt)( ( 1UL << num_bits ) - 256 )
71 : state->max_free + 1;
74 if ( state->buf_clear )
76 state->num_bits = num_bits = LZW_INIT_BITS;
77 state->free_bits = (FT_UInt)( ( 1UL << num_bits ) - 256 );
81 if ( ft_lzwstate_refill( state ) < 0 )
87 state->buf_offset = offset + num_bits;
89 p = &state->buf_tab[offset >> 3];
91 result = *p++ >> offset;
97 result |= *p++ << offset;
102 result |= ( *p & LZW_MASK( num_bits ) ) << offset;
108 /* grow the character stack */
110 ft_lzwstate_stack_grow( FT_LzwState state )
112 if ( state->stack_top >= state->stack_size )
114 FT_Memory memory = state->memory;
116 FT_Offset old_size = state->stack_size;
117 FT_Offset new_size = old_size;
119 new_size = new_size + ( new_size >> 1 ) + 4;
121 if ( state->stack == state->stack_0 )
127 /* requirement of the character stack larger than 1<<LZW_MAX_BITS */
128 /* implies bug in the decompression code */
129 if ( new_size > ( 1 << LZW_MAX_BITS ) )
131 new_size = 1 << LZW_MAX_BITS;
132 if ( new_size == old_size )
136 if ( FT_RENEW_ARRAY( state->stack, old_size, new_size ) )
139 state->stack_size = new_size;
145 /* grow the prefix/suffix arrays */
147 ft_lzwstate_prefix_grow( FT_LzwState state )
149 FT_UInt old_size = state->prefix_size;
150 FT_UInt new_size = old_size;
151 FT_Memory memory = state->memory;
155 if ( new_size == 0 ) /* first allocation -> 9 bits */
158 new_size += new_size >> 2; /* don't grow too fast */
161 * Note that the `suffix' array is located in the same memory block
162 * pointed to by `prefix'.
164 * I know that sizeof(FT_Byte) == 1 by definition, but it is clearer
165 * to write it literally.
168 if ( FT_REALLOC_MULT( state->prefix, old_size, new_size,
169 sizeof ( FT_UShort ) + sizeof ( FT_Byte ) ) )
172 /* now adjust `suffix' and move the data accordingly */
173 state->suffix = (FT_Byte*)( state->prefix + new_size );
175 FT_MEM_MOVE( state->suffix,
176 state->prefix + old_size,
177 old_size * sizeof ( FT_Byte ) );
179 state->prefix_size = new_size;
185 ft_lzwstate_reset( FT_LzwState state )
188 state->buf_offset = 0;
190 state->buf_clear = 0;
191 state->buf_total = 0;
192 state->stack_top = 0;
193 state->num_bits = LZW_INIT_BITS;
194 state->phase = FT_LZW_PHASE_START;
199 ft_lzwstate_init( FT_LzwState state,
204 state->source = source;
205 state->memory = source->memory;
207 state->prefix = NULL;
208 state->suffix = NULL;
209 state->prefix_size = 0;
211 state->stack = state->stack_0;
212 state->stack_size = sizeof ( state->stack_0 );
214 ft_lzwstate_reset( state );
219 ft_lzwstate_done( FT_LzwState state )
221 FT_Memory memory = state->memory;
224 ft_lzwstate_reset( state );
226 if ( state->stack != state->stack_0 )
227 FT_FREE( state->stack );
229 FT_FREE( state->prefix );
230 state->suffix = NULL;
236 #define FTLZW_STACK_PUSH( c ) \
238 if ( state->stack_top >= state->stack_size && \
239 ft_lzwstate_stack_grow( state ) < 0 ) \
242 state->stack[state->stack_top++] = (FT_Byte)(c); \
246 FT_LOCAL_DEF( FT_ULong )
247 ft_lzwstate_io( FT_LzwState state,
253 FT_UInt old_char = state->old_char;
254 FT_UInt old_code = state->old_code;
255 FT_UInt in_code = state->in_code;
261 switch ( state->phase )
263 case FT_LZW_PHASE_START:
269 /* skip magic bytes, and read max_bits + block_flag */
270 if ( FT_Stream_Seek( state->source, 2 ) != 0 ||
271 FT_Stream_TryRead( state->source, &max_bits, 1 ) != 1 )
274 state->max_bits = max_bits & LZW_BIT_MASK;
275 state->block_mode = max_bits & LZW_BLOCK_MASK;
276 state->max_free = (FT_UInt)( ( 1UL << state->max_bits ) - 256 );
278 if ( state->max_bits > LZW_MAX_BITS )
281 state->num_bits = LZW_INIT_BITS;
282 state->free_ent = ( state->block_mode ? LZW_FIRST
286 state->free_bits = state->num_bits < state->max_bits
287 ? (FT_UInt)( ( 1UL << state->num_bits ) - 256 )
288 : state->max_free + 1;
290 c = ft_lzwstate_get_code( state );
291 if ( c < 0 || c > 255 )
294 old_code = old_char = (FT_UInt)c;
297 buffer[result] = (FT_Byte)old_char;
299 if ( ++result >= out_size )
302 state->phase = FT_LZW_PHASE_CODE;
306 case FT_LZW_PHASE_CODE:
313 c = ft_lzwstate_get_code( state );
319 if ( code == LZW_CLEAR && state->block_mode )
321 /* why not LZW_FIRST-256 ? */
322 state->free_ent = ( LZW_FIRST - 1 ) - 256;
323 state->buf_clear = 1;
325 /* not quite right, but at least more predictable */
332 in_code = code; /* save code for later */
336 /* special case for KwKwKwK */
337 if ( code - 256U >= state->free_ent )
339 /* corrupted LZW stream */
340 if ( code - 256U > state->free_ent )
343 FTLZW_STACK_PUSH( old_char );
347 while ( code >= 256U )
349 if ( !state->prefix )
352 FTLZW_STACK_PUSH( state->suffix[code - 256] );
353 code = state->prefix[code - 256];
358 FTLZW_STACK_PUSH( old_char );
360 state->phase = FT_LZW_PHASE_STACK;
364 case FT_LZW_PHASE_STACK:
366 while ( state->stack_top > 0 )
371 buffer[result] = state->stack[state->stack_top];
373 if ( ++result == out_size )
377 /* now create new entry */
378 if ( state->free_ent < state->max_free )
380 if ( state->free_ent >= state->prefix_size &&
381 ft_lzwstate_prefix_grow( state ) < 0 )
384 FT_ASSERT( state->free_ent < state->prefix_size );
386 state->prefix[state->free_ent] = (FT_UShort)old_code;
387 state->suffix[state->free_ent] = (FT_Byte) old_char;
389 state->free_ent += 1;
394 state->phase = FT_LZW_PHASE_CODE;
398 default: /* state == EOF */
403 state->old_code = old_code;
404 state->old_char = old_char;
405 state->in_code = in_code;
410 state->phase = FT_LZW_PHASE_EOF;