| /***************************************************************************/ |
| /* */ |
| /* ttload.c */ |
| /* */ |
| /* TrueType tables loader (body). */ |
| /* */ |
| /* Copyright 1996-1999 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. */ |
| /* */ |
| /* */ |
| /* WARNING: This file should not be compiled directly; it is meant to be */ |
| /* included in the source of several font drivers (i.e., the TTF */ |
| /* and OTF drivers). */ |
| /* */ |
| /***************************************************************************/ |
| |
| |
| #include <ftdebug.h> |
| |
| #include <ttload.h> |
| #include <tttags.h> |
| #include <ttcmap.h> |
| |
| |
| /* required by the tracing mode */ |
| #undef FT_COMPONENT |
| #define FT_COMPONENT trace_ttload |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* TT_LookUp_Table */ |
| /* */ |
| /* <Description> */ |
| /* Looks for a TrueType table by name. */ |
| /* */ |
| /* <Input> */ |
| /* face :: A face object handle. */ |
| /* tag :: The searched tag. */ |
| /* */ |
| /* <Return> */ |
| /* Index of table if found, -1 otherwise. */ |
| /* */ |
| EXPORT_FUNC |
| FT_Long TT_LookUp_Table( TT_Face face, |
| TT_ULong tag ) |
| { |
| TT_Long i, found; |
| |
| |
| FT_TRACE4(( "TT_LookUp_Table( %08lx, %c%c%c%c )\n", |
| (TT_Long)face, |
| (TT_Char)(tag >> 24), |
| (TT_Char)(tag >> 16), |
| (TT_Char)(tag >> 8), |
| (TT_Char)(tag) )); |
| |
| found = -1; |
| for ( i = 0; i < face->num_tables; i++ ) |
| if ( face->dir_tables[i].Tag == tag ) |
| { |
| found = i; |
| break; |
| } |
| |
| if ( found == -1 ) |
| { |
| FT_TRACE4(( " Could not find table!\n" )); |
| } |
| |
| return found; |
| } |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* TT_Load_Collection */ |
| /* */ |
| /* <Description> */ |
| /* Loads the TTC table directory into face table. */ |
| /* */ |
| /* <Input> */ |
| /* face :: A face object handle. */ |
| /* stream :: The input stream. */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success. */ |
| /* */ |
| static |
| TT_Error TT_Load_Collection( TT_Face face, |
| FT_Stream stream ) |
| { |
| TT_Long n; |
| TT_Error error; |
| FT_Memory memory = stream->memory; |
| |
| |
| FT_TRACE3(( "TT_Load_Collection( %08lx )\n", (TT_Long)face )); |
| |
| if ( FILE_Seek ( 0L ) || |
| ACCESS_Frame( 12L ) ) |
| goto Exit; |
| |
| face->ttc_header.Tag = GET_Tag4(); |
| face->ttc_header.version = GET_Long(); |
| face->ttc_header.DirCount = GET_Long(); /* see comment in tttypes.h */ |
| |
| FORGET_Frame(); |
| |
| if ( face->ttc_header.Tag != TTAG_ttcf ) |
| { |
| face->ttc_header.Tag = 0; |
| face->ttc_header.version = 0; |
| face->ttc_header.DirCount = 0; |
| |
| face->ttc_header.TableDirectory = NULL; |
| |
| FT_TRACE3(( "skipped.\n" )); |
| |
| error = TT_Err_File_Is_Not_Collection; |
| goto Exit; |
| } |
| |
| if ( ALLOC_ARRAY( face->ttc_header.TableDirectory, |
| face->ttc_header.DirCount, |
| TT_ULong ) || |
| ACCESS_Frame( face->ttc_header.DirCount * 4L ) ) |
| goto Exit; |
| |
| for ( n = 0; n < face->ttc_header.DirCount; n++ ) |
| face->ttc_header.TableDirectory[n] = GET_ULong(); |
| |
| FORGET_Frame(); |
| |
| FT_TRACE3(( "collections directory loaded.\n" )); |
| |
| Exit: |
| return error; |
| } |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* TT_Load_Directory */ |
| /* */ |
| /* <Description> */ |
| /* Loads the table directory into a face object. */ |
| /* */ |
| /* <Input> */ |
| /* face :: A handle to the target face object. */ |
| /* stream :: The input stream. */ |
| /* faceIndex :: The index of the TrueType font, if we're opening a */ |
| /* collection. */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success. */ |
| /* */ |
| LOCAL_FUNC |
| TT_Error TT_Load_Directory( TT_Face face, |
| FT_Stream stream, |
| TT_Long faceIndex ) |
| { |
| TT_Error error; |
| FT_Memory memory = stream->memory; |
| |
| TT_UShort n, limit; |
| TT_TableDir tableDir; |
| |
| TT_TableDirEntry* entry; |
| |
| |
| FT_TRACE2(( "TT_Load_Directory( %08lx, %ld )\n", |
| (TT_Long)face, faceIndex )); |
| |
| error = TT_Load_Collection( face, stream ); |
| if ( error ) |
| { |
| /* if this is a `traditional' error, exit now */ |
| if ( error != TT_Err_File_Is_Not_Collection ) |
| goto Exit; |
| |
| /* the file isn't a collection, exit if we're asking */ |
| /* for a collected font */ |
| |
| /* Note that we don't exit during font format checking (i.e., */ |
| /* faceIndex is -1) */ |
| if ( faceIndex > 0 ) |
| goto Exit; |
| |
| /* Now skip to the beginning of the file */ |
| if ( FILE_Seek( 0 ) ) |
| goto Exit; |
| } |
| else |
| { |
| /* The file is a collection. Check the font index */ |
| if ( faceIndex >= face->ttc_header.DirCount ) |
| { |
| error = TT_Err_Bad_Argument; |
| goto Exit; |
| } |
| |
| /* if we're checking the font format, exit immediately */ |
| if ( faceIndex < 0 ) |
| goto Exit; |
| |
| /* select a TrueType font in the ttc file */ |
| if ( FILE_Seek( face->ttc_header.TableDirectory[faceIndex] ) ) |
| goto Exit; |
| } |
| |
| if ( ACCESS_Frame( 12L ) ) |
| goto Exit; |
| |
| tableDir.version = GET_Long(); |
| tableDir.numTables = GET_UShort(); |
| |
| tableDir.searchRange = GET_UShort(); |
| tableDir.entrySelector = GET_UShort(); |
| tableDir.rangeShift = GET_UShort(); |
| |
| FORGET_Frame(); |
| |
| FT_TRACE2(( "-- Tables count : %12u\n", tableDir.numTables )); |
| FT_TRACE2(( "-- Format version : %08lx\n", tableDir.version )); |
| |
| /* Check that we have a `sfnt' format there */ |
| /* We must also be able to accept Mac/GX fonts, as well as OT ones */ |
| |
| if ( tableDir.version != 0x00010000 && |
| tableDir.version != TTAG_true && |
| tableDir.version != TTAG_OTTO ) |
| { |
| FT_TRACE2(( "[not a valid TTF or OTF font]" )); |
| error = TT_Err_Invalid_File_Format; |
| goto Exit; |
| } |
| |
| /* if we're performing a font format check, exit immediately */ |
| /* with success */ |
| if ( faceIndex < 0 ) |
| goto Exit; |
| |
| face->num_tables = tableDir.numTables; |
| |
| if ( ALLOC_ARRAY( face->dir_tables, |
| face->num_tables, |
| TT_TableDirEntry ) ) |
| goto Exit; |
| |
| if ( ACCESS_Frame( face->num_tables * 16L ) ) |
| goto Exit; |
| |
| limit = face->num_tables; |
| entry = face->dir_tables; |
| |
| for ( n = 0; n < limit; n++ ) |
| { /* loop through the tables and get all entries */ |
| entry->Tag = GET_Tag4(); |
| entry->CheckSum = GET_ULong(); |
| entry->Offset = GET_Long(); |
| entry->Length = GET_Long(); |
| |
| FT_TRACE2(( " %c%c%c%c - %08lx - %08lx\n", |
| (TT_Char)(entry->Tag >> 24), |
| (TT_Char)(entry->Tag >> 16), |
| (TT_Char)(entry->Tag >> 8 ), |
| (TT_Char)(entry->Tag), |
| entry->Offset, |
| entry->Length )); |
| entry++; |
| } |
| |
| FORGET_Frame(); |
| |
| FT_TRACE2(( "Directory loaded\n\n" )); |
| |
| Exit: |
| return error; |
| } |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* TT_Load_Any */ |
| /* */ |
| /* <Description> */ |
| /* Loads any font table into client memory. Used by the */ |
| /* TT_Get_Font_Data() API function. */ |
| /* */ |
| /* <Input> */ |
| /* face :: The face object to look for. */ |
| /* */ |
| /* tag :: The tag of table to load. Use the value 0 if you want */ |
| /* to access the whole font file, else set this parameter */ |
| /* to a valid TrueType table tag that you can forge with */ |
| /* the MAKE_TT_TAG macro. */ |
| /* */ |
| /* offset :: The starting offset in the table (or the file if */ |
| /* tag == 0). */ |
| /* */ |
| /* length :: The address of the decision variable: */ |
| /* */ |
| /* If length == NULL: */ |
| /* Loads the whole table. Returns an error if */ |
| /* `offset' == 0! */ |
| /* */ |
| /* If *length == 0: */ |
| /* Exits immediately; returning the length of the given */ |
| /* table or of the font file, depending on the value of */ |
| /* `tag'. */ |
| /* */ |
| /* If *length != 0: */ |
| /* Loads the next `length' bytes of table or font, */ |
| /* starting at offset `offset' (in table or font too). */ |
| /* */ |
| /* <Output> */ |
| /* buffer :: The address of target buffer. */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success. */ |
| /* */ |
| LOCAL_FUNC |
| TT_Error TT_Load_Any( TT_Face face, |
| TT_ULong tag, |
| TT_Long offset, |
| void* buffer, |
| TT_Long* length ) |
| { |
| TT_Error error; |
| FT_Stream stream; |
| TT_Long table; |
| TT_ULong size; |
| |
| |
| if ( tag != 0 ) |
| { |
| /* look for tag in font directory */ |
| table = TT_LookUp_Table( face, tag ); |
| if ( table < 0 ) |
| { |
| error = TT_Err_Table_Missing; |
| goto Exit; |
| } |
| |
| offset += face->dir_tables[table].Offset; |
| size = face->dir_tables[table].Length; |
| } |
| else |
| /* tag = 0 -- the use want to access the font file directly */ |
| { |
| size = face->root.stream->size; |
| } |
| |
| if ( length && *length == 0 ) |
| { |
| *length = size; |
| |
| return TT_Err_Ok; |
| } |
| |
| if ( length ) |
| size = *length; |
| |
| stream = face->root.stream; |
| (void)FILE_Read_At( offset, buffer, size ); |
| |
| Exit: |
| return error; |
| } |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* TT_Load_Header */ |
| /* */ |
| /* <Description> */ |
| /* Loads the TrueType font header. */ |
| /* */ |
| /* <Input> */ |
| /* face :: A handle to the target face object. */ |
| /* stream :: The input stream. */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success. */ |
| /* */ |
| LOCAL_FUNC |
| TT_Error TT_Load_Header( TT_Face face, |
| FT_Stream stream ) |
| { |
| TT_Error error; |
| |
| TT_Long table; |
| TT_Header* header; |
| |
| |
| FT_TRACE2(( "Load_TT_Header( %08lx )\n", (TT_Long)face )); |
| |
| if ( ( table = TT_LookUp_Table( face, TTAG_head ) ) < 0 ) |
| { |
| FT_TRACE0(( "Font Header is missing!\n" )); |
| error = TT_Err_Header_Table_Missing; |
| |
| goto Exit; |
| } |
| |
| if ( FILE_Seek( face->dir_tables[table].Offset ) || |
| ACCESS_Frame( 54L ) ) |
| goto Exit; |
| |
| header = &face->header; |
| |
| header->Table_Version = GET_ULong(); |
| header->Font_Revision = GET_ULong(); |
| |
| header->CheckSum_Adjust = GET_Long(); |
| header->Magic_Number = GET_Long(); |
| |
| header->Flags = GET_UShort(); |
| header->Units_Per_EM = GET_UShort(); |
| |
| header->Created [0] = GET_Long(); |
| header->Created [1] = GET_Long(); |
| header->Modified[0] = GET_Long(); |
| header->Modified[1] = GET_Long(); |
| |
| header->xMin = GET_Short(); |
| header->yMin = GET_Short(); |
| header->xMax = GET_Short(); |
| header->yMax = GET_Short(); |
| |
| header->Mac_Style = GET_UShort(); |
| header->Lowest_Rec_PPEM = GET_UShort(); |
| |
| header->Font_Direction = GET_Short(); |
| header->Index_To_Loc_Format = GET_Short(); |
| header->Glyph_Data_Format = GET_Short(); |
| |
| FORGET_Frame(); |
| |
| FT_TRACE2(( " Units per EM : %8u\n", header->Units_Per_EM )); |
| FT_TRACE2(( " IndexToLoc : %8d\n", header->Index_To_Loc_Format )); |
| FT_TRACE2(( "Font Header Loaded.\n" )); |
| |
| Exit: |
| return error; |
| } |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* TT_Load_MaxProfile */ |
| /* */ |
| /* <Description> */ |
| /* Loads the maximum profile into a face object. */ |
| /* */ |
| /* <Input> */ |
| /* face :: A handle to the target face object. */ |
| /* stream :: The input stream. */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success. */ |
| /* */ |
| LOCAL_FUNC |
| TT_Error TT_Load_MaxProfile( TT_Face face, |
| FT_Stream stream ) |
| { |
| TT_Error error; |
| |
| TT_Long i; |
| TT_MaxProfile* maxProfile = &face->max_profile; |
| |
| |
| FT_TRACE2(( "Load_TT_MaxProfile( %08lx )\n", (TT_Long)face )); |
| |
| if ( ( i = TT_LookUp_Table( face, TTAG_maxp ) ) < 0 ) |
| { |
| error = TT_Err_Max_Profile_Missing; |
| |
| goto Exit; |
| } |
| |
| if ( FILE_Seek( face->dir_tables[i].Offset ) || |
| ACCESS_Frame( 32L ) ) |
| goto Exit; |
| |
| /* read frame data into face table */ |
| maxProfile->version = GET_ULong(); |
| maxProfile->numGlyphs = GET_UShort(); |
| |
| maxProfile->maxPoints = GET_UShort(); |
| maxProfile->maxContours = GET_UShort(); |
| maxProfile->maxCompositePoints = GET_UShort(); |
| maxProfile->maxCompositeContours = GET_UShort(); |
| |
| maxProfile->maxZones = GET_UShort(); |
| maxProfile->maxTwilightPoints = GET_UShort(); |
| |
| maxProfile->maxStorage = GET_UShort(); |
| maxProfile->maxFunctionDefs = GET_UShort(); |
| maxProfile->maxInstructionDefs = GET_UShort(); |
| maxProfile->maxStackElements = GET_UShort(); |
| maxProfile->maxSizeOfInstructions = GET_UShort(); |
| maxProfile->maxComponentElements = GET_UShort(); |
| maxProfile->maxComponentDepth = GET_UShort(); |
| |
| FORGET_Frame(); |
| |
| /* XXX: an adjustment that is necessary to load certain */ |
| /* broken fonts like `Keystrokes MT' :-( */ |
| /* */ |
| /* We allocate 64 function entries by default when */ |
| /* the maxFunctionDefs field is null. */ |
| |
| if ( maxProfile->maxFunctionDefs == 0 ) |
| maxProfile->maxFunctionDefs = 64; |
| |
| face->root.num_glyphs = maxProfile->numGlyphs; |
| |
| face->root.max_points = MAX( maxProfile->maxCompositePoints, |
| maxProfile->maxPoints ); |
| |
| face->root.max_contours = MAX( maxProfile->maxCompositeContours, |
| maxProfile->maxContours ); |
| |
| face->max_components = (TT_ULong)maxProfile->maxComponentElements + |
| maxProfile->maxComponentDepth; |
| |
| FT_TRACE2(( "GASP loaded.\n" )); |
| |
| Exit: |
| return error; |
| } |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* TT_Load_Metrics */ |
| /* */ |
| /* <Description> */ |
| /* Loads the horizontal or vertical metrics table into a face object. */ |
| /* */ |
| /* <Input> */ |
| /* face :: A handle to the target face object. */ |
| /* stream :: The input stream. */ |
| /* vertical :: A boolean flag. If set, load vertical metrics. */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success. */ |
| /* */ |
| static |
| TT_Error TT_Load_Metrics( TT_Face face, |
| FT_Stream stream, |
| TT_Bool vertical ) |
| { |
| TT_Error error; |
| FT_Memory memory = stream->memory; |
| |
| TT_UShort n, num_shorts, num_longs; |
| TT_Long table; |
| |
| TT_LongMetrics** longs; |
| TT_ShortMetrics** shorts; |
| |
| TT_LongMetrics* long_metric; |
| |
| FT_TRACE2(( "TT_Load_%s_Metrics( %08lx )\n", |
| vertical ? "Vertical" : "Horizontal", (TT_Long)face )); |
| |
| if ( vertical ) |
| { |
| /* The table is optional, quit silently if it wasn't found */ |
| /* XXX: Some fonts have a valid vertical header with a non-null */ |
| /* `number_of_VMetrics' fields, but no corresponding `vmtx' */ |
| /* table to get the metrics from (e.g. mingliu). */ |
| /* */ |
| /* For safety, we set the field to 0! */ |
| /* */ |
| table = TT_LookUp_Table( face, TTAG_vmtx ); |
| if ( table < 0 ) |
| { |
| /* Set the number_Of_VMetrics to 0! */ |
| FT_TRACE2(( " no vertical header in file.\n" )); |
| face->vertical.number_Of_VMetrics = 0; |
| error = TT_Err_Ok; |
| |
| goto Exit; |
| } |
| |
| num_longs = face->vertical.number_Of_VMetrics; |
| longs = (TT_LongMetrics**)&face->vertical.long_metrics; |
| shorts = (TT_ShortMetrics**)&face->vertical.short_metrics; |
| } |
| else |
| { |
| if ( ( table = TT_LookUp_Table( face, TTAG_hmtx ) ) < 0 ) |
| { |
| FT_ERROR(( " no horizontal metrics in file!\n" )); |
| error = TT_Err_Hmtx_Table_Missing; |
| |
| goto Exit; |
| } |
| |
| num_longs = face->horizontal.number_Of_HMetrics; |
| longs = (TT_LongMetrics**)&face->horizontal.long_metrics; |
| shorts = (TT_ShortMetrics**)&face->horizontal.short_metrics; |
| } |
| |
| num_shorts = face->max_profile.numGlyphs - num_longs; |
| |
| if ( num_longs > face->max_profile.numGlyphs ) /* sanity check */ |
| { |
| FT_ERROR(( " more metrics than glyphs!\n" )); |
| error = TT_Err_Invalid_Horiz_Metrics; |
| |
| goto Exit; |
| } |
| |
| if ( ALLOC_ARRAY( *longs, num_longs, TT_LongMetrics ) || |
| ALLOC_ARRAY( *shorts, num_shorts, TT_ShortMetrics ) ) |
| goto Exit; |
| |
| if ( FILE_Seek( face->dir_tables[table].Offset ) || |
| ACCESS_Frame( face->dir_tables[table].Length ) ) |
| goto Exit; |
| |
| long_metric = *longs; |
| for ( n = 0; n < num_longs; n++ ) |
| { |
| long_metric->advance = GET_UShort(); |
| long_metric->bearing = GET_Short(); |
| long_metric++; |
| } |
| |
| for ( n = 0; n < num_shorts; n++ ) |
| (*shorts)[n] = GET_Short(); |
| |
| FORGET_Frame(); |
| |
| FT_TRACE2(( "loaded\n" )); |
| |
| Exit: |
| return error; |
| } |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* TT_Load_Metrics_Header */ |
| /* */ |
| /* <Description> */ |
| /* Loads the horizontal or vertical header in a face object. */ |
| /* */ |
| /* <Input> */ |
| /* face :: A handle to the target face object. */ |
| /* stream :: The input stream. */ |
| /* vertical :: A boolean flag. If set, load vertical metrics. */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success. */ |
| /* */ |
| LOCAL_FUNC |
| TT_Error TT_Load_Metrics_Header( TT_Face face, |
| FT_Stream stream, |
| TT_Bool vertical ) |
| { |
| TT_Error error; |
| |
| TT_Long table; |
| TT_HoriHeader* header; |
| |
| |
| FT_TRACE2(( vertical ? "Vertical header " : "Horizontal header " )); |
| |
| if ( vertical ) |
| { |
| face->vertical_info = 0; |
| |
| /* The vertical header table is optional, so return quietly if */ |
| /* we don't find it. */ |
| if ( ( table = TT_LookUp_Table( face, TTAG_vhea ) ) < 0 ) |
| { |
| error = TT_Err_Ok; |
| |
| goto Exit; |
| } |
| |
| face->vertical_info = 1; |
| header = (TT_HoriHeader*)&face->vertical; |
| } |
| else |
| { |
| /* The horizontal header is mandatory, return an error if we */ |
| /* don't find it. */ |
| if ( ( table = TT_LookUp_Table( face, TTAG_hhea ) ) < 0 ) |
| { |
| error = TT_Err_Horiz_Header_Missing; |
| |
| goto Exit; |
| } |
| |
| header = &face->horizontal; |
| } |
| |
| if ( FILE_Seek( face->dir_tables[table].Offset ) || |
| ACCESS_Frame( 36L ) ) |
| goto Exit; |
| |
| header->Version = GET_ULong(); |
| header->Ascender = GET_Short(); |
| header->Descender = GET_Short(); |
| header->Line_Gap = GET_Short(); |
| |
| header->advance_Width_Max = GET_UShort(); |
| |
| header->min_Left_Side_Bearing = GET_Short(); |
| header->min_Right_Side_Bearing = GET_Short(); |
| header->xMax_Extent = GET_Short(); |
| header->caret_Slope_Rise = GET_Short(); |
| header->caret_Slope_Run = GET_Short(); |
| |
| header->Reserved[0] = GET_Short(); |
| header->Reserved[1] = GET_Short(); |
| header->Reserved[2] = GET_Short(); |
| header->Reserved[3] = GET_Short(); |
| header->Reserved[4] = GET_Short(); |
| |
| header->metric_Data_Format = GET_Short(); |
| header->number_Of_HMetrics = GET_UShort(); |
| |
| FORGET_Frame(); |
| |
| header->long_metrics = NULL; |
| header->short_metrics = NULL; |
| |
| FT_TRACE2(( "loaded\n" )); |
| |
| /* Now try to load the corresponding metrics */ |
| |
| error = TT_Load_Metrics( face, stream, vertical ); |
| |
| Exit: |
| return error; |
| } |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* TT_Load_Names */ |
| /* */ |
| /* <Description> */ |
| /* Loads the name records. */ |
| /* */ |
| /* <Input> */ |
| /* face :: A handle to the target face object. */ |
| /* stream :: The input stream. */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success. */ |
| /* */ |
| LOCAL_FUNC |
| TT_Error TT_Load_Names( TT_Face face, FT_Stream stream ) |
| { |
| TT_Error error; |
| FT_Memory memory = stream->memory; |
| |
| TT_UShort i; |
| TT_Long table; |
| TT_Long storageSize; |
| |
| TT_NameTable* names; |
| TT_NameRec* namerec; |
| |
| |
| FT_TRACE2(( "Names " )); |
| |
| if ( ( table = TT_LookUp_Table( face, TTAG_name ) ) < 0 ) |
| { |
| /* The name table is required so indicate failure. */ |
| FT_TRACE2(( "is missing!\n" )); |
| error = TT_Err_Name_Table_Missing; |
| |
| goto Exit; |
| } |
| |
| /* Seek to the beginning of the table and check the frame access. */ |
| /* The names table has a 6 byte header. */ |
| if ( FILE_Seek( face->dir_tables[table].Offset ) || |
| ACCESS_Frame( 6L ) ) |
| goto Exit; |
| |
| names = &face->name_table; |
| |
| /* Load the initial names data. */ |
| names->format = GET_UShort(); |
| names->numNameRecords = GET_UShort(); |
| names->storageOffset = GET_UShort(); |
| |
| FORGET_Frame(); |
| |
| /* Allocate the array of name records. */ |
| if ( ALLOC_ARRAY( names->names, |
| names->numNameRecords, |
| TT_NameRec ) || |
| ACCESS_Frame( names->numNameRecords * 12L ) ) |
| goto Exit; |
| |
| /* Load the name records and determine how much storage is needed */ |
| /* to hold the strings themselves. */ |
| namerec = names->names; |
| storageSize = 0; |
| |
| for ( i = 0; i < names->numNameRecords; i++, namerec++ ) |
| { |
| TT_Long upper; |
| |
| |
| namerec->platformID = GET_UShort(); |
| namerec->encodingID = GET_UShort(); |
| namerec->languageID = GET_UShort(); |
| namerec->nameID = GET_UShort(); |
| namerec->stringLength = GET_UShort(); |
| namerec->stringOffset = GET_UShort(); |
| |
| upper = namerec->stringOffset + namerec->stringLength; |
| if ( upper > storageSize ) storageSize = upper; |
| } |
| |
| FORGET_Frame(); |
| |
| if ( ALLOC( names->storage, storageSize ) || |
| FILE_Read_At( face->dir_tables[table].Offset + names->storageOffset, |
| (void*)names->storage, storageSize ) ) |
| goto Exit; |
| |
| /* Go through and assign the string pointers to the name records. */ |
| namerec = names->names; |
| for ( i = 0; i < names->numNameRecords; i++, namerec++ ) |
| namerec->string = names->storage + namerec->stringOffset; |
| |
| /* Print Name Record Table in case of debugging */ |
| #if 0 |
| namerec = names->names; |
| for ( i = 0; i < names->numNameRecords; i++, namerec++ ) |
| { |
| TT_UShort j; |
| |
| |
| FT_TRACE2(( "%d %d %x %d ", |
| namerec->platformID, |
| namerec->encodingID, |
| namerec->languageID, |
| namerec->nameID )); |
| |
| /* I know that M$ encoded strings are Unicode, */ |
| /* but this works reasonable well for debugging purposes. */ |
| if ( namerec->string ) |
| for ( j = 0; j < namerec->stringLength; j++ ) |
| { |
| TT_Char c = *(namerec->string + j); |
| |
| if ( (TT_Byte)c < 128 ) |
| FT_TRACE2(( "%c", c )); |
| } |
| } |
| FT_TRACE2(( "\n" )); |
| #endif |
| |
| FT_TRACE2(( "loaded\n" )); |
| |
| Exit: |
| return error; |
| |
| } |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* TT_Free_Names */ |
| /* */ |
| /* <Description> */ |
| /* Frees the name records. */ |
| /* */ |
| /* <Input> */ |
| /* face :: A handle to the target face object. */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success. */ |
| /* */ |
| LOCAL_FUNC |
| TT_Error TT_Free_Names( TT_Face face ) |
| { |
| FT_Memory memory = face->root.driver->memory; |
| TT_NameTable* names = &face->name_table; |
| |
| |
| /* free strings table */ |
| FREE( names->names ); |
| |
| /* free strings storage */ |
| FREE( names->storage ); |
| |
| names->numNameRecords = 0; |
| names->format = 0; |
| names->storageOffset = 0; |
| |
| return TT_Err_Ok; |
| } |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* TT_Load_CMap */ |
| /* */ |
| /* <Description> */ |
| /* Loads the cmap directory in a face object. The cmaps itselves are */ |
| /* loaded on demand in the `ttcmap.c' module. */ |
| /* */ |
| /* <Input> */ |
| /* face :: A handle to the target face object. */ |
| /* stream :: A handle to the input stream. */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success. */ |
| /* */ |
| LOCAL_FUNC |
| TT_Error TT_Load_CMap( TT_Face face, |
| FT_Stream stream ) |
| { |
| TT_Error error; |
| FT_Memory memory = stream->memory; |
| |
| TT_Long i, off, cur_off, table_start; |
| TT_UShort n, limit; |
| |
| TT_CMapDir cmap_dir; |
| TT_CharMap charmap; |
| TT_CMapTable* cmap; |
| |
| |
| FT_TRACE2(( "CMaps " )); |
| |
| if ( ( i = TT_LookUp_Table( face, TTAG_cmap ) ) < 0 ) |
| { |
| error = TT_Err_CMap_Table_Missing; |
| |
| goto Exit; |
| } |
| |
| table_start = face->dir_tables[i].Offset; |
| |
| if ( ( FILE_Seek( table_start ) ) || |
| ( ACCESS_Frame( 4L ) ) ) /* 4 bytes cmap header */ |
| goto Exit; |
| |
| cmap_dir.tableVersionNumber = GET_UShort(); |
| cmap_dir.numCMaps = GET_UShort(); |
| |
| FORGET_Frame(); |
| |
| off = FILE_Pos(); /* save offset to cmapdir[] which follows */ |
| |
| /* save space in face table for cmap tables */ |
| if ( ALLOC_ARRAY( face->charmaps, |
| cmap_dir.numCMaps, |
| TT_CharMapRec ) ) |
| goto Exit; |
| |
| face->num_charmaps = cmap_dir.numCMaps; |
| |
| limit = face->num_charmaps; |
| charmap = face->charmaps; |
| |
| for ( n = 0; n < limit; n++ ) |
| { |
| charmap->root.face = (FT_Face)face; |
| cmap = &charmap->cmap; |
| |
| if ( FILE_Seek( off ) || |
| ACCESS_Frame( 8L ) ) |
| goto Exit; |
| |
| cmap->loaded = FALSE; |
| cmap->platformID = GET_UShort(); |
| cmap->platformEncodingID = GET_UShort(); |
| |
| cur_off = GET_Long(); |
| |
| FORGET_Frame(); |
| |
| off = FILE_Pos(); |
| |
| if ( FILE_Seek( table_start + cur_off ) || |
| ACCESS_Frame( 6L ) ) |
| goto Exit; |
| |
| cmap->format = GET_UShort(); |
| cmap->length = GET_UShort(); |
| cmap->version = GET_UShort(); |
| |
| FORGET_Frame(); |
| |
| cmap->offset = FILE_Pos(); |
| |
| charmap++; |
| } |
| |
| FT_TRACE2(( "loaded\n" )); |
| |
| Exit: |
| return error; |
| } |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* TT_Load_OS2 */ |
| /* */ |
| /* <Description> */ |
| /* Loads the OS2 table. */ |
| /* */ |
| /* <Input> */ |
| /* face :: A handle to the target face object. */ |
| /* stream :: A handle to the input stream. */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success. */ |
| /* */ |
| LOCAL_FUNC |
| TT_Error TT_Load_OS2( TT_Face face, |
| FT_Stream stream ) |
| { |
| TT_Error error; |
| |
| TT_Long i; |
| TT_Int j; |
| TT_OS2* os2; |
| |
| |
| FT_TRACE2(( "OS/2 Table " )); |
| |
| /* We now support old Mac fonts where the OS/2 table doesn't */ |
| /* exist. Simply put, we set the `version' field to 0xFFFF */ |
| /* and test this value each time we need to access the table. */ |
| if ( ( i = TT_LookUp_Table( face, TTAG_OS2 ) ) < 0 ) |
| { |
| FT_TRACE2(( "is missing\n!" )); |
| face->os2.version = 0xFFFF; |
| error = TT_Err_Ok; |
| |
| goto Exit; |
| } |
| |
| if ( FILE_Seek( face->dir_tables[i].Offset ) || |
| ACCESS_Frame( 78L ) ) |
| goto Exit; |
| |
| os2 = &face->os2; |
| |
| os2->version = GET_UShort(); |
| os2->xAvgCharWidth = GET_Short(); |
| os2->usWeightClass = GET_UShort(); |
| os2->usWidthClass = GET_UShort(); |
| os2->fsType = GET_Short(); |
| os2->ySubscriptXSize = GET_Short(); |
| os2->ySubscriptYSize = GET_Short(); |
| os2->ySubscriptXOffset = GET_Short(); |
| os2->ySubscriptYOffset = GET_Short(); |
| os2->ySuperscriptXSize = GET_Short(); |
| os2->ySuperscriptYSize = GET_Short(); |
| os2->ySuperscriptXOffset = GET_Short(); |
| os2->ySuperscriptYOffset = GET_Short(); |
| os2->yStrikeoutSize = GET_Short(); |
| os2->yStrikeoutPosition = GET_Short(); |
| os2->sFamilyClass = GET_Short(); |
| |
| for ( j = 0; j < 10; j++ ) |
| os2->panose[j] = GET_Byte(); |
| |
| os2->ulUnicodeRange1 = GET_ULong(); |
| os2->ulUnicodeRange2 = GET_ULong(); |
| os2->ulUnicodeRange3 = GET_ULong(); |
| os2->ulUnicodeRange4 = GET_ULong(); |
| |
| for ( j = 0; j < 4; j++ ) |
| os2->achVendID[j] = GET_Byte(); |
| |
| os2->fsSelection = GET_UShort(); |
| os2->usFirstCharIndex = GET_UShort(); |
| os2->usLastCharIndex = GET_UShort(); |
| os2->sTypoAscender = GET_Short(); |
| os2->sTypoDescender = GET_Short(); |
| os2->sTypoLineGap = GET_Short(); |
| os2->usWinAscent = GET_UShort(); |
| os2->usWinDescent = GET_UShort(); |
| |
| FORGET_Frame(); |
| |
| if ( os2->version >= 0x0001 ) |
| { |
| /* only version 1 tables */ |
| |
| if ( ACCESS_Frame( 8L ) ) /* read into frame */ |
| goto Exit; |
| |
| os2->ulCodePageRange1 = GET_ULong(); |
| os2->ulCodePageRange2 = GET_ULong(); |
| |
| FORGET_Frame(); |
| } |
| else |
| { |
| os2->ulCodePageRange1 = 0; |
| os2->ulCodePageRange2 = 0; |
| } |
| |
| FT_TRACE2(( "loaded\n" )); |
| |
| Exit: |
| return error; |
| } |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* TT_Load_Postscript */ |
| /* */ |
| /* <Description> */ |
| /* Loads the Postscript table. */ |
| /* */ |
| /* <Input> */ |
| /* face :: A handle to the target face object. */ |
| /* stream :: A handle to the input stream. */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success. */ |
| /* */ |
| LOCAL_FUNC |
| TT_Error TT_Load_PostScript( TT_Face face, |
| FT_Stream stream ) |
| { |
| TT_Error error; |
| TT_Long i; |
| TT_Postscript* post = &face->postscript; |
| |
| |
| FT_TRACE2(( "PostScript " )); |
| |
| if ( ( i = TT_LookUp_Table( face, TTAG_post ) ) < 0 ) |
| return TT_Err_Post_Table_Missing; |
| |
| if ( FILE_Seek( face->dir_tables[i].Offset ) || |
| ACCESS_Frame( 32L ) ) |
| return error; |
| |
| /* read frame data into face table */ |
| |
| post->FormatType = GET_ULong(); |
| post->italicAngle = GET_ULong(); |
| post->underlinePosition = GET_Short(); |
| post->underlineThickness = GET_Short(); |
| post->isFixedPitch = GET_ULong(); |
| post->minMemType42 = GET_ULong(); |
| post->maxMemType42 = GET_ULong(); |
| post->minMemType1 = GET_ULong(); |
| post->maxMemType1 = GET_ULong(); |
| |
| FORGET_Frame(); |
| |
| /* we don't load the glyph names, we do that in another */ |
| /* module (ttpost). */ |
| |
| FT_TRACE2(( "loaded\n" )); |
| |
| return TT_Err_Ok; |
| } |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* TT_Load_Gasp */ |
| /* */ |
| /* <Description> */ |
| /* Loads the `GASP' table into a face object. */ |
| /* */ |
| /* <Input> */ |
| /* face :: A handle to the target face object. */ |
| /* stream :: The input stream. */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success. */ |
| /* */ |
| LOCAL_FUNC |
| TT_Error TT_Load_Gasp( TT_Face face, |
| FT_Stream stream ) |
| { |
| TT_Error error; |
| FT_Memory memory = stream->memory; |
| |
| TT_Long table; |
| TT_UShort num_ranges; |
| TT_UShort j; |
| TT_GaspRange* gaspranges; |
| |
| |
| FT_TRACE2(( "TT_Load_Gasp( %08lx )\n", (TT_Long)face )); |
| |
| error = TT_Err_Ok; |
| |
| /* the gasp table is optional */ |
| if ( ( table = TT_LookUp_Table( face, TTAG_gasp ) ) < 0 ) |
| goto Exit; |
| |
| if ( FILE_Seek( face->dir_tables[table].Offset ) || |
| ACCESS_Frame( 4L ) ) |
| goto Exit; |
| |
| face->gasp.version = GET_UShort(); |
| face->gasp.numRanges = GET_UShort(); |
| |
| FORGET_Frame(); |
| |
| num_ranges = face->gasp.numRanges; |
| FT_TRACE3(( "number of ranges = %d\n", num_ranges )); |
| |
| if ( ALLOC_ARRAY( gaspranges, num_ranges, TT_GaspRange ) || |
| ACCESS_Frame( num_ranges * 4L ) ) |
| goto Exit; |
| |
| face->gasp.gaspRanges = gaspranges; |
| |
| for ( j = 0; j < num_ranges; j++ ) |
| { |
| gaspranges[j].maxPPEM = GET_UShort(); |
| gaspranges[j].gaspFlag = GET_UShort(); |
| |
| FT_TRACE3(( " [max:%d flag:%d]", |
| gaspranges[j].maxPPEM, |
| gaspranges[j].gaspFlag )); |
| } |
| FT_TRACE3(( "\n" )); |
| |
| FORGET_Frame(); |
| |
| FT_TRACE2(( "GASP loaded\n" )); |
| |
| Exit: |
| return error; |
| } |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* TT_Load_Kern */ |
| /* */ |
| /* <Description> */ |
| /* Loads the first kerning table with format 0 in the font. Only */ |
| /* accepts the first horizontal kerning table. Developers should use */ |
| /* the `ftxkern' extension to access other kerning tables in the font */ |
| /* file, if they really want to. */ |
| /* */ |
| /* <Input> */ |
| /* face :: A handle to the target face object. */ |
| /* stream :: The input stream. */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success. */ |
| /* */ |
| LOCAL_FUNC |
| TT_Error TT_Load_Kern( TT_Face face, |
| FT_Stream stream ) |
| { |
| TT_Error error; |
| FT_Memory memory = stream->memory; |
| |
| TT_Long table; |
| TT_UShort n, num_tables, version; |
| |
| |
| error = TT_Err_Ok; |
| table = TT_LookUp_Table( face, TTAG_kern ); |
| if ( table < 0 ) |
| goto Exit; |
| |
| if ( FILE_Seek( face->dir_tables[table].Offset ) || |
| READ_UShort( version ) || |
| READ_UShort( num_tables ) ) |
| goto Exit; |
| |
| for ( n = 0; n < num_tables; n++ ) |
| { |
| TT_UShort coverage; |
| |
| |
| if ( FILE_Skip( 4L ) || |
| READ_UShort( coverage ) ) |
| goto Exit; |
| |
| if ( coverage == 0x0001 ) |
| { |
| TT_UShort num_pairs, m; |
| TT_Kern_0_Pair* pair; |
| |
| |
| /* found a horizontal format 0 kerning table ! */ |
| if ( READ_UShort( num_pairs ) || |
| FILE_Skip( 6 ) ) |
| goto Exit; |
| |
| /* allocate array of kerning pairs */ |
| if ( ALLOC_ARRAY( face->kern_pairs, num_pairs, TT_Kern_0_Pair ) ) |
| goto Exit; |
| |
| /* read the kerning pairs */ |
| if ( ACCESS_Frame( 6L * num_pairs ) ) |
| goto Exit; |
| |
| pair = face->kern_pairs; |
| for ( m = 0; m < num_pairs; m++ ) |
| { |
| pair->left = GET_UShort(); |
| pair->right = GET_UShort(); |
| pair->value = GET_UShort(); |
| pair++; |
| } |
| |
| FORGET_Frame(); |
| |
| face->num_kern_pairs = num_pairs; |
| face->kern_table_index = n; |
| goto Exit; |
| } |
| } |
| |
| /* no kern table found -- doesn't matter */ |
| face->kern_table_index = -1; |
| face->num_kern_pairs = 0; |
| face->kern_pairs = NULL; |
| |
| Exit: |
| return error; |
| } |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* TT_Load_Hdmx */ |
| /* */ |
| /* <Description> */ |
| /* Loads the horizontal device metrics table. */ |
| /* */ |
| /* <Input> */ |
| /* face :: A handle to the target face object. */ |
| /* stream :: A handle to the input stream. */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success. */ |
| /* */ |
| LOCAL_FUNC |
| TT_Error TT_Load_Hdmx( TT_Face face, |
| FT_Stream stream ) |
| { |
| TT_Error error; |
| FT_Memory memory = stream->memory; |
| |
| TT_HdmxRec* rec; |
| TT_Hdmx hdmx; |
| TT_Long table; |
| TT_UShort n; |
| TT_Long num_glyphs; |
| TT_Long record_size; |
| |
| hdmx.version = 0; |
| hdmx.num_records = 0; |
| hdmx.records = 0; |
| |
| face->hdmx = hdmx; |
| |
| error = TT_Err_Ok; |
| |
| /* ths table is optional */ |
| if ( ( table = TT_LookUp_Table( face, TTAG_hdmx ) ) < 0 ) |
| return error; |
| |
| if ( FILE_Seek( face->dir_tables[table].Offset ) || |
| ACCESS_Frame( 8L ) ) |
| goto Exit; |
| |
| hdmx.version = GET_UShort(); |
| hdmx.num_records = GET_Short(); |
| record_size = GET_Long(); |
| |
| FORGET_Frame(); |
| |
| /* Only recognize format 0 */ |
| if ( hdmx.version != 0 ) |
| goto Exit; |
| |
| if ( ALLOC( hdmx.records, sizeof ( TT_HdmxRec ) * hdmx.num_records ) ) |
| goto Exit; |
| |
| num_glyphs = face->root.num_glyphs; |
| record_size -= num_glyphs + 2; |
| rec = hdmx.records; |
| |
| for ( n = 0; n < hdmx.num_records; n++ ) |
| { |
| /* read record */ |
| if ( READ_Byte( rec->ppem ) || |
| READ_Byte( rec->max_width ) ) |
| goto Exit; |
| |
| if ( ALLOC( rec->widths, num_glyphs ) || |
| FILE_Read( rec->widths, num_glyphs ) ) |
| goto Exit; |
| |
| /* skip padding bytes */ |
| if ( record_size > 0 ) |
| if ( FILE_Skip( record_size ) ) |
| goto Exit; |
| |
| rec++; |
| } |
| |
| face->hdmx = hdmx; |
| |
| Exit: |
| return error; |
| } |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* TT_Free_Hdmx */ |
| /* */ |
| /* <Description> */ |
| /* Frees the horizontal device metrics table. */ |
| /* */ |
| /* <Input> */ |
| /* face :: A handle to the target face object. */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success. */ |
| /* */ |
| LOCAL_FUNC |
| TT_Error TT_Free_Hdmx( TT_Face face ) |
| { |
| if ( face ) |
| { |
| TT_UShort n; |
| FT_Memory memory = face->root.driver->memory; |
| |
| |
| for ( n = 0; n < face->hdmx.num_records; n++ ) |
| FREE( face->hdmx.records[n].widths ); |
| |
| FREE( face->hdmx.records ); |
| face->hdmx.num_records = 0; |
| } |
| |
| return TT_Err_Ok; |
| } |
| |
| |
| /* END */ |
