← Back to branch summary

~ubuntu-branches/ubuntu/wily/hedgewars/wily

« back to all changes in this revision

Viewing changes to misc/libfreetype/src/cache/ftcbasic.c

  • Committer: Package Import Robot
  • Author(s): Dmitry E. Oboukhov
  • Date: 2011-09-23 10:16:55 UTC
  • mfrom: (1.2.11 upstream)
  • Revision ID: package-import@ubuntu.com-20110923101655-3977th2gc5n0a3pv
Tags: 0.9.16-1
* New upstream version.
 + Downloadable content! Simply click to install any content.
   New voices, hats, maps, themes, translations, music, scripts...
   Hedgewars is now more customisable than ever before! As time goes
   by we will be soliciting community content to feature on this page,
   so remember to check it from time to time. If you decide you want
   to go back to standard Hedgewars, just remove the Data directory
   from your Hedgewars config directory.
 + 3-D rendering! Diorama-like rendering of the game in a variety
   of 3D modes. Let us know which ones work best for you, we didn't
   really have the equipment to test them all.
 + Resizable game window.
 + New utilities! The Time Box will remove one of your hedgehogs
   from the game for a while, protecting from attack until it returns,
   somewhere else on the map. Land spray will allow you to build bridges,
   seal up holes, or just make life unpleasant for your enemies.
 + New single player: Bamboo Thicket, That Sinking Feeling, Newton and
   the Tree and multi-player: The Specialists, Space Invaders,
   Racer - scripts! And a ton more script hooks for scripters
 + New twists on old weapons. Drill strike, seduction and fire have
   been adjusted. Defective mines have been added, rope can attach to
   hogs/crates/barrels again, grenades now have variable bounce (use
   precise key + 1-5). Portal gun is now more usable in flight and
   all game actions are a lot faster.
 + New theme - Golf, dozens of new community hats and a new
   localised Default voice, Ukranian.

Show diffs side-by-side

added added

removed removed

Lines of Context:
misc/libfreetype/src/cache/ftcbasic.c
 
1
/***************************************************************************/
 
2
/*                                                                         */
 
3
/*  ftcbasic.c                                                             */
 
4
/*                                                                         */
 
5
/*    The FreeType basic cache interface (body).                           */
 
6
/*                                                                         */
 
7
/*  Copyright 2003, 2004, 2005, 2006, 2007, 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_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
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
 
34
 
 
35
  /*
 
36
   *  These structures correspond to the FTC_Font and FTC_ImageDesc types
 
37
   *  that were defined in version 2.1.7.
 
38
   */
 
39
  typedef struct  FTC_OldFontRec_
 
40
  {
 
41
    FTC_FaceID  face_id;
 
42
    FT_UShort   pix_width;
 
43
    FT_UShort   pix_height;
 
44
 
 
45
  } FTC_OldFontRec, *FTC_OldFont;
 
46
 
 
47
 
 
48
  typedef struct  FTC_OldImageDescRec_
 
49
  {
 
50
    FTC_OldFontRec  font;
 
51
    FT_UInt32       flags;
 
52
 
 
53
  } FTC_OldImageDescRec, *FTC_OldImageDesc;
 
54
 
 
55
 
 
56
  /*
 
57
   *  Notice that FTC_OldImageDescRec and FTC_ImageTypeRec are nearly
 
58
   *  identical, bit-wise.  The only difference is that the `width' and
 
59
   *  `height' fields are expressed as 16-bit integers in the old structure,
 
60
   *  and as normal `int' in the new one.
 
61
   *
 
62
   *  We are going to perform a weird hack to detect which structure is
 
63
   *  being passed to the image and sbit caches.  If the new structure's
 
64
   *  `width' is larger than 0x10000, we assume that we are really receiving
 
65
   *  an FTC_OldImageDesc.
 
66
   */
 
67
 
 
68
#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
 
69
 
 
70
 
 
71
  /*
 
72
   *  Basic Families
 
73
   *
 
74
   */
 
75
  typedef struct  FTC_BasicAttrRec_
 
76
  {
 
77
    FTC_ScalerRec  scaler;
 
78
    FT_UInt        load_flags;
 
79
 
 
80
  } FTC_BasicAttrRec, *FTC_BasicAttrs;
 
81
 
 
82
#define FTC_BASIC_ATTR_COMPARE( a, b )                                 \
 
83
          FT_BOOL( FTC_SCALER_COMPARE( &(a)->scaler, &(b)->scaler ) && \
 
84
                   (a)->load_flags == (b)->load_flags               )
 
