minhngoc25a
/
freetype2
mirror of git://git.savannah.gnu.org/freetype/freetype2.git
2
1
Fork 2
Code Issues 9 Releases Wiki Activity

Formatting. 

* src/cache/ftccache.c (ftc_node_destroy, ftc_cache_lookup): Fix
tracing strings.
* src/cache/ftccmap.c (ftc_cmap_family_init): Ditto.
* src/cache/ftcmanag.c (ftc_family_table_alloc,
ftc_family_table_free, FTC_Manager_Check): Ditto.
* src/cache/ftcsbits.c (ftc_sbit_node_load): Ditto.
This commit is contained in:
Werner Lemberg 2001-12-20 17:49:10 +00:00
parent 7c0403638f
commit a931abf7a1
16 changed files with 859 additions and 764 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
ChangeLog
View File

@ -1,36 +1,44 @@
2001-12-20 Werner Lemberg <wl@gnu.org>
* src/cache/ftccache.c (ftc_node_destroy, ftc_cache_lookup): Fix
tracing strings.
* src/cache/ftccmap.c (ftc_cmap_family_init): Ditto.
* src/cache/ftcmanag.c (ftc_family_table_alloc,
ftc_family_table_free, FTC_Manager_Check): Ditto.
* src/cache/ftcsbits.c (ftc_sbit_node_load): Ditto.
2001-12-20 David Turner <david@freetype.org>
* include/freetype/config/ftoption.h: disabling bytecode interpreter
for new release
* include/freetype/config/ftoption.h: Disabling bytecode interpreter
for new release.
* docs/CHANGES: updated for 2.0.6 release
* docs/CHANGES: Updated for 2.0.6 release.
* src/cff/cffload.h, src/cff/cffload.c, src/cff/cffgload.c: updated
to mode the definition of encoding tables within "cffload.c" instead
of making them part of a shared header (causing problems in "multi"
builds)
* src/cff/cffload.h, src/cff/cffload.c, src/cff/cffgload.c: Updated
to mode the definition of encoding tables within "cffload.c" instead
of making them part of a shared header (causing problems in "multi"
builds).
* docs/TODO: added "stem3 and counter hints support" to the TODO list
for the Postscript hinter
* docs/TODO: Added "stem3 and counter hints support" to the TODO list
for the Postscript hinter.
* docs/BUGS: closed the AUTOHINT-NO-SBITS bug.
* docs/BUGS: Closed the AUTOHINT-NO-SBITS bug.
* src/pshinter/pshrec.c (t2_hint_stems), src/cff/cffobjs.h,
src/cff/cffobjs.c, src/cff/cffload.c, src/cff/cffload.h,
src/cff/cffgload.c, src/cff/cffgload.h, src/cff/cffdriver.c,
include/freetype/internal/cfftypes.h: added Postscript hinter support
to the CFF driver
* src/pshinter/pshrec.c (t2_hint_stems), src/cff/cffobjs.h,
src/cff/cffobjs.c, src/cff/cffload.c, src/cff/cffload.h,
src/cff/cffgload.c, src/cff/cffgload.h, src/cff/cffdriver.c,
include/freetype/internal/cfftypes.h: added Postscript hinter support
to the CFF driver.
* src/base/ftobjs.c (FT_Done_Library): fixed a stupid bug that crashed
the library on exit
* src/base/ftobjs.c (FT_Done_Library): Fixed a stupid bug that crashed
the library on exit.
* src/type1/t1gload.c (T1_Load_Glyph): enable font matrix transform
on hinted glyphs..
* src/cid/cidgload.c, src/cid/cidobjs.c, src/cid/cidobjs.h,
src/cid/cidriver.c, include/freetype/internal/t1types.h: added
Postscript hinter support to the CID font driver !!
* src/type1/t1gload.c (T1_Load_Glyph): Enable font matrix transform
on hinted glyphs.
* src/cid/cidgload.c, src/cid/cidobjs.c, src/cid/cidobjs.h,
src/cid/cidriver.c, include/freetype/internal/t1types.h: Added
Postscript hinter support to the CID font driver.
2001-12-19 David Turner <david@freetype.org>

182
include/freetype/cache/ftccache.h vendored
View File

@ -1,23 +1,39 @@
#ifndef __FT_CACHE_CACHE_H__
#define __FT_CACHE_CACHE_H__
/***************************************************************************/
/* */
/* ftccache.h */
/* */
/* FreeType internal cache interface (specification). */
/* */
/* 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 __FTCCACHE_H__
#define __FTCCACHE_H__
FT_BEGIN_HEADER
/* handle to cache object */
typedef struct FTC_CacheRec_* FTC_Cache;
/* handle to cache class */
typedef const struct FTC_Cache_ClassRec_* FTC_Cache_Class;
/* handle to cache node family */
typedef struct FTC_FamilyRec_* FTC_Family;
/* handle to cache node family */
typedef struct FTC_FamilyRec_* FTC_Family;
/* handle to cache root query */
/* handle to cache root query */
typedef struct FTC_QueryRec_* FTC_Query;
/*************************************************************************/
/*************************************************************************/
@ -37,22 +53,24 @@ FT_BEGIN_HEADER
/* the cache. It can be an individual glyph image, a set of bitmaps */
/* glyphs for a given size, some metrics, etc. */
/* */
/*************************************************************************/
/* structure size should be 20 bytes on 32-bits machines */
/* structure size should be 20 bytes on 32-bits machines */
typedef struct FTC_NodeRec_
{
FTC_Node mru_next; /* circular mru list pointer */
FTC_Node mru_prev; /* circular mru list pointer */
FTC_Node link; /* used for hashing.. */
FT_UInt32 hash; /* used for hashing too.. */
FTC_Node link; /* used for hashing */
FT_UInt32 hash; /* used for hashing too */
FT_UShort fam_index; /* index of family the node belongs to */
FT_Short ref_count; /* reference count for this node.. */
FT_Short ref_count; /* reference count for this node */
} FTC_NodeRec;
#define FTC_NODE(x) ((FTC_Node)(x))
#define FTC_NODE_P(x) ((FTC_Node*)(x))
#define FTC_NODE( x ) ( (FTC_Node)(x) )
#define FTC_NODE_P( x ) ( (FTC_Node*)(x) )
/*************************************************************************/
/* */
@ -66,7 +84,6 @@ FT_BEGIN_HEADER
ftc_node_done( FTC_Node node,
FTC_Cache cache );
/* reserved for manager's use */
FT_EXPORT( void )
ftc_node_destroy( FTC_Node node,
@ -81,11 +98,11 @@ FT_BEGIN_HEADER
/*************************************************************************/
/*************************************************************************/
/* structure modelling a cache node query. the following fields must */
/* all be set by the @FTC_Family_CompareFunc method of a cache's family */
/* list */
/* */
typedef struct FTC_QueryRec_
/* A structure modelling a cache node query. The following fields must */
/* all be set by the @FTC_Family_CompareFunc method of a cache's family */
/* list. */
/* */
typedef struct FTC_QueryRec_
{
FTC_Family family;
FT_UFast hash;
@ -93,10 +110,8 @@ FT_BEGIN_HEADER
} FTC_QueryRec;
#define FTC_QUERY(x) ((FTC_Query)(x))
#define FTC_QUERY_P(x) ((FTC_Query*)(x))
#define FTC_QUERY( x ) ( (FTC_Query)(x) )
#define FTC_QUERY_P( x ) ( (FTC_Query*)(x) )
/*************************************************************************/
@ -107,17 +122,18 @@ FT_BEGIN_HEADER
/*************************************************************************/
/*************************************************************************/
typedef struct FTC_FamilyRec_
typedef struct FTC_FamilyRec_
{
FT_LruNodeRec lru;
FTC_Cache cache;
FT_UInt num_nodes;
FT_UInt fam_index;
} FTC_FamilyRec;
#define FTC_FAMILY(x) ((FTC_Family)(x))
#define FTC_FAMILY_P(x) ((FTC_Family*)(x))
#define FTC_FAMILY( x ) ( (FTC_Family)(x) )
#define FTC_FAMILY_P( x ) ( (FTC_Family*)(x) )
/*************************************************************************/
@ -127,16 +143,16 @@ FT_BEGIN_HEADER
/* cache sub-system internals. */
/* */
/* must be called by any FTC_Node_InitFunc routine */
FT_EXPORT(FT_Error)
/* must be called by any FTC_Node_InitFunc routine */
FT_EXPORT( FT_Error )
ftc_family_init( FTC_Family family,
FTC_Query query,
FTC_Cache cache );
/* can be used as a FTC_Family_DoneFunc, otherwise, must be called */
/* by any family finalizer function.. */
FT_EXPORT(void)
/* can be used as a FTC_Family_DoneFunc; otherwise, must be called */
/* by any family finalizer function */
FT_EXPORT( void )
ftc_family_done( FTC_Family family );
@ -148,7 +164,7 @@ FT_BEGIN_HEADER
/*************************************************************************/
/*************************************************************************/
/* each cache really implements a dynamic hash table to manage its nodes */
/* each cache really implements a dynamic hash table to manage its nodes */
typedef struct FTC_CacheRec_
{
FTC_Manager manager;
@ -168,47 +184,57 @@ FT_BEGIN_HEADER
} FTC_CacheRec;
#define FTC_CACHE(x) ((FTC_Cache)(x))
#define FTC_CACHE_P(x) ((FTC_Cache*)(x))
#define FTC_CACHE( x ) ( (FTC_Cache)(x) )
#define FTC_CACHE_P( x ) ( (FTC_Cache*)(x) )
/* initialize a given cache */
typedef FT_Error (*FTC_Cache_InitFunc)( FTC_Cache cache );
typedef FT_Error
(*FTC_Cache_InitFunc)( FTC_Cache cache );
/* clear a cache */
typedef void (*FTC_Cache_ClearFunc)( FTC_Cache cache );
/* finalize a given cache */
typedef void (*FTC_Cache_DoneFunc)( FTC_Cache cache );
typedef void
(*FTC_Cache_ClearFunc)( FTC_Cache cache );
/* finalize a given cache */
typedef void
(*FTC_Cache_DoneFunc)( FTC_Cache cache );
typedef FT_Error (*FTC_Family_InitFunc)( FTC_Family family,
FTC_Query query,
FTC_Cache cache );
typedef FT_Error
(*FTC_Family_InitFunc)( FTC_Family family,
FTC_Query query,
FTC_Cache cache );
typedef FT_Int (*FTC_Family_CompareFunc)( FTC_Family family,
FTC_Query query );
typedef FT_Int
(*FTC_Family_CompareFunc)( FTC_Family family,
FTC_Query query );
typedef void (*FTC_Family_DoneFunc)( FTC_Family family,
FTC_Cache cache );
/* initialize a new cache node */
typedef FT_Error (*FTC_Node_InitFunc)( FTC_Node node,
FT_Pointer type,
FTC_Cache cache );
typedef void
(*FTC_Family_DoneFunc)( FTC_Family family,
FTC_Cache cache );
/* initialize a new cache node */
typedef FT_Error
(*FTC_Node_InitFunc)( FTC_Node node,
FT_Pointer type,
FTC_Cache cache );
/* compute the weight of a given cache node */
typedef FT_ULong (*FTC_Node_WeightFunc)( FTC_Node node,
FTC_Cache cache );
typedef FT_ULong
(*FTC_Node_WeightFunc)( FTC_Node node,
FTC_Cache cache );
/* compare a node to a given key pair */
typedef FT_Bool (*FTC_Node_CompareFunc)( FTC_Node node,
FT_Pointer key,
FTC_Cache cache );
typedef FT_Bool
(*FTC_Node_CompareFunc)( FTC_Node node,
FT_Pointer key,
FTC_Cache cache );
/* finalize a given cache node */
typedef void (*FTC_Node_DoneFunc)( FTC_Node node,
FTC_Cache cache );
typedef void
(*FTC_Node_DoneFunc)( FTC_Node node,
FTC_Cache cache );
typedef struct FTC_Cache_ClassRec_
@ -222,17 +248,19 @@ FT_BEGIN_HEADER
FTC_Family_InitFunc family_init;
FTC_Family_CompareFunc family_compare;
FTC_Family_DoneFunc family_done;
FT_UInt node_size;
FTC_Node_InitFunc node_init;
FTC_Node_WeightFunc node_weight;
FTC_Node_CompareFunc node_compare;
FTC_Node_DoneFunc node_done;
} FTC_Cache_ClassRec;
/* */
/*************************************************************************/
/* */
/* These functions are exported so that they can be called from */
@ -245,28 +273,28 @@ FT_BEGIN_HEADER
FT_EXPORT( void )
ftc_cache_done( FTC_Cache cache );
/* can be used directly as FTC_Cache_ClearFunc(), or called by custom */
/* cache clear routines.. */
/* cache clear routines */
FT_EXPORT( void )
ftc_cache_clear( FTC_Cache cache );
/* initalize the hash table within the cache */
FT_EXPORT( FT_Error )
ftc_cache_init( FTC_Cache cache );
/* can be called when the key's hash value has been computed */
FT_EXPORT(FT_Error)
ftc_cache_lookup( FTC_Cache cache,
FTC_Query query,
FTC_Node *anode );
/* can be called when the key's hash value has been computed */
FT_EXPORT( FT_Error )
ftc_cache_lookup( FTC_Cache cache,
FTC_Query query,
FTC_Node *anode );
/* */
FT_END_HEADER
#endif /* __FT_CACHE_CACHE_H__ */
#endif /* __FTCCACHE_H__ */
/* END */

