ttgload.c revision 8c82ec5b17d0cfc9b0876a2d848acc207a62a25a
1/***************************************************************************/ 2/* */ 3/* ttgload.c */ 4/* */ 5/* TrueType Glyph Loader (body). */ 6/* */ 7/* Copyright 1996-2011 */ 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#include FT_INTERNAL_CALC_H 22#include FT_INTERNAL_STREAM_H 23#include FT_INTERNAL_SFNT_H 24#include FT_TRUETYPE_TAGS_H 25#include FT_OUTLINE_H 26 27#include "ttgload.h" 28#include "ttpload.h" 29 30#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT 31#include "ttgxvar.h" 32#endif 33 34#include "tterrors.h" 35 36 37 /*************************************************************************/ 38 /* */ 39 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ 40 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ 41 /* messages during execution. */ 42 /* */ 43#undef FT_COMPONENT 44#define FT_COMPONENT trace_ttgload 45 46 47 /*************************************************************************/ 48 /* */ 49 /* Composite glyph flags. */ 50 /* */ 51#define ARGS_ARE_WORDS 0x0001 52#define ARGS_ARE_XY_VALUES 0x0002 53#define ROUND_XY_TO_GRID 0x0004 54#define WE_HAVE_A_SCALE 0x0008 55/* reserved 0x0010 */ 56#define MORE_COMPONENTS 0x0020 57#define WE_HAVE_AN_XY_SCALE 0x0040 58#define WE_HAVE_A_2X2 0x0080 59#define WE_HAVE_INSTR 0x0100 60#define USE_MY_METRICS 0x0200 61#define OVERLAP_COMPOUND 0x0400 62#define SCALED_COMPONENT_OFFSET 0x0800 63#define UNSCALED_COMPONENT_OFFSET 0x1000 64 65 66 /*************************************************************************/ 67 /* */ 68 /* Return the horizontal metrics in font units for a given glyph. */ 69 /* */ 70 FT_LOCAL_DEF( void ) 71 TT_Get_HMetrics( TT_Face face, 72 FT_UInt idx, 73 FT_Short* lsb, 74 FT_UShort* aw ) 75 { 76 ( (SFNT_Service)face->sfnt )->get_metrics( face, 0, idx, lsb, aw ); 77 78 FT_TRACE5(( " advance width (font units): %d\n", *aw )); 79 FT_TRACE5(( " left side bearing (font units): %d\n", *lsb )); 80 } 81 82 83 /*************************************************************************/ 84 /* */ 85 /* Return the vertical metrics in font units for a given glyph. */ 86 /* Greg Hitchcock from Microsoft told us that if there were no `vmtx' */ 87 /* table, typoAscender/Descender from the `OS/2' table would be used */ 88 /* instead, and if there were no `OS/2' table, use ascender/descender */ 89 /* from the `hhea' table. But that is not what Microsoft's rasterizer */ 90 /* apparently does: It uses the ppem value as the advance height, and */ 91 /* sets the top side bearing to be zero. */ 92 /* */ 93 FT_LOCAL_DEF( void ) 94 TT_Get_VMetrics( TT_Face face, 95 FT_UInt idx, 96 FT_Short* tsb, 97 FT_UShort* ah ) 98 { 99 if ( face->vertical_info ) 100 ( (SFNT_Service)face->sfnt )->get_metrics( face, 1, idx, tsb, ah ); 101 102#if 1 /* Empirically determined, at variance with what MS said */ 103 104 else 105 { 106 *tsb = 0; 107 *ah = face->root.units_per_EM; 108 } 109 110#else /* This is what MS said to do. It isn't what they do, however. */ 111 112 else if ( face->os2.version != 0xFFFFU ) 113 { 114 *tsb = face->os2.sTypoAscender; 115 *ah = face->os2.sTypoAscender - face->os2.sTypoDescender; 116 } 117 else 118 { 119 *tsb = face->horizontal.Ascender; 120 *ah = face->horizontal.Ascender - face->horizontal.Descender; 121 } 122 123#endif 124 125 FT_TRACE5(( " advance height (font units): %d\n", *ah )); 126 FT_TRACE5(( " top side bearing (font units): %d\n", *tsb )); 127 } 128 129 130 static void 131 tt_get_metrics( TT_Loader loader, 132 FT_UInt glyph_index ) 133 { 134 TT_Face face = (TT_Face)loader->face; 135 136 FT_Short left_bearing = 0, top_bearing = 0; 137 FT_UShort advance_width = 0, advance_height = 0; 138 139 140 TT_Get_HMetrics( face, glyph_index, 141 &left_bearing, 142 &advance_width ); 143 TT_Get_VMetrics( face, glyph_index, 144 &top_bearing, 145 &advance_height ); 146 147 loader->left_bearing = left_bearing; 148 loader->advance = advance_width; 149 loader->top_bearing = top_bearing; 150 loader->vadvance = advance_height; 151 152 if ( !loader->linear_def ) 153 { 154 loader->linear_def = 1; 155 loader->linear = advance_width; 156 } 157 } 158 159 160#ifdef FT_CONFIG_OPTION_INCREMENTAL 161 162 static void 163 tt_get_metrics_incr_overrides( TT_Loader loader, 164 FT_UInt glyph_index ) 165 { 166 TT_Face face = (TT_Face)loader->face; 167 168 FT_Short left_bearing = 0, top_bearing = 0; 169 FT_UShort advance_width = 0, advance_height = 0; 170 171 172 /* If this is an incrementally loaded font check whether there are */ 173 /* overriding metrics for this glyph. */ 174 if ( face->root.internal->incremental_interface && 175 face->root.internal->incremental_interface->funcs->get_glyph_metrics ) 176 { 177 FT_Incremental_MetricsRec metrics; 178 FT_Error error; 179 180 181 metrics.bearing_x = loader->left_bearing; 182 metrics.bearing_y = 0; 183 metrics.advance = loader->advance; 184 metrics.advance_v = 0; 185 186 error = face->root.internal->incremental_interface->funcs->get_glyph_metrics( 187 face->root.internal->incremental_interface->object, 188 glyph_index, FALSE, &metrics ); 189 if ( error ) 190 goto Exit; 191 192 left_bearing = (FT_Short)metrics.bearing_x; 193 advance_width = (FT_UShort)metrics.advance; 194 195#if 0 196 197 /* GWW: Do I do the same for vertical metrics? */ 198 metrics.bearing_x = 0; 199 metrics.bearing_y = loader->top_bearing; 200 metrics.advance = loader->vadvance; 201 202 error = face->root.internal->incremental_interface->funcs->get_glyph_metrics( 203 face->root.internal->incremental_interface->object, 204 glyph_index, TRUE, &metrics ); 205 if ( error ) 206 goto Exit; 207 208 top_bearing = (FT_Short)metrics.bearing_y; 209 advance_height = (FT_UShort)metrics.advance; 210 211#endif /* 0 */ 212 213 loader->left_bearing = left_bearing; 214 loader->advance = advance_width; 215 loader->top_bearing = top_bearing; 216 loader->vadvance = advance_height; 217 218 if ( !loader->linear_def ) 219 { 220 loader->linear_def = 1; 221 loader->linear = advance_width; 222 } 223 } 224 225 Exit: 226 return; 227 } 228 229#endif /* FT_CONFIG_OPTION_INCREMENTAL */ 230 231 232 /*************************************************************************/ 233 /* */ 234 /* Translates an array of coordinates. */ 235 /* */ 236 static void 237 translate_array( FT_UInt n, 238 FT_Vector* coords, 239 FT_Pos delta_x, 240 FT_Pos delta_y ) 241 { 242 FT_UInt k; 243 244 245 if ( delta_x ) 246 for ( k = 0; k < n; k++ ) 247 coords[k].x += delta_x; 248 249 if ( delta_y ) 250 for ( k = 0; k < n; k++ ) 251 coords[k].y += delta_y; 252 } 253 254 255#undef IS_HINTED 256#define IS_HINTED( flags ) ( ( flags & FT_LOAD_NO_HINTING ) == 0 ) 257 258 259 /*************************************************************************/ 260 /* */ 261 /* The following functions are used by default with TrueType fonts. */ 262 /* However, they can be replaced by alternatives if we need to support */ 263 /* TrueType-compressed formats (like MicroType) in the future. */ 264 /* */ 265 /*************************************************************************/ 266 267 FT_CALLBACK_DEF( FT_Error ) 268 TT_Access_Glyph_Frame( TT_Loader loader, 269 FT_UInt glyph_index, 270 FT_ULong offset, 271 FT_UInt byte_count ) 272 { 273 FT_Error error; 274 FT_Stream stream = loader->stream; 275 276 /* for non-debug mode */ 277 FT_UNUSED( glyph_index ); 278 279 280 FT_TRACE4(( "Glyph %ld\n", glyph_index )); 281 282 /* the following line sets the `error' variable through macros! */ 283 if ( FT_STREAM_SEEK( offset ) || FT_FRAME_ENTER( byte_count ) ) 284 return error; 285 286 loader->cursor = stream->cursor; 287 loader->limit = stream->limit; 288 289 return TT_Err_Ok; 290 } 291 292 293 FT_CALLBACK_DEF( void ) 294 TT_Forget_Glyph_Frame( TT_Loader loader ) 295 { 296 FT_Stream stream = loader->stream; 297 298 299 FT_FRAME_EXIT(); 300 } 301 302 303 FT_CALLBACK_DEF( FT_Error ) 304 TT_Load_Glyph_Header( TT_Loader loader ) 305 { 306 FT_Byte* p = loader->cursor; 307 FT_Byte* limit = loader->limit; 308 309 310 if ( p + 10 > limit ) 311 return TT_Err_Invalid_Outline; 312 313 loader->n_contours = FT_NEXT_SHORT( p ); 314 315 loader->bbox.xMin = FT_NEXT_SHORT( p ); 316 loader->bbox.yMin = FT_NEXT_SHORT( p ); 317 loader->bbox.xMax = FT_NEXT_SHORT( p ); 318 loader->bbox.yMax = FT_NEXT_SHORT( p ); 319 320 FT_TRACE5(( " # of contours: %d\n", loader->n_contours )); 321 FT_TRACE5(( " xMin: %4d xMax: %4d\n", loader->bbox.xMin, 322 loader->bbox.xMax )); 323 FT_TRACE5(( " yMin: %4d yMax: %4d\n", loader->bbox.yMin, 324 loader->bbox.yMax )); 325 loader->cursor = p; 326 327 return TT_Err_Ok; 328 } 329 330 331 FT_CALLBACK_DEF( FT_Error ) 332 TT_Load_Simple_Glyph( TT_Loader load ) 333 { 334 FT_Error error; 335 FT_Byte* p = load->cursor; 336 FT_Byte* limit = load->limit; 337 FT_GlyphLoader gloader = load->gloader; 338 FT_Int n_contours = load->n_contours; 339 FT_Outline* outline; 340 TT_Face face = (TT_Face)load->face; 341 FT_UShort n_ins; 342 FT_Int n_points; 343 344 FT_Byte *flag, *flag_limit; 345 FT_Byte c, count; 346 FT_Vector *vec, *vec_limit; 347 FT_Pos x; 348 FT_Short *cont, *cont_limit, prev_cont; 349 FT_Int xy_size = 0; 350 351 352 /* check that we can add the contours to the glyph */ 353 error = FT_GLYPHLOADER_CHECK_POINTS( gloader, 0, n_contours ); 354 if ( error ) 355 goto Fail; 356 357 /* reading the contours' endpoints & number of points */ 358 cont = gloader->current.outline.contours; 359 cont_limit = cont + n_contours; 360 361 /* check space for contours array + instructions count */ 362 if ( n_contours >= 0xFFF || p + ( n_contours + 1 ) * 2 > limit ) 363 goto Invalid_Outline; 364 365 prev_cont = FT_NEXT_USHORT( p ); 366 367 if ( n_contours > 0 ) 368 cont[0] = prev_cont; 369 370 for ( cont++; cont < cont_limit; cont++ ) 371 { 372 cont[0] = FT_NEXT_USHORT( p ); 373 if ( cont[0] <= prev_cont ) 374 { 375 /* unordered contours: this is invalid */ 376 error = TT_Err_Invalid_Table; 377 goto Fail; 378 } 379 prev_cont = cont[0]; 380 } 381 382 n_points = 0; 383 if ( n_contours > 0 ) 384 { 385 n_points = cont[-1] + 1; 386 if ( n_points < 0 ) 387 goto Invalid_Outline; 388 } 389 390 /* note that we will add four phantom points later */ 391 error = FT_GLYPHLOADER_CHECK_POINTS( gloader, n_points + 4, 0 ); 392 if ( error ) 393 goto Fail; 394 395 /* we'd better check the contours table right now */ 396 outline = &gloader->current.outline; 397 398 for ( cont = outline->contours + 1; cont < cont_limit; cont++ ) 399 if ( cont[-1] >= cont[0] ) 400 goto Invalid_Outline; 401 402 /* reading the bytecode instructions */ 403 load->glyph->control_len = 0; 404 load->glyph->control_data = 0; 405 406 if ( p + 2 > limit ) 407 goto Invalid_Outline; 408 409 n_ins = FT_NEXT_USHORT( p ); 410 411 FT_TRACE5(( " Instructions size: %u\n", n_ins )); 412 413 if ( n_ins > face->max_profile.maxSizeOfInstructions ) 414 { 415 FT_TRACE0(( "TT_Load_Simple_Glyph: too many instructions (%d)\n", 416 n_ins )); 417 error = TT_Err_Too_Many_Hints; 418 goto Fail; 419 } 420 421 if ( ( limit - p ) < n_ins ) 422 { 423 FT_TRACE0(( "TT_Load_Simple_Glyph: instruction count mismatch\n" )); 424 error = TT_Err_Too_Many_Hints; 425 goto Fail; 426 } 427 428#ifdef TT_USE_BYTECODE_INTERPRETER 429 430 if ( IS_HINTED( load->load_flags ) ) 431 { 432 load->glyph->control_len = n_ins; 433 load->glyph->control_data = load->exec->glyphIns; 434 435 FT_MEM_COPY( load->exec->glyphIns, p, (FT_Long)n_ins ); 436 } 437 438#endif /* TT_USE_BYTECODE_INTERPRETER */ 439 440 p += n_ins; 441 442 /* reading the point tags */ 443 flag = (FT_Byte*)outline->tags; 444 flag_limit = flag + n_points; 445 446 FT_ASSERT( flag != NULL ); 447 448 while ( flag < flag_limit ) 449 { 450 if ( p + 1 > limit ) 451 goto Invalid_Outline; 452 453 *flag++ = c = FT_NEXT_BYTE( p ); 454 if ( c & 8 ) 455 { 456 if ( p + 1 > limit ) 457 goto Invalid_Outline; 458 459 count = FT_NEXT_BYTE( p ); 460 if ( flag + (FT_Int)count > flag_limit ) 461 goto Invalid_Outline; 462 463 for ( ; count > 0; count-- ) 464 *flag++ = c; 465 } 466 } 467 468 /* reading the X coordinates */ 469 470 vec = outline->points; 471 vec_limit = vec + n_points; 472 flag = (FT_Byte*)outline->tags; 473 x = 0; 474 475 if ( p + xy_size > limit ) 476 goto Invalid_Outline; 477 478 for ( ; vec < vec_limit; vec++, flag++ ) 479 { 480 FT_Pos y = 0; 481 FT_Byte f = *flag; 482 483 484 if ( f & 2 ) 485 { 486 if ( p + 1 > limit ) 487 goto Invalid_Outline; 488 489 y = (FT_Pos)FT_NEXT_BYTE( p ); 490 if ( ( f & 16 ) == 0 ) 491 y = -y; 492 } 493 else if ( ( f & 16 ) == 0 ) 494 { 495 if ( p + 2 > limit ) 496 goto Invalid_Outline; 497 498 y = (FT_Pos)FT_NEXT_SHORT( p ); 499 } 500 501 x += y; 502 vec->x = x; 503 /* the cast is for stupid compilers */ 504 *flag = (FT_Byte)( f & ~( 2 | 16 ) ); 505 } 506 507 /* reading the Y coordinates */ 508 509 vec = gloader->current.outline.points; 510 vec_limit = vec + n_points; 511 flag = (FT_Byte*)outline->tags; 512 x = 0; 513 514 for ( ; vec < vec_limit; vec++, flag++ ) 515 { 516 FT_Pos y = 0; 517 FT_Byte f = *flag; 518 519 520 if ( f & 4 ) 521 { 522 if ( p + 1 > limit ) 523 goto Invalid_Outline; 524 525 y = (FT_Pos)FT_NEXT_BYTE( p ); 526 if ( ( f & 32 ) == 0 ) 527 y = -y; 528 } 529 else if ( ( f & 32 ) == 0 ) 530 { 531 if ( p + 2 > limit ) 532 goto Invalid_Outline; 533 534 y = (FT_Pos)FT_NEXT_SHORT( p ); 535 } 536 537 x += y; 538 vec->y = x; 539 /* the cast is for stupid compilers */ 540 *flag = (FT_Byte)( f & FT_CURVE_TAG_ON ); 541 } 542 543 outline->n_points = (FT_UShort)n_points; 544 outline->n_contours = (FT_Short) n_contours; 545 546 load->cursor = p; 547 548 Fail: 549 return error; 550 551 Invalid_Outline: 552 error = TT_Err_Invalid_Outline; 553 goto Fail; 554 } 555 556 557 FT_CALLBACK_DEF( FT_Error ) 558 TT_Load_Composite_Glyph( TT_Loader loader ) 559 { 560 FT_Error error; 561 FT_Byte* p = loader->cursor; 562 FT_Byte* limit = loader->limit; 563 FT_GlyphLoader gloader = loader->gloader; 564 FT_SubGlyph subglyph; 565 FT_UInt num_subglyphs; 566 567 568 num_subglyphs = 0; 569 570 do 571 { 572 FT_Fixed xx, xy, yy, yx; 573 FT_UInt count; 574 575 576 /* check that we can load a new subglyph */ 577 error = FT_GlyphLoader_CheckSubGlyphs( gloader, num_subglyphs + 1 ); 578 if ( error ) 579 goto Fail; 580 581 /* check space */ 582 if ( p + 4 > limit ) 583 goto Invalid_Composite; 584 585 subglyph = gloader->current.subglyphs + num_subglyphs; 586 587 subglyph->arg1 = subglyph->arg2 = 0; 588 589 subglyph->flags = FT_NEXT_USHORT( p ); 590 subglyph->index = FT_NEXT_USHORT( p ); 591 592 /* check space */ 593 count = 2; 594 if ( subglyph->flags & ARGS_ARE_WORDS ) 595 count += 2; 596 if ( subglyph->flags & WE_HAVE_A_SCALE ) 597 count += 2; 598 else if ( subglyph->flags & WE_HAVE_AN_XY_SCALE ) 599 count += 4; 600 else if ( subglyph->flags & WE_HAVE_A_2X2 ) 601 count += 8; 602 603 if ( p + count > limit ) 604 goto Invalid_Composite; 605 606 /* read arguments */ 607 if ( subglyph->flags & ARGS_ARE_WORDS ) 608 { 609 subglyph->arg1 = FT_NEXT_SHORT( p ); 610 subglyph->arg2 = FT_NEXT_SHORT( p ); 611 } 612 else 613 { 614 subglyph->arg1 = FT_NEXT_CHAR( p ); 615 subglyph->arg2 = FT_NEXT_CHAR( p ); 616 } 617 618 /* read transform */ 619 xx = yy = 0x10000L; 620 xy = yx = 0; 621 622 if ( subglyph->flags & WE_HAVE_A_SCALE ) 623 { 624 xx = (FT_Fixed)FT_NEXT_SHORT( p ) << 2; 625 yy = xx; 626 } 627 else if ( subglyph->flags & WE_HAVE_AN_XY_SCALE ) 628 { 629 xx = (FT_Fixed)FT_NEXT_SHORT( p ) << 2; 630 yy = (FT_Fixed)FT_NEXT_SHORT( p ) << 2; 631 } 632 else if ( subglyph->flags & WE_HAVE_A_2X2 ) 633 { 634 xx = (FT_Fixed)FT_NEXT_SHORT( p ) << 2; 635 yx = (FT_Fixed)FT_NEXT_SHORT( p ) << 2; 636 xy = (FT_Fixed)FT_NEXT_SHORT( p ) << 2; 637 yy = (FT_Fixed)FT_NEXT_SHORT( p ) << 2; 638 } 639 640 subglyph->transform.xx = xx; 641 subglyph->transform.xy = xy; 642 subglyph->transform.yx = yx; 643 subglyph->transform.yy = yy; 644 645 num_subglyphs++; 646 647 } while ( subglyph->flags & MORE_COMPONENTS ); 648 649 gloader->current.num_subglyphs = num_subglyphs; 650 651#ifdef TT_USE_BYTECODE_INTERPRETER 652 653 { 654 FT_Stream stream = loader->stream; 655 656 657 /* we must undo the FT_FRAME_ENTER in order to point */ 658 /* to the composite instructions, if we find some. */ 659 /* We will process them later. */ 660 /* */ 661 loader->ins_pos = (FT_ULong)( FT_STREAM_POS() + 662 p - limit ); 663 } 664 665#endif 666 667 loader->cursor = p; 668 669 Fail: 670 return error; 671 672 Invalid_Composite: 673 error = TT_Err_Invalid_Composite; 674 goto Fail; 675 } 676 677 678 FT_LOCAL_DEF( void ) 679 TT_Init_Glyph_Loading( TT_Face face ) 680 { 681 face->access_glyph_frame = TT_Access_Glyph_Frame; 682 face->read_glyph_header = TT_Load_Glyph_Header; 683 face->read_simple_glyph = TT_Load_Simple_Glyph; 684 face->read_composite_glyph = TT_Load_Composite_Glyph; 685 face->forget_glyph_frame = TT_Forget_Glyph_Frame; 686 } 687 688 689 static void 690 tt_prepare_zone( TT_GlyphZone zone, 691 FT_GlyphLoad load, 692 FT_UInt start_point, 693 FT_UInt start_contour ) 694 { 695 zone->n_points = (FT_UShort)( load->outline.n_points - start_point ); 696 zone->n_contours = (FT_Short) ( load->outline.n_contours - 697 start_contour ); 698 zone->org = load->extra_points + start_point; 699 zone->cur = load->outline.points + start_point; 700 zone->orus = load->extra_points2 + start_point; 701 zone->tags = (FT_Byte*)load->outline.tags + start_point; 702 zone->contours = (FT_UShort*)load->outline.contours + start_contour; 703 zone->first_point = (FT_UShort)start_point; 704 } 705 706 707 /*************************************************************************/ 708 /* */ 709 /* <Function> */ 710 /* TT_Hint_Glyph */ 711 /* */ 712 /* <Description> */ 713 /* Hint the glyph using the zone prepared by the caller. Note that */ 714 /* the zone is supposed to include four phantom points. */ 715 /* */ 716 static FT_Error 717 TT_Hint_Glyph( TT_Loader loader, 718 FT_Bool is_composite ) 719 { 720 TT_GlyphZone zone = &loader->zone; 721 FT_Pos origin; 722 723#ifdef TT_USE_BYTECODE_INTERPRETER 724 FT_UInt n_ins; 725#else 726 FT_UNUSED( is_composite ); 727#endif 728 729 730#ifdef TT_USE_BYTECODE_INTERPRETER 731 if ( loader->glyph->control_len > 0xFFFFL ) 732 { 733 FT_TRACE1(( "TT_Hint_Glyph: too long instructions " )); 734 FT_TRACE1(( "(0x%lx byte) is truncated\n", 735 loader->glyph->control_len )); 736 } 737 n_ins = (FT_UInt)( loader->glyph->control_len ); 738#endif 739 740 origin = zone->cur[zone->n_points - 4].x; 741 origin = FT_PIX_ROUND( origin ) - origin; 742 if ( origin ) 743 translate_array( zone->n_points, zone->cur, origin, 0 ); 744 745#ifdef TT_USE_BYTECODE_INTERPRETER 746 /* save original point position in org */ 747 if ( n_ins > 0 ) 748 FT_ARRAY_COPY( zone->org, zone->cur, zone->n_points ); 749 750 /* Reset graphics state. */ 751 loader->exec->GS = ((TT_Size)loader->size)->GS; 752 753 /* XXX: UNDOCUMENTED! Hinting instructions of a composite glyph */ 754 /* completely refer to the (already) hinted subglyphs. */ 755 if ( is_composite ) 756 { 757 loader->exec->metrics.x_scale = 1 << 16; 758 loader->exec->metrics.y_scale = 1 << 16; 759 760 FT_ARRAY_COPY( zone->orus, zone->cur, zone->n_points ); 761 } 762 else 763 { 764 loader->exec->metrics.x_scale = 765 ((TT_Size)loader->size)->metrics.x_scale; 766 loader->exec->metrics.y_scale = 767 ((TT_Size)loader->size)->metrics.y_scale; 768 } 769#endif 770 771 /* round pp2 and pp4 */ 772 zone->cur[zone->n_points - 3].x = 773 FT_PIX_ROUND( zone->cur[zone->n_points - 3].x ); 774 zone->cur[zone->n_points - 1].y = 775 FT_PIX_ROUND( zone->cur[zone->n_points - 1].y ); 776 777#ifdef TT_USE_BYTECODE_INTERPRETER 778 779 if ( n_ins > 0 ) 780 { 781 FT_Bool debug; 782 FT_Error error; 783 784 FT_GlyphLoader gloader = loader->gloader; 785 FT_Outline current_outline = gloader->current.outline; 786 787 788 error = TT_Set_CodeRange( loader->exec, tt_coderange_glyph, 789 loader->exec->glyphIns, n_ins ); 790 if ( error ) 791 return error; 792 793 loader->exec->is_composite = is_composite; 794 loader->exec->pts = *zone; 795 796 debug = FT_BOOL( !( loader->load_flags & FT_LOAD_NO_SCALE ) && 797 ((TT_Size)loader->size)->debug ); 798 799 error = TT_Run_Context( loader->exec, debug ); 800 if ( error && loader->exec->pedantic_hinting ) 801 return error; 802 803 /* store drop-out mode in bits 5-7; set bit 2 also as a marker */ 804 current_outline.tags[0] |= 805 ( loader->exec->GS.scan_type << 5 ) | FT_CURVE_TAG_HAS_SCANMODE; 806 } 807 808#endif 809 810 /* save glyph phantom points */ 811 if ( !loader->preserve_pps ) 812 { 813 loader->pp1 = zone->cur[zone->n_points - 4]; 814 loader->pp2 = zone->cur[zone->n_points - 3]; 815 loader->pp3 = zone->cur[zone->n_points - 2]; 816 loader->pp4 = zone->cur[zone->n_points - 1]; 817 } 818 819 return TT_Err_Ok; 820 } 821 822 823 /*************************************************************************/ 824 /* */ 825 /* <Function> */ 826 /* TT_Process_Simple_Glyph */ 827 /* */ 828 /* <Description> */ 829 /* Once a simple glyph has been loaded, it needs to be processed. */ 830 /* Usually, this means scaling and hinting through bytecode */ 831 /* interpretation. */ 832 /* */ 833 static FT_Error 834 TT_Process_Simple_Glyph( TT_Loader loader ) 835 { 836 FT_GlyphLoader gloader = loader->gloader; 837 FT_Error error = TT_Err_Ok; 838 FT_Outline* outline; 839 FT_Int n_points; 840 841 842 outline = &gloader->current.outline; 843 n_points = outline->n_points; 844 845 /* set phantom points */ 846 847 outline->points[n_points ] = loader->pp1; 848 outline->points[n_points + 1] = loader->pp2; 849 outline->points[n_points + 2] = loader->pp3; 850 outline->points[n_points + 3] = loader->pp4; 851 852 outline->tags[n_points ] = 0; 853 outline->tags[n_points + 1] = 0; 854 outline->tags[n_points + 2] = 0; 855 outline->tags[n_points + 3] = 0; 856 857 n_points += 4; 858 859#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT 860 861 if ( ((TT_Face)loader->face)->doblend ) 862 { 863 /* Deltas apply to the unscaled data. */ 864 FT_Vector* deltas; 865 FT_Memory memory = loader->face->memory; 866 FT_Int i; 867 868 869 error = TT_Vary_Get_Glyph_Deltas( (TT_Face)(loader->face), 870 loader->glyph_index, 871 &deltas, 872 n_points ); 873 if ( error ) 874 return error; 875 876 for ( i = 0; i < n_points; ++i ) 877 { 878 outline->points[i].x += deltas[i].x; 879 outline->points[i].y += deltas[i].y; 880 } 881 882 FT_FREE( deltas ); 883 } 884 885#endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */ 886 887 if ( IS_HINTED( loader->load_flags ) ) 888 { 889 tt_prepare_zone( &loader->zone, &gloader->current, 0, 0 ); 890 891 FT_ARRAY_COPY( loader->zone.orus, loader->zone.cur, 892 loader->zone.n_points + 4 ); 893 } 894 895 /* scale the glyph */ 896 if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 ) 897 { 898 FT_Vector* vec = outline->points; 899 FT_Vector* limit = outline->points + n_points; 900 FT_Fixed x_scale = ((TT_Size)loader->size)->metrics.x_scale; 901 FT_Fixed y_scale = ((TT_Size)loader->size)->metrics.y_scale; 902 903 904 for ( ; vec < limit; vec++ ) 905 { 906 vec->x = FT_MulFix( vec->x, x_scale ); 907 vec->y = FT_MulFix( vec->y, y_scale ); 908 } 909 910 loader->pp1 = outline->points[n_points - 4]; 911 loader->pp2 = outline->points[n_points - 3]; 912 loader->pp3 = outline->points[n_points - 2]; 913 loader->pp4 = outline->points[n_points - 1]; 914 } 915 916 if ( IS_HINTED( loader->load_flags ) ) 917 { 918 loader->zone.n_points += 4; 919 920 error = TT_Hint_Glyph( loader, 0 ); 921 } 922 923 return error; 924 } 925 926 927 /*************************************************************************/ 928 /* */ 929 /* <Function> */ 930 /* TT_Process_Composite_Component */ 931 /* */ 932 /* <Description> */ 933 /* Once a composite component has been loaded, it needs to be */ 934 /* processed. Usually, this means transforming and translating. */ 935 /* */ 936 static FT_Error 937 TT_Process_Composite_Component( TT_Loader loader, 938 FT_SubGlyph subglyph, 939 FT_UInt start_point, 940 FT_UInt num_base_points ) 941 { 942 FT_GlyphLoader gloader = loader->gloader; 943 FT_Vector* base_vec = gloader->base.outline.points; 944 FT_UInt num_points = gloader->base.outline.n_points; 945 FT_Bool have_scale; 946 FT_Pos x, y; 947 948 949 have_scale = FT_BOOL( subglyph->flags & ( WE_HAVE_A_SCALE | 950 WE_HAVE_AN_XY_SCALE | 951 WE_HAVE_A_2X2 ) ); 952 953 /* perform the transform required for this subglyph */ 954 if ( have_scale ) 955 { 956 FT_UInt i; 957 958 959 for ( i = num_base_points; i < num_points; i++ ) 960 FT_Vector_Transform( base_vec + i, &subglyph->transform ); 961 } 962 963 /* get offset */ 964 if ( !( subglyph->flags & ARGS_ARE_XY_VALUES ) ) 965 { 966 FT_UInt k = subglyph->arg1; 967 FT_UInt l = subglyph->arg2; 968 FT_Vector* p1; 969 FT_Vector* p2; 970 971 972 /* match l-th point of the newly loaded component to the k-th point */ 973 /* of the previously loaded components. */ 974 975 /* change to the point numbers used by our outline */ 976 k += start_point; 977 l += num_base_points; 978 if ( k >= num_base_points || 979 l >= num_points ) 980 return TT_Err_Invalid_Composite; 981 982 p1 = gloader->base.outline.points + k; 983 p2 = gloader->base.outline.points + l; 984 985 x = p1->x - p2->x; 986 y = p1->y - p2->y; 987 } 988 else 989 { 990 x = subglyph->arg1; 991 y = subglyph->arg2; 992 993 if ( !x && !y ) 994 return TT_Err_Ok; 995 996 /* Use a default value dependent on */ 997 /* TT_CONFIG_OPTION_COMPONENT_OFFSET_SCALED. This is useful for old TT */ 998 /* fonts which don't set the xxx_COMPONENT_OFFSET bit. */ 999 1000 if ( have_scale && 1001#ifdef TT_CONFIG_OPTION_COMPONENT_OFFSET_SCALED 1002 !( subglyph->flags & UNSCALED_COMPONENT_OFFSET ) ) 1003#else 1004 ( subglyph->flags & SCALED_COMPONENT_OFFSET ) ) 1005#endif 1006 { 1007 1008#if 0 1009 1010 /*************************************************************************/ 1011 /* */ 1012 /* This algorithm is what Apple documents. But it doesn't work. */ 1013 /* */ 1014 int a = subglyph->transform.xx > 0 ? subglyph->transform.xx 1015 : -subglyph->transform.xx; 1016 int b = subglyph->transform.yx > 0 ? subglyph->transform.yx 1017 : -subglyph->transform.yx; 1018 int c = subglyph->transform.xy > 0 ? subglyph->transform.xy 1019 : -subglyph->transform.xy; 1020 int d = subglyph->transform.yy > 0 ? subglyph->transform.yy 1021 : -subglyph->transform.yy; 1022 int m = a > b ? a : b; 1023 int n = c > d ? c : d; 1024 1025 1026 if ( a - b <= 33 && a - b >= -33 ) 1027 m *= 2; 1028 if ( c - d <= 33 && c - d >= -33 ) 1029 n *= 2; 1030 x = FT_MulFix( x, m ); 1031 y = FT_MulFix( y, n ); 1032 1033#else /* 0 */ 1034 1035 /*************************************************************************/ 1036 /* */ 1037 /* This algorithm is a guess and works much better than the above. */ 1038 /* */ 1039 FT_Fixed mac_xscale = FT_SqrtFixed( 1040 (FT_Int32)FT_MulFix( subglyph->transform.xx, 1041 subglyph->transform.xx ) + 1042 (FT_Int32)FT_MulFix( subglyph->transform.xy, 1043 subglyph->transform.xy ) ); 1044 FT_Fixed mac_yscale = FT_SqrtFixed( 1045 (FT_Int32)FT_MulFix( subglyph->transform.yy, 1046 subglyph->transform.yy ) + 1047 (FT_Int32)FT_MulFix( subglyph->transform.yx, 1048 subglyph->transform.yx ) ); 1049 1050 1051 x = FT_MulFix( x, mac_xscale ); 1052 y = FT_MulFix( y, mac_yscale ); 1053 1054#endif /* 0 */ 1055 1056 } 1057 1058 if ( !( loader->load_flags & FT_LOAD_NO_SCALE ) ) 1059 { 1060 FT_Fixed x_scale = ((TT_Size)loader->size)->metrics.x_scale; 1061 FT_Fixed y_scale = ((TT_Size)loader->size)->metrics.y_scale; 1062 1063 1064 x = FT_MulFix( x, x_scale ); 1065 y = FT_MulFix( y, y_scale ); 1066 1067 if ( subglyph->flags & ROUND_XY_TO_GRID ) 1068 { 1069 x = FT_PIX_ROUND( x ); 1070 y = FT_PIX_ROUND( y ); 1071 } 1072 } 1073 } 1074 1075 if ( x || y ) 1076 translate_array( num_points - num_base_points, 1077 base_vec + num_base_points, 1078 x, y ); 1079 1080 return TT_Err_Ok; 1081 } 1082 1083 1084 /*************************************************************************/ 1085 /* */ 1086 /* <Function> */ 1087 /* TT_Process_Composite_Glyph */ 1088 /* */ 1089 /* <Description> */ 1090 /* This is slightly different from TT_Process_Simple_Glyph, in that */ 1091 /* its sole purpose is to hint the glyph. Thus this function is */ 1092 /* only available when bytecode interpreter is enabled. */ 1093 /* */ 1094 static FT_Error 1095 TT_Process_Composite_Glyph( TT_Loader loader, 1096 FT_UInt start_point, 1097 FT_UInt start_contour ) 1098 { 1099 FT_Error error; 1100 FT_Outline* outline; 1101 FT_UInt i; 1102 1103 1104 outline = &loader->gloader->base.outline; 1105 1106 /* make room for phantom points */ 1107 error = FT_GLYPHLOADER_CHECK_POINTS( loader->gloader, 1108 outline->n_points + 4, 1109 0 ); 1110 if ( error ) 1111 return error; 1112 1113 outline->points[outline->n_points ] = loader->pp1; 1114 outline->points[outline->n_points + 1] = loader->pp2; 1115 outline->points[outline->n_points + 2] = loader->pp3; 1116 outline->points[outline->n_points + 3] = loader->pp4; 1117 1118 outline->tags[outline->n_points ] = 0; 1119 outline->tags[outline->n_points + 1] = 0; 1120 outline->tags[outline->n_points + 2] = 0; 1121 outline->tags[outline->n_points + 3] = 0; 1122 1123#ifdef TT_USE_BYTECODE_INTERPRETER 1124 1125 { 1126 FT_Stream stream = loader->stream; 1127 FT_UShort n_ins, max_ins; 1128 FT_ULong tmp; 1129 1130 1131 /* TT_Load_Composite_Glyph only gives us the offset of instructions */ 1132 /* so we read them here */ 1133 if ( FT_STREAM_SEEK( loader->ins_pos ) || 1134 FT_READ_USHORT( n_ins ) ) 1135 return error; 1136 1137 FT_TRACE5(( " Instructions size = %d\n", n_ins )); 1138 1139 /* check it */ 1140 max_ins = ((TT_Face)loader->face)->max_profile.maxSizeOfInstructions; 1141 if ( n_ins > max_ins ) 1142 { 1143 /* acroread ignores this field, so we only do a rough safety check */ 1144 if ( (FT_Int)n_ins > loader->byte_len ) 1145 { 1146 FT_TRACE1(( "TT_Process_Composite_Glyph: " 1147 "too many instructions (%d) for glyph with length %d\n", 1148 n_ins, loader->byte_len )); 1149 return TT_Err_Too_Many_Hints; 1150 } 1151 1152 tmp = loader->exec->glyphSize; 1153 error = Update_Max( loader->exec->memory, 1154 &tmp, 1155 sizeof ( FT_Byte ), 1156 (void*)&loader->exec->glyphIns, 1157 n_ins ); 1158 loader->exec->glyphSize = (FT_UShort)tmp; 1159 if ( error ) 1160 return error; 1161 } 1162 else if ( n_ins == 0 ) 1163 return TT_Err_Ok; 1164 1165 if ( FT_STREAM_READ( loader->exec->glyphIns, n_ins ) ) 1166 return error; 1167 1168 loader->glyph->control_data = loader->exec->glyphIns; 1169 loader->glyph->control_len = n_ins; 1170 } 1171 1172#endif 1173 1174 tt_prepare_zone( &loader->zone, &loader->gloader->base, 1175 start_point, start_contour ); 1176 1177 /* Some points are likely touched during execution of */ 1178 /* instructions on components. So let's untouch them. */ 1179 for ( i = start_point; i < loader->zone.n_points; i++ ) 1180 loader->zone.tags[i] &= ~FT_CURVE_TAG_TOUCH_BOTH; 1181 1182 loader->zone.n_points += 4; 1183 1184 return TT_Hint_Glyph( loader, 1 ); 1185 } 1186 1187 1188 /* Calculate the four phantom points. */ 1189 /* The first two stand for horizontal origin and advance. */ 1190 /* The last two stand for vertical origin and advance. */ 1191#define TT_LOADER_SET_PP( loader ) \ 1192 do { \ 1193 (loader)->pp1.x = (loader)->bbox.xMin - (loader)->left_bearing; \ 1194 (loader)->pp1.y = 0; \ 1195 (loader)->pp2.x = (loader)->pp1.x + (loader)->advance; \ 1196 (loader)->pp2.y = 0; \ 1197 (loader)->pp3.x = 0; \ 1198 (loader)->pp3.y = (loader)->top_bearing + (loader)->bbox.yMax; \ 1199 (loader)->pp4.x = 0; \ 1200 (loader)->pp4.y = (loader)->pp3.y - (loader)->vadvance; \ 1201 } while ( 0 ) 1202 1203 1204 /*************************************************************************/ 1205 /* */ 1206 /* <Function> */ 1207 /* load_truetype_glyph */ 1208 /* */ 1209 /* <Description> */ 1210 /* Loads a given truetype glyph. Handles composites and uses a */ 1211 /* TT_Loader object. */ 1212 /* */ 1213 static FT_Error 1214 load_truetype_glyph( TT_Loader loader, 1215 FT_UInt glyph_index, 1216 FT_UInt recurse_count, 1217 FT_Bool header_only ) 1218 { 1219 FT_Error error = TT_Err_Ok; 1220 FT_Fixed x_scale, y_scale; 1221 FT_ULong offset; 1222 TT_Face face = (TT_Face)loader->face; 1223 FT_GlyphLoader gloader = loader->gloader; 1224 FT_Bool opened_frame = 0; 1225 1226#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT 1227 FT_Vector* deltas = NULL; 1228#endif 1229 1230#ifdef FT_CONFIG_OPTION_INCREMENTAL 1231 FT_StreamRec inc_stream; 1232 FT_Data glyph_data; 1233 FT_Bool glyph_data_loaded = 0; 1234#endif 1235 1236 1237 /* some fonts have an incorrect value of `maxComponentDepth', */ 1238 /* thus we allow depth 1 to catch the majority of them */ 1239 if ( recurse_count > 1 && 1240 recurse_count > face->max_profile.maxComponentDepth ) 1241 { 1242 error = TT_Err_Invalid_Composite; 1243 goto Exit; 1244 } 1245 1246 /* check glyph index */ 1247 if ( glyph_index >= (FT_UInt)face->root.num_glyphs ) 1248 { 1249 error = TT_Err_Invalid_Glyph_Index; 1250 goto Exit; 1251 } 1252 1253 loader->glyph_index = glyph_index; 1254 1255 if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 ) 1256 { 1257 x_scale = ((TT_Size)loader->size)->metrics.x_scale; 1258 y_scale = ((TT_Size)loader->size)->metrics.y_scale; 1259 } 1260 else 1261 { 1262 x_scale = 0x10000L; 1263 y_scale = 0x10000L; 1264 } 1265 1266 tt_get_metrics( loader, glyph_index ); 1267 1268 /* Set `offset' to the start of the glyph relative to the start of */ 1269 /* the `glyf' table, and `byte_len' to the length of the glyph in */ 1270 /* bytes. */ 1271 1272#ifdef FT_CONFIG_OPTION_INCREMENTAL 1273 1274 /* If we are loading glyph data via the incremental interface, set */ 1275 /* the loader stream to a memory stream reading the data returned */ 1276 /* by the interface. */ 1277 if ( face->root.internal->incremental_interface ) 1278 { 1279 error = face->root.internal->incremental_interface->funcs->get_glyph_data( 1280 face->root.internal->incremental_interface->object, 1281 glyph_index, &glyph_data ); 1282 if ( error ) 1283 goto Exit; 1284 1285 glyph_data_loaded = 1; 1286 offset = 0; 1287 loader->byte_len = glyph_data.length; 1288 1289 FT_MEM_ZERO( &inc_stream, sizeof ( inc_stream ) ); 1290 FT_Stream_OpenMemory( &inc_stream, 1291 glyph_data.pointer, glyph_data.length ); 1292 1293 loader->stream = &inc_stream; 1294 } 1295 else 1296 1297#endif /* FT_CONFIG_OPTION_INCREMENTAL */ 1298 1299 offset = tt_face_get_location( face, glyph_index, 1300 (FT_UInt*)&loader->byte_len ); 1301 1302 if ( loader->byte_len > 0 ) 1303 { 1304#ifdef FT_CONFIG_OPTION_INCREMENTAL 1305 /* for the incremental interface, `glyf_offset' is always zero */ 1306 if ( !loader->glyf_offset && 1307 !face->root.internal->incremental_interface ) 1308#else 1309 if ( !loader->glyf_offset ) 1310#endif /* FT_CONFIG_OPTION_INCREMENTAL */ 1311 { 1312 FT_TRACE2(( "no `glyf' table but non-zero `loca' entry\n" )); 1313 error = TT_Err_Invalid_Table; 1314 goto Exit; 1315 } 1316 1317 error = face->access_glyph_frame( loader, glyph_index, 1318 loader->glyf_offset + offset, 1319 loader->byte_len ); 1320 if ( error ) 1321 goto Exit; 1322 1323 opened_frame = 1; 1324 1325 /* read glyph header first */ 1326 error = face->read_glyph_header( loader ); 1327 if ( error || header_only ) 1328 goto Exit; 1329 } 1330 1331 if ( loader->byte_len == 0 || loader->n_contours == 0 ) 1332 { 1333 loader->bbox.xMin = 0; 1334 loader->bbox.xMax = 0; 1335 loader->bbox.yMin = 0; 1336 loader->bbox.yMax = 0; 1337 1338 if ( header_only ) 1339 goto Exit; 1340 1341 /* must initialize points before (possibly) overriding */ 1342 /* glyph metrics from the incremental interface */ 1343 TT_LOADER_SET_PP( loader ); 1344 1345#ifdef FT_CONFIG_OPTION_INCREMENTAL 1346 tt_get_metrics_incr_overrides( loader, glyph_index ); 1347#endif 1348 1349#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT 1350 1351 if ( ((TT_Face)(loader->face))->doblend ) 1352 { 1353 /* this must be done before scaling */ 1354 FT_Memory memory = loader->face->memory; 1355 1356 1357 error = TT_Vary_Get_Glyph_Deltas( (TT_Face)(loader->face), 1358 glyph_index, &deltas, 4 ); 1359 if ( error ) 1360 goto Exit; 1361 1362 loader->pp1.x += deltas[0].x; loader->pp1.y += deltas[0].y; 1363 loader->pp2.x += deltas[1].x; loader->pp2.y += deltas[1].y; 1364 loader->pp3.x += deltas[2].x; loader->pp3.y += deltas[2].y; 1365 loader->pp4.x += deltas[3].x; loader->pp4.y += deltas[3].y; 1366 1367 FT_FREE( deltas ); 1368 } 1369 1370#endif 1371 1372 if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 ) 1373 { 1374 loader->pp1.x = FT_MulFix( loader->pp1.x, x_scale ); 1375 loader->pp2.x = FT_MulFix( loader->pp2.x, x_scale ); 1376 loader->pp3.y = FT_MulFix( loader->pp3.y, y_scale ); 1377 loader->pp4.y = FT_MulFix( loader->pp4.y, y_scale ); 1378 } 1379 1380 error = TT_Err_Ok; 1381 goto Exit; 1382 } 1383 1384 /* must initialize points before (possibly) overriding */ 1385 /* glyph metrics from the incremental interface */ 1386 TT_LOADER_SET_PP( loader ); 1387 1388#ifdef FT_CONFIG_OPTION_INCREMENTAL 1389 tt_get_metrics_incr_overrides( loader, glyph_index ); 1390#endif 1391 1392 /***********************************************************************/ 1393 /***********************************************************************/ 1394 /***********************************************************************/ 1395 1396 /* if it is a simple glyph, load it */ 1397 1398 if ( loader->n_contours > 0 ) 1399 { 1400 error = face->read_simple_glyph( loader ); 1401 if ( error ) 1402 goto Exit; 1403 1404 /* all data have been read */ 1405 face->forget_glyph_frame( loader ); 1406 opened_frame = 0; 1407 1408 error = TT_Process_Simple_Glyph( loader ); 1409 if ( error ) 1410 goto Exit; 1411 1412 FT_GlyphLoader_Add( gloader ); 1413 } 1414 1415 /***********************************************************************/ 1416 /***********************************************************************/ 1417 /***********************************************************************/ 1418 1419 /* otherwise, load a composite! */ 1420 else if ( loader->n_contours == -1 ) 1421 { 1422 FT_UInt start_point; 1423 FT_UInt start_contour; 1424 FT_ULong ins_pos; /* position of composite instructions, if any */ 1425 1426 1427 start_point = gloader->base.outline.n_points; 1428 start_contour = gloader->base.outline.n_contours; 1429 1430 /* for each subglyph, read composite header */ 1431 error = face->read_composite_glyph( loader ); 1432 if ( error ) 1433 goto Exit; 1434 1435 /* store the offset of instructions */ 1436 ins_pos = loader->ins_pos; 1437 1438 /* all data we need are read */ 1439 face->forget_glyph_frame( loader ); 1440 opened_frame = 0; 1441 1442#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT 1443 1444 if ( face->doblend ) 1445 { 1446 FT_Int i, limit; 1447 FT_SubGlyph subglyph; 1448 FT_Memory memory = face->root.memory; 1449 1450 1451 /* this provides additional offsets */ 1452 /* for each component's translation */ 1453 1454 if ( ( error = TT_Vary_Get_Glyph_Deltas( 1455 face, 1456 glyph_index, 1457 &deltas, 1458 gloader->current.num_subglyphs + 4 )) != 0 ) 1459 goto Exit; 1460 1461 subglyph = gloader->current.subglyphs + gloader->base.num_subglyphs; 1462 limit = gloader->current.num_subglyphs; 1463 1464 for ( i = 0; i < limit; ++i, ++subglyph ) 1465 { 1466 if ( subglyph->flags & ARGS_ARE_XY_VALUES ) 1467 { 1468 /* XXX: overflow check for subglyph->{arg1,arg2}. */ 1469 /* deltas[i].{x,y} must be within signed 16-bit, */ 1470 /* but the restriction of summed delta is not clear */ 1471 subglyph->arg1 += (FT_Int16)deltas[i].x; 1472 subglyph->arg2 += (FT_Int16)deltas[i].y; 1473 } 1474 } 1475 1476 loader->pp1.x += deltas[i + 0].x; loader->pp1.y += deltas[i + 0].y; 1477 loader->pp2.x += deltas[i + 1].x; loader->pp2.y += deltas[i + 1].y; 1478 loader->pp3.x += deltas[i + 2].x; loader->pp3.y += deltas[i + 2].y; 1479 loader->pp4.x += deltas[i + 3].x; loader->pp4.y += deltas[i + 3].y; 1480 1481 FT_FREE( deltas ); 1482 } 1483 1484#endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */ 1485 1486 if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 ) 1487 { 1488 loader->pp1.x = FT_MulFix( loader->pp1.x, x_scale ); 1489 loader->pp2.x = FT_MulFix( loader->pp2.x, x_scale ); 1490 loader->pp3.y = FT_MulFix( loader->pp3.y, y_scale ); 1491 loader->pp4.y = FT_MulFix( loader->pp4.y, y_scale ); 1492 } 1493 1494 /* if the flag FT_LOAD_NO_RECURSE is set, we return the subglyph */ 1495 /* `as is' in the glyph slot (the client application will be */ 1496 /* responsible for interpreting these data)... */ 1497 if ( loader->load_flags & FT_LOAD_NO_RECURSE ) 1498 { 1499 FT_GlyphLoader_Add( gloader ); 1500 loader->glyph->format = FT_GLYPH_FORMAT_COMPOSITE; 1501 1502 goto Exit; 1503 } 1504 1505 /*********************************************************************/ 1506 /*********************************************************************/ 1507 /*********************************************************************/ 1508 1509 { 1510 FT_UInt n, num_base_points; 1511 FT_SubGlyph subglyph = 0; 1512 1513 FT_UInt num_points = start_point; 1514 FT_UInt num_subglyphs = gloader->current.num_subglyphs; 1515 FT_UInt num_base_subgs = gloader->base.num_subglyphs; 1516 1517 FT_Stream old_stream = loader->stream; 1518 FT_Int old_byte_len = loader->byte_len; 1519 1520 1521 FT_GlyphLoader_Add( gloader ); 1522 1523 /* read each subglyph independently */ 1524 for ( n = 0; n < num_subglyphs; n++ ) 1525 { 1526 FT_Vector pp[4]; 1527 1528 1529 /* Each time we call load_truetype_glyph in this loop, the */ 1530 /* value of `gloader.base.subglyphs' can change due to table */ 1531 /* reallocations. We thus need to recompute the subglyph */ 1532 /* pointer on each iteration. */ 1533 subglyph = gloader->base.subglyphs + num_base_subgs + n; 1534 1535 pp[0] = loader->pp1; 1536 pp[1] = loader->pp2; 1537 pp[2] = loader->pp3; 1538 pp[3] = loader->pp4; 1539 1540 num_base_points = gloader->base.outline.n_points; 1541 1542 error = load_truetype_glyph( loader, subglyph->index, 1543 recurse_count + 1, FALSE ); 1544 if ( error ) 1545 goto Exit; 1546 1547 /* restore subglyph pointer */ 1548 subglyph = gloader->base.subglyphs + num_base_subgs + n; 1549 1550 if ( !( subglyph->flags & USE_MY_METRICS ) ) 1551 { 1552 loader->pp1 = pp[0]; 1553 loader->pp2 = pp[1]; 1554 loader->pp3 = pp[2]; 1555 loader->pp4 = pp[3]; 1556 } 1557 1558 num_points = gloader->base.outline.n_points; 1559 1560 if ( num_points == num_base_points ) 1561 continue; 1562 1563 /* gloader->base.outline consists of three parts: */ 1564 /* 0 -(1)-> start_point -(2)-> num_base_points -(3)-> n_points. */ 1565 /* */ 1566 /* (1): exists from the beginning */ 1567 /* (2): components that have been loaded so far */ 1568 /* (3): the newly loaded component */ 1569 TT_Process_Composite_Component( loader, subglyph, start_point, 1570 num_base_points ); 1571 } 1572 1573 loader->stream = old_stream; 1574 loader->byte_len = old_byte_len; 1575 1576 /* process the glyph */ 1577 loader->ins_pos = ins_pos; 1578 if ( IS_HINTED( loader->load_flags ) && 1579 1580#ifdef TT_USE_BYTECODE_INTERPRETER 1581 1582 subglyph->flags & WE_HAVE_INSTR && 1583 1584#endif 1585 1586 num_points > start_point ) 1587 TT_Process_Composite_Glyph( loader, start_point, start_contour ); 1588 1589 } 1590 } 1591 else 1592 { 1593 /* invalid composite count (negative but not -1) */ 1594 error = TT_Err_Invalid_Outline; 1595 goto Exit; 1596 } 1597 1598 /***********************************************************************/ 1599 /***********************************************************************/ 1600 /***********************************************************************/ 1601 1602 Exit: 1603 1604 if ( opened_frame ) 1605 face->forget_glyph_frame( loader ); 1606 1607#ifdef FT_CONFIG_OPTION_INCREMENTAL 1608 1609 if ( glyph_data_loaded ) 1610 face->root.internal->incremental_interface->funcs->free_glyph_data( 1611 face->root.internal->incremental_interface->object, 1612 &glyph_data ); 1613 1614#endif 1615 1616 return error; 1617 } 1618 1619 1620 static FT_Error 1621 compute_glyph_metrics( TT_Loader loader, 1622 FT_UInt glyph_index ) 1623 { 1624 FT_BBox bbox; 1625 TT_Face face = (TT_Face)loader->face; 1626 FT_Fixed y_scale; 1627 TT_GlyphSlot glyph = loader->glyph; 1628 TT_Size size = (TT_Size)loader->size; 1629 1630 1631 y_scale = 0x10000L; 1632 if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 ) 1633 y_scale = size->root.metrics.y_scale; 1634 1635 if ( glyph->format != FT_GLYPH_FORMAT_COMPOSITE ) 1636 FT_Outline_Get_CBox( &glyph->outline, &bbox ); 1637 else 1638 bbox = loader->bbox; 1639 1640 /* get the device-independent horizontal advance; it is scaled later */ 1641 /* by the base layer. */ 1642 glyph->linearHoriAdvance = loader->linear; 1643 1644 glyph->metrics.horiBearingX = bbox.xMin; 1645 glyph->metrics.horiBearingY = bbox.yMax; 1646 glyph->metrics.horiAdvance = loader->pp2.x - loader->pp1.x; 1647 1648 /* adjust advance width to the value contained in the hdmx table */ 1649 if ( !face->postscript.isFixedPitch && 1650 IS_HINTED( loader->load_flags ) ) 1651 { 1652 FT_Byte* widthp; 1653 1654 1655 widthp = tt_face_get_device_metrics( face, 1656 size->root.metrics.x_ppem, 1657 glyph_index ); 1658 1659 if ( widthp ) 1660 glyph->metrics.horiAdvance = *widthp << 6; 1661 } 1662 1663 /* set glyph dimensions */ 1664 glyph->metrics.width = bbox.xMax - bbox.xMin; 1665 glyph->metrics.height = bbox.yMax - bbox.yMin; 1666 1667 /* Now take care of vertical metrics. In the case where there is */ 1668 /* no vertical information within the font (relatively common), */ 1669 /* create some metrics manually */ 1670 { 1671 FT_Pos top; /* scaled vertical top side bearing */ 1672 FT_Pos advance; /* scaled vertical advance height */ 1673 1674 1675 /* Get the unscaled top bearing and advance height. */ 1676 if ( face->vertical_info && 1677 face->vertical.number_Of_VMetrics > 0 ) 1678 { 1679 top = (FT_Short)FT_DivFix( loader->pp3.y - bbox.yMax, 1680 y_scale ); 1681 1682 if ( loader->pp3.y <= loader->pp4.y ) 1683 advance = 0; 1684 else 1685 advance = (FT_UShort)FT_DivFix( loader->pp3.y - loader->pp4.y, 1686 y_scale ); 1687 } 1688 else 1689 { 1690 FT_Pos height; 1691 1692 1693 /* XXX Compute top side bearing and advance height in */ 1694 /* Get_VMetrics instead of here. */ 1695 1696 /* NOTE: The OS/2 values are the only `portable' ones, */ 1697 /* which is why we use them, if there is an OS/2 */ 1698 /* table in the font. Otherwise, we use the */ 1699 /* values defined in the horizontal header. */ 1700 1701 height = (FT_Short)FT_DivFix( bbox.yMax - bbox.yMin, 1702 y_scale ); 1703 if ( face->os2.version != 0xFFFFU ) 1704 advance = (FT_Pos)( face->os2.sTypoAscender - 1705 face->os2.sTypoDescender ); 1706 else 1707 advance = (FT_Pos)( face->horizontal.Ascender - 1708 face->horizontal.Descender ); 1709 1710 top = ( advance - height ) / 2; 1711 } 1712 1713#ifdef FT_CONFIG_OPTION_INCREMENTAL 1714 { 1715 FT_Incremental_InterfaceRec* incr; 1716 FT_Incremental_MetricsRec metrics; 1717 FT_Error error; 1718 1719 1720 incr = face->root.internal->incremental_interface; 1721 1722 /* If this is an incrementally loaded font see if there are */ 1723 /* overriding metrics for this glyph. */ 1724 if ( incr && incr->funcs->get_glyph_metrics ) 1725 { 1726 metrics.bearing_x = 0; 1727 metrics.bearing_y = top; 1728 metrics.advance = advance; 1729 1730 error = incr->funcs->get_glyph_metrics( incr->object, 1731 glyph_index, 1732 TRUE, 1733 &metrics ); 1734 if ( error ) 1735 return error; 1736 1737 top = metrics.bearing_y; 1738 advance = metrics.advance; 1739 } 1740 } 1741 1742 /* GWW: Do vertical metrics get loaded incrementally too? */ 1743 1744#endif /* FT_CONFIG_OPTION_INCREMENTAL */ 1745 1746 glyph->linearVertAdvance = advance; 1747 1748 /* scale the metrics */ 1749 if ( !( loader->load_flags & FT_LOAD_NO_SCALE ) ) 1750 { 1751 top = FT_MulFix( top, y_scale ); 1752 advance = FT_MulFix( advance, y_scale ); 1753 } 1754 1755 /* XXX: for now, we have no better algorithm for the lsb, but it */ 1756 /* should work fine. */ 1757 /* */ 1758 glyph->metrics.vertBearingX = glyph->metrics.horiBearingX - 1759 glyph->metrics.horiAdvance / 2; 1760 glyph->metrics.vertBearingY = top; 1761 glyph->metrics.vertAdvance = advance; 1762 } 1763 1764 return 0; 1765 } 1766 1767 1768#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS 1769 1770 static FT_Error 1771 load_sbit_image( TT_Size size, 1772 TT_GlyphSlot glyph, 1773 FT_UInt glyph_index, 1774 FT_Int32 load_flags ) 1775 { 1776 TT_Face face; 1777 SFNT_Service sfnt; 1778 FT_Stream stream; 1779 FT_Error error; 1780 TT_SBit_MetricsRec metrics; 1781 1782 1783 face = (TT_Face)glyph->face; 1784 sfnt = (SFNT_Service)face->sfnt; 1785 stream = face->root.stream; 1786 1787 error = sfnt->load_sbit_image( face, 1788 size->strike_index, 1789 glyph_index, 1790 (FT_Int)load_flags, 1791 stream, 1792 &glyph->bitmap, 1793 &metrics ); 1794 if ( !error ) 1795 { 1796 glyph->outline.n_points = 0; 1797 glyph->outline.n_contours = 0; 1798 1799 glyph->metrics.width = (FT_Pos)metrics.width << 6; 1800 glyph->metrics.height = (FT_Pos)metrics.height << 6; 1801 1802 glyph->metrics.horiBearingX = (FT_Pos)metrics.horiBearingX << 6; 1803 glyph->metrics.horiBearingY = (FT_Pos)metrics.horiBearingY << 6; 1804 glyph->metrics.horiAdvance = (FT_Pos)metrics.horiAdvance << 6; 1805 1806 glyph->metrics.vertBearingX = (FT_Pos)metrics.vertBearingX << 6; 1807 glyph->metrics.vertBearingY = (FT_Pos)metrics.vertBearingY << 6; 1808 glyph->metrics.vertAdvance = (FT_Pos)metrics.vertAdvance << 6; 1809 1810 glyph->format = FT_GLYPH_FORMAT_BITMAP; 1811 1812 if ( load_flags & FT_LOAD_VERTICAL_LAYOUT ) 1813 { 1814 glyph->bitmap_left = metrics.vertBearingX; 1815 glyph->bitmap_top = metrics.vertBearingY; 1816 } 1817 else 1818 { 1819 glyph->bitmap_left = metrics.horiBearingX; 1820 glyph->bitmap_top = metrics.horiBearingY; 1821 } 1822 } 1823 1824 return error; 1825 } 1826 1827#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */ 1828 1829 1830 static FT_Error 1831 tt_loader_init( TT_Loader loader, 1832 TT_Size size, 1833 TT_GlyphSlot glyph, 1834 FT_Int32 load_flags, 1835 FT_Bool glyf_table_only ) 1836 { 1837 TT_Face face; 1838 FT_Stream stream; 1839 FT_Bool pedantic = FT_BOOL( load_flags & FT_LOAD_PEDANTIC ); 1840 1841 1842 face = (TT_Face)glyph->face; 1843 stream = face->root.stream; 1844 1845 FT_MEM_ZERO( loader, sizeof ( TT_LoaderRec ) ); 1846 1847#ifdef TT_USE_BYTECODE_INTERPRETER 1848 1849 /* load execution context */ 1850 if ( IS_HINTED( load_flags ) && !glyf_table_only ) 1851 { 1852 TT_ExecContext exec; 1853 FT_Bool grayscale; 1854 1855 1856 if ( !size->cvt_ready ) 1857 { 1858 FT_Error error = tt_size_ready_bytecode( size, pedantic ); 1859 1860 1861 if ( error ) 1862 return error; 1863 } 1864 1865 /* query new execution context */ 1866 exec = size->debug ? size->context 1867 : ( (TT_Driver)FT_FACE_DRIVER( face ) )->context; 1868 if ( !exec ) 1869 return TT_Err_Could_Not_Find_Context; 1870 1871 grayscale = 1872 FT_BOOL( FT_LOAD_TARGET_MODE( load_flags ) != FT_RENDER_MODE_MONO ); 1873 1874 TT_Load_Context( exec, face, size ); 1875 1876 /* a change from mono to grayscale rendering (and vice versa) */ 1877 /* requires a re-execution of the CVT program */ 1878 if ( grayscale != exec->grayscale ) 1879 { 1880 FT_UInt i; 1881 1882 1883 FT_TRACE4(( "tt_loader_init: grayscale change," 1884 " re-executing `prep' table\n" )); 1885 1886 exec->grayscale = grayscale; 1887 1888 for ( i = 0; i < size->cvt_size; i++ ) 1889 size->cvt[i] = FT_MulFix( face->cvt[i], size->ttmetrics.scale ); 1890 tt_size_run_prep( size, pedantic ); 1891 } 1892 1893 /* see whether the cvt program has disabled hinting */ 1894 if ( exec->GS.instruct_control & 1 ) 1895 load_flags |= FT_LOAD_NO_HINTING; 1896 1897 /* load default graphics state -- if needed */ 1898 if ( exec->GS.instruct_control & 2 ) 1899 exec->GS = tt_default_graphics_state; 1900 1901 exec->pedantic_hinting = FT_BOOL( load_flags & FT_LOAD_PEDANTIC ); 1902 loader->exec = exec; 1903 loader->instructions = exec->glyphIns; 1904 } 1905 1906#endif /* TT_USE_BYTECODE_INTERPRETER */ 1907 1908 /* seek to the beginning of the glyph table -- for Type 42 fonts */ 1909 /* the table might be accessed from a Postscript stream or something */ 1910 /* else... */ 1911 1912#ifdef FT_CONFIG_OPTION_INCREMENTAL 1913 1914 if ( face->root.internal->incremental_interface ) 1915 loader->glyf_offset = 0; 1916 else 1917 1918#endif 1919 1920 { 1921 FT_Error error = face->goto_table( face, TTAG_glyf, stream, 0 ); 1922 1923 1924 if ( error == TT_Err_Table_Missing ) 1925 loader->glyf_offset = 0; 1926 else if ( error ) 1927 { 1928 FT_ERROR(( "tt_loader_init: could not access glyph table\n" )); 1929 return error; 1930 } 1931 else 1932 loader->glyf_offset = FT_STREAM_POS(); 1933 } 1934 1935 /* get face's glyph loader */ 1936 if ( !glyf_table_only ) 1937 { 1938 FT_GlyphLoader gloader = glyph->internal->loader; 1939 1940 1941 FT_GlyphLoader_Rewind( gloader ); 1942 loader->gloader = gloader; 1943 } 1944 1945 loader->load_flags = load_flags; 1946 1947 loader->face = (FT_Face)face; 1948 loader->size = (FT_Size)size; 1949 loader->glyph = (FT_GlyphSlot)glyph; 1950 loader->stream = stream; 1951 1952 return TT_Err_Ok; 1953 } 1954 1955 1956 /*************************************************************************/ 1957 /* */ 1958 /* <Function> */ 1959 /* TT_Load_Glyph */ 1960 /* */ 1961 /* <Description> */ 1962 /* A function used to load a single glyph within a given glyph slot, */ 1963 /* for a given size. */ 1964 /* */ 1965 /* <Input> */ 1966 /* glyph :: A handle to a target slot object where the glyph */ 1967 /* will be loaded. */ 1968 /* */ 1969 /* size :: A handle to the source face size at which the glyph */ 1970 /* must be scaled/loaded. */ 1971 /* */ 1972 /* glyph_index :: The index of the glyph in the font file. */ 1973 /* */ 1974 /* load_flags :: A flag indicating what to load for this glyph. The */ 1975 /* FT_LOAD_XXX constants can be used to control the */ 1976 /* glyph loading process (e.g., whether the outline */ 1977 /* should be scaled, whether to load bitmaps or not, */ 1978 /* whether to hint the outline, etc). */ 1979 /* */ 1980 /* <Return> */ 1981 /* FreeType error code. 0 means success. */ 1982 /* */ 1983 FT_LOCAL_DEF( FT_Error ) 1984 TT_Load_Glyph( TT_Size size, 1985 TT_GlyphSlot glyph, 1986 FT_UInt glyph_index, 1987 FT_Int32 load_flags ) 1988 { 1989 TT_Face face; 1990 FT_Error error; 1991 TT_LoaderRec loader; 1992 1993 1994 face = (TT_Face)glyph->face; 1995 error = TT_Err_Ok; 1996 1997#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS 1998 1999 /* try to load embedded bitmap if any */ 2000 /* */ 2001 /* XXX: The convention should be emphasized in */ 2002 /* the documents because it can be confusing. */ 2003 if ( size->strike_index != 0xFFFFFFFFUL && 2004 ( load_flags & FT_LOAD_NO_BITMAP ) == 0 ) 2005 { 2006 error = load_sbit_image( size, glyph, glyph_index, load_flags ); 2007 if ( !error ) 2008 { 2009 FT_Face root = &face->root; 2010 2011 2012 if ( FT_IS_SCALABLE( root ) ) 2013 { 2014 /* for the bbox we need the header only */ 2015 (void)tt_loader_init( &loader, size, glyph, load_flags, TRUE ); 2016 (void)load_truetype_glyph( &loader, glyph_index, 0, TRUE ); 2017 glyph->linearHoriAdvance = loader.linear; 2018 glyph->linearVertAdvance = loader.top_bearing + loader.bbox.yMax - 2019 loader.vadvance; 2020 } 2021 2022 return TT_Err_Ok; 2023 } 2024 } 2025 2026#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */ 2027 2028 /* if FT_LOAD_NO_SCALE is not set, `ttmetrics' must be valid */ 2029 if ( !( load_flags & FT_LOAD_NO_SCALE ) && !size->ttmetrics.valid ) 2030 return TT_Err_Invalid_Size_Handle; 2031 2032 if ( load_flags & FT_LOAD_SBITS_ONLY ) 2033 return TT_Err_Invalid_Argument; 2034 2035 error = tt_loader_init( &loader, size, glyph, load_flags, FALSE ); 2036 if ( error ) 2037 return error; 2038 2039 glyph->format = FT_GLYPH_FORMAT_OUTLINE; 2040 glyph->num_subglyphs = 0; 2041 glyph->outline.flags = 0; 2042 2043 /* main loading loop */ 2044 error = load_truetype_glyph( &loader, glyph_index, 0, FALSE ); 2045 if ( !error ) 2046 { 2047 if ( glyph->format == FT_GLYPH_FORMAT_COMPOSITE ) 2048 { 2049 glyph->num_subglyphs = loader.gloader->base.num_subglyphs; 2050 glyph->subglyphs = loader.gloader->base.subglyphs; 2051 } 2052 else 2053 { 2054 glyph->outline = loader.gloader->base.outline; 2055 glyph->outline.flags &= ~FT_OUTLINE_SINGLE_PASS; 2056 2057 /* Translate array so that (0,0) is the glyph's origin. Note */ 2058 /* that this behaviour is independent on the value of bit 1 of */ 2059 /* the `flags' field in the `head' table -- at least major */ 2060 /* applications like Acroread indicate that. */ 2061 if ( loader.pp1.x ) 2062 FT_Outline_Translate( &glyph->outline, -loader.pp1.x, 0 ); 2063 } 2064 2065#ifdef TT_USE_BYTECODE_INTERPRETER 2066 2067 if ( IS_HINTED( load_flags ) ) 2068 { 2069 if ( loader.exec->GS.scan_control ) 2070 { 2071 /* convert scan conversion mode to FT_OUTLINE_XXX flags */ 2072 switch ( loader.exec->GS.scan_type ) 2073 { 2074 case 0: /* simple drop-outs including stubs */ 2075 glyph->outline.flags |= FT_OUTLINE_INCLUDE_STUBS; 2076 break; 2077 case 1: /* simple drop-outs excluding stubs */ 2078 /* nothing; it's the default rendering mode */ 2079 break; 2080 case 4: /* smart drop-outs including stubs */ 2081 glyph->outline.flags |= FT_OUTLINE_SMART_DROPOUTS | 2082 FT_OUTLINE_INCLUDE_STUBS; 2083 break; 2084 case 5: /* smart drop-outs excluding stubs */ 2085 glyph->outline.flags |= FT_OUTLINE_SMART_DROPOUTS; 2086 break; 2087 2088 default: /* no drop-out control */ 2089 glyph->outline.flags |= FT_OUTLINE_IGNORE_DROPOUTS; 2090 break; 2091 } 2092 } 2093 else 2094 glyph->outline.flags |= FT_OUTLINE_IGNORE_DROPOUTS; 2095 } 2096 2097#endif /* TT_USE_BYTECODE_INTERPRETER */ 2098 2099 compute_glyph_metrics( &loader, glyph_index ); 2100 } 2101 2102 /* Set the `high precision' bit flag. */ 2103 /* This is _critical_ to get correct output for monochrome */ 2104 /* TrueType glyphs at all sizes using the bytecode interpreter. */ 2105 /* */ 2106 if ( !( load_flags & FT_LOAD_NO_SCALE ) && 2107 size->root.metrics.y_ppem < 24 ) 2108 glyph->outline.flags |= FT_OUTLINE_HIGH_PRECISION; 2109 2110 return error; 2111 } 2112 2113 2114/* END */ 2115