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 (C) 2005-2023 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 <freetype/freetype.h>
  26
  27 FT_BEGIN_HEADER
  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   {
  52     FT_LZW_PHASE_START = 0,
  53     FT_LZW_PHASE_CODE,
  54     FT_LZW_PHASE_STACK,
  55     FT_LZW_PHASE_EOF
  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   {
 115     FT_LzwPhase  phase;
 116     FT_Int       in_eof;
 117
 118     FT_Byte      buf_tab[16];
 119     FT_UInt      buf_offset;
 120     FT_UInt      buf_size;
 121     FT_Bool      buf_clear;
 122     FT_Offset    buf_total;
 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 */
 131     FT_UInt      old_code;
 132     FT_UInt      old_char;
 133     FT_UInt      in_code;
 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 */
 140     FT_UInt      stack_top;
 141     FT_Offset    stack_size;
 142     FT_Byte      stack_0[FT_LZW_DEFAULT_STACK_SIZE]; /* minimize heap alloc */
 143
 144     FT_Stream    source;      /* source stream */
 145     FT_Memory    memory;
 146
 147   } FT_LzwStateRec, *FT_LzwState;
 148
 149
 150   FT_LOCAL( void )
 151   ft_lzwstate_init( FT_LzwState  state,
 152                     FT_Stream    source );
 153
 154   FT_LOCAL( void )
 155   ft_lzwstate_done( FT_LzwState  state );
 156
 157
 158   FT_LOCAL( void )
 159   ft_lzwstate_reset( FT_LzwState  state );
 160
 161
 162   FT_LOCAL( FT_ULong )
 163   ft_lzwstate_io( FT_LzwState  state,
 164                   FT_Byte*     buffer,
 165                   FT_ULong     out_size );
 166
 167 /* */
 168
 169 FT_END_HEADER
 170
 171 #endif /* FTZOPEN_H_ */
 172
 173
 174 /* END */