disabling the discovery of SDL13+ on desktop. SDL13 has become SDL2 with a completely different ABI and will require a new FindSDL2 module for Cmake to be found; for current sdl development installations, hedgewars will either use the compatibility layer (present in sdl1.3 but not in sdl2) or just fail to build (in case sdl2 is installed but sdl1.2.* is not). whew
/***************************************************************************/
/* */
/* 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, 2006, 2007, 2009 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;
}
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 )
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;
c = ft_lzwstate_get_code( state );
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 >= state->free_ent )
{
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 */