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

• Show log

  Commit

• Hash : 23f85c8a
  Author :
  Date : 2021-04-22T23:34:08
  

  [cache] Optimize SBit copying. * src/cache/ftcsbits.c (ftc_snode_load): Do not initialize the buffer. (ftc_sbit_copy_bitmap): Accept zero size, s/FT_ALLOC/FT_QALLOC/.

Download

• src/cache/ftcsbits.c

• /****************************************************************************
   *
   * ftcsbits.c
   *
   *   FreeType sbits manager (body).
   *
   * Copyright (C) 2000-2021 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 <freetype/ftcache.h>
  #include "ftcsbits.h"
  #include <freetype/internal/ftobjs.h>
  #include <freetype/internal/ftdebug.h>
  #include <freetype/fterrors.h>
  
  #include "ftccback.h"
  #include "ftcerror.h"
  
  #undef  FT_COMPONENT
  #define FT_COMPONENT  cache
  
  
    /*************************************************************************/
    /*************************************************************************/
    /*****                                                               *****/
    /*****                     SBIT CACHE NODES                          *****/
    /*****                                                               *****/
    /*************************************************************************/
    /*************************************************************************/
  
  
    static FT_Error
    ftc_sbit_copy_bitmap( FTC_SBit    sbit,
                          FT_Bitmap*  bitmap,
                          FT_Memory   memory )
    {
      FT_Error  error;
      FT_Int    pitch = bitmap->pitch;
      FT_ULong  size;
  
  
      if ( pitch < 0 )
        pitch = -pitch;
  
      size = (FT_ULong)pitch * bitmap->rows;
  
      if ( !FT_QALLOC( sbit->buffer, size ) )
        FT_MEM_COPY( sbit->buffer, bitmap->buffer, size );
  
      return error;
    }
  
  
    FT_LOCAL_DEF( void )
    ftc_snode_free( FTC_Node   ftcsnode,
                    FTC_Cache  cache )
    {
      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 );
    }
  
  
    FT_LOCAL_DEF( void )
    FTC_SNode_Free( FTC_SNode  snode,
                    FTC_Cache  cache )
    {
      ftc_snode_free( FTC_NODE( snode ), cache );
    }
  
  
    /*
     * This function tries to load a small bitmap within a given FTC_SNode.
     * Note that it returns a non-zero error code _only_ in the case of
     * out-of-memory condition.  For all other errors (e.g., corresponding
     * to a bad font file), this function will mark the sbit as `unavailable'
     * and return a value of 0.
     *
     * You should also read the comment within the @ftc_snode_compare
     * function below to see how out-of-memory is handled during a lookup.
     */
    static FT_Error
    ftc_snode_load( FTC_SNode    snode,
                    FTC_Manager  manager,
                    FT_UInt      gindex,
                    FT_ULong    *asize )
    {
      FT_Error          error;
      FTC_GNode         gnode  = FTC_GNODE( snode );
      FTC_Family        family = gnode->family;
      FT_Face           face;
      FTC_SBit          sbit;
      FTC_SFamilyClass  clazz;
  
  
      if ( (FT_UInt)(gindex - gnode->gindex) >= snode->count )
      {
        FT_ERROR(( "ftc_snode_load: invalid glyph index" ));
        return FT_THROW( Invalid_Argument );
      }
  
      sbit  = snode->sbits + ( gindex - gnode->gindex );
      clazz = (FTC_SFamilyClass)family->clazz;
  
      error = clazz->family_load_glyph( family, gindex, manager, &face );
      if ( error )
        goto BadGlyph;
  
      {
        FT_Int        temp;
        FT_GlyphSlot  slot   = face->glyph;
        FT_Bitmap*    bitmap = &slot->bitmap;
        FT_Pos        xadvance, yadvance; /* FT_GlyphSlot->advance.{x|y} */
  
  
        if ( slot->format != FT_GLYPH_FORMAT_BITMAP )
        {
          FT_TRACE0(( "ftc_snode_load:"
                      " glyph loaded didn't return a bitmap\n" ));
          goto BadGlyph;
        }
  
        /* Check whether our values fit into 8/16-bit containers! */
        /* If this is not the case, our bitmap is too large       */
        /* and we will leave it as `missing' with sbit.buffer = 0 */
  
  #define CHECK_CHAR( d )  ( temp = (FT_Char)d, (FT_Int) temp == (FT_Int) d )
  #define CHECK_BYTE( d )  ( temp = (FT_Byte)d, (FT_UInt)temp == (FT_UInt)d )
  #define CHECK_SHRT( d )  ( temp = (FT_Short)d, (FT_Int)temp == (FT_Int) d )
  
        /* horizontal advance in pixels */
        xadvance = ( slot->advance.x + 32 ) >> 6;
        yadvance = ( slot->advance.y + 32 ) >> 6;
  
        if ( !CHECK_BYTE( bitmap->rows  )     ||
             !CHECK_BYTE( bitmap->width )     ||
             !CHECK_SHRT( bitmap->pitch )     ||
             !CHECK_CHAR( slot->bitmap_left ) ||
             !CHECK_CHAR( slot->bitmap_top  ) ||
             !CHECK_CHAR( xadvance )          ||
             !CHECK_CHAR( yadvance )          )
        {
          FT_TRACE2(( "ftc_snode_load:"
                      " glyph too large for small bitmap cache\n"));
          goto BadGlyph;
        }
  
        sbit->width     = (FT_Byte)bitmap->width;
        sbit->height    = (FT_Byte)bitmap->rows;
        sbit->pitch     = (FT_Short)bitmap->pitch;
        sbit->left      = (FT_Char)slot->bitmap_left;
        sbit->top       = (FT_Char)slot->bitmap_top;
        sbit->xadvance  = (FT_Char)xadvance;
        sbit->yadvance  = (FT_Char)yadvance;
        sbit->format    = (FT_Byte)bitmap->pixel_mode;
        sbit->max_grays = (FT_Byte)(bitmap->num_grays - 1);
  
        if ( slot->internal->flags & FT_GLYPH_OWN_BITMAP )
        {
          /* take the bitmap ownership */
          sbit->buffer = bitmap->buffer;
          slot->internal->flags &= ~FT_GLYPH_OWN_BITMAP;
        }
        else
        {
          /* copy the bitmap into a new buffer -- ignore error */
          error = ftc_sbit_copy_bitmap( sbit, bitmap, manager->memory );
        }
  
        /* now, compute size */
        if ( asize )
          *asize = (FT_ULong)FT_ABS( sbit->pitch ) * sbit->height;
  
      } /* glyph loading successful */
  
      /* ignore the errors that might have occurred --   */
      /* we mark unloaded glyphs with `sbit.buffer == 0' */
      /* and `width == 255', `height == 0'               */
      /*                                                 */
      if ( error && FT_ERR_NEQ( error, Out_Of_Memory ) )
      {
      BadGlyph:
        sbit->width  = 255;
        sbit->height = 0;
        sbit->buffer = NULL;
        error        = FT_Err_Ok;
        if ( asize )
          *asize = 0;
      }
  
      return error;
    }
  
  
    FT_LOCAL_DEF( FT_Error )
    FTC_SNode_New( FTC_SNode  *psnode,
                   FTC_GQuery  gquery,
                   FTC_Cache   cache )
    {
      FT_Memory   memory = cache->memory;
      FT_Error    error;
      FTC_SNode   snode  = NULL;
      FT_UInt     gindex = gquery->gindex;
      FTC_Family  family = gquery->family;
  
      FTC_SFamilyClass  clazz = FTC_CACHE_SFAMILY_CLASS( cache );
      FT_UInt           total;
      FT_UInt           node_count;
  
  
      total = clazz->family_get_count( family, cache->manager );
      if ( total == 0 || gindex >= total )
      {
        error = FT_THROW( Invalid_Argument );
        goto Exit;
      }
  
      if ( !FT_NEW( snode ) )
      {
        FT_UInt  count, start;
  
  
        start = gindex - ( gindex % FTC_SBIT_ITEMS_PER_NODE );
        count = total - start;
        if ( count > FTC_SBIT_ITEMS_PER_NODE )
          count = FTC_SBIT_ITEMS_PER_NODE;
  
        FTC_GNode_Init( FTC_GNODE( snode ), start, family );
  
        snode->count = count;
        for ( node_count = 0; node_count < count; node_count++ )
        {
          snode->sbits[node_count].width = 255;
        }
  
        error = ftc_snode_load( snode,
                                cache->manager,
                                gindex,
                                NULL );
        if ( error )
        {
          FTC_SNode_Free( snode, cache );
          snode = NULL;
        }
      }
  
    Exit:
      *psnode = snode;
      return error;
    }
  
  
    FT_LOCAL_DEF( FT_Error )
    ftc_snode_new( FTC_Node   *ftcpsnode,
                   FT_Pointer  ftcgquery,
                   FTC_Cache   cache )
    {
      FTC_SNode  *psnode = (FTC_SNode*)ftcpsnode;
      FTC_GQuery  gquery = (FTC_GQuery)ftcgquery;
  
  
      return FTC_SNode_New( psnode, gquery, cache );
    }
  
  
    FT_LOCAL_DEF( FT_Offset )
    ftc_snode_weight( FTC_Node   ftcsnode,
                      FTC_Cache  cache )
    {
      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;
    }
  
  
  #if 0
  
    FT_LOCAL_DEF( FT_Offset )
    FTC_SNode_Weight( FTC_SNode  snode )
    {
      return ftc_snode_weight( FTC_NODE( snode ), NULL );
    }
  
  #endif /* 0 */
  
  
    FT_LOCAL_DEF( FT_Bool )
    ftc_snode_compare( FTC_Node    ftcsnode,
                       FT_Pointer  ftcgquery,
                       FTC_Cache   cache,
                       FT_Bool*    list_changed )
    {
      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;
    }
  
  
  #ifdef FTC_INLINE
  
    FT_LOCAL_DEF( FT_Bool )
    FTC_SNode_Compare( FTC_SNode   snode,
                       FTC_GQuery  gquery,
                       FTC_Cache   cache,
                       FT_Bool*    list_changed )
    {
      return ftc_snode_compare( FTC_NODE( snode ), gquery,
                                cache, list_changed );
    }
  
  #endif
  
  /* END */
  

Download