/***************************************************************************/ | |
/* */ | |
/* ftstream.c */ | |
/* */ | |
/* I/O stream support (body). */ | |
/* */ | |
/* Copyright 2000-2015 by */ | |
/* David Turner, Robert Wilhelm, and Werner Lemberg. */ | |
/* */ | |
/* 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 <ft2build.h> | |
#include FT_INTERNAL_STREAM_H | |
#include FT_INTERNAL_DEBUG_H | |
/*************************************************************************/ | |
/* */ | |
/* The macro FT_COMPONENT is used in trace mode. It is an implicit */ | |
/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ | |
/* messages during execution. */ | |
/* */ | |
#undef FT_COMPONENT | |
#define FT_COMPONENT trace_stream | |
FT_BASE_DEF( void ) | |
FT_Stream_OpenMemory( FT_Stream stream, | |
const FT_Byte* base, | |
FT_ULong size ) | |
{ | |
stream->base = (FT_Byte*) base; | |
stream->size = size; | |
stream->pos = 0; | |
stream->cursor = NULL; | |
stream->read = NULL; | |
stream->close = NULL; | |
} | |
FT_BASE_DEF( void ) | |
FT_Stream_Close( FT_Stream stream ) | |
{ | |
if ( stream && stream->close ) | |
stream->close( stream ); | |
} | |
FT_BASE_DEF( FT_Error ) | |
FT_Stream_Seek( FT_Stream stream, | |
FT_ULong pos ) | |
{ | |
FT_Error error = FT_Err_Ok; | |
if ( stream->read ) | |
{ | |
if ( stream->read( stream, pos, 0, 0 ) ) | |
{ | |
FT_ERROR(( "FT_Stream_Seek:" | |
" invalid i/o; pos = 0x%lx, size = 0x%lx\n", | |
pos, stream->size )); | |
error = FT_THROW( Invalid_Stream_Operation ); | |
} | |
} | |
/* note that seeking to the first position after the file is valid */ | |
else if ( pos > stream->size ) | |
{ | |
FT_ERROR(( "FT_Stream_Seek:" | |
" invalid i/o; pos = 0x%lx, size = 0x%lx\n", | |
pos, stream->size )); | |
error = FT_THROW( Invalid_Stream_Operation ); | |
} | |
if ( !error ) | |
stream->pos = pos; | |
return error; | |
} | |
FT_BASE_DEF( FT_Error ) | |
FT_Stream_Skip( FT_Stream stream, | |
FT_Long distance ) | |
{ | |
if ( distance < 0 ) | |
return FT_THROW( Invalid_Stream_Operation ); | |
return FT_Stream_Seek( stream, stream->pos + (FT_ULong)distance ); | |
} | |
FT_BASE_DEF( FT_ULong ) | |
FT_Stream_Pos( FT_Stream stream ) | |
{ | |
return stream->pos; | |
} | |
FT_BASE_DEF( FT_Error ) | |
FT_Stream_Read( FT_Stream stream, | |
FT_Byte* buffer, | |
FT_ULong count ) | |
{ | |
return FT_Stream_ReadAt( stream, stream->pos, buffer, count ); | |
} | |
FT_BASE_DEF( FT_Error ) | |
FT_Stream_ReadAt( FT_Stream stream, | |
FT_ULong pos, | |
FT_Byte* buffer, | |
FT_ULong count ) | |
{ | |
FT_Error error = FT_Err_Ok; | |
FT_ULong read_bytes; | |
if ( pos >= stream->size ) | |
{ | |
FT_ERROR(( "FT_Stream_ReadAt:" | |
" invalid i/o; pos = 0x%lx, size = 0x%lx\n", | |
pos, stream->size )); | |
return FT_THROW( Invalid_Stream_Operation ); | |
} | |
if ( stream->read ) | |
read_bytes = stream->read( stream, pos, buffer, count ); | |
else | |
{ | |
read_bytes = stream->size - pos; | |
if ( read_bytes > count ) | |
read_bytes = count; | |
FT_MEM_COPY( buffer, stream->base + pos, read_bytes ); | |
} | |
stream->pos = pos + read_bytes; | |
if ( read_bytes < count ) | |
{ | |
FT_ERROR(( "FT_Stream_ReadAt:" | |
" invalid read; expected %lu bytes, got %lu\n", | |
count, read_bytes )); | |
error = FT_THROW( Invalid_Stream_Operation ); | |
} | |
return error; | |
} | |
FT_BASE_DEF( FT_ULong ) | |
FT_Stream_TryRead( FT_Stream stream, | |
FT_Byte* buffer, | |
FT_ULong count ) | |
{ | |
FT_ULong read_bytes = 0; | |
if ( stream->pos >= stream->size ) | |
goto Exit; | |
if ( stream->read ) | |
read_bytes = stream->read( stream, stream->pos, buffer, count ); | |
else | |
{ | |
read_bytes = stream->size - stream->pos; | |
if ( read_bytes > count ) | |
read_bytes = count; | |
FT_MEM_COPY( buffer, stream->base + stream->pos, read_bytes ); | |
} | |
stream->pos += read_bytes; | |
Exit: | |
return read_bytes; | |
} | |
FT_BASE_DEF( FT_Error ) | |
FT_Stream_ExtractFrame( FT_Stream stream, | |
FT_ULong count, | |
FT_Byte** pbytes ) | |
{ | |
FT_Error error; | |
error = FT_Stream_EnterFrame( stream, count ); | |
if ( !error ) | |
{ | |
*pbytes = (FT_Byte*)stream->cursor; | |
/* equivalent to FT_Stream_ExitFrame(), with no memory block release */ | |
stream->cursor = NULL; | |
stream->limit = NULL; | |
} | |
return error; | |
} | |
FT_BASE_DEF( void ) | |
FT_Stream_ReleaseFrame( FT_Stream stream, | |
FT_Byte** pbytes ) | |
{ | |
if ( stream && stream->read ) | |
{ | |
FT_Memory memory = stream->memory; | |
#ifdef FT_DEBUG_MEMORY | |
ft_mem_free( memory, *pbytes ); | |
*pbytes = NULL; | |
#else | |
FT_FREE( *pbytes ); | |
#endif | |
} | |
*pbytes = NULL; | |
} | |
FT_BASE_DEF( FT_Error ) | |
FT_Stream_EnterFrame( FT_Stream stream, | |
FT_ULong count ) | |
{ | |
FT_Error error = FT_Err_Ok; | |
FT_ULong read_bytes; | |
/* check for nested frame access */ | |
FT_ASSERT( stream && stream->cursor == 0 ); | |
if ( stream->read ) | |
{ | |
/* allocate the frame in memory */ | |
FT_Memory memory = stream->memory; | |
/* simple sanity check */ | |
if ( count > stream->size ) | |
{ | |
FT_ERROR(( "FT_Stream_EnterFrame:" | |
" frame size (%lu) larger than stream size (%lu)\n", | |
count, stream->size )); | |
error = FT_THROW( Invalid_Stream_Operation ); | |
goto Exit; | |
} | |
#ifdef FT_DEBUG_MEMORY | |
/* assume _ft_debug_file and _ft_debug_lineno are already set */ | |
stream->base = (unsigned char*)ft_mem_qalloc( memory, | |
(FT_Long)count, | |
&error ); | |
if ( error ) | |
goto Exit; | |
#else | |
if ( FT_QALLOC( stream->base, count ) ) | |
goto Exit; | |
#endif | |
/* read it */ | |
read_bytes = stream->read( stream, stream->pos, | |
stream->base, count ); | |
if ( read_bytes < count ) | |
{ | |
FT_ERROR(( "FT_Stream_EnterFrame:" | |
" invalid read; expected %lu bytes, got %lu\n", | |
count, read_bytes )); | |
FT_FREE( stream->base ); | |
error = FT_THROW( Invalid_Stream_Operation ); | |
} | |
stream->cursor = stream->base; | |
stream->limit = stream->cursor + count; | |
stream->pos += read_bytes; | |
} | |
else | |
{ | |
/* check current and new position */ | |
if ( stream->pos >= stream->size || | |
stream->size - stream->pos < count ) | |
{ | |
FT_ERROR(( "FT_Stream_EnterFrame:" | |
" invalid i/o; pos = 0x%lx, count = %lu, size = 0x%lx\n", | |
stream->pos, count, stream->size )); | |
error = FT_THROW( Invalid_Stream_Operation ); | |
goto Exit; | |
} | |
/* set cursor */ | |
stream->cursor = stream->base + stream->pos; | |
stream->limit = stream->cursor + count; | |
stream->pos += count; | |
} | |
Exit: | |
return error; | |
} | |
FT_BASE_DEF( void ) | |
FT_Stream_ExitFrame( FT_Stream stream ) | |
{ | |
/* IMPORTANT: The assertion stream->cursor != 0 was removed, given */ | |
/* that it is possible to access a frame of length 0 in */ | |
/* some weird fonts (usually, when accessing an array of */ | |
/* 0 records, like in some strange kern tables). */ | |
/* */ | |
/* In this case, the loader code handles the 0-length table */ | |
/* gracefully; however, stream.cursor is really set to 0 by the */ | |
/* FT_Stream_EnterFrame() call, and this is not an error. */ | |
/* */ | |
FT_ASSERT( stream ); | |
if ( stream->read ) | |
{ | |
FT_Memory memory = stream->memory; | |
#ifdef FT_DEBUG_MEMORY | |
ft_mem_free( memory, stream->base ); | |
stream->base = NULL; | |
#else | |
FT_FREE( stream->base ); | |
#endif | |
} | |
stream->cursor = NULL; | |
stream->limit = NULL; | |
} | |
FT_BASE_DEF( FT_Char ) | |
FT_Stream_GetChar( FT_Stream stream ) | |
{ | |
FT_Char result; | |
FT_ASSERT( stream && stream->cursor ); | |
result = 0; | |
if ( stream->cursor < stream->limit ) | |
result = (FT_Char)*stream->cursor++; | |
return result; | |
} | |
FT_BASE_DEF( FT_UShort ) | |
FT_Stream_GetUShort( FT_Stream stream ) | |
{ | |
FT_Byte* p; | |
FT_UShort result; | |
FT_ASSERT( stream && stream->cursor ); | |
result = 0; | |
p = stream->cursor; | |
if ( p + 1 < stream->limit ) | |
result = FT_NEXT_USHORT( p ); | |
stream->cursor = p; | |
return result; | |
} | |
FT_BASE_DEF( FT_UShort ) | |
FT_Stream_GetUShortLE( FT_Stream stream ) | |
{ | |
FT_Byte* p; | |
FT_UShort result; | |
FT_ASSERT( stream && stream->cursor ); | |
result = 0; | |
p = stream->cursor; | |
if ( p + 1 < stream->limit ) | |
result = FT_NEXT_USHORT_LE( p ); | |
stream->cursor = p; | |
return result; | |
} | |
FT_BASE_DEF( FT_ULong ) | |
FT_Stream_GetUOffset( FT_Stream stream ) | |
{ | |
FT_Byte* p; | |
FT_ULong result; | |
FT_ASSERT( stream && stream->cursor ); | |
result = 0; | |
p = stream->cursor; | |
if ( p + 2 < stream->limit ) | |
result = FT_NEXT_UOFF3( p ); | |
stream->cursor = p; | |
return result; | |
} | |
FT_BASE_DEF( FT_ULong ) | |
FT_Stream_GetULong( FT_Stream stream ) | |
{ | |
FT_Byte* p; | |
FT_ULong result; | |
FT_ASSERT( stream && stream->cursor ); | |
result = 0; | |
p = stream->cursor; | |
if ( p + 3 < stream->limit ) | |
result = FT_NEXT_ULONG( p ); | |
stream->cursor = p; | |
return result; | |
} | |
FT_BASE_DEF( FT_ULong ) | |
FT_Stream_GetULongLE( FT_Stream stream ) | |
{ | |
FT_Byte* p; | |
FT_ULong result; | |
FT_ASSERT( stream && stream->cursor ); | |
result = 0; | |
p = stream->cursor; | |
if ( p + 3 < stream->limit ) | |
result = FT_NEXT_ULONG_LE( p ); | |
stream->cursor = p; | |
return result; | |
} | |
FT_BASE_DEF( FT_Char ) | |
FT_Stream_ReadChar( FT_Stream stream, | |
FT_Error* error ) | |
{ | |
FT_Byte result = 0; | |
FT_ASSERT( stream ); | |
*error = FT_Err_Ok; | |
if ( stream->read ) | |
{ | |
if ( stream->read( stream, stream->pos, &result, 1L ) != 1L ) | |
goto Fail; | |
} | |
else | |
{ | |
if ( stream->pos < stream->size ) | |
result = stream->base[stream->pos]; | |
else | |
goto Fail; | |
} | |
stream->pos++; | |
return (FT_Char)result; | |
Fail: | |
*error = FT_THROW( Invalid_Stream_Operation ); | |
FT_ERROR(( "FT_Stream_ReadChar:" | |
" invalid i/o; pos = 0x%lx, size = 0x%lx\n", | |
stream->pos, stream->size )); | |
return 0; | |
} | |
FT_BASE_DEF( FT_UShort ) | |
FT_Stream_ReadUShort( FT_Stream stream, | |
FT_Error* error ) | |
{ | |
FT_Byte reads[2]; | |
FT_Byte* p = 0; | |
FT_UShort result = 0; | |
FT_ASSERT( stream ); | |
*error = FT_Err_Ok; | |
if ( stream->pos + 1 < stream->size ) | |
{ | |
if ( stream->read ) | |
{ | |
if ( stream->read( stream, stream->pos, reads, 2L ) != 2L ) | |
goto Fail; | |
p = reads; | |
} | |
else | |
p = stream->base + stream->pos; | |
if ( p ) | |
result = FT_NEXT_USHORT( p ); | |
} | |
else | |
goto Fail; | |
stream->pos += 2; | |
return result; | |
Fail: | |
*error = FT_THROW( Invalid_Stream_Operation ); | |
FT_ERROR(( "FT_Stream_ReadUShort:" | |
" invalid i/o; pos = 0x%lx, size = 0x%lx\n", | |
stream->pos, stream->size )); | |
return 0; | |
} | |
FT_BASE_DEF( FT_UShort ) | |
FT_Stream_ReadUShortLE( FT_Stream stream, | |
FT_Error* error ) | |
{ | |
FT_Byte reads[2]; | |
FT_Byte* p = 0; | |
FT_UShort result = 0; | |
FT_ASSERT( stream ); | |
*error = FT_Err_Ok; | |
if ( stream->pos + 1 < stream->size ) | |
{ | |
if ( stream->read ) | |
{ | |
if ( stream->read( stream, stream->pos, reads, 2L ) != 2L ) | |
goto Fail; | |
p = reads; | |
} | |
else | |
p = stream->base + stream->pos; | |
if ( p ) | |
result = FT_NEXT_USHORT_LE( p ); | |
} | |
else | |
goto Fail; | |
stream->pos += 2; | |
return result; | |
Fail: | |
*error = FT_THROW( Invalid_Stream_Operation ); | |
FT_ERROR(( "FT_Stream_ReadUShortLE:" | |
" invalid i/o; pos = 0x%lx, size = 0x%lx\n", | |
stream->pos, stream->size )); | |
return 0; | |
} | |
FT_BASE_DEF( FT_ULong ) | |
FT_Stream_ReadUOffset( FT_Stream stream, | |
FT_Error* error ) | |
{ | |
FT_Byte reads[3]; | |
FT_Byte* p = 0; | |
FT_ULong result = 0; | |
FT_ASSERT( stream ); | |
*error = FT_Err_Ok; | |
if ( stream->pos + 2 < stream->size ) | |
{ | |
if ( stream->read ) | |
{ | |
if (stream->read( stream, stream->pos, reads, 3L ) != 3L ) | |
goto Fail; | |
p = reads; | |
} | |
else | |
p = stream->base + stream->pos; | |
if ( p ) | |
result = FT_NEXT_UOFF3( p ); | |
} | |
else | |
goto Fail; | |
stream->pos += 3; | |
return result; | |
Fail: | |
*error = FT_THROW( Invalid_Stream_Operation ); | |
FT_ERROR(( "FT_Stream_ReadUOffset:" | |
" invalid i/o; pos = 0x%lx, size = 0x%lx\n", | |
stream->pos, stream->size )); | |
return 0; | |
} | |
FT_BASE_DEF( FT_ULong ) | |
FT_Stream_ReadULong( FT_Stream stream, | |
FT_Error* error ) | |
{ | |
FT_Byte reads[4]; | |
FT_Byte* p = 0; | |
FT_ULong result = 0; | |
FT_ASSERT( stream ); | |
*error = FT_Err_Ok; | |
if ( stream->pos + 3 < stream->size ) | |
{ | |
if ( stream->read ) | |
{ | |
if ( stream->read( stream, stream->pos, reads, 4L ) != 4L ) | |
goto Fail; | |
p = reads; | |
} | |
else | |
p = stream->base + stream->pos; | |
if ( p ) | |
result = FT_NEXT_ULONG( p ); | |
} | |
else | |
goto Fail; | |
stream->pos += 4; | |
return result; | |
Fail: | |
*error = FT_THROW( Invalid_Stream_Operation ); | |
FT_ERROR(( "FT_Stream_ReadULong:" | |
" invalid i/o; pos = 0x%lx, size = 0x%lx\n", | |
stream->pos, stream->size )); | |
return 0; | |
} | |
FT_BASE_DEF( FT_ULong ) | |
FT_Stream_ReadULongLE( FT_Stream stream, | |
FT_Error* error ) | |
{ | |
FT_Byte reads[4]; | |
FT_Byte* p = 0; | |
FT_ULong result = 0; | |
FT_ASSERT( stream ); | |
*error = FT_Err_Ok; | |
if ( stream->pos + 3 < stream->size ) | |
{ | |
if ( stream->read ) | |
{ | |
if ( stream->read( stream, stream->pos, reads, 4L ) != 4L ) | |
goto Fail; | |
p = reads; | |
} | |
else | |
p = stream->base + stream->pos; | |
if ( p ) | |
result = FT_NEXT_ULONG_LE( p ); | |
} | |
else | |
goto Fail; | |
stream->pos += 4; | |
return result; | |
Fail: | |
*error = FT_THROW( Invalid_Stream_Operation ); | |
FT_ERROR(( "FT_Stream_ReadULongLE:" | |
" invalid i/o; pos = 0x%lx, size = 0x%lx\n", | |
stream->pos, stream->size )); | |
return 0; | |
} | |
FT_BASE_DEF( FT_Error ) | |
FT_Stream_ReadFields( FT_Stream stream, | |
const FT_Frame_Field* fields, | |
void* structure ) | |
{ | |
FT_Error error; | |
FT_Bool frame_accessed = 0; | |
FT_Byte* cursor; | |
if ( !fields ) | |
return FT_THROW( Invalid_Argument ); | |
if ( !stream ) | |
return FT_THROW( Invalid_Stream_Handle ); | |
cursor = stream->cursor; | |
error = FT_Err_Ok; | |
do | |
{ | |
FT_ULong value; | |
FT_Int sign_shift; | |
FT_Byte* p; | |
switch ( fields->value ) | |
{ | |
case ft_frame_start: /* access a new frame */ | |
error = FT_Stream_EnterFrame( stream, fields->offset ); | |
if ( error ) | |
goto Exit; | |
frame_accessed = 1; | |
cursor = stream->cursor; | |
fields++; | |
continue; /* loop! */ | |
case ft_frame_bytes: /* read a byte sequence */ | |
case ft_frame_skip: /* skip some bytes */ | |
{ | |
FT_UInt len = fields->size; | |
if ( cursor + len > stream->limit ) | |
{ | |
error = FT_THROW( Invalid_Stream_Operation ); | |
goto Exit; | |
} | |
if ( fields->value == ft_frame_bytes ) | |
{ | |
p = (FT_Byte*)structure + fields->offset; | |
FT_MEM_COPY( p, cursor, len ); | |
} | |
cursor += len; | |
fields++; | |
continue; | |
} | |
case ft_frame_byte: | |
case ft_frame_schar: /* read a single byte */ | |
value = FT_NEXT_BYTE( cursor ); | |
sign_shift = 24; | |
break; | |
case ft_frame_short_be: | |
case ft_frame_ushort_be: /* read a 2-byte big-endian short */ | |
value = FT_NEXT_USHORT( cursor) ; | |
sign_shift = 16; | |
break; | |
case ft_frame_short_le: | |
case ft_frame_ushort_le: /* read a 2-byte little-endian short */ | |
value = FT_NEXT_USHORT_LE( cursor ); | |
sign_shift = 16; | |
break; | |
case ft_frame_long_be: | |
case ft_frame_ulong_be: /* read a 4-byte big-endian long */ | |
value = FT_NEXT_ULONG( cursor ); | |
sign_shift = 0; | |
break; | |
case ft_frame_long_le: | |
case ft_frame_ulong_le: /* read a 4-byte little-endian long */ | |
value = FT_NEXT_ULONG_LE( cursor ); | |
sign_shift = 0; | |
break; | |
case ft_frame_off3_be: | |
case ft_frame_uoff3_be: /* read a 3-byte big-endian long */ | |
value = FT_NEXT_UOFF3( cursor ); | |
sign_shift = 8; | |
break; | |
case ft_frame_off3_le: | |
case ft_frame_uoff3_le: /* read a 3-byte little-endian long */ | |
value = FT_NEXT_UOFF3_LE( cursor ); | |
sign_shift = 8; | |
break; | |
default: | |
/* otherwise, exit the loop */ | |
stream->cursor = cursor; | |
goto Exit; | |
} | |
/* now, compute the signed value is necessary */ | |
if ( fields->value & FT_FRAME_OP_SIGNED ) | |
value = (FT_ULong)( (FT_Int32)( value << sign_shift ) >> sign_shift ); | |
/* finally, store the value in the object */ | |
p = (FT_Byte*)structure + fields->offset; | |
switch ( fields->size ) | |
{ | |
case ( 8 / FT_CHAR_BIT ): | |
*(FT_Byte*)p = (FT_Byte)value; | |
break; | |
case ( 16 / FT_CHAR_BIT ): | |
*(FT_UShort*)p = (FT_UShort)value; | |
break; | |
case ( 32 / FT_CHAR_BIT ): | |
*(FT_UInt32*)p = (FT_UInt32)value; | |
break; | |
default: /* for 64-bit systems */ | |
*(FT_ULong*)p = (FT_ULong)value; | |
} | |
/* go to next field */ | |
fields++; | |
} | |
while ( 1 ); | |
Exit: | |
/* close the frame if it was opened by this read */ | |
if ( frame_accessed ) | |
FT_Stream_ExitFrame( stream ); | |
return error; | |
} | |
/* END */ |