ReactOS 0.4.15-dev-5893-g1bb4167
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
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 )
153
154 FT_LOCAL( void )
156
157
158 FT_LOCAL( void )
160
161
166
167/* */
168
169#endif /* FTZOPEN_H_ */
170
171
172/* END */
static int state
Definition: maze.c:121
#define FT_LOCAL(x)
Definition: ftconfig.h:387
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:108
unsigned long FT_ULong
Definition: fttypes.h:253
unsigned char FT_Byte
Definition: fttypes.h:154
unsigned short FT_UShort
Definition: fttypes.h:209
unsigned int FT_UInt
Definition: fttypes.h:231
size_t FT_Offset
Definition: fttypes.h:324
signed int FT_Int
Definition: fttypes.h:220
ft_lzwstate_init(FT_LzwState state, FT_Stream source)
Definition: ftzopen.c:208
struct FT_LzwStateRec_ FT_LzwStateRec
struct FT_LzwStateRec_ * FT_LzwState
FT_LzwPhase_
Definition: ftzopen.h:51
@ FT_LZW_PHASE_EOF
Definition: ftzopen.h:55
@ FT_LZW_PHASE_CODE
Definition: ftzopen.h:53
@ FT_LZW_PHASE_STACK
Definition: ftzopen.h:54
@ FT_LZW_PHASE_START
Definition: ftzopen.h:52
enum FT_LzwPhase_ FT_LzwPhase
ft_lzwstate_io(FT_LzwState state, FT_Byte *buffer, FT_ULong out_size)
Definition: ftzopen.c:256
#define FT_LZW_DEFAULT_STACK_SIZE
Definition: ftzopen.h:37
ft_lzwstate_reset(FT_LzwState state)
Definition: ftzopen.c:194
ft_lzwstate_done(FT_LzwState state)
Definition: ftzopen.c:228
GLuint buffer
Definition: glext.h:5915
static HANDLE PIO_APC_ROUTINE PVOID PIO_STATUS_BLOCK ULONG PVOID ULONG PVOID ULONG out_size
Definition: file.c:100
FT_UInt num_bits
Definition: ftzopen.h:128
FT_UInt max_bits
Definition: ftzopen.h:124
FT_Memory memory
Definition: ftzopen.h:145
FT_Stream source
Definition: ftzopen.h:144
FT_UInt old_code
Definition: ftzopen.h:131
FT_UInt old_char
Definition: ftzopen.h:132
FT_LzwPhase phase
Definition: ftzopen.h:115
FT_Byte * suffix
Definition: ftzopen.h:136
FT_UInt buf_offset
Definition: ftzopen.h:119
FT_UInt buf_size
Definition: ftzopen.h:120
FT_UInt max_free
Definition: ftzopen.h:126
FT_Offset buf_total
Definition: ftzopen.h:122
FT_UInt prefix_size
Definition: ftzopen.h:137
FT_UShort * prefix
Definition: ftzopen.h:135
FT_Int in_eof
Definition: ftzopen.h:116
FT_Byte buf_tab[16]
Definition: ftzopen.h:118
FT_Byte * stack
Definition: ftzopen.h:139
FT_Byte stack_0[FT_LZW_DEFAULT_STACK_SIZE]
Definition: ftzopen.h:142
FT_Int block_mode
Definition: ftzopen.h:125
FT_UInt stack_top
Definition: ftzopen.h:140
FT_Offset stack_size
Definition: ftzopen.h:141
FT_UInt free_bits
Definition: ftzopen.h:130
FT_Bool buf_clear
Definition: ftzopen.h:121
FT_UInt free_ent
Definition: ftzopen.h:129
FT_UInt in_code
Definition: ftzopen.h:133