85
 
 
86
#define FTC_BASIC_ATTR_HASH( a )                                   \
 
87
          ( FTC_SCALER_HASH( &(a)->scaler ) + 31*(a)->load_flags )
 
88
 
 
89
 
 
90
  typedef struct  FTC_BasicQueryRec_
 
91
  {
 
92
    FTC_GQueryRec     gquery;
 
93
    FTC_BasicAttrRec  attrs;
 
94
 
 
95
  } FTC_BasicQueryRec, *FTC_BasicQuery;
 
96
 
 
97
 
 
98
  typedef struct  FTC_BasicFamilyRec_
 
99
  {
 
100
    FTC_FamilyRec     family;
 
101
    FTC_BasicAttrRec  attrs;
 
102
 
 
103
  } FTC_BasicFamilyRec, *FTC_BasicFamily;
 
104
 
 
105
 
 
106
  FT_CALLBACK_DEF( FT_Bool )
 
107
  ftc_basic_family_compare( FTC_MruNode  ftcfamily,
 
108
                            FT_Pointer   ftcquery )
 
109
  {
 
110
    FTC_BasicFamily  family = (FTC_BasicFamily)ftcfamily;
 
111
    FTC_BasicQuery   query  = (FTC_BasicQuery)ftcquery;
 
112
 
 
113
 
 
114
    return FTC_BASIC_ATTR_COMPARE( &family->attrs, &query->attrs );
 
115
  }
 
116
 
 
117
 
 
118
  FT_CALLBACK_DEF( FT_Error )
 
119
  ftc_basic_family_init( FTC_MruNode  ftcfamily,
 
120
                         FT_Pointer   ftcquery,
 
121
                         FT_Pointer   ftccache )
 
122
  {
 
123
    FTC_BasicFamily  family = (FTC_BasicFamily)ftcfamily;
 
124
    FTC_BasicQuery   query  = (FTC_BasicQuery)ftcquery;
 
125
    FTC_Cache        cache  = (FTC_Cache)ftccache;
 
126
 
 
127
 
 
128
    FTC_Family_Init( FTC_FAMILY( family ), cache );
 
129
    family->attrs = query->attrs;
 
130
    return 0;
 
131
  }
 
132
 
 
133
 
 
134
  FT_CALLBACK_DEF( FT_UInt )
 
135
  ftc_basic_family_get_count( FTC_Family   ftcfamily,
 
136
                              FTC_Manager  manager )
 
137
  {
 
138
    FTC_BasicFamily  family = (FTC_BasicFamily)ftcfamily;
 
139
    FT_Error         error;
 
140
    FT_Face          face;
 
141
    FT_UInt          result = 0;
 
142
 
 
143
 
 
144
    error = FTC_Manager_LookupFace( manager, family->attrs.scaler.face_id,
 
145
                                    &face );
 
146
 
 
147
    if ( error || !face )
 
148
      return result;
 
149
 
 
150
    if ( (FT_ULong)face->num_glyphs > FT_UINT_MAX || 0 > face->num_glyphs )
 
151
    {
 
152
      FT_TRACE1(( "ftc_basic_family_get_count: too large number of glyphs " ));
 
153
      FT_TRACE1(( "in this face, truncated\n", face->num_glyphs ));
 
154
    }
 
155
 
 
156
    if ( !error )
 
157
      result = (FT_UInt)face->num_glyphs;
 
158
 
 
159
    return result;
 
160
  }
 
161
 
 
162
 
 
163
  FT_CALLBACK_DEF( FT_Error )
 
164
  ftc_basic_family_load_bitmap( FTC_Family   ftcfamily,
 
165
                                FT_UInt      gindex,
 
166
                                FTC_Manager  manager,
 
167
                                FT_Face     *aface )
 
168
  {
 
169
    FTC_BasicFamily  family = (FTC_BasicFamily)ftcfamily;
 
170
    FT_Error         error;
 
171
    FT_Size          size;
 
172
 
 
173
 
 
174
    error = FTC_Manager_LookupSize( manager, &family->attrs.scaler, &size );
 
175
    if ( !error )
 
176
    {
 
177
      FT_Face  face = size->face;
 
178
 
 
179
 
 
180
      error = FT_Load_Glyph( face, gindex,
 
181
                             family->attrs.load_flags | FT_LOAD_RENDER );
 
182
      if ( !error )
 
183
        *aface = face;
 
184
    }
 
185
 
 
186
    return error;
 
187
  }
 
188
 
 
189
 
 
190
  FT_CALLBACK_DEF( FT_Error )
 
