Context Navigation

source: trunk/poppler/freetype2/src/cache/ftccmap.c @ 262

Last change on this file since 262 was 262, checked in by Eugene Romanenko, 12 years ago
PDF plugin: freetype library updated to version 2.3.8
File size: 13.0 KB

Line
1	/***************************************************************************/
2	/* */
3	/* ftccmap.c */
4	/* */
5	/* FreeType CharMap cache (body) */
6	/* */
7	/* Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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_FREETYPE_H
21	#include FT_CACHE_H
22	#include "ftcmanag.h"
23	#include FT_INTERNAL_MEMORY_H
24	#include FT_INTERNAL_DEBUG_H
25	#include FT_TRUETYPE_IDS_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	( (char_code) / 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;
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_ULong )
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_CMapNode node;
288	FT_Error error;
289	FT_UInt gindex = 0;
290	FT_UInt32 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_ERROR(( "FTC_CMapCache_Lookup: bad arguments, returning 0!\n" ));
308	return 0;
309	}
310
311	#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
312
313	/*
314	* Detect a call from a rogue client that thinks it is linking
315	* to FreeType 2.1.7. This is possible because the third parameter
316	* is then a character code, and we have never seen any font with
317	* more than a few charmaps, so if the index is very large...
318	*
319	* It is also very unlikely that a rogue client is interested
320	* in Unicode values 0 to 15.
321	*
322	* NOTE: The original threshold was 4, but we found a font from the
323	* Adobe Acrobat Reader Pack, named `KozMinProVI-Regular.otf',
324	* which contains more than 5 charmaps.
325	*/
326	if ( cmap_index >= 16 && !no_cmap_change )
327	{
328	FTC_OldCMapDesc desc = (FTC_OldCMapDesc) face_id;
329
330
331	char_code = (FT_UInt32)cmap_index;
332	query.face_id = desc->face_id;
333
334
335	switch ( desc->type )
336	{
337	case FTC_OLD_CMAP_BY_INDEX:
338	query.cmap_index = desc->u.index;
339	query.char_code = (FT_UInt32)cmap_index;
340	break;
341
342	case FTC_OLD_CMAP_BY_ENCODING:
343	{
344	FT_Face face;
345
346
347	error = FTC_Manager_LookupFace( cache->manager, desc->face_id,
348	&face );
349	if ( error )
350	return 0;
351
352	FT_Select_Charmap( face, desc->u.encoding );
353
354	return FT_Get_Char_Index( face, char_code );
355	}
356
357	default:
358	return 0;
359	}
360	}
361	else
362
363	#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
364
365	{
366	query.face_id = face_id;
367	query.cmap_index = (FT_UInt)cmap_index;
368	query.char_code = char_code;
369	}
370
371	hash = FTC_CMAP_HASH( face_id, cmap_index, char_code );
372
373	#if 1
374	FTC_CACHE_LOOKUP_CMP( cache, ftc_cmap_node_compare, hash, &query,
375	node, error );
376	#else
377	error = FTC_Cache_Lookup( cache, hash, &query, (FTC_Node*) &node );
378	#endif
379	if ( error )
380	goto Exit;
381
382	FT_ASSERT( (FT_UInt)( char_code - node->first ) < FTC_CMAP_INDICES_MAX );
383
384	/* something rotten can happen with rogue clients */
385	if ( (FT_UInt)( char_code - node->first >= FTC_CMAP_INDICES_MAX ) )
386	return 0;
387
388	gindex = node->indices[char_code - node->first];
389	if ( gindex == FTC_CMAP_UNKNOWN )
390	{
391	FT_Face face;
392
393
394	gindex = 0;
395
396	error = FTC_Manager_LookupFace( cache->manager, node->face_id, &face );
397	if ( error )
398	goto Exit;
399
400	if ( (FT_UInt)cmap_index < (FT_UInt)face->num_charmaps )
401	{
402	FT_CharMap old, cmap = NULL;
403
404
405	old = face->charmap;
406	cmap = face->charmaps[cmap_index];
407
408	if ( old != cmap && !no_cmap_change )
409	FT_Set_Charmap( face, cmap );
410
411	gindex = FT_Get_Char_Index( face, char_code );
412
413	if ( old != cmap && !no_cmap_change )
414	FT_Set_Charmap( face, old );
415	}
416
417	node->indices[char_code - node->first] = (FT_UShort)gindex;
418	}
419
420	Exit:
421	return gindex;
422	}
423
424
425	/* END */

Note: See TracBrowser for help on using the repository browser.

Download in other formats: