FT_EXPORT_DEF( FT_Error ) FT_Outline_Copy( FT_Outline* source,
FT_Outline *target )
{
FT_Int is_owner;
if ( !source || !target ||
source->n_points != target->n_points ||
source->n_contours != target->n_contours )
return FT_Err_Invalid_Argument;
MEM_Copy( target->points, source->points,
source->n_points * sizeof ( FT_Vector ) );
MEM_Copy( target->tags, source->tags,
source->n_points * sizeof ( FT_Byte ) );
MEM_Copy( target->contours, source->contours,
source->n_contours * sizeof ( FT_Short ) );
/* copy all flags, except the `ft_outline_owner' one */
is_owner = target->flags & ft_outline_owner;
target->flags = source->flags;
target->flags &= ~ft_outline_owner;
target->flags |= is_owner;
return FT_Err_Ok;
}
EXPORT_FUNC
TT_Error TT_Check_And_Access_Frame( STREAM_ARGS FRAME_ARGS Long size )
{
TT_Error error;
Long readBytes;
if ( CUR_Frame.address != NULL )
return TT_Err_Nested_Frame_Access;
readBytes = CUR_Stream->map->size - CUR_Stream->pos;
if ( size > readBytes )
{
/* There is overflow, we allocate a new block then */
if ( ALLOC( CUR_Frame.address, size ) )
return error;
CUR_Frame.size = size;
/* copy the valid part */
MEM_Copy( CUR_Frame.address,
MAP_Address( CUR_Stream->map ) + CUR_Stream->pos,
readBytes );
}
else
{
CUR_Frame.size = size;
CUR_Frame.address = MAP_Address( CUR_Stream->map ) + CUR_Stream->pos;
}
CUR_Frame.cursor = CUR_Frame.address;
return TT_Err_Ok;
}
static
FT_Error get_t1_glyph_name( T1_Face face,
FT_UInt glyph_index,
FT_Pointer buffer,
FT_UInt buffer_max )
{
FT_String* gname;
gname = face->type1.glyph_names[glyph_index];
if ( buffer_max > 0 )
{
FT_UInt len = strlen( gname );
if (len >= buffer_max)
len = buffer_max - 1;
MEM_Copy( buffer, gname, len );
((FT_Byte*)buffer)[len] = 0;
}
return T1_Err_Ok;
}
static
FT_Error ft_bitmap_copy(FT_Memory memory,
FT_Bitmap *source,
FT_Bitmap *target)
{
FT_Error error;
FT_Int pitch = source->pitch;
FT_ULong size;
*target = *source;
if(pitch < 0)
{
pitch = -pitch;
}
size = (FT_ULong)(pitch * source->rows);
if(!ALLOC(target->buffer, size))
{
MEM_Copy(source->buffer, target->buffer, size);
}
return error;
}
static
FT_Error ft_outline_glyph_init(FT_OutlineGlyph glyph,
FT_GlyphSlot slot)
{
FT_Error error = FT_Err_Ok;
FT_Library library = FT_GLYPH(glyph)->library;
FT_Outline *source = &slot->outline;
FT_Outline *target = &glyph->outline;
/* check format in glyph slot */
if(slot->format != ft_glyph_format_outline)
{
error = FT_Err_Invalid_Glyph_Format;
goto Exit;
}
/* allocate new outline */
error = FT_Outline_New(library, source->n_points, source->n_contours,
&glyph->outline);
if(error)
{
goto Exit;
}
/* copy it */
MEM_Copy(target->points, source->points,
source->n_points * sizeof(FT_Vector));
MEM_Copy(target->tags, source->tags,
source->n_points * sizeof(FT_Byte));
MEM_Copy(target->contours, source->contours,
source->n_contours * sizeof(FT_Short));
/* copy all flags, except the `ft_outline_owner' one */
target->flags = source->flags | ft_outline_owner;
Exit:
return error;
}
EXPORT_FUNC
TT_Error TT_Read_File( STREAM_ARGS void* buffer, Long count )
{
if ( CUR_Stream->pos + count > CUR_Stream->map->size )
return TT_Err_Invalid_File_Read;
MEM_Copy( buffer,
MAP_Address( CUR_Stream->map ) + CUR_Stream->pos, count );
CUR_Stream->pos += count;
return TT_Err_Ok;
}
/* read a glyph name and return the equivalent glyph index */
static
FT_UInt afm_atoindex( FT_Byte** start,
FT_Byte* limit,
T1_Font* type1 )
{
FT_Byte* p = *start;
FT_Int len;
FT_UInt result = 0;
char temp[64];
/* skip whitespace */
while ( ( *p == ' ' || *p == '\t' || *p == ':' || *p == ';' ) &&
p < limit )
p++;
*start = p;
/* now, read glyph name */
while ( IS_ALPHANUM( *p ) && p < limit )
p++;
len = p - *start;
if ( len > 0 && len < 64 )
{
FT_Int n;
/* copy glyph name to intermediate array */
MEM_Copy( temp, *start, len );
temp[len] = 0;
/* lookup glyph name in face array */
for ( n = 0; n < type1->num_glyphs; n++ )
{
char* gname = (char*)type1->glyph_names[n];
if ( gname && gname[0] == temp[0] && strcmp( gname, temp ) == 0 )
{
result = n;
break;
}
}
}
*start = p;
return result;
}
BASE_FUNC(FT_Error) FT_Read_Stream_At(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_Read_Stream_At:"));
FT_ERROR((" 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;
}
MEM_Copy(buffer, stream->base + pos, read_bytes);
}
stream->pos = pos + read_bytes;
if(read_bytes < count)
{
FT_ERROR(("FT_Read_Stream_At:"));
FT_ERROR((" invalid read; expected %lu bytes, got %lu\n",
count, read_bytes));
error = FT_Err_Invalid_Stream_Operation;
}
return error;
}
BASE_FUNC(FT_Error) FT_Read_Fields(FT_Stream stream,
const FT_Frame_Field *fields,
void *structure)
{
FT_Error error;
FT_Bool frame_accessed = 0;
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_Access_Frame(stream, fields->offset);
if(error)
{
goto Exit;
}
frame_accessed = 1;
fields++;
continue; /* loop! */
case ft_frame_bytes: /* read a byte sequence */
case ft_frame_skip: /* skip some bytes */
{
FT_Int len = fields->size;
if(stream->cursor + len > stream->limit)
{
error = FT_Err_Invalid_Stream_Operation;
goto Exit;
}
if(fields->value == ft_frame_bytes)
{
p = (FT_Byte *)structure + fields->offset;
MEM_Copy(p, stream->cursor, len);
}
stream->cursor += len;
fields++;
continue;
}
case ft_frame_byte:
case ft_frame_schar: /* read a single byte */
value = GET_Byte();
sign_shift = 24;
break;
case ft_frame_short_be:
case ft_frame_ushort_be: /* read a 2-byte big-endian short */
value = GET_UShort();
sign_shift = 16;
break;
case ft_frame_short_le:
case ft_frame_ushort_le: /* read a 2-byte little-endian short */
{
FT_Byte *p;
value = 0;
p = stream->cursor;
if(p + 1 < stream->limit)
{
value = (FT_UShort)p[0] | ((FT_UShort)p[1] << 8);
stream->cursor += 2;
}
sign_shift = 16;
break;
}
case ft_frame_long_be:
case ft_frame_ulong_be: /* read a 4-byte big-endian long */
value = GET_ULong();
sign_shift = 0;
break;
case ft_frame_long_le:
case ft_frame_ulong_le: /* read a 4-byte little-endian long */
{
FT_Byte *p;
value = 0;
p = stream->cursor;
if(p + 3 < stream->limit)
{
value = (FT_ULong)p[0] |
((FT_ULong)p[1] << 8) |
((FT_ULong)p[2] << 16) |
((FT_ULong)p[3] << 24);
stream->cursor += 4;
}
sign_shift = 0;
break;
}
case ft_frame_off3_be:
case ft_frame_uoff3_be: /* read a 3-byte big-endian long */
value = GET_UOffset();
sign_shift = 8;
break;
case ft_frame_off3_le:
case ft_frame_uoff3_le: /* read a 3-byte little-endian long */
{
FT_Byte *p;
value = 0;
p = stream->cursor;
if(p + 2 < stream->limit)
{
value = (FT_ULong)p[0] |
((FT_ULong)p[1] << 8) |
((FT_ULong)p[2] << 16);
stream->cursor += 3;
}
sign_shift = 8;
break;
}
default:
/* otherwise, exit the loop */
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++;
}
static
FT_String *Get_Name(TT_Face face,
FT_UShort nameid)
{
FT_Memory memory = face->root.memory;
FT_UShort n;
TT_NameRec *rec;
FT_Bool wide_chars = 1;
rec = face->name_table.names;
for(n = 0; n < face->name_table.numNameRecords; n++, rec++)
{
if(rec->nameID == nameid)
{
/* found the name -- now create an ASCII string from it */
FT_Bool found = 0;
/* test for Microsoft English language */
if(rec->platformID == TT_PLATFORM_MICROSOFT &&
rec->encodingID <= TT_MS_ID_UNICODE_CS &&
(rec->languageID & 0x3FF) == 0x009)
{
found = 1;
}
/* test for Apple Unicode encoding */
else if(rec->platformID == TT_PLATFORM_APPLE_UNICODE)
{
found = 1;
}
/* test for Apple Roman */
else if(rec->platformID == TT_PLATFORM_MACINTOSH &&
rec->languageID == TT_MAC_ID_ROMAN)
{
found = 1;
wide_chars = 0;
}
/* found a Unicode name */
if(found)
{
FT_String *string;
FT_UInt len;
if(wide_chars)
{
FT_UInt m;
len = (FT_UInt)rec->stringLength / 2;
if(MEM_Alloc(string, len + 1))
{
return NULL;
}
for(m = 0; m < len; m++)
string[m] = rec->string[2 * m + 1];
}
else
{
len = rec->stringLength;
if(MEM_Alloc(string, len + 1))
{
return NULL;
}
MEM_Copy(string, rec->string, len);
}
string[len] = '\0';
return string;
}
}
}
return NULL;
}
