kc3-lang/freetype/src/cache/ftcglyph.c

• Show log

  Commit

• Hash : 1f7f0e87
  Author :
  Date : 2001-06-06T17:30:41
  

  Complete redesign of error codes. Please check ftmoderr.h for more details. * include/freetype/internal/cfferrs.h, include/freetype/internal/tterrors.h, include/freetype/internal/t1errors.h: Removed. Replaced with files local to the module. All extra error codes have been moved to `fterrors.h'. * src/sfnt/ttpost.h: Move error codes to `fterrors.h'. * src/autohint/aherrors.h, src/cache/ftcerror.h, src/cff/cfferrs.h, src/cid/ciderrs.h, src/pcf/pcferror.h, src/psaux/psauxerr.h, src/psnames/psnamerr.h, src/raster/rasterrs.h, src/sfnt/sferrors.h, src/smooth/ftsmerrs.h, src/truetype/tterrors.h, src/type1/t1errors.h, src/winfonts/fnterrs.h: New files defining the error names for the module it belongs to. * include/freetype/ftmoderr.h: New file, defining the module error offsets. Its structure is similar to `fterrors.h'. * include/freetype/fterrors.h (FT_NOERRORDEF): New macro. (FT_ERRORDEF): Redefined to use module error offsets. All internal error codes are now public; unused error codes have been removed, some are new. * include/freetype/config/ftheader.h (FT_MODULE_ERRORS_H): New macro. * include/freetype/config/ftoption.h (FT_CONFIG_OPTION_USE_MODULE_ERRORS): New macro. All other source files have been updated to use the new error codes; some already existing (internal) error codes local to a module have been renamed to give them the same name as in the base module. All make files have been updated to include the local error files. * src/cid/cidtokens.h: Replaced with... * src/cid/cidtoken.h: This file for 8+3 consistency. * src/raster/ftraster.c: Use macros for header file names.

Download

• src/cache/ftcglyph.c

