|
1 /***************************************************************************/ |
|
2 /* */ |
|
3 /* ftcsbits.c */ |
|
4 /* */ |
|
5 /* FreeType sbits manager (body). */ |
|
6 /* */ |
|
7 /* Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 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_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 FT_UInt node_count; |
|
221 |
|
222 |
|
223 total = clazz->family_get_count( family, cache->manager ); |
|
224 if ( total == 0 || gindex >= total ) |
|
225 { |
|
226 error = FTC_Err_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 ) |
|
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 ) |
|
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 += 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 ) |
|
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 ) |
|
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 */ |