191
  ftc_basic_family_load_glyph( FTC_Family  ftcfamily,
 
192
                               FT_UInt     gindex,
 
193
                               FTC_Cache   cache,
 
194
                               FT_Glyph   *aglyph )
 
195
  {
 
196
    FTC_BasicFamily  family = (FTC_BasicFamily)ftcfamily;
 
197
    FT_Error         error;
 
198
    FTC_Scaler       scaler = &family->attrs.scaler;
 
199
    FT_Face          face;
 
200
    FT_Size          size;
 
201
 
 
202
 
 
203
    /* we will now load the glyph image */
 
204
    error = FTC_Manager_LookupSize( cache->manager,
 
205
                                    scaler,
 
206
                                    &size );
 
207
    if ( !error )
 
208
    {
 
209
      face = size->face;
 
210
 
 
211
      error = FT_Load_Glyph( face, gindex, family->attrs.load_flags );
 
212
      if ( !error )
 
213
      {
 
214
        if ( face->glyph->format == FT_GLYPH_FORMAT_BITMAP  ||
 
215
             face->glyph->format == FT_GLYPH_FORMAT_OUTLINE )
 
216
        {
 
217
          /* ok, copy it */
 
218
          FT_Glyph  glyph;
 
219
 
 
220
 
 
221
          error = FT_Get_Glyph( face->glyph, &glyph );
 
222
          if ( !error )
 
223
          {
 
224
            *aglyph = glyph;
 
225
            goto Exit;
 
226
          }
 
227
        }
 
228
        else
 
229
          error = FTC_Err_Invalid_Argument;
 
230
      }
 
231
    }
 
232
 
 
233
  Exit:
 
234
    return error;
 
235
  }
 
236
 
 
237
 
 
238
  FT_CALLBACK_DEF( FT_Bool )
 
239
  ftc_basic_gnode_compare_faceid( FTC_Node    ftcgnode,
 
240
                                  FT_Pointer  ftcface_id,
 
241
                                  FTC_Cache   cache,
 
242
                                  FT_Bool*    list_changed )
 
243
  {
 
244
    FTC_GNode        gnode   = (FTC_GNode)ftcgnode;
 
245
    FTC_FaceID       face_id = (FTC_FaceID)ftcface_id;
 
246
    FTC_BasicFamily  family  = (FTC_BasicFamily)gnode->family;
 
247
    FT_Bool          result;
 
248
 
 
249
 
 
250
    if ( list_changed )
 
251
      *list_changed = FALSE;
 
252
    result = FT_BOOL( family->attrs.scaler.face_id == face_id );
 
253
    if ( result )
 
254
    {
 
255
      /* we must call this function to avoid this node from appearing
 
256
       * in later lookups with the same face_id!
 
257
       */
 
258
      FTC_GNode_UnselectFamily( gnode, cache );
 
259
    }
 
260
    return result;
 
261
  }
 
262
 
 
263
 
 
264
 /*
 
265
  *
 
266
  * basic image cache
 
267
  *
 
268
  */
 
269
 
 
270
  FT_CALLBACK_TABLE_DEF
 
271
  const FTC_IFamilyClassRec  ftc_basic_image_family_class =
 
272
  {
 
273
    {
 
274
      sizeof ( FTC_BasicFamilyRec ),
 
275
      ftc_basic_family_compare,
 
276
      ftc_basic_family_init,
 
277
      0,                        /* FTC_MruNode_ResetFunc */
 
278
      0                         /* FTC_MruNode_DoneFunc  */
 
279
    },
 
280
    ftc_basic_family_load_glyph
 
281
  };
 
282
 
 
283
 
 
284
  FT_CALLBACK_TABLE_DEF
 
285
  const FTC_GCacheClassRec  ftc_basic_image_cache_class =
 
286
  {
 
287
    {
 
288
      ftc_inode_new,
 
289
      ftc_inode_weight,
 
290
      ftc_gnode_compare,
 
291
      ftc_basic_gnode_compare_faceid,
 
292
      ftc_inode_free,
 
293
 
 
294
      sizeof ( FTC_GCacheRec ),
 
295
      ftc_gcache_init,
 
296
      ftc_gcache_done
 
297
    },
 
298
    (FTC_MruListClass)&ftc_basic_image_family_class
 
299
  };
 
300
 
 
301
 
 
302
  /* documentation is in ftcache.h */
 
303
 
 
304
  FT_EXPORT_DEF( FT_Error )
 
305
  FTC_ImageCache_New( FTC_Manager      manager,
 
306
                      FTC_ImageCache  *acache )
 
