Subversion Repositories Kolibri OS

/***************************************************************************/

/*                                                                         */

/*  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-2007, 2009, 2011 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

  static int

  ft_lzwstate_refill( FT_LzwState  state )

  {

    FT_ULong  count;

    if ( state->in_eof )

      return -1;

    count = FT_Stream_TryRead( state->source,

                               state->buf_tab,

                               state->num_bits );  /* WHY? */

    state->buf_size   = (FT_UInt)count;

    state->buf_total += count;

    state->in_eof     = FT_BOOL( count < state->num_bits );

    state->buf_offset = 0;

    state->buf_size   = ( state->buf_size << 3 ) - ( state->num_bits - 1 );

    if ( count == 0 )  /* end of file */

      return -1;

    return 0;

  }

  static FT_Int32

  ft_lzwstate_get_code( FT_LzwState  state )

  {

    FT_UInt   num_bits = state->num_bits;

    FT_Int    offset   = state->buf_offset;

    FT_Byte*  p;

    FT_Int    result;

    if ( state->buf_clear                    ||

         offset >= state->buf_size           ||

         state->free_ent >= state->free_bits )

    {

      if ( state->free_ent >= state->free_bits )

      {

        state->num_bits  = ++num_bits;

        state->free_bits = state->num_bits < state->max_bits

                           ? (FT_UInt)( ( 1UL << num_bits ) - 256 )

                           : state->max_free + 1;

      }

      if ( state->buf_clear )

      {

        state->num_bits  = num_bits = LZW_INIT_BITS;

        state->free_bits = (FT_UInt)( ( 1UL << num_bits ) - 256 );

        state->buf_clear = 0;

      }

      if ( ft_lzwstate_refill( state ) < 0 )

        return -1;

      offset = 0;

    }

    state->buf_offset = offset + num_bits;

    p         = &state->buf_tab[offset >> 3];

    offset   &= 7;

    result    = *p++ >> offset;

    offset    = 8 - offset;

    num_bits -= offset;

    if ( num_bits >= 8 )

    {

      result   |= *p++ << offset;

      offset   += 8;

      num_bits -= 8;

    }

    if ( num_bits > 0 )

      result |= ( *p & LZW_MASK( num_bits ) ) << offset;

    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_Offset  old_size = state->stack_size;

      FT_Offset  new_size = old_size;

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

      if ( state->stack == state->stack_0 )

      {

        state->stack = NULL;

        old_size     = 0;

      }

      /* requirement of the character stack larger than 1<

      /* implies bug in the decompression code                          */

      if ( new_size > ( 1 << LZW_MAX_BITS ) )

      {

        new_size = 1 << LZW_MAX_BITS;

        if ( new_size == old_size )

          return -1;

      }

      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 is clearer

     *  to write it literally.

     *

     */

    if ( FT_REALLOC_MULT( state->prefix, old_size, 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_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;

  }

  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  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;

  }

/* END */