272
include/freetype/cache/ftccmap.h vendored
View File

@ -2,7 +2,7 @@
/* */
/* ftccmap.h */
/* */
/* FreeType charmap cache */
/* FreeType charmap cache (specification). */
/* */
/* Copyright 2000-2001 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -15,111 +15,119 @@
/* */
/***************************************************************************/
#ifndef __FT_CACHE_CHARMAP_H__
#define __FT_CACHE_CHARMAP_H__
#ifndef __FTCCMAP_H__
#define __FTCCMAP_H__
#include <ft2build.h>
#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_CmapCache */
/* */
/* @description: */
/* An opaque handle used to manager a charmap cache. This cache is */
/* 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;
/*************************************************************************/
/* */
/* @type: */
/* FTC_CMapDesc */
/* */
/* @description: */
/* A handle to an @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
/*************************************************************************/
/* */
/* @enum: */
/* FTC_CMapType */
/* */
/* @description: */
/* The list of valid @FTC_CMap types. They indicate how we want to */
/* address a charmap within an @FTC_FaceID. */
/* */
/* @values: */
/* FTC_CMAP_BY_INDEX :: */
/* Address a charmap by its index in the corresponding @FT_Face. */
/* */
/* FTC_CMAP_BY_ENCODING :: */
/* Use a @FT_Face charmap that corresponds to a given encoding. */
/* */
/* FTC_CMAP_BY_ID :: */
/* Use an @FT_Face charmap that corresponds to a given */
/* (platform,encoding) ID. See @FTC_CMapIdRec. */
/* */
typedef enum FTC_CMapType_
{
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_
/*************************************************************************/
/* */
/* @struct: */
/* FTC_CMapIdRec */
/* */
/* @description: */
/* A short structure to identify a charmap by a (platform,encoding) */
/* pair of values. */
/* */
/* @fields: */
/* platform :: The platform ID. */
/* */
/* encoding :: The 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_
/*************************************************************************/
/* */
/* @struct: */
/* FTC_CMapDescRec */
/* */
/* @description: */
/* A structure to describe a given charmap to @FTC_CMapCache. */
/* */
/* @fields: */
/* face_id :: @FTC_FaceID of the face this charmap belongs to. */
/* */
/* type :: The 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;
@ -129,67 +137,73 @@ FT_BEGIN_HEADER
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
*/
/*************************************************************************/
/* */
/* @function: */
/* FTC_CMapCache_New */
/* */
/* @description: */
/* Creates a new charmap cache. */
/* */
/* @input: */
/* manager :: A handle to the cache manager. */
/* */
/* @output: */
/* acache :: A 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
*/
/*************************************************************************/
/* */
/* @function: */
/* FTC_CMapCache_Lookup */
/* */
/* @description: */
/* Translates a character code into a glyph index, using the charmap */
/* cache. */
/* */
/* @input: */
/* cache :: A charmap cache handle. */
/* */
/* cmap_desc :: A charmap descriptor handle. */
/* */
/* char_code :: The 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__ */
#endif /* __FTCCMAP_H__ */
/* END */

129
include/freetype/cache/ftcglyph.h vendored
View File

@ -64,18 +64,18 @@
FT_BEGIN_HEADER
/* each glyph set is caracterized by a "glyph set type" which must be */
/* defined by sub-classes.. */
typedef struct FTC_GlyphFamilyRec_* FTC_GlyphFamily;
/* each glyph set is characterized by a "glyph set type" which must be */
/* defined by sub-classes */
typedef struct FTC_GlyphFamilyRec_* FTC_GlyphFamily;
/* handle to a glyph cache node */
typedef struct FTC_GlyphNodeRec_* FTC_GlyphNode;
/* handle to a glyph cache node */
typedef struct FTC_GlyphNodeRec_* FTC_GlyphNode;
/* size should be 24 + chunk size on 32-bit machines */
/* note that the node's hash is ((gfam->hash << 16) | glyph_index) */
/* this _must_ be set properly by the glyph node initializer.. */
/* */
/* size should be 24 + chunk size on 32-bit machines; */
/* note that the node's hash is ((gfam->hash << 16) | glyph_index) -- */
/* this _must_ be set properly by the glyph node initializer */
/* */
typedef struct FTC_GlyphNodeRec_
{
FTC_NodeRec node;
@ -84,9 +84,9 @@ FT_BEGIN_HEADER
} FTC_GlyphNodeRec;
#define FTC_GLYPH_NODE(x) ((FTC_GlyphNode)(x))
#define FTC_GLYPH_NODE_P(x) ((FTC_GlyphNode*)(x))
#define FTC_GLYPH_NODE( x ) ( (FTC_GlyphNode)(x) )
#define FTC_GLYPH_NODE_P( x ) ( (FTC_GlyphNode*)(x) )
typedef struct FTC_GlyphQueryRec_
@ -96,13 +96,12 @@ FT_BEGIN_HEADER
} FTC_GlyphQueryRec, *FTC_GlyphQuery;
#define FTC_GLYPH_QUERY(x) ((FTC_GlyphQuery)(x))
#define FTC_GLYPH_QUERY( x ) ( (FTC_GlyphQuery)(x) )
/* a glyph set is used to categorize glyphs of a given type */
typedef struct FTC_GlyphFamilyRec_
/* a glyph set is used to categorize glyphs of a given type */
typedef struct FTC_GlyphFamilyRec_
{
FTC_FamilyRec family;
FT_UInt32 hash;
@ -112,42 +111,43 @@ FT_BEGIN_HEADER
} FTC_GlyphFamilyRec;
#define FTC_GLYPH_FAMILY(x) ((FTC_GlyphFamily)(x))
#define FTC_GLYPH_FAMILY_P(x) ((FTC_GlyphFamily*)(x))
#define FTC_GLYPH_FAMILY( x ) ( (FTC_GlyphFamily)(x) )
#define FTC_GLYPH_FAMILY_P( x ) ( (FTC_GlyphFamily*)(x) )
#define FTC_GLYPH_FAMILY_MEMORY(x) FTC_FAMILY(x)->cache->memory
/* each glyph node contains a 'chunk' of glyph items */
/* translate a glyph index into a chunk index */
#define FTC_GLYPH_FAMILY_CHUNK(gfam,gindex) \
( (gindex) / FTC_GLYPH_FAMILY(gfam)->item_count )
/* find a glyph index's chunk, and return its start index */
/* */
#define FTC_GLYPH_FAMILY_START(gfam,gindex) \
( FTC_GLYPH_FAMILY_CHUNK(gfam,gindex) * FTC_GLYPH_FAMILY(gfam)->item_count )
/* compute a glyph request's hash value */
/* */
#define FTC_GLYPH_FAMILY_HASH(gfam,gindex) \
((FT_UFast)( (FTC_GLYPH_FAMILY(gfam)->hash << 16) | \
(FTC_GLYPH_FAMILY_CHUNK(gfam,gindex) & 0xFFFF) ))
/* must be called in a FTC_Family_CompareFunc to update the query */
/* whenever a glyph set is matched in the lookup.. or when it */
/* is created */
/* */
#define FTC_GLYPH_FAMILY_FOUND(gfam,gquery) \
do { \
FTC_QUERY(gquery)->family = FTC_FAMILY(gfam); \
FTC_QUERY(gquery)->hash = \
FTC_GLYPH_FAMILY_HASH(gfam,FTC_GLYPH_QUERY(gquery)->gindex); \
} while (0)
#define FTC_GLYPH_FAMILY_MEMORY( x ) FTC_FAMILY(x)->cache->memory
/* retrieve glyph index of glyph node */
#define FTC_GLYPH_NODE_GINDEX(x) \
((FT_UInt)(FTC_GLYPH_NODE(x)->node.hash & 0xFFFF))
/* each glyph node contains a 'chunk' of glyph items; */
/* translate a glyph index into a chunk index */
#define FTC_GLYPH_FAMILY_CHUNK( gfam, gindex ) \
( ( gindex ) / FTC_GLYPH_FAMILY( gfam )->item_count )
/* find a glyph index's chunk, and return its start index */
#define FTC_GLYPH_FAMILY_START( gfam, gindex ) \
( FTC_GLYPH_FAMILY_CHUNK( gfam, gindex ) * \
FTC_GLYPH_FAMILY( gfam )->item_count )
/* compute a glyph request's hash value */
#define FTC_GLYPH_FAMILY_HASH( gfam, gindex ) \
( (FT_UFast)( \
( FTC_GLYPH_FAMILY( gfam )->hash << 16 ) | \
( FTC_GLYPH_FAMILY_CHUNK( gfam, gindex ) & 0xFFFF ) ) )
/* must be called in an FTC_Family_CompareFunc to update the query */
/* whenever a glyph set is matched in the lookup, or when it */
/* is created */
#define FTC_GLYPH_FAMILY_FOUND( gfam, gquery ) \
do \
{ \
FTC_QUERY( gquery )->family = FTC_FAMILY( gfam ); \
FTC_QUERY( gquery )->hash = \
FTC_GLYPH_FAMILY_HASH( gfam, \
FTC_GLYPH_QUERY( gquery )->gindex ); \
} while ( 0 )
/* retrieve glyph index of glyph node */
#define FTC_GLYPH_NODE_GINDEX( x ) \
( (FT_UInt)( FTC_GLYPH_NODE( x )->node.hash & 0xFFFF ) )
/*************************************************************************/
@ -159,18 +159,16 @@ FT_BEGIN_HEADER
/* must be called by derived FTC_Node_InitFunc routines */
FT_EXPORT( void )
ftc_glyph_node_init( FTC_GlyphNode node,
FT_UInt gindex, /* glyph index for node */
FTC_GlyphFamily gfam );
ftc_glyph_node_init( FTC_GlyphNode node,
FT_UInt gindex, /* glyph index for node */
FTC_GlyphFamily gfam );
/* returns TRUE iff the query's glyph index correspond to the node */
/* this assume that the "family" and "hash" fields of the query are */
/* already correctly set.. */
/* */
/* returns TRUE iff the query's glyph index correspond to the node; */
/* this assumes that the "family" and "hash" fields of the query are */
/* already correctly set */
FT_EXPORT( FT_Bool )
ftc_glyph_node_compare( FTC_GlyphNode gnode,
FTC_GlyphQuery gquery );
ftc_glyph_node_compare( FTC_GlyphNode gnode,
FTC_GlyphQuery gquery );
/* must be called by derived FTC_Node_DoneFunc routines */
FT_EXPORT( void )
@ -178,7 +176,8 @@ FT_BEGIN_HEADER
FTC_Cache cache );
/* must be called by derived FTC_Family_InitFunc, calls "ftc_family_init" */
/* must be called by derived FTC_Family_InitFunc; */
/* calls "ftc_family_init" */
FT_EXPORT( FT_Error )
ftc_glyph_family_init( FTC_GlyphFamily gfam,
FT_UInt32 hash,
@ -187,14 +186,16 @@ FT_BEGIN_HEADER
FTC_GlyphQuery gquery,
FTC_Cache cache );
FT_EXPORT( void )
ftc_glyph_family_done( FTC_GlyphFamily gfam );
/* */
/* */
FT_END_HEADER
#endif /* __FTC_GLYPH_H__ */
#endif /* __FTCGLYPH_H__ */
/* END */

101
include/freetype/cache/ftcimage.h vendored
View File

@ -2,7 +2,7 @@
/* */
/* ftcimage.h */
/* */
/* FreeType Image cache (body). */
/* FreeType Image cache (specification). */
/* */
/* Copyright 2000-2001 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -56,16 +56,16 @@ FT_BEGIN_HEADER
#define FTC_IMAGE_FORMAT( x ) ( (x) & 7 )
#define ftc_image_format_bitmap 0x0000
#define ftc_image_format_outline 0x0001
#define ftc_image_format_bitmap 0x0000
#define ftc_image_format_outline 0x0001
#define ftc_image_format_mask 0x000F
#define ftc_image_format_mask 0x000F
#define ftc_image_flag_monochrome 0x0010
#define ftc_image_flag_unhinted 0x0020
#define ftc_image_flag_autohinted 0x0040
#define ftc_image_flag_unscaled 0x0080
#define ftc_image_flag_no_sbits 0x0100
#define ftc_image_flag_monochrome 0x0010
#define ftc_image_flag_unhinted 0x0020
#define ftc_image_flag_autohinted 0x0040
#define ftc_image_flag_unscaled 0x0080
#define ftc_image_flag_no_sbits 0x0100
/* monochrome bitmap */
#define ftc_image_mono ftc_image_format_bitmap | \
@ -85,16 +85,16 @@ FT_BEGIN_HEADER
/* */
/* <Description> */
/* A simple structure used to describe a given glyph image category. */
/* note that this is different from @FTC_Image_Desc */
/* Note that this is different from @FTC_Image_Desc. */
/* */
/* <Fields> */
/* size :: An FTC_SizeRec used to describe the glyph's face & */
/* size :: An @FTC_SizeRec used to describe the glyph's face and */
/* size. */
/* */
/* type :: The glyph image's type. note that it's a 32-bit uint */
/* type :: The glyph image's type. Note that it is a 32-bit uint. */
/* */
/* <Note> */
/* this type deprecates @FTC_Image_Desc */
/* This type deprecates @FTC_Image_Desc. */
/* */
typedef struct FTC_ImageDesc_
{
@ -104,13 +104,15 @@ FT_BEGIN_HEADER
} FTC_ImageDesc;
/* */
#define FTC_IMAGE_DESC_COMPARE( d1, d2 ) \
( FTC_FONT_COMPARE( &(d1)->font, &(d2)->font ) && \
(d1)->type == (d2)->type )
#define FTC_IMAGE_DESC_HASH(d) \
(FT_UFast)( FTC_FONT_HASH(&(d)->font) ^ \
((d)->type << 4) )
#define FTC_IMAGE_DESC_COMPARE( d1, d2 ) \
( FTC_FONT_COMPARE( &(d1)->font, &(d2)->font ) && \
(d1)->type == (d2)->type )
#define FTC_IMAGE_DESC_HASH( d ) \
(FT_UFast)( FTC_FONT_HASH( &(d)->font ) ^ \
( (d)->type << 4 ) )
/*************************************************************************/
/* */
@ -119,7 +121,7 @@ FT_BEGIN_HEADER
/* */
/* <Description> */
/* A handle to an glyph image cache object. They are designed to */
/* hold many distinct glyph images, while not exceeding a certain */
/* hold many distinct glyph images while not exceeding a certain */
/* memory threshold. */
/* */
typedef struct FTC_ImageCacheRec_* FTC_ImageCache;
@ -153,10 +155,9 @@ FT_BEGIN_HEADER
/* FTC_ImageCache_Lookup */
/* */
/* <Description> */
/* Retrieves a given glyph image from a glyph image cache */
/* and 'acquire' it. This prevents the glyph image from being */
/* flushed out of the cache, until @FTC_Image_Cache_Release is */
/* called */
/* Retrieves a given glyph image from a glyph image cache and */
/* `acquires' it. This prevents the glyph image from being flushed */
/* out of the cache, until @FTC_Image_Cache_Release is called. */
/* */
/* <Input> */
/* cache :: A handle to the source glyph image cache. */
@ -166,13 +167,13 @@ FT_BEGIN_HEADER
/* gindex :: The glyph index to retrieve. */
/* */
/* <Output> */
/* aglyph :: The corresponding FT_Glyph object. 0 in case of */
/* aglyph :: The corresponding @FT_Glyph object. 0 in case of */
/* failure. */
/* */
/* anode :: an opaque cache node pointer that will be used */
/* to release the glyph once it becomes unuseful. */
/* can be NULL, in which case this function will */
/* have the same effect than @FTC_Image_Cache_Lookup */
/* anode :: An opaque cache node pointer that will be used to */
/* release the glyph once it becomes unuseful. Can be */
/* NULL, in which case this function will have the same */
/* effect as @FTC_Image_Cache_Release. XXX */
/* */
/* <Return> */
/* FreeType error code. 0 means success. */
@ -180,20 +181,19 @@ FT_BEGIN_HEADER
/* <Note> */
/* The returned glyph is owned and managed by the glyph image cache. */
/* Never try to transform or discard it manually! You can however */
/* create a copy with FT_Glyph_Copy() and modify the new one. */
/* */
/* if 'anode' is NULL */
/* create a copy with @FT_Glyph_Copy and modify the new one. */
/* */
/* Because the glyph image cache limits the total amount of memory */
/* taken by the glyphs it holds, the returned glyph might disappear */
/* on a later invocation of this function! It's a cache after all... */
/* on a later invocation of this function! It is a cache after */
/* all... */
/* */
FT_EXPORT( FT_Error )
FTC_ImageCache_Lookup( FTC_ImageCache cache,
FTC_ImageDesc* desc,
FT_UInt gindex,
FT_Glyph *aglyph,
FTC_Node *anode );
FT_UInt gindex,
FT_Glyph *aglyph,
FTC_Node *anode );
/* */
@ -204,18 +204,16 @@ FT_BEGIN_HEADER
/* FTC_Image_Desc */
/* */
/* <Description> */
/* THIS TYPE IS DEPRECATED. USE @FTC_ImageDesc instead.. */
/* THIS TYPE IS DEPRECATED. Use @FTC_ImageDesc instead. */
/* */
/* A simple structure used to describe a given glyph image category. */
/* */
/* <Fields> */
/* size :: An FTC_SizeRec used to describe the glyph's face & */
/* size. */
/* size :: An @FTC_SizeRec used to describe the glyph's face */
/* and size. */
/* */
/* image_type :: The glyph image's type. */
/* */
/* <Note> */
/* */
/* */
typedef struct FTC_Image_Desc_
{
FTC_FontRec font;
@ -230,19 +228,19 @@ FT_BEGIN_HEADER
/* FTC_Image_Cache */
/* */
/* <Description> */
/* THIS TYPE IS DEPRECATED, USE @FTC_ImageCache instead */
/* THIS TYPE IS DEPRECATED. Use @FTC_ImageCache instead. */
/* */
typedef FTC_ImageCache FTC_Image_Cache;
/*************************************************************************/
/* */
/* <Function> */
/* FTC_Image_Cache_New */
/* */
/* <Description> */
/* THIS FUNCTION IS DEPRECATED, USE @FTC_ImageCache_New instead */
/* THIS FUNCTION IS DEPRECATED. Use @FTC_ImageCache_New instead. */
/* */
/* Creates a new glyph image cache. */
/* */
/* <Input> */
@ -265,7 +263,7 @@ FT_BEGIN_HEADER
/* FTC_Image_Cache_Lookup */
/* */
/* <Description> */
/* THIS FUNCTION IS DEPRECATED. USE @FTC_ImageCache_Lookup instead */
/* THIS FUNCTION IS DEPRECATED. Use @FTC_ImageCache_Lookup instead. */
/* */
/* <Input> */
/* cache :: A handle to the source glyph image cache. */
@ -275,7 +273,7 @@ FT_BEGIN_HEADER
/* gindex :: The glyph index to retrieve. */
/* */
/* <Output> */
/* aglyph :: The corresponding FT_Glyph object. 0 in case of */
/* aglyph :: The corresponding @FT_Glyph object. 0 in case of */
/* failure. */
/* */
/* <Return> */
@ -284,14 +282,14 @@ FT_BEGIN_HEADER
/* <Note> */
/* The returned glyph is owned and managed by the glyph image cache. */
/* Never try to transform or discard it manually! You can however */
/* create a copy with FT_Glyph_Copy() and modify the new one. */
/* create a copy with @FT_Glyph_Copy and modify the new one. */
/* */
/* Because the glyph image cache limits the total amount of memory */
/* taken by the glyphs it holds, the returned glyph might disappear */
/* on a later invocation of this function! It's a cache after all... */
/* on a later invocation of this function! It is a cache after */
/* all... */
/* */
/* use @FTC_ImageCache_Lookup to "lock" the glyph as long as you */
/* need it.. */
/* Use this function to "lock" the glyph as long as it is needed. */
/* */
FT_EXPORT( FT_Error )
FTC_Image_Cache_Lookup( FTC_Image_Cache cache,
@ -303,6 +301,7 @@ FT_BEGIN_HEADER
FT_END_HEADER
#endif /* __FTCIMAGE_H__ */

39
include/freetype/cache/ftcmanag.h vendored
View File

@ -23,7 +23,7 @@
/* - Maintain a mapping between generic FTC_FaceIDs and live FT_Face */
/* objects. The mapping itself is performed through a user-provided */
/* callback. However, the manager maintains a small cache of FT_Face */
/* & FT_Size objects in order to speed up things considerably. */
/* and FT_Size objects in order to speed up things considerably. */
/* */
/* - Manage one or more cache objects. Each cache is in charge of */
/* holding a varying number of `cache nodes'. Each cache node */
@ -68,6 +68,7 @@
#include FT_CACHE_INTERNAL_LRU_H
#include FT_CACHE_INTERNAL_CACHE_H
FT_BEGIN_HEADER
@ -81,24 +82,26 @@ FT_BEGIN_HEADER
#define FTC_MAX_FACES_DEFAULT 2
#define FTC_MAX_SIZES_DEFAULT 4
#define FTC_MAX_BYTES_DEFAULT 200000L /* ~200 KB bytes by default */
#define FTC_MAX_BYTES_DEFAULT 200000L /* ~200kByte by default */
/* maximum number of caches registered in a single manager */
#define FTC_MAX_CACHES 16
typedef struct FTC_FamilyEntryRec_
typedef struct FTC_FamilyEntryRec_
{
FTC_Family family;
FTC_Cache cache;
FT_UInt index;
FT_UInt link;
FTC_Family family;
FTC_Cache cache;
FT_UInt index;
FT_UInt link;
} FTC_FamilyEntryRec, *FTC_FamilyEntry;
#define FTC_FAMILY_ENTRY_NONE ((FT_UInt)-1)
typedef struct FTC_FamilyTableRec_
#define FTC_FAMILY_ENTRY_NONE ( (FT_UInt)-1 )
typedef struct FTC_FamilyTableRec_
{
FT_UInt count;
FT_UInt size;
@ -113,7 +116,6 @@ FT_BEGIN_HEADER
FT_Memory memory,
FTC_FamilyEntry *aentry );
FT_EXPORT( void )
ftc_family_table_free( FTC_FamilyTable table,
FT_UInt index );
@ -130,9 +132,9 @@ FT_BEGIN_HEADER
/* <Fields> */
/* library :: A handle to a FreeType library instance. */
/* */
/* faces_list :: The lru list of FT_Face objects in the cache. */
/* faces_list :: The lru list of @FT_Face objects in the cache. */
/* */
/* sizes_list :: The lru list of FT_Size objects in the cache. */
/* sizes_list :: The lru list of @FT_Size objects in the cache. */
/* */
/* max_weight :: The maximum cache pool weight. */
/* */
@ -147,8 +149,10 @@ FT_BEGIN_HEADER
/* request_data :: User-provided data passed to the requester. */
/* */
/* request_face :: User-provided function used to implement a mapping */
/* between abstract FTC_FaceIDs and real FT_Face */
/* objects. */
/* between abstract @FTC_FaceID values and real */
/* @FT_Face objects. */
/* */
/* families :: XXX */
/* */
typedef struct FTC_ManagerRec_
{
@ -167,7 +171,7 @@ FT_BEGIN_HEADER
FT_Pointer request_data;
FTC_Face_Requester request_face;
FTC_FamilyTableRec families;
FTC_FamilyTableRec families;
} FTC_ManagerRec;
@ -204,8 +208,8 @@ FT_BEGIN_HEADER
FTC_Cache *acache );
/* can be called to increment a node's reference count */
FT_EXPORT(void)
/* can be called to increment a node's reference count */
FT_EXPORT( void )
FTC_Node_Ref( FTC_Node node,
FTC_Manager manager );
@ -233,6 +237,7 @@ FT_BEGIN_HEADER
FT_END_HEADER
#endif /* __FTCMANAG_H__ */

30
include/freetype/cache/ftcsbits.h vendored
View File

@ -42,7 +42,7 @@ FT_BEGIN_HEADER
/* FTC_SBit */
/* */
/* <Description> */
/* A handle to a small bitmap descriptor. See the FTC_SBitRec */
/* A handle to a small bitmap descriptor. See the @FTC_SBitRec */
/* structure for details. */
/* */
typedef struct FTC_SBitRec_* FTC_SBit;
@ -98,31 +98,29 @@ FT_BEGIN_HEADER
} FTC_SBitRec;
/*************************************************************************/
/* */
/* <Type> */
/* FTC_SBit_Cache */
/* FTC_SBitCache */
/* */
/* <Description> */
/* A handle to a small bitmap cache. These are special cache objects */
/* used to store small glyph bitmaps (and anti-aliased pixmaps) in a */
/* much more efficient way than the traditional glyph image cache */
/* implemented by FTC_Image_Cache. */
/* implemented by @FTC_ImageCache. */
/* */
typedef struct FTC_SBitCacheRec_* FTC_SBitCache;
typedef struct FTC_SBitCacheRec_* FTC_SBitCache;
/*************************************************************************/
/* */
/* <Type> */
/* FTC_SBit_Cache */
/* */
/* <Description> */
/* deprecated. please use @FTC_SBitCache instead */
/* DEPRECATED. Use @FTC_SBitCache instead. */
/* */
typedef FTC_SBitCache FTC_SBit_Cache;
typedef FTC_SBitCache FTC_SBit_Cache;
/*************************************************************************/
@ -158,16 +156,18 @@ FT_BEGIN_HEADER
/* */
/* <Input> */
/* cache :: A handle to the source sbit cache. */
/* */
/* desc :: A pointer to the glyph image descriptor. */
/* */
/* gindex :: The glyph index. */
/* */
/* <Output> */
/* sbit :: A handle to a small bitmap descriptor. */
/* */
/* anode :: an opaque cache node pointer that will be used */
/* anode :: An opaque cache node pointer that will be used */
/* to release the sbit once it becomes unuseful. */
/* can be NULL, in which case this function will */
/* have the same effect than @FTC_SBit_Cache_Lookup */
/* Can be NULL, in which case this function will */
/* have the same effect as @FTC_SBitCache_Lookup. XXX */
/* */
/* <Return> */
/* FreeType error code. 0 means success. */
@ -198,6 +198,8 @@ FT_BEGIN_HEADER
/* FTC_SBit_Cache_New */
/* */
/* <Description> */
/* DEPRECATED. Use @FTC_SBitCache_New instead. */
/* */
/* Creates a new cache to store small glyph bitmaps. */
/* */
/* <Input> */
@ -220,11 +222,15 @@ FT_BEGIN_HEADER
/* FTC_SBit_Cache_Lookup */
/* */
/* <Description> */
/* DEPRECATED. Use @FTC_SBitCache_Lookup instead. */
/* */
/* Looks up a given small glyph bitmap in a given sbit cache. */
/* */
/* <Input> */
/* cache :: A handle to the source sbit cache. */
/* */
/* desc :: A pointer to the glyph image descriptor. */
/* */
/* gindex :: The glyph index. */
/* */
/* <Output> */

