From 1d1edb49bd4bd5bbd156bf1d44468b300ae51f2a Mon Sep 17 00:00:00 2001 From: David Turner Date: Fri, 7 Dec 2001 14:43:45 +0000 Subject: added new charmap cache. see include/freetype/cache/ftccmap.h --- ChangeLog | 32 ++- include/freetype/cache/ftccmap.h | 195 ++++++++++++++++++ include/freetype/config/ftheader.h | 12 ++ src/cache/Jamfile | 2 +- src/cache/ftccache.c | 2 +- src/cache/ftccmap.c | 391 +++++++++++++++++++++++++++++++++++++ src/cache/ftcglyph.c | 10 +- src/cache/ftcimage.c | 1 - src/cache/ftcsbits.c | 40 ++-- src/cache/rules.mk | 3 +- 10 files changed, 655 insertions(+), 33 deletions(-) create mode 100644 include/freetype/cache/ftccmap.h create mode 100644 src/cache/ftccmap.c diff --git a/ChangeLog b/ChangeLog index a6259d54f..2f6763a18 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,9 @@ +2001-12-07 David Turner + + * include/freetype/cache/ftccmap.h, src/cache/ftccmap.c: added new + charmap cache + + 2001-12-06 Leonard Rosenthol * src/base/ftmac.c: Added support for reading .dfont files on @@ -7,22 +13,36 @@ * include/freetype/ftmac.h: Exported FT_GetFile_From_Mac_Name() + 2001-12-06 Werner Lemberg * INSTALL: Small update. + 2001-12-05 David Turner - * src/base/ftglyph.c (FT_Glyph_To_Bitmap): Re-ordered code for - debugging purposes. + * src/base/ftglyph.c (FT_Glyph_To_Bitmap): re-ordered code for debugging + purposes.. + + * src/smooth/ftsmooth.c (ft_smooth_render): fixed a nasty hidden bug where + outline shifting wasn't correctly undone after bitmap rasterization. this + created problems with certain glyphs (like '"' of certain fonts..) and + the cache system.. - * src/smooth/ftsmooth.c (ft_smooth_render): Fixed a nasty hidden bug - where outline shifting wasn't correctly undone after bitmap - rasterization. This created problems with certain glyphs (like '"' - of certain fonts) and the cache system. 2001-12-05 David Turner + First of all, a big thanks to Werner and Antoine for their latest work !! + + * src/pshinter/pshalgo2.c (psh2_hint_table_init), + src/pshinter/pshalgo1.c (psh1_hint_table_init): removed compiler + warnings + + * include/freetype/cache/*, src/cache/*: yet another massive rewrite of + the caching sub-system, in order to both increase performance and allow + simpler cache sub-classing. As an example, the code for the image and + sbit caches is now much simpler + * src/pshinter/pshalgo2.c (psh2_hint_table_init), src/pshinter/pshalgo1.c (psh1_hint_table_init): Removed compiler warnings diff --git a/include/freetype/cache/ftccmap.h b/include/freetype/cache/ftccmap.h new file mode 100644 index 000000000..3966016bb --- /dev/null +++ b/include/freetype/cache/ftccmap.h @@ -0,0 +1,195 @@ +/***************************************************************************/ +/* */ +/* ftccmap.h */ +/* */ +/* FreeType charmap cache */ +/* */ +/* Copyright 2000-2001 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. */ +/* */ +/***************************************************************************/ + +#ifndef __FT_CACHE_CHARMAP_H__ +#define __FT_CACHE_CHARMAP_H__ + +#include +#include FT_CACHE_H + +FT_BEGIN_HEADER + + /************************************************************************ + * + * @type: FTC_CmapCache + * + * @description: + * opaque handle used to manager a charmap cache. This cache is used + * to hold character codes -> glyph indices mappings + */ + typedef struct FTC_CMapCacheRec_* FTC_CMapCache; + + + /************************************************************************ + * + * @type: FTC_CMapDesc + * + * @description: + * handle to a @FTC_CMapDescRec structure used to describe a given charmap + * in a charmap cache. + * + * each @FTC_CMapDesc describes which charmap, of which @FTC_Face we + * want to use in @FTC_CMapCache_Lookup + */ + typedef struct FTC_CMapDescRec_* FTC_CMapDesc; + + + /************************************************************************ + * + * @enum: FTC_CMapType + * + * @description: + * the list of valid @FTC_CMap types, they indicate how we want to + * address a charmap within a @FTC_FaceID + * + * @values: + * FTC_CMAP_BY_INDEX :: + * used to indicate that we want to address a charmap by its index in + * the corresponding @FT_Face + * + * FTC_CMAP_BY_ENCODING :: + * used to indicate that we want to use a @FT_Face charmap that + * corresponds to a given encoding + * + * FTC_CMAP_BY_ID :: + * used to indicate that we want to use a @FT_Face charmap that + * corresponds to a given (platform,encoding) id. see @FTC_CMapIdRec + */ + typedef enum + { + FTC_CMAP_BY_INDEX = 0, + FTC_CMAP_BY_ENCODING = 1, + FTC_CMAP_BY_ID = 2 + + } FTC_CMapType; + + + /************************************************************************ + * + * @struct: FTC_CMapIdRec + * + * @description: + * a short structure used to identify a charmap by a (platform,encoding) + * pair of values + * + * @fields: + * platform :: platform ID + * encoding :: encoding ID + */ + typedef struct FTC_CMapIdRec_ + { + FT_UInt platform; + FT_UInt encoding; + + } FTC_CMapIdRec; + + + /************************************************************************ + * + * @struct: FTC_CMapDescRec + * + * @description: + * a structure used to describe a given charmap to the @FTC_CMapCache + * + * @fields: + * face_id :: @FTC_FaceID of the face this charmap belongs to + * type :: type of charmap, see @FTC_CMapType + * + * u.index :: for @FTC_CMAP_BY_INDEX types, this is the charmap index + * (within a @FT_Face) we want to use. + * + * u.encoding :: for @FTC_CMAP_BY_ENCODING types, this is the charmap + * encoding we want to use. see @FT_Encoding + * + * u.id :: for @FTC_CMAP_BY_ID types, this is the (platform,encoding) + * pair we want to use. see @FTC_CMapIdRec and + * @FT_CharMapRec + */ + typedef struct FTC_CMapDescRec_ + { + FTC_FaceID face_id; + FTC_CMapType type; + + union + { + FT_UInt index; + FT_Encoding encoding; + FTC_CMapIdRec id; + + } u; + + } FTC_CMapDescRec; + + + + /************************************************************************ + * + * @function: FTC_CMapCache_New + * + * @description: + * create a new charmap cache + * + * @input: + * manager :: handle to cache manager + * + * @output: + * acache :: new cache handle. NULL in case of error + * + * @return: + * FreeType error code. 0 means success + * + * @note: + * like all other caches, this one will be destroyed with the + * cache manager + */ + FT_EXPORT( FT_Error ) + FTC_CMapCache_New( FTC_Manager manager, + FTC_CMapCache *acache ); + + + + /************************************************************************ + * + * @function: FTC_CMapCache_Lookup + * + * @description: + * translate a character code into a glyph index, using the charmap + * cache. + * + * @input: + * cache :: charmap cache handle + * cmap_desc :: charmap descriptor handle + * char_code :: character code (in the corresponding charmap) + * + * @return: + * glyph index. 0 means "no glyph" !! + * + * @note: + * this function doesn't return @FTC_Node handles, since there is + * no real use for them with typical uses of charmaps + */ + FT_EXPORT( FT_UInt ) + FTC_CMapCache_Lookup( FTC_CMapCache cache, + FTC_CMapDesc cmap_desc, + FT_UInt32 char_code ); + + + /* */ + +FT_END_HEADER + +#endif /* __FT_CACHE_CHARMAP_H__ */ diff --git a/include/freetype/config/ftheader.h b/include/freetype/config/ftheader.h index bd64ce41e..b216d8639 100644 --- a/include/freetype/config/ftheader.h +++ b/include/freetype/config/ftheader.h @@ -417,6 +417,18 @@ #define FT_CACHE_SMALL_BITMAPS_H + /*************************************************************************/ + /* */ + /* @macro: */ + /* FT_CACHE_CHARMAP_H */ + /* */ + /* @description: */ + /* A macro used in #include statements to name the file containing */ + /* the `charmap'API of the FreeType 2 cache sub-system. */ + /* */ +#define FT_CACHE_CHARMAP_H + + /*************************************************************************/ /* */ /* @macro: */ diff --git a/src/cache/Jamfile b/src/cache/Jamfile index a4905b156..3148f558e 100644 --- a/src/cache/Jamfile +++ b/src/cache/Jamfile @@ -16,7 +16,7 @@ HDRMACRO [ FT2_SubDir include ftcache.h ] ; if $(FT2_MULTI) { - _sources = ftlru ftcmanag ftccache ftcglyph ftcsbits ftcimage ; + _sources = ftlru ftcmanag ftccache ftcglyph ftcsbits ftcimage ftccmap ; } else { diff --git a/src/cache/ftccache.c b/src/cache/ftccache.c index 582d67944..147a624f9 100644 --- a/src/cache/ftccache.c +++ b/src/cache/ftccache.c @@ -559,8 +559,8 @@ if ( ALLOC( node, clazz->node_size ) ) goto Exit; - /* node initializer must set 'hash' field */ node->fam_index = (FT_UShort) family->fam_index; + node->hash = query->hash; node->ref_count = 0; error = clazz->node_init( node, query, cache ); diff --git a/src/cache/ftccmap.c b/src/cache/ftccmap.c new file mode 100644 index 000000000..fa72a388b --- /dev/null +++ b/src/cache/ftccmap.c @@ -0,0 +1,391 @@ +/***************************************************************************/ +/* */ +/* ftccmap.c */ +/* */ +/* FreeType CharMap cache */ +/* */ +/* Copyright 2000-2001 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 +#include FT_FREETYPE_H +#include FT_CACHE_H +#include FT_CACHE_CHARMAP_H +#include FT_CACHE_MANAGER_H +#include FT_INTERNAL_MEMORY_H +#include FT_INTERNAL_DEBUG_H + +#include "ftcerror.h" + + + + /* each FTC_CMapNode contains a simple array used to map a */ + /* range of character codes to equivalent glyph indices */ + /* */ + /* for now, the implementation is very basic: each node */ + /* maps a range of 128 consecutive character codes to their */ + /* correspondingglyph indices.. */ + /* */ + /* we could do more complex things, but I don't think it's */ + /* really very useful.. */ + /* */ + + /* number of glyph indices / character code per node */ +#define FTC_CMAP_INDICES_MAX 128 + + + typedef struct FTC_CMapNodeRec_ + { + FTC_NodeRec node; + FT_UInt32 first; /* first character in node */ + FT_UInt16 indices[ FTC_CMAP_INDICES_MAX ]; /* array of glyph indices */ + + } FTC_CMapNodeRec, *FTC_CMapNode; + +#define FTC_CMAP_NODE( x ) ((FTC_CMapNode)( x )) + + /* compute node hash value from cmap family and "requested" glyph index */ +#define FTC_CMAP_HASH(cfam,cquery) \ + ((cfam)->hash + ((cquery)->char_code/FTC_CMAP_INDICES_MAX)) + + + /* if (indices[n] == FTC_CMAP_UNKNOWN), we assume that the corresponding */ + /* glyph indices hasn't been queried through @FT_Get_Glyph_Index yet.. */ + /* */ +#define FTC_CMAP_UNKNOWN ((FT_UInt16)-1) + + + /* the charmap query */ + typedef struct FTC_CMapQueryRec_ + { + FTC_QueryRec query; + FTC_CMapDesc desc; + FT_UInt32 char_code; + + } FTC_CMapQueryRec, *FTC_CMapQuery; + +#define FTC_CMAP_QUERY( x ) ((FTC_CMapQuery)( x )) + + + /* the charmap family */ + typedef struct FTC_CMapFamilyRec_ + { + FTC_FamilyRec family; + FT_UInt32 hash; + FTC_CMapDescRec desc; + FT_UInt index; + + } FTC_CMapFamilyRec, *FTC_CMapFamily; + +#define FTC_CMAP_FAMILY( x ) ((FTC_CMapFamily)( x )) +#define FTC_CMAP_FAMILY_MEMORY( x ) FTC_FAMILY(x)->memory + + + /*************************************************************************/ + /*************************************************************************/ + /***** *****/ + /***** CHARMAP NODES *****/ + /***** *****/ + /*************************************************************************/ + /*************************************************************************/ + + + /* no need for specific finalizer, we'll use "ftc_node_done" directly */ + + /* initialize a new cmap node */ + FT_CALLBACK_DEF( FT_Error ) + ftc_cmap_node_init( FTC_CMapNode cnode, + FTC_CMapQuery cquery, + FTC_Cache cache ) + { + FTC_CMapFamily cfam = FTC_CMAP_FAMILY( FTC_QUERY(cquery)->family ); + FT_UInt32 first; + FT_UInt n; + + + first = (cquery->char_code / FTC_CMAP_INDICES_MAX) * FTC_CMAP_INDICES_MAX; + + cnode->first = first; + for ( n = 0; n < FTC_CMAP_INDICES_MAX; n++ ) + cnode->indices[n] = FTC_CMAP_UNKNOWN; + + return 0; + } + + + /* compute the weight of a given cmap node */ + FT_CALLBACK_DEF( FT_ULong ) + ftc_cmap_node_weight( FTC_CMapNode cnode ) + { + return sizeof(*cnode); + } + + + /* compare a cmap node to a given query */ + FT_CALLBACK_DEF( FT_Bool ) + ftc_cmap_node_compare( FTC_CMapNode cnode, + FTC_CMapQuery cquery ) + { + FT_UInt32 offset = (FT_UInt32)( cquery->char_code - cnode->first ); + + + return ( offset < FTC_CMAP_INDICES_MAX ); + } + + + /*************************************************************************/ + /*************************************************************************/ + /***** *****/ + /***** CHARMAP FAMILY *****/ + /***** *****/ + /*************************************************************************/ + /*************************************************************************/ + + + FT_CALLBACK_DEF( FT_Error ) + ftc_cmap_family_init( FTC_CMapFamily cfam, + FTC_CMapQuery cquery, + FTC_Cache cache ) + { + FTC_Manager manager = cache->manager; + FTC_CMapDesc desc = cquery->desc; + FT_UInt32 hash; + FT_Error error; + FT_Face face; + + + /* setup charmap descriptor */ + cfam->desc = *desc; + + /* let's see if the rest is correct too */ + error = FTC_Manager_Lookup_Face( manager, desc->face_id, &face ); + if ( !error ) + { + FT_UInt count = face->num_charmaps; + FT_UInt index = count; + FT_CharMap* cur = face->charmaps; + + switch ( desc->type ) + { + case FTC_CMAP_BY_INDEX: + { + index = desc->u.index; + hash = index*33; + break; + } + + + case FTC_CMAP_BY_ENCODING: + { + for ( index = 0; index < count; index++, cur++ ) + if ( cur[0]->encoding == desc->u.encoding ) + break; + + hash = index*67; + break; + } + + + case FTC_CMAP_BY_ID: + { + for ( index = 0; index < count; index++, cur++ ) + { + if ( (FT_UInt) cur[0]->platform_id == desc->u.id.platform && + (FT_UInt) cur[0]->encoding_id == desc->u.id.encoding ) + { + hash = ((desc->u.id.platform << 8) | desc->u.id.encoding)*7; + break; + } + } + break; + } + + default: + ; + } + + if ( index >= count ) + goto Bad_Descriptor; + + /* compute hash value, both in family and query */ + cfam->index = index; + cfam->hash = hash ^ FTC_FACE_ID_HASH(desc->face_id); + FTC_QUERY(cquery)->hash = FTC_CMAP_HASH(cfam,cquery); + + error = ftc_family_init( FTC_FAMILY(cfam), FTC_QUERY(cquery), cache ); + } + + return error; + + + Bad_Descriptor: + FT_ERROR(( "FreeType.cache.cmap.lookup: invalid charmap descriptor\n" )); + return FT_Err_Invalid_Argument; + } + + + + FT_CALLBACK_DEF( FT_Bool ) + ftc_cmap_family_compare( FTC_CMapFamily cfam, + FTC_CMapQuery cquery ) + { + FT_Int result = 0; + + + /* first, compare face id and type */ + if ( cfam->desc.face_id != cquery->desc->face_id || + cfam->desc.type != cquery->desc->type ) + goto Exit; + + switch ( cfam->desc.type ) + { + case FTC_CMAP_BY_INDEX: + result = ( cfam->desc.u.index == cquery->desc->u.index ); + break; + + case FTC_CMAP_BY_ENCODING: + result = ( cfam->desc.u.encoding == cquery->desc->u.encoding ); + break; + + case FTC_CMAP_BY_ID: + result = ( cfam->desc.u.id.platform == cquery->desc->u.id.platform && + cfam->desc.u.id.encoding == cquery->desc->u.id.encoding ); + break; + + default: + ; + } + + if (result) + { + /* when found, update the 'family' and 'hash' field of the query */ + FTC_QUERY(cquery)->family = FTC_FAMILY(cfam); + FTC_QUERY(cquery)->hash = FTC_CMAP_HASH(cfam,cquery); + } + + Exit: + return FT_BOOL(result); + } + + + /*************************************************************************/ + /*************************************************************************/ + /***** *****/ + /***** GLYPH IMAGE CACHE *****/ + /***** *****/ + /*************************************************************************/ + /*************************************************************************/ + + + + FT_CALLBACK_TABLE_DEF + const FTC_Cache_ClassRec ftc_cmap_cache_class = + { + sizeof( FTC_CacheRec ), + (FTC_Cache_InitFunc) ftc_cache_init, + (FTC_Cache_ClearFunc) ftc_cache_clear, + (FTC_Cache_DoneFunc) ftc_cache_done, + + sizeof( FTC_CMapFamilyRec ), + (FTC_Family_InitFunc) ftc_cmap_family_init, + (FTC_Family_CompareFunc) ftc_cmap_family_compare, + (FTC_Family_DoneFunc) ftc_family_done, + + sizeof( FTC_CMapNodeRec ), + (FTC_Node_InitFunc) ftc_cmap_node_init, + (FTC_Node_WeightFunc) ftc_cmap_node_weight, + (FTC_Node_CompareFunc) ftc_cmap_node_compare, + (FTC_Node_DoneFunc) ftc_node_done + }; + + + /* documentation is in ftccmap.h */ + + FT_EXPORT_DEF( FT_Error ) + FTC_CMapCache_New( FTC_Manager manager, + FTC_CMapCache *acache ) + { + return FTC_Manager_Register_Cache( + manager, + (FTC_Cache_Class)&ftc_cmap_cache_class, + FTC_CACHE_P( acache ) ); + } + + + /* documentation is in ftccmap.h */ + + FT_EXPORT_DEF( FT_UInt ) + FTC_CMapCache_Lookup( FTC_CMapCache cache, + FTC_CMapDesc desc, + FT_UInt32 char_code ) + { + FTC_CMapQueryRec cquery; + FTC_CMapNode node; + FT_Error error; + FT_UInt gindex; + + if ( !cache || !desc ) + { + FT_ERROR(( "FTC_CMapCache_Lookup: bad arguments, returning 0 !!\n" )); + return 0; + } + + cquery.desc = desc; + cquery.char_code = char_code; + + error = ftc_cache_lookup( FTC_CACHE(cache), + FTC_QUERY(&cquery), + (FTC_Node*) &node ); + if ( !error ) + { + FT_UInt offset = (FT_UInt)( char_code - node->first ); + + gindex = node->indices[offset]; + if ( gindex == FTC_CMAP_UNKNOWN ) + { + FT_Face face; + FT_CharMap old, cmap, limit; + + /* we need to use @FT_Get_Char_Index */ + gindex = 0; + + error = FTC_Manager_Lookup_Face( FTC_CACHE(cache)->manager, + desc->face_id, + &face ); + if (!error) + { + FT_CharMap old, cmap = NULL; + FT_UInt cmap_index; + + /* save old charmap, select new one */ + old = face->charmap; + cmap_index = FTC_CMAP_FAMILY( FTC_QUERY(&cquery)->family )->index; + cmap = face->charmaps[cmap_index]; + + FT_Set_Charmap( face, cmap ); + + /* perform lookup */ + gindex = FT_Get_Char_Index( face, char_code ); + node->indices[offset] = gindex; + + /* restore old charmap */ + FT_Set_Charmap( face, old ); + } + } + } + + return gindex; + } + + + +/* END */ diff --git a/src/cache/ftcglyph.c b/src/cache/ftcglyph.c index 8be466fbd..d1b5d49ff 100644 --- a/src/cache/ftcglyph.c +++ b/src/cache/ftcglyph.c @@ -39,9 +39,7 @@ FT_UInt start = FTC_GLYPH_FAMILY_START(gfam,gindex); - gnode->node.fam_index = (FT_UShort) gfam->family.fam_index; - gnode->node.hash = FTC_GLYPH_FAMILY_HASH(gfam,gindex); - gnode->item_start = (FT_UShort) start; + gnode->item_start = (FT_UShort) start; len = gfam->item_total - start; if ( len > gfam->item_count ) @@ -68,12 +66,10 @@ ftc_glyph_node_compare( FTC_GlyphNode gnode, FTC_GlyphQuery gquery ) { - FT_UInt fam_index = (FT_UInt) FTC_NODE(gnode)->fam_index; FT_UInt start = (FT_UInt) gnode->item_start; FT_UInt count = (FT_UInt) gnode->item_count; - return FT_BOOL( (FT_UInt)(gquery->gindex - start) < count && - gquery->query.family->fam_index == fam_index ); + return FT_BOOL( (FT_UInt)(gquery->gindex - start) < count ); } @@ -103,7 +99,7 @@ gfam->hash = hash; gfam->item_total = item_total; gfam->item_count = item_count; - + FTC_GLYPH_FAMILY_FOUND(gfam,gquery); } diff --git a/src/cache/ftcimage.c b/src/cache/ftcimage.c index 2d5cfcca8..291b1cc13 100644 --- a/src/cache/ftcimage.c +++ b/src/cache/ftcimage.c @@ -261,7 +261,6 @@ FT_Bool result; - /* we must set iquery.glyph.gfam for faster glyph node comparisons */ result = FT_BOOL( FTC_IMAGE_DESC_COMPARE( &ifam->desc, &iquery->desc ) ); if ( result ) FTC_GLYPH_FAMILY_FOUND(ifam,iquery); diff --git a/src/cache/ftcsbits.c b/src/cache/ftcsbits.c index e917e2d56..7386ad72e 100644 --- a/src/cache/ftcsbits.c +++ b/src/cache/ftcsbits.c @@ -120,19 +120,19 @@ static FT_Error - ftc_sbit_node_load( FTC_SBitNode snode, - FTC_Manager manager, - FT_UInt gindex, - FT_ULong *asize ) + ftc_sbit_node_load( FTC_SBitNode snode, + FTC_Manager manager, + FTC_SBitFamily sfam, + FT_UInt gindex, + FT_ULong *asize ) { - FT_Error error; - FTC_GlyphNode gnode = FTC_GLYPH_NODE(snode); - FTC_GlyphFamily gfam; - FTC_SBitFamily sfam; - FT_Memory memory; - FT_Face face; - FT_Size size; - FTC_SBit sbit; + FT_Error error; + FTC_GlyphNode gnode = FTC_GLYPH_NODE(snode); + FTC_GlyphFamily gfam = FTC_GLYPH_FAMILY(sfam); + FT_Memory memory; + FT_Face face; + FT_Size size; + FTC_SBit sbit; if ( gindex < (FT_UInt)gnode->item_start || gindex >= (FT_UInt)gnode->item_start + gnode->item_count ) @@ -141,8 +141,6 @@ return FTC_Err_Invalid_Argument; } - gfam = FTC_GLYPH_FAMILY( manager->families.entries[ gnode->node.fam_index ].family ); - sfam = FTC_SBIT_FAMILY(gfam); memory = manager->library->memory; sbit = snode->sbits + (gindex - gnode->item_start); @@ -275,7 +273,11 @@ gquery->gindex, FTC_GLYPH_FAMILY(gquery->query.family) ); - error = ftc_sbit_node_load( snode, cache->manager, gquery->gindex, NULL ); + error = ftc_sbit_node_load( snode, + cache->manager, + FTC_SBIT_FAMILY( FTC_QUERY(gquery)->family ), + gquery->gindex, + NULL ); if ( error ) ftc_glyph_node_done( FTC_GLYPH_NODE(snode), cache ); @@ -336,7 +338,13 @@ { FT_ULong size; - ftc_sbit_node_load( snode, cache->manager, gindex, &size ); + /* yes, it's safe to ignore errors here */ + ftc_sbit_node_load( snode, + cache->manager, + FTC_SBIT_FAMILY( FTC_QUERY(squery)->family ), + gindex, + &size ); + cache->manager->cur_weight += size; } } diff --git a/src/cache/rules.mk b/src/cache/rules.mk index 0620cddf6..fb6a177a9 100644 --- a/src/cache/rules.mk +++ b/src/cache/rules.mk @@ -33,7 +33,8 @@ Cache_DRV_SRC := $(CACHE_DIR_)ftlru.c \ $(CACHE_DIR_)ftccache.c \ $(CACHE_DIR_)ftcglyph.c \ $(CACHE_DIR_)ftcsbits.c \ - $(CACHE_DIR_)ftcimage.c + $(CACHE_DIR_)ftcimage.c \ + $(CACHE_DIR_)ftccmap.c # Cache driver headers # -- cgit v1.2.1