ftccback.h File Reference

#include <freetype/ftcache.h>
#include "ftcmru.h"
#include "ftcimage.h"
#include "ftcmanag.h"
#include "ftcglyph.h"
#include "ftcsbits.h"

Include dependency graph for ftccback.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
FT_BEGIN_HEADER	ftc_inode_free (FTC_Node inode, FTC_Cache cache)
	ftc_inode_new (FTC_Node *pinode, FT_Pointer gquery, FTC_Cache cache)
	ftc_inode_weight (FTC_Node inode, FTC_Cache cache)
	ftc_snode_free (FTC_Node snode, FTC_Cache cache)
	ftc_snode_new (FTC_Node *psnode, FT_Pointer gquery, FTC_Cache cache)
	ftc_snode_weight (FTC_Node snode, FTC_Cache cache)
	ftc_snode_compare (FTC_Node snode, FT_Pointer gquery, FTC_Cache cache, FT_Bool *list_changed)
	ftc_gnode_compare (FTC_Node gnode, FT_Pointer gquery, FTC_Cache cache, FT_Bool *list_changed)
	ftc_gcache_init (FTC_Cache cache)
	ftc_gcache_done (FTC_Cache cache)
	ftc_cache_init (FTC_Cache cache)
	ftc_cache_done (FTC_Cache cache)
	ftc_node_destroy (FTC_Node node, FTC_Manager manager)

Function Documentation

ftc_cache_done()

ftc_cache_done

(

FTC_Cache

cache

)

Definition at line 388 of file ftccache.c.

  {
    if ( cache->memory )
    {
      FT_Memory  memory = cache->memory;
 
 
      FTC_Cache_Clear( cache );
 
      FT_FREE( cache->buckets );
      cache->mask  = 0;
      cache->p     = 0;
      cache->slack = 0;
 
      cache->memory = NULL;
    }
  }

Referenced by FTC_Cache_Done().

ftc_cache_init()

ftc_cache_init

(

FTC_Cache

cache

)

Definition at line 334 of file ftccache.c.

  {
    FT_Memory  memory = cache->memory;
    FT_Error   error;
 
 
    cache->p     = 0;
    cache->mask  = FTC_HASH_INITIAL_SIZE - 1;
    cache->slack = FTC_HASH_INITIAL_SIZE * FTC_HASH_MAX_LOAD;
 
    (void)FT_NEW_ARRAY( cache->buckets, FTC_HASH_INITIAL_SIZE * 2 );
    return error;
  }

Referenced by FTC_Cache_Init().

ftc_gcache_done()

ftc_gcache_done

(

FTC_Cache

cache

)

Definition at line 152 of file ftcglyph.c.

  {
    FTC_GCache  cache = (FTC_GCache)ftccache;
 
 
    FTC_Cache_Done( (FTC_Cache)cache );
    FTC_MruList_Done( &cache->families );
  }

ftc_gcache_init()

ftc_gcache_init

(

FTC_Cache

cache

)

Definition at line 118 of file ftcglyph.c.

  {
    FTC_GCache  cache = (FTC_GCache)ftccache;
    FT_Error    error;
 
 
    error = FTC_Cache_Init( FTC_CACHE( cache ) );
    if ( !error )
    {
      FTC_GCacheClass   clazz = (FTC_GCacheClass)FTC_CACHE( cache )->org_class;
 
      FTC_MruList_Init( &cache->families,
                        clazz->family_class,
                        0,  /* no maximum here! */
                        cache,
                        FTC_CACHE( cache )->memory );
    }
 
    return error;
  }

ftc_gnode_compare()

ftc_gnode_compare	(	FTC_Node	gnode,
		FT_Pointer	gquery,
		FTC_Cache	cache,
		FT_Bool *	list_changed
	)

Definition at line 65 of file ftcglyph.c.

  {
    FTC_GNode   gnode  = (FTC_GNode)ftcgnode;
    FTC_GQuery  gquery = (FTC_GQuery)ftcgquery;
    FT_UNUSED( cache );
 
 
    if ( list_changed )
      *list_changed = FALSE;
    return FT_BOOL( gnode->family == gquery->family &&
                    gnode->gindex == gquery->gindex );
  }

Referenced by FTC_GNode_Compare().

ftc_inode_free()

