1 | /**************************************************************************** |
2 | * |
3 | * ftcsbits.c |
4 | * |
5 | * FreeType sbits manager (body). |
6 | * |
7 | * Copyright (C) 2000-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/ftcache.h> |
20 | #include "ftcsbits.h" |
21 | #include <freetype/internal/ftobjs.h> |
22 | #include <freetype/internal/ftdebug.h> |
23 | #include <freetype/fterrors.h> |
24 | |
25 | #include "ftccback.h" |
26 | #include "ftcerror.h" |
27 | |
28 | #undef FT_COMPONENT |
29 | #define FT_COMPONENT cache |
30 | |
31 | |
32 | /*************************************************************************/ |
33 | /*************************************************************************/ |
34 | /***** *****/ |
35 | /***** SBIT CACHE NODES *****/ |
36 | /***** *****/ |
37 | /*************************************************************************/ |
38 | /*************************************************************************/ |
39 | |
40 | |
41 | static FT_Error |
42 | ftc_sbit_copy_bitmap( FTC_SBit sbit, |
43 | FT_Bitmap* bitmap, |
44 | FT_Memory memory ) |
45 | { |
46 | FT_Error error; |
47 | FT_Int pitch = bitmap->pitch; |
48 | FT_ULong size; |
49 | |
50 | |
51 | if ( pitch < 0 ) |
52 | pitch = -pitch; |
53 | |
54 | size = (FT_ULong)pitch * bitmap->rows; |
55 | |
56 | if ( !FT_QALLOC( sbit->buffer, size ) ) |
57 | FT_MEM_COPY( sbit->buffer, bitmap->buffer, size ); |
58 | |
59 | return error; |
60 | } |
61 | |
62 | |
63 | FT_LOCAL_DEF( void ) |
64 | ftc_snode_free( FTC_Node ftcsnode, |
65 | FTC_Cache cache ) |
66 | { |
67 | FTC_SNode snode = (FTC_SNode)ftcsnode; |
68 | FTC_SBit sbit = snode->sbits; |
69 | FT_UInt count = snode->count; |
70 | FT_Memory memory = cache->memory; |
71 | |
72 | |
73 | for ( ; count > 0; sbit++, count-- ) |
74 | FT_FREE( sbit->buffer ); |
75 | |
76 | FTC_GNode_Done( FTC_GNODE( snode ), cache ); |
77 | |
78 | FT_FREE( snode ); |
79 | } |
80 | |
81 | |
82 | FT_LOCAL_DEF( void ) |
83 | FTC_SNode_Free( FTC_SNode snode, |
84 | FTC_Cache cache ) |
85 | { |
86 | ftc_snode_free( FTC_NODE( snode ), cache ); |
87 | } |
88 | |
89 | |
90 | /* |
91 | * This function tries to load a small bitmap within a given FTC_SNode. |
92 | * Note that it returns a non-zero error code _only_ in the case of |
93 | * out-of-memory condition. For all other errors (e.g., corresponding |
94 | * to a bad font file), this function will mark the sbit as `unavailable' |
95 | * and return a value of 0. |
96 | * |
97 | * You should also read the comment within the @ftc_snode_compare |
98 | * function below to see how out-of-memory is handled during a lookup. |
99 | */ |
100 | static FT_Error |
101 | ftc_snode_load( FTC_SNode snode, |
102 | FTC_Manager manager, |
103 | FT_UInt gindex, |
104 | FT_ULong *asize ) |
105 | { |
106 | FT_Error error; |
107 | FTC_GNode gnode = FTC_GNODE( snode ); |
108 | FTC_Family family = gnode->family; |
109 | FT_Face face; |
110 | FTC_SBit sbit; |
111 | FTC_SFamilyClass clazz; |
112 | |
113 | |
114 | if ( gindex - gnode->gindex >= snode->count ) |
115 | { |
116 | FT_ERROR(( "ftc_snode_load: invalid glyph index" )); |
117 | return FT_THROW( Invalid_Argument ); |
118 | } |
119 | |
120 | sbit = snode->sbits + ( gindex - gnode->gindex ); |
121 | clazz = (FTC_SFamilyClass)family->clazz; |
122 | |
123 | error = clazz->family_load_glyph( family, gindex, manager, &face ); |
124 | if ( error ) |
125 | goto BadGlyph; |
126 | |
127 | { |
128 | FT_Int temp; |
129 | FT_GlyphSlot slot = face->glyph; |
130 | FT_Bitmap* bitmap = &slot->bitmap; |
131 | FT_Pos xadvance, yadvance; /* FT_GlyphSlot->advance.{x|y} */ |
132 | |
133 | |
134 | if ( slot->format != FT_GLYPH_FORMAT_BITMAP ) |
135 | { |
136 | FT_TRACE0(( "ftc_snode_load:" |
137 | " glyph loaded didn't return a bitmap\n" )); |
138 | goto BadGlyph; |
139 | } |
140 | |
141 | /* Check whether our values fit into 8/16-bit containers! */ |
142 | /* If this is not the case, our bitmap is too large */ |
143 | /* and we will leave it as `missing' with sbit.buffer = 0 */ |
144 | |
145 | #define CHECK_CHAR( d ) ( temp = (FT_Char)d, (FT_Int) temp == (FT_Int) d ) |
146 | #define CHECK_BYTE( d ) ( temp = (FT_Byte)d, (FT_UInt)temp == (FT_UInt)d ) |
147 | #define CHECK_SHRT( d ) ( temp = (FT_Short)d, (FT_Int)temp == (FT_Int) d ) |
148 | |
149 | /* horizontal advance in pixels */ |
150 | xadvance = ( slot->advance.x + 32 ) >> 6; |
151 | yadvance = ( slot->advance.y + 32 ) >> 6; |
152 | |
153 | if ( !CHECK_BYTE( bitmap->rows ) || |
154 | !CHECK_BYTE( bitmap->width ) || |
155 | !CHECK_SHRT( bitmap->pitch ) || |
156 | !CHECK_CHAR( slot->bitmap_left ) || |
157 | !CHECK_CHAR( slot->bitmap_top ) || |
158 | !CHECK_CHAR( xadvance ) || |
159 | !CHECK_CHAR( yadvance ) ) |
160 | { |
161 | FT_TRACE2(( "ftc_snode_load:" |
162 | " glyph too large for small bitmap cache\n" )); |
163 | goto BadGlyph; |
164 | } |
165 | |
166 | sbit->width = (FT_Byte)bitmap->width; |
167 | sbit->height = (FT_Byte)bitmap->rows; |
168 | sbit->pitch = (FT_Short)bitmap->pitch; |
169 | sbit->left = (FT_Char)slot->bitmap_left; |
170 | sbit->top = (FT_Char)slot->bitmap_top; |
171 | sbit->xadvance = (FT_Char)xadvance; |
172 | sbit->yadvance = (FT_Char)yadvance; |
173 | sbit->format = (FT_Byte)bitmap->pixel_mode; |
174 | sbit->max_grays = (FT_Byte)( bitmap->num_grays - 1 ); |
175 | |
176 | if ( slot->internal->flags & FT_GLYPH_OWN_BITMAP ) |
177 | { |
178 | /* take the bitmap ownership */ |
179 | sbit->buffer = bitmap->buffer; |
180 | slot->internal->flags &= ~FT_GLYPH_OWN_BITMAP; |
181 | } |
182 | else |
183 | { |
184 | /* copy the bitmap into a new buffer -- ignore error */ |
185 | error = ftc_sbit_copy_bitmap( sbit, bitmap, manager->memory ); |
186 | } |
187 | |
188 | /* now, compute size */ |
189 | if ( asize ) |
190 | *asize = (FT_ULong)FT_ABS( sbit->pitch ) * sbit->height; |
191 | |
192 | } /* glyph loading successful */ |
193 | |
194 | /* ignore the errors that might have occurred -- */ |
195 | /* we mark unloaded glyphs with `sbit.buffer == 0' */ |
196 | /* and `width == 255', `height == 0' */ |
197 | /* */ |
198 | if ( error && FT_ERR_NEQ( error, Out_Of_Memory ) ) |
199 | { |
200 | BadGlyph: |
201 | sbit->width = 255; |
202 | sbit->height = 0; |
203 | sbit->buffer = NULL; |
204 | error = FT_Err_Ok; |
205 | if ( asize ) |
206 | *asize = 0; |
207 | } |
208 | |
209 | return error; |
210 | } |
211 | |
212 | |
213 | FT_LOCAL_DEF( FT_Error ) |
214 | FTC_SNode_New( FTC_SNode *psnode, |
215 | FTC_GQuery gquery, |
216 | FTC_Cache cache ) |
217 | { |
218 | FT_Memory memory = cache->memory; |
219 | FT_Error error; |
220 | FTC_SNode snode = NULL; |
221 | FT_UInt gindex = gquery->gindex; |
222 | FTC_Family family = gquery->family; |
223 | |
224 | FTC_SFamilyClass clazz = FTC_CACHE_SFAMILY_CLASS( cache ); |
225 | FT_UInt total; |
226 | FT_UInt node_count; |
227 | |
228 | |
229 | total = clazz->family_get_count( family, cache->manager ); |
230 | if ( total == 0 || gindex >= total ) |
231 | { |
232 | error = FT_THROW( Invalid_Argument ); |
233 | goto Exit; |
234 | } |
235 | |
236 | if ( !FT_QNEW( snode ) ) |
237 | { |
238 | FT_UInt count, start; |
239 | |
240 | |
241 | start = gindex - ( gindex % FTC_SBIT_ITEMS_PER_NODE ); |
242 | count = total - start; |
243 | if ( count > FTC_SBIT_ITEMS_PER_NODE ) |
244 | count = FTC_SBIT_ITEMS_PER_NODE; |
245 | |
246 | FTC_GNode_Init( FTC_GNODE( snode ), start, family ); |
247 | |
248 | snode->count = count; |
249 | for ( node_count = 0; node_count < count; node_count++ ) |
250 | { |
251 | snode->sbits[node_count].width = 255; |
252 | snode->sbits[node_count].height = 0; |
253 | snode->sbits[node_count].buffer = NULL; |
254 | } |
255 | |
256 | error = ftc_snode_load( snode, |
257 | cache->manager, |
258 | gindex, |
259 | NULL ); |
260 | if ( error ) |
261 | { |
262 | FTC_SNode_Free( snode, cache ); |
263 | snode = NULL; |
264 | } |
265 | } |
266 | |
267 | Exit: |
268 | *psnode = snode; |
269 | return error; |
270 | } |
271 | |
272 | |
273 | FT_LOCAL_DEF( FT_Error ) |
274 | ftc_snode_new( FTC_Node *ftcpsnode, |
275 | FT_Pointer ftcgquery, |
276 | FTC_Cache cache ) |
277 | { |
278 | FTC_SNode *psnode = (FTC_SNode*)ftcpsnode; |
279 | FTC_GQuery gquery = (FTC_GQuery)ftcgquery; |
280 | |
281 | |
282 | return FTC_SNode_New( psnode, gquery, cache ); |
283 | } |
284 | |
285 | |
286 | FT_LOCAL_DEF( FT_Offset ) |
287 | ftc_snode_weight( FTC_Node ftcsnode, |
288 | FTC_Cache cache ) |
289 | { |
290 | FTC_SNode snode = (FTC_SNode)ftcsnode; |
291 | FT_UInt count = snode->count; |
292 | FTC_SBit sbit = snode->sbits; |
293 | FT_Int pitch; |
294 | FT_Offset size; |
295 | |
296 | FT_UNUSED( cache ); |
297 | |
298 | |
299 | FT_ASSERT( snode->count <= FTC_SBIT_ITEMS_PER_NODE ); |
300 | |
301 | /* the node itself */ |
302 | size = sizeof ( *snode ); |
303 | |
304 | for ( ; count > 0; count--, sbit++ ) |
305 | { |
306 | if ( sbit->buffer ) |
307 | { |
308 | pitch = sbit->pitch; |
309 | if ( pitch < 0 ) |
310 | pitch = -pitch; |
311 | |
312 | /* add the size of a given glyph image */ |
313 | size += (FT_Offset)pitch * sbit->height; |
314 | } |
315 | } |
316 | |
317 | return size; |
318 | } |
319 | |
320 | |
321 | #if 0 |
322 | |
323 | FT_LOCAL_DEF( FT_Offset ) |
324 | FTC_SNode_Weight( FTC_SNode snode ) |
325 | { |
326 | return ftc_snode_weight( FTC_NODE( snode ), NULL ); |
327 | } |
328 | |
329 | #endif /* 0 */ |
330 | |
331 | |
332 | FT_LOCAL_DEF( FT_Bool ) |
333 | ftc_snode_compare( FTC_Node ftcsnode, |
334 | FT_Pointer ftcgquery, |
335 | FTC_Cache cache, |
336 | FT_Bool* list_changed ) |
337 | { |
338 | FTC_SNode snode = (FTC_SNode)ftcsnode; |
339 | FTC_GQuery gquery = (FTC_GQuery)ftcgquery; |
340 | FTC_GNode gnode = FTC_GNODE( snode ); |
341 | FT_UInt gindex = gquery->gindex; |
342 | FT_Bool result; |
343 | |
344 | |
345 | if ( list_changed ) |
346 | *list_changed = FALSE; |
347 | result = FT_BOOL( gnode->family == gquery->family && |
348 | gindex - gnode->gindex < snode->count ); |
349 | if ( result ) |
350 | { |
351 | /* check if we need to load the glyph bitmap now */ |
352 | FTC_SBit sbit = snode->sbits + ( gindex - gnode->gindex ); |
353 | |
354 | |
355 | /* |
356 | * The following code illustrates what to do when you want to |
357 | * perform operations that may fail within a lookup function. |
358 | * |
359 | * Here, we want to load a small bitmap on-demand; we thus |
360 | * need to call the `ftc_snode_load' function which may return |
361 | * a non-zero error code only when we are out of memory (OOM). |
362 | * |
363 | * The correct thing to do is to use @FTC_CACHE_TRYLOOP and |
364 | * @FTC_CACHE_TRYLOOP_END in order to implement a retry loop |
365 | * that is capable of flushing the cache incrementally when |
366 | * an OOM errors occur. |
367 | * |
368 | * However, we need to `lock' the node before this operation to |
369 | * prevent it from being flushed within the loop. |
370 | * |
371 | * When we exit the loop, we unlock the node, then check the `error' |
372 | * variable. If it is non-zero, this means that the cache was |
373 | * completely flushed and that no usable memory was found to load |
374 | * the bitmap. |
375 | * |
376 | * We then prefer to return a value of 0 (i.e., NO MATCH). This |
377 | * ensures that the caller will try to allocate a new node. |
378 | * This operation consequently _fail_ and the lookup function |
379 | * returns the appropriate OOM error code. |
380 | * |
381 | * Note that `buffer == NULL && width == 255' is a hack used to |
382 | * tag `unavailable' bitmaps in the array. We should never try |
383 | * to load these. |
384 | * |
385 | */ |
386 | |
387 | if ( !sbit->buffer && sbit->width == 255 ) |
388 | { |
389 | FT_ULong size; |
390 | FT_Error error; |
391 | |
392 | |
393 | ftcsnode->ref_count++; /* lock node to prevent flushing */ |
394 | /* in retry loop */ |
395 | |
396 | FTC_CACHE_TRYLOOP( cache ) |
397 | { |
398 | error = ftc_snode_load( snode, cache->manager, gindex, &size ); |
399 | } |
400 | FTC_CACHE_TRYLOOP_END( list_changed ) |
401 | |
402 | ftcsnode->ref_count--; /* unlock the node */ |
403 | |
404 | if ( error ) |
405 | result = 0; |
406 | else |
407 | cache->manager->cur_weight += size; |
408 | } |
409 | } |
410 | |
411 | return result; |
412 | } |
413 | |
414 | /* END */ |
415 | |