ref: d0ab3a0dd8f6355b3603d0fb04043a9ae867639b
dir: /libfreetype/ftstream.c/
/***************************************************************************/ /* */ /* ftstream.c */ /* */ /* I/O stream support (body). */ /* */ /* Copyright 2000-2001, 2002 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 = 0; stream->read = 0; stream->close = 0; } FT_BASE_DEF( void ) FT_Stream_Close( FT_Stream stream ) { if ( stream && stream->close ) { stream->close( stream ); stream->close = NULL; } } FT_BASE_DEF( FT_Error ) FT_Stream_Seek( FT_Stream stream, FT_ULong pos ) { FT_Error error = FT_Err_Ok; stream->pos = pos; 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_Err_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_Err_Invalid_Stream_Operation; } return error; } FT_BASE_DEF( FT_Error ) FT_Stream_Skip( FT_Stream stream, FT_Long distance ) { return FT_Stream_Seek( stream, (FT_ULong)( stream->pos + distance ) ); } FT_BASE_DEF( FT_Long ) 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_Err_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:" )); FT_ERROR(( " invalid read; expected %lu bytes, got %lu\n", count, read_bytes )); error = FT_Err_Invalid_Stream_Operation; } return error; } 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 = 0; stream->limit = 0; } return error; } FT_BASE_DEF( void ) FT_Stream_ReleaseFrame( FT_Stream stream, FT_Byte** pbytes ) { if ( stream->read ) { FT_Memory memory = stream->memory; FT_FREE( *pbytes ); } *pbytes = 0; } 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; if ( FT_ALLOC( stream->base, count ) ) goto Exit; /* read it */ read_bytes = stream->read( stream, stream->pos, stream->base, count ); if ( read_bytes < count ) { FT_ERROR(( "FT_Stream_EnterFrame:" )); FT_ERROR(( " invalid read; expected %lu bytes, got %lu\n", count, read_bytes )); FT_FREE( stream->base ); error = FT_Err_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->pos + count > stream->size ) { FT_ERROR(( "FT_Stream_EnterFrame:" )); FT_ERROR(( " invalid i/o; pos = 0x%lx, count = %lu, size = 0x%lx\n", stream->pos, count, stream->size )); error = FT_Err_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; FT_FREE( stream->base ); } stream->cursor = 0; stream->limit = 0; } 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 = *stream->cursor++; return result; } FT_BASE_DEF( FT_Short ) FT_Stream_GetShort( FT_Stream stream ) { FT_Byte* p; FT_Short result; FT_ASSERT( stream && stream->cursor ); result = 0; p = stream->cursor; if ( p + 1 < stream->limit ) result = FT_NEXT_SHORT( p ); stream->cursor = p; return result; } FT_BASE_DEF( FT_Short ) FT_Stream_GetShortLE( FT_Stream stream ) { FT_Byte* p; FT_Short result; FT_ASSERT( stream && stream->cursor ); result = 0; p = stream->cursor; if ( p + 1 < stream->limit ) result = FT_NEXT_SHORT_LE( p ); stream->cursor = p; return result; } FT_BASE_DEF( FT_Long ) FT_Stream_GetOffset( FT_Stream stream ) { FT_Byte* p; FT_Long result; FT_ASSERT( stream && stream->cursor ); result = 0; p = stream->cursor; if ( p + 2 < stream->limit ) result = FT_NEXT_OFF3( p ); stream->cursor = p; return result; } FT_BASE_DEF( FT_Long ) FT_Stream_GetLong( FT_Stream stream ) { FT_Byte* p; FT_Long result; FT_ASSERT( stream && stream->cursor ); result = 0; p = stream->cursor; if ( p + 3 < stream->limit ) result = FT_NEXT_LONG( p ); stream->cursor = p; return result; } FT_BASE_DEF( FT_Long ) FT_Stream_GetLongLE( FT_Stream stream ) { FT_Byte* p; FT_Long result; FT_ASSERT( stream && stream->cursor ); result = 0; p = stream->cursor; if ( p + 3 < stream->limit ) result = FT_NEXT_LONG_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 result; Fail: *error = FT_Err_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_Short ) FT_Stream_ReadShort( FT_Stream stream, FT_Error* error ) { FT_Byte reads[2]; FT_Byte* p = 0; FT_Short 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_SHORT( p ); } else goto Fail; stream->pos += 2; return result; Fail: *error = FT_Err_Invalid_Stream_Operation; FT_ERROR(( "FT_Stream_ReadShort:" )); FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n", stream->pos, stream->size )); return 0; } FT_BASE_DEF( FT_Short ) FT_Stream_ReadShortLE( FT_Stream stream, FT_Error* error ) { FT_Byte reads[2]; FT_Byte* p = 0; FT_Short 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_SHORT_LE( p ); } else goto Fail; stream->pos += 2; return result; Fail: *error = FT_Err_Invalid_Stream_Operation; FT_ERROR(( "FT_Stream_ReadShortLE:" )); FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n", stream->pos, stream->size )); return 0; } FT_BASE_DEF( FT_Long ) FT_Stream_ReadOffset( FT_Stream stream, FT_Error* error ) { FT_Byte reads[3]; FT_Byte* p = 0; FT_Long 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_OFF3( p ); } else goto Fail; stream->pos += 3; return result; Fail: *error = FT_Err_Invalid_Stream_Operation; FT_ERROR(( "FT_Stream_ReadOffset:" )); FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n", stream->pos, stream->size )); return 0; } FT_BASE_DEF( FT_Long ) FT_Stream_ReadLong( FT_Stream stream, FT_Error* error ) { FT_Byte reads[4]; FT_Byte* p = 0; FT_Long 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_LONG( p ); } else goto Fail; stream->pos += 4; return result; Fail: FT_ERROR(( "FT_Stream_ReadLong: invalid i/o; pos = 0x%lx, size = 0x%lx\n", stream->pos, stream->size )); *error = FT_Err_Invalid_Stream_Operation; return 0; } FT_BASE_DEF( FT_Long ) FT_Stream_ReadLongLE( FT_Stream stream, FT_Error* error ) { FT_Byte reads[4]; FT_Byte* p = 0; FT_Long 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_LONG_LE( p ); } else goto Fail; stream->pos += 4; return result; Fail: FT_ERROR(( "FT_Stream_ReadLongLE:" )); FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n", stream->pos, stream->size )); *error = FT_Err_Invalid_Stream_Operation; 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 = stream->cursor; if ( !fields || !stream ) return FT_Err_Invalid_Argument; 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_Err_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 1: *(FT_Byte*)p = (FT_Byte)value; break; case 2: *(FT_UShort*)p = (FT_UShort)value; break; case 4: *(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 */