src/cache/ftcbasic.c

   1 /****************************************************************************
   2  *
   3  * ftcbasic.c
   4  *
   5  *   The FreeType basic cache interface (body).
   6  *
   7  * Copyright (C) 2003-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/internal/ftobjs.h>
  20 #include <freetype/internal/ftdebug.h>
  21 #include <freetype/ftcache.h>
  22 #include "ftcglyph.h"
  23 #include "ftcimage.h"
  24 #include "ftcsbits.h"
  25
  26 #include "ftccback.h"
  27 #include "ftcerror.h"
  28
  29 #undef  FT_COMPONENT
  30 #define FT_COMPONENT  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 #ifdef FT_DEBUG_LEVEL_TRACE
 113     if ( (FT_ULong)face->num_glyphs > FT_UINT_MAX || 0 > face->num_glyphs )
 114     {
 115       FT_TRACE1(( "ftc_basic_family_get_count:"
 116                   " the number of glyphs in this face is %ld,\n",
 117                   face->num_glyphs ));
 118       FT_TRACE1(( "                           "
 119                   " which is too much and thus truncated\n" ));
 120     }
 121 #endif
 122
 123     result = (FT_UInt)face->num_glyphs;
 124
 125     return result;
 126   }
 127
 128
 129   FT_CALLBACK_DEF( FT_Error )
 130   ftc_basic_family_load_bitmap( FTC_Family   ftcfamily,
 131                                 FT_UInt      gindex,
 132                                 FTC_Manager  manager,
 133                                 FT_Face     *aface )
 134   {
 135     FTC_BasicFamily  family = (FTC_BasicFamily)ftcfamily;
 136     FT_Error         error;
 137     FT_Size          size;
 138
 139
 140     error = FTC_Manager_LookupSize( manager, &family->attrs.scaler, &size );
 141     if ( !error )
 142     {
 143       FT_Face  face = size->face;
 144
 145
 146       error = FT_Load_Glyph(
 147                 face,
 148                 gindex,
 149                 (FT_Int)family->attrs.load_flags | FT_LOAD_RENDER );
 150       if ( !error )
 151         *aface = face;
 152     }
 153
 154     return error;
 155   }
 156
 157
 158   FT_CALLBACK_DEF( FT_Error )
 159   ftc_basic_family_load_glyph( FTC_Family  ftcfamily,
 160                                FT_UInt     gindex,
 161                                FTC_Cache   cache,
 162                                FT_Glyph   *aglyph )
 163   {
 164     FTC_BasicFamily  family = (FTC_BasicFamily)ftcfamily;
 165     FT_Error         error;
 166     FTC_Scaler       scaler = &family->attrs.scaler;
 167     FT_Face          face;
 168     FT_Size          size;
 169
 170
 171     /* we will now load the glyph image */
 172     error = FTC_Manager_LookupSize( cache->manager,
 173                                     scaler,
 174                                     &size );
 175     if ( !error )
 176     {
 177       face = size->face;
 178
 179       error = FT_Load_Glyph( face,
 180                              gindex,
 181                              (FT_Int)family->attrs.load_flags );
 182       if ( !error )
 183       {
 184         if ( face->glyph->format == FT_GLYPH_FORMAT_BITMAP  ||
 185              face->glyph->format == FT_GLYPH_FORMAT_OUTLINE ||
 186              face->glyph->format == FT_GLYPH_FORMAT_SVG     )
 187         {
 188           /* ok, copy it */
 189           FT_Glyph  glyph;
 190
 191
 192           error = FT_Get_Glyph( face->glyph, &glyph );
 193           if ( !error )
 194           {
 195             *aglyph = glyph;
 196             goto Exit;
 197           }
 198         }
 199         else
 200           error = FT_THROW( Invalid_Argument );
 201       }
 202     }
 203
 204   Exit:
 205     return error;
 206   }
 207
 208
 209   FT_CALLBACK_DEF( FT_Bool )
 210   ftc_basic_gnode_compare_faceid( FTC_Node    ftcgnode,
 211                                   FT_Pointer  ftcface_id,
 212                                   FTC_Cache   cache,
 213                                   FT_Bool*    list_changed )
 214   {
 215     FTC_GNode        gnode   = (FTC_GNode)ftcgnode;
 216     FTC_FaceID       face_id = (FTC_FaceID)ftcface_id;
 217     FTC_BasicFamily  family  = (FTC_BasicFamily)gnode->family;
 218     FT_Bool          result;
 219
 220
 221     if ( list_changed )
 222       *list_changed = FALSE;
 223     result = FT_BOOL( family->attrs.scaler.face_id == face_id );
 224     if ( result )
 225     {
 226       /* we must call this function to avoid this node from appearing
 227        * in later lookups with the same face_id!
 228        */
 229       FTC_GNode_UnselectFamily( gnode, cache );
 230     }
 231     return result;
 232   }
 233
 234
 235  /*
 236   *
 237   * basic image cache
 238   *
 239   */
 240
 241   static
 242   const FTC_IFamilyClassRec  ftc_basic_image_family_class =
 243   {
 244     {
 245       sizeof ( FTC_BasicFamilyRec ),
 246
 247       ftc_basic_family_compare, /* FTC_MruNode_CompareFunc  node_compare */
 248       ftc_basic_family_init,    /* FTC_MruNode_InitFunc     node_init    */
 249       NULL,                     /* FTC_MruNode_ResetFunc    node_reset   */
 250       NULL                      /* FTC_MruNode_DoneFunc     node_done    */
 251     },
 252
 253     ftc_basic_family_load_glyph /* FTC_IFamily_LoadGlyphFunc  family_load_glyph */
 254   };
 255
 256
 257   static
 258   const FTC_GCacheClassRec  ftc_basic_image_cache_class =
 259   {
 260     {
 261       ftc_inode_new,                  /* FTC_Node_NewFunc      node_new           */
 262       ftc_inode_weight,               /* FTC_Node_WeightFunc   node_weight        */
 263       ftc_gnode_compare,              /* FTC_Node_CompareFunc  node_compare       */
 264       ftc_basic_gnode_compare_faceid, /* FTC_Node_CompareFunc  node_remove_faceid */
 265       ftc_inode_free,                 /* FTC_Node_FreeFunc     node_free          */
 266
 267       sizeof ( FTC_GCacheRec ),
 268       ftc_gcache_init,                /* FTC_Cache_InitFunc    cache_init         */
 269       ftc_gcache_done                 /* FTC_Cache_DoneFunc    cache_done         */
 270     },
 271
 272     (FTC_MruListClass)&ftc_basic_image_family_class
 273   };
 274
 275
 276   /* documentation is in ftcache.h */
 277
 278   FT_EXPORT_DEF( FT_Error )
 279   FTC_ImageCache_New( FTC_Manager      manager,
 280                       FTC_ImageCache  *acache )
 281   {
 282     return FTC_GCache_New( manager, &ftc_basic_image_cache_class,
 283                            (FTC_GCache*)acache );
 284   }
 285
 286
 287   /* documentation is in ftcache.h */
 288
 289   FT_EXPORT_DEF( FT_Error )
 290   FTC_ImageCache_Lookup( FTC_ImageCache  cache,
 291                          FTC_ImageType   type,
 292                          FT_UInt         gindex,
 293                          FT_Glyph       *aglyph,
 294                          FTC_Node       *anode )
 295   {
 296     FTC_BasicQueryRec  query;
 297     FTC_Node           node = 0; /* make compiler happy */
 298     FT_Error           error;
 299     FT_Offset          hash;
 300
 301
 302     /* some argument checks are delayed to `FTC_Cache_Lookup' */
 303     if ( !aglyph )
 304     {
 305       error = FT_THROW( Invalid_Argument );
 306       goto Exit;
 307     }
 308
 309     *aglyph = NULL;
 310     if ( anode )
 311       *anode  = NULL;
 312
 313     /*
 314      * Internal `FTC_BasicAttr->load_flags' is of type `FT_UInt',
 315      * but public `FT_ImageType->flags' is of type `FT_Int32'.
 316      *
 317      * On 16bit systems, higher bits of type->flags cannot be handled.
 318      */
 319 #if 0xFFFFFFFFUL > FT_UINT_MAX
 320     if ( (type->flags & (FT_ULong)FT_UINT_MAX) )
 321       FT_TRACE1(( "FTC_ImageCache_Lookup:"
 322                   " higher bits in load_flags 0x%lx are dropped\n",
 323                   (FT_ULong)type->flags & ~((FT_ULong)FT_UINT_MAX) ));
 324 #endif
 325
 326     query.attrs.scaler.face_id = type->face_id;
 327     query.attrs.scaler.width   = type->width;
 328     query.attrs.scaler.height  = type->height;
 329     query.attrs.load_flags     = (FT_UInt)type->flags;
 330
 331     query.attrs.scaler.pixel = 1;
 332     query.attrs.scaler.x_res = 0;  /* make compilers happy */
 333     query.attrs.scaler.y_res = 0;
 334
 335     hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex;
 336
 337 #if 1  /* inlining is about 50% faster! */
 338     FTC_GCACHE_LOOKUP_CMP( cache,
 339                            ftc_basic_family_compare,
 340                            ftc_gnode_compare,
 341                            hash, gindex,
 342                            &query,
 343                            node,
 344                            error );
 345 #else
 346     error = FTC_GCache_Lookup( FTC_GCACHE( cache ),
 347                                hash, gindex,
 348                                FTC_GQUERY( &query ),
 349                                &node );
 350 #endif
 351     if ( !error )
 352     {
 353       *aglyph = FTC_INODE( node )->glyph;
 354
 355       if ( anode )
 356       {
 357         *anode = node;
 358         node->ref_count++;
 359       }
 360     }
 361
 362   Exit:
 363     return error;
 364   }
 365
 366
 367   /* documentation is in ftcache.h */
 368
 369   FT_EXPORT_DEF( FT_Error )
 370   FTC_ImageCache_LookupScaler( FTC_ImageCache  cache,
 371                                FTC_Scaler      scaler,
 372                                FT_ULong        load_flags,
 373                                FT_UInt         gindex,
 374                                FT_Glyph       *aglyph,
 375                                FTC_Node       *anode )
 376   {
 377     FTC_BasicQueryRec  query;
 378     FTC_Node           node = 0; /* make compiler happy */
 379     FT_Error           error;
 380     FT_Offset          hash;
 381
 382
 383     /* some argument checks are delayed to `FTC_Cache_Lookup' */
 384     if ( !aglyph || !scaler )
 385     {
 386       error = FT_THROW( Invalid_Argument );
 387       goto Exit;
 388     }
 389
 390     *aglyph = NULL;
 391     if ( anode )
 392       *anode  = NULL;
 393
 394     /*
 395      * Internal `FTC_BasicAttr->load_flags' is of type `FT_UInt',
 396      * but public `FT_Face->face_flags' is of type `FT_Long'.
 397      *
 398      * On long > int systems, higher bits of load_flags cannot be handled.
 399      */
 400 #if FT_ULONG_MAX > FT_UINT_MAX
 401     if ( load_flags > FT_UINT_MAX )
 402       FT_TRACE1(( "FTC_ImageCache_LookupScaler:"
 403                   " higher bits in load_flags 0x%lx are dropped\n",
 404                   load_flags & ~((FT_ULong)FT_UINT_MAX) ));
 405 #endif
 406
 407     query.attrs.scaler     = scaler[0];
 408     query.attrs.load_flags = (FT_UInt)load_flags;
 409
 410     hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex;
 411
 412     FTC_GCACHE_LOOKUP_CMP( cache,
 413                            ftc_basic_family_compare,
 414                            ftc_gnode_compare,
 415                            hash, gindex,
 416                            &query,
 417                            node,
 418                            error );
 419     if ( !error )
 420     {
 421       *aglyph = FTC_INODE( node )->glyph;
 422
 423       if ( anode )
 424       {
 425         *anode = node;
 426         node->ref_count++;
 427       }
 428     }
 429
 430   Exit:
 431     return error;
 432   }
 433
 434
 435   /*
 436    *
 437    * basic small bitmap cache
 438    *
 439    */
 440
 441   static
 442   const FTC_SFamilyClassRec  ftc_basic_sbit_family_class =
 443   {
 444     {
 445       sizeof ( FTC_BasicFamilyRec ),
 446       ftc_basic_family_compare,     /* FTC_MruNode_CompareFunc  node_compare */
 447       ftc_basic_family_init,        /* FTC_MruNode_InitFunc     node_init    */
 448       NULL,                         /* FTC_MruNode_ResetFunc    node_reset   */
 449       NULL                          /* FTC_MruNode_DoneFunc     node_done    */
 450     },
 451
 452     ftc_basic_family_get_count,
 453     ftc_basic_family_load_bitmap
 454   };
 455
 456
 457   static
 458   const FTC_GCacheClassRec  ftc_basic_sbit_cache_class =
 459   {
 460     {
 461       ftc_snode_new,                  /* FTC_Node_NewFunc      node_new           */
 462       ftc_snode_weight,               /* FTC_Node_WeightFunc   node_weight        */
 463       ftc_snode_compare,              /* FTC_Node_CompareFunc  node_compare       */
 464       ftc_basic_gnode_compare_faceid, /* FTC_Node_CompareFunc  node_remove_faceid */
 465       ftc_snode_free,                 /* FTC_Node_FreeFunc     node_free          */
 466
 467       sizeof ( FTC_GCacheRec ),
 468       ftc_gcache_init,                /* FTC_Cache_InitFunc    cache_init         */
 469       ftc_gcache_done                 /* FTC_Cache_DoneFunc    cache_done         */
 470     },
 471
 472     (FTC_MruListClass)&ftc_basic_sbit_family_class
 473   };
 474
 475
 476   /* documentation is in ftcache.h */
 477
 478   FT_EXPORT_DEF( FT_Error )
 479   FTC_SBitCache_New( FTC_Manager     manager,
 480                      FTC_SBitCache  *acache )
 481   {
 482     return FTC_GCache_New( manager, &ftc_basic_sbit_cache_class,
 483                            (FTC_GCache*)acache );
 484   }
 485
 486
 487   /* documentation is in ftcache.h */
 488
 489   FT_EXPORT_DEF( FT_Error )
 490   FTC_SBitCache_Lookup( FTC_SBitCache  cache,
 491                         FTC_ImageType  type,
 492                         FT_UInt        gindex,
 493                         FTC_SBit      *ansbit,
 494                         FTC_Node      *anode )
 495   {
 496     FT_Error           error;
 497     FTC_BasicQueryRec  query;
 498     FTC_Node           node = 0; /* make compiler happy */
 499     FT_Offset          hash;
 500
 501
 502     if ( anode )
 503       *anode = NULL;
 504
 505     /* other argument checks delayed to `FTC_Cache_Lookup' */
 506     if ( !ansbit )
 507       return FT_THROW( Invalid_Argument );
 508
 509     *ansbit = NULL;
 510
 511     /*
 512      * Internal `FTC_BasicAttr->load_flags' is of type `FT_UInt',
 513      * but public `FT_ImageType->flags' is of type `FT_Int32'.
 514      *
 515      * On 16bit systems, higher bits of type->flags cannot be handled.
 516      */
 517 #if 0xFFFFFFFFUL > FT_UINT_MAX
 518     if ( (type->flags & (FT_ULong)FT_UINT_MAX) )
 519       FT_TRACE1(( "FTC_ImageCache_Lookup:"
 520                   " higher bits in load_flags 0x%lx are dropped\n",
 521                   (FT_ULong)type->flags & ~((FT_ULong)FT_UINT_MAX) ));
 522 #endif
 523
 524     query.attrs.scaler.face_id = type->face_id;
 525     query.attrs.scaler.width   = type->width;
 526     query.attrs.scaler.height  = type->height;
 527     query.attrs.load_flags     = (FT_UInt)type->flags;
 528
 529     query.attrs.scaler.pixel = 1;
 530     query.attrs.scaler.x_res = 0;  /* make compilers happy */
 531     query.attrs.scaler.y_res = 0;
 532
 533     /* beware, the hash must be the same for all glyph ranges! */
 534     hash = FTC_BASIC_ATTR_HASH( &query.attrs ) +
 535            gindex / FTC_SBIT_ITEMS_PER_NODE;
 536
 537 #if 1  /* inlining is about 50% faster! */
 538     FTC_GCACHE_LOOKUP_CMP( cache,
 539                            ftc_basic_family_compare,
 540                            ftc_snode_compare,
 541                            hash, gindex,
 542                            &query,
 543                            node,
 544                            error );
 545 #else
 546     error = FTC_GCache_Lookup( FTC_GCACHE( cache ),
 547                                hash,
 548                                gindex,
 549                                FTC_GQUERY( &query ),
 550                                &node );
 551 #endif
 552     if ( error )
 553       goto Exit;
 554
 555     *ansbit = FTC_SNODE( node )->sbits +
 556               ( gindex - FTC_GNODE( node )->gindex );
 557
 558     if ( anode )
 559     {
 560       *anode = node;
 561       node->ref_count++;
 562     }
 563
 564   Exit:
 565     return error;
 566   }
 567
 568
 569   /* documentation is in ftcache.h */
 570
 571   FT_EXPORT_DEF( FT_Error )
 572   FTC_SBitCache_LookupScaler( FTC_SBitCache  cache,
 573                               FTC_Scaler     scaler,
 574                               FT_ULong       load_flags,
 575                               FT_UInt        gindex,
 576                               FTC_SBit      *ansbit,
 577                               FTC_Node      *anode )
 578   {
 579     FT_Error           error;
 580     FTC_BasicQueryRec  query;
 581     FTC_Node           node = 0; /* make compiler happy */
 582     FT_Offset          hash;
 583
 584
 585     if ( anode )
 586         *anode = NULL;
 587
 588     /* other argument checks delayed to `FTC_Cache_Lookup' */
 589     if ( !ansbit || !scaler )
 590         return FT_THROW( Invalid_Argument );
 591
 592     *ansbit = NULL;
 593
 594     /*
 595      * Internal `FTC_BasicAttr->load_flags' is of type `FT_UInt',
 596      * but public `FT_Face->face_flags' is of type `FT_Long'.
 597      *
 598      * On long > int systems, higher bits of load_flags cannot be handled.
 599      */
 600 #if FT_ULONG_MAX > FT_UINT_MAX
 601     if ( load_flags > FT_UINT_MAX )
 602       FT_TRACE1(( "FTC_ImageCache_LookupScaler:"
 603                   " higher bits in load_flags 0x%lx are dropped\n",
 604                   load_flags & ~((FT_ULong)FT_UINT_MAX) ));
 605 #endif
 606
 607     query.attrs.scaler     = scaler[0];
 608     query.attrs.load_flags = (FT_UInt)load_flags;
 609
 610     /* beware, the hash must be the same for all glyph ranges! */
 611     hash = FTC_BASIC_ATTR_HASH( &query.attrs ) +
 612              gindex / FTC_SBIT_ITEMS_PER_NODE;
 613
 614     FTC_GCACHE_LOOKUP_CMP( cache,
 615                            ftc_basic_family_compare,
 616                            ftc_snode_compare,
 617                            hash, gindex,
 618                            &query,
 619                            node,
 620                            error );
 621     if ( error )
 622       goto Exit;
 623
 624     *ansbit = FTC_SNODE( node )->sbits +
 625               ( gindex - FTC_GNODE( node )->gindex );
 626
 627     if ( anode )
 628     {
 629       *anode = node;
 630       node->ref_count++;
 631     }
 632
 633   Exit:
 634     return error;
 635   }
 636
 637
 638 /* END */