QRScanner/mobile/jni/thirdparty/freetype/src/cache/ftcsbits.c

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