FTC_SBitCache_LookupScaler( FTC_SBitCache cache, FTC_Scaler scaler, FT_ULong load_flags, FT_UInt gindex, FTC_SBit *ansbit, FTC_Node *anode ) { FT_Error error; FTC_BasicQueryRec query; FTC_Node node = 0; /* make compiler happy */ FT_UInt32 hash; if ( anode ) *anode = NULL; /* other argument checks delayed to FTC_Cache_Lookup */ if ( !ansbit || !scaler ) return FTC_Err_Invalid_Argument; *ansbit = NULL; /* FT_Load_Glyph(), FT_Load_Char() take FT_UInt flags */ if ( load_flags > FT_UINT_MAX ) { FT_TRACE1(( "FTC_ImageCache_LookupScaler: higher bits in load_flags" )); FT_TRACE1(( "0x%x are dropped\n", (load_flags & ~((FT_ULong)FT_UINT_MAX)) )); } query.attrs.scaler = scaler[0]; query.attrs.load_flags = (FT_UInt)load_flags; /* beware, the hash must be the same for all glyph ranges! */ hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex / FTC_SBIT_ITEMS_PER_NODE; FTC_GCACHE_LOOKUP_CMP( cache, ftc_basic_family_compare, FTC_SNode_Compare, hash, gindex, &query, node, error ); if ( error ) goto Exit; *ansbit = FTC_SNODE( node )->sbits + ( gindex - FTC_GNODE( node )->gindex ); if ( anode ) { *anode = node; node->ref_count++; } Exit: return error; }
FTC_ImageCache_LookupScaler( FTC_ImageCache cache, FTC_Scaler scaler, FT_ULong load_flags, FT_UInt gindex, FT_Glyph *aglyph, FTC_Node *anode ) { FTC_BasicQueryRec query; FTC_Node node = 0; /* make compiler happy */ FT_Error error; FT_UInt32 hash; /* some argument checks are delayed to FTC_Cache_Lookup */ if ( !aglyph || !scaler ) { error = FTC_Err_Invalid_Argument; goto Exit; } *aglyph = NULL; if ( anode ) *anode = NULL; /* FT_Load_Glyph(), FT_Load_Char() take FT_UInt flags */ if ( load_flags > FT_UINT_MAX ) { FT_TRACE1(( "FTC_ImageCache_LookupScaler: higher bits in load_flags" )); FT_TRACE1(( "0x%x are dropped\n", (load_flags & ~((FT_ULong)FT_UINT_MAX)) )); } query.attrs.scaler = scaler[0]; query.attrs.load_flags = (FT_UInt)load_flags; hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex; FTC_GCACHE_LOOKUP_CMP( cache, ftc_basic_family_compare, FTC_GNode_Compare, hash, gindex, &query, node, error ); if ( !error ) { *aglyph = FTC_INODE( node )->glyph; if ( anode ) { *anode = node; node->ref_count++; } } Exit: return error; }
FTC_SBitCache_LookupScaler( FTC_SBitCache cache, FTC_Scaler scaler, FT_ULong load_flags, FT_UInt gindex, FTC_SBit *ansbit, FTC_Node *anode ) { FT_Error error; FTC_BasicQueryRec query; FTC_SNode node = 0; /* make compiler happy */ FT_UInt32 hash; if ( anode ) *anode = NULL; /* other argument checks delayed to FTC_Cache_Lookup */ if ( !ansbit || !scaler ) return FTC_Err_Invalid_Argument; *ansbit = NULL; query.attrs.scaler = scaler[0]; query.attrs.load_flags = load_flags; /* beware, the hash must be the same for all glyph ranges! */ hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex / FTC_SBIT_ITEMS_PER_NODE; FTC_GCACHE_LOOKUP_CMP( cache, ftc_basic_family_compare, FTC_SNode_Compare, hash, gindex, &query, node, error ); if ( error ) goto Exit; *ansbit = node->sbits + ( gindex - FTC_GNODE( node )->gindex ); if ( anode ) { *anode = FTC_NODE( node ); FTC_NODE( node )->ref_count++; } Exit: return error; }
FTC_ImageCache_LookupScaler( FTC_ImageCache cache, FTC_Scaler scaler, FT_ULong load_flags, FT_UInt gindex, FT_Glyph *aglyph, FTC_Node *anode ) { FTC_BasicQueryRec query; FTC_INode node = 0; /* make compiler happy */ FT_Error error; FT_UInt32 hash; /* some argument checks are delayed to FTC_Cache_Lookup */ if ( !aglyph || !scaler ) { error = FTC_Err_Invalid_Argument; goto Exit; } *aglyph = NULL; if ( anode ) *anode = NULL; query.attrs.scaler = scaler[0]; query.attrs.load_flags = load_flags; hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex; FTC_GCACHE_LOOKUP_CMP( cache, ftc_basic_family_compare, FTC_GNode_Compare, hash, gindex, &query, node, error ); if ( !error ) { *aglyph = FTC_INODE( node )->glyph; if ( anode ) { *anode = FTC_NODE( node ); FTC_NODE( node )->ref_count++; } } Exit: return error; }
FTC_SBitCache_Lookup( FTC_SBitCache cache, FTC_ImageType type, FT_UInt gindex, FTC_SBit *ansbit, FTC_Node *anode ) { FT_Error error; FTC_BasicQueryRec query; FTC_Node node = 0; /* make compiler happy */ FT_UInt32 hash; if ( anode ) *anode = NULL; /* other argument checks delayed to FTC_Cache_Lookup */ if ( !ansbit ) return FTC_Err_Invalid_Argument; *ansbit = NULL; #if defined( FT_CONFIG_OPTION_OLD_INTERNALS ) && ( FT_INT_MAX > 0xFFFFU ) /* This one is a major hack used to detect whether we are passed a * regular FTC_ImageType handle, or a legacy FTC_OldImageDesc one. */ if ( (FT_ULong)type->width >= 0x10000L ) { FTC_OldImageDesc desc = (FTC_OldImageDesc)type; query.attrs.scaler.face_id = desc->font.face_id; query.attrs.scaler.width = desc->font.pix_width; query.attrs.scaler.height = desc->font.pix_height; query.attrs.load_flags = desc->flags; } else #endif /* FT_CONFIG_OPTION_OLD_INTERNALS */ { if ( (FT_ULong)(type->flags - FT_INT_MIN) > FT_UINT_MAX ) { FT_TRACE1(( "FTC_ImageCache_Lookup: higher bits in load_flags" )); FT_TRACE1(( "0x%x are dropped\n", (type->flags & ~((FT_ULong)FT_UINT_MAX)) )); } query.attrs.scaler.face_id = type->face_id; query.attrs.scaler.width = type->width; query.attrs.scaler.height = type->height; query.attrs.load_flags = (FT_UInt)type->flags; } query.attrs.scaler.pixel = 1; query.attrs.scaler.x_res = 0; /* make compilers happy */ query.attrs.scaler.y_res = 0; /* beware, the hash must be the same for all glyph ranges! */ hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex / FTC_SBIT_ITEMS_PER_NODE; #if 1 /* inlining is about 50% faster! */ FTC_GCACHE_LOOKUP_CMP( cache, ftc_basic_family_compare, FTC_SNode_Compare, hash, gindex, &query, node, error ); #else error = FTC_GCache_Lookup( FTC_GCACHE( cache ), hash, gindex, FTC_GQUERY( &query ), &node ); #endif if ( error ) goto Exit; *ansbit = FTC_SNODE( node )->sbits + ( gindex - FTC_GNODE( node )->gindex ); if ( anode ) { *anode = node; node->ref_count++; } Exit: return error; }
FTC_SBitCache_Lookup( FTC_SBitCache cache, FTC_ImageType type, FT_UInt gindex, FTC_SBit *ansbit, FTC_Node *anode ) { FT_Error error; FTC_BasicQueryRec query; FTC_SNode node = 0; /* make compiler happy */ FT_UInt32 hash; if ( anode ) *anode = NULL; /* other argument checks delayed to FTC_Cache_Lookup */ if ( !ansbit ) return FTC_Err_Invalid_Argument; *ansbit = NULL; query.attrs.scaler.face_id = type->face_id; query.attrs.scaler.width = type->width; query.attrs.scaler.height = type->height; query.attrs.scaler.pixel = 1; query.attrs.load_flags = type->flags; query.attrs.scaler.x_res = 0; /* make compilers happy */ query.attrs.scaler.y_res = 0; /* beware, the hash must be the same for all glyph ranges! */ hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex / FTC_SBIT_ITEMS_PER_NODE; #if 1 /* inlining is about 50% faster! */ FTC_GCACHE_LOOKUP_CMP( cache, ftc_basic_family_compare, FTC_SNode_Compare, hash, gindex, &query, node, error ); #else error = FTC_GCache_Lookup( FTC_GCACHE( cache ), hash, gindex, FTC_GQUERY( &query ), (FTC_Node*)&node ); #endif if ( error ) goto Exit; *ansbit = node->sbits + ( gindex - FTC_GNODE( node )->gindex ); if ( anode ) { *anode = FTC_NODE( node ); FTC_NODE( node )->ref_count++; } Exit: return error; }
FTC_ImageCache_Lookup( FTC_ImageCache cache, FTC_ImageType type, FT_UInt gindex, FT_Glyph *aglyph, FTC_Node *anode ) { FTC_BasicQueryRec query; FTC_INode node = 0; /* make compiler happy */ FT_Error error; FT_UInt32 hash; /* some argument checks are delayed to FTC_Cache_Lookup */ if ( !aglyph ) { error = FTC_Err_Invalid_Argument; goto Exit; } *aglyph = NULL; if ( anode ) *anode = NULL; query.attrs.scaler.face_id = type->face_id; query.attrs.scaler.width = type->width; query.attrs.scaler.height = type->height; query.attrs.scaler.pixel = 1; query.attrs.load_flags = type->flags; query.attrs.scaler.x_res = 0; /* make compilers happy */ query.attrs.scaler.y_res = 0; hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex; #if 1 /* inlining is about 50% faster! */ FTC_GCACHE_LOOKUP_CMP( cache, ftc_basic_family_compare, FTC_GNode_Compare, hash, gindex, &query, node, error ); #else error = FTC_GCache_Lookup( FTC_GCACHE( cache ), hash, gindex, FTC_GQUERY( &query ), (FTC_Node*) &node ); #endif if ( !error ) { *aglyph = FTC_INODE( node )->glyph; if ( anode ) { *anode = FTC_NODE( node ); FTC_NODE( node )->ref_count++; } } Exit: return error; }
FTC_SBitCache_LookupScaler( FTC_SBitCache cache, FTC_Scaler scaler, FT_ULong load_flags, FT_UInt gindex, FTC_SBit *ansbit, FTC_Node *anode ) { FT_Error error; FTC_BasicQueryRec query; FTC_Node node = 0; /* make compiler happy */ FT_Offset hash; if ( anode ) *anode = NULL; /* other argument checks delayed to `FTC_Cache_Lookup' */ if ( !ansbit || !scaler ) return FT_THROW( Invalid_Argument ); *ansbit = NULL; /* * Internal `FTC_BasicAttr->load_flags' is of type `FT_UInt', * but public `FT_Face->face_flags' is of type `FT_Long'. * * On long > int systems, higher bits of load_flags cannot be handled. */ #if FT_ULONG_MAX > FT_UINT_MAX if ( load_flags > FT_UINT_MAX ) FT_TRACE1(( "FTC_ImageCache_LookupScaler:" " higher bits in load_flags 0x%x are dropped\n", load_flags & ~((FT_ULong)FT_UINT_MAX) )); #endif query.attrs.scaler = scaler[0]; query.attrs.load_flags = (FT_UInt)load_flags; /* beware, the hash must be the same for all glyph ranges! */ hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex / FTC_SBIT_ITEMS_PER_NODE; FTC_GCACHE_LOOKUP_CMP( cache, ftc_basic_family_compare, FTC_SNode_Compare, hash, gindex, &query, node, error ); if ( error ) goto Exit; *ansbit = FTC_SNODE( node )->sbits + ( gindex - FTC_GNODE( node )->gindex ); if ( anode ) { *anode = node; node->ref_count++; } Exit: return error; }
FTC_SBitCache_Lookup( FTC_SBitCache cache, FTC_ImageType type, FT_UInt gindex, FTC_SBit *ansbit, FTC_Node *anode ) { FT_Error error; FTC_BasicQueryRec query; FTC_Node node = 0; /* make compiler happy */ FT_Offset hash; if ( anode ) *anode = NULL; /* other argument checks delayed to `FTC_Cache_Lookup' */ if ( !ansbit ) return FT_THROW( Invalid_Argument ); *ansbit = NULL; /* * Internal `FTC_BasicAttr->load_flags' is of type `FT_UInt', * but public `FT_ImageType->flags' is of type `FT_Int32'. * * On 16bit systems, higher bits of type->flags cannot be handled. */ #if 0xFFFFFFFFUL > FT_UINT_MAX if ( (type->flags & (FT_ULong)FT_UINT_MAX) ) FT_TRACE1(( "FTC_ImageCache_Lookup:" " higher bits in load_flags 0x%x are dropped\n", (FT_ULong)type->flags & ~((FT_ULong)FT_UINT_MAX) )); #endif query.attrs.scaler.face_id = type->face_id; query.attrs.scaler.width = type->width; query.attrs.scaler.height = type->height; query.attrs.load_flags = (FT_UInt)type->flags; query.attrs.scaler.pixel = 1; query.attrs.scaler.x_res = 0; /* make compilers happy */ query.attrs.scaler.y_res = 0; /* beware, the hash must be the same for all glyph ranges! */ hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex / FTC_SBIT_ITEMS_PER_NODE; #if 1 /* inlining is about 50% faster! */ FTC_GCACHE_LOOKUP_CMP( cache, ftc_basic_family_compare, FTC_SNode_Compare, hash, gindex, &query, node, error ); #else error = FTC_GCache_Lookup( FTC_GCACHE( cache ), hash, gindex, FTC_GQUERY( &query ), &node ); #endif if ( error ) goto Exit; *ansbit = FTC_SNODE( node )->sbits + ( gindex - FTC_GNODE( node )->gindex ); if ( anode ) { *anode = node; node->ref_count++; } Exit: return error; }
FTC_ImageCache_LookupScaler( FTC_ImageCache cache, FTC_Scaler scaler, FT_ULong load_flags, FT_UInt gindex, FT_Glyph *aglyph, FTC_Node *anode ) { FTC_BasicQueryRec query; FTC_Node node = 0; /* make compiler happy */ FT_Error error; FT_Offset hash; /* some argument checks are delayed to `FTC_Cache_Lookup' */ if ( !aglyph || !scaler ) { error = FT_THROW( Invalid_Argument ); goto Exit; } *aglyph = NULL; if ( anode ) *anode = NULL; /* * Internal `FTC_BasicAttr->load_flags' is of type `FT_UInt', * but public `FT_Face->face_flags' is of type `FT_Long'. * * On long > int systems, higher bits of load_flags cannot be handled. */ #if FT_ULONG_MAX > FT_UINT_MAX if ( load_flags > FT_UINT_MAX ) FT_TRACE1(( "FTC_ImageCache_LookupScaler:" " higher bits in load_flags 0x%x are dropped\n", load_flags & ~((FT_ULong)FT_UINT_MAX) )); #endif query.attrs.scaler = scaler[0]; query.attrs.load_flags = (FT_UInt)load_flags; hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex; FTC_GCACHE_LOOKUP_CMP( cache, ftc_basic_family_compare, FTC_GNode_Compare, hash, gindex, &query, node, error ); if ( !error ) { *aglyph = FTC_INODE( node )->glyph; if ( anode ) { *anode = node; node->ref_count++; } } Exit: return error; }
FTC_ImageCache_Lookup( FTC_ImageCache cache, FTC_ImageType type, FT_UInt gindex, FT_Glyph *aglyph, FTC_Node *anode ) { FTC_BasicQueryRec query; FTC_INode node = 0; /* make compiler happy */ FT_Error error; FT_UInt32 hash; /* some argument checks are delayed to FTC_Cache_Lookup */ if ( !aglyph ) { error = FTC_Err_Invalid_Argument; goto Exit; } *aglyph = NULL; if ( anode ) *anode = NULL; #ifdef FT_CONFIG_OPTION_OLD_INTERNALS /* * This one is a major hack used to detect whether we are passed a * regular FTC_ImageType handle, or a legacy FTC_OldImageDesc one. */ if ( type->width >= 0x10000 ) { FTC_OldImageDesc desc = (FTC_OldImageDesc)type; query.attrs.scaler.face_id = desc->font.face_id; query.attrs.scaler.width = desc->font.pix_width; query.attrs.scaler.height = desc->font.pix_height; query.attrs.load_flags = desc->flags; } else #endif /* FT_CONFIG_OPTION_OLD_INTERNALS */ { query.attrs.scaler.face_id = type->face_id; query.attrs.scaler.width = type->width; query.attrs.scaler.height = type->height; query.attrs.load_flags = type->flags; } query.attrs.scaler.pixel = 1; query.attrs.scaler.x_res = 0; /* make compilers happy */ query.attrs.scaler.y_res = 0; hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex; #if 1 /* inlining is about 50% faster! */ FTC_GCACHE_LOOKUP_CMP( cache, ftc_basic_family_compare, FTC_GNode_Compare, hash, gindex, &query, node, error ); #else error = FTC_GCache_Lookup( FTC_GCACHE( cache ), hash, gindex, FTC_GQUERY( &query ), (FTC_Node*) &node ); #endif if ( !error ) { *aglyph = FTC_INODE( node )->glyph; if ( anode ) { *anode = FTC_NODE( node ); FTC_NODE( node )->ref_count++; } } Exit: return error; }
FTC_ImageCache_Lookup( FTC_ImageCache cache, FTC_ImageType type, FT_UInt gindex, FT_Glyph *aglyph, FTC_Node *anode ) { FTC_BasicQueryRec query; FTC_Node node = 0; /* make compiler happy */ FT_Error error; FT_Offset hash; /* some argument checks are delayed to `FTC_Cache_Lookup' */ if ( !aglyph ) { error = FT_THROW( Invalid_Argument ); goto Exit; } *aglyph = NULL; if ( anode ) *anode = NULL; if ( (FT_ULong)( type->flags - FT_INT_MIN ) > FT_UINT_MAX ) FT_TRACE1(( "FTC_ImageCache_Lookup:" " higher bits in load_flags 0x%x are dropped\n", (FT_ULong)type->flags & ~((FT_ULong)FT_UINT_MAX) )); query.attrs.scaler.face_id = type->face_id; query.attrs.scaler.width = type->width; query.attrs.scaler.height = type->height; query.attrs.load_flags = (FT_UInt)type->flags; query.attrs.scaler.pixel = 1; query.attrs.scaler.x_res = 0; /* make compilers happy */ query.attrs.scaler.y_res = 0; hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex; #if 1 /* inlining is about 50% faster! */ FTC_GCACHE_LOOKUP_CMP( cache, ftc_basic_family_compare, FTC_GNode_Compare, hash, gindex, &query, node, error ); #else error = FTC_GCache_Lookup( FTC_GCACHE( cache ), hash, gindex, FTC_GQUERY( &query ), &node ); #endif if ( !error ) { *aglyph = FTC_INODE( node )->glyph; if ( anode ) { *anode = node; node->ref_count++; } } Exit: return error; }