freetype2/src/lzw/ftzopen.c

/***************************************************************************/
/*                                                                         */
/*  ftzopen.c                                                              */
/*                                                                         */
/*    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 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.                                        */
/*                                                                         */
/***************************************************************************/

#include "ftzopen.h"
#include FT_INTERNAL_MEMORY_H
#include FT_INTERNAL_STREAM_H
#include FT_INTERNAL_DEBUG_H

/* refill input buffer, return 0 on success, or -1 if eof
 */
static int
ft_lzwstate_refill( FT_LzwState  state )
{
  int  result = -1;

  if ( !state->in_eof )
  {
    FT_ULong  count = FT_Stream_TryRead( state->source,
                                         state->in_buff,
                                         sizeof( state->in_buff ) );

    state->in_cursor = state->in_buff;
    state->in_limit  = state->in_buff + count;
    state->in_eof    = FT_BOOL( count < sizeof( state->in_buff ) );

    if ( count > 0 )
      result = 0;
  }
  return result;
}


/* return new code of 'num_bits', or -1 if eof
 */
static FT_Int32
ft_lzwstate_get_code( FT_LzwState  state,
                      FT_UInt      num_bits )
{
  FT_Int32   result   = -1;
  FT_UInt32  pad      = state->pad;
  FT_UInt    pad_bits = state->pad_bits;

  while ( num_bits > pad_bits )
  {
    if ( state->in_cursor >= state->in_limit &&
         ft_lzwstate_refill( state ) < 0    )
      goto Exit;

    pad      |= (FT_UInt32)(*state->in_cursor++) << pad_bits;
    pad_bits += 8;
  }

  result          = (FT_Int32)( pad & LZW_MASK(num_bits) );
  state->pad_bits = pad_bits - num_bits;
  state->pad      = pad >> num_bits;

Exit:
  return result;
}


/* grow the character stack
 */
static int
ft_lzwstate_stack_grow( FT_LzwState  state )
{
  if ( state->stack_top >= state->stack_size )
  {
    FT_Memory  memory = state->memory;
    FT_Error   error;
    FT_UInt    old_size = state->stack_size;
    FT_UInt    new_size = old_size;

    new_size = new_size + (new_size >> 1) + 4;

    if ( state->stack == state->stack_0 )
    {
      state->stack = NULL;
      old_size     = 0;
    }

    if ( FT_RENEW_ARRAY( state->stack, old_size, new_size ) )
      return -1;

    state->stack_size = new_size;
  }
  return 0;
}


/* grow the prefix/suffix arrays
 */
static int
ft_lzwstate_prefix_grow( FT_LzwState  state )
{
  FT_UInt    old_size = state->prefix_size;
  FT_UInt    new_size = old_size;
  FT_Memory  memory   = state->memory;
  FT_Error   error;

  if ( new_size == 0 )  /* first allocation -> 9 bits */
    new_size = 512;
  else
    new_size += (new_size >> 2);  /* don't grow too fast */

 /* note that the 'suffix' array is located in the same memory block
  * pointed to by 'prefix'
  *
  * I know that sizeof(FT_Byte) == 1 by definition, but it's clearer
  * to write it literally
  */
  if ( FT_REALLOC( state->prefix,
                   old_size*(sizeof(FT_UShort)+sizeof(FT_Byte)),
                   new_size*(sizeof(FT_UShort)+sizeof(FT_Byte)) ) )
    return -1;

  /* now adjust 'suffix' and move the data accordingly */
  state->suffix = (FT_Byte*)(state->prefix + new_size);

  FT_MEM_MOVE( state->suffix,
               state->prefix + old_size,
               old_size * sizeof(FT_Byte) );

  state->prefix_size = new_size;
  return 0;
}


FT_LOCAL_DEF( void )
ft_lzwstate_reset( FT_LzwState  state )
{
  state->in_cursor = state->in_buff;
  state->in_limit  = state->in_buff;
  state->in_eof    = 0;
  state->pad_bits  = 0;
  state->pad       = 0;

  state->stack_top  = 0;
  state->num_bits   = LZW_INIT_BITS;
  state->phase      = FT_LZW_PHASE_START;
}


FT_LOCAL_DEF( void )
ft_lzwstate_init( FT_LzwState  state,
                   FT_Stream    source )
{
  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_LOCAL_DEF( void )
ft_lzwstate_done( FT_LzwState  state )
{
  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 );
}


#define  FTLZW_STACK_PUSH(c)                               \
  FT_BEGIN_STMNT                                           \
    if ( state->stack_top >= state->stack_size &&          \
         ft_lzwstate_stack_grow( state ) < 0   )           \
      goto Eof;                                            \
                                                           \
    state->stack[ state->stack_top++ ] = (FT_Byte)(c);     \
  FT_END_STMNT



FT_LOCAL_DEF( FT_ULong )
ft_lzwstate_io( FT_LzwState  state,
                FT_Byte*     buffer,
                FT_ULong     out_size )
{
  FT_ULong  result   = 0;

  FT_UInt   num_bits = state->num_bits;
  FT_UInt   free_ent = state->free_ent;
  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;

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

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

        c = ft_lzwstate_get_code( state, num_bits );
        if ( c < 0 )
          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, num_bits );
        if ( c < 0 ) goto Eof;

        code = (FT_UInt)c;

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

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

          c = ft_lzwstate_get_code( state, num_bits );
          if ( c < 0 ) goto Eof;

          code = (FT_UInt)c;
        }

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

        if ( code >= 256U )
        {
          /* special case for KwKwKwK */
          if ( code-256U >= free_ent )
          {
            FTLZW_STACK_PUSH( old_char );
            code = old_code;
          }

          while ( code >= 256U )
          {
            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 ( free_ent < state->max_free )
        {
          if ( free_ent >= state->prefix_size       &&
               ft_lzwstate_prefix_grow( state ) < 0 )
            goto Eof;

          FT_ASSERT( free_ent < state->prefix_size );

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

          if ( ++free_ent == state->free_bits )
          {
            num_bits++;

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

        old_code = in_code;

        state->phase = FT_LZW_PHASE_CODE;
        goto NextCode;
      }

    default:  /* state == EOF */
      ;
  }
Exit:
  state->num_bits = num_bits;
  state->free_ent = free_ent;
  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;
}