1 /***************************************************************************/ 2 /* */ 3 /* ftzopen.h */ 4 /* */ 5 /* FreeType support for .Z compressed files. */ 6 /* */ 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 */ 9 /* distributions. */ 10 /* */ 11 /* Copyright 2005, 2006, 2007, 2008 by David Turner. */ 12 /* */ 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. */ 18 /* */ 19 /***************************************************************************/ 20 21 #ifndef __FT_ZOPEN_H__ 22 #define __FT_ZOPEN_H__ 23 24 #include <ft2build.h> 25 #include FT_FREETYPE_H 26 27 28 /* 29 * This is a complete re-implementation of the LZW file reader, 30 * since the old one was incredibly badly written, using 31 * 400 KByte of heap memory before decompressing anything. 32 * 33 */ 34 35 #define FT_LZW_IN_BUFF_SIZE 64 36 #define FT_LZW_DEFAULT_STACK_SIZE 64 37 38 #define LZW_INIT_BITS 9 39 #define LZW_MAX_BITS 16 40 41 #define LZW_CLEAR 256 42 #define LZW_FIRST 257 43 44 #define LZW_BIT_MASK 0x1f 45 #define LZW_BLOCK_MASK 0x80 46 #define LZW_MASK( n ) ( ( 1U << (n) ) - 1U ) 47 48 49 typedef enum FT_LzwPhase_ 50 { 51 FT_LZW_PHASE_START = 0, 52 FT_LZW_PHASE_CODE, 53 FT_LZW_PHASE_STACK, 54 FT_LZW_PHASE_EOF 55 56 } FT_LzwPhase; 57 58 59 /* 60 * state of LZW decompressor 61 * 62 * small technical note 63 * -------------------- 64 * 65 * We use a few tricks in this implementation that are explained here to 66 * ease debugging and maintenance. 67 * 68 * - First of all, the `prefix' and `suffix' arrays contain the suffix 69 * and prefix for codes over 256; this means that 70 * 71 * prefix_of(code) == state->prefix[code-256] 72 * suffix_of(code) == state->suffix[code-256] 73 * 74 * Each prefix is a 16-bit code, and each suffix an 8-bit byte. 75 * 76 * Both arrays are stored in a single memory block, pointed to by 77 * `state->prefix'. This means that the following equality is always 78 * true: 79 * 80 * state->suffix == (FT_Byte*)(state->prefix + state->prefix_size) 81 * 82 * Of course, state->prefix_size is the number of prefix/suffix slots 83 * in the arrays, corresponding to codes 256..255+prefix_size. 84 * 85 * - `free_ent' is the index of the next free entry in the `prefix' 86 * and `suffix' arrays. This means that the corresponding `next free 87 * code' is really `256+free_ent'. 88 * 89 * Moreover, `max_free' is the maximum value that `free_ent' can reach. 90 * 91 * `max_free' corresponds to `(1 << max_bits) - 256'. Note that this 92 * value is always <= 0xFF00, which means that both `free_ent' and 93 * `max_free' can be stored in an FT_UInt variable, even on 16-bit 94 * machines. 95 * 96 * If `free_ent == max_free', you cannot add new codes to the 97 * prefix/suffix table. 98 * 99 * - `num_bits' is the current number of code bits, starting at 9 and 100 * growing each time `free_ent' reaches the value of `free_bits'. The 101 * latter is computed as follows 102 * 103 * if num_bits < max_bits: 104 * free_bits = (1 << num_bits)-256 105 * else: 106 * free_bits = max_free + 1 107 * 108 * Since the value of `max_free + 1' can never be reached by 109 * `free_ent', `num_bits' cannot grow larger than `max_bits'. 110 */ 111 112 typedef struct FT_LzwStateRec_ 113 { 114 FT_LzwPhase phase; 115 FT_Int in_eof; 116 117 FT_Byte buf_tab[16]; 118 FT_Int buf_offset; 119 FT_Int buf_size; 120 FT_Bool buf_clear; 121 FT_Offset buf_total; 122 123 FT_UInt max_bits; /* max code bits, from file header */ 124 FT_Int block_mode; /* block mode flag, from file header */ 125 FT_UInt max_free; /* (1 << max_bits) - 256 */ 126 127 FT_UInt num_bits; /* current code bit number */ 128 FT_UInt free_ent; /* index of next free entry */ 129 FT_UInt free_bits; /* if reached by free_ent, increment num_bits */ 130 FT_UInt old_code; 131 FT_UInt old_char; 132 FT_UInt in_code; 133 134 FT_UShort* prefix; /* always dynamically allocated / reallocated */ 135 FT_Byte* suffix; /* suffix = (FT_Byte*)(prefix + prefix_size) */ 136 FT_UInt prefix_size; /* number of slots in `prefix' or `suffix' */ 137 138 FT_Byte* stack; /* character stack */ 139 FT_UInt stack_top; 140 FT_Offset stack_size; 141 FT_Byte stack_0[FT_LZW_DEFAULT_STACK_SIZE]; /* minimize heap alloc */ 142 143 FT_Stream source; /* source stream */ 144 FT_Memory memory; 145 146 } FT_LzwStateRec, *FT_LzwState; 147 148 149 FT_LOCAL( void ) 150 ft_lzwstate_init( FT_LzwState state, 151 FT_Stream source ); 152 153 FT_LOCAL( void ) 154 ft_lzwstate_done( FT_LzwState state ); 155 156 157 FT_LOCAL( void ) 158 ft_lzwstate_reset( FT_LzwState state ); 159 160 161 FT_LOCAL( FT_ULong ) 162 ft_lzwstate_io( FT_LzwState state, 163 FT_Byte* buffer, 164 FT_ULong out_size ); 165 166 /* */ 167 168 #endif /* __FT_ZOPEN_H__ */ 169 170 171 /* END */ 172