/***************************************************************************/ /* */ /* 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 #include #include #include /* required by the tracing mode */ #undef FT_COMPONENT #define FT_COMPONENT trace_ttload /*************************************************************************/ /* */ /* */ /* TT_LookUp_Table */ /* */ /* */ /* Looks for a TrueType table by name. */ /* */ /* */ /* face :: A face object handle. */ /* tag :: The searched tag. */ /* */ /* */ /* 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; } /*************************************************************************/ /* */ /* */ /* TT_Load_Collection */ /* */ /* */ /* Loads the TTC table directory into face table. */ /* */ /* */ /* face :: A face object handle. */ /* stream :: The input stream. */ /* */ /* */ /* 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; } /*************************************************************************/ /* */ /* */ /* TT_Load_Directory */ /* */ /* */ /* Loads the table directory into a face object. */ /* */ /* */ /* 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. */ /* */ /* */ /* 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; } /*************************************************************************/ /* */ /* */ /* TT_Load_Any */ /* */ /* */ /* Loads any font table into client memory. Used by the */ /* TT_Get_Font_Data() API function. */ /* */ /* */ /* 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). */ /* */ /* */ /* buffer :: The address of target buffer. */ /* */ /* */ /* 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; } /*************************************************************************/ /* */ /* */ /* TT_Load_Header */ /* */ /* */ /* Loads the TrueType font header. */ /* */ /* */ /* face :: A handle to the target face object. */ /* stream :: The input stream. */ /* */ /* */ /* 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; } /*************************************************************************/ /* */ /* */ /* TT_Load_MaxProfile */ /* */ /* */ /* Loads the maximum profile into a face object. */ /* */ /* */ /* face :: A handle to the target face object. */ /* stream :: The input stream. */ /* */ /* */ /* 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; } /*************************************************************************/ /* */ /* */ /* TT_Load_Metrics */ /* */ /* */ /* Loads the horizontal or vertical metrics table into a face object. */ /* */ /* */ /* face :: A handle to the target face object. */ /* stream :: The input stream. */ /* vertical :: A boolean flag. If set, load vertical metrics. */ /* */ /* */ /* 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; } /*************************************************************************/ /* */ /* */ /* TT_Load_Metrics_Header */ /* */ /* */ /* Loads the horizontal or vertical header in a face object. */ /* */ /* */ /* face :: A handle to the target face object. */ /* stream :: The input stream. */ /* vertical :: A boolean flag. If set, load vertical metrics. */ /* */ /* */ /* 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; } /*************************************************************************/ /* */ /* */ /* TT_Load_Names */ /* */ /* */ /* Loads the name records. */ /* */ /* */ /* face :: A handle to the target face object. */ /* stream :: The input stream. */ /* */ /* */ /* 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; } /*************************************************************************/ /* */ /* */ /* TT_Free_Names */ /* */ /* */ /* Frees the name records. */ /* */ /* */ /* face :: A handle to the target face object. */ /* */ /* */ /* 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; } /*************************************************************************/ /* */ /* */ /* TT_Load_CMap */ /* */ /* */ /* Loads the cmap directory in a face object. The cmaps itselves are */ /* loaded on demand in the `ttcmap.c' module. */ /* */ /* */ /* face :: A handle to the target face object. */ /* stream :: A handle to the input stream. */ /* */ /* */ /* 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; } /*************************************************************************/ /* */ /* */ /* TT_Load_OS2 */ /* */ /* */ /* Loads the OS2 table. */ /* */ /* */ /* face :: A handle to the target face object. */ /* stream :: A handle to the input stream. */ /* */ /* */ /* 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; } /*************************************************************************/ /* */ /* */ /* TT_Load_Postscript */ /* */ /* */ /* Loads the Postscript table. */ /* */ /* */ /* face :: A handle to the target face object. */ /* stream :: A handle to the input stream. */ /* */ /* */ /* 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; } /*************************************************************************/ /* */ /* */ /* TT_Load_Gasp */ /* */ /* */ /* Loads the `GASP' table into a face object. */ /* */ /* */ /* face :: A handle to the target face object. */ /* stream :: The input stream. */ /* */ /* */ /* 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; } /*************************************************************************/ /* */ /* */ /* TT_Load_Kern */ /* */ /* */ /* 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. */ /* */ /* */ /* face :: A handle to the target face object. */ /* stream :: The input stream. */ /* */ /* */ /* 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; } /*************************************************************************/ /* */ /* */ /* TT_Load_Hdmx */ /* */ /* */ /* Loads the horizontal device metrics table. */ /* */ /* */ /* face :: A handle to the target face object. */ /* stream :: A handle to the input stream. */ /* */ /* */ /* 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; } /*************************************************************************/ /* */ /* */ /* TT_Free_Hdmx */ /* */ /* */ /* Frees the horizontal device metrics table. */ /* */ /* */ /* face :: A handle to the target face object. */ /* */ /* */ /* 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 */