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 */ |
|