Skip to content
GitLab
Commit 2905ff93 authored by David Turner's avatar David Turner
Browse files

removed obsolete file (ftcimage.h) 

updated header files
parent ac1c157d
Hide whitespace changes
Inline Side-by-side
include/freetype/cache/ftcimage.h deleted 100644 → 0
View file @ ac1c157d
/***************************************************************************/
/* */
/* 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 */
include/freetype/cache/ftcmanag.h
View file @ 2905ff93
......@@ -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,89 +68,132 @@
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;
/* maximum number of caches registered in a single manager */
#define FTC_MAX_CACHES 16
/* a ftc node is used to
typedef FT_ListNode FTC_Node;
typedef struct FTC_ManagerRec_
{
FT_Library library;
FT_Lru faces_lru;
FT_Lru sizes_lru;
/* 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 )
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;
} 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;
/* a function used to initialize a cache */
typedef FT_Error (FTC_Cache_Init_Func) ( FTC_Cache cache );
/* the fields "cachenode.data" is typecasted to this type */
typedef struct FTC_CacheNode_Data_
{
FT_UShort cache_index;
FT_Short ref_count;
/* a function used to finalize a cache */
typedef void (FTC_Cache_Done_Func) ( FTC_Cache cache );
} FTC_CacheNode_Data;
/* 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_
/* 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_
{
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_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 );
} FTC_Cache_Class;
typedef struct FTC_CacheRec_
struct FTC_Cache_Class_
{
FTC_Manager manager; /* cache manager.. */
FTC_Cache_Class* clazz; /* cache clazz */
FT_Memory memory; /* memory allocator */
FT_UInt cache_id;
} FTC_CacheRec;
FT_UInt cache_byte_size;
FTC_Cache_InitFunc init_cache;
FTC_Cache_DoneFunc done_cache;
};
typedef struct FTC_ManagerRec_
typedef struct FTC_CacheRec_
{
FT_Library library;
FT_Lru faces_lru;
FT_Lru sizes_lru;
FT_Pointer request_data;
FTC_Face_Requester request_face;
FTC_Manager manager;
FT_Memory memory;
FTC_Cache_Class* clazz;
FTC_CacheNode_Class* node_clazz;
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 cache_index; /* in manager's table */
FT_Pointer cache_user; /* passed to cache node methods*/
FT_UInt num_caches;
FT_UInt last_id;
FTC_Cache caches[ FTC_MAX_CACHES ];
} FTC_ManagerRec;
} 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
......
include/freetype/cache/ftlru.h
View file @ 2905ff93
......@@ -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
......
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment