← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to tests/freetype/src/cache/ftcsbits.c

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/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 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
 
 
221
 
 
222
    total = clazz->family_get_count( family, cache->manager );
 
223
    if ( total == 0 || gindex >= total )
 
224
    {
 
225
      error = FTC_Err_Invalid_Argument;
 
226
      goto Exit;
 
227
    }
 
228
 
 
229
    if ( !FT_NEW( snode ) )
 
230
    {
 
231
      FT_UInt  count, start;
 
232
 
 
233
 
 
234
      start = gindex - ( gindex % FTC_SBIT_ITEMS_PER_NODE );
 
235
      count = total - start;
 
236
      if ( count > FTC_SBIT_ITEMS_PER_NODE )
 
237
        count = FTC_SBIT_ITEMS_PER_NODE;
 
238
 
 
239
      FTC_GNode_Init( FTC_GNODE( snode ), start, family );
 
240
 
 
241
      snode->count = count;
 
242
 
 
243
      error = ftc_snode_load( snode,
 
244
                              cache->manager,
 
245
                              gindex,
 
246
                              NULL );
 
247
      if ( error )
 
248
      {
 
249
        FTC_SNode_Free( snode, cache );
 
250
        snode = NULL;
 
251
      }
 
252
    }
 
253
 
 
254
  Exit:
 
255
    *psnode = snode;
 
256
    return error;
 
257
  }
 
258
 
 
259
 
 
260
  FT_LOCAL_DEF( FT_Error )
 
261
  ftc_snode_new( FTC_Node   *ftcpsnode,
 
262
                 FT_Pointer  ftcgquery,
 
263
                 FTC_Cache   cache )
 
264
  {
 
265
    FTC_SNode  *psnode = (FTC_SNode*)ftcpsnode;
 
266
    FTC_GQuery  gquery = (FTC_GQuery)ftcgquery;
 
267
 
 
268
 
 
269
    return FTC_SNode_New( psnode, gquery, cache );
 
270
  }
 
271
 
 
272
 
 
273
  FT_LOCAL_DEF( FT_Offset )
 
274
  ftc_snode_weight( FTC_Node   ftcsnode,
 
275
                    FTC_Cache  cache )
 
276
  {
 
277
    FTC_SNode  snode = (FTC_SNode)ftcsnode;
 
278
    FT_UInt    count = snode->count;
 
279
    FTC_SBit   sbit  = snode->sbits;
 
280
    FT_Int     pitch;
 
281
    FT_Offset  size;
 
282
 
 
283
    FT_UNUSED( cache );
 
284
 
 
285
 
 
286
    FT_ASSERT( snode->count <= FTC_SBIT_ITEMS_PER_NODE );
 
287
 
 
288
    /* the node itself */
 
289
    size = sizeof ( *snode );
 
290
 
 
291
    for ( ; count > 0; count--, sbit++ )
 
292
    {
 
293
      if ( sbit->buffer )
 
294
      {
 
295
        pitch = sbit->pitch;
 
296
        if ( pitch < 0 )
 
297
          pitch = -pitch;
 
298
 
 
299
        /* add the size of a given glyph image */
 
300
        size += pitch * sbit->height;
 
301
      }
 
302
    }
 
303
 
 
304
    return size;
 
305
  }
 
306
 
 
307
 
 
308
#if 0
 
309
 
 
310
  FT_LOCAL_DEF( FT_Offset )
 
311
  FTC_SNode_Weight( FTC_SNode  snode )
 
312
  {
 
313
    return ftc_snode_weight( FTC_NODE( snode ), NULL );
 
314
  }
 
315
 
 
316
#endif /* 0 */
 
317
 
 
318
 
 
319
  FT_LOCAL_DEF( FT_Bool )
 
320
  ftc_snode_compare( FTC_Node    ftcsnode,
 
321
                     FT_Pointer  ftcgquery,
 
322
                     FTC_Cache   cache )
 
323
  {
 
324
    FTC_SNode   snode  = (FTC_SNode)ftcsnode;
 
325
    FTC_GQuery  gquery = (FTC_GQuery)ftcgquery;
 
326
    FTC_GNode   gnode  = FTC_GNODE( snode );
 
327
    FT_UInt     gindex = gquery->gindex;
 
328
    FT_Bool     result;
 
329
 
 
330
 
 
331
    result = FT_BOOL( gnode->family == gquery->family                    &&
 
332
                      (FT_UInt)( gindex - gnode->gindex ) < snode->count );
 
333
    if ( result )
 
334
    {
 
335
      /* check if we need to load the glyph bitmap now */
 
336
      FTC_SBit  sbit = snode->sbits + ( gindex - gnode->gindex );
 
337
 
 
338
 
 
339
      /*
 
340
       *  The following code illustrates what to do when you want to
 
341
       *  perform operations that may fail within a lookup function.
 
342
       *
 
343
       *  Here, we want to load a small bitmap on-demand; we thus
 
344
       *  need to call the `ftc_snode_load' function which may return
 
345
       *  a non-zero error code only when we are out of memory (OOM).
 
346
       *
 
347
       *  The correct thing to do is to use @FTC_CACHE_TRYLOOP and
 
348
       *  @FTC_CACHE_TRYLOOP_END in order to implement a retry loop
 
349
       *  that is capable of flushing the cache incrementally when
 
350
       *  an OOM errors occur.
 
351
       *
 
352
       *  However, we need to `lock' the node before this operation to
 
353
       *  prevent it from being flushed within the loop.
 
354
       *
 
355
       *  When we exit the loop, we unlock the node, then check the `error'
 
356
       *  variable.  If it is non-zero, this means that the cache was
 
357
       *  completely flushed and that no usable memory was found to load
 
358
       *  the bitmap.
 
359
       *
 
360
       *  We then prefer to return a value of 0 (i.e., NO MATCH).  This
 
361
       *  ensures that the caller will try to allocate a new node.
 
362
       *  This operation consequently _fail_ and the lookup function
 
363
       *  returns the appropriate OOM error code.
 
364
       *
 
365
       *  Note that `buffer == NULL && width == 255' is a hack used to
 
366
       *  tag `unavailable' bitmaps in the array.  We should never try
 
367
       *  to load these.
 
368
       *
 
369
       */
 
370
 
 
371
      if ( sbit->buffer == NULL && sbit->width != 255 )
 
372
      {
 
373
        FT_ULong  size;
 
374
        FT_Error  error;
 
375
 
 
376
 
 
377
        ftcsnode->ref_count++;  /* lock node to prevent flushing */
 
378
                                /* in retry loop                 */
 
379
 
 
380
        FTC_CACHE_TRYLOOP( cache )
 
381
        {
 
382
          error = ftc_snode_load( snode, cache->manager, gindex, &size );
 
383
        }
 
384
        FTC_CACHE_TRYLOOP_END();
 
385
 
 
386
        ftcsnode->ref_count--;  /* unlock the node */
 
387
 
 
388
        if ( error )
 
389
          result = 0;
 
390
        else
 
391
          cache->manager->cur_weight += size;
 
392
      }
 
393
    }
 
394
 
 
395
    return result;
 
396
  }
 
397
 
 
398
 
 
399
  FT_LOCAL_DEF( FT_Bool )
 
400
  FTC_SNode_Compare( FTC_SNode   snode,
 
401
                     FTC_GQuery  gquery,
 
402
                     FTC_Cache   cache )
 
403
  {
 
404
    return ftc_snode_compare( FTC_NODE( snode ), gquery, cache );
 
405
  }
 
406
 
 
407
 
 
408
/* END */