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