FT_BEGIN_HEADER ftc_inode_free	(	FTC_Node	inode,
		FTC_Cache	cache
	)

Definition at line 30 of file ftcimage.c.

  {
    FTC_INode  inode = (FTC_INode)ftcinode;
    FT_Memory  memory = cache->memory;
 
 
    if ( inode->glyph )
    {
      FT_Done_Glyph( inode->glyph );
      inode->glyph = NULL;
    }
 
    FTC_GNode_Done( FTC_GNODE( inode ), cache );
    FT_FREE( inode );
  }

Referenced by FTC_INode_Free().

ftc_inode_new()

ftc_inode_new	(	FTC_Node *	pinode,
		FT_Pointer	gquery,
		FTC_Cache	cache
	)

Definition at line 94 of file ftcimage.c.

  {
    FTC_INode  *pinode = (FTC_INode*)ftcpinode;
    FTC_GQuery  gquery = (FTC_GQuery)ftcgquery;
 
 
    return FTC_INode_New( pinode, gquery, cache );
  }

ftc_inode_weight()

ftc_inode_weight	(	FTC_Node	inode,
		FTC_Cache	cache
	)

Definition at line 107 of file ftcimage.c.

  {
    FTC_INode  inode = (FTC_INode)ftcinode;
    FT_Offset  size  = 0;
    FT_Glyph   glyph = inode->glyph;
 
    FT_UNUSED( ftccache );
 
 
    switch ( glyph->format )
    {
    case FT_GLYPH_FORMAT_BITMAP:
      {
        FT_BitmapGlyph  bitg;
 
 
        bitg = (FT_BitmapGlyph)glyph;
        size = bitg->bitmap.rows * (FT_Offset)FT_ABS( bitg->bitmap.pitch ) +
               sizeof ( *bitg );
      }
      break;
 
    case FT_GLYPH_FORMAT_OUTLINE:
      {
        FT_OutlineGlyph  outg;
 
 
        outg = (FT_OutlineGlyph)glyph;
        size = (FT_Offset)outg->outline.n_points *
                 ( sizeof ( FT_Vector ) + sizeof ( FT_Byte ) ) +
               (FT_Offset)outg->outline.n_contours * sizeof ( FT_Short ) +
               sizeof ( *outg );
      }
      break;
 
    default:
      ;
    }
 
    size += sizeof ( *inode );
    return size;
  }

ftc_node_destroy()

ftc_node_destroy	(	FTC_Node	node,
		FTC_Manager	manager
	)

Definition at line 272 of file ftccache.c.

  {
    FTC_Cache  cache;
 
 
#ifdef FT_DEBUG_ERROR
    /* find node's cache */
    if ( node->cache_index >= manager->num_caches )
    {
      FT_TRACE0(( "ftc_node_destroy: invalid node handle\n" ));
      return;
    }
#endif
 
    cache = manager->caches[node->cache_index];
 
#ifdef FT_DEBUG_ERROR
    if ( !cache )
    {
      FT_TRACE0(( "ftc_node_destroy: invalid node handle\n" ));
      return;
    }
#endif
 
    manager->cur_weight -= cache->clazz.node_weight( node, cache );
 
    /* remove node from mru list */
    ftc_node_mru_unlink( node, manager );
 
    /* remove node from cache's hash table */
    ftc_node_hash_unlink( node, cache );
 
    /* now finalize it */
    cache->clazz.node_free( node, cache );
 
#if 0
    /* check, just in case of general corruption :-) */
    if ( manager->num_nodes == 0 )
      FT_TRACE0(( "ftc_node_destroy: invalid cache node count (%d)\n",
                  manager->num_nodes ));
#endif
  }

Referenced by FTC_Manager_Compress(), and FTC_Manager_FlushN().

ftc_snode_compare()

ftc_snode_compare	(	FTC_Node	snode,
		FT_Pointer	gquery,
		FTC_Cache	cache,
		FT_Bool *	list_changed
	)

