ftzopen.h File Reference

#include <ft2build.h>

Include dependency graph for ftzopen.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	FT_LzwStateRec_

Macros
#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 )

Typedefs
typedef enum FT_LzwPhase_	FT_LzwPhase
typedef struct FT_LzwStateRec_	FT_LzwStateRec
typedef struct FT_LzwStateRec_ *	FT_LzwState

Enumerations
enum	FT_LzwPhase_ { FT_LZW_PHASE_START = 0, FT_LZW_PHASE_CODE, FT_LZW_PHASE_STACK, FT_LZW_PHASE_EOF }

Functions
	ft_lzwstate_init (FT_LzwState state, FT_Stream source)
	ft_lzwstate_done (FT_LzwState state)
	ft_lzwstate_reset (FT_LzwState state)
	ft_lzwstate_io (FT_LzwState state, FT_Byte *buffer, FT_ULong out_size)

Macro Definition Documentation

FT_LZW_DEFAULT_STACK_SIZE

#define FT_LZW_DEFAULT_STACK_SIZE   64

Definition at line 37 of file ftzopen.h.

FT_LZW_IN_BUFF_SIZE

#define FT_LZW_IN_BUFF_SIZE   64

Definition at line 36 of file ftzopen.h.

LZW_BIT_MASK

#define LZW_BIT_MASK   0x1F

Definition at line 45 of file ftzopen.h.

LZW_BLOCK_MASK

#define LZW_BLOCK_MASK   0x80

Definition at line 46 of file ftzopen.h.

LZW_CLEAR

#define LZW_CLEAR   256

Definition at line 42 of file ftzopen.h.

LZW_FIRST

#define LZW_FIRST   257

Definition at line 43 of file ftzopen.h.

LZW_INIT_BITS

#define LZW_INIT_BITS   9

Definition at line 39 of file ftzopen.h.

LZW_MASK

#define LZW_MASK

(

n

)

( ( 1U << (n) ) - 1U )

Definition at line 47 of file ftzopen.h.

LZW_MAX_BITS

#define LZW_MAX_BITS   16

Definition at line 40 of file ftzopen.h.

Typedef Documentation

FT_LzwPhase

typedef enum FT_LzwPhase_ FT_LzwPhase

FT_LzwState

typedef struct FT_LzwStateRec_ * FT_LzwState

FT_LzwStateRec

typedef struct FT_LzwStateRec_ FT_LzwStateRec

Enumeration Type Documentation

FT_LzwPhase_

enum FT_LzwPhase_

Enumerator
FT_LZW_PHASE_START
FT_LZW_PHASE_CODE
FT_LZW_PHASE_STACK
FT_LZW_PHASE_EOF

Definition at line 50 of file ftzopen.h.

  {
    FT_LZW_PHASE_START = 0,
    FT_LZW_PHASE_CODE,
    FT_LZW_PHASE_STACK,
    FT_LZW_PHASE_EOF

  } FT_LzwPhase;

Function Documentation

ft_lzwstate_done()

ft_lzwstate_done

(

FT_LzwState

state

)

Definition at line 228 of file ftzopen.c.

  {
    FT_Memory  memory = state->memory;


    ft_lzwstate_reset( state );

    if ( state->stack != state->stack_0 )
      FT_FREE( state->stack );

    FT_FREE( state->prefix );
    state->suffix = NULL;

    FT_ZERO( state );
  }

ft_lzwstate_init()

ft_lzwstate_init	(	FT_LzwState	state,
		FT_Stream	source
	)

Definition at line 208 of file ftzopen.c.

  {
    FT_ZERO( state );

    state->source = source;
    state->memory = source->memory;

    state->prefix      = NULL;
    state->suffix      = NULL;
    state->prefix_size = 0;

    state->stack      = state->stack_0;
    state->stack_size = sizeof ( state->stack_0 );

    ft_lzwstate_reset( state );
  }

ft_lzwstate_io()

ft_lzwstate_io	(	FT_LzwState	state,
		FT_Byte *	buffer,
		FT_ULong	out_size
	)

Definition at line 256 of file ftzopen.c.

  {
    FT_ULong  result = 0;

    FT_UInt  old_char = state->old_char;
    FT_UInt  old_code = state->old_code;
    FT_UInt  in_code  = state->in_code;


    if ( out_size == 0 )
      goto Exit;

    switch ( state->phase )
    {
    case FT_LZW_PHASE_START:
      {
        FT_Byte   max_bits;
        FT_Int32  c;


        /* skip magic bytes, and read max_bits + block_flag */
        if ( FT_Stream_Seek( state->source, 2 ) != 0               ||
             FT_Stream_TryRead( state->source, &max_bits, 1 ) != 1 )
          goto Eof;

        state->max_bits   = max_bits & LZW_BIT_MASK;
        state->block_mode = max_bits & LZW_BLOCK_MASK;
        state->max_free   = (FT_UInt)( ( 1UL << state->max_bits ) - 256 );

        if ( state->max_bits > LZW_MAX_BITS )
          goto Eof;

        state->num_bits = LZW_INIT_BITS;
        state->free_ent = ( state->block_mode ? LZW_FIRST
                                              : LZW_CLEAR ) - 256;
        in_code  = 0;

        state->free_bits = state->num_bits < state->max_bits
                           ? (FT_UInt)( ( 1UL << state->num_bits ) - 256 )
                           : state->max_free + 1;

        c = ft_lzwstate_get_code( state );
        if ( c < 0 || c > 255 )
          goto Eof;

        old_code = old_char = (FT_UInt)c;

        if ( buffer )
          buffer[result] = (FT_Byte)old_char;

        if ( ++result >= out_size )
          goto Exit;

        state->phase = FT_LZW_PHASE_CODE;
      }
      /* fall-through */

    case FT_LZW_PHASE_CODE:
      {
        FT_Int32  c;
        FT_UInt   code;


      NextCode:
        c = ft_lzwstate_get_code( state );
        if ( c < 0 )
          goto Eof;

        code = (FT_UInt)c;

        if ( code == LZW_CLEAR && state->block_mode )
        {
          /* why not LZW_FIRST-256 ? */
          state->free_ent  = ( LZW_FIRST - 1 ) - 256;
          state->buf_clear = 1;

          /* not quite right, but at least more predictable */
          old_code = 0;
          old_char = 0;

          goto NextCode;
        }

        in_code = code; /* save code for later */

        if ( code >= 256U )
        {
          /* special case for KwKwKwK */
          if ( code - 256U >= state->free_ent )
          {
            /* corrupted LZW stream */
            if ( code - 256U > state->free_ent )
              goto Eof;

            FTLZW_STACK_PUSH( old_char );
            code = old_code;
          }

          while ( code >= 256U )
          {
            if ( !state->prefix )
              goto Eof;

            FTLZW_STACK_PUSH( state->suffix[code - 256] );
            code = state->prefix[code - 256];
          }
        }

        old_char = code;
        FTLZW_STACK_PUSH( old_char );

        state->phase = FT_LZW_PHASE_STACK;
      }
      /* fall-through */

    case FT_LZW_PHASE_STACK:
      {
        while ( state->stack_top > 0 )
        {
          state->stack_top--;

          if ( buffer )
            buffer[result] = state->stack[state->stack_top];

          if ( ++result == out_size )
            goto Exit;
        }

        /* now create new entry */
        if ( state->free_ent < state->max_free )
        {
          if ( state->free_ent >= state->prefix_size &&
               ft_lzwstate_prefix_grow( state ) < 0  )
            goto Eof;

          FT_ASSERT( state->free_ent < state->prefix_size );

          state->prefix[state->free_ent] = (FT_UShort)old_code;
          state->suffix[state->free_ent] = (FT_Byte)  old_char;

          state->free_ent += 1;
        }

        old_code = in_code;

        state->phase = FT_LZW_PHASE_CODE;
        goto NextCode;
      }

    default:  /* state == EOF */
      ;
    }

  Exit:
    state->old_code = old_code;
    state->old_char = old_char;
    state->in_code  = in_code;

    return result;

  Eof:
    state->phase = FT_LZW_PHASE_EOF;
    goto Exit;
  }

ft_lzwstate_reset()

ft_lzwstate_reset

(

FT_LzwState

state

)

Definition at line 194 of file ftzopen.c.

  {
    state->in_eof     = 0;
    state->buf_offset = 0;
    state->buf_size   = 0;
    state->buf_clear  = 0;
    state->buf_total  = 0;
    state->stack_top  = 0;
    state->num_bits   = LZW_INIT_BITS;
    state->phase      = FT_LZW_PHASE_START;
  }

Referenced by ft_lzwstate_done(), and ft_lzwstate_init().