ReactOS  0.4.14-dev-583-g2a1ba2c
ftzopen.h
Go to the documentation of this file.
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-2018 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 <ft2build.h>
26 #include FT_FREETYPE_H
27 
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  {
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  {
117 
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 */
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 */
142  FT_Byte stack_0[FT_LZW_DEFAULT_STACK_SIZE]; /* minimize heap alloc */
143 
144  FT_Stream source; /* source stream */
146 
148 
149 
150  FT_LOCAL( void )
152  FT_Stream source );
153 
154  FT_LOCAL( void )
156 
157 
158  FT_LOCAL( void )
160 
161 
162  FT_LOCAL( FT_ULong )
164  FT_Byte* buffer,
165  FT_ULong out_size );
166 
167 /* */
168 
169 #endif /* FTZOPEN_H_ */
170 
171 
172 /* END */
FT_UInt old_code
Definition: ftzopen.h:131
struct FT_LzwStateRec_ * FT_LzwState
static HANDLE PIO_APC_ROUTINE PVOID PIO_STATUS_BLOCK ULONG PVOID ULONG PVOID ULONG out_size
Definition: file.c:100
unsigned long FT_ULong
Definition: fttypes.h:253
FT_UInt max_free
Definition: ftzopen.h:126
signed int FT_Int
Definition: fttypes.h:220
FT_UInt old_char
Definition: ftzopen.h:132
FT_UInt buf_size
Definition: ftzopen.h:120
FT_LzwPhase phase
Definition: ftzopen.h:115
FT_UInt buf_offset
Definition: ftzopen.h:119
ft_lzwstate_init(FT_LzwState state, FT_Stream source)
Definition: ftzopen.c:208
GLuint buffer
Definition: glext.h:5915
FT_Memory memory
Definition: ftzopen.h:145
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:108
#define FT_LZW_DEFAULT_STACK_SIZE
Definition: ftzopen.h:37
FT_UInt free_bits
Definition: ftzopen.h:130
unsigned char FT_Byte
Definition: fttypes.h:154
FT_UInt in_code
Definition: ftzopen.h:133
#define FT_LOCAL(x)
Definition: ftconfig.h:387
FT_UInt num_bits
Definition: ftzopen.h:128
FT_Int block_mode
Definition: ftzopen.h:125
FT_Byte buf_tab[16]
Definition: ftzopen.h:118
struct FT_LzwStateRec_ FT_LzwStateRec
FT_UInt free_ent
Definition: ftzopen.h:129
FT_Offset stack_size
Definition: ftzopen.h:141
FT_UInt max_bits
Definition: ftzopen.h:124
ft_lzwstate_reset(FT_LzwState state)
Definition: ftzopen.c:194
static int state
Definition: maze.c:121
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
FT_UShort * prefix
Definition: ftzopen.h:135
FT_Byte * suffix
Definition: ftzopen.h:136
FT_Byte stack_0[FT_LZW_DEFAULT_STACK_SIZE]
Definition: ftzopen.h:142
ft_lzwstate_io(FT_LzwState state, FT_Byte *buffer, FT_ULong out_size)
Definition: ftzopen.c:256
unsigned int FT_UInt
Definition: fttypes.h:231
FT_UInt prefix_size
Definition: ftzopen.h:137
FT_UInt stack_top
Definition: ftzopen.h:140
enum FT_LzwPhase_ FT_LzwPhase
FT_Stream source
Definition: ftzopen.h:144
ft_lzwstate_done(FT_LzwState state)
Definition: ftzopen.c:228
FT_LzwPhase_
Definition: ftzopen.h:50
unsigned short FT_UShort
Definition: fttypes.h:209
FT_Int in_eof
Definition: ftzopen.h:116
FT_Offset buf_total
Definition: ftzopen.h:122
size_t FT_Offset
Definition: fttypes.h:324
FT_Byte * stack
Definition: ftzopen.h:139
FT_Bool buf_clear
Definition: ftzopen.h:121