← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to tests/freetype/src/lzw/ftzopen.h

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/freetype/src/lzw/ftzopen.h
 
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 */