71
include/freetype/cache/ftlru.h vendored
View File

@ -19,7 +19,7 @@
/*************************************************************************/
/* */
/* An LRU is a list that cannot hold more than a certain number of */
/* elements (`max_elements'). All elements on the list are sorted in */
/* elements (`max_elements'). All elements in the list are sorted in */
/* least-recently-used order, i.e., the `oldest' element is at the tail */
/* of the list. */
/* */
@ -58,22 +58,25 @@
#ifndef __FTLRU_H__
#define __FTLRU_H__
#include <ft2build.h>
#include FT_FREETYPE_H
FT_BEGIN_HEADER
/* generic list key type */
typedef FT_Pointer FT_LruKey;
/* a list list handle */
typedef struct FT_LruListRec_* FT_LruList;
/* list class handle */
/* a list class handle */
typedef const struct FT_LruList_ClassRec_* FT_LruList_Class;
/* an list node handle */
typedef struct FT_LruNodeRec_* FT_LruNode;
/* a list node handle */
typedef struct FT_LruNodeRec_* FT_LruNode;
/* the list node structure */
typedef struct FT_LruNodeRec_
@ -87,53 +90,60 @@ FT_BEGIN_HEADER
/* the list structure */
typedef struct FT_LruListRec_
{
FT_Memory memory;
FT_LruList_Class clazz;
FT_LruNode nodes;
FT_UInt max_nodes;
FT_UInt num_nodes;
FT_Pointer data;
FT_Memory memory;
FT_LruList_Class clazz;
FT_LruNode nodes;
FT_UInt max_nodes;
FT_UInt num_nodes;
FT_Pointer data;
} FT_LruListRec;
/* initialize a list list */
typedef FT_Error (*FT_LruList_InitFunc)( FT_LruList list );
typedef FT_Error
(*FT_LruList_InitFunc)( FT_LruList list );
/* finalize a list list */
typedef void (*FT_LruList_DoneFunc)( FT_LruList list );
/* finalize a list list */
typedef void
(*FT_LruList_DoneFunc)( FT_LruList list );
/* this method is used to initialize a new list element node */
typedef FT_Error (*FT_LruNode_InitFunc)( FT_LruNode node,
FT_LruKey key,
FT_Pointer data );
typedef FT_Error
(*FT_LruNode_InitFunc)( FT_LruNode node,
FT_LruKey key,
FT_Pointer data );
/* this method is used to finalize a given list element node */
typedef void (*FT_LruNode_DoneFunc)( FT_LruNode node,
FT_Pointer data );
typedef void
(*FT_LruNode_DoneFunc)( FT_LruNode node,
FT_Pointer data );
/* If defined, this method is called when the list if full */
/* during the lookup process -- it is used to change the contents */
/* of a list element node, instead of calling `done_element()', */
/* of a list element node instead of calling `done_element()', */
/* then `init_element()'. Set it to 0 for default behaviour. */
typedef FT_Error (*FT_LruNode_FlushFunc)( FT_LruNode node,
FT_LruKey new_key,
FT_Pointer data );
typedef FT_Error
(*FT_LruNode_FlushFunc)( FT_LruNode node,
FT_LruKey new_key,
FT_Pointer data );
/* If defined, this method is used to compare a list element node */
/* with a given key during a lookup. If set to 0, the `key' */
/* fields will be directly compared instead. */
typedef FT_Bool (*FT_LruNode_CompareFunc)( FT_LruNode node,
FT_LruKey key,
FT_Pointer data );
typedef FT_Bool
(*FT_LruNode_CompareFunc)( FT_LruNode node,
FT_LruKey key,
FT_Pointer data );
/* A selector is used to indicate whether a given list element node */
/* is part of a selection for FT_LruList_Remove_Selection(). The */
/* functrion must return true (i.e., non-null) to indicate that the */
/* node is part of it. */
typedef FT_Bool (*FT_LruNode_SelectFunc)( FT_LruNode node,
FT_Pointer data,
FT_Pointer list_data );
typedef FT_Bool
(*FT_LruNode_SelectFunc)( FT_LruNode node,
FT_Pointer data,
FT_Pointer list_data );
/* LRU class */
typedef struct FT_LruList_ClassRec_
@ -164,22 +174,18 @@ FT_BEGIN_HEADER
FT_EXPORT( void )
FT_LruList_Reset( FT_LruList list );
FT_EXPORT( void )
FT_LruList_Destroy ( FT_LruList list );
FT_EXPORT( FT_Error )
FT_LruList_Lookup( FT_LruList list,
FT_LruKey key,
FT_LruNode *anode );
FT_EXPORT( void )
FT_LruList_Remove( FT_LruList list,
FT_LruNode node );
FT_EXPORT( void )
FT_LruList_Remove_Selection( FT_LruList list,
FT_LruNode_SelectFunc select_func,
@ -189,6 +195,7 @@ FT_BEGIN_HEADER
FT_END_HEADER
#endif /* __FTLRU_H__ */

68
include/freetype/ftcache.h
View File

@ -2,7 +2,7 @@
/* */
/* ftcache.h */
/* */
/* FreeType Cache subsystem. */
/* FreeType Cache subsystem (specification). */
/* */
/* Copyright 1996-2001 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -122,7 +122,7 @@ FT_BEGIN_HEADER
/* */
/* <Description> */
/* A callback function provided by client applications. It is used */
/* to translate a given FTC_FaceID into a new valid FT_Face object. */
/* to translate a given @FTC_FaceID into a new valid @FT_Face object. */
/* */
/* <Input> */
/* face_id :: The face ID to resolve. */
@ -132,15 +132,15 @@ FT_BEGIN_HEADER
/* data :: Application-provided request data. */
/* */
/* <Output> */
/* aface :: A new FT_Face handle. */
/* aface :: A new @FT_Face handle. */
/* */
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
/* <Note> */
/* The face requester should not perform funny things on the returned */
/* face object, like creating a new FT_Size for it, or setting a */
/* transformation through FT_Set_Transform()! */
/* face object, like creating a new @FT_Size for it, or setting a */
/* transformation through @FT_Set_Transform! */
/* */
typedef FT_Error
(*FTC_Face_Requester)( FTC_FaceID face_id,
@ -175,7 +175,8 @@ FT_BEGIN_HEADER
} FTC_FontRec;
/* */
/* */
#define FTC_FONT_COMPARE( f1, f2 ) \
( (f1)->face_id == (f2)->face_id && \
@ -189,13 +190,14 @@ FT_BEGIN_HEADER
((f)->pix_width << 8) ^ \
((f)->pix_height) )
/*************************************************************************/
/* */
/* <Type> */
/* FTC_Font */
/* */
/* <Description> */
/* A simple handle to a FTC_FontRec structure. */
/* A simple handle to an @FTC_FontRec structure. */
/* */
typedef FTC_FontRec* FTC_Font;
@ -217,8 +219,8 @@ FT_BEGIN_HEADER
/* FTC_Manager */
/* */
/* <Description> */
/* This object is used to cache one or more FT_Face objects, along */
/* with corresponding FT_Size objects. */
/* This object is used to cache one or more @FT_Face objects, along */
/* with corresponding @FT_Size objects. */
/* */
typedef struct FTC_ManagerRec_* FTC_Manager;
@ -229,18 +231,18 @@ FT_BEGIN_HEADER
/* FTC_Node */
/* */
/* <Description> */
/* an opaque handle to a cache node object. Each cache node is */
/* reference-counted. A node with a count of 0 might be flushed */
/* out of a full cache whenever a lookup request is performed */
/* An opaque handle to a cache node object. Each cache node is */
/* reference-counted. A node with a count of 0 might be flushed */
/* out of a full cache whenever a lookup request is performed. */
/* */
/* when you lookup nodes, you have the ability to "acquire" them, */
/* i.e. increment their reference count. This will prevent the node */
/* from being flushed out of the cache until you explicitely */
/* "release" it (see @FTC_Node_Release) */
/* If you lookup nodes, you have the ability to "acquire" them, i.e., */
/* to increment their reference count. This will prevent the node */
/* from being flushed out of the cache until you explicitly "release" */
/* it (see @FTC_Node_Release). */
/* */
/* see @FTC_BitsetCache_Lookup and @FTC_ImageCache_Lookup */
/* See also @FTC_BitsetCache_Lookup and @FTC_ImageCache_Lookup. */
/* */
typedef struct FTC_NodeRec_* FTC_Node;
typedef struct FTC_NodeRec_* FTC_Node;
/*************************************************************************/
@ -264,10 +266,10 @@ FT_BEGIN_HEADER
/* Use 0 for defaults. */
/* */
/* requester :: An application-provided callback used to translate */
/* face IDs into real FT_Face objects. */
/* face IDs into real @FT_Face objects. */
/* */
/* req_data :: A generic pointer that is passed to the requester */
/* each time it is called (see FTC_Face_Requester) */
/* each time it is called (see @FTC_Face_Requester). */
/* */
/* <Output> */
/* amanager :: A handle to a new manager object. 0 in case of */
@ -293,7 +295,7 @@ FT_BEGIN_HEADER
/* */
/* <Description> */
/* Empties a given cache manager. This simply gets rid of all the */
/* currently cached FT_Face & FT_Size objects within the manager. */
/* currently cached @FT_Face and @FT_Size objects within the manager. */
/* */
/* <InOut> */
/* manager :: A handle to the manager. */
@ -323,7 +325,7 @@ FT_BEGIN_HEADER
/* FTC_Manager_Lookup_Face */
/* */
/* <Description> */
/* Retrieves the FT_Face object that corresponds to a given face ID */
/* Retrieves the @FT_Face object that corresponds to a given face ID */
/* through a cache manager. */
/* */
/* <Input> */
@ -338,15 +340,15 @@ FT_BEGIN_HEADER
/* FreeType error code. 0 means success. */
/* */
/* <Note> */
/* The returned FT_Face object is always owned by the manager. You */
/* The returned @FT_Face object is always owned by the manager. You */
/* should never try to discard it yourself. */
/* */
/* The FT_Face object doesn't necessarily have a current size object */
/* The @FT_Face object doesn't necessarily have a current size object */
/* (i.e., face->size can be 0). If you need a specific `font size', */
/* use FTC_Manager_Lookup_Size() instead. */
/* use @FTC_Manager_Lookup_Size instead. */
/* */
/* Never change the face's transformation matrix (i.e., never call */
/* the FT_Set_Transform() function) on a returned face! If you need */
/* the @FT_Set_Transform function) on a returned face! If you need */
/* to transform glyphs, do it yourself after glyph loading. */
/* */
FT_EXPORT( FT_Error )
@ -361,8 +363,8 @@ FT_BEGIN_HEADER
/* FTC_Manager_Lookup_Size */
/* */
/* <Description> */
/* Retrieves the FT_Face & FT_Size objects that correspond to a given */
/* FTC_SizeID. */
/* Retrieves the @FT_Face and @FT_Size objects that correspond to a */
/* given @FTC_SizeID. */
/* */
/* <Input> */
/* manager :: A handle to the cache manager. */
@ -380,19 +382,19 @@ FT_BEGIN_HEADER
/* FreeType error code. 0 means success. */
/* */
/* <Note> */
/* The returned FT_Face object is always owned by the manager. You */
/* The returned @FT_Face object is always owned by the manager. You */
/* should never try to discard it yourself. */
/* */
/* Never change the face's transformation matrix (i.e., never call */
/* the FT_Set_Transform() function) on a returned face! If you need */
/* the @FT_Set_Transform function) on a returned face! If you need */
/* to transform glyphs, do it yourself after glyph loading. */
/* */
/* Similarly, the returned FT_Size object is always owned by the */
/* Similarly, the returned @FT_Size object is always owned by the */
/* manager. You should never try to discard it, and never change its */
/* settings with FT_Set_Pixel_Sizes() or FT_Set_Char_Size()! */
/* settings with @FT_Set_Pixel_Sizes or @FT_Set_Char_Size! */
/* */
/* The returned size object is the face's current size, which means */
/* that you can call FT_Load_Glyph() with the face if you need to. */
/* that you can call @FT_Load_Glyph with the face if you need to. */
/* */
FT_EXPORT( FT_Error )
FTC_Manager_Lookup_Size( FTC_Manager manager,

93
src/cache/ftccache.c vendored
View File

@ -1,3 +1,21 @@
/***************************************************************************/
/* */
/* ftccache.c */
/* */
/* The FreeType internal cache interface (body). */
/* */
/* 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 <ft2build.h>
#include FT_CACHE_MANAGER_H
#include FT_INTERNAL_OBJECTS_H
@ -5,6 +23,7 @@
#include "ftcerror.h"
/*************************************************************************/
/*************************************************************************/
/***** *****/
@ -13,13 +32,14 @@
/*************************************************************************/
/*************************************************************************/
FT_EXPORT_DEF(void)
FT_EXPORT_DEF( void )
ftc_node_done( FTC_Node node,
FTC_Cache cache )
{
FTC_Family family;
FTC_FamilyEntry entry;
entry = cache->manager->families.entries + node->fam_index;
family = entry->family;
@ -29,9 +49,7 @@
}
/* add a new node to the head of the manager's circular MRU list */
/* add a new node to the head of the manager's circular MRU list */
static void
ftc_node_mru_link( FTC_Node node,
FTC_Manager manager )
@ -162,7 +180,7 @@
/* find node's cache */
if ( node->fam_index >= manager->families.count )
{
FT_ERROR(( "FreeType.cache.node_destroy: invalid node handle\n" ));
FT_ERROR(( "ftc_node_destroy: invalid node handle\n" ));
return;
}
#endif
@ -173,7 +191,7 @@
#ifdef FT_DEBUG_ERROR
if ( cache == NULL )
{
FT_ERROR(( "FreeType.cache.node_destroy: invalid node handle\n" ));
FT_ERROR(( "ftc_node_destroy: invalid node handle\n" ));
return;
}
#endif
@ -196,7 +214,7 @@
/* check, just in case of general corruption :-) */
if ( manager->num_nodes <= 0 )
FT_ERROR(( "FTC_Manager_Compress: Invalid cache node count! = %d\n",
FT_ERROR(( "ftc_node_destroy: invalid cache node count! = %d\n",
manager->num_nodes ));
}
@ -210,7 +228,7 @@
/*************************************************************************/
FT_EXPORT_DEF(FT_Error)
FT_EXPORT_DEF( FT_Error )
ftc_family_init( FTC_Family family,
FTC_Query query,
FTC_Cache cache )
@ -220,12 +238,13 @@
FT_Memory memory = manager->library->memory;
FTC_FamilyEntry entry;
family->cache = cache;
family->num_nodes = 0;
/* now add to manager's family table */
error = ftc_family_table_alloc( &manager->families, memory, &entry );
if (!error)
if ( !error )
{
entry->cache = cache;
entry->family = family;
@ -233,16 +252,17 @@
query->family = family; /* save family in query */
}
return error;
}
FT_EXPORT_DEF(void)
FT_EXPORT_DEF( void )
ftc_family_done( FTC_Family family )
{
FTC_Manager manager = family->cache->manager;
/* remove from manager's family table */
ftc_family_table_free( &manager->families, family->fam_index );
}
@ -318,7 +338,6 @@
(c)->size*3 < (c)->nodes )
static void
ftc_cache_resize( FTC_Cache cache )
{
@ -333,7 +352,8 @@
FTC_Node* new_buckets ;
FT_ULong i;
/* no need to report an error, we'll simply keep using the same */
/* no need to report an error; we'll simply keep using the same */
/* buckets number / size */
if ( ALLOC_ARRAY( new_buckets, new_size, FTC_Node ) )
return;
@ -386,22 +406,23 @@
{
FT_LruList_ClassRec* lru_class = &cache->family_class;
lru_class->list_size = sizeof( FT_LruListRec );
lru_class->list_init = NULL;
lru_class->list_done = NULL;
lru_class->node_size = clazz->family_size;
lru_class->node_init = (FT_LruNode_InitFunc) clazz->family_init;
lru_class->node_done = (FT_LruNode_DoneFunc) clazz->family_done;
lru_class->node_flush = (FT_LruNode_FlushFunc) NULL;
lru_class->node_compare = (FT_LruNode_CompareFunc) clazz->family_compare;
lru_class->node_init = (FT_LruNode_InitFunc) clazz->family_init;
lru_class->node_done = (FT_LruNode_DoneFunc) clazz->family_done;
lru_class->node_flush = (FT_LruNode_FlushFunc) NULL;
lru_class->node_compare = (FT_LruNode_CompareFunc)clazz->family_compare;
error = FT_LruList_New( (FT_LruList_Class) lru_class,
0, /* max items == 0 => unbounded list */
0, /* max items == 0 => unbounded list */
cache,
memory,
&cache->families );
if (error)
if ( error )
FREE( cache->buckets );
}
@ -410,7 +431,7 @@
}
FT_EXPORT_DEF(void)
FT_EXPORT_DEF( void )
ftc_cache_clear( FTC_Cache cache )
{
if ( cache )
@ -425,6 +446,7 @@
{
FTC_Node *pnode = cache->buckets + i, next, node = *pnode;
while ( node )
{
next = node->link;
@ -453,6 +475,7 @@
}
}
FT_EXPORT_DEF( void )
ftc_cache_done( FTC_Cache cache )
{
@ -460,6 +483,7 @@
{
FT_Memory memory = cache->memory;
ftc_cache_clear( cache );
FREE( cache->buckets );
@ -474,11 +498,10 @@
}
/* Look up a node in "top" of its cache's hash table. */
/* If not found, create a new node. */
/* */
FT_EXPORT_DEF(FT_Error)
FT_EXPORT_DEF( FT_Error )
ftc_cache_lookup( FTC_Cache cache,
FTC_Query query,
FTC_Node *anode )
@ -497,35 +520,38 @@
query->family = NULL;
error = FT_LruList_Lookup( cache->families, query, &lru );
if (!error)
if ( !error )
{
FTC_Family family = (FTC_Family) lru;
FT_UFast hash = query->hash;
FTC_Node* bucket = cache->buckets + (hash % cache->size);
if ( query->family != family ||
family->fam_index >= cache->manager->families.size )
{
FT_ERROR(( "%s: invalid query (bad 'family' field)\n",
"FreeType.cache.lookup" ));
return FT_Err_Invalid_Argument;
}
if ( query->family != family ||
family->fam_index >= cache->manager->families.size )
{
FT_ERROR((
"ftc_cache_lookup: invalid query (bad 'family' field)\n" ));
return FT_Err_Invalid_Argument;
}
if ( *bucket )
{
FTC_Node* pnode = bucket;
FTC_Node_CompareFunc compare = cache->clazz->node_compare;
for ( ;; )
{
FTC_Node node;
node = *pnode;
if ( node == NULL )
break;
if ( (FT_UInt)node->fam_index == family->fam_index &&
compare( node, query, cache ) )
compare( node, query, cache ) )
{
/* move to head of bucket list */
if ( pnode != bucket )
@ -582,8 +608,8 @@
node->ref_count--;
}
/* try to resize the hash table when appropriate */
if ( FTC_CACHE_RESIZE_TEST(cache) )
/* try to resize the hash table if appropriate */
if ( FTC_CACHE_RESIZE_TEST( cache ) )
ftc_cache_resize( cache );
*anode = node;
@ -595,3 +621,4 @@
}
/* END */

228
src/cache/ftccmap.c vendored
View File

@ -2,7 +2,7 @@
/* */
/* ftccmap.c */
/* */
/* FreeType CharMap cache */
/* FreeType CharMap cache (body) */
/* */
/* Copyright 2000-2001 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -26,46 +26,47 @@
#include "ftcerror.h"
/*************************************************************************/
/* */
/* Each FTC_CMapNode contains a simple array 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 is really very */
/* useful. */
/* */
/*************************************************************************/
/* 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
/* number of glyph indices / character code per node */
#define FTC_CMAP_INDICES_MAX 128
typedef struct FTC_CMapNodeRec_
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 */
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))
#define FTC_CMAP_NODE( x ) ( (FTC_CMapNode)( x ) )
/* 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)
/* 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 haven't been queried through FT_Get_Glyph_Index() yet */
#define FTC_CMAP_UNKNOWN ( (FT_UInt16)-1 )
/* the charmap query */
typedef struct FTC_CMapQueryRec_
typedef struct FTC_CMapQueryRec_
{
FTC_QueryRec query;
FTC_CMapDesc desc;
@ -73,7 +74,8 @@
} FTC_CMapQueryRec, *FTC_CMapQuery;
#define FTC_CMAP_QUERY( x ) ((FTC_CMapQuery)( x ))
#define FTC_CMAP_QUERY( x ) ( (FTC_CMapQuery)( x ) )
/* the charmap family */
@ -86,8 +88,9 @@
} FTC_CMapFamilyRec, *FTC_CMapFamily;
#define FTC_CMAP_FAMILY( x ) ((FTC_CMapFamily)( x ))
#define FTC_CMAP_FAMILY_MEMORY( x ) FTC_FAMILY(x)->memory
#define FTC_CMAP_FAMILY( x ) ( (FTC_CMapFamily)( x ) )
#define FTC_CMAP_FAMILY_MEMORY( x ) FTC_FAMILY( x )->memory
/*************************************************************************/
@ -99,7 +102,7 @@
/*************************************************************************/
/* no need for specific finalizer, we'll use "ftc_node_done" directly */
/* no need for specific finalizer; we use "ftc_node_done" directly */
/* initialize a new cmap node */
FT_CALLBACK_DEF( FT_Error )
@ -112,7 +115,8 @@
FT_UNUSED( cache );
first = (cquery->char_code / FTC_CMAP_INDICES_MAX) * FTC_CMAP_INDICES_MAX;
first = ( cquery->char_code / FTC_CMAP_INDICES_MAX ) *
FTC_CMAP_INDICES_MAX;
cnode->first = first;
for ( n = 0; n < FTC_CMAP_INDICES_MAX; n++ )
@ -122,15 +126,15 @@
}
/* compute the weight of a given cmap node */
/* compute the weight of a given cmap node */
FT_CALLBACK_DEF( FT_ULong )
ftc_cmap_node_weight( FTC_CMapNode cnode )
{
return sizeof(*cnode);
return sizeof ( *cnode );
}
/* compare a cmap node to a given query */
/* compare a cmap node to a given query */
FT_CALLBACK_DEF( FT_Bool )
ftc_cmap_node_compare( FTC_CMapNode cnode,
FTC_CMapQuery cquery )
@ -166,74 +170,66 @@
/* setup charmap descriptor */
cfam->desc = *desc;
/* let's see if the rest is correct too */
/* let's see whether 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:
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 )
{
index = desc->u.index;
hash = index*33;
hash = ( ( desc->u.id.platform << 8 ) | desc->u.id.encoding ) * 7;
break;
}
}
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:
;
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);
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 );
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" ));
FT_ERROR(( "ftp_cmap_family_init: invalid charmap descriptor\n" ));
return FT_Err_Invalid_Argument;
}
FT_CALLBACK_DEF( FT_Bool )
ftc_cmap_family_compare( FTC_CMapFamily cfam,
FTC_CMapQuery cquery )
@ -248,32 +244,32 @@
switch ( cfam->desc.type )
{
case FTC_CMAP_BY_INDEX:
result = ( cfam->desc.u.index == cquery->desc->u.index );
break;
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_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;
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:
;
default:
;
}
if (result)
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);
FTC_QUERY( cquery )->family = FTC_FAMILY( cfam );
FTC_QUERY( cquery )->hash = FTC_CMAP_HASH( cfam, cquery );
}
Exit:
return FT_BOOL(result);
return FT_BOOL( result );
}
@ -286,25 +282,24 @@
/*************************************************************************/
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_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_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
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
};
@ -333,42 +328,45 @@
FT_Error error;
FT_UInt gindex = 0;
if ( !cache || !desc )
{
FT_ERROR(( "FTC_CMapCache_Lookup: bad arguments, returning 0 !!\n" ));
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 );
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_Face face;
/* we need to use @FT_Get_Char_Index */
/* 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)
if ( !error )
{
FT_CharMap old, cmap = NULL;
FT_UInt cmap_index;
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_index = FTC_CMAP_FAMILY( FTC_QUERY( &cquery )->family )->index;
cmap = face->charmaps[cmap_index];
FT_Set_Charmap( face, cmap );

31
src/cache/ftcglyph.c vendored
View File

@ -27,25 +27,23 @@
#include "ftcerror.h"
/* create a new chunk node, setting its cache index and ref count */
FT_EXPORT_DEF( void )
ftc_glyph_node_init( FTC_GlyphNode gnode,
FT_UInt gindex,
FTC_GlyphFamily gfam )
{
FT_UInt len;
FT_UInt start = FTC_GLYPH_FAMILY_START(gfam,gindex);
FT_UInt len;
FT_UInt start = FTC_GLYPH_FAMILY_START( gfam, gindex );
gnode->item_start = (FT_UShort) start;
gnode->item_start = (FT_UShort)start;
len = gfam->item_total - start;
if ( len > gfam->item_count )
len = gfam->item_count;
gnode->item_count = (FT_UShort) len;
gnode->item_count = (FT_UShort)len;
gfam->family.num_nodes++;
}
@ -58,18 +56,18 @@
gnode->item_count = 0;
gnode->item_start = 0;
ftc_node_done( FTC_NODE(gnode), cache );
ftc_node_done( FTC_NODE( gnode ), cache );
}
FT_EXPORT_DEF( FT_Bool )
ftc_glyph_node_compare( FTC_GlyphNode gnode,
FTC_GlyphQuery gquery )
ftc_glyph_node_compare( FTC_GlyphNode gnode,
FTC_GlyphQuery gquery )
{
FT_UInt start = (FT_UInt) gnode->item_start;
FT_UInt count = (FT_UInt) gnode->item_count;
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 );
return FT_BOOL( (FT_UInt)( gquery->gindex - start ) < count );
}
@ -93,14 +91,14 @@
FT_Error error;
error = ftc_family_init( FTC_FAMILY(gfam), FTC_QUERY(gquery), cache );
if (!error)
error = ftc_family_init( FTC_FAMILY( gfam ), FTC_QUERY( gquery ), cache );
if ( !error )
{
gfam->hash = hash;
gfam->item_total = item_total;
gfam->item_count = item_count;
FTC_GLYPH_FAMILY_FOUND(gfam,gquery);
FTC_GLYPH_FAMILY_FOUND( gfam, gquery );
}
return error;
@ -110,9 +108,8 @@
FT_EXPORT_DEF( void )
ftc_glyph_family_done( FTC_GlyphFamily gfam )
{
ftc_family_done( FTC_FAMILY(gfam) );
ftc_family_done( FTC_FAMILY( gfam ) );
}
/* END */

