Home | History | Annotate | Download | only in cache
      1 /***************************************************************************/
      2 /*                                                                         */
      3 /*  ftcbasic.c                                                             */
      4 /*                                                                         */
      5 /*    The FreeType basic cache interface (body).                           */
      6 /*                                                                         */
      7 /*  Copyright 2003-2007, 2009-2011, 2013 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_INTERNAL_OBJECTS_H
     21 #include FT_INTERNAL_DEBUG_H
     22 #include FT_CACHE_H
     23 #include "ftcglyph.h"
     24 #include "ftcimage.h"
     25 #include "ftcsbits.h"
     26 
     27 #include "ftccback.h"
     28 #include "ftcerror.h"
     29 
     30 #define FT_COMPONENT  trace_cache
     31 
     32 
     33   /*
     34    *  Basic Families
     35    *
     36    */
     37   typedef struct  FTC_BasicAttrRec_
     38   {
     39     FTC_ScalerRec  scaler;
     40     FT_UInt        load_flags;
     41 
     42   } FTC_BasicAttrRec, *FTC_BasicAttrs;
     43 
     44 #define FTC_BASIC_ATTR_COMPARE( a, b )                                 \
     45           FT_BOOL( FTC_SCALER_COMPARE( &(a)->scaler, &(b)->scaler ) && \
     46                    (a)->load_flags == (b)->load_flags               )
     47 
     48 #define FTC_BASIC_ATTR_HASH( a )                                   \
     49           ( FTC_SCALER_HASH( &(a)->scaler ) + 31*(a)->load_flags )
     50 
     51 
     52   typedef struct  FTC_BasicQueryRec_
     53   {
     54     FTC_GQueryRec     gquery;
     55     FTC_BasicAttrRec  attrs;
     56 
     57   } FTC_BasicQueryRec, *FTC_BasicQuery;
     58 
     59 
     60   typedef struct  FTC_BasicFamilyRec_
     61   {
     62     FTC_FamilyRec     family;
     63     FTC_BasicAttrRec  attrs;
     64 
     65   } FTC_BasicFamilyRec, *FTC_BasicFamily;
     66 
     67 
     68   FT_CALLBACK_DEF( FT_Bool )
     69   ftc_basic_family_compare( FTC_MruNode  ftcfamily,
     70                             FT_Pointer   ftcquery )
     71   {
     72     FTC_BasicFamily  family = (FTC_BasicFamily)ftcfamily;
     73     FTC_BasicQuery   query  = (FTC_BasicQuery)ftcquery;
     74 
     75 
     76     return FTC_BASIC_ATTR_COMPARE( &family->attrs, &query->attrs );
     77   }
     78 
     79 
     80   FT_CALLBACK_DEF( FT_Error )
     81   ftc_basic_family_init( FTC_MruNode  ftcfamily,
     82                          FT_Pointer   ftcquery,
     83                          FT_Pointer   ftccache )
     84   {
     85     FTC_BasicFamily  family = (FTC_BasicFamily)ftcfamily;
     86     FTC_BasicQuery   query  = (FTC_BasicQuery)ftcquery;
     87     FTC_Cache        cache  = (FTC_Cache)ftccache;
     88 
     89 
     90     FTC_Family_Init( FTC_FAMILY( family ), cache );
     91     family->attrs = query->attrs;
     92     return 0;
     93   }
     94 
     95 
     96   FT_CALLBACK_DEF( FT_UInt )
     97   ftc_basic_family_get_count( FTC_Family   ftcfamily,
     98                               FTC_Manager  manager )
     99   {
    100     FTC_BasicFamily  family = (FTC_BasicFamily)ftcfamily;
    101     FT_Error         error;
    102     FT_Face          face;
    103     FT_UInt          result = 0;
    104 
    105 
    106     error = FTC_Manager_LookupFace( manager, family->attrs.scaler.face_id,
    107                                     &face );
    108 
    109     if ( error || !face )
    110       return result;
    111 
    112     if ( (FT_ULong)face->num_glyphs > FT_UINT_MAX || 0 > face->num_glyphs )
    113     {
    114       FT_TRACE1(( "ftc_basic_family_get_count: too large number of glyphs " ));
    115       FT_TRACE1(( "in this face, truncated\n", face->num_glyphs ));
    116     }
    117 
    118     if ( !error )
    119       result = (FT_UInt)face->num_glyphs;
    120 
    121     return result;
    122   }
    123 
    124 
    125   FT_CALLBACK_DEF( FT_Error )
    126   ftc_basic_family_load_bitmap( FTC_Family   ftcfamily,
    127                                 FT_UInt      gindex,
    128                                 FTC_Manager  manager,
    129                                 FT_Face     *aface )
    130   {
    131     FTC_BasicFamily  family = (FTC_BasicFamily)ftcfamily;
    132     FT_Error         error;
    133     FT_Size          size;
    134 
    135 
    136     error = FTC_Manager_LookupSize( manager, &family->attrs.scaler, &size );
    137     if ( !error )
    138     {
    139       FT_Face  face = size->face;
    140 
    141 
    142       error = FT_Load_Glyph( face, gindex,
    143                              family->attrs.load_flags | FT_LOAD_RENDER );
    144       if ( !error )
    145         *aface = face;
    146     }
    147 
    148     return error;
    149   }
    150 
    151 
    152   FT_CALLBACK_DEF( FT_Error )
    153   ftc_basic_family_load_glyph( FTC_Family  ftcfamily,
    154                                FT_UInt     gindex,
    155                                FTC_Cache   cache,
    156                                FT_Glyph   *aglyph )
    157   {
    158     FTC_BasicFamily  family = (FTC_BasicFamily)ftcfamily;
    159     FT_Error         error;
    160     FTC_Scaler       scaler = &family->attrs.scaler;
    161     FT_Face          face;
    162     FT_Size          size;
    163 
    164 
    165     /* we will now load the glyph image */
    166     error = FTC_Manager_LookupSize( cache->manager,
    167                                     scaler,
    168                                     &size );
    169     if ( !error )
    170     {
    171       face = size->face;
    172 
    173       error = FT_Load_Glyph( face, gindex, family->attrs.load_flags );
    174       if ( !error )
    175       {
    176         if ( face->glyph->format == FT_GLYPH_FORMAT_BITMAP  ||
    177              face->glyph->format == FT_GLYPH_FORMAT_OUTLINE )
    178         {
    179           /* ok, copy it */
    180           FT_Glyph  glyph;
    181 
    182 
    183           error = FT_Get_Glyph( face->glyph, &glyph );
    184           if ( !error )
    185           {
    186             *aglyph = glyph;
    187             goto Exit;
    188           }
    189         }
    190         else
    191           error = FT_THROW( Invalid_Argument );
    192       }
    193     }
    194 
    195   Exit:
    196     return error;
    197   }
    198 
    199 
    200   FT_CALLBACK_DEF( FT_Bool )
    201   ftc_basic_gnode_compare_faceid( FTC_Node    ftcgnode,
    202                                   FT_Pointer  ftcface_id,
    203                                   FTC_Cache   cache,
    204                                   FT_Bool*    list_changed )
    205   {
    206     FTC_GNode        gnode   = (FTC_GNode)ftcgnode;
    207     FTC_FaceID       face_id = (FTC_FaceID)ftcface_id;
    208     FTC_BasicFamily  family  = (FTC_BasicFamily)gnode->family;
    209     FT_Bool          result;
    210 
    211 
    212     if ( list_changed )
    213       *list_changed = FALSE;
    214     result = FT_BOOL( family->attrs.scaler.face_id == face_id );
    215     if ( result )
    216     {
    217       /* we must call this function to avoid this node from appearing
    218        * in later lookups with the same face_id!
    219        */
    220       FTC_GNode_UnselectFamily( gnode, cache );
    221     }
    222     return result;
    223   }
    224 
    225 
    226  /*
    227   *
    228   * basic image cache
    229   *
    230   */
    231 
    232   FT_CALLBACK_TABLE_DEF
    233   const FTC_IFamilyClassRec  ftc_basic_image_family_class =
    234   {
    235     {
    236       sizeof ( FTC_BasicFamilyRec ),
    237       ftc_basic_family_compare,
    238       ftc_basic_family_init,
    239       0,                        /* FTC_MruNode_ResetFunc */
    240       0                         /* FTC_MruNode_DoneFunc  */
    241     },
    242     ftc_basic_family_load_glyph
    243   };
    244 
    245 
    246   FT_CALLBACK_TABLE_DEF
    247   const FTC_GCacheClassRec  ftc_basic_image_cache_class =
    248   {
    249     {
    250       ftc_inode_new,
    251       ftc_inode_weight,
    252       ftc_gnode_compare,
    253       ftc_basic_gnode_compare_faceid,
    254       ftc_inode_free,
    255 
    256       sizeof ( FTC_GCacheRec ),
    257       ftc_gcache_init,
    258       ftc_gcache_done
    259     },
    260     (FTC_MruListClass)&ftc_basic_image_family_class
    261   };
    262 
    263 
    264   /* documentation is in ftcache.h */
    265 
    266   FT_EXPORT_DEF( FT_Error )
    267   FTC_ImageCache_New( FTC_Manager      manager,
    268                       FTC_ImageCache  *acache )
    269   {
    270     return FTC_GCache_New( manager, &ftc_basic_image_cache_class,
    271                            (FTC_GCache*)acache );
    272   }
    273 
    274 
    275   /* documentation is in ftcache.h */
    276 
    277   FT_EXPORT_DEF( FT_Error )
    278   FTC_ImageCache_Lookup( FTC_ImageCache  cache,
    279                          FTC_ImageType   type,
    280                          FT_UInt         gindex,
    281                          FT_Glyph       *aglyph,
    282                          FTC_Node       *anode )
    283   {
    284     FTC_BasicQueryRec  query;
    285     FTC_Node           node = 0; /* make compiler happy */
    286     FT_Error           error;
    287     FT_PtrDist         hash;
    288 
    289 
    290     /* some argument checks are delayed to FTC_Cache_Lookup */
    291     if ( !aglyph )
    292     {
    293       error = FT_THROW( Invalid_Argument );
    294       goto Exit;
    295     }
    296 
    297     *aglyph = NULL;
    298     if ( anode )
    299       *anode  = NULL;
    300 
    301     {
    302       if ( (FT_ULong)(type->flags - FT_INT_MIN) > FT_UINT_MAX )
    303       {
    304         FT_TRACE1(( "FTC_ImageCache_Lookup: higher bits in load_flags" ));
    305         FT_TRACE1(( "0x%x are dropped\n", (type->flags & ~((FT_ULong)FT_UINT_MAX)) ));
    306       }
    307 
    308       query.attrs.scaler.face_id = type->face_id;
    309       query.attrs.scaler.width   = type->width;
    310       query.attrs.scaler.height  = type->height;
    311       query.attrs.load_flags     = (FT_UInt)type->flags;
    312     }
    313 
    314     query.attrs.scaler.pixel = 1;
    315     query.attrs.scaler.x_res = 0;  /* make compilers happy */
    316     query.attrs.scaler.y_res = 0;
    317 
    318     hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex;
    319 
    320 #if 1  /* inlining is about 50% faster! */
    321     FTC_GCACHE_LOOKUP_CMP( cache,
    322                            ftc_basic_family_compare,
    323                            FTC_GNode_Compare,
    324                            hash, gindex,
    325                            &query,
    326                            node,
    327                            error );
    328 #else
    329     error = FTC_GCache_Lookup( FTC_GCACHE( cache ),
    330                                hash, gindex,
    331                                FTC_GQUERY( &query ),
    332                                &node );
    333 #endif
    334     if ( !error )
    335     {
    336       *aglyph = FTC_INODE( node )->glyph;
    337 
    338       if ( anode )
    339       {
    340         *anode = node;
    341         node->ref_count++;
    342       }
    343     }
    344 
    345   Exit:
    346     return error;
    347   }
    348 
    349 
    350   /* documentation is in ftcache.h */
    351 
    352   FT_EXPORT_DEF( FT_Error )
    353   FTC_ImageCache_LookupScaler( FTC_ImageCache  cache,
    354                                FTC_Scaler      scaler,
    355                                FT_ULong        load_flags,
    356                                FT_UInt         gindex,
    357                                FT_Glyph       *aglyph,
    358                                FTC_Node       *anode )
    359   {
    360     FTC_BasicQueryRec  query;
    361     FTC_Node           node = 0; /* make compiler happy */
    362     FT_Error           error;
    363     FT_PtrDist         hash;
    364 
    365 
    366     /* some argument checks are delayed to FTC_Cache_Lookup */
    367     if ( !aglyph || !scaler )
    368     {
    369       error = FT_THROW( Invalid_Argument );
    370       goto Exit;
    371     }
    372 
    373     *aglyph = NULL;
    374     if ( anode )
    375       *anode  = NULL;
    376 
    377     /* FT_Load_Glyph(), FT_Load_Char() take FT_UInt flags */
    378     if ( load_flags > FT_UINT_MAX )
    379     {
    380       FT_TRACE1(( "FTC_ImageCache_LookupScaler: higher bits in load_flags" ));
    381       FT_TRACE1(( "0x%x are dropped\n", (load_flags & ~((FT_ULong)FT_UINT_MAX)) ));
    382     }
    383 
    384     query.attrs.scaler     = scaler[0];
    385     query.attrs.load_flags = (FT_UInt)load_flags;
    386 
    387     hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex;
    388 
    389     FTC_GCACHE_LOOKUP_CMP( cache,
    390                            ftc_basic_family_compare,
    391                            FTC_GNode_Compare,
    392                            hash, gindex,
    393                            &query,
    394                            node,
    395                            error );
    396     if ( !error )
    397     {
    398       *aglyph = FTC_INODE( node )->glyph;
    399 
    400       if ( anode )
    401       {
    402         *anode = node;
    403         node->ref_count++;
    404       }
    405     }
    406 
    407   Exit:
    408     return error;
    409   }
    410 
    411 
    412   /*
    413    *
    414    * basic small bitmap cache
    415    *
    416    */
    417 
    418   FT_CALLBACK_TABLE_DEF
    419   const FTC_SFamilyClassRec  ftc_basic_sbit_family_class =
    420   {
    421     {
    422       sizeof ( FTC_BasicFamilyRec ),
    423       ftc_basic_family_compare,
    424       ftc_basic_family_init,
    425       0,                            /* FTC_MruNode_ResetFunc */
    426       0                             /* FTC_MruNode_DoneFunc  */
    427     },
    428     ftc_basic_family_get_count,
    429     ftc_basic_family_load_bitmap
    430   };
    431 
    432 
    433   FT_CALLBACK_TABLE_DEF
    434   const FTC_GCacheClassRec  ftc_basic_sbit_cache_class =
    435   {
    436     {
    437       ftc_snode_new,
    438       ftc_snode_weight,
    439       ftc_snode_compare,
    440       ftc_basic_gnode_compare_faceid,
    441       ftc_snode_free,
    442 
    443       sizeof ( FTC_GCacheRec ),
    444       ftc_gcache_init,
    445       ftc_gcache_done
    446     },
    447     (FTC_MruListClass)&ftc_basic_sbit_family_class
    448   };
    449 
    450 
    451   /* documentation is in ftcache.h */
    452 
    453   FT_EXPORT_DEF( FT_Error )
    454   FTC_SBitCache_New( FTC_Manager     manager,
    455                      FTC_SBitCache  *acache )
    456   {
    457     return FTC_GCache_New( manager, &ftc_basic_sbit_cache_class,
    458                            (FTC_GCache*)acache );
    459   }
    460 
    461 
    462   /* documentation is in ftcache.h */
    463 
    464   FT_EXPORT_DEF( FT_Error )
    465   FTC_SBitCache_Lookup( FTC_SBitCache  cache,
    466                         FTC_ImageType  type,
    467                         FT_UInt        gindex,
    468                         FTC_SBit      *ansbit,
    469                         FTC_Node      *anode )
    470   {
    471     FT_Error           error;
    472     FTC_BasicQueryRec  query;
    473     FTC_Node           node = 0; /* make compiler happy */
    474     FT_PtrDist         hash;
    475 
    476 
    477     if ( anode )
    478       *anode = NULL;
    479 
    480     /* other argument checks delayed to FTC_Cache_Lookup */
    481     if ( !ansbit )
    482       return FT_THROW( Invalid_Argument );
    483 
    484     *ansbit = NULL;
    485 
    486     {
    487       if ( (FT_ULong)(type->flags - FT_INT_MIN) > FT_UINT_MAX )
    488       {
    489         FT_TRACE1(( "FTC_ImageCache_Lookup: higher bits in load_flags" ));
    490         FT_TRACE1(( "0x%x are dropped\n", (type->flags & ~((FT_ULong)FT_UINT_MAX)) ));
    491       }
    492 
    493       query.attrs.scaler.face_id = type->face_id;
    494       query.attrs.scaler.width   = type->width;
    495       query.attrs.scaler.height  = type->height;
    496       query.attrs.load_flags     = (FT_UInt)type->flags;
    497     }
    498 
    499     query.attrs.scaler.pixel = 1;
    500     query.attrs.scaler.x_res = 0;  /* make compilers happy */
    501     query.attrs.scaler.y_res = 0;
    502 
    503     /* beware, the hash must be the same for all glyph ranges! */
    504     hash = FTC_BASIC_ATTR_HASH( &query.attrs ) +
    505            gindex / FTC_SBIT_ITEMS_PER_NODE;
    506 
    507 #if 1  /* inlining is about 50% faster! */
    508     FTC_GCACHE_LOOKUP_CMP( cache,
    509                            ftc_basic_family_compare,
    510                            FTC_SNode_Compare,
    511                            hash, gindex,
    512                            &query,
    513                            node,
    514                            error );
    515 #else
    516     error = FTC_GCache_Lookup( FTC_GCACHE( cache ),
    517                                hash,
    518                                gindex,
    519                                FTC_GQUERY( &query ),
    520                                &node );
    521 #endif
    522     if ( error )
    523       goto Exit;
    524 
    525     *ansbit = FTC_SNODE( node )->sbits +
    526               ( gindex - FTC_GNODE( node )->gindex );
    527 
    528     if ( anode )
    529     {
    530       *anode = node;
    531       node->ref_count++;
    532     }
    533 
    534   Exit:
    535     return error;
    536   }
    537 
    538 
    539   /* documentation is in ftcache.h */
    540 
    541   FT_EXPORT_DEF( FT_Error )
    542   FTC_SBitCache_LookupScaler( FTC_SBitCache  cache,
    543                               FTC_Scaler     scaler,
    544                               FT_ULong       load_flags,
    545                               FT_UInt        gindex,
    546                               FTC_SBit      *ansbit,
    547                               FTC_Node      *anode )
    548   {
    549     FT_Error           error;
    550     FTC_BasicQueryRec  query;
    551     FTC_Node           node = 0; /* make compiler happy */
    552     FT_PtrDist         hash;
    553 
    554 
    555     if ( anode )
    556         *anode = NULL;
    557 
    558     /* other argument checks delayed to FTC_Cache_Lookup */
    559     if ( !ansbit || !scaler )
    560         return FT_THROW( Invalid_Argument );
    561 
    562     *ansbit = NULL;
    563 
    564     /* FT_Load_Glyph(), FT_Load_Char() take FT_UInt flags */
    565     if ( load_flags > FT_UINT_MAX )
    566     {
    567       FT_TRACE1(( "FTC_ImageCache_LookupScaler: higher bits in load_flags" ));
    568       FT_TRACE1(( "0x%x are dropped\n", (load_flags & ~((FT_ULong)FT_UINT_MAX)) ));
    569     }
    570 
    571     query.attrs.scaler     = scaler[0];
    572     query.attrs.load_flags = (FT_UInt)load_flags;
    573 
    574     /* beware, the hash must be the same for all glyph ranges! */
    575     hash = FTC_BASIC_ATTR_HASH( &query.attrs ) +
    576              gindex / FTC_SBIT_ITEMS_PER_NODE;
    577 
    578     FTC_GCACHE_LOOKUP_CMP( cache,
    579                            ftc_basic_family_compare,
    580                            FTC_SNode_Compare,
    581                            hash, gindex,
    582                            &query,
    583                            node,
    584                            error );
    585     if ( error )
    586       goto Exit;
    587 
    588     *ansbit = FTC_SNODE( node )->sbits +
    589               ( gindex - FTC_GNODE( node )->gindex );
    590 
    591     if ( anode )
    592     {
    593       *anode = node;
    594       node->ref_count++;
    595     }
    596 
    597   Exit:
    598     return error;
    599   }
    600 
    601 
    602 /* END */
    603