• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /***************************************************************************/
2 /*                                                                         */
3 /*  ftcsbits.c                                                             */
4 /*                                                                         */
5 /*    FreeType sbits manager (body).                                       */
6 /*                                                                         */
7 /*  Copyright 2000-2015 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
ftc_sbit_copy_bitmap(FTC_SBit sbit,FT_Bitmap * bitmap,FT_Memory memory)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 )
ftc_snode_free(FTC_Node ftcsnode,FTC_Cache cache)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 )
FTC_SNode_Free(FTC_SNode snode,FTC_Cache cache)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
ftc_snode_load(FTC_SNode snode,FTC_Manager manager,FT_UInt gindex,FT_ULong * asize)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 FT_THROW( 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 whether 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, (FT_Int) temp == (FT_Int) d )
150 #define CHECK_BYTE( d )  ( temp = (FT_Byte)d, (FT_UInt)temp == (FT_UInt)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_ULong)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 && FT_ERR_NEQ( error, Out_Of_Memory ) )
193     {
194     BadGlyph:
195       sbit->width  = 255;
196       sbit->height = 0;
197       sbit->buffer = NULL;
198       error        = FT_Err_Ok;
199       if ( asize )
200         *asize = 0;
201     }
202 
203     return error;
204   }
205 
206 
207   FT_LOCAL_DEF( FT_Error )
FTC_SNode_New(FTC_SNode * psnode,FTC_GQuery gquery,FTC_Cache cache)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 = FT_THROW( 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 )
ftc_snode_new(FTC_Node * ftcpsnode,FT_Pointer ftcgquery,FTC_Cache cache)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 )
ftc_snode_weight(FTC_Node ftcsnode,FTC_Cache cache)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 += (FT_Offset)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 )
ftc_snode_compare(FTC_Node ftcsnode,FT_Pointer ftcgquery,FTC_Cache cache,FT_Bool * list_changed)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 )
FTC_SNode_Compare(FTC_SNode snode,FTC_GQuery gquery,FTC_Cache cache,FT_Bool * list_changed)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 */
422