PageRenderTime 43ms CodeModel.GetById 17ms app.highlight 22ms RepoModel.GetById 1ms app.codeStats 0ms

/modules/freetype2/src/cache/ftccmap.c

http://github.com/zpao/v8monkey
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 */