307
  {
 
308
    return FTC_GCache_New( manager, &ftc_basic_image_cache_class,
 
309
                           (FTC_GCache*)acache );
 
310
  }
 
311
 
 
312
 
 
313
  /* documentation is in ftcache.h */
 
314
 
 
315
  FT_EXPORT_DEF( FT_Error )
 
316
  FTC_ImageCache_Lookup( FTC_ImageCache  cache,
 
317
                         FTC_ImageType   type,
 
318
                         FT_UInt         gindex,
 
319
                         FT_Glyph       *aglyph,
 
320
                         FTC_Node       *anode )
 
321
  {
 
322
    FTC_BasicQueryRec  query;
 
323
    FTC_Node           node = 0; /* make compiler happy */
 
324
    FT_Error           error;
 
325
    FT_PtrDist         hash;
 
326
 
 
327
 
 
328
    /* some argument checks are delayed to FTC_Cache_Lookup */
 
329
    if ( !aglyph )
 
330
    {
 
331
      error = FTC_Err_Invalid_Argument;
 
332
      goto Exit;
 
333
    }
 
334
 
 
335
    *aglyph = NULL;
 
336
    if ( anode )
 
337
      *anode  = NULL;
 
338
 
 
339
#if defined( FT_CONFIG_OPTION_OLD_INTERNALS ) && ( FT_INT_MAX > 0xFFFFU )
 
340
 
 
341
    /*
 
342
     *  This one is a major hack used to detect whether we are passed a
 
343
     *  regular FTC_ImageType handle, or a legacy FTC_OldImageDesc one.
 
344
     */
 
345
    if ( (FT_ULong)type->width >= 0x10000L )
 
346
    {
 
347
      FTC_OldImageDesc  desc = (FTC_OldImageDesc)type;
 
348
 
 
349
 
 
350
      query.attrs.scaler.face_id = desc->font.face_id;
 
351
      query.attrs.scaler.width   = desc->font.pix_width;
 
352
      query.attrs.scaler.height  = desc->font.pix_height;
 
353
      query.attrs.load_flags     = desc->flags;
 
354
    }
 
355
    else
 
356
 
 
357
#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
 
358
 
 
359
    {
 
360
      if ( (FT_ULong)(type->flags - FT_INT_MIN) > FT_UINT_MAX )
 
361
      {
 
362
        FT_TRACE1(( "FTC_ImageCache_Lookup: higher bits in load_flags" ));
 
363
        FT_TRACE1(( "0x%x are dropped\n", (type->flags & ~((FT_ULong)FT_UINT_MAX)) ));
 
364
      }
 
365
 
 
366
      query.attrs.scaler.face_id = type->face_id;
 
367
      query.attrs.scaler.width   = type->width;
 
368
      query.attrs.scaler.height  = type->height;
 
369
      query.attrs.load_flags     = (FT_UInt)type->flags;
 
370
    }
 
371
 
 
372
    query.attrs.scaler.pixel = 1;
 
373
    query.attrs.scaler.x_res = 0;  /* make compilers happy */
 
374
    query.attrs.scaler.y_res = 0;
 
375
 
 
376
    hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex;
 
377
 
 
378
#if 1  /* inlining is about 50% faster! */
 
379
    FTC_GCACHE_LOOKUP_CMP( cache,
 
380
                           ftc_basic_family_compare,
 
381
                           FTC_GNode_Compare,
 
382
                           hash, gindex,
 
383
                           &query,
 
384
                           node,
 
385
                           error );
 
386
#else
 
387
    error = FTC_GCache_Lookup( FTC_GCACHE( cache ),
 
388
                               hash, gindex,
 
389
                               FTC_GQUERY( &query ),
 
390
                               &node );
 
391
#endif
 
392
    if ( !error )
 
393
    {
 
394
      *aglyph = FTC_INODE( node )->glyph;
 
395
 
 
396
      if ( anode )
 
397
      {
 
398
        *anode = node;
 
399
        node->ref_count++;
 
400
      }
 
401
    }
 
402
 
 
403
  Exit:
 
404
    return error;
 
405
  }
 
406
 
 
407
 
 
408
  /* documentation is in ftcache.h */
 
409
 
 
410
  FT_EXPORT_DEF( FT_Error )
 
411
  FTC_ImageCache_LookupScaler( FTC_ImageCache  cache,
 
412
                               FTC_Scaler      scaler,
 
413
                               FT_ULong        load_flags,
 
414
                               FT_UInt         gindex,
 
415
                               FT_Glyph       *aglyph,
 
416
                               FTC_Node       *anode )
 
