forked from minhngoc25a/freetype2
David Turner
parent
ac1c157d2c
commit
2905ff93b1
|
|
@ -1,133 +0,0 @@
|
|||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftcimage.h */
|
||||
/* */
|
||||
/* FreeType Image Cache (specification). */
|
||||
/* */
|
||||
/* Copyright 2000 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 FTCIMAGE_H
|
||||
#define FTCIMAGE_H
|
||||
|
||||
#include <freetype/cache/ftcmanag.h>
|
||||
#include <freetype/ftglyph.h>
|
||||
#include <stddef.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define FTC_MAX_IMAGE_QUEUES 16
|
||||
|
||||
typedef struct FTC_Image_QueueRec_* FTC_Image_Queue;
|
||||
typedef struct FTC_ImageNodeRec_* FTC_ImageNode;
|
||||
|
||||
|
||||
/* macros used to pack a glyph index and a queue index in a single ptr */
|
||||
#define FTC_PTR_TO_GINDEX( p ) ( (FT_UInt)( (FT_ULong)(p) >> 16 ) )
|
||||
#define FTC_PTR_TO_QINDEX( p ) ( (FT_UInt)( (FT_ULong)(p) & 0xFFFF ) )
|
||||
#define FTC_INDICES_TO_PTR( g, q ) \
|
||||
( (FT_Pointer)( ( (FT_ULong)(g) << 16 ) | \
|
||||
( (FT_ULong)(q) & 0xFFFF) ) )
|
||||
|
||||
typedef struct FTC_ImageNodeRec_
|
||||
{
|
||||
/* root1.data contains an FT_Glyph handle */
|
||||
FT_ListNodeRec root1;
|
||||
|
||||
/* root2.data contains a glyph index + queue index */
|
||||
FT_ListNodeRec root2;
|
||||
|
||||
} FTC_ImageNodeRec;
|
||||
|
||||
|
||||
/* macros to read/set the glyph & queue index in a FTC_ImageNode */
|
||||
#define FTC_IMAGENODE_GET_GINDEX( n ) FTC_PTR_TO_GINDEX( (n)->root2.data )
|
||||
#define FTC_IMAGENODE_GET_QINDEX( n ) FTC_PTR_TO_QINDEX( (n)->root2.data )
|
||||
#define FTC_IMAGENODE_GET_GLYPH( n ) ( (FT_Glyph)(n)->root1.data )
|
||||
#define FTC_IMAGENODE_SET_GLYPH( n, g ) \
|
||||
do \
|
||||
{ \
|
||||
(n)->root1.data = g; \
|
||||
} while ( 0 )
|
||||
|
||||
#define FTC_IMAGENODE_SET_INDICES( n, g, q ) \
|
||||
do \
|
||||
{ \
|
||||
(n)->root2.data = FTC_INDICES_TO_PTR( g, q ); \
|
||||
} while ( 0 )
|
||||
|
||||
|
||||
/* this macro is used to extract a handle to the global LRU list node */
|
||||
/* corresponding to a given image node */
|
||||
#define FTC_IMAGENODE_TO_LISTNODE( n ) \
|
||||
( (FT_ListNode)&(n)->root2 )
|
||||
|
||||
/* this macro is used to extract a handle to a given image node from */
|
||||
/* the corresponding LRU glyph list node. That's a bit hackish.. */
|
||||
#define FTC_LISTNODE_TO_IMAGENODE( p ) \
|
||||
( (FTC_ImageNode)( (char*)(p) - \
|
||||
offsetof( FTC_ImageNodeRec,root2 ) ) )
|
||||
|
||||
|
||||
typedef struct FTC_Image_CacheRec_
|
||||
{
|
||||
FTC_CacheRec root;
|
||||
|
||||
FT_Lru queues_lru; /* static queues lru list */
|
||||
FT_ListRec glyphs_lru; /* global lru list of glyph images */
|
||||
|
||||
FTC_Image_Queue last_queue; /* small cache */
|
||||
|
||||
} FTC_Image_CacheRec;
|
||||
|
||||
|
||||
/* a table of functions used to generate/manager glyph images */
|
||||
typedef struct FTC_Image_Class_
|
||||
{
|
||||
FT_Error (*init_image)( FTC_Image_Queue queue,
|
||||
FTC_ImageNode node );
|
||||
|
||||
void (*done_image)( FTC_Image_Queue queue,
|
||||
FTC_ImageNode node );
|
||||
|
||||
FT_ULong (*size_image)( FTC_Image_Queue queue,
|
||||
FTC_ImageNode node );
|
||||
|
||||
} FTC_Image_Class;
|
||||
|
||||
|
||||
typedef struct FTC_Image_QueueRec_
|
||||
{
|
||||
FTC_Image_Cache cache;
|
||||
FTC_Manager manager;
|
||||
FT_Memory memory;
|
||||
FTC_Image_Class* clazz;
|
||||
FTC_Image_Desc descriptor;
|
||||
FT_UInt hash_size;
|
||||
FT_List buckets;
|
||||
FT_UInt index; /* index in parent cache */
|
||||
|
||||
} FTC_Image_QueueRec;
|
||||
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#endif /* FTCIMAGE_H */
|
||||
|
||||
|
||||
/* END */
|
||||
|
|
@ -13,8 +13,49 @@
|
|||
/* this file you indicate that you have read the license and */
|
||||
/* understand and accept it fully. */
|
||||
/* */
|
||||
/* */
|
||||
/* A cache manager is in charge of the following: */
|
||||
/* */
|
||||
/* - 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 things */
|
||||
/* considerably.. */
|
||||
/* */
|
||||
/* - manage one or more cache object. Each cache is in charge of */
|
||||
/* holding a varying number of "cache nodes". Each cache node */
|
||||
/* represents a minimal amount of individually-accessible cached */
|
||||
/* data. For example, a cache node can be a FT_Glyph image containing */
|
||||
/* a vector outline, or some glyph metrics, or anything else.. */
|
||||
/* */
|
||||
/* each cache node has a certain size in bytes that is added to the */
|
||||
/* total amount of "cache memory" within the manager. */
|
||||
/* */
|
||||
/* all cache nodes are located in a global LRU list, where the */
|
||||
/* oldest node is at the tail of the list */
|
||||
/* */
|
||||
/* each node belongs to a single cache, and includes a reference */
|
||||
/* count to avoid destroying it (due to caching) */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
/**************************************************************************/
|
||||
/**************************************************************************/
|
||||
/**************************************************************************/
|
||||
/**************************************************************************/
|
||||
/**************************************************************************/
|
||||
/********* **********/
|
||||
/********* **********/
|
||||
/********* WARNING, THIS IS ALPHA CODE, THIS API **********/
|
||||
/********* IS DUE TO CHANGE UNTIL STRICTLY NOTIFIED BY THE **********/
|
||||
/********* FREETYPE DEVELOPMENT TEAM **********/
|
||||
/********* **********/
|
||||
/**************************************************************************/
|
||||
/**************************************************************************/
|
||||
/**************************************************************************/
|
||||
/**************************************************************************/
|
||||
/**************************************************************************/
|
||||
|
||||
|
||||
#ifndef FTCMANAG_H
|
||||
#define FTCMANAG_H
|
||||
|
|
@ -27,68 +68,13 @@
|
|||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* default values */
|
||||
#define FTC_MAX_FACES_DEFAULT 4
|
||||
#define FTC_MAX_SIZES_DEFAULT 8
|
||||
#define FTC_MAX_BYTES_DEFAULT 65536 /* 64 Kb by default */
|
||||
|
||||
#define FTC_MAX_FACES_DEFAULT 4
|
||||
#define FTC_MAX_SIZES_DEFAULT 8
|
||||
#define FTC_MAX_BYTES_DEFAULT 65536
|
||||
|
||||
#define FTC_MAX_CACHES 8
|
||||
|
||||
/* opaque pointer to a cache object */
|
||||
typedef struct FTC_CacheRec_* FTC_Cache;
|
||||
|
||||
|
||||
|
||||
/* a ftc node is used to
|
||||
typedef FT_ListNode FTC_Node;
|
||||
|
||||
/* macros to read/set the glyph & queue index in a FTC_Node */
|
||||
#define FTC_IMAGENODE_GET_GINDEX( n ) FTC_PTR_TO_GINDEX( (n)->data )
|
||||
#define FTC_IMAGENODE_GET_QINDEX( n ) FTC_PTR_TO_QINDEX( (n)->data )
|
||||
|
||||
#define FTC_IMAGENODE_SET_INDICES( n, g, q ) \
|
||||
do { \
|
||||
(n)->data = FTC_INDICES_TO_PTR( g, q ); \
|
||||
} while ( 0 )
|
||||
|
||||
|
||||
|
||||
|
||||
/* a function used to initialize a cache */
|
||||
typedef FT_Error (FTC_Cache_Init_Func) ( FTC_Cache cache );
|
||||
|
||||
/* a function used to finalize a cache */
|
||||
typedef void (FTC_Cache_Done_Func) ( FTC_Cache cache );
|
||||
|
||||
/* a function used to return the size in bytes of a given cache node */
|
||||
typedef FT_ULong (FTC_Cache_Size_Func) ( FTC_Cache cache,
|
||||
FT_Pointer object );
|
||||
|
||||
/* a function used to purge a given cache node */
|
||||
typedef void (FTC_Cache_Purge_Func)( FTC_Cache cache,
|
||||
FT_Pointer object );
|
||||
|
||||
|
||||
/* cache class */
|
||||
typedef struct FTC_Cache_Class_
|
||||
{
|
||||
FT_UInt cache_size; /* size of cache object in bytes */
|
||||
FTC_Cache_Init_Func init;
|
||||
FTC_Cache_Done_Func done;
|
||||
FTC_Cache_Size_Func size;
|
||||
FTC_Cache_Purge_Func purge;
|
||||
|
||||
} FTC_Cache_Class;
|
||||
|
||||
|
||||
typedef struct FTC_CacheRec_
|
||||
{
|
||||
FTC_Manager manager; /* cache manager.. */
|
||||
FTC_Cache_Class* clazz; /* cache clazz */
|
||||
FT_Memory memory; /* memory allocator */
|
||||
FT_UInt cache_id;
|
||||
|
||||
} FTC_CacheRec;
|
||||
/* maximum number of caches registered in a single manager */
|
||||
#define FTC_MAX_CACHES 16
|
||||
|
||||
|
||||
typedef struct FTC_ManagerRec_
|
||||
|
|
@ -96,21 +82,119 @@
|
|||
FT_Library library;
|
||||
FT_Lru faces_lru;
|
||||
FT_Lru sizes_lru;
|
||||
|
||||
FT_ULong max_bytes;
|
||||
FT_ULong num_bytes;
|
||||
FT_ListRec global_lru;
|
||||
FTC_Cache caches[ FTC_MAX_CACHES ];
|
||||
|
||||
FT_Pointer request_data;
|
||||
FTC_Face_Requester request_face;
|
||||
|
||||
FT_ULong num_bytes; /* current number of bytes in the caches */
|
||||
FT_ULong max_bytes; /* maximum number of bytes in the caches */
|
||||
FT_ListRec global_lru; /* the global LRU list of nodes */
|
||||
|
||||
FT_UInt num_caches;
|
||||
FT_UInt last_id;
|
||||
FTC_Cache caches[ FTC_MAX_CACHES ];
|
||||
|
||||
} FTC_ManagerRec;
|
||||
|
||||
|
||||
/*********************************************************************/
|
||||
/*********************************************************************/
|
||||
/***** *****/
|
||||
/***** CACHE NODE DEFINITIONS *****/
|
||||
/***** *****/
|
||||
/*********************************************************************/
|
||||
/*********************************************************************/
|
||||
|
||||
|
||||
|
||||
/* each cache controls one or more cache nodes. Each node */
|
||||
/* is part of the global_lru list of the manager. Its "data" */
|
||||
/* field however is used as a reference count for now.. */
|
||||
/* */
|
||||
/* a node can anything, depending on the type of information */
|
||||
/* held by the cache. It can be an individual glyph image, */
|
||||
/* a set of bitmaps glyphs for a given size, some metrics, */
|
||||
/* etc.. */
|
||||
/* */
|
||||
|
||||
typedef FT_ListNodeRec FTC_CacheNodeRec;
|
||||
typedef FTC_CacheNodeRec* FTC_CacheNode;
|
||||
|
||||
|
||||
/* the fields "cachenode.data" is typecasted to this type */
|
||||
typedef struct FTC_CacheNode_Data_
|
||||
{
|
||||
FT_UShort cache_index;
|
||||
FT_Short ref_count;
|
||||
|
||||
} FTC_CacheNode_Data;
|
||||
|
||||
/* returns a pointer to the FTC_CacheNode_Data contained in a */
|
||||
/* CacheNode's "data" field.. */
|
||||
#define FTC_CACHENODE_TO_DATA_P(n) \
|
||||
((FTC_CacheNode_Data*)&(n)->data)
|
||||
|
||||
#define FTC_LIST_TO_CACHENODE(n) ((FTC_CacheNode)(n))
|
||||
|
||||
/* returns the size in bytes of a given cache node */
|
||||
typedef FT_ULong (*FTC_CacheNode_SizeFunc)( FTC_CacheNode node,
|
||||
FT_Pointer user );
|
||||
|
||||
/* finalise a given cache node */
|
||||
typedef void (*FTC_CacheNode_DestroyFunc)( FTC_CacheNode node,
|
||||
FT_Pointer user );
|
||||
|
||||
/* this structure is used to provide functions to the cache manager */
|
||||
/* It will use them to size and destroy cache nodes.. Note that there */
|
||||
/* is no "init_node" there because cache objects are entirely */
|
||||
/* responsible for the creation of new cache nodes */
|
||||
/* */
|
||||
typedef struct FTC_CacheNode_Class_
|
||||
{
|
||||
FTC_CacheNode_SizeFunc size_node;
|
||||
FTC_CacheNode_DestroyFunc destroy_node;
|
||||
|
||||
} FTC_CacheNode_Class;
|
||||
|
||||
|
||||
/*********************************************************************/
|
||||
/*********************************************************************/
|
||||
/***** *****/
|
||||
/***** CACHE DEFINITIONS *****/
|
||||
/***** *****/
|
||||
/*********************************************************************/
|
||||
/*********************************************************************/
|
||||
|
||||
|
||||
typedef FT_Error (*FTC_Cache_InitFunc)( FTC_Cache cache );
|
||||
|
||||
typedef void (*FTC_Cache_DoneFunc)( FTC_Cache cache );
|
||||
|
||||
|
||||
struct FTC_Cache_Class_
|
||||
{
|
||||
FT_UInt cache_byte_size;
|
||||
FTC_Cache_InitFunc init_cache;
|
||||
FTC_Cache_DoneFunc done_cache;
|
||||
};
|
||||
|
||||
|
||||
|
||||
typedef struct FTC_CacheRec_
|
||||
{
|
||||
FTC_Manager manager;
|
||||
FT_Memory memory;
|
||||
FTC_Cache_Class* clazz;
|
||||
FTC_CacheNode_Class* node_clazz;
|
||||
|
||||
FT_UInt cache_index; /* in manager's table */
|
||||
FT_Pointer cache_user; /* passed to cache node methods*/
|
||||
|
||||
} FTC_CacheRec;
|
||||
|
||||
|
||||
/* "compress" the manager's data, i.e. get rids of old cache nodes */
|
||||
/* that are not referenced anymore in order to limit the total */
|
||||
/* memory used by the cache.. */
|
||||
FT_EXPORT_DEF(void) FTC_Manager_Compress( FTC_Manager manager );
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,8 +13,46 @@
|
|||
/* this file you indicate that you have read the license and */
|
||||
/* understand and accept it fully. */
|
||||
/* */
|
||||
/* */
|
||||
/* A LRU is a list that cannot hold more than a certain number of */
|
||||
/* elements ("max_elements"). All elements on the list are sorted */
|
||||
/* in lest-recently-used order, i.e. the "oldest" element is at */
|
||||
/* the tail of the list */
|
||||
/* */
|
||||
/* When doing a lookup (either through "Lookup" or "Lookup_Node"), */
|
||||
/* the list is searched for an element with the corresponding key */
|
||||
/* if it is found, the element is moved to the head of the list */
|
||||
/* and is returned.. */
|
||||
/* */
|
||||
/* If no corresponding element is found, the lookup routine will */
|
||||
/* try to obtain a new element with the relevant key. If the list */
|
||||
/* is already full, the oldest element from the list is discarded */
|
||||
/* and replaced by a new one; a new element is added to the list */
|
||||
/* otherwise.. */
|
||||
/* */
|
||||
/* Note that it is possible to pre-allocate the element list nodes. */
|
||||
/* That's handy when "max_elements" is sufficiently small, as it */
|
||||
/* saves allocations/releases during the lookup process */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
/**************************************************************************/
|
||||
/**************************************************************************/
|
||||
/**************************************************************************/
|
||||
/**************************************************************************/
|
||||
/**************************************************************************/
|
||||
/********* **********/
|
||||
/********* **********/
|
||||
/********* WARNING, THIS IS ALPHA CODE, THIS API **********/
|
||||
/********* IS DUE TO CHANGE UNTIL STRICTLY NOTIFIED BY THE **********/
|
||||
/********* FREETYPE DEVELOPMENT TEAM **********/
|
||||
/********* **********/
|
||||
/**************************************************************************/
|
||||
/**************************************************************************/
|
||||
/**************************************************************************/
|
||||
/**************************************************************************/
|
||||
/**************************************************************************/
|
||||
|
||||
|
||||
#ifndef FTLRU_H
|
||||
#define FTLRU_H
|
||||
|
|
@ -26,10 +64,11 @@
|
|||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
/* generic key type */
|
||||
typedef FT_Pointer FT_LruKey;
|
||||
|
||||
|
||||
/* a lru node - node.root.data points to the element */
|
||||
typedef struct FT_LruNodeRec_
|
||||
{
|
||||
FT_ListNodeRec root;
|
||||
|
|
@ -37,30 +76,43 @@
|
|||
|
||||
} FT_LruNodeRec, *FT_LruNode;
|
||||
|
||||
|
||||
/* forward declaration */
|
||||
typedef struct FT_LruRec_* FT_Lru;
|
||||
|
||||
|
||||
/* LRU clazz */
|
||||
typedef struct FT_Lru_Class_
|
||||
{
|
||||
FT_UInt lru_size; /* object size in bytes */
|
||||
|
||||
/* this method is used to initialise a new list element node */
|
||||
FT_Error (*init_element)( FT_Lru lru,
|
||||
FT_LruNode node );
|
||||
|
||||
|
||||
/* this method is used to finalise a given list element node */
|
||||
void (*done_element)( FT_Lru lru,
|
||||
FT_LruNode node );
|
||||
|
||||
/* when defined, this method is called when the list if full */
|
||||
/* during the lookup process.. it is used to change the content */
|
||||
/* of a list element node, instead of calling "done_element" */
|
||||
/* then "init_element". Put it to 0 for default behaviour */
|
||||
FT_Error (*flush_element)( FT_Lru lru,
|
||||
FT_LruNode node,
|
||||
FT_LruKey new_key );
|
||||
|
||||
|
||||
/* when defined, this method is used to compare a list element node */
|
||||
/* with a given key during a lookup. When set to 0, the "key" */
|
||||
/* fields will be directly compared instead.. */
|
||||
FT_Bool (*compare_element)( FT_LruNode node,
|
||||
FT_LruKey key );
|
||||
|
||||
} FT_Lru_Class;
|
||||
|
||||
|
||||
/* a selector is used to indicate wether a given list element node */
|
||||
/* is part of a selection for FT_Lru_Remove_Selection. The function */
|
||||
/* must returns true (i.e. non 0) to indicate that the node is part */
|
||||
/* of it.. */
|
||||
typedef FT_Bool (*FT_Lru_Selector)( FT_Lru lru,
|
||||
FT_LruNode node,
|
||||
FT_Pointer data );
|
||||
|
|
@ -89,9 +141,9 @@
|
|||
FT_Bool pre_alloc,
|
||||
FT_Lru* alru );
|
||||
|
||||
FT_EXPORT_DEF( void ) FT_Lru_Reset( FT_Lru lru );
|
||||
FT_EXPORT_DEF( void ) FT_Lru_Reset( FT_Lru lru );
|
||||
|
||||
FT_EXPORT_DEF( void ) FT_Lru_Done( FT_Lru lru );
|
||||
FT_EXPORT_DEF( void ) FT_Lru_Done( FT_Lru lru );
|
||||
|
||||
FT_EXPORT_DEF( FT_Error ) FT_Lru_Lookup_Node( FT_Lru lru,
|
||||
FT_LruKey key,
|
||||
|
|
@ -101,12 +153,12 @@
|
|||
FT_LruKey key,
|
||||
FT_Pointer* aobject );
|
||||
|
||||
FT_EXPORT_DEF( void ) FT_Lru_Remove_Node( FT_Lru lru,
|
||||
FT_LruNode node );
|
||||
FT_EXPORT_DEF( void ) FT_Lru_Remove_Node( FT_Lru lru,
|
||||
FT_LruNode node );
|
||||
|
||||
FT_EXPORT_DEF( void ) FT_Lru_Remove_Selection( FT_Lru lru,
|
||||
FT_Lru_Selector selector,
|
||||
FT_Pointer data );
|
||||
FT_EXPORT_DEF( void ) FT_Lru_Remove_Selection( FT_Lru lru,
|
||||
FT_Lru_Selector selector,
|
||||
FT_Pointer data );
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
|
|
|||
Loading…
Reference in New Issue