[CMAKE]
[reactos.git] / lib / 3rdparty / freetype / src / cache / ftccmap.c
1 /***************************************************************************/
2 /* */
3 /* ftccmap.c */
4 /* */
5 /* FreeType CharMap cache (body) */
6 /* */
7 /* Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, */
8 /* 2010 by */
9 /* David Turner, Robert Wilhelm, and Werner Lemberg. */
10 /* */
11 /* This file is part of the FreeType project, and may only be used, */
12 /* modified, and distributed under the terms of the FreeType project */
13 /* license, LICENSE.TXT. By continuing to use, modify, or distribute */
14 /* this file you indicate that you have read the license and */
15 /* understand and accept it fully. */
16 /* */
17 /***************************************************************************/
18
19
20 #include <ft2build.h>
21 #include FT_FREETYPE_H
22 #include FT_CACHE_H
23 #include "ftcmanag.h"
24 #include FT_INTERNAL_MEMORY_H
25 #include FT_INTERNAL_DEBUG_H
26
27 #include "ftccback.h"
28 #include "ftcerror.h"
29
30 #undef FT_COMPONENT
31 #define FT_COMPONENT trace_cache
32
33
34 #ifdef FT_CONFIG_OPTION_OLD_INTERNALS
35
36 typedef enum FTC_OldCMapType_
37 {
38 FTC_OLD_CMAP_BY_INDEX = 0,
39 FTC_OLD_CMAP_BY_ENCODING = 1,
40 FTC_OLD_CMAP_BY_ID = 2
41
42 } FTC_OldCMapType;
43
44
45 typedef struct FTC_OldCMapIdRec_
46 {
47 FT_UInt platform;
48 FT_UInt encoding;
49
50 } FTC_OldCMapIdRec, *FTC_OldCMapId;
51
52
53 typedef struct FTC_OldCMapDescRec_
54 {
55 FTC_FaceID face_id;
56 FTC_OldCMapType type;
57
58 union
59 {
60 FT_UInt index;
61 FT_Encoding encoding;
62 FTC_OldCMapIdRec id;
63
64 } u;
65
66 } FTC_OldCMapDescRec, *FTC_OldCMapDesc;
67
68 #endif /* FT_CONFIG_OLD_INTERNALS */
69
70
71 /*************************************************************************/
72 /* */
73 /* Each FTC_CMapNode contains a simple array to map a range of character */
74 /* codes to equivalent glyph indices. */
75 /* */
76 /* For now, the implementation is very basic: Each node maps a range of */
77 /* 128 consecutive character codes to their corresponding glyph indices. */
78 /* */
79 /* We could do more complex things, but I don't think it is really very */
80 /* useful. */
81 /* */
82 /*************************************************************************/
83
84
85 /* number of glyph indices / character code per node */
86 #define FTC_CMAP_INDICES_MAX 128
87
88 /* compute a query/node hash */
89 #define FTC_CMAP_HASH( faceid, index, charcode ) \
90 ( _FTC_FACE_ID_HASH( faceid ) + 211 * (index) + \
91 ( (charcode) / FTC_CMAP_INDICES_MAX ) )
92
93 /* the charmap query */
94 typedef struct FTC_CMapQueryRec_
95 {
96 FTC_FaceID face_id;
97 FT_UInt cmap_index;
98 FT_UInt32 char_code;
99
100 } FTC_CMapQueryRec, *FTC_CMapQuery;
101
102 #define FTC_CMAP_QUERY( x ) ((FTC_CMapQuery)(x))
103 #define FTC_CMAP_QUERY_HASH( x ) \
104 FTC_CMAP_HASH( (x)->face_id, (x)->cmap_index, (x)->char_code )
105
106 /* the cmap cache node */
107 typedef struct FTC_CMapNodeRec_
108 {
109 FTC_NodeRec node;
110 FTC_FaceID face_id;
111 FT_UInt cmap_index;
112 FT_UInt32 first; /* first character in node */
113 FT_UInt16 indices[FTC_CMAP_INDICES_MAX]; /* array of glyph indices */
114
115 } FTC_CMapNodeRec, *FTC_CMapNode;
116
117 #define FTC_CMAP_NODE( x ) ( (FTC_CMapNode)( x ) )
118 #define FTC_CMAP_NODE_HASH( x ) \
119 FTC_CMAP_HASH( (x)->face_id, (x)->cmap_index, (x)->first )
120
121 /* if (indices[n] == FTC_CMAP_UNKNOWN), we assume that the corresponding */
122 /* glyph indices haven't been queried through FT_Get_Glyph_Index() yet */
123 #define FTC_CMAP_UNKNOWN ( (FT_UInt16)-1 )
124
125
126 /*************************************************************************/
127 /*************************************************************************/
128 /***** *****/
129 /***** CHARMAP NODES *****/
130 /***** *****/
131 /*************************************************************************/
132 /*************************************************************************/
133
134
135 FT_CALLBACK_DEF( void )
136 ftc_cmap_node_free( FTC_Node ftcnode,
137 FTC_Cache cache )
138 {
139 FTC_CMapNode node = (FTC_CMapNode)ftcnode;
140 FT_Memory memory = cache->memory;
141
142
143 FT_FREE( node );
144 }
145
146
147 /* initialize a new cmap node */
148 FT_CALLBACK_DEF( FT_Error )
149 ftc_cmap_node_new( FTC_Node *ftcanode,
150 FT_Pointer ftcquery,
151 FTC_Cache cache )
152 {
153 FTC_CMapNode *anode = (FTC_CMapNode*)ftcanode;
154 FTC_CMapQuery query = (FTC_CMapQuery)ftcquery;
155 FT_Error error;
156 FT_Memory memory = cache->memory;
157 FTC_CMapNode node = NULL;
158 FT_UInt nn;
159
160
161 if ( !FT_NEW( node ) )
162 {
163 node->face_id = query->face_id;
164 node->cmap_index = query->cmap_index;
165 node->first = (query->char_code / FTC_CMAP_INDICES_MAX) *
166 FTC_CMAP_INDICES_MAX;
167
168 for ( nn = 0; nn < FTC_CMAP_INDICES_MAX; nn++ )
169 node->indices[nn] = FTC_CMAP_UNKNOWN;
170 }
171
172 *anode = node;
173 return error;
174 }
175
176
177 /* compute the weight of a given cmap node */
178 FT_CALLBACK_DEF( FT_Offset )
179 ftc_cmap_node_weight( FTC_Node cnode,
180 FTC_Cache cache )
181 {
182 FT_UNUSED( cnode );
183 FT_UNUSED( cache );
184
185 return sizeof ( *cnode );
186 }
187
188
189 /* compare a cmap node to a given query */
190 FT_CALLBACK_DEF( FT_Bool )
191 ftc_cmap_node_compare( FTC_Node ftcnode,
192 FT_Pointer ftcquery,
193 FTC_Cache cache )
194 {
195 FTC_CMapNode node = (FTC_CMapNode)ftcnode;
196 FTC_CMapQuery query = (FTC_CMapQuery)ftcquery;
197 FT_UNUSED( cache );
198
199
200 if ( node->face_id == query->face_id &&
201 node->cmap_index == query->cmap_index )
202 {
203 FT_UInt32 offset = (FT_UInt32)( query->char_code - node->first );
204
205
206 return FT_BOOL( offset < FTC_CMAP_INDICES_MAX );
207 }
208
209 return 0;
210 }
211
212
213 FT_CALLBACK_DEF( FT_Bool )
214 ftc_cmap_node_remove_faceid( FTC_Node ftcnode,
215 FT_Pointer ftcface_id,
216 FTC_Cache cache )
217 {
218 FTC_CMapNode node = (FTC_CMapNode)ftcnode;
219 FTC_FaceID face_id = (FTC_FaceID)ftcface_id;
220 FT_UNUSED( cache );
221
222 return FT_BOOL( node->face_id == face_id );
223 }
224
225
226 /*************************************************************************/
227 /*************************************************************************/
228 /***** *****/
229 /***** GLYPH IMAGE CACHE *****/
230 /***** *****/
231 /*************************************************************************/
232 /*************************************************************************/
233
234
235 FT_CALLBACK_TABLE_DEF
236 const FTC_CacheClassRec ftc_cmap_cache_class =
237 {
238 ftc_cmap_node_new,
239 ftc_cmap_node_weight,
240 ftc_cmap_node_compare,
241 ftc_cmap_node_remove_faceid,
242 ftc_cmap_node_free,
243
244 sizeof ( FTC_CacheRec ),
245 ftc_cache_init,
246 ftc_cache_done,
247 };
248
249
250 /* documentation is in ftcache.h */
251
252 FT_EXPORT_DEF( FT_Error )
253 FTC_CMapCache_New( FTC_Manager manager,
254 FTC_CMapCache *acache )
255 {
256 return FTC_Manager_RegisterCache( manager,
257 &ftc_cmap_cache_class,
258 FTC_CACHE_P( acache ) );
259 }
260
261
262 #ifdef FT_CONFIG_OPTION_OLD_INTERNALS
263
264 /*
265 * Unfortunately, it is not possible to support binary backwards
266 * compatibility in the cmap cache. The FTC_CMapCache_Lookup signature
267 * changes were too deep, and there is no clever hackish way to detect
268 * what kind of structure we are being passed.
269 *
270 * On the other hand it seems that no production code is using this
271 * function on Unix distributions.
272 */
273
274 #endif
275
276
277 /* documentation is in ftcache.h */
278
279 FT_EXPORT_DEF( FT_UInt )
280 FTC_CMapCache_Lookup( FTC_CMapCache cmap_cache,
281 FTC_FaceID face_id,
282 FT_Int cmap_index,
283 FT_UInt32 char_code )
284 {
285 FTC_Cache cache = FTC_CACHE( cmap_cache );
286 FTC_CMapQueryRec query;
287 FTC_Node node;
288 FT_Error error;
289 FT_UInt gindex = 0;
290 FT_PtrDist hash;
291 FT_Int no_cmap_change = 0;
292
293
294 if ( cmap_index < 0 )
295 {
296 /* Treat a negative cmap index as a special value, meaning that you */
297 /* don't want to change the FT_Face's character map through this */
298 /* call. This can be useful if the face requester callback already */
299 /* sets the face's charmap to the appropriate value. */
300
301 no_cmap_change = 1;
302 cmap_index = 0;
303 }
304
305 if ( !cache )
306 {
307 FT_TRACE0(( "FTC_CMapCache_Lookup: bad arguments, returning 0\n" ));
308 return 0;
309 }
310
311 #ifdef FT_CONFIG_OPTION_OLD_INTERNALS
312
313 /*
314 * If cmap_index is greater than the maximum number of cachable
315 * charmaps, we assume the request is from a legacy rogue client
316 * using old internal header. See include/config/ftoption.h.
317 */
318 if ( cmap_index > FT_MAX_CHARMAP_CACHEABLE && !no_cmap_change )
319 {
320 FTC_OldCMapDesc desc = (FTC_OldCMapDesc) face_id;
321
322
323 char_code = (FT_UInt32)cmap_index;
324 query.face_id = desc->face_id;
325
326
327 switch ( desc->type )
328 {
329 case FTC_OLD_CMAP_BY_INDEX:
330 query.cmap_index = desc->u.index;
331 query.char_code = (FT_UInt32)cmap_index;
332 break;
333
334 case FTC_OLD_CMAP_BY_ENCODING:
335 {
336 FT_Face face;
337
338
339 error = FTC_Manager_LookupFace( cache->manager, desc->face_id,
340 &face );
341 if ( error )
342 return 0;
343
344 FT_Select_Charmap( face, desc->u.encoding );
345
346 return FT_Get_Char_Index( face, char_code );
347 }
348
349 default:
350 return 0;
351 }
352 }
353 else
354
355 #endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
356
357 {
358 query.face_id = face_id;
359 query.cmap_index = (FT_UInt)cmap_index;
360 query.char_code = char_code;
361 }
362
363 hash = FTC_CMAP_HASH( face_id, cmap_index, char_code );
364
365 #if 1
366 FTC_CACHE_LOOKUP_CMP( cache, ftc_cmap_node_compare, hash, &query,
367 node, error );
368 #else
369 error = FTC_Cache_Lookup( cache, hash, &query, &node );
370 #endif
371 if ( error )
372 goto Exit;
373
374 FT_ASSERT( (FT_UInt)( char_code - FTC_CMAP_NODE( node )->first ) <
375 FTC_CMAP_INDICES_MAX );
376
377 /* something rotten can happen with rogue clients */
378 if ( (FT_UInt)( char_code - FTC_CMAP_NODE( node )->first >=
379 FTC_CMAP_INDICES_MAX ) )
380 return 0; /* XXX: should return appropriate error */
381
382 gindex = FTC_CMAP_NODE( node )->indices[char_code -
383 FTC_CMAP_NODE( node )->first];
384 if ( gindex == FTC_CMAP_UNKNOWN )
385 {
386 FT_Face face;
387
388
389 gindex = 0;
390
391 error = FTC_Manager_LookupFace( cache->manager,
392 FTC_CMAP_NODE( node )->face_id,
393 &face );
394 if ( error )
395 goto Exit;
396
397 #ifdef FT_MAX_CHARMAP_CACHEABLE
398 /* something rotten can happen with rogue clients */
399 if ( cmap_index > FT_MAX_CHARMAP_CACHEABLE )
400 return 0; /* XXX: should return appropriate error */
401 #endif
402
403 if ( (FT_UInt)cmap_index < (FT_UInt)face->num_charmaps )
404 {
405 FT_CharMap old, cmap = NULL;
406
407
408 old = face->charmap;
409 cmap = face->charmaps[cmap_index];
410
411 if ( old != cmap && !no_cmap_change )
412 FT_Set_Charmap( face, cmap );
413
414 gindex = FT_Get_Char_Index( face, char_code );
415
416 if ( old != cmap && !no_cmap_change )
417 FT_Set_Charmap( face, old );
418 }
419
420 FTC_CMAP_NODE( node )->indices[char_code -
421 FTC_CMAP_NODE( node )->first]
422 = (FT_UShort)gindex;
423 }
424
425 Exit:
426 return gindex;
427 }
428
429
430 /* END */