417
  {
 
418
    FTC_BasicQueryRec  query;
 
419
    FTC_Node           node = 0; /* make compiler happy */
 
420
    FT_Error           error;
 
421
    FT_PtrDist         hash;
 
422
 
 
423
 
 
424
    /* some argument checks are delayed to FTC_Cache_Lookup */
 
425
    if ( !aglyph || !scaler )
 
426
    {
 
427
      error = FTC_Err_Invalid_Argument;
 
428
      goto Exit;
 
429
    }
 
430
 
 
431
    *aglyph = NULL;
 
432
    if ( anode )
 
433
      *anode  = NULL;
 
434
 
 
435
    /* FT_Load_Glyph(), FT_Load_Char() take FT_UInt flags */
 
436
    if ( load_flags > FT_UINT_MAX )
 
437
    {
 
438
      FT_TRACE1(( "FTC_ImageCache_LookupScaler: higher bits in load_flags" ));
 
439
      FT_TRACE1(( "0x%x are dropped\n", (load_flags & ~((FT_ULong)FT_UINT_MAX)) ));
 
440
    }
 
441
 
 
442
    query.attrs.scaler     = scaler[0];
 
443
    query.attrs.load_flags = (FT_UInt)load_flags;
 
444
 
 
445
    hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex;
 
446
 
 
447
    FTC_GCACHE_LOOKUP_CMP( cache,
 
448
                           ftc_basic_family_compare,
 
449
                           FTC_GNode_Compare,
 
450
                           hash, gindex,
 
451
                           &query,
 
452
                           node,
 
453
                           error );
 
454
    if ( !error )
 
455
    {
 
456
      *aglyph = FTC_INODE( node )->glyph;
 
457
 
 
458
      if ( anode )
 
459
      {
 
460
        *anode = node;
 
461
        node->ref_count++;
 
462
      }
 
463
    }
 
464
 
 
465
  Exit:
 
466
    return error;
 
467
  }
 
468
 
 
469
 
 
470
  
 
471
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
 
472
 
 
473
  /* yet another backwards-legacy structure */
 
474
  typedef struct  FTC_OldImage_Desc_
 
475
  {
 
476
    FTC_FontRec  font;
 
477
    FT_UInt      image_type;
 
478
 
 
479
  } FTC_OldImage_Desc;
 
480
 
 
481
 
 
482
#define FTC_OLD_IMAGE_FORMAT( x )  ( (x) & 7 )
 
483
 
 
484
 
 
485
#define ftc_old_image_format_bitmap    0x0000
 
486
#define ftc_old_image_format_outline   0x0001
 
487
 
 
488
#define ftc_old_image_format_mask      0x000F
 
489
 
 
490
#define ftc_old_image_flag_monochrome  0x0010
 
491
#define ftc_old_image_flag_unhinted    0x0020
 
492
#define ftc_old_image_flag_autohinted  0x0040
 
493
#define ftc_old_image_flag_unscaled    0x0080
 
494
#define ftc_old_image_flag_no_sbits    0x0100
 
495
 
 
496
  /* monochrome bitmap */
 
497
#define ftc_old_image_mono             ftc_old_image_format_bitmap   | \
 
498
                                       ftc_old_image_flag_monochrome
 
499
 
 
500
  /* anti-aliased bitmap */
 
501
#define ftc_old_image_grays            ftc_old_image_format_bitmap
 
502
 
 
503
  /* scaled outline */
 
504
#define ftc_old_image_outline          ftc_old_image_format_outline
 
505
 
 
506
 
 
507
  static void
 
508
  ftc_image_type_from_old_desc( FTC_ImageType       typ,
 
509
                                FTC_OldImage_Desc*  desc )
 
