projects / reactos.git / blob
? search:


544750ab17fc272b41ebbdecd1457d164b75f78b
[reactos.git] / lib / 3rdparty / freetype / src / sfnt / ttcmap.c
1 /***************************************************************************/
2 /* */
3 /* ttcmap.c */
4 /* */
5 /* TrueType character mapping table (cmap) support (body). */
6 /* */
7 /* Copyright 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 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_INTERNAL_DEBUG_H
21
22 #include "sferrors.h" /* must come before FT_INTERNAL_VALIDATE_H */
23
24 #include FT_INTERNAL_VALIDATE_H
25 #include FT_INTERNAL_STREAM_H
26 #include "ttload.h"
27 #include "ttcmap.h"
28 #include "sfntpic.h"
29
30
31 /*************************************************************************/
32 /* */
33 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
34 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
35 /* messages during execution. */
36 /* */
37 #undef FT_COMPONENT
38 #define FT_COMPONENT trace_ttcmap
39
40
41 #define TT_PEEK_SHORT FT_PEEK_SHORT
42 #define TT_PEEK_USHORT FT_PEEK_USHORT
43 #define TT_PEEK_UINT24 FT_PEEK_UOFF3
44 #define TT_PEEK_LONG FT_PEEK_LONG
45 #define TT_PEEK_ULONG FT_PEEK_ULONG
46
47 #define TT_NEXT_SHORT FT_NEXT_SHORT
48 #define TT_NEXT_USHORT FT_NEXT_USHORT
49 #define TT_NEXT_UINT24 FT_NEXT_UOFF3
50 #define TT_NEXT_LONG FT_NEXT_LONG
51 #define TT_NEXT_ULONG FT_NEXT_ULONG
52
53
54 FT_CALLBACK_DEF( FT_Error )
55 tt_cmap_init( TT_CMap cmap,
56 FT_Byte* table )
57 {
58 cmap->data = table;
59 return SFNT_Err_Ok;
60 }
61
62
63 /*************************************************************************/
64 /*************************************************************************/
65 /***** *****/
66 /***** FORMAT 0 *****/
67 /***** *****/
68 /*************************************************************************/
69 /*************************************************************************/
70
71 /*************************************************************************/
72 /* */
73 /* TABLE OVERVIEW */
74 /* -------------- */
75 /* */
76 /* NAME OFFSET TYPE DESCRIPTION */
77 /* */
78 /* format 0 USHORT must be 0 */
79 /* length 2 USHORT table length in bytes */
80 /* language 4 USHORT Mac language code */
81 /* glyph_ids 6 BYTE[256] array of glyph indices */
82 /* 262 */
83 /* */
84
85 #ifdef TT_CONFIG_CMAP_FORMAT_0
86
87 FT_CALLBACK_DEF( FT_Error )
88 tt_cmap0_validate( FT_Byte* table,
89 FT_Validator valid )
90 {
91 FT_Byte* p = table + 2;
92 FT_UInt length = TT_NEXT_USHORT( p );
93
94
95 if ( table + length > valid->limit || length < 262 )
96 FT_INVALID_TOO_SHORT;
97
98 /* check glyph indices whenever necessary */
99 if ( valid->level >= FT_VALIDATE_TIGHT )
100 {
101 FT_UInt n, idx;
102
103
104 p = table + 6;
105 for ( n = 0; n < 256; n++ )
106 {
107 idx = *p++;
108 if ( idx >= TT_VALID_GLYPH_COUNT( valid ) )
109 FT_INVALID_GLYPH_ID;
110 }
111 }
112
113 return SFNT_Err_Ok;
114 }
115
116
117 FT_CALLBACK_DEF( FT_UInt )
118 tt_cmap0_char_index( TT_CMap cmap,
119 FT_UInt32 char_code )
120 {
121 FT_Byte* table = cmap->data;
122
123
124 return char_code < 256 ? table[6 + char_code] : 0;
125 }
126
127
128 FT_CALLBACK_DEF( FT_UInt32 )
129 tt_cmap0_char_next( TT_CMap cmap,
130 FT_UInt32 *pchar_code )
131 {
132 FT_Byte* table = cmap->data;
133 FT_UInt32 charcode = *pchar_code;
134 FT_UInt32 result = 0;
135 FT_UInt gindex = 0;
136
137
138 table += 6; /* go to glyph IDs */
139 while ( ++charcode < 256 )
140 {
141 gindex = table[charcode];
142 if ( gindex != 0 )
143 {
144 result = charcode;
145 break;
146 }
147 }
148
149 *pchar_code = result;
150 return gindex;
151 }
152
153
154 FT_CALLBACK_DEF( FT_Error )
155 tt_cmap0_get_info( TT_CMap cmap,
156 TT_CMapInfo *cmap_info )
157 {
158 FT_Byte* p = cmap->data + 4;
159
160
161 cmap_info->format = 0;
162 cmap_info->language = (FT_ULong)TT_PEEK_USHORT( p );
163
164 return SFNT_Err_Ok;
165 }
166
167
168 FT_DEFINE_TT_CMAP(tt_cmap0_class_rec,
169 sizeof ( TT_CMapRec ),
170
171 (FT_CMap_InitFunc) tt_cmap_init,
172 (FT_CMap_DoneFunc) NULL,
173 (FT_CMap_CharIndexFunc)tt_cmap0_char_index,
174 (FT_CMap_CharNextFunc) tt_cmap0_char_next,
175
176 NULL, NULL, NULL, NULL, NULL
177 ,
178 0,
179 (TT_CMap_ValidateFunc) tt_cmap0_validate,
180 (TT_CMap_Info_GetFunc) tt_cmap0_get_info
181 )
182
183 #endif /* TT_CONFIG_CMAP_FORMAT_0 */
184
185
186 /*************************************************************************/
187 /*************************************************************************/
188 /***** *****/
189 /***** FORMAT 2 *****/
190 /***** *****/
191 /***** This is used for certain CJK encodings that encode text in a *****/
192 /***** mixed 8/16 bits encoding along the following lines: *****/
193 /***** *****/
194 /***** * Certain byte values correspond to an 8-bit character code *****/
195 /***** (typically in the range 0..127 for ASCII compatibility). *****/
196 /***** *****/
197 /***** * Certain byte values signal the first byte of a 2-byte *****/
198 /***** character code (but these values are also valid as the *****/
199 /***** second byte of a 2-byte character). *****/
200 /***** *****/
201 /***** The following charmap lookup and iteration functions all *****/
202 /***** assume that the value "charcode" correspond to following: *****/
203 /***** *****/
204 /***** - For one byte characters, "charcode" is simply the *****/
205 /***** character code. *****/
206 /***** *****/
207 /***** - For two byte characters, "charcode" is the 2-byte *****/
208 /***** character code in big endian format. More exactly: *****/
209 /***** *****/
210 /***** (charcode >> 8) is the first byte value *****/
211 /***** (charcode & 0xFF) is the second byte value *****/
212 /***** *****/
213 /***** Note that not all values of "charcode" are valid according *****/
214 /***** to these rules, and the function moderately check the *****/
215 /***** arguments. *****/
216 /***** *****/
217 /*************************************************************************/
218 /*************************************************************************/
219
220 /*************************************************************************/
221 /* */
222 /* TABLE OVERVIEW */
223 /* -------------- */
224 /* */
225 /* NAME OFFSET TYPE DESCRIPTION */
226 /* */
227 /* format 0 USHORT must be 2 */
228 /* length 2 USHORT table length in bytes */
229 /* language 4 USHORT Mac language code */
230 /* keys 6 USHORT[256] sub-header keys */
231 /* subs 518 SUBHEAD[NSUBS] sub-headers array */
232 /* glyph_ids 518+NSUB*8 USHORT[] glyph ID array */
233 /* */
234 /* The `keys' table is used to map charcode high-bytes to sub-headers. */
235 /* The value of `NSUBS' is the number of sub-headers defined in the */
236 /* table and is computed by finding the maximum of the `keys' table. */
237 /* */
238 /* Note that for any n, `keys[n]' is a byte offset within the `subs' */
239 /* table, i.e., it is the corresponding sub-header index multiplied */
240 /* by 8. */
241 /* */
242 /* Each sub-header has the following format: */
243 /* */
244 /* NAME OFFSET TYPE DESCRIPTION */
245 /* */
246 /* first 0 USHORT first valid low-byte */
247 /* count 2 USHORT number of valid low-bytes */
248 /* delta 4 SHORT see below */
249 /* offset 6 USHORT see below */
250 /* */
251 /* A sub-header defines, for each high-byte, the range of valid */
252 /* low-bytes within the charmap. Note that the range defined by `first' */
253 /* and `count' must be completely included in the interval [0..255] */
254 /* according to the specification. */
255 /* */
256 /* If a character code is contained within a given sub-header, then */
257 /* mapping it to a glyph index is done as follows: */
258 /* */
259 /* * The value of `offset' is read. This is a _byte_ distance from the */
260 /* location of the `offset' field itself into a slice of the */
261 /* `glyph_ids' table. Let's call it `slice' (it is a USHORT[] too). */
262 /* */
263 /* * The value `slice[char.lo - first]' is read. If it is 0, there is */
264 /* no glyph for the charcode. Otherwise, the value of `delta' is */
265 /* added to it (modulo 65536) to form a new glyph index. */
266 /* */
267 /* It is up to the validation routine to check that all offsets fall */
268 /* within the glyph IDs table (and not within the `subs' table itself or */
269 /* outside of the CMap). */
270 /* */
271
272 #ifdef TT_CONFIG_CMAP_FORMAT_2
273
274 FT_CALLBACK_DEF( FT_Error )
275 tt_cmap2_validate( FT_Byte* table,
276 FT_Validator valid )
277 {
278 FT_Byte* p = table + 2; /* skip format */
279 FT_UInt length = TT_PEEK_USHORT( p );
280 FT_UInt n, max_subs;
281 FT_Byte* keys; /* keys table */
282 FT_Byte* subs; /* sub-headers */
283 FT_Byte* glyph_ids; /* glyph ID array */
284
285
286 if ( table + length > valid->limit || length < 6 + 512 )
287 FT_INVALID_TOO_SHORT;
288
289 keys = table + 6;
290
291 /* parse keys to compute sub-headers count */
292 p = keys;
293 max_subs = 0;
294 for ( n = 0; n < 256; n++ )
295 {
296 FT_UInt idx = TT_NEXT_USHORT( p );
297
298
299 /* value must be multiple of 8 */
300 if ( valid->level >= FT_VALIDATE_PARANOID && ( idx & 7 ) != 0 )
301 FT_INVALID_DATA;
302
303 idx >>= 3;
304
305 if ( idx > max_subs )
306 max_subs = idx;
307 }
308
309 FT_ASSERT( p == table + 518 );
310
311 subs = p;
312 glyph_ids = subs + (max_subs + 1) * 8;
313 if ( glyph_ids > valid->limit )
314 FT_INVALID_TOO_SHORT;
315
316 /* parse sub-headers */
317 for ( n = 0; n <= max_subs; n++ )
318 {
319 FT_UInt first_code, code_count, offset;
320 FT_Int delta;
321 FT_Byte* ids;
322
323
324 first_code = TT_NEXT_USHORT( p );
325 code_count = TT_NEXT_USHORT( p );
326 delta = TT_NEXT_SHORT( p );
327 offset = TT_NEXT_USHORT( p );
328
329 /* many Dynalab fonts have empty sub-headers */
330 if ( code_count == 0 )
331 continue;
332
333 /* check range within 0..255 */
334 if ( valid->level >= FT_VALIDATE_PARANOID )
335 {
336 if ( first_code >= 256 || first_code + code_count > 256 )
337 FT_INVALID_DATA;
338 }
339
340 /* check offset */
341 if ( offset != 0 )
342 {
343 ids = p - 2 + offset;
344 if ( ids < glyph_ids || ids + code_count*2 > table + length )
345 FT_INVALID_OFFSET;
346
347 /* check glyph IDs */
348 if ( valid->level >= FT_VALIDATE_TIGHT )
349 {
350 FT_Byte* limit = p + code_count * 2;
351 FT_UInt idx;
352
353
354 for ( ; p < limit; )
355 {
356 idx = TT_NEXT_USHORT( p );
357 if ( idx != 0 )
358 {
359 idx = ( idx + delta ) & 0xFFFFU;
360 if ( idx >= TT_VALID_GLYPH_COUNT( valid ) )
361 FT_INVALID_GLYPH_ID;
362 }
363 }
364 }
365 }
366 }
367
368 return SFNT_Err_Ok;
369 }
370
371
372 /* return sub header corresponding to a given character code */
373 /* NULL on invalid charcode */
374 static FT_Byte*
375 tt_cmap2_get_subheader( FT_Byte* table,
376 FT_UInt32 char_code )
377 {
378 FT_Byte* result = NULL;
379
380
381 if ( char_code < 0x10000UL )
382 {
383 FT_UInt char_lo = (FT_UInt)( char_code & 0xFF );
384 FT_UInt char_hi = (FT_UInt)( char_code >> 8 );
385 FT_Byte* p = table + 6; /* keys table */
386 FT_Byte* subs = table + 518; /* subheaders table */
387 FT_Byte* sub;
388
389
390 if ( char_hi == 0 )
391 {
392 /* an 8-bit character code -- we use subHeader 0 in this case */
393 /* to test whether the character code is in the charmap */
394 /* */
395 sub = subs; /* jump to first sub-header */
396
397 /* check that the sub-header for this byte is 0, which */
398 /* indicates that it is really a valid one-byte value */
399 /* Otherwise, return 0 */
400 /* */
401 p += char_lo * 2;
402 if ( TT_PEEK_USHORT( p ) != 0 )
403 goto Exit;
404 }
405 else
406 {
407 /* a 16-bit character code */
408
409 /* jump to key entry */
410 p += char_hi * 2;
411 /* jump to sub-header */
412 sub = subs + ( FT_PAD_FLOOR( TT_PEEK_USHORT( p ), 8 ) );
413
414 /* check that the high byte isn't a valid one-byte value */
415 if ( sub == subs )
416 goto Exit;
417 }
418 result = sub;
419 }
420 Exit:
421 return result;
422 }
423
424
425 FT_CALLBACK_DEF( FT_UInt )
426 tt_cmap2_char_index( TT_CMap cmap,
427 FT_UInt32 char_code )
428 {
429 FT_Byte* table = cmap->data;
430 FT_UInt result = 0;
431 FT_Byte* subheader;
432
433
434 subheader = tt_cmap2_get_subheader( table, char_code );
435 if ( subheader )
436 {
437 FT_Byte* p = subheader;
438 FT_UInt idx = (FT_UInt)(char_code & 0xFF);
439 FT_UInt start, count;
440 FT_Int delta;
441 FT_UInt offset;
442
443
444 start = TT_NEXT_USHORT( p );
445 count = TT_NEXT_USHORT( p );
446 delta = TT_NEXT_SHORT ( p );
447 offset = TT_PEEK_USHORT( p );
448
449 idx -= start;
450 if ( idx < count && offset != 0 )
451 {
452 p += offset + 2 * idx;
453 idx = TT_PEEK_USHORT( p );
454
455 if ( idx != 0 )
456 result = (FT_UInt)( idx + delta ) & 0xFFFFU;
457 }
458 }
459 return result;
460 }
461
462
463 FT_CALLBACK_DEF( FT_UInt32 )
464 tt_cmap2_char_next( TT_CMap cmap,
465 FT_UInt32 *pcharcode )
466 {
467 FT_Byte* table = cmap->data;
468 FT_UInt gindex = 0;
469 FT_UInt32 result = 0;
470 FT_UInt32 charcode = *pcharcode + 1;
471 FT_Byte* subheader;
472
473
474 while ( charcode < 0x10000UL )
475 {
476 subheader = tt_cmap2_get_subheader( table, charcode );
477 if ( subheader )
478 {
479 FT_Byte* p = subheader;
480 FT_UInt start = TT_NEXT_USHORT( p );
481 FT_UInt count = TT_NEXT_USHORT( p );
482 FT_Int delta = TT_NEXT_SHORT ( p );
483 FT_UInt offset = TT_PEEK_USHORT( p );
484 FT_UInt char_lo = (FT_UInt)( charcode & 0xFF );
485 FT_UInt pos, idx;
486
487
488 if ( offset == 0 )
489 goto Next_SubHeader;
490
491 if ( char_lo < start )
492 {
493 char_lo = start;
494 pos = 0;
495 }
496 else
497 pos = (FT_UInt)( char_lo - start );
498
499 p += offset + pos * 2;
500 charcode = FT_PAD_FLOOR( charcode, 256 ) + char_lo;
501
502 for ( ; pos < count; pos++, charcode++ )
503 {
504 idx = TT_NEXT_USHORT( p );
505
506 if ( idx != 0 )
507 {
508 gindex = ( idx + delta ) & 0xFFFFU;
509 if ( gindex != 0 )
510 {
511 result = charcode;
512 goto Exit;
513 }
514 }
515 }
516 }
517
518 /* jump to next sub-header, i.e. higher byte value */
519 Next_SubHeader:
520 charcode = FT_PAD_FLOOR( charcode, 256 ) + 256;
521 }
522
523 Exit:
524 *pcharcode = result;
525
526 return gindex;
527 }
528
529
530 FT_CALLBACK_DEF( FT_Error )
531 tt_cmap2_get_info( TT_CMap cmap,
532 TT_CMapInfo *cmap_info )
533 {
534 FT_Byte* p = cmap->data + 4;
535
536
537 cmap_info->format = 2;
538 cmap_info->language = (FT_ULong)TT_PEEK_USHORT( p );
539
540 return SFNT_Err_Ok;
541 }
542
543
544 FT_DEFINE_TT_CMAP(tt_cmap2_class_rec,
545 sizeof ( TT_CMapRec ),
546
547 (FT_CMap_InitFunc) tt_cmap_init,
548 (FT_CMap_DoneFunc) NULL,
549 (FT_CMap_CharIndexFunc)tt_cmap2_char_index,
550 (FT_CMap_CharNextFunc) tt_cmap2_char_next,
551
552 NULL, NULL, NULL, NULL, NULL
553 ,
554 2,
555 (TT_CMap_ValidateFunc) tt_cmap2_validate,
556 (TT_CMap_Info_GetFunc) tt_cmap2_get_info
557 )
558
559 #endif /* TT_CONFIG_CMAP_FORMAT_2 */
560
561
562 /*************************************************************************/
563 /*************************************************************************/
564 /***** *****/
565 /***** FORMAT 4 *****/
566 /***** *****/
567 /*************************************************************************/
568 /*************************************************************************/
569
570 /*************************************************************************/
571 /* */
572 /* TABLE OVERVIEW */
573 /* -------------- */
574 /* */
575 /* NAME OFFSET TYPE DESCRIPTION */
576 /* */
577 /* format 0 USHORT must be 4 */
578 /* length 2 USHORT table length */
579 /* in bytes */
580 /* language 4 USHORT Mac language code */
581 /* */
582 /* segCountX2 6 USHORT 2*NUM_SEGS */
583 /* searchRange 8 USHORT 2*(1 << LOG_SEGS) */
584 /* entrySelector 10 USHORT LOG_SEGS */
585 /* rangeShift 12 USHORT segCountX2 - */
586 /* searchRange */
587 /* */
588 /* endCount 14 USHORT[NUM_SEGS] end charcode for */
589 /* each segment; last */
590 /* is 0xFFFF */
591 /* */
592 /* pad 14+NUM_SEGS*2 USHORT padding */
593 /* */
594 /* startCount 16+NUM_SEGS*2 USHORT[NUM_SEGS] first charcode for */
595 /* each segment */
596 /* */
597 /* idDelta 16+NUM_SEGS*4 SHORT[NUM_SEGS] delta for each */
598 /* segment */
599 /* idOffset 16+NUM_SEGS*6 SHORT[NUM_SEGS] range offset for */
600 /* each segment; can be */
601 /* zero */
602 /* */
603 /* glyphIds 16+NUM_SEGS*8 USHORT[] array of glyph ID */
604 /* ranges */
605 /* */
606 /* Character codes are modelled by a series of ordered (increasing) */
607 /* intervals called segments. Each segment has start and end codes, */
608 /* provided by the `startCount' and `endCount' arrays. Segments must */
609 /* not overlap, and the last segment should always contain the value */
610 /* 0xFFFF for `endCount'. */
611 /* */
612 /* The fields `searchRange', `entrySelector' and `rangeShift' are better */
613 /* ignored (they are traces of over-engineering in the TrueType */
614 /* specification). */
615 /* */
616 /* Each segment also has a signed `delta', as well as an optional offset */
617 /* within the `glyphIds' table. */
618 /* */
619 /* If a segment's idOffset is 0, the glyph index corresponding to any */
620 /* charcode within the segment is obtained by adding the value of */
621 /* `idDelta' directly to the charcode, modulo 65536. */
622 /* */
623 /* Otherwise, a glyph index is taken from the glyph IDs sub-array for */
624 /* the segment, and the value of `idDelta' is added to it. */
625 /* */
626 /* */
627 /* Finally, note that a lot of fonts contain an invalid last segment, */
628 /* where `start' and `end' are correctly set to 0xFFFF but both `delta' */
629 /* and `offset' are incorrect (e.g., `opens___.ttf' which comes with */
630 /* OpenOffice.org). We need special code to deal with them correctly. */
631 /* */
632
633 #ifdef TT_CONFIG_CMAP_FORMAT_4
634
635 typedef struct TT_CMap4Rec_
636 {
637 TT_CMapRec cmap;
638 FT_UInt32 cur_charcode; /* current charcode */
639 FT_UInt cur_gindex; /* current glyph index */
640
641 FT_UInt num_ranges;
642 FT_UInt cur_range;
643 FT_UInt cur_start;
644 FT_UInt cur_end;
645 FT_Int cur_delta;
646 FT_Byte* cur_values;
647
648 } TT_CMap4Rec, *TT_CMap4;
649
650
651 FT_CALLBACK_DEF( FT_Error )
652 tt_cmap4_init( TT_CMap4 cmap,
653 FT_Byte* table )
654 {
655 FT_Byte* p;
656
657
658 cmap->cmap.data = table;
659
660 p = table + 6;
661 cmap->num_ranges = FT_PEEK_USHORT( p ) >> 1;
662 cmap->cur_charcode = (FT_UInt32)0xFFFFFFFFUL;
663 cmap->cur_gindex = 0;
664
665 return SFNT_Err_Ok;
666 }
667
668
669 static FT_Int
670 tt_cmap4_set_range( TT_CMap4 cmap,
671 FT_UInt range_index )
672 {
673 FT_Byte* table = cmap->cmap.data;
674 FT_Byte* p;
675 FT_UInt num_ranges = cmap->num_ranges;
676
677
678 while ( range_index < num_ranges )
679 {
680 FT_UInt offset;
681
682
683 p = table + 14 + range_index * 2;
684 cmap->cur_end = FT_PEEK_USHORT( p );
685
686 p += 2 + num_ranges * 2;
687 cmap->cur_start = FT_PEEK_USHORT( p );
688
689 p += num_ranges * 2;
690 cmap->cur_delta = FT_PEEK_SHORT( p );
691
692 p += num_ranges * 2;
693 offset = FT_PEEK_USHORT( p );
694
695 /* some fonts have an incorrect last segment; */
696 /* we have to catch it */
697 if ( range_index >= num_ranges - 1 &&
698 cmap->cur_start == 0xFFFFU &&
699 cmap->cur_end == 0xFFFFU )
700 {
701 TT_Face face = (TT_Face)cmap->cmap.cmap.charmap.face;
702 FT_Byte* limit = face->cmap_table + face->cmap_size;
703
704
705 if ( offset && p + offset + 2 > limit )
706 {
707 cmap->cur_delta = 1;
708 offset = 0;
709 }
710 }
711
712 if ( offset != 0xFFFFU )
713 {
714 cmap->cur_values = offset ? p + offset : NULL;
715 cmap->cur_range = range_index;
716 return 0;
717 }
718
719 /* we skip empty segments */
720 range_index++;
721 }
722
723 return -1;
724 }
725
726
727 /* search the index of the charcode next to cmap->cur_charcode; */
728 /* caller should call tt_cmap4_set_range with proper range */
729 /* before calling this function */
730 /* */
731 static void
732 tt_cmap4_next( TT_CMap4 cmap )
733 {
734 FT_UInt charcode;
735
736
737 if ( cmap->cur_charcode >= 0xFFFFUL )
738 goto Fail;
739
740 charcode = (FT_UInt)cmap->cur_charcode + 1;
741
742 if ( charcode < cmap->cur_start )
743 charcode = cmap->cur_start;
744
745 for ( ;; )
746 {
747 FT_Byte* values = cmap->cur_values;
748 FT_UInt end = cmap->cur_end;
749 FT_Int delta = cmap->cur_delta;
750
751
752 if ( charcode <= end )
753 {
754 if ( values )
755 {
756 FT_Byte* p = values + 2 * ( charcode - cmap->cur_start );
757
758
759 do
760 {
761 FT_UInt gindex = FT_NEXT_USHORT( p );
762
763
764 if ( gindex != 0 )
765 {
766 gindex = (FT_UInt)( ( gindex + delta ) & 0xFFFFU );
767 if ( gindex != 0 )
768 {
769 cmap->cur_charcode = charcode;
770 cmap->cur_gindex = gindex;
771 return;
772 }
773 }
774 } while ( ++charcode <= end );
775 }
776 else
777 {
778 do
779 {
780 FT_UInt gindex = (FT_UInt)( ( charcode + delta ) & 0xFFFFU );
781
782
783 if ( gindex != 0 )
784 {
785 cmap->cur_charcode = charcode;
786 cmap->cur_gindex = gindex;
787 return;
788 }
789 } while ( ++charcode <= end );
790 }
791 }
792
793 /* we need to find another range */
794 if ( tt_cmap4_set_range( cmap, cmap->cur_range + 1 ) < 0 )
795 break;
796
797 if ( charcode < cmap->cur_start )
798 charcode = cmap->cur_start;
799 }
800
801 Fail:
802 cmap->cur_charcode = (FT_UInt32)0xFFFFFFFFUL;
803 cmap->cur_gindex = 0;
804 }
805
806
807 FT_CALLBACK_DEF( FT_Error )
808 tt_cmap4_validate( FT_Byte* table,
809 FT_Validator valid )
810 {
811 FT_Byte* p = table + 2; /* skip format */
812 FT_UInt length = TT_NEXT_USHORT( p );
813 FT_Byte *ends, *starts, *offsets, *deltas, *glyph_ids;
814 FT_UInt num_segs;
815 FT_Error error = SFNT_Err_Ok;
816
817
818 if ( length < 16 )
819 FT_INVALID_TOO_SHORT;
820
821 /* in certain fonts, the `length' field is invalid and goes */
822 /* out of bound. We try to correct this here... */
823 if ( table + length > valid->limit )
824 {
825 if ( valid->level >= FT_VALIDATE_TIGHT )
826 FT_INVALID_TOO_SHORT;
827
828 length = (FT_UInt)( valid->limit - table );
829 }
830
831 p = table + 6;
832 num_segs = TT_NEXT_USHORT( p ); /* read segCountX2 */
833
834 if ( valid->level >= FT_VALIDATE_PARANOID )
835 {
836 /* check that we have an even value here */
837 if ( num_segs & 1 )
838 FT_INVALID_DATA;
839 }
840
841 num_segs /= 2;
842
843 if ( length < 16 + num_segs * 2 * 4 )
844 FT_INVALID_TOO_SHORT;
845
846 /* check the search parameters - even though we never use them */
847 /* */
848 if ( valid->level >= FT_VALIDATE_PARANOID )
849 {
850 /* check the values of `searchRange', `entrySelector', `rangeShift' */
851 FT_UInt search_range = TT_NEXT_USHORT( p );
852 FT_UInt entry_selector = TT_NEXT_USHORT( p );
853 FT_UInt range_shift = TT_NEXT_USHORT( p );
854
855
856 if ( ( search_range | range_shift ) & 1 ) /* must be even values */
857 FT_INVALID_DATA;
858
859 search_range /= 2;
860 range_shift /= 2;
861
862 /* `search range' is the greatest power of 2 that is <= num_segs */
863
864 if ( search_range > num_segs ||
865 search_range * 2 < num_segs ||
866 search_range + range_shift != num_segs ||
867 search_range != ( 1U << entry_selector ) )
868 FT_INVALID_DATA;
869 }
870
871 ends = table + 14;
872 starts = table + 16 + num_segs * 2;
873 deltas = starts + num_segs * 2;
874 offsets = deltas + num_segs * 2;
875 glyph_ids = offsets + num_segs * 2;
876
877 /* check last segment; its end count value must be 0xFFFF */
878 if ( valid->level >= FT_VALIDATE_PARANOID )
879 {
880 p = ends + ( num_segs - 1 ) * 2;
881 if ( TT_PEEK_USHORT( p ) != 0xFFFFU )
882 FT_INVALID_DATA;
883 }
884
885 {
886 FT_UInt start, end, offset, n;
887 FT_UInt last_start = 0, last_end = 0;
888 FT_Int delta;
889 FT_Byte* p_start = starts;
890 FT_Byte* p_end = ends;
891 FT_Byte* p_delta = deltas;
892 FT_Byte* p_offset = offsets;
893
894
895 for ( n = 0; n < num_segs; n++ )
896 {
897 p = p_offset;
898 start = TT_NEXT_USHORT( p_start );
899 end = TT_NEXT_USHORT( p_end );
900 delta = TT_NEXT_SHORT( p_delta );
901 offset = TT_NEXT_USHORT( p_offset );
902
903 if ( start > end )
904 FT_INVALID_DATA;
905
906 /* this test should be performed at default validation level; */
907 /* unfortunately, some popular Asian fonts have overlapping */
908 /* ranges in their charmaps */
909 /* */
910 if ( start <= last_end && n > 0 )
911 {
912 if ( valid->level >= FT_VALIDATE_TIGHT )
913 FT_INVALID_DATA;
914 else
915 {
916 /* allow overlapping segments, provided their start points */
917 /* and end points, respectively, are in ascending order */
918 /* */
919 if ( last_start > start || last_end > end )
920 error |= TT_CMAP_FLAG_UNSORTED;
921 else
922 error |= TT_CMAP_FLAG_OVERLAPPING;
923 }
924 }
925
926 if ( offset && offset != 0xFFFFU )
927 {
928 p += offset; /* start of glyph ID array */
929
930 /* check that we point within the glyph IDs table only */
931 if ( valid->level >= FT_VALIDATE_TIGHT )
932 {
933 if ( p < glyph_ids ||
934 p + ( end - start + 1 ) * 2 > table + length )
935 FT_INVALID_DATA;
936 }
937 /* Some fonts handle the last segment incorrectly. In */
938 /* theory, 0xFFFF might point to an ordinary glyph -- */
939 /* a cmap 4 is versatile and could be used for any */
940 /* encoding, not only Unicode. However, reality shows */
941 /* that far too many fonts are sloppy and incorrectly */
942 /* set all fields but `start' and `end' for the last */
943 /* segment if it contains only a single character. */
944 /* */
945 /* We thus omit the test here, delaying it to the */
946 /* routines which actually access the cmap. */
947 else if ( n != num_segs - 1 ||
948 !( start == 0xFFFFU && end == 0xFFFFU ) )
949 {
950 if ( p < glyph_ids ||
951 p + ( end - start + 1 ) * 2 > valid->limit )
952 FT_INVALID_DATA;
953 }
954
955 /* check glyph indices within the segment range */
956 if ( valid->level >= FT_VALIDATE_TIGHT )
957 {
958 FT_UInt i, idx;
959
960
961 for ( i = start; i < end; i++ )
962 {
963 idx = FT_NEXT_USHORT( p );
964 if ( idx != 0 )
965 {
966 idx = (FT_UInt)( idx + delta ) & 0xFFFFU;
967
968 if ( idx >= TT_VALID_GLYPH_COUNT( valid ) )
969 FT_INVALID_GLYPH_ID;
970 }
971 }
972 }
973 }
974 else if ( offset == 0xFFFFU )
975 {
976 /* some fonts (erroneously?) use a range offset of 0xFFFF */
977 /* to mean missing glyph in cmap table */
978 /* */
979 if ( valid->level >= FT_VALIDATE_PARANOID ||
980 n != num_segs - 1 ||
981 !( start == 0xFFFFU && end == 0xFFFFU ) )
982 FT_INVALID_DATA;
983 }
984
985 last_start = start;
986 last_end = end;
987 }
988 }
989
990 return error;
991 }
992
993
994 static FT_UInt
995 tt_cmap4_char_map_linear( TT_CMap cmap,
996 FT_UInt32* pcharcode,
997 FT_Bool next )
998 {
999 FT_UInt num_segs2, start, end, offset;
1000 FT_Int delta;
1001 FT_UInt i, num_segs;
1002 FT_UInt32 charcode = *pcharcode;
1003 FT_UInt gindex = 0;
1004 FT_Byte* p;
1005
1006
1007 p = cmap->data + 6;
1008 num_segs2 = FT_PAD_FLOOR( TT_PEEK_USHORT( p ), 2 );
1009
1010 num_segs = num_segs2 >> 1;
1011
1012 if ( !num_segs )
1013 return 0;
1014
1015 if ( next )
1016 charcode++;
1017
1018 /* linear search */
1019 for ( ; charcode <= 0xFFFFU; charcode++ )
1020 {
1021 FT_Byte* q;
1022
1023
1024 p = cmap->data + 14; /* ends table */
1025 q = cmap->data + 16 + num_segs2; /* starts table */
1026
1027 for ( i = 0; i < num_segs; i++ )
1028 {
1029 end = TT_NEXT_USHORT( p );
1030 start = TT_NEXT_USHORT( q );
1031
1032 if ( charcode >= start && charcode <= end )
1033 {
1034 p = q - 2 + num_segs2;
1035 delta = TT_PEEK_SHORT( p );
1036 p += num_segs2;
1037 offset = TT_PEEK_USHORT( p );
1038
1039 /* some fonts have an incorrect last segment; */
1040 /* we have to catch it */
1041 if ( i >= num_segs - 1 &&
1042 start == 0xFFFFU && end == 0xFFFFU )
1043 {
1044 TT_Face face = (TT_Face)cmap->cmap.charmap.face;
1045 FT_Byte* limit = face->cmap_table + face->cmap_size;
1046
1047
1048 if ( offset && p + offset + 2 > limit )
1049 {
1050 delta = 1;
1051 offset = 0;
1052 }
1053 }
1054
1055 if ( offset == 0xFFFFU )
1056 continue;
1057
1058 if ( offset )
1059 {
1060 p += offset + ( charcode - start ) * 2;
1061 gindex = TT_PEEK_USHORT( p );
1062 if ( gindex != 0 )
1063 gindex = (FT_UInt)( gindex + delta ) & 0xFFFFU;
1064 }
1065 else
1066 gindex = (FT_UInt)( charcode + delta ) & 0xFFFFU;
1067
1068 break;
1069 }
1070 }
1071
1072 if ( !next || gindex )
1073 break;
1074 }
1075
1076 if ( next && gindex )
1077 *pcharcode = charcode;
1078
1079 return gindex;
1080 }
1081
1082
1083 static FT_UInt
1084 tt_cmap4_char_map_binary( TT_CMap cmap,
1085 FT_UInt32* pcharcode,
1086 FT_Bool next )
1087 {
1088 FT_UInt num_segs2, start, end, offset;
1089 FT_Int delta;
1090 FT_UInt max, min, mid, num_segs;
1091 FT_UInt charcode = (FT_UInt)*pcharcode;
1092 FT_UInt gindex = 0;
1093 FT_Byte* p;
1094
1095
1096 p = cmap->data + 6;
1097 num_segs2 = FT_PAD_FLOOR( TT_PEEK_USHORT( p ), 2 );
1098
1099 if ( !num_segs2 )
1100 return 0;
1101
1102 num_segs = num_segs2 >> 1;
1103
1104 /* make compiler happy */
1105 mid = num_segs;
1106 end = 0xFFFFU;
1107
1108 if ( next )
1109 charcode++;
1110
1111 min = 0;
1112 max = num_segs;
1113
1114 /* binary search */
1115 while ( min < max )
1116 {
1117 mid = ( min + max ) >> 1;
1118 p = cmap->data + 14 + mid * 2;
1119 end = TT_PEEK_USHORT( p );
1120 p += 2 + num_segs2;
1121 start = TT_PEEK_USHORT( p );
1122
1123 if ( charcode < start )
1124 max = mid;
1125 else if ( charcode > end )
1126 min = mid + 1;
1127 else
1128 {
1129 p += num_segs2;
1130 delta = TT_PEEK_SHORT( p );
1131 p += num_segs2;
1132 offset = TT_PEEK_USHORT( p );
1133
1134 /* some fonts have an incorrect last segment; */
1135 /* we have to catch it */
1136 if ( mid >= num_segs - 1 &&
1137 start == 0xFFFFU && end == 0xFFFFU )
1138 {
1139 TT_Face face = (TT_Face)cmap->cmap.charmap.face;
1140 FT_Byte* limit = face->cmap_table + face->cmap_size;
1141
1142
1143 if ( offset && p + offset + 2 > limit )
1144 {
1145 delta = 1;
1146 offset = 0;
1147 }
1148 }
1149
1150 /* search the first segment containing `charcode' */
1151 if ( cmap->flags & TT_CMAP_FLAG_OVERLAPPING )
1152 {
1153 FT_UInt i;
1154
1155
1156 /* call the current segment `max' */
1157 max = mid;
1158
1159 if ( offset == 0xFFFFU )
1160 mid = max + 1;
1161
1162 /* search in segments before the current segment */
1163 for ( i = max ; i > 0; i-- )
1164 {
1165 FT_UInt prev_end;
1166 FT_Byte* old_p;
1167
1168
1169 old_p = p;
1170 p = cmap->data + 14 + ( i - 1 ) * 2;
1171 prev_end = TT_PEEK_USHORT( p );
1172
1173 if ( charcode > prev_end )
1174 {
1175 p = old_p;
1176 break;
1177 }
1178
1179 end = prev_end;
1180 p += 2 + num_segs2;
1181 start = TT_PEEK_USHORT( p );
1182 p += num_segs2;
1183 delta = TT_PEEK_SHORT( p );
1184 p += num_segs2;
1185 offset = TT_PEEK_USHORT( p );
1186
1187 if ( offset != 0xFFFFU )
1188 mid = i - 1;
1189 }
1190
1191 /* no luck */
1192 if ( mid == max + 1 )
1193 {
1194 if ( i != max )
1195 {
1196 p = cmap->data + 14 + max * 2;
1197 end = TT_PEEK_USHORT( p );
1198 p += 2 + num_segs2;
1199 start = TT_PEEK_USHORT( p );
1200 p += num_segs2;
1201 delta = TT_PEEK_SHORT( p );
1202 p += num_segs2;
1203 offset = TT_PEEK_USHORT( p );
1204 }
1205
1206 mid = max;
1207
1208 /* search in segments after the current segment */
1209 for ( i = max + 1; i < num_segs; i++ )
1210 {
1211 FT_UInt next_end, next_start;
1212
1213
1214 p = cmap->data + 14 + i * 2;
1215 next_end = TT_PEEK_USHORT( p );
1216 p += 2 + num_segs2;
1217 next_start = TT_PEEK_USHORT( p );
1218
1219 if ( charcode < next_start )
1220 break;
1221
1222 end = next_end;
1223 start = next_start;
1224 p += num_segs2;
1225 delta = TT_PEEK_SHORT( p );
1226 p += num_segs2;
1227 offset = TT_PEEK_USHORT( p );
1228
1229 if ( offset != 0xFFFFU )
1230 mid = i;
1231 }
1232 i--;
1233
1234 /* still no luck */
1235 if ( mid == max )
1236 {
1237 mid = i;
1238
1239 break;
1240 }
1241 }
1242
1243 /* end, start, delta, and offset are for the i'th segment */
1244 if ( mid != i )
1245 {
1246 p = cmap->data + 14 + mid * 2;
1247 end = TT_PEEK_USHORT( p );
1248 p += 2 + num_segs2;
1249 start = TT_PEEK_USHORT( p );
1250 p += num_segs2;
1251 delta = TT_PEEK_SHORT( p );
1252 p += num_segs2;
1253 offset = TT_PEEK_USHORT( p );
1254 }
1255 }
1256 else
1257 {
1258 if ( offset == 0xFFFFU )
1259 break;
1260 }
1261
1262 if ( offset )
1263 {
1264 p += offset + ( charcode - start ) * 2;
1265 gindex = TT_PEEK_USHORT( p );
1266 if ( gindex != 0 )
1267 gindex = (FT_UInt)( gindex + delta ) & 0xFFFFU;
1268 }
1269 else
1270 gindex = (FT_UInt)( charcode + delta ) & 0xFFFFU;
1271
1272 break;
1273 }
1274 }
1275
1276 if ( next )
1277 {
1278 TT_CMap4 cmap4 = (TT_CMap4)cmap;
1279
1280
1281 /* if `charcode' is not in any segment, then `mid' is */
1282 /* the segment nearest to `charcode' */
1283 /* */
1284
1285 if ( charcode > end )
1286 {
1287 mid++;
1288 if ( mid == num_segs )
1289 return 0;
1290 }
1291
1292 if ( tt_cmap4_set_range( cmap4, mid ) )
1293 {
1294 if ( gindex )
1295 *pcharcode = charcode;
1296 }
1297 else
1298 {
1299 cmap4->cur_charcode = charcode;
1300
1301 if ( gindex )
1302 cmap4->cur_gindex = gindex;
1303 else
1304 {
1305 cmap4->cur_charcode = charcode;
1306 tt_cmap4_next( cmap4 );
1307 gindex = cmap4->cur_gindex;
1308 }
1309
1310 if ( gindex )
1311 *pcharcode = cmap4->cur_charcode;
1312 }
1313 }
1314
1315 return gindex;
1316 }
1317
1318
1319 FT_CALLBACK_DEF( FT_UInt )
1320 tt_cmap4_char_index( TT_CMap cmap,
1321 FT_UInt32 char_code )
1322 {
1323 if ( char_code >= 0x10000UL )
1324 return 0;
1325
1326 if ( cmap->flags & TT_CMAP_FLAG_UNSORTED )
1327 return tt_cmap4_char_map_linear( cmap, &char_code, 0 );
1328 else
1329 return tt_cmap4_char_map_binary( cmap, &char_code, 0 );
1330 }
1331
1332
1333 FT_CALLBACK_DEF( FT_UInt32 )
1334 tt_cmap4_char_next( TT_CMap cmap,
1335 FT_UInt32 *pchar_code )
1336 {
1337 FT_UInt gindex;
1338
1339
1340 if ( *pchar_code >= 0xFFFFU )
1341 return 0;
1342
1343 if ( cmap->flags & TT_CMAP_FLAG_UNSORTED )
1344 gindex = tt_cmap4_char_map_linear( cmap, pchar_code, 1 );
1345 else
1346 {
1347 TT_CMap4 cmap4 = (TT_CMap4)cmap;
1348
1349
1350 /* no need to search */
1351 if ( *pchar_code == cmap4->cur_charcode )
1352 {
1353 tt_cmap4_next( cmap4 );
1354 gindex = cmap4->cur_gindex;
1355 if ( gindex )
1356 *pchar_code = cmap4->cur_charcode;
1357 }
1358 else
1359 gindex = tt_cmap4_char_map_binary( cmap, pchar_code, 1 );
1360 }
1361
1362 return gindex;
1363 }
1364
1365
1366 FT_CALLBACK_DEF( FT_Error )
1367 tt_cmap4_get_info( TT_CMap cmap,
1368 TT_CMapInfo *cmap_info )
1369 {
1370 FT_Byte* p = cmap->data + 4;
1371
1372
1373 cmap_info->format = 4;
1374 cmap_info->language = (FT_ULong)TT_PEEK_USHORT( p );
1375
1376 return SFNT_Err_Ok;
1377 }
1378
1379
1380 FT_DEFINE_TT_CMAP(tt_cmap4_class_rec,
1381 sizeof ( TT_CMap4Rec ),
1382 (FT_CMap_InitFunc) tt_cmap4_init,
1383 (FT_CMap_DoneFunc) NULL,
1384 (FT_CMap_CharIndexFunc)tt_cmap4_char_index,
1385 (FT_CMap_CharNextFunc) tt_cmap4_char_next,
1386
1387 NULL, NULL, NULL, NULL, NULL
1388 ,
1389 4,
1390 (TT_CMap_ValidateFunc) tt_cmap4_validate,
1391 (TT_CMap_Info_GetFunc) tt_cmap4_get_info
1392 )
1393
1394 #endif /* TT_CONFIG_CMAP_FORMAT_4 */
1395
1396
1397 /*************************************************************************/
1398 /*************************************************************************/
1399 /***** *****/
1400 /***** FORMAT 6 *****/
1401 /***** *****/
1402 /*************************************************************************/
1403 /*************************************************************************/
1404
1405 /*************************************************************************/
1406 /* */
1407 /* TABLE OVERVIEW */
1408 /* -------------- */
1409 /* */
1410 /* NAME OFFSET TYPE DESCRIPTION */
1411 /* */
1412 /* format 0 USHORT must be 4 */
1413 /* length 2 USHORT table length in bytes */
1414 /* language 4 USHORT Mac language code */
1415 /* */
1416 /* first 6 USHORT first segment code */
1417 /* count 8 USHORT segment size in chars */
1418 /* glyphIds 10 USHORT[count] glyph IDs */
1419 /* */
1420 /* A very simplified segment mapping. */
1421 /* */
1422
1423 #ifdef TT_CONFIG_CMAP_FORMAT_6
1424
1425 FT_CALLBACK_DEF( FT_Error )
1426 tt_cmap6_validate( FT_Byte* table,
1427 FT_Validator valid )
1428 {
1429 FT_Byte* p;
1430 FT_UInt length, count;
1431
1432
1433 if ( table + 10 > valid->limit )
1434 FT_INVALID_TOO_SHORT;
1435
1436 p = table + 2;
1437 length = TT_NEXT_USHORT( p );
1438
1439 p = table + 8; /* skip language and start index */
1440 count = TT_NEXT_USHORT( p );
1441
1442 if ( table + length > valid->limit || length < 10 + count * 2 )
1443 FT_INVALID_TOO_SHORT;
1444
1445 /* check glyph indices */
1446 if ( valid->level >= FT_VALIDATE_TIGHT )
1447 {
1448 FT_UInt gindex;
1449
1450
1451 for ( ; count > 0; count-- )
1452 {
1453 gindex = TT_NEXT_USHORT( p );
1454 if ( gindex >= TT_VALID_GLYPH_COUNT( valid ) )
1455 FT_INVALID_GLYPH_ID;
1456 }
1457 }
1458
1459 return SFNT_Err_Ok;
1460 }
1461
1462
1463 FT_CALLBACK_DEF( FT_UInt )
1464 tt_cmap6_char_index( TT_CMap cmap,
1465 FT_UInt32 char_code )
1466 {
1467 FT_Byte* table = cmap->data;
1468 FT_UInt result = 0;
1469 FT_Byte* p = table + 6;
1470 FT_UInt start = TT_NEXT_USHORT( p );
1471 FT_UInt count = TT_NEXT_USHORT( p );
1472 FT_UInt idx = (FT_UInt)( char_code - start );
1473
1474
1475 if ( idx < count )
1476 {
1477 p += 2 * idx;
1478 result = TT_PEEK_USHORT( p );
1479 }
1480 return result;
1481 }
1482
1483
1484 FT_CALLBACK_DEF( FT_UInt32 )
1485 tt_cmap6_char_next( TT_CMap cmap,
1486 FT_UInt32 *pchar_code )
1487 {
1488 FT_Byte* table = cmap->data;
1489 FT_UInt32 result = 0;
1490 FT_UInt32 char_code = *pchar_code + 1;
1491 FT_UInt gindex = 0;
1492
1493 FT_Byte* p = table + 6;
1494 FT_UInt start = TT_NEXT_USHORT( p );
1495 FT_UInt count = TT_NEXT_USHORT( p );
1496 FT_UInt idx;
1497
1498
1499 if ( char_code >= 0x10000UL )
1500 goto Exit;
1501
1502 if ( char_code < start )
1503 char_code = start;
1504
1505 idx = (FT_UInt)( char_code - start );
1506 p += 2 * idx;
1507
1508 for ( ; idx < count; idx++ )
1509 {
1510 gindex = TT_NEXT_USHORT( p );
1511 if ( gindex != 0 )
1512 {
1513 result = char_code;
1514 break;
1515 }
1516 char_code++;
1517 }
1518
1519 Exit:
1520 *pchar_code = result;
1521 return gindex;
1522 }
1523
1524
1525 FT_CALLBACK_DEF( FT_Error )
1526 tt_cmap6_get_info( TT_CMap cmap,
1527 TT_CMapInfo *cmap_info )
1528 {
1529 FT_Byte* p = cmap->data + 4;
1530
1531
1532 cmap_info->format = 6;
1533 cmap_info->language = (FT_ULong)TT_PEEK_USHORT( p );
1534
1535 return SFNT_Err_Ok;
1536 }
1537
1538
1539 FT_DEFINE_TT_CMAP(tt_cmap6_class_rec,
1540 sizeof ( TT_CMapRec ),
1541
1542 (FT_CMap_InitFunc) tt_cmap_init,
1543 (FT_CMap_DoneFunc) NULL,
1544 (FT_CMap_CharIndexFunc)tt_cmap6_char_index,
1545 (FT_CMap_CharNextFunc) tt_cmap6_char_next,
1546
1547 NULL, NULL, NULL, NULL, NULL
1548 ,
1549 6,
1550 (TT_CMap_ValidateFunc) tt_cmap6_validate,
1551 (TT_CMap_Info_GetFunc) tt_cmap6_get_info
1552 )
1553
1554 #endif /* TT_CONFIG_CMAP_FORMAT_6 */
1555
1556
1557 /*************************************************************************/
1558 /*************************************************************************/
1559 /***** *****/
1560 /***** FORMAT 8 *****/
1561 /***** *****/
1562 /***** It is hard to completely understand what the OpenType spec *****/
1563 /***** says about this format, but here is my conclusion. *****/
1564 /***** *****/
1565 /***** The purpose of this format is to easily map UTF-16 text to *****/
1566 /***** glyph indices. Basically, the `char_code' must be in one of *****/
1567 /***** the following formats: *****/
1568 /***** *****/
1569 /***** - A 16-bit value that isn't part of the Unicode Surrogates *****/
1570 /***** Area (i.e. U+D800-U+DFFF). *****/
1571 /***** *****/
1572 /***** - A 32-bit value, made of two surrogate values, i.e.. if *****/
1573 /***** `char_code = (char_hi << 16) | char_lo', then both *****/
1574 /***** `char_hi' and `char_lo' must be in the Surrogates Area. *****/
1575 /***** Area. *****/
1576 /***** *****/
1577 /***** The `is32' table embedded in the charmap indicates whether a *****/
1578 /***** given 16-bit value is in the surrogates area or not. *****/
1579 /***** *****/
1580 /***** So, for any given `char_code', we can assert the following: *****/
1581 /***** *****/
1582 /***** If `char_hi == 0' then we must have `is32[char_lo] == 0'. *****/
1583 /***** *****/
1584 /***** If `char_hi != 0' then we must have both *****/
1585 /***** `is32[char_hi] != 0' and `is32[char_lo] != 0'. *****/
1586 /***** *****/
1587 /*************************************************************************/
1588 /*************************************************************************/
1589
1590 /*************************************************************************/
1591 /* */
1592 /* TABLE OVERVIEW */
1593 /* -------------- */
1594 /* */
1595 /* NAME OFFSET TYPE DESCRIPTION */
1596 /* */
1597 /* format 0 USHORT must be 8 */
1598 /* reserved 2 USHORT reserved */
1599 /* length 4 ULONG length in bytes */
1600 /* language 8 ULONG Mac language code */
1601 /* is32 12 BYTE[8192] 32-bitness bitmap */
1602 /* count 8204 ULONG number of groups */
1603 /* */
1604 /* This header is followed by `count' groups of the following format: */
1605 /* */
1606 /* start 0 ULONG first charcode */
1607 /* end 4 ULONG last charcode */
1608 /* startId 8 ULONG start glyph ID for the group */
1609 /* */
1610
1611 #ifdef TT_CONFIG_CMAP_FORMAT_8
1612
1613 FT_CALLBACK_DEF( FT_Error )
1614 tt_cmap8_validate( FT_Byte* table,
1615 FT_Validator valid )
1616 {
1617 FT_Byte* p = table + 4;
1618 FT_Byte* is32;
1619 FT_UInt32 length;
1620 FT_UInt32 num_groups;
1621
1622
1623 if ( table + 16 + 8192 > valid->limit )
1624 FT_INVALID_TOO_SHORT;
1625
1626 length = TT_NEXT_ULONG( p );
1627 if ( length > (FT_UInt32)( valid->limit - table ) || length < 8192 + 16 )
1628 FT_INVALID_TOO_SHORT;
1629
1630 is32 = table + 12;
1631 p = is32 + 8192; /* skip `is32' array */
1632 num_groups = TT_NEXT_ULONG( p );
1633
1634 if ( p + num_groups * 12 > valid->limit )
1635 FT_INVALID_TOO_SHORT;
1636
1637 /* check groups, they must be in increasing order */
1638 {
1639 FT_UInt32 n, start, end, start_id, count, last = 0;
1640
1641
1642 for ( n = 0; n < num_groups; n++ )
1643 {
1644 FT_UInt hi, lo;
1645
1646
1647 start = TT_NEXT_ULONG( p );
1648 end = TT_NEXT_ULONG( p );
1649 start_id = TT_NEXT_ULONG( p );
1650
1651 if ( start > end )
1652 FT_INVALID_DATA;
1653
1654 if ( n > 0 && start <= last )
1655 FT_INVALID_DATA;
1656
1657 if ( valid->level >= FT_VALIDATE_TIGHT )
1658 {
1659 if ( start_id + end - start >= TT_VALID_GLYPH_COUNT( valid ) )
1660 FT_INVALID_GLYPH_ID;
1661
1662 count = (FT_UInt32)( end - start + 1 );
1663
1664 if ( start & ~0xFFFFU )
1665 {
1666 /* start_hi != 0; check that is32[i] is 1 for each i in */
1667 /* the `hi' and `lo' of the range [start..end] */
1668 for ( ; count > 0; count--, start++ )
1669 {
1670 hi = (FT_UInt)( start >> 16 );
1671 lo = (FT_UInt)( start & 0xFFFFU );
1672
1673 if ( (is32[hi >> 3] & ( 0x80 >> ( hi & 7 ) ) ) == 0 )
1674 FT_INVALID_DATA;
1675
1676 if ( (is32[lo >> 3] & ( 0x80 >> ( lo & 7 ) ) ) == 0 )
1677 FT_INVALID_DATA;
1678 }
1679 }
1680 else
1681 {
1682 /* start_hi == 0; check that is32[i] is 0 for each i in */
1683 /* the range [start..end] */
1684
1685 /* end_hi cannot be != 0! */
1686 if ( end & ~0xFFFFU )
1687 FT_INVALID_DATA;
1688
1689 for ( ; count > 0; count--, start++ )
1690 {
1691 lo = (FT_UInt)( start & 0xFFFFU );
1692
1693 if ( (is32[lo >> 3] & ( 0x80 >> ( lo & 7 ) ) ) != 0 )
1694 FT_INVALID_DATA;
1695 }
1696 }
1697 }
1698
1699 last = end;
1700 }
1701 }
1702
1703 return SFNT_Err_Ok;
1704 }
1705
1706
1707 FT_CALLBACK_DEF( FT_UInt )
1708 tt_cmap8_char_index( TT_CMap cmap,
1709 FT_UInt32 char_code )
1710 {
1711 FT_Byte* table = cmap->data;
1712 FT_UInt result = 0;
1713 FT_Byte* p = table + 8204;
1714 FT_UInt32 num_groups = TT_NEXT_ULONG( p );
1715 FT_UInt32 start, end, start_id;
1716
1717
1718 for ( ; num_groups > 0; num_groups-- )
1719 {
1720 start = TT_NEXT_ULONG( p );
1721 end = TT_NEXT_ULONG( p );
1722 start_id = TT_NEXT_ULONG( p );
1723
1724 if ( char_code < start )
1725 break;
1726
1727 if ( char_code <= end )
1728 {
1729 result = (FT_UInt)( start_id + char_code - start );
1730 break;
1731 }
1732 }
1733 return result;
1734 }
1735
1736
1737 FT_CALLBACK_DEF( FT_UInt32 )
1738 tt_cmap8_char_next( TT_CMap cmap,
1739 FT_UInt32 *pchar_code )
1740 {
1741 FT_UInt32 result = 0;
1742 FT_UInt32 char_code = *pchar_code + 1;
1743 FT_UInt gindex = 0;
1744 FT_Byte* table = cmap->data;
1745 FT_Byte* p = table + 8204;
1746 FT_UInt32 num_groups = TT_NEXT_ULONG( p );
1747 FT_UInt32 start, end, start_id;
1748
1749
1750 p = table + 8208;
1751
1752 for ( ; num_groups > 0; num_groups-- )
1753 {
1754 start = TT_NEXT_ULONG( p );
1755 end = TT_NEXT_ULONG( p );
1756 start_id = TT_NEXT_ULONG( p );
1757
1758 if ( char_code < start )
1759 char_code = start;
1760
1761 if ( char_code <= end )
1762 {
1763 gindex = (FT_UInt)( char_code - start + start_id );
1764 if ( gindex != 0 )
1765 {
1766 result = char_code;
1767 goto Exit;
1768 }
1769 }
1770 }
1771
1772 Exit:
1773 *pchar_code = result;
1774 return gindex;
1775 }
1776
1777
1778 FT_CALLBACK_DEF( FT_Error )
1779 tt_cmap8_get_info( TT_CMap cmap,
1780 TT_CMapInfo *cmap_info )
1781 {
1782 FT_Byte* p = cmap->data + 8;
1783
1784
1785 cmap_info->format = 8;
1786 cmap_info->language = (FT_ULong)TT_PEEK_ULONG( p );
1787
1788 return SFNT_Err_Ok;
1789 }
1790
1791
1792 FT_DEFINE_TT_CMAP(tt_cmap8_class_rec,
1793 sizeof ( TT_CMapRec ),
1794
1795 (FT_CMap_InitFunc) tt_cmap_init,
1796 (FT_CMap_DoneFunc) NULL,
1797 (FT_CMap_CharIndexFunc)tt_cmap8_char_index,
1798 (FT_CMap_CharNextFunc) tt_cmap8_char_next,
1799
1800 NULL, NULL, NULL, NULL, NULL
1801 ,
1802 8,
1803 (TT_CMap_ValidateFunc) tt_cmap8_validate,
1804 (TT_CMap_Info_GetFunc) tt_cmap8_get_info
1805 )
1806
1807 #endif /* TT_CONFIG_CMAP_FORMAT_8 */
1808
1809
1810 /*************************************************************************/
1811 /*************************************************************************/
1812 /***** *****/
1813 /***** FORMAT 10 *****/
1814 /***** *****/
1815 /*************************************************************************/
1816 /*************************************************************************/
1817
1818 /*************************************************************************/
1819 /* */
1820 /* TABLE OVERVIEW */
1821 /* -------------- */
1822 /* */
1823 /* NAME OFFSET TYPE DESCRIPTION */
1824 /* */
1825 /* format 0 USHORT must be 10 */
1826 /* reserved 2 USHORT reserved */
1827 /* length 4 ULONG length in bytes */
1828 /* language 8 ULONG Mac language code */
1829 /* */
1830 /* start 12 ULONG first char in range */
1831 /* count 16 ULONG number of chars in range */
1832 /* glyphIds 20 USHORT[count] glyph indices covered */
1833 /* */
1834
1835 #ifdef TT_CONFIG_CMAP_FORMAT_10
1836
1837 FT_CALLBACK_DEF( FT_Error )
1838 tt_cmap10_validate( FT_Byte* table,
1839 FT_Validator valid )
1840 {
1841 FT_Byte* p = table + 4;
1842 FT_ULong length, count;
1843
1844
1845 if ( table + 20 > valid->limit )
1846 FT_INVALID_TOO_SHORT;
1847
1848 length = TT_NEXT_ULONG( p );
1849 p = table + 16;
1850 count = TT_NEXT_ULONG( p );
1851
1852 if ( length > (FT_ULong)( valid->limit - table ) ||
1853 length < 20 + count * 2 )
1854 FT_INVALID_TOO_SHORT;
1855
1856 /* check glyph indices */
1857 if ( valid->level >= FT_VALIDATE_TIGHT )
1858 {
1859 FT_UInt gindex;
1860
1861
1862 for ( ; count > 0; count-- )
1863 {
1864 gindex = TT_NEXT_USHORT( p );
1865 if ( gindex >= TT_VALID_GLYPH_COUNT( valid ) )
1866 FT_INVALID_GLYPH_ID;
1867 }
1868 }
1869
1870 return SFNT_Err_Ok;
1871 }
1872
1873
1874 FT_CALLBACK_DEF( FT_UInt )
1875 tt_cmap10_char_index( TT_CMap cmap,
1876 FT_UInt32 char_code )
1877 {
1878 FT_Byte* table = cmap->data;
1879 FT_UInt result = 0;
1880 FT_Byte* p = table + 12;
1881 FT_UInt32 start = TT_NEXT_ULONG( p );
1882 FT_UInt32 count = TT_NEXT_ULONG( p );
1883 FT_UInt32 idx = (FT_ULong)( char_code - start );
1884
1885
1886 if ( idx < count )
1887 {
1888 p += 2 * idx;
1889 result = TT_PEEK_USHORT( p );
1890 }
1891 return result;
1892 }
1893
1894
1895 FT_CALLBACK_DEF( FT_UInt32 )
1896 tt_cmap10_char_next( TT_CMap cmap,
1897 FT_UInt32 *pchar_code )
1898 {
1899 FT_Byte* table = cmap->data;
1900 FT_UInt32 char_code = *pchar_code + 1;
1901 FT_UInt gindex = 0;
1902 FT_Byte* p = table + 12;
1903 FT_UInt32 start = TT_NEXT_ULONG( p );
1904 FT_UInt32 count = TT_NEXT_ULONG( p );
1905 FT_UInt32 idx;
1906
1907
1908 if ( char_code < start )
1909 char_code = start;
1910
1911 idx = (FT_UInt32)( char_code - start );
1912 p += 2 * idx;
1913
1914 for ( ; idx < count; idx++ )
1915 {
1916 gindex = TT_NEXT_USHORT( p );
1917 if ( gindex != 0 )
1918 break;
1919 char_code++;
1920 }
1921
1922 *pchar_code = char_code;
1923 return gindex;
1924 }
1925
1926
1927 FT_CALLBACK_DEF( FT_Error )
1928 tt_cmap10_get_info( TT_CMap cmap,
1929 TT_CMapInfo *cmap_info )
1930 {
1931 FT_Byte* p = cmap->data + 8;
1932
1933
1934 cmap_info->format = 10;
1935 cmap_info->language = (FT_ULong)TT_PEEK_ULONG( p );
1936
1937 return SFNT_Err_Ok;
1938 }
1939
1940
1941 FT_DEFINE_TT_CMAP(tt_cmap10_class_rec,
1942 sizeof ( TT_CMapRec ),
1943
1944 (FT_CMap_InitFunc) tt_cmap_init,
1945 (FT_CMap_DoneFunc) NULL,
1946 (FT_CMap_CharIndexFunc)tt_cmap10_char_index,
1947 (FT_CMap_CharNextFunc) tt_cmap10_char_next,
1948
1949 NULL, NULL, NULL, NULL, NULL
1950 ,
1951 10,
1952 (TT_CMap_ValidateFunc) tt_cmap10_validate,
1953 (TT_CMap_Info_GetFunc) tt_cmap10_get_info
1954 )
1955
1956 #endif /* TT_CONFIG_CMAP_FORMAT_10 */
1957
1958
1959 /*************************************************************************/
1960 /*************************************************************************/
1961 /***** *****/
1962 /***** FORMAT 12 *****/
1963 /***** *****/
1964 /*************************************************************************/
1965 /*************************************************************************/
1966
1967 /*************************************************************************/
1968 /* */
1969 /* TABLE OVERVIEW */
1970 /* -------------- */
1971 /* */
1972 /* NAME OFFSET TYPE DESCRIPTION */
1973 /* */
1974 /* format 0 USHORT must be 12 */
1975 /* reserved 2 USHORT reserved */
1976 /* length 4 ULONG length in bytes */
1977 /* language 8 ULONG Mac language code */
1978 /* count 12 ULONG number of groups */
1979 /* 16 */
1980 /* */
1981 /* This header is followed by `count' groups of the following format: */
1982 /* */
1983 /* start 0 ULONG first charcode */
1984 /* end 4 ULONG last charcode */
1985 /* startId 8 ULONG start glyph ID for the group */
1986 /* */
1987
1988 #ifdef TT_CONFIG_CMAP_FORMAT_12
1989
1990 typedef struct TT_CMap12Rec_
1991 {
1992 TT_CMapRec cmap;
1993 FT_Bool valid;
1994 FT_ULong cur_charcode;
1995 FT_UInt cur_gindex;
1996 FT_ULong cur_group;
1997 FT_ULong num_groups;
1998
1999 } TT_CMap12Rec, *TT_CMap12;
2000
2001
2002 FT_CALLBACK_DEF( FT_Error )
2003 tt_cmap12_init( TT_CMap12 cmap,
2004 FT_Byte* table )
2005 {
2006 cmap->cmap.data = table;
2007
2008 table += 12;
2009 cmap->num_groups = FT_PEEK_ULONG( table );
2010
2011 cmap->valid = 0;
2012
2013 return SFNT_Err_Ok;
2014 }
2015
2016
2017 FT_CALLBACK_DEF( FT_Error )
2018 tt_cmap12_validate( FT_Byte* table,
2019 FT_Validator valid )
2020 {
2021 FT_Byte* p;
2022 FT_ULong length;
2023 FT_ULong num_groups;
2024
2025
2026 if ( table + 16 > valid->limit )
2027 FT_INVALID_TOO_SHORT;
2028
2029 p = table + 4;
2030 length = TT_NEXT_ULONG( p );
2031
2032 p = table + 12;
2033 num_groups = TT_NEXT_ULONG( p );
2034
2035 if ( length > (FT_ULong)( valid->limit - table ) ||
2036 length < 16 + 12 * num_groups )
2037 FT_INVALID_TOO_SHORT;
2038
2039 /* check groups, they must be in increasing order */
2040 {
2041 FT_ULong n, start, end, start_id, last = 0;
2042
2043
2044 for ( n = 0; n < num_groups; n++ )
2045 {
2046 start = TT_NEXT_ULONG( p );
2047 end = TT_NEXT_ULONG( p );
2048 start_id = TT_NEXT_ULONG( p );
2049
2050 if ( start > end )
2051 FT_INVALID_DATA;
2052
2053 if ( n > 0 && start <= last )
2054 FT_INVALID_DATA;
2055
2056 if ( valid->level >= FT_VALIDATE_TIGHT )
2057 {
2058 if ( start_id + end - start >= TT_VALID_GLYPH_COUNT( valid ) )
2059 FT_INVALID_GLYPH_ID;
2060 }
2061
2062 last = end;
2063 }
2064 }
2065
2066 return SFNT_Err_Ok;
2067 }
2068
2069
2070 /* search the index of the charcode next to cmap->cur_charcode */
2071 /* cmap->cur_group should be set up properly by caller */
2072 /* */
2073 static void
2074 tt_cmap12_next( TT_CMap12 cmap )
2075 {
2076 FT_Byte* p;
2077 FT_ULong start, end, start_id, char_code;
2078 FT_ULong n;
2079 FT_UInt gindex;
2080
2081
2082 if ( cmap->cur_charcode >= 0xFFFFFFFFUL )
2083 goto Fail;
2084
2085 char_code = cmap->cur_charcode + 1;
2086
2087 n = cmap->cur_group;
2088
2089 for ( n = cmap->cur_group; n < cmap->num_groups; n++ )
2090 {
2091 p = cmap->cmap.data + 16 + 12 * n;
2092 start = TT_NEXT_ULONG( p );
2093 end = TT_NEXT_ULONG( p );
2094 start_id = TT_PEEK_ULONG( p );
2095
2096 if ( char_code < start )
2097 char_code = start;
2098
2099 for ( ; char_code <= end; char_code++ )
2100 {
2101 gindex = (FT_UInt)( start_id + char_code - start );
2102
2103 if ( gindex )
2104 {
2105 cmap->cur_charcode = char_code;;
2106 cmap->cur_gindex = gindex;
2107 cmap->cur_group = n;
2108
2109 return;
2110 }
2111 }
2112 }
2113
2114 Fail:
2115 cmap->valid = 0;
2116 }
2117
2118
2119 static FT_UInt
2120 tt_cmap12_char_map_binary( TT_CMap cmap,
2121 FT_UInt32* pchar_code,
2122 FT_Bool next )
2123 {
2124 FT_UInt gindex = 0;
2125 FT_Byte* p = cmap->data + 12;
2126 FT_UInt32 num_groups = TT_PEEK_ULONG( p );
2127 FT_UInt32 char_code = *pchar_code;
2128 FT_UInt32 start, end, start_id;
2129 FT_UInt32 max, min, mid;
2130
2131
2132 if ( !num_groups )
2133 return 0;
2134
2135 /* make compiler happy */
2136 mid = num_groups;
2137 end = 0xFFFFFFFFUL;
2138
2139 if ( next )
2140 char_code++;
2141
2142 min = 0;
2143 max = num_groups;
2144
2145 /* binary search */
2146 while ( min < max )
2147 {
2148 mid = ( min + max ) >> 1;
2149 p = cmap->data + 16 + 12 * mid;
2150
2151 start = TT_NEXT_ULONG( p );
2152 end = TT_NEXT_ULONG( p );
2153
2154 if ( char_code < start )
2155 max = mid;
2156 else if ( char_code > end )
2157 min = mid + 1;
2158 else
2159 {
2160 start_id = TT_PEEK_ULONG( p );
2161 gindex = (FT_UInt)( start_id + char_code - start );
2162
2163 break;
2164 }
2165 }
2166
2167 if ( next )
2168 {
2169 TT_CMap12 cmap12 = (TT_CMap12)cmap;
2170
2171
2172 /* if `char_code' is not in any group, then `mid' is */
2173 /* the group nearest to `char_code' */
2174 /* */
2175
2176 if ( char_code > end )
2177 {
2178 mid++;
2179 if ( mid == num_groups )
2180 return 0;
2181 }
2182
2183 cmap12->valid = 1;
2184 cmap12->cur_charcode = char_code;
2185 cmap12->cur_group = mid;
2186
2187 if ( !gindex )
2188 {
2189 tt_cmap12_next( cmap12 );
2190
2191 if ( cmap12->valid )
2192 gindex = cmap12->cur_gindex;
2193 }
2194 else
2195 cmap12->cur_gindex = gindex;
2196
2197 if ( gindex )
2198 *pchar_code = cmap12->cur_charcode;
2199 }
2200
2201 return gindex;
2202 }
2203
2204
2205 FT_CALLBACK_DEF( FT_UInt )
2206 tt_cmap12_char_index( TT_CMap cmap,
2207 FT_UInt32 char_code )
2208 {
2209 return tt_cmap12_char_map_binary( cmap, &char_code, 0 );
2210 }
2211
2212
2213 FT_CALLBACK_DEF( FT_UInt32 )
2214 tt_cmap12_char_next( TT_CMap cmap,
2215 FT_UInt32 *pchar_code )
2216 {
2217 TT_CMap12 cmap12 = (TT_CMap12)cmap;
2218 FT_ULong gindex;
2219
2220
2221 if ( cmap12->cur_charcode >= 0xFFFFFFFFUL )
2222 return 0;
2223
2224 /* no need to search */
2225 if ( cmap12->valid && cmap12->cur_charcode == *pchar_code )
2226 {
2227 tt_cmap12_next( cmap12 );
2228 if ( cmap12->valid )
2229 {
2230 gindex = cmap12->cur_gindex;
2231
2232 /* XXX: check cur_charcode overflow is expected */
2233 if ( gindex )
2234 *pchar_code = (FT_UInt32)cmap12->cur_charcode;
2235 }
2236 else
2237 gindex = 0;
2238 }
2239 else
2240 gindex = tt_cmap12_char_map_binary( cmap, pchar_code, 1 );
2241
2242 /* XXX: check gindex overflow is expected */
2243 return (FT_UInt32)gindex;
2244 }
2245
2246
2247 FT_CALLBACK_DEF( FT_Error )
2248 tt_cmap12_get_info( TT_CMap cmap,
2249 TT_CMapInfo *cmap_info )
2250 {
2251 FT_Byte* p = cmap->data + 8;
2252
2253
2254 cmap_info->format = 12;
2255 cmap_info->language = (FT_ULong)TT_PEEK_ULONG( p );
2256
2257 return SFNT_Err_Ok;
2258 }
2259
2260
2261 FT_DEFINE_TT_CMAP(tt_cmap12_class_rec,
2262 sizeof ( TT_CMap12Rec ),
2263
2264 (FT_CMap_InitFunc) tt_cmap12_init,
2265 (FT_CMap_DoneFunc) NULL,
2266 (FT_CMap_CharIndexFunc)tt_cmap12_char_index,
2267 (FT_CMap_CharNextFunc) tt_cmap12_char_next,
2268
2269 NULL, NULL, NULL, NULL, NULL
2270 ,
2271 12,
2272 (TT_CMap_ValidateFunc) tt_cmap12_validate,
2273 (TT_CMap_Info_GetFunc) tt_cmap12_get_info
2274 )
2275
2276 #endif /* TT_CONFIG_CMAP_FORMAT_12 */
2277
2278
2279 /*************************************************************************/
2280 /*************************************************************************/
2281 /***** *****/
2282 /***** FORMAT 13 *****/
2283 /***** *****/
2284 /*************************************************************************/
2285 /*************************************************************************/
2286
2287 /*************************************************************************/
2288 /* */
2289 /* TABLE OVERVIEW */
2290 /* -------------- */
2291 /* */
2292 /* NAME OFFSET TYPE DESCRIPTION */
2293 /* */
2294 /* format 0 USHORT must be 13 */
2295 /* reserved 2 USHORT reserved */
2296 /* length 4 ULONG length in bytes */
2297 /* language 8 ULONG Mac language code */
2298 /* count 12 ULONG number of groups */
2299 /* 16 */
2300 /* */
2301 /* This header is followed by `count' groups of the following format: */
2302 /* */
2303 /* start 0 ULONG first charcode */
2304 /* end 4 ULONG last charcode */
2305 /* glyphId 8 ULONG glyph ID for the whole group */
2306 /* */
2307
2308 #ifdef TT_CONFIG_CMAP_FORMAT_13
2309
2310 typedef struct TT_CMap13Rec_
2311 {
2312 TT_CMapRec cmap;
2313 FT_Bool valid;
2314 FT_ULong cur_charcode;
2315 FT_UInt cur_gindex;
2316 FT_ULong cur_group;
2317 FT_ULong num_groups;
2318
2319 } TT_CMap13Rec, *TT_CMap13;
2320
2321
2322 FT_CALLBACK_DEF( FT_Error )
2323 tt_cmap13_init( TT_CMap13 cmap,
2324 FT_Byte* table )
2325 {
2326 cmap->cmap.data = table;
2327
2328 table += 12;
2329 cmap->num_groups = FT_PEEK_ULONG( table );
2330
2331 cmap->valid = 0;
2332
2333 return SFNT_Err_Ok;
2334 }
2335
2336
2337 FT_CALLBACK_DEF( FT_Error )
2338 tt_cmap13_validate( FT_Byte* table,
2339 FT_Validator valid )
2340 {
2341 FT_Byte* p;
2342 FT_ULong length;
2343 FT_ULong num_groups;
2344
2345
2346 if ( table + 16 > valid->limit )
2347 FT_INVALID_TOO_SHORT;
2348
2349 p = table + 4;
2350 length = TT_NEXT_ULONG( p );
2351
2352 p = table + 12;
2353 num_groups = TT_NEXT_ULONG( p );
2354
2355 if ( length > (FT_ULong)( valid->limit - table ) ||
2356 length < 16 + 12 * num_groups )
2357 FT_INVALID_TOO_SHORT;
2358
2359 /* check groups, they must be in increasing order */
2360 {
2361 FT_ULong n, start, end, glyph_id, last = 0;
2362
2363
2364 for ( n = 0; n < num_groups; n++ )
2365 {
2366 start = TT_NEXT_ULONG( p );
2367 end = TT_NEXT_ULONG( p );
2368 glyph_id = TT_NEXT_ULONG( p );
2369
2370 if ( start > end )
2371 FT_INVALID_DATA;
2372
2373 if ( n > 0 && start <= last )
2374 FT_INVALID_DATA;
2375
2376 if ( valid->level >= FT_VALIDATE_TIGHT )
2377 {
2378 if ( glyph_id >= TT_VALID_GLYPH_COUNT( valid ) )
2379 FT_INVALID_GLYPH_ID;
2380 }
2381
2382 last = end;
2383 }
2384 }
2385
2386 return SFNT_Err_Ok;
2387 }
2388
2389
2390 /* search the index of the charcode next to cmap->cur_charcode */
2391 /* cmap->cur_group should be set up properly by caller */
2392 /* */
2393 static void
2394 tt_cmap13_next( TT_CMap13 cmap )
2395 {
2396 FT_Byte* p;
2397 FT_ULong start, end, glyph_id, char_code;
2398 FT_ULong n;
2399 FT_UInt gindex;
2400
2401
2402 if ( cmap->cur_charcode >= 0xFFFFFFFFUL )
2403 goto Fail;
2404
2405 char_code = cmap->cur_charcode + 1;
2406
2407 n = cmap->cur_group;
2408
2409 for ( n = cmap->cur_group; n < cmap->num_groups; n++ )
2410 {
2411 p = cmap->cmap.data + 16 + 12 * n;
2412 start = TT_NEXT_ULONG( p );
2413 end = TT_NEXT_ULONG( p );
2414 glyph_id = TT_PEEK_ULONG( p );
2415
2416 if ( char_code < start )
2417 char_code = start;
2418
2419 if ( char_code <= end )
2420 {
2421 gindex = (FT_UInt)glyph_id;
2422
2423 if ( gindex )
2424 {
2425 cmap->cur_charcode = char_code;;
2426 cmap->cur_gindex = gindex;
2427 cmap->cur_group = n;
2428
2429 return;
2430 }
2431 }
2432 }
2433
2434 Fail:
2435 cmap->valid = 0;
2436 }
2437
2438
2439 static FT_UInt
2440 tt_cmap13_char_map_binary( TT_CMap cmap,
2441 FT_UInt32* pchar_code,
2442 FT_Bool next )
2443 {
2444 FT_UInt gindex = 0;
2445 FT_Byte* p = cmap->data + 12;
2446 FT_UInt32 num_groups = TT_PEEK_ULONG( p );
2447 FT_UInt32 char_code = *pchar_code;
2448 FT_UInt32 start, end;
2449 FT_UInt32 max, min, mid;
2450
2451
2452 if ( !num_groups )
2453 return 0;
2454
2455 /* make compiler happy */
2456 mid = num_groups;
2457 end = 0xFFFFFFFFUL;
2458
2459 if ( next )
2460 char_code++;
2461
2462 min = 0;
2463 max = num_groups;
2464
2465 /* binary search */
2466 while ( min < max )
2467 {
2468 mid = ( min + max ) >> 1;
2469 p = cmap->data + 16 + 12 * mid;
2470
2471 start = TT_NEXT_ULONG( p );
2472 end = TT_NEXT_ULONG( p );
2473
2474 if ( char_code < start )
2475 max = mid;
2476 else if ( char_code > end )
2477 min = mid + 1;
2478 else
2479 {
2480 gindex = (FT_UInt)TT_PEEK_ULONG( p );
2481
2482 break;
2483 }
2484 }
2485
2486 if ( next )
2487 {
2488 TT_CMap13 cmap13 = (TT_CMap13)cmap;
2489
2490
2491 /* if `char_code' is not in any group, then `mid' is */
2492 /* the group nearest to `char_code' */
2493 /* */
2494
2495 if ( char_code > end )
2496 {
2497 mid++;
2498 if ( mid == num_groups )
2499 return 0;
2500 }
2501
2502 cmap13->valid = 1;
2503 cmap13->cur_charcode = char_code;
2504 cmap13->cur_group = mid;
2505
2506 if ( !gindex )
2507 {
2508 tt_cmap13_next( cmap13 );
2509
2510 if ( cmap13->valid )
2511 gindex = cmap13->cur_gindex;
2512 }
2513 else
2514 cmap13->cur_gindex = gindex;
2515
2516 if ( gindex )
2517 *pchar_code = cmap13->cur_charcode;
2518 }
2519
2520 return gindex;
2521 }
2522
2523
2524 FT_CALLBACK_DEF( FT_UInt )
2525 tt_cmap13_char_index( TT_CMap cmap,
2526 FT_UInt32 char_code )
2527 {
2528 return tt_cmap13_char_map_binary( cmap, &char_code, 0 );
2529 }
2530
2531
2532 FT_CALLBACK_DEF( FT_UInt32 )
2533 tt_cmap13_char_next( TT_CMap cmap,
2534 FT_UInt32 *pchar_code )
2535 {
2536 TT_CMap13 cmap13 = (TT_CMap13)cmap;
2537 FT_UInt gindex;
2538
2539
2540 if ( cmap13->cur_charcode >= 0xFFFFFFFFUL )
2541 return 0;
2542
2543 /* no need to search */
2544 if ( cmap13->valid && cmap13->cur_charcode == *pchar_code )
2545 {
2546 tt_cmap13_next( cmap13 );
2547 if ( cmap13->valid )
2548 {
2549 gindex = cmap13->cur_gindex;
2550 if ( gindex )
2551 *pchar_code = cmap13->cur_charcode;
2552 }
2553 else
2554 gindex = 0;
2555 }
2556 else
2557 gindex = tt_cmap13_char_map_binary( cmap, pchar_code, 1 );
2558
2559 return gindex;
2560 }
2561
2562
2563 FT_CALLBACK_DEF( FT_Error )
2564 tt_cmap13_get_info( TT_CMap cmap,
2565 TT_CMapInfo *cmap_info )
2566 {
2567 FT_Byte* p = cmap->data + 8;
2568
2569
2570 cmap_info->format = 13;
2571 cmap_info->language = (FT_ULong)TT_PEEK_ULONG( p );
2572
2573 return SFNT_Err_Ok;
2574 }
2575
2576
2577 FT_DEFINE_TT_CMAP(tt_cmap13_class_rec,
2578 sizeof ( TT_CMap13Rec ),
2579
2580 (FT_CMap_InitFunc) tt_cmap13_init,
2581 (FT_CMap_DoneFunc) NULL,
2582 (FT_CMap_CharIndexFunc)tt_cmap13_char_index,
2583 (FT_CMap_CharNextFunc) tt_cmap13_char_next,
2584
2585 NULL, NULL, NULL, NULL, NULL
2586 ,
2587 13,
2588 (TT_CMap_ValidateFunc) tt_cmap13_validate,
2589 (TT_CMap_Info_GetFunc) tt_cmap13_get_info
2590 )
2591
2592 #endif /* TT_CONFIG_CMAP_FORMAT_13 */
2593
2594
2595 /*************************************************************************/
2596 /*************************************************************************/
2597 /***** *****/
2598 /***** FORMAT 14 *****/
2599 /***** *****/
2600 /*************************************************************************/
2601 /*************************************************************************/
2602
2603 /*************************************************************************/
2604 /* */
2605 /* TABLE OVERVIEW */
2606 /* -------------- */
2607 /* */
2608 /* NAME OFFSET TYPE DESCRIPTION */
2609 /* */
2610 /* format 0 USHORT must be 14 */
2611 /* length 2 ULONG table length in bytes */
2612 /* numSelector 6 ULONG number of variation sel. records */
2613 /* */
2614 /* Followed by numSelector records, each of which looks like */
2615 /* */
2616 /* varSelector 0 UINT24 Unicode codepoint of sel. */
2617 /* defaultOff 3 ULONG offset to a default UVS table */
2618 /* describing any variants to be found in */
2619 /* the normal Unicode subtable. */
2620 /* nonDefOff 7 ULONG offset to a non-default UVS table */
2621 /* describing any variants not in the */
2622 /* standard cmap, with GIDs here */
2623 /* (either offset may be 0 NULL) */
2624 /* */
2625 /* Selectors are sorted by code point. */
2626 /* */
2627 /* A default Unicode Variation Selector (UVS) subtable is just a list of */
2628 /* ranges of code points which are to be found in the standard cmap. No */
2629 /* glyph IDs (GIDs) here. */
2630 /* */
2631 /* numRanges 0 ULONG number of ranges following */
2632 /* */
2633 /* A range looks like */
2634 /* */
2635 /* uniStart 0 UINT24 code point of the first character in */
2636 /* this range */
2637 /* additionalCnt 3 UBYTE count of additional characters in this */
2638 /* range (zero means a range of a single */
2639 /* character) */
2640 /* */
2641 /* Ranges are sorted by `uniStart'. */
2642 /* */
2643 /* A non-default Unicode Variation Selector (UVS) subtable is a list of */
2644 /* mappings from codepoint to GID. */
2645 /* */
2646 /* numMappings 0 ULONG number of mappings */
2647 /* */
2648 /* A range looks like */
2649 /* */
2650 /* uniStart 0 UINT24 code point of the first character in */
2651 /* this range */
2652 /* GID 3 USHORT and its GID */
2653 /* */
2654 /* Ranges are sorted by `uniStart'. */
2655
2656 #ifdef TT_CONFIG_CMAP_FORMAT_14
2657
2658 typedef struct TT_CMap14Rec_
2659 {
2660 TT_CMapRec cmap;
2661 FT_ULong num_selectors;
2662
2663 /* This array is used to store the results of various
2664 * cmap 14 query functions. The data is overwritten
2665 * on each call to these functions.
2666 */
2667 FT_UInt32 max_results;
2668 FT_UInt32* results;
2669 FT_Memory memory;
2670
2671 } TT_CMap14Rec, *TT_CMap14;
2672
2673
2674 FT_CALLBACK_DEF( void )
2675 tt_cmap14_done( TT_CMap14 cmap )
2676 {
2677 FT_Memory memory = cmap->memory;
2678
2679
2680 cmap->max_results = 0;
2681 if ( memory != NULL && cmap->results != NULL )
2682 FT_FREE( cmap->results );
2683 }
2684
2685
2686 static FT_Error
2687 tt_cmap14_ensure( TT_CMap14 cmap,
2688 FT_UInt32 num_results,
2689 FT_Memory memory )
2690 {
2691 FT_UInt32 old_max = cmap->max_results;
2692 FT_Error error = SFNT_Err_Ok;
2693
2694
2695 if ( num_results > cmap->max_results )
2696 {
2697 cmap->memory = memory;
2698
2699 if ( FT_QRENEW_ARRAY( cmap->results, old_max, num_results ) )
2700 return error;
2701
2702 cmap->max_results = num_results;
2703 }
2704
2705 return error;
2706 }
2707
2708
2709 FT_CALLBACK_DEF( FT_Error )
2710 tt_cmap14_init( TT_CMap14 cmap,
2711 FT_Byte* table )
2712 {
2713 cmap->cmap.data = table;
2714
2715 table += 6;
2716 cmap->num_selectors = FT_PEEK_ULONG( table );
2717 cmap->max_results = 0;
2718 cmap->results = NULL;
2719
2720 return SFNT_Err_Ok;
2721 }
2722
2723
2724 FT_CALLBACK_DEF( FT_Error )
2725 tt_cmap14_validate( FT_Byte* table,
2726 FT_Validator valid )
2727 {
2728 FT_Byte* p = table + 2;
2729 FT_ULong length = TT_NEXT_ULONG( p );
2730 FT_ULong num_selectors = TT_NEXT_ULONG( p );
2731
2732
2733 if ( length > (FT_ULong)( valid->limit - table ) ||
2734 length < 10 + 11 * num_selectors )
2735 FT_INVALID_TOO_SHORT;
2736
2737 /* check selectors, they must be in increasing order */
2738 {
2739 /* we start lastVarSel at 1 because a variant selector value of 0
2740 * isn't valid.
2741 */
2742 FT_ULong n, lastVarSel = 1;
2743
2744
2745 for ( n = 0; n < num_selectors; n++ )
2746 {
2747 FT_ULong varSel = TT_NEXT_UINT24( p );
2748 FT_ULong defOff = TT_NEXT_ULONG( p );
2749 FT_ULong nondefOff = TT_NEXT_ULONG( p );
2750
2751
2752 if ( defOff >= length || nondefOff >= length )
2753 FT_INVALID_TOO_SHORT;
2754
2755 if ( varSel < lastVarSel )
2756 FT_INVALID_DATA;
2757
2758 lastVarSel = varSel + 1;
2759
2760 /* check the default table (these glyphs should be reached */
2761 /* through the normal Unicode cmap, no GIDs, just check order) */
2762 if ( defOff != 0 )
2763 {
2764 FT_Byte* defp = table + defOff;
2765 FT_ULong numRanges = TT_NEXT_ULONG( defp );
2766 FT_ULong i;
2767 FT_ULong lastBase = 0;
2768
2769
2770 if ( defp + numRanges * 4 > valid->limit )
2771 FT_INVALID_TOO_SHORT;
2772
2773 for ( i = 0; i < numRanges; ++i )
2774 {
2775 FT_ULong base = TT_NEXT_UINT24( defp );
2776 FT_ULong cnt = FT_NEXT_BYTE( defp );
2777
2778
2779 if ( base + cnt >= 0x110000UL ) /* end of Unicode */
2780 FT_INVALID_DATA;
2781
2782 if ( base < lastBase )
2783 FT_INVALID_DATA;
2784
2785 lastBase = base + cnt + 1U;
2786 }
2787 }
2788
2789 /* and the non-default table (these glyphs are specified here) */
2790 if ( nondefOff != 0 )
2791 {
2792 FT_Byte* ndp = table + nondefOff;
2793 FT_ULong numMappings = TT_NEXT_ULONG( ndp );
2794 FT_ULong i, lastUni = 0;
2795
2796
2797 if ( numMappings * 4 > (FT_ULong)( valid->limit - ndp ) )
2798 FT_INVALID_TOO_SHORT;
2799
2800 for ( i = 0; i < numMappings; ++i )
2801 {
2802 FT_ULong uni = TT_NEXT_UINT24( ndp );
2803 FT_ULong gid = TT_NEXT_USHORT( ndp );
2804
2805
2806 if ( uni >= 0x110000UL ) /* end of Unicode */
2807 FT_INVALID_DATA;
2808
2809 if ( uni < lastUni )
2810 FT_INVALID_DATA;
2811
2812 lastUni = uni + 1U;
2813
2814 if ( valid->level >= FT_VALIDATE_TIGHT &&
2815 gid >= TT_VALID_GLYPH_COUNT( valid ) )
2816 FT_INVALID_GLYPH_ID;
2817 }
2818 }
2819 }
2820 }
2821
2822 return SFNT_Err_Ok;
2823 }
2824
2825
2826 FT_CALLBACK_DEF( FT_UInt )
2827 tt_cmap14_char_index( TT_CMap cmap,
2828 FT_UInt32 char_code )
2829 {
2830 FT_UNUSED( cmap );
2831 FT_UNUSED( char_code );
2832
2833 /* This can't happen */
2834 return 0;
2835 }
2836
2837
2838 FT_CALLBACK_DEF( FT_UInt32 )
2839 tt_cmap14_char_next( TT_CMap cmap,
2840 FT_UInt32 *pchar_code )
2841 {
2842 FT_UNUSED( cmap );
2843
2844 /* This can't happen */
2845 *pchar_code = 0;
2846 return 0;
2847 }
2848
2849
2850 FT_CALLBACK_DEF( FT_Error )
2851 tt_cmap14_get_info( TT_CMap cmap,
2852 TT_CMapInfo *cmap_info )
2853 {
2854 FT_UNUSED( cmap );
2855
2856 cmap_info->format = 14;
2857 /* subtable 14 does not define a language field */
2858 cmap_info->language = 0xFFFFFFFFUL;
2859
2860 return SFNT_Err_Ok;
2861 }
2862
2863
2864 static FT_UInt
2865 tt_cmap14_char_map_def_binary( FT_Byte *base,
2866 FT_UInt32 char_code )
2867 {
2868 FT_UInt32 numRanges = TT_PEEK_ULONG( base );
2869 FT_UInt32 max, min;
2870
2871
2872 min = 0;
2873 max = numRanges;
2874
2875 base += 4;
2876
2877 /* binary search */
2878 while ( min < max )
2879 {
2880 FT_UInt32 mid = ( min + max ) >> 1;
2881 FT_Byte* p = base + 4 * mid;
2882 FT_ULong start = TT_NEXT_UINT24( p );
2883 FT_UInt cnt = FT_NEXT_BYTE( p );
2884
2885
2886 if ( char_code < start )
2887 max = mid;
2888 else if ( char_code > start+cnt )
2889 min = mid + 1;
2890 else
2891 return TRUE;
2892 }
2893
2894 return FALSE;
2895 }
2896
2897
2898 static FT_UInt
2899 tt_cmap14_char_map_nondef_binary( FT_Byte *base,
2900 FT_UInt32 char_code )
2901 {
2902 FT_UInt32 numMappings = TT_PEEK_ULONG( base );
2903 FT_UInt32 max, min;
2904
2905
2906 min = 0;
2907 max = numMappings;
2908
2909 base += 4;
2910
2911 /* binary search */
2912 while ( min < max )
2913 {
2914 FT_UInt32 mid = ( min + max ) >> 1;
2915 FT_Byte* p = base + 5 * mid;
2916 FT_UInt32 uni = (FT_UInt32)TT_NEXT_UINT24( p );
2917
2918
2919 if ( char_code < uni )
2920 max = mid;
2921 else if ( char_code > uni )
2922 min = mid + 1;
2923 else
2924 return TT_PEEK_USHORT( p );
2925 }
2926
2927 return 0;
2928 }
2929
2930
2931 static FT_Byte*
2932 tt_cmap14_find_variant( FT_Byte *base,
2933 FT_UInt32 variantCode )
2934 {
2935 FT_UInt32 numVar = TT_PEEK_ULONG( base );
2936 FT_UInt32 max, min;
2937
2938
2939 min = 0;
2940 max = numVar;
2941
2942 base += 4;
2943
2944 /* binary search */
2945 while ( min < max )
2946 {
2947 FT_UInt32 mid = ( min + max ) >> 1;
2948 FT_Byte* p = base + 11 * mid;
2949 FT_ULong varSel = TT_NEXT_UINT24( p );
2950
2951
2952 if ( variantCode < varSel )
2953 max = mid;
2954 else if ( variantCode > varSel )
2955 min = mid + 1;
2956 else
2957 return p;
2958 }
2959
2960 return NULL;
2961 }
2962
2963
2964 FT_CALLBACK_DEF( FT_UInt )
2965 tt_cmap14_char_var_index( TT_CMap cmap,
2966 TT_CMap ucmap,
2967 FT_UInt32 charcode,
2968 FT_UInt32 variantSelector)
2969 {
2970 FT_Byte* p = tt_cmap14_find_variant( cmap->data + 6, variantSelector );
2971 FT_ULong defOff;
2972 FT_ULong nondefOff;
2973
2974
2975 if ( !p )
2976 return 0;
2977
2978 defOff = TT_NEXT_ULONG( p );
2979 nondefOff = TT_PEEK_ULONG( p );
2980
2981 if ( defOff != 0 &&
2982 tt_cmap14_char_map_def_binary( cmap->data + defOff, charcode ) )
2983 {
2984 /* This is the default variant of this charcode. GID not stored */
2985 /* here; stored in the normal Unicode charmap instead. */
2986 return ucmap->cmap.clazz->char_index( &ucmap->cmap, charcode );
2987 }
2988
2989 if ( nondefOff != 0 )
2990 return tt_cmap14_char_map_nondef_binary( cmap->data + nondefOff,
2991 charcode );
2992
2993 return 0;
2994 }
2995
2996
2997 FT_CALLBACK_DEF( FT_Int )
2998 tt_cmap14_char_var_isdefault( TT_CMap cmap,
2999 FT_UInt32 charcode,
3000 FT_UInt32 variantSelector )
3001 {
3002 FT_Byte* p = tt_cmap14_find_variant( cmap->data + 6, variantSelector );
3003 FT_ULong defOff;
3004 FT_ULong nondefOff;
3005
3006
3007 if ( !p )
3008 return -1;
3009
3010 defOff = TT_NEXT_ULONG( p );
3011 nondefOff = TT_NEXT_ULONG( p );
3012
3013 if ( defOff != 0 &&
3014 tt_cmap14_char_map_def_binary( cmap->data + defOff, charcode ) )
3015 return 1;
3016
3017 if ( nondefOff != 0 &&
3018 tt_cmap14_char_map_nondef_binary( cmap->data + nondefOff,
3019 charcode ) != 0 )
3020 return 0;
3021
3022 return -1;
3023 }
3024
3025
3026 FT_CALLBACK_DEF( FT_UInt32* )
3027 tt_cmap14_variants( TT_CMap cmap,
3028 FT_Memory memory )
3029 {
3030 TT_CMap14 cmap14 = (TT_CMap14)cmap;
3031 FT_UInt32 count = cmap14->num_selectors;
3032 FT_Byte* p = cmap->data + 10;
3033 FT_UInt32* result;
3034 FT_UInt32 i;
3035
3036
3037 if ( tt_cmap14_ensure( cmap14, ( count + 1 ), memory ) )
3038 return NULL;
3039
3040 result = cmap14->results;
3041 for ( i = 0; i < count; ++i )
3042 {
3043 result[i] = (FT_UInt32)TT_NEXT_UINT24( p );
3044 p += 8;
3045 }
3046 result[i] = 0;
3047
3048 return result;
3049 }
3050
3051
3052 FT_CALLBACK_DEF( FT_UInt32 * )
3053 tt_cmap14_char_variants( TT_CMap cmap,
3054 FT_Memory memory,
3055 FT_UInt32 charCode )
3056 {
3057 TT_CMap14 cmap14 = (TT_CMap14) cmap;
3058 FT_UInt32 count = cmap14->num_selectors;
3059 FT_Byte* p = cmap->data + 10;
3060 FT_UInt32* q;
3061
3062
3063 if ( tt_cmap14_ensure( cmap14, ( count + 1 ), memory ) )
3064 return NULL;
3065
3066 for ( q = cmap14->results; count > 0; --count )
3067 {
3068 FT_UInt32 varSel = TT_NEXT_UINT24( p );
3069 FT_ULong defOff = TT_NEXT_ULONG( p );
3070 FT_ULong nondefOff = TT_NEXT_ULONG( p );
3071
3072
3073 if ( ( defOff != 0 &&
3074 tt_cmap14_char_map_def_binary( cmap->data + defOff,
3075 charCode ) ) ||
3076 ( nondefOff != 0 &&
3077 tt_cmap14_char_map_nondef_binary( cmap->data + nondefOff,
3078 charCode ) != 0 ) )
3079 {
3080 q[0] = varSel;
3081 q++;
3082 }
3083 }
3084 q[0] = 0;
3085
3086 return cmap14->results;
3087 }
3088
3089
3090 static FT_UInt
3091 tt_cmap14_def_char_count( FT_Byte *p )
3092 {
3093 FT_UInt32 numRanges = (FT_UInt32)TT_NEXT_ULONG( p );
3094 FT_UInt tot = 0;
3095
3096
3097 p += 3; /* point to the first `cnt' field */
3098 for ( ; numRanges > 0; numRanges-- )
3099 {
3100 tot += 1 + p[0];
3101 p += 4;
3102 }
3103
3104 return tot;
3105 }
3106
3107
3108 static FT_UInt32*
3109 tt_cmap14_get_def_chars( TT_CMap cmap,
3110 FT_Byte* p,
3111 FT_Memory memory )
3112 {
3113 TT_CMap14 cmap14 = (TT_CMap14) cmap;
3114 FT_UInt32 numRanges;
3115 FT_UInt cnt;
3116 FT_UInt32* q;
3117
3118
3119 cnt = tt_cmap14_def_char_count( p );
3120 numRanges = (FT_UInt32)TT_NEXT_ULONG( p );
3121
3122 if ( tt_cmap14_ensure( cmap14, ( cnt + 1 ), memory ) )
3123 return NULL;
3124
3125 for ( q = cmap14->results; numRanges > 0; --numRanges )
3126 {
3127 FT_UInt32 uni = (FT_UInt32)TT_NEXT_UINT24( p );
3128
3129
3130 cnt = FT_NEXT_BYTE( p ) + 1;
3131 do
3132 {
3133 q[0] = uni;
3134 uni += 1;
3135 q += 1;
3136 } while ( --cnt != 0 );
3137 }
3138 q[0] = 0;
3139
3140 return cmap14->results;
3141 }
3142
3143
3144 static FT_UInt32*
3145 tt_cmap14_get_nondef_chars( TT_CMap cmap,
3146 FT_Byte *p,
3147 FT_Memory memory )
3148 {
3149 TT_CMap14 cmap14 = (TT_CMap14) cmap;
3150 FT_UInt32 numMappings;
3151 FT_UInt i;
3152 FT_UInt32 *ret;
3153
3154
3155 numMappings = (FT_UInt32)TT_NEXT_ULONG( p );
3156
3157 if ( tt_cmap14_ensure( cmap14, ( numMappings + 1 ), memory ) )
3158 return NULL;
3159
3160 ret = cmap14->results;
3161 for ( i = 0; i < numMappings; ++i )
3162 {
3163 ret[i] = (FT_UInt32)TT_NEXT_UINT24( p );
3164 p += 2;
3165 }
3166 ret[i] = 0;
3167
3168 return ret;
3169 }
3170
3171
3172 FT_CALLBACK_DEF( FT_UInt32 * )
3173 tt_cmap14_variant_chars( TT_CMap cmap,
3174 FT_Memory memory,
3175 FT_UInt32 variantSelector )
3176 {
3177 FT_Byte *p = tt_cmap14_find_variant( cmap->data + 6,
3178 variantSelector );
3179 FT_UInt32 *ret;
3180 FT_Int i;
3181 FT_ULong defOff;
3182 FT_ULong nondefOff;
3183
3184
3185 if ( !p )
3186 return NULL;
3187
3188 defOff = TT_NEXT_ULONG( p );
3189 nondefOff = TT_NEXT_ULONG( p );
3190
3191 if ( defOff == 0 && nondefOff == 0 )
3192 return NULL;
3193
3194 if ( defOff == 0 )
3195 return tt_cmap14_get_nondef_chars( cmap, cmap->data + nondefOff,
3196 memory );
3197 else if ( nondefOff == 0 )
3198 return tt_cmap14_get_def_chars( cmap, cmap->data + defOff,
3199 memory );
3200 else
3201 {
3202 /* Both a default and a non-default glyph set? That's probably not */
3203 /* good font design, but the spec allows for it... */
3204 TT_CMap14 cmap14 = (TT_CMap14) cmap;
3205 FT_UInt32 numRanges;
3206 FT_UInt32 numMappings;
3207 FT_UInt32 duni;
3208 FT_UInt32 dcnt;
3209 FT_UInt32 nuni;
3210 FT_Byte* dp;
3211 FT_UInt di, ni, k;
3212
3213
3214 p = cmap->data + nondefOff;
3215 dp = cmap->data + defOff;
3216
3217 numMappings = (FT_UInt32)TT_NEXT_ULONG( p );
3218 dcnt = tt_cmap14_def_char_count( dp );
3219 numRanges = (FT_UInt32)TT_NEXT_ULONG( dp );
3220
3221 if ( numMappings == 0 )
3222 return tt_cmap14_get_def_chars( cmap, cmap->data + defOff,
3223 memory );
3224 if ( dcnt == 0 )
3225 return tt_cmap14_get_nondef_chars( cmap, cmap->data + nondefOff,
3226 memory );
3227
3228 if ( tt_cmap14_ensure( cmap14, ( dcnt + numMappings + 1 ), memory ) )
3229 return NULL;
3230
3231 ret = cmap14->results;
3232 duni = (FT_UInt32)TT_NEXT_UINT24( dp );
3233 dcnt = FT_NEXT_BYTE( dp );
3234 di = 1;
3235 nuni = (FT_UInt32)TT_NEXT_UINT24( p );
3236 p += 2;
3237 ni = 1;
3238 i = 0;
3239
3240 for ( ;; )
3241 {
3242 if ( nuni > duni + dcnt )
3243 {
3244 for ( k = 0; k <= dcnt; ++k )
3245 ret[i++] = duni + k;
3246
3247 ++di;
3248
3249 if ( di > numRanges )
3250 break;
3251
3252 duni = (FT_UInt32)TT_NEXT_UINT24( dp );
3253 dcnt = FT_NEXT_BYTE( dp );
3254 }
3255 else
3256 {
3257 if ( nuni < duni )
3258 ret[i++] = nuni;
3259 /* If it is within the default range then ignore it -- */
3260 /* that should not have happened */
3261 ++ni;
3262 if ( ni > numMappings )
3263 break;
3264
3265 nuni = (FT_UInt32)TT_NEXT_UINT24( p );
3266 p += 2;
3267 }
3268 }
3269
3270 if ( ni <= numMappings )
3271 {
3272 /* If we get here then we have run out of all default ranges. */
3273 /* We have read one non-default mapping which we haven't stored */
3274 /* and there may be others that need to be read. */
3275 ret[i++] = nuni;
3276 while ( ni < numMappings )
3277 {
3278 ret[i++] = (FT_UInt32)TT_NEXT_UINT24( p );
3279 p += 2;
3280 ++ni;
3281 }
3282 }
3283 else if ( di <= numRanges )
3284 {
3285 /* If we get here then we have run out of all non-default */
3286 /* mappings. We have read one default range which we haven't */
3287 /* stored and there may be others that need to be read. */
3288 for ( k = 0; k <= dcnt; ++k )
3289 ret[i++] = duni + k;
3290
3291 while ( di < numRanges )
3292 {
3293 duni = (FT_UInt32)TT_NEXT_UINT24( dp );
3294 dcnt = FT_NEXT_BYTE( dp );
3295
3296 for ( k = 0; k <= dcnt; ++k )
3297 ret[i++] = duni + k;
3298 ++di;
3299 }
3300 }
3301
3302 ret[i] = 0;
3303
3304 return ret;
3305 }
3306 }
3307
3308
3309 FT_DEFINE_TT_CMAP(tt_cmap14_class_rec,
3310 sizeof ( TT_CMap14Rec ),
3311
3312 (FT_CMap_InitFunc) tt_cmap14_init,
3313 (FT_CMap_DoneFunc) tt_cmap14_done,
3314 (FT_CMap_CharIndexFunc)tt_cmap14_char_index,
3315 (FT_CMap_CharNextFunc) tt_cmap14_char_next,
3316
3317 /* Format 14 extension functions */
3318 (FT_CMap_CharVarIndexFunc) tt_cmap14_char_var_index,
3319 (FT_CMap_CharVarIsDefaultFunc)tt_cmap14_char_var_isdefault,
3320 (FT_CMap_VariantListFunc) tt_cmap14_variants,
3321 (FT_CMap_CharVariantListFunc) tt_cmap14_char_variants,
3322 (FT_CMap_VariantCharListFunc) tt_cmap14_variant_chars
3323 ,
3324 14,
3325 (TT_CMap_ValidateFunc)tt_cmap14_validate,
3326 (TT_CMap_Info_GetFunc)tt_cmap14_get_info
3327 )
3328
3329 #endif /* TT_CONFIG_CMAP_FORMAT_14 */
3330
3331
3332 #ifndef FT_CONFIG_OPTION_PIC
3333
3334 static const TT_CMap_Class tt_cmap_classes[] =
3335 {
3336 #define TTCMAPCITEM(a) &a,
3337 #include "ttcmapc.h"
3338 NULL,
3339 };
3340
3341 #else /*FT_CONFIG_OPTION_PIC*/
3342
3343 void FT_Destroy_Class_tt_cmap_classes(FT_Library library, TT_CMap_Class* clazz)
3344 {
3345 FT_Memory memory = library->memory;
3346 if ( clazz )
3347 FT_FREE( clazz );
3348 }
3349
3350 FT_Error FT_Create_Class_tt_cmap_classes(FT_Library library, TT_CMap_Class** output_class)
3351 {
3352 TT_CMap_Class* clazz;
3353 TT_CMap_ClassRec* recs;
3354 FT_Error error;
3355 FT_Memory memory = library->memory;
3356 int i = 0;
3357
3358 #define TTCMAPCITEM(a) i++;
3359 #include "ttcmapc.h"
3360
3361 /* allocate enough space for both the pointers +terminator and the class instances */
3362 if ( FT_ALLOC( clazz, sizeof(*clazz)*(i+1)+sizeof(TT_CMap_ClassRec)*i ) )
3363 return error;
3364
3365 /* the location of the class instances follows the array of pointers */
3366 recs = (TT_CMap_ClassRec*) (((char*)clazz)+(sizeof(*clazz)*(i+1)));
3367 i=0;
3368
3369 #undef TTCMAPCITEM
3370 #define TTCMAPCITEM(a) \
3371 FT_Init_Class_##a(&recs[i]); \
3372 clazz[i] = &recs[i]; \
3373 i++;
3374 #include "ttcmapc.h"
3375
3376 clazz[i] = NULL;
3377
3378 *output_class = clazz;
3379 return SFNT_Err_Ok;
3380 }
3381
3382 #endif /*FT_CONFIG_OPTION_PIC*/
3383
3384
3385 /* parse the `cmap' table and build the corresponding TT_CMap objects */
3386 /* in the current face */
3387 /* */
3388 FT_LOCAL_DEF( FT_Error )
3389 tt_face_build_cmaps( TT_Face face )
3390 {
3391 FT_Byte* table = face->cmap_table;
3392 FT_Byte* limit = table + face->cmap_size;
3393 FT_UInt volatile num_cmaps;
3394 FT_Byte* volatile p = table;
3395 FT_Library library = FT_FACE_LIBRARY( face );
3396
3397 FT_UNUSED( library );
3398
3399
3400 if ( !p || p + 4 > limit )
3401 return SFNT_Err_Invalid_Table;
3402
3403 /* only recognize format 0 */
3404 if ( TT_NEXT_USHORT( p ) != 0 )
3405 {
3406 p -= 2;
3407 FT_ERROR(( "tt_face_build_cmaps:"
3408 " unsupported `cmap' table format = %d\n",
3409 TT_PEEK_USHORT( p ) ));
3410 return SFNT_Err_Invalid_Table;
3411 }
3412
3413 num_cmaps = TT_NEXT_USHORT( p );
3414 #ifdef FT_MAX_CHARMAP_CACHEABLE
3415 if ( num_cmaps > FT_MAX_CHARMAP_CACHEABLE )
3416 FT_ERROR(( "tt_face_build_cmaps: too many cmap subtables(%d) "
3417 "subtable#%d and later are loaded but cannot be searched\n",
3418 num_cmaps, FT_MAX_CHARMAP_CACHEABLE + 1 ));
3419 #endif
3420
3421 for ( ; num_cmaps > 0 && p + 8 <= limit; num_cmaps-- )
3422 {
3423 FT_CharMapRec charmap;
3424 FT_UInt32 offset;
3425
3426
3427 charmap.platform_id = TT_NEXT_USHORT( p );
3428 charmap.encoding_id = TT_NEXT_USHORT( p );
3429 charmap.face = FT_FACE( face );
3430 charmap.encoding = FT_ENCODING_NONE; /* will be filled later */
3431 offset = TT_NEXT_ULONG( p );
3432
3433 if ( offset && offset <= face->cmap_size - 2 )
3434 {
3435 FT_Byte* volatile cmap = table + offset;
3436 volatile FT_UInt format = TT_PEEK_USHORT( cmap );
3437 const TT_CMap_Class* volatile pclazz = FT_TT_CMAP_CLASSES_GET;
3438 TT_CMap_Class volatile clazz;
3439
3440
3441 for ( ; *pclazz; pclazz++ )
3442 {
3443 clazz = *pclazz;
3444 if ( clazz->format == format )
3445 {
3446 volatile TT_ValidatorRec valid;
3447 volatile FT_Error error = SFNT_Err_Ok;
3448
3449
3450 ft_validator_init( FT_VALIDATOR( &valid ), cmap, limit,
3451 FT_VALIDATE_DEFAULT );
3452
3453 valid.num_glyphs = (FT_UInt)face->max_profile.numGlyphs;
3454
3455 if ( ft_setjmp(
3456 *((ft_jmp_buf*)&FT_VALIDATOR( &valid )->jump_buffer) ) == 0 )
3457 {
3458 /* validate this cmap sub-table */
3459 error = clazz->validate( cmap, FT_VALIDATOR( &valid ) );
3460 }
3461
3462 if ( valid.validator.error == 0 )
3463 {
3464 FT_CMap ttcmap;
3465
3466
3467 /* It might make sense to store the single variation selector */
3468 /* cmap somewhere special. But it would have to be in the */
3469 /* public FT_FaceRec, and we can't change that. */
3470
3471 if ( !FT_CMap_New( (FT_CMap_Class)clazz,
3472 cmap, &charmap, &ttcmap ) )
3473 {
3474 /* it is simpler to directly set `flags' than adding */
3475 /* a parameter to FT_CMap_New */
3476 ((TT_CMap)ttcmap)->flags = (FT_Int)error;
3477 }
3478 }
3479 else
3480 {
3481 FT_TRACE0(( "tt_face_build_cmaps:"
3482 " broken cmap sub-table ignored\n" ));
3483 }
3484 break;
3485 }
3486 }
3487
3488 if ( *pclazz == NULL )
3489 {
3490 FT_TRACE0(( "tt_face_build_cmaps:"
3491 " unsupported cmap sub-table ignored\n" ));
3492 }
3493 }
3494 }
3495
3496 return SFNT_Err_Ok;
3497 }
3498
3499
3500 FT_LOCAL( FT_Error )
3501 tt_get_cmap_info( FT_CharMap charmap,
3502 TT_CMapInfo *cmap_info )
3503 {
3504 FT_CMap cmap = (FT_CMap)charmap;
3505 TT_CMap_Class clazz = (TT_CMap_Class)cmap->clazz;
3506
3507
3508 return clazz->get_cmap_info( charmap, cmap_info );
3509 }
3510
3511
3512 /* END */
A free Windows-compatible Operating System