freetype2/src/cache/ftcimage.c

#ifdef FT_FLAT_COMPILE
#  include "ftcimage.h"
#else
#  include <cache/ftcimage.h>
#endif

 /*************************************************************************/
 /*************************************************************************/
 /*****                                                               *****/
 /*****                    GLYPH IMAGE NODES                          *****/
 /*****                                                               *****/
 /*************************************************************************/
 /*************************************************************************/
 
  /* this is a simple glyph image destructor, which is called exclusively */
  /* from the CacheQueue object                                           */
  LOCAL_FUNC_X
  void  ftc_glyph_image_node_destroy( FTC_GlyphNode    node,
                                      FTC_Glyph_Queue  queue )
  {
    FT_Memory  memory = queue->memory;
    
    FT_Done_Glyph( FTC_GLYPHNODE_GET_GLYPH( node ) );
    FREE( node );
  }


  LOCAL_FUNC_X
  FT_Error  ftc_glyph_image_node_new( FTC_Glyph_Queue  queue,
                                      FT_UInt          glyph_index,
                                      FTC_GlyphNode   *anode )
  {  
    FT_Memory        memory   = queue->memory;
    FTC_Image_Queue  imageq = (FTC_Image_Queue)queue;
    FT_Error         error;
    FTC_GlyphNode    node = 0;
    FT_Face          face;
    FT_Size          size;

    /* allocate node */
    if ( ALLOC( node, sizeof(*node) ) )
      goto Exit;

    /* init its inner fields */
    FTC_GlyphNode_Init( node, queue, glyph_index );

    /* we will now load the glyph image */
    error = FTC_Manager_Lookup_Size( queue->manager,
                                     &imageq->description.font,
                                     &face, &size );
    if ( !error )
    {
      FT_UInt  glyph_index = node->glyph_index;
      FT_UInt  load_flags  = FT_LOAD_DEFAULT;
      FT_UInt  image_type  = imageq->description.image_type;
      
      if ( FTC_IMAGE_FORMAT( image_type ) == ftc_image_format_bitmap )
      {           
        load_flags |= FT_LOAD_RENDER;           
        if ( image_type & ftc_image_flag_monochrome )
          load_flags |= FT_LOAD_MONOCHROME;
          
        /* disable embedded bitmaps loading if necessary */
        if ( load_flags & ftc_image_flag_no_sbits )
          load_flags |= FT_LOAD_NO_BITMAP;
      }
      else if ( FTC_IMAGE_FORMAT( image_type ) == ftc_image_format_outline )
      {
        /* disable embedded bitmaps loading */
        load_flags |= FT_LOAD_NO_BITMAP;
        
        if ( image_type & ftc_image_flag_unscaled )
          load_flags |= FT_LOAD_NO_SCALE;
      }
          
      if ( image_type & ftc_image_flag_unhinted )
        load_flags |= FT_LOAD_NO_HINTING;
          
      if ( image_type & ftc_image_flag_autohinted )
        load_flags |= FT_LOAD_FORCE_AUTOHINT;

      error = FT_Load_Glyph( face, glyph_index, load_flags );
      if ( !error )
      {
        if ( face->glyph->format == ft_glyph_format_bitmap  ||
             face->glyph->format == ft_glyph_format_outline )
        {             
          /* ok, copy it */
          FT_Glyph  glyph;
          
          
          error = FT_Get_Glyph( face->glyph, &glyph );
          if ( !error )
            FTC_GLYPHNODE_SET_GLYPH( node, glyph );
        }
        else
          error = FT_Err_Invalid_Argument;
      }
    }
  Exit:
    if (error && node)
      FREE(node);

    *anode = node;
    return error;
  }


 /* this function is important, because it is both part of */
 /* a FTC_Glyph_Queue_Class and a FTC_CacheNode_Class      */
 /*                                                        */
  LOCAL_FUNC_X
  FT_ULong  ftc_glyph_image_node_size( FTC_GlyphNode    node )
  {
    FT_ULong        size  = 0;
    FT_Glyph        glyph = FTC_GLYPHNODE_GET_GLYPH(node);
    
    switch (glyph->format)
    {
      case ft_glyph_format_bitmap:
        {
          FT_BitmapGlyph  bitg;
          
          bitg = (FT_BitmapGlyph)glyph;
          size = bitg->bitmap.rows * labs(bitg->bitmap.pitch) +
                 sizeof(*bitg);
        }
        break;
        
      case ft_glyph_format_outline:
        {
          FT_OutlineGlyph  outg;
          
          outg = (FT_OutlineGlyph)glyph;
          size = outg->outline.n_points * 
                   ( sizeof( FT_Vector ) + sizeof( FT_Byte ) ) +
                 outg->outline.n_contours *
                     sizeof( FT_Short ) +
                 sizeof(*outg);
        }
        break;
        
      default:
        ;
    }
    size += sizeof(*node);
    return size;
  }


 /*************************************************************************/
 /*************************************************************************/
 /*****                                                               *****/
 /*****                    GLYPH IMAGE QUEUES                         *****/
 /*****                                                               *****/
 /*************************************************************************/
 /*************************************************************************/


  LOCAL_FUNC_X
  FT_Error  ftc_image_queue_init( FTC_Image_Queue  queue,
                                  FTC_Image_Desc*  type )
  {
    queue->description = *type;
    return 0;
  }


  LOCAL_FUNC_X
  FT_Bool   ftc_image_queue_compare( FTC_Image_Queue   queue,
                                     FTC_Image_Desc*   type )
  {
    return !memcmp( &queue->description, type, sizeof(*type) );
  }
                                      

  FT_CPLUSPLUS(const FTC_Glyph_Queue_Class)  ftc_glyph_image_queue_class =
  {
    sizeof( FTC_Image_QueueRec ),
    
    (FTC_Glyph_Queue_InitFunc)     ftc_image_queue_init,
    (FTC_Glyph_Queue_DoneFunc)     0,
    (FTC_Glyph_Queue_CompareFunc)  ftc_image_queue_compare,
    
    (FTC_Glyph_Queue_NewNodeFunc)      ftc_glyph_image_node_new,
    (FTC_Glyph_Queue_SizeNodeFunc)     ftc_glyph_image_node_size,
    (FTC_Glyph_Queue_DestroyNodeFunc)  ftc_glyph_image_node_destroy
  };


 /*************************************************************************/
 /*************************************************************************/
 /*****                                                               *****/
 /*****                    GLYPH IMAGE CACHE                          *****/
 /*****                                                               *****/
 /*************************************************************************/
 /*************************************************************************/



  FT_CPLUSPLUS(const FTC_Glyph_Cache_Class)  ftc_glyph_image_cache_class =
  {
    {
      sizeof( FTC_Glyph_CacheRec ),
      (FTC_Cache_InitFunc)  FTC_Glyph_Cache_Init,
      (FTC_Cache_DoneFunc)  FTC_Glyph_Cache_Done
    },
    (FTC_Glyph_Queue_Class*)  &ftc_glyph_image_queue_class
  };


  FT_EXPORT_FUNC( FT_Error )  FTC_Image_Cache_New( FTC_Manager       manager,
                                                   FTC_Image_Cache*  acache )
  {
    return FTC_Manager_Register_Cache(
              manager,
              (FTC_Cache_Class*)&ftc_glyph_image_cache_class,
              (FTC_Cache*)acache );
  }
                                        

  FT_EXPORT_DEF( FT_Error )  FTC_Image_Cache_Lookup(
                               FTC_Image_Cache  cache,
                               FTC_Image_Desc*  desc,
                               FT_UInt          gindex,
                               FT_Glyph*        aglyph )
  {
    FT_Error         error;
    FTC_Glyph_Queue  queue;
    FTC_GlyphNode    inode;
    FTC_Manager      manager;

    FTC_Image_Queue  img_queue;

    /* check for valid `desc' delayed to FT_Lru_Lookup() */

    if ( !cache || !aglyph )
      return FT_Err_Invalid_Argument;

    *aglyph   = 0;    
    queue     = cache->root.last_queue;
    img_queue = (FTC_Image_Queue)queue;
    if ( !queue || memcmp( &img_queue->description, desc, sizeof(*desc) ) )
    {
      error = FT_Lru_Lookup( cache->root.queues_lru,
                             (FT_LruKey)desc,
                             (FT_Pointer*)&queue );
      cache->root.last_queue = queue;
      if ( error )
        goto Exit;
    }

    error = FTC_Glyph_Queue_Lookup_Node( queue, gindex, &inode );
    if ( error )
      goto Exit;

    /* now compress the manager's cache pool if needed */
    manager = cache->root.root.manager;
    if (manager->num_bytes > manager->max_bytes)
    {
      FTC_GlyphNode_Ref(inode);
      FTC_Manager_Compress( manager );
      FTC_GlyphNode_Unref(inode);
    }

    *aglyph = FTC_GLYPHNODE_GET_GLYPH( inode );

  Exit:
    return error;
  }