510
  {
 
511
    typ->face_id = desc->font.face_id;
 
512
    typ->width   = desc->font.pix_width;
 
513
    typ->height  = desc->font.pix_height;
 
514
 
 
515
    /* convert image type flags to load flags */
 
516
    {
 
517
      FT_UInt  load_flags = FT_LOAD_DEFAULT;
 
518
      FT_UInt  type       = desc->image_type;
 
519
 
 
520
 
 
521
      /* determine load flags, depending on the font description's */
 
522
      /* image type                                                */
 
523
 
 
524
      if ( FTC_OLD_IMAGE_FORMAT( type ) == ftc_old_image_format_bitmap )
 
525
      {
 
526
        if ( type & ftc_old_image_flag_monochrome )
 
527
          load_flags |= FT_LOAD_MONOCHROME;
 
528
 
 
529
        /* disable embedded bitmaps loading if necessary */
 
530
        if ( type & ftc_old_image_flag_no_sbits )
 
531
          load_flags |= FT_LOAD_NO_BITMAP;
 
532
      }
 
533
      else
 
534
      {
 
535
        /* we want an outline, don't load embedded bitmaps */
 
536
        load_flags |= FT_LOAD_NO_BITMAP;
 
537
 
 
538
        if ( type & ftc_old_image_flag_unscaled )
 
539
          load_flags |= FT_LOAD_NO_SCALE;
 
540
      }
 
541
 
 
542
      /* always render glyphs to bitmaps */
 
543
      load_flags |= FT_LOAD_RENDER;
 
544
 
 
545
      if ( type & ftc_old_image_flag_unhinted )
 
546
        load_flags |= FT_LOAD_NO_HINTING;
 
547
 
 
548
      if ( type & ftc_old_image_flag_autohinted )
 
549
        load_flags |= FT_LOAD_FORCE_AUTOHINT;
 
550
 
 
551
      typ->flags = load_flags;
 
552
    }
 
553
  }
 
554
 
 
555
 
 
556
  FT_EXPORT( FT_Error )
 
557
  FTC_Image_Cache_New( FTC_Manager      manager,
 
558
                       FTC_ImageCache  *acache );
 
559
 
 
560
  FT_EXPORT( FT_Error )
 
561
  FTC_Image_Cache_Lookup( FTC_ImageCache      icache,
 
562
                          FTC_OldImage_Desc*  desc,
 
563
                          FT_UInt             gindex,
 
564
                          FT_Glyph           *aglyph );
 
565
 
 
566
 
 
567
  FT_EXPORT_DEF( FT_Error )
 
568
  FTC_Image_Cache_New( FTC_Manager      manager,
 
569
                       FTC_ImageCache  *acache )
 
570
  {
 
571
    return FTC_ImageCache_New( manager, (FTC_ImageCache*)acache );
 
572
  }
 
573
 
 
574
 
 
575
 
 
576
  FT_EXPORT_DEF( FT_Error )
 
577
  FTC_Image_Cache_Lookup( FTC_ImageCache      icache,
 
578
                          FTC_OldImage_Desc*  desc,
 
579
                          FT_UInt             gindex,
 
580
                          FT_Glyph           *aglyph )
 
581
  {
 
582
    FTC_ImageTypeRec  type0;
 
583
 
 
584
 
 
585
    if ( !desc )
 
586
      return FTC_Err_Invalid_Argument;
 
587
 
 
588
    ftc_image_type_from_old_desc( &type0, desc );
 
589
 
 
590
    return FTC_ImageCache_Lookup( (FTC_ImageCache)icache,
 
591
                                   &type0,
 
592
                                   gindex,
 
593
                                   aglyph,
 
594
                                   NULL );
 
595
  }
 
596
 
 
597
#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
 
598
 
 
599
 
 
600
 /*
 
601
  *
 
602
  * basic small bitmap cache
 
603
  *
 
604
  */
 
605
 
 
606
 
 
607
  FT_CALLBACK_TABLE_DEF
 
608
  const FTC_SFamilyClassRec  ftc_basic_sbit_family_class =
 
609
  {
 
610
    {
 
611
      sizeof( FTC_BasicFamilyRec ),
 
612
      ftc_basic_family_compare,
 
613
      ftc_basic_family_init,
 
614
      0,                            /* FTC_MruNode_ResetFunc */
 
615
      0                             /* FTC_MruNode_DoneFunc  */
 
616
    },
 
617
    ftc_basic_family_get_count,
 
618
    ftc_basic_family_load_bitmap
 
619
  };
 
620
 
 
621
 
 
622
  FT_CALLBACK_TABLE_DEF
 
623
  const FTC_GCacheClassRec  ftc_basic_sbit_cache_class =
 
624
  {
 
625
    {
 
626
      ftc_snode_new,
 
627
      ftc_snode_weight,
 
628
      ftc_snode_compare,
 
629
      ftc_basic_gnode_compare_faceid,
 
630
      ftc_snode_free,
 
631
 
 
632
      sizeof ( FTC_GCacheRec ),
 
633
      ftc_gcache_init,
 
634
      ftc_gcache_done
 
635
    },
 
636
    (FTC_MruListClass)&ftc_basic_sbit_family_class
 
637
  };
 
638
 
 
639
 
 
640
  /* documentation is in ftcache.h */
 
