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