Definition at line 326 of file ftcsbits.c.

  {
    FTC_SNode   snode  = (FTC_SNode)ftcsnode;
    FTC_GQuery  gquery = (FTC_GQuery)ftcgquery;
    FTC_GNode   gnode  = FTC_GNODE( snode );
    FT_UInt     gindex = gquery->gindex;
    FT_Bool     result;
 
 
    if (list_changed)
      *list_changed = FALSE;
    result = FT_BOOL( gnode->family == gquery->family                    &&
                      (FT_UInt)( gindex - gnode->gindex ) < snode->count );
    if ( result )
    {
      /* check if we need to load the glyph bitmap now */
      FTC_SBit  sbit = snode->sbits + ( gindex - gnode->gindex );
 
 
      /*
       * The following code illustrates what to do when you want to
       * perform operations that may fail within a lookup function.
       *
       * Here, we want to load a small bitmap on-demand; we thus
       * need to call the `ftc_snode_load' function which may return
       * a non-zero error code only when we are out of memory (OOM).
       *
       * The correct thing to do is to use @FTC_CACHE_TRYLOOP and
       * @FTC_CACHE_TRYLOOP_END in order to implement a retry loop
       * that is capable of flushing the cache incrementally when
       * an OOM errors occur.
       *
       * However, we need to `lock' the node before this operation to
       * prevent it from being flushed within the loop.
       *
       * When we exit the loop, we unlock the node, then check the `error'
       * variable.  If it is non-zero, this means that the cache was
       * completely flushed and that no usable memory was found to load
       * the bitmap.
       *
       * We then prefer to return a value of 0 (i.e., NO MATCH).  This
       * ensures that the caller will try to allocate a new node.
       * This operation consequently _fail_ and the lookup function
       * returns the appropriate OOM error code.
       *
       * Note that `buffer == NULL && width == 255' is a hack used to
       * tag `unavailable' bitmaps in the array.  We should never try
       * to load these.
       *
       */
 
      if ( !sbit->buffer && sbit->width == 255 )
      {
        FT_ULong  size;
        FT_Error  error;
 
 
        ftcsnode->ref_count++;  /* lock node to prevent flushing */
                                /* in retry loop                 */
 
        FTC_CACHE_TRYLOOP( cache )
        {
          error = ftc_snode_load( snode, cache->manager, gindex, &size );
        }
        FTC_CACHE_TRYLOOP_END( list_changed );
 
        ftcsnode->ref_count--;  /* unlock the node */
 
        if ( error )
          result = 0;
        else
          cache->manager->cur_weight += size;
      }
    }
 
    return result;
  }

Referenced by FTC_SNode_Compare().

ftc_snode_free()

ftc_snode_free	(	FTC_Node	snode,
		FTC_Cache	cache
	)

Definition at line 66 of file ftcsbits.c.

  {
    FTC_SNode  snode  = (FTC_SNode)ftcsnode;
    FTC_SBit   sbit   = snode->sbits;
    FT_UInt    count  = snode->count;
    FT_Memory  memory = cache->memory;
 
 
    for ( ; count > 0; sbit++, count-- )
      FT_FREE( sbit->buffer );
 
    FTC_GNode_Done( FTC_GNODE( snode ), cache );
 
    FT_FREE( snode );
  }

Referenced by FTC_SNode_Free().

ftc_snode_new()

ftc_snode_new	(	FTC_Node *	psnode,
		FT_Pointer	gquery,
		FTC_Cache	cache
	)

Definition at line 267 of file ftcsbits.c.

  {
    FTC_SNode  *psnode = (FTC_SNode*)ftcpsnode;
    FTC_GQuery  gquery = (FTC_GQuery)ftcgquery;
 
 
    return FTC_SNode_New( psnode, gquery, cache );
  }

ftc_snode_weight()

ftc_snode_weight	(	FTC_Node	snode,
		FTC_Cache	cache
	)

Definition at line 280 of file ftcsbits.c.

  {
    FTC_SNode  snode = (FTC_SNode)ftcsnode;
    FT_UInt    count = snode->count;
    FTC_SBit   sbit  = snode->sbits;
    FT_Int     pitch;
    FT_Offset  size;
 
    FT_UNUSED( cache );
 
 
    FT_ASSERT( snode->count <= FTC_SBIT_ITEMS_PER_NODE );
 
    /* the node itself */
    size = sizeof ( *snode );
 
    for ( ; count > 0; count--, sbit++ )
    {
      if ( sbit->buffer )
      {
        pitch = sbit->pitch;
        if ( pitch < 0 )
          pitch = -pitch;
 
        /* add the size of a given glyph image */
        size += (FT_Offset)pitch * sbit->height;
      }
    }
 
    return size;
  }