80
src/cache/ftcimage.c vendored
View File

@ -37,7 +37,7 @@
} FTC_ImageNodeRec, *FTC_ImageNode;
#define FTC_IMAGE_NODE( x ) ((FTC_ImageNode)( x ))
#define FTC_IMAGE_NODE( x ) ( (FTC_ImageNode)( x ) )
#define FTC_IMAGE_NODE_GINDEX( x ) FTC_GLYPH_NODE_GINDEX( x )
@ -49,8 +49,8 @@
} FTC_ImageQueryRec, *FTC_ImageQuery;
#define FTC_IMAGE_QUERY(x) ((FTC_ImageQuery)(x))
#define FTC_IMAGE_QUERY( x ) ( (FTC_ImageQuery)( x ) )
/* the glyph image set type */
@ -62,8 +62,8 @@
} FTC_ImageFamilyRec, *FTC_ImageFamily;
#define FTC_IMAGE_FAMILY( x ) ((FTC_ImageFamily)( x ))
#define FTC_IMAGE_FAMILY_MEMORY( x ) FTC_GLYPH_FAMILY_MEMORY( &(x)->gfam )
#define FTC_IMAGE_FAMILY( x ) ( (FTC_ImageFamily)( x ) )
#define FTC_IMAGE_FAMILY_MEMORY( x ) FTC_GLYPH_FAMILY_MEMORY( &(x)->gfam )
/*************************************************************************/
@ -85,9 +85,9 @@
FT_Done_Glyph( inode->glyph );
inode->glyph = NULL;
}
ftc_glyph_node_done( FTC_GLYPH_NODE(inode), cache );
}
ftc_glyph_node_done( FTC_GLYPH_NODE( inode ), cache );
}
/* initialize a new glyph image node */
@ -96,26 +96,26 @@
FTC_GlyphQuery gquery,
FTC_Cache cache )
{
FTC_ImageFamily ifam = FTC_IMAGE_FAMILY( gquery->query.family );
FT_Error error;
FT_Face face;
FT_Size size;
FTC_ImageFamily ifam = FTC_IMAGE_FAMILY( gquery->query.family );
FT_Error error;
FT_Face face;
FT_Size size;
/* initialize its inner fields */
ftc_glyph_node_init( FTC_GLYPH_NODE(inode),
ftc_glyph_node_init( FTC_GLYPH_NODE( inode ),
gquery->gindex,
FTC_GLYPH_FAMILY(ifam) );
FTC_GLYPH_FAMILY( ifam ) );
/* we will now load the glyph image */
error = FTC_Manager_Lookup_Size( FTC_FAMILY(ifam)->cache->manager,
error = FTC_Manager_Lookup_Size( FTC_FAMILY( ifam )->cache->manager,
&ifam->desc.font,
&face, &size );
if ( !error )
{
FT_UInt gindex = FTC_GLYPH_NODE_GINDEX(inode);
FT_UInt load_flags = FT_LOAD_DEFAULT;
FT_UInt type = ifam->desc.type;
FT_UInt gindex = FTC_GLYPH_NODE_GINDEX( inode );
FT_UInt load_flags = FT_LOAD_DEFAULT;
FT_UInt type = ifam->desc.type;
if ( FTC_IMAGE_FORMAT( type ) == ftc_image_format_bitmap )
@ -242,11 +242,11 @@
&face );
if ( !error )
{
error = ftc_glyph_family_init( FTC_GLYPH_FAMILY(ifam),
error = ftc_glyph_family_init( FTC_GLYPH_FAMILY( ifam ),
FTC_IMAGE_DESC_HASH( &ifam->desc ),
1,
face->num_glyphs,
FTC_GLYPH_QUERY(iquery),
FTC_GLYPH_QUERY( iquery ),
cache );
}
@ -263,7 +263,7 @@
result = FT_BOOL( FTC_IMAGE_DESC_COMPARE( &ifam->desc, &iquery->desc ) );
if ( result )
FTC_GLYPH_FAMILY_FOUND(ifam,iquery);
FTC_GLYPH_FAMILY_FOUND( ifam, iquery );
return result;
}
@ -282,21 +282,21 @@
FT_CALLBACK_TABLE_DEF
const FTC_Cache_ClassRec ftc_image_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_CacheRec ),
(FTC_Cache_InitFunc) ftc_cache_init,
(FTC_Cache_ClearFunc)ftc_cache_clear,
(FTC_Cache_DoneFunc) ftc_cache_done,
sizeof( FTC_ImageFamilyRec ),
(FTC_Family_InitFunc) ftc_image_family_init,
(FTC_Family_CompareFunc) ftc_image_family_compare,
(FTC_Family_DoneFunc) ftc_glyph_family_done,
sizeof ( FTC_ImageFamilyRec ),
(FTC_Family_InitFunc) ftc_image_family_init,
(FTC_Family_CompareFunc)ftc_image_family_compare,
(FTC_Family_DoneFunc) ftc_glyph_family_done,
sizeof( FTC_ImageNodeRec ),
(FTC_Node_InitFunc) ftc_image_node_init,
(FTC_Node_WeightFunc) ftc_image_node_weight,
(FTC_Node_CompareFunc) ftc_glyph_node_compare,
(FTC_Node_DoneFunc) ftc_image_node_done
sizeof ( FTC_ImageNodeRec ),
(FTC_Node_InitFunc) ftc_image_node_init,
(FTC_Node_WeightFunc) ftc_image_node_weight,
(FTC_Node_CompareFunc)ftc_glyph_node_compare,
(FTC_Node_DoneFunc) ftc_image_node_done
};
@ -339,17 +339,17 @@
iquery.gquery.gindex = gindex;
iquery.desc = *desc;
error = ftc_cache_lookup( FTC_CACHE(cache),
FTC_QUERY(&iquery),
(FTC_Node*) &node );
error = ftc_cache_lookup( FTC_CACHE( cache ),
FTC_QUERY( &iquery ),
(FTC_Node*)&node );
if ( !error )
{
*aglyph = node->glyph;
if (anode)
if ( anode )
{
*anode = (FTC_Node)node;
FTC_NODE(node)->ref_count++;
FTC_NODE( node )->ref_count++;
}
}
@ -357,8 +357,7 @@
}
/* backwards-compatibility functions */
/* backwards-compatibility functions */
FT_EXPORT_DEF( FT_Error )
FTC_Image_Cache_New( FTC_Manager manager,
@ -376,11 +375,12 @@
{
FTC_ImageDesc desc0;
if ( !desc )
return FT_Err_Invalid_Argument;
desc0.font = desc->font;
desc0.type = (FT_UInt32) desc->image_type;
desc0.type = (FT_UInt32)desc->image_type;
return FTC_ImageCache_Lookup( (FTC_ImageCache)icache,
&desc0,

68
src/cache/ftcmanag.c vendored
View File

@ -62,9 +62,9 @@
FT_CALLBACK_DEF( FT_Error )
ftc_face_node_init( FTC_FaceNode node,
FTC_FaceID face_id,
FTC_Manager manager )
ftc_face_node_init( FTC_FaceNode node,
FTC_FaceID face_id,
FTC_Manager manager )
{
FT_Error error;
@ -84,7 +84,7 @@
}
/* helper function for ftc_manager_done_face() */
/* helper function for ftc_face_node_done() */
FT_CALLBACK_DEF( FT_Bool )
ftc_size_node_select( FTC_SizeNode node,
FT_Face face )
@ -116,8 +116,8 @@
const FT_LruList_ClassRec ftc_face_list_class =
{
sizeof ( FT_LruListRec ),
(FT_LruList_InitFunc) 0,
(FT_LruList_DoneFunc) 0,
(FT_LruList_InitFunc)0,
(FT_LruList_DoneFunc)0,
sizeof ( FTC_FaceNodeRec ),
(FT_LruNode_InitFunc) ftc_face_node_init,
@ -156,7 +156,6 @@
}
/*************************************************************************/
/*************************************************************************/
/***** *****/
@ -258,8 +257,8 @@
const FT_LruList_ClassRec ftc_size_list_class =
{
sizeof ( FT_LruListRec ),
(FT_LruList_InitFunc) 0,
(FT_LruList_DoneFunc) 0,
(FT_LruList_InitFunc)0,
(FT_LruList_DoneFunc)0,
sizeof ( FTC_SizeNodeRec ),
(FT_LruNode_InitFunc) ftc_size_node_init,
@ -269,7 +268,6 @@
};
/* documentation is in ftcache.h */
FT_EXPORT_DEF( FT_Error )
@ -353,24 +351,27 @@
FTC_FamilyEntry entry;
FT_Error error = 0;
/* re-allocate table size when needed */
/* re-allocate table size when needed */
if ( table->free == FTC_FAMILY_ENTRY_NONE && table->count >= table->size )
{
FT_UInt old_size = table->size;
FT_UInt new_size, index;
if ( old_size == 0 )
new_size = 8;
else
{
new_size = old_size*2;
new_size = old_size * 2;
/* check for (unlikely) overflow */
if ( new_size < old_size )
new_size = 65534;
}
if ( REALLOC_ARRAY( table->entries, old_size, new_size, FTC_FamilyEntryRec ) )
if ( REALLOC_ARRAY( table->entries, old_size, new_size,
FTC_FamilyEntryRec ) )
return error;
table->size = new_size;
@ -378,9 +379,9 @@
entry = table->entries + old_size;
table->free = old_size;
for ( index = old_size; index+1 < new_size; index++, entry++ )
for ( index = old_size; index + 1 < new_size; index++, entry++ )
{
entry->link = index+1;
entry->link = index + 1;
entry->index = index;
}
@ -399,7 +400,7 @@
}
else
{
FT_ERROR(( "FreeType.cache.alloc_set: internal bug !!" ));
FT_ERROR(( "ftc_family_table_alloc: internal bug!" ));
return FT_Err_Invalid_Argument;
}
@ -420,8 +421,9 @@
{
FTC_FamilyEntry entry = table->entries + index;
if ( entry->link != FTC_FAMILY_ENTRY_NONE )
FT_ERROR(( "FreeType.cache.set_free: internal bug !!\n" ));
FT_ERROR(( "ftc_family_table_free: internal bug!\n" ));
else
{
entry->link = table->free;
@ -569,10 +571,9 @@
}
#ifdef FT_DEBUG_ERROR
FT_EXPORT_DEF(void)
FT_EXPORT_DEF( void )
FTC_Manager_Check( FTC_Manager manager )
{
FTC_Node node, first;
@ -595,7 +596,7 @@
if ( (FT_UInt)node->fam_index >= manager->families.count ||
entry->link != FTC_FAMILY_ENTRY_NONE )
FT_ERROR(( "FTC_Manager_Compress: invalid node (family index = %ld\n",
FT_ERROR(( "FTC_Manager_Check: invalid node (family index = %ld\n",
node->fam_index ));
else
{
@ -604,13 +605,12 @@
}
node = node->mru_next;
}
while (node != first);
} while ( node != first );
if ( weight != manager->cur_weight )
FT_ERROR((
"FTC_Manager_Compress: invalid weight %ld instead of %ld\n",
manager->cur_weight, weight ));
FT_ERROR(( "FTC_Manager_Check: invalid weight %ld instead of %ld\n",
manager->cur_weight, weight ));
}
/* check circular list */
@ -624,15 +624,16 @@
{
count++;
node = node->mru_next;
}
while (node != first);
} while ( node != first );
if ( count != manager->num_nodes )
FT_ERROR((
"FTC_Manager_Compress: invalid cache node count %d instead of %d\n",
"FTC_Manager_Check: invalid cache node count %d instead of %d\n",
manager->num_nodes, count ));
}
}
#endif /* FT_DEBUG_ERROR */
@ -682,6 +683,8 @@
}
/* documentation is in ftcmanag.h */
FT_EXPORT_DEF( FT_Error )
FTC_Manager_Register_Cache( FTC_Manager manager,
FTC_Cache_Class clazz,
@ -746,12 +749,9 @@
}
/* documentation is in ftcmanag.h */
FT_EXPORT_DEF(void)
FT_EXPORT_DEF( void )
FTC_Node_Unref( FTC_Node node,
FTC_Manager manager )
{

175
src/cache/ftcsbits.c vendored
View File

@ -32,17 +32,17 @@
#define FTC_SBIT_ITEMS_PER_NODE 16
typedef struct FTC_SBitNodeRec_* FTC_SBitNode;
typedef struct FTC_SBitNodeRec_* FTC_SBitNode;
typedef struct FTC_SBitNodeRec_
typedef struct FTC_SBitNodeRec_
{
FTC_GlyphNodeRec gnode;
FTC_SBitRec sbits[ FTC_SBIT_ITEMS_PER_NODE ];
FTC_GlyphNodeRec gnode;
FTC_SBitRec sbits[FTC_SBIT_ITEMS_PER_NODE];
} FTC_SBitNodeRec;
#define FTC_SBIT_NODE(x) ((FTC_SBitNode)(x))
#define FTC_SBIT_NODE( x ) ( (FTC_SBitNode)( x ) )
typedef struct FTC_SBitQueryRec_
@ -52,23 +52,23 @@
} FTC_SBitQueryRec, *FTC_SBitQuery;
#define FTC_SBIT_QUERY(x) ((FTC_SBitQuery)(x))
#define FTC_SBIT_QUERY( x ) ( (FTC_SBitQuery)( x ) )
typedef struct FTC_SBitFamilyRec_* FTC_SBitFamily;
/* sbit family structure */
/* sbit family structure */
typedef struct FTC_SBitFamilyRec_
{
FTC_GlyphFamilyRec gfam;
FTC_ImageDesc desc;
} FTC_SBitFamilyRec;
#define FTC_SBIT_FAMILY( x ) ( (FTC_SBitFamily)(x) )
#define FTC_SBIT_FAMILY_MEMORY( x ) FTC_GLYPH_FAMILY_MEMORY( &(x)->cset )
#define FTC_SBIT_FAMILY( x ) ( (FTC_SBitFamily)( x ) )
#define FTC_SBIT_FAMILY_MEMORY( x ) FTC_GLYPH_FAMILY_MEMORY( &( x )->cset )
/*************************************************************************/
@ -102,54 +102,54 @@
}
FT_CALLBACK_DEF( void )
ftc_sbit_node_done( FTC_SBitNode snode,
FTC_Cache cache )
{
FTC_SBit sbit = snode->sbits;
FT_UInt count = FTC_GLYPH_NODE(snode)->item_count;
FT_UInt count = FTC_GLYPH_NODE( snode )->item_count;
FT_Memory memory = cache->memory;
for ( ; count > 0; sbit++, count-- )
FREE( sbit->buffer );
ftc_glyph_node_done( FTC_GLYPH_NODE(snode), cache );
ftc_glyph_node_done( FTC_GLYPH_NODE( snode ), cache );
}
static FT_Error
ftc_sbit_node_load( FTC_SBitNode snode,
FTC_Manager manager,
FTC_SBitFamily sfam,
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);
FT_Memory memory;
FT_Face face;
FT_Size size;
FTC_SBit sbit;
FT_Error error;
FTC_GlyphNode gnode = FTC_GLYPH_NODE( snode );
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 )
{
FT_ERROR(( "FreeType.cache.sbit_load: invalid glyph index" ));
FT_ERROR(( "ftc_sbit_node_load: invalid glyph index" ));
return FTC_Err_Invalid_Argument;
}
memory = manager->library->memory;
sbit = snode->sbits + (gindex - gnode->item_start);
sbit = snode->sbits + ( gindex - gnode->item_start );
error = FTC_Manager_Lookup_Size( manager, &sfam->desc.font,
&face, &size );
if ( !error )
{
FT_UInt load_flags = FT_LOAD_DEFAULT;
FT_UInt type = sfam->desc.type;
FT_UInt load_flags = FT_LOAD_DEFAULT;
FT_UInt type = sfam->desc.type;
/* determine load flags, depending on the font description's */
@ -167,7 +167,7 @@
else
{
FT_ERROR((
"FreeType.cache.sbit_load: cannot load scalable glyphs in an"
"ftc_sbit_node_load: cannot load scalable glyphs in an"
" sbit cache, please check your arguments!\n" ));
error = FTC_Err_Invalid_Argument;
goto Exit;
@ -215,14 +215,14 @@
CHECK_CHAR( xadvance ) &&
CHECK_CHAR( yadvance ) )
{
sbit->width = (FT_Byte) bitmap->width;
sbit->height = (FT_Byte) bitmap->rows;
sbit->pitch = (FT_Char) bitmap->pitch;
sbit->left = (FT_Char) slot->bitmap_left;
sbit->top = (FT_Char) slot->bitmap_top;
sbit->xadvance = (FT_Char) xadvance;
sbit->yadvance = (FT_Char) yadvance;
sbit->format = (FT_Byte) bitmap->pixel_mode;
sbit->width = (FT_Byte)bitmap->width;
sbit->height = (FT_Byte)bitmap->rows;
sbit->pitch = (FT_Char)bitmap->pitch;
sbit->left = (FT_Char)slot->bitmap_left;
sbit->top = (FT_Char)slot->bitmap_top;
sbit->xadvance = (FT_Char)xadvance;
sbit->yadvance = (FT_Char)yadvance;
sbit->format = (FT_Byte)bitmap->pixel_mode;
/* grab the bitmap when possible - this is a hack !! */
if ( slot->flags & ft_glyph_own_bitmap )
@ -238,16 +238,16 @@
/* now, compute size */
if ( asize )
*asize = ABS(sbit->pitch) * sbit->height;
*asize = ABS( sbit->pitch ) * sbit->height;
} /* glyph dimensions ok */
} /* glyph loading successful */
/* ignore the errors that might have occurred -- */
/* we recognize unloaded glyphs with `sbit.buffer == 0' */
/* and 'width == 255', 'height == 0' */
/* */
/* ignore the errors that might have occurred -- */
/* we mark unloaded glyphs with `sbit.buffer == 0' */
/* and 'width == 255', 'height == 0' */
/* */
if ( error )
{
sbit->width = 255;
@ -268,17 +268,18 @@
{
FT_Error error;
ftc_glyph_node_init( FTC_GLYPH_NODE(snode),
ftc_glyph_node_init( FTC_GLYPH_NODE( snode ),
gquery->gindex,
FTC_GLYPH_FAMILY(gquery->query.family) );
FTC_GLYPH_FAMILY( gquery->query.family ) );
error = ftc_sbit_node_load( snode,
cache->manager,
FTC_SBIT_FAMILY( FTC_QUERY(gquery)->family ),
FTC_SBIT_FAMILY( FTC_QUERY( gquery )->family ),
gquery->gindex,
NULL );
if ( error )
ftc_glyph_node_done( FTC_GLYPH_NODE(snode), cache );
ftc_glyph_node_done( FTC_GLYPH_NODE( snode ), cache );
return error;
}
@ -287,7 +288,7 @@
FT_CALLBACK_DEF( FT_ULong )
ftc_sbit_node_weight( FTC_SBitNode snode )
{
FTC_GlyphNode gnode = FTC_GLYPH_NODE(snode);
FTC_GlyphNode gnode = FTC_GLYPH_NODE( snode );
FT_UInt count = gnode->item_count;
FTC_SBit sbit = snode->sbits;
FT_Int pitch;
@ -295,10 +296,10 @@
/* the node itself */
size = sizeof ( *snode );
size = sizeof ( *snode );
/* the sbit records */
size += FTC_GLYPH_NODE(snode)->item_count * sizeof ( FTC_SBitRec );
size += FTC_GLYPH_NODE( snode )->item_count * sizeof ( FTC_SBitRec );
for ( ; count > 0; count--, sbit++ )
{
@ -322,25 +323,28 @@
FTC_SBitQuery squery,
FTC_Cache cache )
{
FTC_GlyphQuery gquery = FTC_GLYPH_QUERY(squery);
FTC_GlyphNode gnode = FTC_GLYPH_NODE(snode);
FTC_GlyphQuery gquery = FTC_GLYPH_QUERY( squery );
FTC_GlyphNode gnode = FTC_GLYPH_NODE( snode );
FT_Bool result;
result = ftc_glyph_node_compare( gnode, gquery );
if ( result )
{
/* check if we need to load the glyph bitmap now */
FT_UInt gindex = gquery->gindex;
FTC_SBit sbit = snode->sbits + (gindex - gnode->item_start);
FTC_SBit sbit = snode->sbits + ( gindex - gnode->item_start );
if ( sbit->buffer == NULL && sbit->width != 255 )
{
FT_ULong size;
/* yes, it's safe to ignore errors here */
ftc_sbit_node_load( snode,
cache->manager,
FTC_SBIT_FAMILY( FTC_QUERY(squery)->family ),
FTC_SBIT_FAMILY( FTC_QUERY( squery )->family ),
gindex,
&size );
@ -370,6 +374,7 @@
FT_Error error;
FT_Face face;
sfam->desc = squery->desc;
/* we need to compute "cquery.item_total" now */
@ -378,11 +383,11 @@
&face );
if ( !error )
{
error = ftc_glyph_family_init( FTC_GLYPH_FAMILY(sfam),
error = ftc_glyph_family_init( FTC_GLYPH_FAMILY( sfam ),
FTC_IMAGE_DESC_HASH( &sfam->desc ),
FTC_SBIT_ITEMS_PER_NODE,
face->num_glyphs,
FTC_GLYPH_QUERY(squery),
FTC_GLYPH_QUERY( squery ),
cache );
}
@ -391,24 +396,23 @@
FT_CALLBACK_DEF( FT_Bool )
ftc_sbit_family_compare( FTC_SBitFamily sfam,
FTC_SBitQuery squery )
ftc_sbit_family_compare( FTC_SBitFamily sfam,
FTC_SBitQuery squery )
{
FT_Bool result;
/* we need to set the "cquery.cset" field or our query for */
/* faster glyph comparisons in ftc_sbit_node_compare.. */
/* */
/* faster glyph comparisons in ftc_sbit_node_compare */
/* */
result = FT_BOOL( FTC_IMAGE_DESC_COMPARE( &sfam->desc, &squery->desc ) );
if ( result )
FTC_GLYPH_FAMILY_FOUND(sfam,squery);
FTC_GLYPH_FAMILY_FOUND( sfam, squery );
return result;
}
/*************************************************************************/
/*************************************************************************/
/***** *****/
@ -418,25 +422,24 @@
/*************************************************************************/
FT_CALLBACK_TABLE_DEF
const FTC_Cache_ClassRec ftc_sbit_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_CacheRec ),
(FTC_Cache_InitFunc) ftc_cache_init,
(FTC_Cache_ClearFunc)ftc_cache_clear,
(FTC_Cache_DoneFunc) ftc_cache_done,
sizeof( FTC_SBitFamilyRec ),
(FTC_Family_InitFunc) ftc_sbit_family_init,
(FTC_Family_CompareFunc) ftc_sbit_family_compare,
(FTC_Family_DoneFunc) ftc_glyph_family_done,
sizeof ( FTC_SBitFamilyRec ),
(FTC_Family_InitFunc) ftc_sbit_family_init,
(FTC_Family_CompareFunc)ftc_sbit_family_compare,
(FTC_Family_DoneFunc) ftc_glyph_family_done,
sizeof( FTC_SBitNodeRec ),
(FTC_Node_InitFunc) ftc_sbit_node_init,
(FTC_Node_WeightFunc) ftc_sbit_node_weight,
(FTC_Node_CompareFunc) ftc_sbit_node_compare,
(FTC_Node_DoneFunc) ftc_sbit_node_done
sizeof ( FTC_SBitNodeRec ),
(FTC_Node_InitFunc) ftc_sbit_node_init,
(FTC_Node_WeightFunc) ftc_sbit_node_weight,
(FTC_Node_CompareFunc)ftc_sbit_node_compare,
(FTC_Node_DoneFunc) ftc_sbit_node_done
};
@ -465,7 +468,8 @@
FTC_SBitQueryRec squery;
FTC_SBitNode node;
/* argument checks delayed to ftc_cache_lookup */
/* other argument checks delayed to ftc_cache_lookup */
if ( !ansbit )
return FTC_Err_Invalid_Argument;
@ -477,25 +481,24 @@
squery.gquery.gindex = gindex;
squery.desc = *desc;
error = ftc_cache_lookup( FTC_CACHE(cache),
FTC_QUERY(&squery),
(FTC_Node*) &node );
error = ftc_cache_lookup( FTC_CACHE( cache ),
FTC_QUERY( &squery ),
(FTC_Node*)&node );
if ( !error )
{
*ansbit = node->sbits + (gindex - FTC_GLYPH_NODE(node)->item_start);
*ansbit = node->sbits + ( gindex - FTC_GLYPH_NODE( node )->item_start );
if ( anode )
{
*anode = FTC_NODE(node);
FTC_NODE(node)->ref_count ++;
*anode = FTC_NODE( node );
FTC_NODE( node )->ref_count++;
}
}
return error;
}
/* backwards-compatibility functions */
/* backwards-compatibility functions */
FT_EXPORT_DEF( FT_Error )
FTC_SBit_Cache_New( FTC_Manager manager,
@ -513,11 +516,12 @@
{
FTC_ImageDesc desc0;
if ( !desc )
return FT_Err_Invalid_Argument;
desc0.font = desc->font;
desc0.type = (FT_UInt32) desc->image_type;
desc0.type = (FT_UInt32)desc->image_type;
return FTC_SBitCache_Lookup( (FTC_SBitCache)cache,
&desc0,
@ -527,5 +531,4 @@
}
/* END */

2
src/cache/ftlru.c vendored
View File

@ -46,7 +46,7 @@
list->clazz = clazz;
list->memory = memory;
list->max_nodes = max_nodes;
list->data = user_data;
list->data = user_data;
if ( clazz->list_init )
{