src/cache/ftcsbits.c

   1 /****************************************************************************
   2  *
   3  * ftcsbits.c
   4  *
   5  *   FreeType sbits manager (body).
   6  *
   7  * Copyright (C) 2000-2023 by
   8  * David Turner, Robert Wilhelm, and Werner Lemberg.
   9  *
  10  * This file is part of the FreeType project, and may only be used,
  11  * modified, and distributed under the terms of the FreeType project
  12  * license, LICENSE.TXT.  By continuing to use, modify, or distribute
  13  * this file you indicate that you have read the license and
  14  * understand and accept it fully.
  15  *
  16  */
  17
  18
  19 #include <freetype/ftcache.h>
  20 #include "ftcsbits.h"
  21 #include <freetype/internal/ftobjs.h>
  22 #include <freetype/internal/ftdebug.h>
  23 #include <freetype/fterrors.h>
  24
  25 #include "ftccback.h"
  26 #include "ftcerror.h"
  27
  28 #undef  FT_COMPONENT
  29 #define FT_COMPONENT  cache
  30
  31
  32   /*************************************************************************/
  33   /*************************************************************************/
  34   /*****                                                               *****/
  35   /*****                     SBIT CACHE NODES                          *****/
  36   /*****                                                               *****/
  37   /*************************************************************************/
  38   /*************************************************************************/
  39
  40
  41   static FT_Error
  42   ftc_sbit_copy_bitmap( FTC_SBit    sbit,
  43                         FT_Bitmap*  bitmap,
  44                         FT_Memory   memory )
  45   {
  46     FT_Error  error;
  47     FT_Int    pitch = bitmap->pitch;
  48     FT_ULong  size;
  49
  50
  51     if ( pitch < 0 )
  52       pitch = -pitch;
  53
  54     size = (FT_ULong)pitch * bitmap->rows;
  55
  56     if ( !FT_QALLOC( sbit->buffer, size ) )
  57       FT_MEM_COPY( sbit->buffer, bitmap->buffer, size );
  58
  59     return error;
  60   }
  61
  62
  63   FT_LOCAL_DEF( void )
  64   ftc_snode_free( FTC_Node   ftcsnode,
  65                   FTC_Cache  cache )
  66   {
  67     FTC_SNode  snode  = (FTC_SNode)ftcsnode;
  68     FTC_SBit   sbit   = snode->sbits;
  69     FT_UInt    count  = snode->count;
  70     FT_Memory  memory = cache->memory;
  71
  72
  73     for ( ; count > 0; sbit++, count-- )
  74       FT_FREE( sbit->buffer );
  75
  76     FTC_GNode_Done( FTC_GNODE( snode ), cache );
  77
  78     FT_FREE( snode );
  79   }
  80
  81
  82   FT_LOCAL_DEF( void )
  83   FTC_SNode_Free( FTC_SNode  snode,
  84                   FTC_Cache  cache )
  85   {
  86     ftc_snode_free( FTC_NODE( snode ), cache );
  87   }
  88
  89
  90   /*
  91    * This function tries to load a small bitmap within a given FTC_SNode.
  92    * Note that it returns a non-zero error code _only_ in the case of
  93    * out-of-memory condition.  For all other errors (e.g., corresponding
  94    * to a bad font file), this function will mark the sbit as `unavailable'
  95    * and return a value of 0.
  96    *
  97    * You should also read the comment within the @ftc_snode_compare
  98    * function below to see how out-of-memory is handled during a lookup.
  99    */
 100   static FT_Error
 101   ftc_snode_load( FTC_SNode    snode,
 102                   FTC_Manager  manager,
 103                   FT_UInt      gindex,
 104                   FT_ULong    *asize )
 105   {
 106     FT_Error          error;
 107     FTC_GNode         gnode  = FTC_GNODE( snode );
 108     FTC_Family        family = gnode->family;
 109     FT_Face           face;
 110     FTC_SBit          sbit;
 111     FTC_SFamilyClass  clazz;
 112
 113
 114     if ( gindex - gnode->gindex >= snode->count )
 115     {
 116       FT_ERROR(( "ftc_snode_load: invalid glyph index" ));
 117       return FT_THROW( Invalid_Argument );
 118     }
 119
 120     sbit  = snode->sbits + ( gindex - gnode->gindex );
 121     clazz = (FTC_SFamilyClass)family->clazz;
 122
 123     error = clazz->family_load_glyph( family, gindex, manager, &face );
 124     if ( error )
 125       goto BadGlyph;
 126
 127     {
 128       FT_Int        temp;
 129       FT_GlyphSlot  slot   = face->glyph;
 130       FT_Bitmap*    bitmap = &slot->bitmap;
 131       FT_Pos        xadvance, yadvance; /* FT_GlyphSlot->advance.{x|y} */
 132
 133
 134       if ( slot->format != FT_GLYPH_FORMAT_BITMAP )
 135       {
 136         FT_TRACE0(( "ftc_snode_load:"
 137                     " glyph loaded didn't return a bitmap\n" ));
 138         goto BadGlyph;
 139       }
 140
 141       /* Check whether our values fit into 8/16-bit containers! */
 142       /* If this is not the case, our bitmap is too large       */
 143       /* and we will leave it as `missing' with sbit.buffer = 0 */
 144
 145 #define CHECK_CHAR( d )  ( temp = (FT_Char)d, (FT_Int) temp == (FT_Int) d )
 146 #define CHECK_BYTE( d )  ( temp = (FT_Byte)d, (FT_UInt)temp == (FT_UInt)d )
 147 #define CHECK_SHRT( d )  ( temp = (FT_Short)d, (FT_Int)temp == (FT_Int) d )
 148
 149       /* horizontal advance in pixels */
 150       xadvance = ( slot->advance.x + 32 ) >> 6;
 151       yadvance = ( slot->advance.y + 32 ) >> 6;
 152
 153       if ( !CHECK_BYTE( bitmap->rows  )     ||
 154            !CHECK_BYTE( bitmap->width )     ||
 155            !CHECK_SHRT( bitmap->pitch )     ||
 156            !CHECK_CHAR( slot->bitmap_left ) ||
 157            !CHECK_CHAR( slot->bitmap_top  ) ||
 158            !CHECK_CHAR( xadvance )          ||
 159            !CHECK_CHAR( yadvance )          )
 160       {
 161         FT_TRACE2(( "ftc_snode_load:"
 162                     " glyph too large for small bitmap cache\n"));
 163         goto BadGlyph;
 164       }
 165
 166       sbit->width     = (FT_Byte)bitmap->width;
 167       sbit->height    = (FT_Byte)bitmap->rows;
 168       sbit->pitch     = (FT_Short)bitmap->pitch;
 169       sbit->left      = (FT_Char)slot->bitmap_left;
 170       sbit->top       = (FT_Char)slot->bitmap_top;
 171       sbit->xadvance  = (FT_Char)xadvance;
 172       sbit->yadvance  = (FT_Char)yadvance;
 173       sbit->format    = (FT_Byte)bitmap->pixel_mode;
 174       sbit->max_grays = (FT_Byte)( bitmap->num_grays - 1 );
 175
 176       if ( slot->internal->flags & FT_GLYPH_OWN_BITMAP )
 177       {
 178         /* take the bitmap ownership */
 179         sbit->buffer = bitmap->buffer;
 180         slot->internal->flags &= ~FT_GLYPH_OWN_BITMAP;
 181       }
 182       else
 183       {
 184         /* copy the bitmap into a new buffer -- ignore error */
 185         error = ftc_sbit_copy_bitmap( sbit, bitmap, manager->memory );
 186       }
 187
 188       /* now, compute size */
 189       if ( asize )
 190         *asize = (FT_ULong)FT_ABS( sbit->pitch ) * sbit->height;
 191
 192     } /* glyph loading successful */
 193
 194     /* ignore the errors that might have occurred --   */
 195     /* we mark unloaded glyphs with `sbit.buffer == 0' */
 196     /* and `width == 255', `height == 0'               */
 197     /*                                                 */
 198     if ( error && FT_ERR_NEQ( error, Out_Of_Memory ) )
 199     {
 200     BadGlyph:
 201       sbit->width  = 255;
 202       sbit->height = 0;
 203       sbit->buffer = NULL;
 204       error        = FT_Err_Ok;
 205       if ( asize )
 206         *asize = 0;
 207     }
 208
 209     return error;
 210   }
 211
 212
 213   FT_LOCAL_DEF( FT_Error )
 214   FTC_SNode_New( FTC_SNode  *psnode,
 215                  FTC_GQuery  gquery,
 216                  FTC_Cache   cache )
 217   {
 218     FT_Memory   memory = cache->memory;
 219     FT_Error    error;
 220     FTC_SNode   snode  = NULL;
 221     FT_UInt     gindex = gquery->gindex;
 222     FTC_Family  family = gquery->family;
 223
 224     FTC_SFamilyClass  clazz = FTC_CACHE_SFAMILY_CLASS( cache );
 225     FT_UInt           total;
 226     FT_UInt           node_count;
 227
 228
 229     total = clazz->family_get_count( family, cache->manager );
 230     if ( total == 0 || gindex >= total )
 231     {
 232       error = FT_THROW( Invalid_Argument );
 233       goto Exit;
 234     }
 235
 236     if ( !FT_QNEW( snode ) )
 237     {
 238       FT_UInt  count, start;
 239
 240
 241       start = gindex - ( gindex % FTC_SBIT_ITEMS_PER_NODE );
 242       count = total - start;
 243       if ( count > FTC_SBIT_ITEMS_PER_NODE )
 244         count = FTC_SBIT_ITEMS_PER_NODE;
 245
 246       FTC_GNode_Init( FTC_GNODE( snode ), start, family );
 247
 248       snode->count = count;
 249       for ( node_count = 0; node_count < count; node_count++ )
 250       {
 251         snode->sbits[node_count].width  = 255;
 252         snode->sbits[node_count].height = 0;
 253         snode->sbits[node_count].buffer = NULL;
 254       }
 255
 256       error = ftc_snode_load( snode,
 257                               cache->manager,
 258                               gindex,
 259                               NULL );
 260       if ( error )
 261       {
 262         FTC_SNode_Free( snode, cache );
 263         snode = NULL;
 264       }
 265     }
 266
 267   Exit:
 268     *psnode = snode;
 269     return error;
 270   }
 271
 272
 273   FT_LOCAL_DEF( FT_Error )
 274   ftc_snode_new( FTC_Node   *ftcpsnode,
 275                  FT_Pointer  ftcgquery,
 276                  FTC_Cache   cache )
 277   {
 278     FTC_SNode  *psnode = (FTC_SNode*)ftcpsnode;
 279     FTC_GQuery  gquery = (FTC_GQuery)ftcgquery;
 280
 281
 282     return FTC_SNode_New( psnode, gquery, cache );
 283   }
 284
 285
 286   FT_LOCAL_DEF( FT_Offset )
 287   ftc_snode_weight( FTC_Node   ftcsnode,
 288                     FTC_Cache  cache )
 289   {
 290     FTC_SNode  snode = (FTC_SNode)ftcsnode;
 291     FT_UInt    count = snode->count;
 292     FTC_SBit   sbit  = snode->sbits;
 293     FT_Int     pitch;
 294     FT_Offset  size;
 295
 296     FT_UNUSED( cache );
 297
 298
 299     FT_ASSERT( snode->count <= FTC_SBIT_ITEMS_PER_NODE );
 300
 301     /* the node itself */
 302     size = sizeof ( *snode );
 303
 304     for ( ; count > 0; count--, sbit++ )
 305     {
 306       if ( sbit->buffer )
 307       {
 308         pitch = sbit->pitch;
 309         if ( pitch < 0 )
 310           pitch = -pitch;
 311
 312         /* add the size of a given glyph image */
 313         size += (FT_Offset)pitch * sbit->height;
 314       }
 315     }
 316
 317     return size;
 318   }
 319
 320
 321 #if 0
 322
 323   FT_LOCAL_DEF( FT_Offset )
 324   FTC_SNode_Weight( FTC_SNode  snode )
 325   {
 326     return ftc_snode_weight( FTC_NODE( snode ), NULL );
 327   }
 328
 329 #endif /* 0 */
 330
 331
 332   FT_LOCAL_DEF( FT_Bool )
 333   ftc_snode_compare( FTC_Node    ftcsnode,
 334                      FT_Pointer  ftcgquery,
 335                      FTC_Cache   cache,
 336                      FT_Bool*    list_changed )
 337   {
 338     FTC_SNode   snode  = (FTC_SNode)ftcsnode;
 339     FTC_GQuery  gquery = (FTC_GQuery)ftcgquery;
 340     FTC_GNode   gnode  = FTC_GNODE( snode );
 341     FT_UInt     gindex = gquery->gindex;
 342     FT_Bool     result;
 343
 344
 345     if ( list_changed )
 346       *list_changed = FALSE;
 347     result = FT_BOOL( gnode->family == gquery->family       &&
 348                       gindex - gnode->gindex < snode->count );
 349     if ( result )
 350     {
 351       /* check if we need to load the glyph bitmap now */
 352       FTC_SBit  sbit = snode->sbits + ( gindex - gnode->gindex );
 353
 354
 355       /*
 356        * The following code illustrates what to do when you want to
 357        * perform operations that may fail within a lookup function.
 358        *
 359        * Here, we want to load a small bitmap on-demand; we thus
 360        * need to call the `ftc_snode_load' function which may return
 361        * a non-zero error code only when we are out of memory (OOM).
 362        *
 363        * The correct thing to do is to use @FTC_CACHE_TRYLOOP and
 364        * @FTC_CACHE_TRYLOOP_END in order to implement a retry loop
 365        * that is capable of flushing the cache incrementally when
 366        * an OOM errors occur.
 367        *
 368        * However, we need to `lock' the node before this operation to
 369        * prevent it from being flushed within the loop.
 370        *
 371        * When we exit the loop, we unlock the node, then check the `error'
 372        * variable.  If it is non-zero, this means that the cache was
 373        * completely flushed and that no usable memory was found to load
 374        * the bitmap.
 375        *
 376        * We then prefer to return a value of 0 (i.e., NO MATCH).  This
 377        * ensures that the caller will try to allocate a new node.
 378        * This operation consequently _fail_ and the lookup function
 379        * returns the appropriate OOM error code.
 380        *
 381        * Note that `buffer == NULL && width == 255' is a hack used to
 382        * tag `unavailable' bitmaps in the array.  We should never try
 383        * to load these.
 384        *
 385        */
 386
 387       if ( !sbit->buffer && sbit->width == 255 )
 388       {
 389         FT_ULong  size;
 390         FT_Error  error;
 391
 392
 393         ftcsnode->ref_count++;  /* lock node to prevent flushing */
 394                                 /* in retry loop                 */
 395
 396         FTC_CACHE_TRYLOOP( cache )
 397         {
 398           error = ftc_snode_load( snode, cache->manager, gindex, &size );
 399         }
 400         FTC_CACHE_TRYLOOP_END( list_changed )
 401
 402         ftcsnode->ref_count--;  /* unlock the node */
 403
 404         if ( error )
 405           result = 0;
 406         else
 407           cache->manager->cur_weight += size;
 408       }
 409     }
 410
 411     return result;
 412   }
 413
 414 /* END */