/modules/freetype2/src/cache/ftccmap.c
C | 430 lines | 249 code | 106 blank | 75 comment | 25 complexity | 2835e7f54b7ddf52e7b85d7a451731d5 MD5 | raw file
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_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_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 */