• /***************************************************************************/
  /*                                                                         */
  /*  ftcglyph.c                                                             */
  /*                                                                         */
  /*    FreeType Glyph Image (FT_Glyph) cache (body).                        */
  /*                                                                         */
  /*  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.                                        */
  /*                                                                         */
  /***************************************************************************/
  
  
  #include <ft2build.h>
  #include FT_CACHE_H
  #include FT_CACHE_INTERNAL_GLYPH_H
  #include FT_ERRORS_H
  #include FT_LIST_H
  #include FT_INTERNAL_OBJECTS_H
  #include FT_INTERNAL_DEBUG_H
  
  #include "ftcerror.h"
  
  
    /*************************************************************************/
    /*************************************************************************/
    /*****                                                               *****/
    /*****                      GLYPH NODES                              *****/
    /*****                                                               *****/
    /*************************************************************************/
    /*************************************************************************/
  
  
    /* create a new glyph node, setting its cache index and ref count */
    FT_EXPORT_DEF( void )  FTC_GlyphNode_Init( FTC_GlyphNode  node,
                                               FTC_GlyphSet   gset,
                                               FT_UInt        gindex )
    {
      FTC_Glyph_Cache      cache = gset->cache;
      FTC_CacheNode_Data*  data  = FTC_CACHENODE_TO_DATA_P( &node->root );
  
  
      data->cache_index = (FT_UShort)cache->root.cache_index;
      data->ref_count   = (FT_Short) 0;
      node->gset_index  = (FT_UShort)gset->gset_index;
      node->glyph_index = (FT_UShort)gindex;
    }
  
  
    /* Important: This function is called from the cache manager to */
    /* destroy a given cache node during `cache compression'.  The  */
    /* second argument is always `cache.cache_data'.  Thus be       */
    /* certain that the function FTC_Glyph_Cache_New() does indeed  */
    /* set its `cache_data' field correctly, otherwise bad things   */
    /* will happen!                                                 */
  
    FT_EXPORT_DEF( void )  FTC_GlyphNode_Destroy( FTC_GlyphNode    node,
                                                  FTC_Glyph_Cache  cache )
    {
      FT_LruNode    gset_lru = cache->gsets_lru->nodes + node->gset_index;
      FTC_GlyphSet  gset     = (FTC_GlyphSet)gset_lru->root.data;
      FT_UInt       hash     = node->glyph_index % gset->hash_size;
  
  
      /* remove the node from its gset's bucket list */
      {
        FTC_GlyphNode*  pnode = gset->buckets + hash;
        FTC_GlyphNode   cur;
  
  
        for (;;)
        {
          cur = *pnode;
          if ( !cur )
          {
            /* this should never happen */
            FT_ERROR(( "FTC_GlyphNode_Destroy:"
                       " trying to delete an unlisted node!" ));
            return;
          }
  
          if ( cur == node )
          {
            *pnode = cur->gset_next;
            break;
          }
          pnode = &cur->gset_next;
        }
      }
  
      /* destroy the node */
      gset->clazz->destroy_node( node, gset );
    }
  
  
    /* Important: This function is called from the cache manager to */
    /* size a given cache node during `cache compression'.  The     */
    /* second argument is always `cache.user_data'.  Thus be        */
    /* certain that the function FTC_Glyph_Cache_New() does indeed  */
    /* set its `user_data' field correctly, otherwise bad things    */
    /* will happen!                                                 */
  
    FT_EXPORT_DEF( FT_ULong )  FTC_GlyphNode_Size( FTC_GlyphNode    node,
                                                   FTC_Glyph_Cache  cache )
    {
      FT_LruNode    gset_lru = cache->gsets_lru->nodes + node->gset_index;
      FTC_GlyphSet  gset     = (FTC_GlyphSet)gset_lru->root.data;
  
  
      return gset->clazz->size_node( node, gset );
    }
  
  
    FT_CALLBACK_TABLE_DEF
    const FTC_CacheNode_Class  ftc_glyph_cache_node_class =
    {
      (FTC_CacheNode_SizeFunc)   FTC_GlyphNode_Size,
      (FTC_CacheNode_DestroyFunc)FTC_GlyphNode_Destroy
    };
  
  
    /*************************************************************************/
    /*************************************************************************/
    /*****                                                               *****/
    /*****                      GLYPH SETS                               *****/
    /*****                                                               *****/
    /*************************************************************************/
    /*************************************************************************/
  
  
    FT_EXPORT_DEF( FT_Error )  FTC_GlyphSet_New( FTC_Glyph_Cache  cache,
                                                 FT_Pointer       type,
                                                 FTC_GlyphSet    *aset )
    {
      FT_Error                error;
      FT_Memory               memory  = cache->root.memory;
      FTC_Manager             manager = cache->root.manager;
      FTC_GlyphSet            gset    = 0;
  
      FTC_Glyph_Cache_Class*  gcache_class;
      FTC_GlyphSet_Class*     clazz;
  
  
      gcache_class = (FTC_Glyph_Cache_Class*)cache->root.clazz;
      clazz        = gcache_class->gset_class;
  
      *aset = 0;
  
      if ( ALLOC( gset, clazz->gset_byte_size ) )
        goto Exit;
  
      gset->cache     = cache;
      gset->manager   = manager;
      gset->memory    = memory;
      gset->hash_size = FTC_GSET_HASH_SIZE_DEFAULT;
      gset->clazz     = clazz;
  
      /* allocate buckets table */
      if ( ALLOC_ARRAY( gset->buckets, gset->hash_size, FTC_GlyphNode ) )
        goto Exit;
  
      /* initialize gset by type if needed */
      if ( clazz->init )
      {
        error = clazz->init( gset, type );
        if ( error )
          goto Exit;
      }
  
      *aset = gset;
  
    Exit:
      if ( error && gset )
      {
        FREE( gset->buckets );
        FREE( gset );
      }
  
      return error;
    }
  
  
    FT_EXPORT_DEF( void )  FTC_GlyphSet_Destroy( FTC_GlyphSet  gset )
    {
      FTC_Glyph_Cache      cache        = gset->cache;
      FTC_Manager          manager      = cache->root.manager;
      FT_List              glyphs_lru   = &manager->global_lru;
      FTC_GlyphNode*       bucket       = gset->buckets;
      FTC_GlyphNode*       bucket_limit = bucket + gset->hash_size;
      FT_Memory            memory       = cache->root.memory;
  
      FTC_GlyphSet_Class*  clazz        = gset->clazz;
  
  
      /* for each bucket, free the list of glyph nodes */
      for ( ; bucket < bucket_limit; bucket++ )
      {
        FTC_GlyphNode   node = bucket[0];
        FTC_GlyphNode   next = 0;
        FT_ListNode     lrunode;
  
  
        for ( ; node; node = next )
        {
          next    = node->gset_next;
          lrunode = FTC_GLYPHNODE_TO_LRUNODE( node );
  
          manager->num_bytes -= clazz->size_node( node, gset );
          manager->num_nodes--;
  
          FT_List_Remove( glyphs_lru, lrunode );
  
          clazz->destroy_node( node, gset );
        }
  
        bucket[0] = 0;
      }
  
      if ( clazz->done )
        clazz->done( gset );
  
      FREE( gset->buckets );
      FREE( gset );
    }
  
  
    FT_EXPORT_DEF( FT_Error )  FTC_GlyphSet_Lookup_Node(
                                 FTC_GlyphSet    gset,
                                 FT_UInt         glyph_index,
                                 FTC_GlyphNode  *anode )
    {
      FTC_Glyph_Cache      cache      = gset->cache;
      FTC_Manager          manager    = cache->root.manager;
      FT_UInt              hash_index = glyph_index % gset->hash_size;
      FTC_GlyphNode*       bucket     = gset->buckets + hash_index;
      FTC_GlyphNode*       pnode      = bucket;
      FTC_GlyphNode        node;
      FT_Error             error;
  
      FTC_GlyphSet_Class*  clazz      = gset->clazz;
  
  
      *anode = 0;
  
      for ( ;; )
      {
        node = *pnode;
        if ( !node )
          break;
  
        if ( (FT_UInt)node->glyph_index == glyph_index )
        {
          /* we found it! -- move glyph to start of the lists */
          *pnode          = node->gset_next;
          node->gset_next = bucket[0];
          bucket[0]       = node;
  
          FT_List_Up( &manager->global_lru, FTC_GLYPHNODE_TO_LRUNODE( node ) );
          *anode = node;
          return 0;
        }
        /* go to next node in bucket */
        pnode = &node->gset_next;
      }
  
      /* we didn't found the glyph image, we will now create a new one */
      error = clazz->new_node( gset, glyph_index, &node );
      if ( error )
        goto Exit;
  
      /* insert the node at the start of our bucket list */
      node->gset_next = bucket[0];
      bucket[0]       = node;
  
      /* insert the node at the start the global LRU glyph list */
      FT_List_Insert( &manager->global_lru, FTC_GLYPHNODE_TO_LRUNODE( node ) );
  
      manager->num_bytes += clazz->size_node( node, gset );
      manager->num_nodes++;
  
      if ( manager->num_bytes > manager->max_bytes )
      {
        FTC_GlyphNode_Ref   ( node );
        FTC_Manager_Compress( manager );
        FTC_GlyphNode_Unref ( node );
      }
  
      *anode = node;
  
    Exit:
      return error;
    }
  
  
    /*************************************************************************/
    /*************************************************************************/
    /*****                                                               *****/
    /*****                   GLYPH SETS LRU CALLBACKS                    *****/
    /*****                                                               *****/
    /*************************************************************************/
    /*************************************************************************/
  
  
  #define FTC_GSET_LRU_GET_CACHE( lru )   \
            ( (FTC_Glyph_Cache)(lru)->user_data )
  
  #define FTC_GSET_LRU_GET_MANAGER( lru ) \
            FTC_GSET_LRU_GET_CACHE( lru )->manager
  
  #define FTC_LRUNODE_GSET( node )        \
            ( (FTC_GlyphSet)(node)->root.data )
  
  
    FT_CALLBACK_DEF
    FT_Error  ftc_glyph_set_lru_init( FT_Lru      lru,
                                      FT_LruNode  node )
    {
      FTC_Glyph_Cache  cache = FTC_GSET_LRU_GET_CACHE( lru );
      FT_Error         error;
      FTC_GlyphSet     gset;
  
  
      error = FTC_GlyphSet_New( cache, (FT_Pointer)node->key, &gset );
      if ( !error )
      {
        /* good, now set the gset index within the gset object */
        gset->gset_index = (FT_UInt)( node - lru->nodes );
        node->root.data  = gset;
      }
  
      return error;
    }
  
  
    FT_CALLBACK_DEF
    void  ftc_glyph_set_lru_done( FT_Lru      lru,
                                  FT_LruNode  node )
    {
      FTC_GlyphSet  gset = FTC_LRUNODE_GSET( node );
  
      FT_UNUSED( lru );
  
  
      FTC_GlyphSet_Destroy( gset );
    }
  
  
    FT_CALLBACK_DEF
    FT_Bool  ftc_glyph_set_lru_compare( FT_LruNode  node,
                                        FT_LruKey   key )
    {
      FTC_GlyphSet  gset = FTC_LRUNODE_GSET( node );
  
  
      return gset->clazz->compare( gset, (FT_Pointer)key );
    }
  
  
    FT_CALLBACK_TABLE_DEF
    const FT_Lru_Class  ftc_glyph_set_lru_class =
    {
      sizeof( FT_LruRec ),
      ftc_glyph_set_lru_init,
      ftc_glyph_set_lru_done,
      0,  /* no flush */
      ftc_glyph_set_lru_compare
    };
  
  
    /*************************************************************************/
    /*************************************************************************/
    /*****                                                               *****/
    /*****                      GLYPH CACHE OBJECTS                      *****/
    /*****                                                               *****/
    /*************************************************************************/
    /*************************************************************************/
  
  
    FT_EXPORT_DEF( FT_Error )  FTC_Glyph_Cache_Init( FTC_Glyph_Cache  cache )
    {
      FT_Memory  memory = cache->root.memory;
      FT_Error   error;
  
      FTC_Glyph_Cache_Class*  gcache_clazz;
  
  
      /* set up root node_class to be used by manager */
      cache->root.node_clazz =
        (FTC_CacheNode_Class*)&ftc_glyph_cache_node_class;
  
      /* setup the `compare' shortcut */
      gcache_clazz   = (FTC_Glyph_Cache_Class*)cache->root.clazz;
      cache->compare = gcache_clazz->gset_class->compare;
  
      /* The following is extremely important for ftc_destroy_glyph_image() */
      /* to work properly, as the second parameter that is sent to it       */
      /* through the cache manager is `cache_data' and must be set to       */
      /* `cache' here.                                                      */
      /*                                                                    */
      cache->root.cache_data = cache;
  
      error = FT_Lru_New( &ftc_glyph_set_lru_class,
                          FTC_MAX_GLYPH_SETS,
                          cache,
                          memory,
                          1, /* pre_alloc == TRUE */
                          &cache->gsets_lru );
      return error;
    }
  
  
    FT_EXPORT_DEF( void )  FTC_Glyph_Cache_Done( FTC_Glyph_Cache  cache )
    {
      /* discard glyph sets */
      FT_Lru_Done( cache->gsets_lru );
    }
  
  
    FT_EXPORT_DEF( FT_Error )  FTC_Glyph_Cache_Lookup( FTC_Glyph_Cache  cache,
                                                       FT_Pointer       type,
                                                       FT_UInt          gindex,
                                                       FTC_GlyphNode   *anode )
    {
      FT_Error       error;
      FTC_GlyphSet   gset;
      FTC_GlyphNode  node;
      FTC_Manager    manager;
  
  
      /* check for valid `desc' delayed to FT_Lru_Lookup() */
  
      if ( !cache || !anode )
        return FTC_Err_Invalid_Argument;
  
      *anode = 0;
      gset   = cache->last_gset;
  
      if ( !gset || !cache->compare( gset, type ) )
      {
        error = FT_Lru_Lookup( cache->gsets_lru,
                               (FT_LruKey)type,
                               (FT_Pointer*)&gset );
        cache->last_gset = gset;
        if ( error )
          goto Exit;
      }
  
      error = FTC_GlyphSet_Lookup_Node( gset, gindex, &node );
      if ( error )
        goto Exit;
  
      /* now compress the manager's cache pool if needed */
      manager = cache->root.manager;
      if ( manager->num_bytes > manager->max_bytes )
      {
        FTC_GlyphNode_Ref   ( node );
        FTC_Manager_Compress( manager );
        FTC_GlyphNode_Unref ( node );
      }
  
      *anode = node;
  
    Exit:
      return error;
    }
  
  
  /* END */
  

Download