/***************************************************************************//*                                                                         *//*  ftzopen.h                                                              *//*                                                                         *//*    FreeType support for .Z compressed files.                            *//*                                                                         *//*  This optional component relies on NetBSD's zopen().  It should mainly  *//*  be used to parse compressed PCF fonts, as found with many X11 server   *//*  distributions.                                                         *//*                                                                         *//*  Copyright 2005, 2006 by David Turner.                                  *//*                                                                         *//*  This file is part of the FreeType project, and may only be used,       *//*  modified, and distributed under the terms of the FreeType project      *//*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     *//*  this file you indicate that you have read the license and              *//*  understand and accept it fully.                                        *//*                                                                         *//***************************************************************************/#ifndef __FT_ZOPEN_H__#define __FT_ZOPEN_H__#include <ft2build.h>#include FT_FREETYPE_H  /*   *  This is a complete re-implementation of the LZW file reader,   *  since the old one was incredibly badly written, using   *  400 KByte of heap memory before decompressing anything.   *   */#define FT_LZW_IN_BUFF_SIZE        64#define FT_LZW_DEFAULT_STACK_SIZE  64#define LZW_INIT_BITS     9#define LZW_MAX_BITS      16#define LZW_CLEAR         256#define LZW_FIRST         257#define LZW_BIT_MASK      0x1f#define LZW_BLOCK_MASK    0x80#define LZW_MASK( n )     ( ( 1U << (n) ) - 1U )  typedef enum  {    FT_LZW_PHASE_START = 0,    FT_LZW_PHASE_CODE,    FT_LZW_PHASE_STACK,    FT_LZW_PHASE_EOF  } FT_LzwPhase;  /*   *  state of LZW decompressor   *   *  small technical note   *  --------------------   *   *  We use a few tricks in this implementation that are explained here to   *  ease debugging and maintenance.   *   *  - First of all, the `prefix' and `suffix' arrays contain the suffix   *    and prefix for codes over 256; this means that   *   *      prefix_of(code) == state->prefix[code-256]   *      suffix_of(code) == state->suffix[code-256]   *   *    Each prefix is a 16-bit code, and each suffix an 8-bit byte.   *   *    Both arrays are stored in a single memory block, pointed to by   *    `state->prefix'.  This means that the following equality is always   *    true:   *   *      state->suffix == (FT_Byte*)(state->prefix + state->prefix_size)   *   *    Of course, state->prefix_size is the number of prefix/suffix slots   *    in the arrays, corresponding to codes 256..255+prefix_size.   *   *  - `free_ent' is the index of the next free entry in the `prefix'   *    and `suffix' arrays.  This means that the corresponding `next free   *    code' is really `256+free_ent'.   *   *    Moreover, `max_free' is the maximum value that `free_ent' can reach.   *   *    `max_free' corresponds to `(1 << max_bits) - 256'.  Note that this   *    value is always <= 0xFF00, which means that both `free_ent' and   *    `max_free' can be stored in an FT_UInt variable, even on 16-bit   *    machines.   *   *    If `free_ent == max_free', you cannot add new codes to the   *    prefix/suffix table.   *   *  - `num_bits' is the current number of code bits, starting at 9 and   *    growing each time `free_ent' reaches the value of `free_bits'.  The   *    latter is computed as follows   *   *      if num_bits < max_bits:   *         free_bits = (1 << num_bits)-256   *      else:   *         free_bits = max_free + 1   *   *    Since the value of `max_free + 1' can never be reached by   *    `free_ent', `num_bits' cannot grow larger than `max_bits'.   */  typedef struct  _FT_LzwStateRec  {    FT_LzwPhase  phase;    FT_Int       in_eof;    FT_Byte*     in_cursor;   /* current buffer pos   */    FT_Byte*     in_limit;    /* current buffer limit */    FT_UInt32    pad;         /* a pad value where incoming bits were read */    FT_Int       pad_bits;    /* number of meaningful bits in pad value    */    FT_UInt      max_bits;    /* max code bits, from file header   */    FT_Int       block_mode;  /* block mode flag, from file header */    FT_UInt      max_free;    /* (1 << max_bits) - 256             */    FT_UInt      num_bits;    /* current code bit number */    FT_UInt      free_ent;    /* index of next free entry */    FT_UInt      free_bits;   /* if reached by free_ent, increment num_bits */    FT_UInt      old_code;    FT_UInt      old_char;    FT_UInt      in_code;    FT_UShort*   prefix;      /* always dynamically allocated / reallocated */    FT_Byte*     suffix;      /* suffix = (FT_Byte*)(prefix + prefix_size)  */    FT_UInt      prefix_size; /* number of slots in `prefix' or `suffix'    */    FT_Byte*     stack;       /* character stack */    FT_UInt      stack_top;    FT_UInt      stack_size;    FT_Byte      in_buff[FT_LZW_IN_BUFF_SIZE];       /* small read-buffer   */    FT_Byte      stack_0[FT_LZW_DEFAULT_STACK_SIZE]; /* minimize heap alloc */    FT_Stream    source;      /* source stream */    FT_Memory    memory;  } FT_LzwStateRec, *FT_LzwState;  FT_LOCAL( void )  ft_lzwstate_init( FT_LzwState  state,                    FT_Stream    source );  FT_LOCAL( void )  ft_lzwstate_done( FT_LzwState  state );  FT_LOCAL( void )  ft_lzwstate_reset( FT_LzwState  state );  FT_LOCAL( FT_ULong )  ft_lzwstate_io( FT_LzwState  state,                  FT_Byte*     buffer,                  FT_ULong     out_size );/* */#endif /* __FT_ZOPEN_H__ *//* END */