641
 
 
642
  FT_EXPORT_DEF( FT_Error )
 
643
  FTC_SBitCache_New( FTC_Manager     manager,
 
644
                     FTC_SBitCache  *acache )
 
645
  {
 
646
    return FTC_GCache_New( manager, &ftc_basic_sbit_cache_class,
 
647
                           (FTC_GCache*)acache );
 
648
  }
 
649
 
 
650
 
 
651
  /* documentation is in ftcache.h */
 
652
 
 
653
  FT_EXPORT_DEF( FT_Error )
 
654
  FTC_SBitCache_Lookup( FTC_SBitCache  cache,
 
655
                        FTC_ImageType  type,
 
656
                        FT_UInt        gindex,
 
657
                        FTC_SBit      *ansbit,
 
658
                        FTC_Node      *anode )
 
659
  {
 
660
    FT_Error           error;
 
661
    FTC_BasicQueryRec  query;
 
662
    FTC_Node           node = 0; /* make compiler happy */
 
663
    FT_PtrDist         hash;
 
664
 
 
665
 
 
666
    if ( anode )
 
667
      *anode = NULL;
 
668
 
 
669
    /* other argument checks delayed to FTC_Cache_Lookup */
 
670
    if ( !ansbit )
 
671
      return FTC_Err_Invalid_Argument;
 
672
 
 
673
    *ansbit = NULL;
 
674
 
 
675
#if defined( FT_CONFIG_OPTION_OLD_INTERNALS ) && ( FT_INT_MAX > 0xFFFFU )
 
676
 
 
677
    /*  This one is a major hack used to detect whether we are passed a
 
678
     *  regular FTC_ImageType handle, or a legacy FTC_OldImageDesc one.
 
679
     */
 
680
    if ( (FT_ULong)type->width >= 0x10000L )
 
681
    {
 
682
      FTC_OldImageDesc  desc = (FTC_OldImageDesc)type;
 
683
 
 
684
 
 
685
      query.attrs.scaler.face_id = desc->font.face_id;
 
686
      query.attrs.scaler.width   = desc->font.pix_width;
 
687
      query.attrs.scaler.height  = desc->font.pix_height;
 
688
      query.attrs.load_flags     = desc->flags;
 
689
    }
 
690
    else
 
691
 
 
692
#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
 
693
 
 
694
    {
 
695
      if ( (FT_ULong)(type->flags - FT_INT_MIN) > FT_UINT_MAX )
 
696
      {
 
697
        FT_TRACE1(( "FTC_ImageCache_Lookup: higher bits in load_flags" ));
 
698
        FT_TRACE1(( "0x%x are dropped\n", (type->flags & ~((FT_ULong)FT_UINT_MAX)) ));
 
699
      }
 
700
 
 
701
      query.attrs.scaler.face_id = type->face_id;
 
702
      query.attrs.scaler.width   = type->width;
 
703
      query.attrs.scaler.height  = type->height;
 
704
      query.attrs.load_flags     = (FT_UInt)type->flags;
 
705
    }
 
706
 
 
707
    query.attrs.scaler.pixel = 1;
 
708
    query.attrs.scaler.x_res = 0;  /* make compilers happy */
 
709
    query.attrs.scaler.y_res = 0;
 
710
 
 
711
    /* beware, the hash must be the same for all glyph ranges! */
 
712
    hash = FTC_BASIC_ATTR_HASH( &query.attrs ) +
 
713
           gindex / FTC_SBIT_ITEMS_PER_NODE;
 
714
 
 
715
#if 1  /* inlining is about 50% faster! */
 
716
    FTC_GCACHE_LOOKUP_CMP( cache,
 
717
                           ftc_basic_family_compare,
 
718
                           FTC_SNode_Compare,
 
719
                           hash, gindex,
 
720
                           &query,
 
721
                           node,
 
722
                           error );
 
723
#else
 
724
    error = FTC_GCache_Lookup( FTC_GCACHE( cache ),
 
725
                               hash,
 
726
                               gindex,
 
727
                               FTC_GQUERY( &query ),
 
728
                               &node );
 
729
#endif
 
730
    if ( error )
 
731
      goto Exit;
 
732
 
 
733
    *ansbit = FTC_SNODE( node )->sbits +
 
734
              ( gindex - FTC_GNODE( node )->gindex );
 
735
 
 
736
    if ( anode )
 
737
    {
 
738
      *anode = node;
 
739
      node->ref_count++;
 
740
    }
 
741
 
 
742
  Exit:
 
743
    return error;
 
744
  }
 
