Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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