745
 
 
746
 
 
747
  /* documentation is in ftcache.h */
 
748
 
 
749
  FT_EXPORT_DEF( FT_Error )
 
750
  FTC_SBitCache_LookupScaler( FTC_SBitCache  cache,
 
751
                              FTC_Scaler     scaler,
 
752
                              FT_ULong       load_flags,
 
753
                              FT_UInt        gindex,
 
754
                              FTC_SBit      *ansbit,
 
755
                              FTC_Node      *anode )
 
756
  {
 
757
    FT_Error           error;
 
758
    FTC_BasicQueryRec  query;
 
759
    FTC_Node           node = 0; /* make compiler happy */
 
760
    FT_PtrDist         hash;
 
761
 
 
762
 
 
763
    if ( anode )
 
764
        *anode = NULL;
 
765
 
 
766
    /* other argument checks delayed to FTC_Cache_Lookup */
 
767
    if ( !ansbit || !scaler )
 
768
        return FTC_Err_Invalid_Argument;
 
769
 
 
770
    *ansbit = NULL;
 
771
 
 
772
    /* FT_Load_Glyph(), FT_Load_Char() take FT_UInt flags */
 
773
    if ( load_flags > FT_UINT_MAX )
 
774
    {
 
775
      FT_TRACE1(( "FTC_ImageCache_LookupScaler: higher bits in load_flags" ));
 
776
      FT_TRACE1(( "0x%x are dropped\n", (load_flags & ~((FT_ULong)FT_UINT_MAX)) ));
 
777
    }
 
778
 
 
779
    query.attrs.scaler     = scaler[0];
 
780
    query.attrs.load_flags = (FT_UInt)load_flags;
 
781
 
 
782
    /* beware, the hash must be the same for all glyph ranges! */
 
783
    hash = FTC_BASIC_ATTR_HASH( &query.attrs ) +
 
784
             gindex / FTC_SBIT_ITEMS_PER_NODE;
 
785
 
 
786
    FTC_GCACHE_LOOKUP_CMP( cache,
 
787
                           ftc_basic_family_compare,
 
788
                           FTC_SNode_Compare,
 
789
                           hash, gindex,
 
790
                           &query,
 
791
                           node,
 
792
                           error );
 
793
    if ( error )
 
794
      goto Exit;
 
795
 
 
796
    *ansbit = FTC_SNODE( node )->sbits +
 
797
              ( gindex - FTC_GNODE( node )->gindex );
 
798
 
 
799
    if ( anode )
 
800
    {
 
801
      *anode = node;
 
802
      node->ref_count++;
 
803
    }
 
804
 
 
805
  Exit:
 
806
    return error;
 
807
  }
 
808
 
 
809
 
 
810
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
 
811
 
 
812
  FT_EXPORT( FT_Error )
 
813
  FTC_SBit_Cache_New( FTC_Manager     manager,
 
814
                      FTC_SBitCache  *acache );
 
815
 
 
816
  FT_EXPORT( FT_Error )
 
817
  FTC_SBit_Cache_Lookup( FTC_SBitCache       cache,
 
818
                         FTC_OldImage_Desc*  desc,
 
819
                         FT_UInt             gindex,
 
820
                         FTC_SBit           *ansbit );
 
821
 
 
822
 
 
823
  FT_EXPORT_DEF( FT_Error )
 
824
  FTC_SBit_Cache_New( FTC_Manager     manager,
 
825
                      FTC_SBitCache  *acache )
 
826
  {
 
827
    return FTC_SBitCache_New( manager, (FTC_SBitCache*)acache );
 
828
  }
 
829
 
 
830
 
 
831
  FT_EXPORT_DEF( FT_Error )
 
832
  FTC_SBit_Cache_Lookup( FTC_SBitCache       cache,
 
833
                         FTC_OldImage_Desc*  desc,
 
834
                         FT_UInt             gindex,
 
835
                         FTC_SBit           *ansbit )
 
836
  {
 
837
    FTC_ImageTypeRec  type0;
 
838
 
 
839
 
 
840
    if ( !desc )
 
841
      return FTC_Err_Invalid_Argument;
 
842
 
 
843
    ftc_image_type_from_old_desc( &type0, desc );
 
844
 
 
845
    return FTC_SBitCache_Lookup( (FTC_SBitCache)cache,
 
846
                                  &type0,
 
847
                                  gindex,
 
848
                                  ansbit,
 
849
                                  NULL );
 
850
  }
 
851
 
 
852
#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
 
853
 
 
854
 
 
855
/* END */