1/***************************************************************************/ 2/* */ 3/* pshints.c */ 4/* */ 5/* Adobe's code for handling CFF hints (body). */ 6/* */ 7/* Copyright 2007-2014 Adobe Systems Incorporated. */ 8/* */ 9/* This software, and all works of authorship, whether in source or */ 10/* object code form as indicated by the copyright notice(s) included */ 11/* herein (collectively, the "Work") is made available, and may only be */ 12/* used, modified, and distributed under the FreeType Project License, */ 13/* LICENSE.TXT. Additionally, subject to the terms and conditions of the */ 14/* FreeType Project License, each contributor to the Work hereby grants */ 15/* to any individual or legal entity exercising permissions granted by */ 16/* the FreeType Project License and this section (hereafter, "You" or */ 17/* "Your") a perpetual, worldwide, non-exclusive, no-charge, */ 18/* royalty-free, irrevocable (except as stated in this section) patent */ 19/* license to make, have made, use, offer to sell, sell, import, and */ 20/* otherwise transfer the Work, where such license applies only to those */ 21/* patent claims licensable by such contributor that are necessarily */ 22/* infringed by their contribution(s) alone or by combination of their */ 23/* contribution(s) with the Work to which such contribution(s) was */ 24/* submitted. If You institute patent litigation against any entity */ 25/* (including a cross-claim or counterclaim in a lawsuit) alleging that */ 26/* the Work or a contribution incorporated within the Work constitutes */ 27/* direct or contributory patent infringement, then any patent licenses */ 28/* granted to You under this License for that Work shall terminate as of */ 29/* the date such litigation is filed. */ 30/* */ 31/* By using, modifying, or distributing the Work you indicate that you */ 32/* have read and understood the terms and conditions of the */ 33/* FreeType Project License as well as those provided in this section, */ 34/* and you accept them fully. */ 35/* */ 36/***************************************************************************/ 37 38 39#include "psft.h" 40#include FT_INTERNAL_DEBUG_H 41 42#include "psglue.h" 43#include "psfont.h" 44#include "pshints.h" 45#include "psintrp.h" 46 47 48 /*************************************************************************/ 49 /* */ 50 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ 51 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ 52 /* messages during execution. */ 53 /* */ 54#undef FT_COMPONENT 55#define FT_COMPONENT trace_cf2hints 56 57 58 typedef struct CF2_HintMoveRec_ 59 { 60 size_t j; /* index of upper hint map edge */ 61 CF2_Fixed moveUp; /* adjustment to optimum position */ 62 63 } CF2_HintMoveRec, *CF2_HintMove; 64 65 66 /* Compute angular momentum for winding order detection. It is called */ 67 /* for all lines and curves, but not necessarily in element order. */ 68 static CF2_Int 69 cf2_getWindingMomentum( CF2_Fixed x1, 70 CF2_Fixed y1, 71 CF2_Fixed x2, 72 CF2_Fixed y2 ) 73 { 74 /* cross product of pt1 position from origin with pt2 position from */ 75 /* pt1; we reduce the precision so that the result fits into 32 bits */ 76 77 return ( x1 >> 16 ) * ( SUB_INT32( y2, y1 ) >> 16 ) - 78 ( y1 >> 16 ) * ( SUB_INT32( x2, x1 ) >> 16 ); 79 } 80 81 82 /* 83 * Construct from a StemHint; this is used as a parameter to 84 * `cf2_blues_capture'. 85 * `hintOrigin' is the character space displacement of a seac accent. 86 * Adjust stem hint for darkening here. 87 * 88 */ 89 static void 90 cf2_hint_init( CF2_Hint hint, 91 const CF2_ArrStack stemHintArray, 92 size_t indexStemHint, 93 const CF2_Font font, 94 CF2_Fixed hintOrigin, 95 CF2_Fixed scale, 96 FT_Bool bottom ) 97 { 98 CF2_Fixed width; 99 const CF2_StemHintRec* stemHint; 100 101 102 FT_ZERO( hint ); 103 104 stemHint = (const CF2_StemHintRec*)cf2_arrstack_getPointer( 105 stemHintArray, 106 indexStemHint ); 107 108 width = SUB_INT32( stemHint->max, stemHint->min ); 109 110 if ( width == cf2_intToFixed( -21 ) ) 111 { 112 /* ghost bottom */ 113 114 if ( bottom ) 115 { 116 hint->csCoord = stemHint->max; 117 hint->flags = CF2_GhostBottom; 118 } 119 else 120 hint->flags = 0; 121 } 122 123 else if ( width == cf2_intToFixed( -20 ) ) 124 { 125 /* ghost top */ 126 127 if ( bottom ) 128 hint->flags = 0; 129 else 130 { 131 hint->csCoord = stemHint->min; 132 hint->flags = CF2_GhostTop; 133 } 134 } 135 136 else if ( width < 0 ) 137 { 138 /* inverted pair */ 139 140 /* 141 * Hints with negative widths were produced by an early version of a 142 * non-Adobe font tool. The Type 2 spec allows edge (ghost) hints 143 * with negative widths, but says 144 * 145 * All other negative widths have undefined meaning. 146 * 147 * CoolType has a silent workaround that negates the hint width; for 148 * permissive mode, we do the same here. 149 * 150 * Note: Such fonts cannot use ghost hints, but should otherwise work. 151 * Note: Some poor hints in our faux fonts can produce negative 152 * widths at some blends. For example, see a light weight of 153 * `u' in ASerifMM. 154 * 155 */ 156 if ( bottom ) 157 { 158 hint->csCoord = stemHint->max; 159 hint->flags = CF2_PairBottom; 160 } 161 else 162 { 163 hint->csCoord = stemHint->min; 164 hint->flags = CF2_PairTop; 165 } 166 } 167 168 else 169 { 170 /* normal pair */ 171 172 if ( bottom ) 173 { 174 hint->csCoord = stemHint->min; 175 hint->flags = CF2_PairBottom; 176 } 177 else 178 { 179 hint->csCoord = stemHint->max; 180 hint->flags = CF2_PairTop; 181 } 182 } 183 184 /* Now that ghost hints have been detected, adjust this edge for */ 185 /* darkening. Bottoms are not changed; tops are incremented by twice */ 186 /* `darkenY'. */ 187 if ( cf2_hint_isTop( hint ) ) 188 hint->csCoord = ADD_INT32( hint->csCoord, 2 * font->darkenY ); 189 190 hint->csCoord = ADD_INT32( hint->csCoord, hintOrigin ); 191 hint->scale = scale; 192 hint->index = indexStemHint; /* index in original stem hint array */ 193 194 /* if original stem hint has been used, use the same position */ 195 if ( hint->flags != 0 && stemHint->used ) 196 { 197 if ( cf2_hint_isTop( hint ) ) 198 hint->dsCoord = stemHint->maxDS; 199 else 200 hint->dsCoord = stemHint->minDS; 201 202 cf2_hint_lock( hint ); 203 } 204 else 205 hint->dsCoord = FT_MulFix( hint->csCoord, scale ); 206 } 207 208 209 /* initialize an invalid hint map element */ 210 static void 211 cf2_hint_initZero( CF2_Hint hint ) 212 { 213 FT_ZERO( hint ); 214 } 215 216 217 FT_LOCAL_DEF( FT_Bool ) 218 cf2_hint_isValid( const CF2_Hint hint ) 219 { 220 return (FT_Bool)( hint->flags != 0 ); 221 } 222 223 224 static FT_Bool 225 cf2_hint_isPair( const CF2_Hint hint ) 226 { 227 return (FT_Bool)( ( hint->flags & 228 ( CF2_PairBottom | CF2_PairTop ) ) != 0 ); 229 } 230 231 232 static FT_Bool 233 cf2_hint_isPairTop( const CF2_Hint hint ) 234 { 235 return (FT_Bool)( ( hint->flags & CF2_PairTop ) != 0 ); 236 } 237 238 239 FT_LOCAL_DEF( FT_Bool ) 240 cf2_hint_isTop( const CF2_Hint hint ) 241 { 242 return (FT_Bool)( ( hint->flags & 243 ( CF2_PairTop | CF2_GhostTop ) ) != 0 ); 244 } 245 246 247 FT_LOCAL_DEF( FT_Bool ) 248 cf2_hint_isBottom( const CF2_Hint hint ) 249 { 250 return (FT_Bool)( ( hint->flags & 251 ( CF2_PairBottom | CF2_GhostBottom ) ) != 0 ); 252 } 253 254 255 static FT_Bool 256 cf2_hint_isLocked( const CF2_Hint hint ) 257 { 258 return (FT_Bool)( ( hint->flags & CF2_Locked ) != 0 ); 259 } 260 261 262 static FT_Bool 263 cf2_hint_isSynthetic( const CF2_Hint hint ) 264 { 265 return (FT_Bool)( ( hint->flags & CF2_Synthetic ) != 0 ); 266 } 267 268 269 FT_LOCAL_DEF( void ) 270 cf2_hint_lock( CF2_Hint hint ) 271 { 272 hint->flags |= CF2_Locked; 273 } 274 275 276 FT_LOCAL_DEF( void ) 277 cf2_hintmap_init( CF2_HintMap hintmap, 278 CF2_Font font, 279 CF2_HintMap initialMap, 280 CF2_ArrStack hintMoves, 281 CF2_Fixed scale ) 282 { 283 FT_ZERO( hintmap ); 284 285 /* copy parameters from font instance */ 286 hintmap->hinted = font->hinted; 287 hintmap->scale = scale; 288 hintmap->font = font; 289 hintmap->initialHintMap = initialMap; 290 /* will clear in `cf2_hintmap_adjustHints' */ 291 hintmap->hintMoves = hintMoves; 292 } 293 294 295 static FT_Bool 296 cf2_hintmap_isValid( const CF2_HintMap hintmap ) 297 { 298 return hintmap->isValid; 299 } 300 301 302 static void 303 cf2_hintmap_dump( CF2_HintMap hintmap ) 304 { 305#ifdef FT_DEBUG_LEVEL_TRACE 306 CF2_UInt i; 307 308 309 FT_TRACE6(( " index csCoord dsCoord scale flags\n" )); 310 311 for ( i = 0; i < hintmap->count; i++ ) 312 { 313 CF2_Hint hint = &hintmap->edge[i]; 314 315 316 FT_TRACE6(( " %3d %7.2f %7.2f %5d %s%s%s%s\n", 317 hint->index, 318 hint->csCoord / 65536.0, 319 hint->dsCoord / ( hint->scale * 1.0 ), 320 hint->scale, 321 ( cf2_hint_isPair( hint ) ? "p" : "g" ), 322 ( cf2_hint_isTop( hint ) ? "t" : "b" ), 323 ( cf2_hint_isLocked( hint ) ? "L" : ""), 324 ( cf2_hint_isSynthetic( hint ) ? "S" : "" ) )); 325 } 326#else 327 FT_UNUSED( hintmap ); 328#endif 329 } 330 331 332 /* transform character space coordinate to device space using hint map */ 333 static CF2_Fixed 334 cf2_hintmap_map( CF2_HintMap hintmap, 335 CF2_Fixed csCoord ) 336 { 337 if ( hintmap->count == 0 || ! hintmap->hinted ) 338 { 339 /* there are no hints; use uniform scale and zero offset */ 340 return FT_MulFix( csCoord, hintmap->scale ); 341 } 342 else 343 { 344 /* start linear search from last hit */ 345 CF2_UInt i = hintmap->lastIndex; 346 347 348 FT_ASSERT( hintmap->lastIndex < CF2_MAX_HINT_EDGES ); 349 350 /* search up */ 351 while ( i < hintmap->count - 1 && 352 csCoord >= hintmap->edge[i + 1].csCoord ) 353 i += 1; 354 355 /* search down */ 356 while ( i > 0 && csCoord < hintmap->edge[i].csCoord ) 357 i -= 1; 358 359 hintmap->lastIndex = i; 360 361 if ( i == 0 && csCoord < hintmap->edge[0].csCoord ) 362 { 363 /* special case for points below first edge: use uniform scale */ 364 return ADD_INT32( FT_MulFix( SUB_INT32( csCoord, 365 hintmap->edge[0].csCoord ), 366 hintmap->scale ), 367 hintmap->edge[0].dsCoord ); 368 } 369 else 370 { 371 /* 372 * Note: entries with duplicate csCoord are allowed. 373 * Use edge[i], the highest entry where csCoord >= entry[i].csCoord 374 */ 375 return ADD_INT32( FT_MulFix( SUB_INT32( csCoord, 376 hintmap->edge[i].csCoord ), 377 hintmap->edge[i].scale ), 378 hintmap->edge[i].dsCoord ); 379 } 380 } 381 } 382 383 384 /* 385 * This hinting policy moves a hint pair in device space so that one of 386 * its two edges is on a device pixel boundary (its fractional part is 387 * zero). `cf2_hintmap_insertHint' guarantees no overlap in CS 388 * space. Ensure here that there is no overlap in DS. 389 * 390 * In the first pass, edges are adjusted relative to adjacent hints. 391 * Those that are below have already been adjusted. Those that are 392 * above have not yet been adjusted. If a hint above blocks an 393 * adjustment to an optimal position, we will try again in a second 394 * pass. The second pass is top-down. 395 * 396 */ 397 398 static void 399 cf2_hintmap_adjustHints( CF2_HintMap hintmap ) 400 { 401 size_t i, j; 402 403 404 cf2_arrstack_clear( hintmap->hintMoves ); /* working storage */ 405 406 /* 407 * First pass is bottom-up (font hint order) without look-ahead. 408 * Locked edges are already adjusted. 409 * Unlocked edges begin with dsCoord from `initialHintMap'. 410 * Save edges that are not optimally adjusted in `hintMoves' array, 411 * and process them in second pass. 412 */ 413 414 for ( i = 0; i < hintmap->count; i++ ) 415 { 416 FT_Bool isPair = cf2_hint_isPair( &hintmap->edge[i] ); 417 418 419 /* index of upper edge (same value for ghost hint) */ 420 j = isPair ? i + 1 : i; 421 422 FT_ASSERT( j < hintmap->count ); 423 FT_ASSERT( cf2_hint_isValid( &hintmap->edge[i] ) ); 424 FT_ASSERT( cf2_hint_isValid( &hintmap->edge[j] ) ); 425 FT_ASSERT( cf2_hint_isLocked( &hintmap->edge[i] ) == 426 cf2_hint_isLocked( &hintmap->edge[j] ) ); 427 428 if ( !cf2_hint_isLocked( &hintmap->edge[i] ) ) 429 { 430 /* hint edge is not locked, we can adjust it */ 431 CF2_Fixed fracDown = cf2_fixedFraction( hintmap->edge[i].dsCoord ); 432 CF2_Fixed fracUp = cf2_fixedFraction( hintmap->edge[j].dsCoord ); 433 434 /* calculate all four possibilities; moves down are negative */ 435 CF2_Fixed downMoveDown = 0 - fracDown; 436 CF2_Fixed upMoveDown = 0 - fracUp; 437 CF2_Fixed downMoveUp = ( fracDown == 0 ) 438 ? 0 439 : cf2_intToFixed( 1 ) - fracDown; 440 CF2_Fixed upMoveUp = ( fracUp == 0 ) 441 ? 0 442 : cf2_intToFixed( 1 ) - fracUp; 443 444 /* smallest move up */ 445 CF2_Fixed moveUp = FT_MIN( downMoveUp, upMoveUp ); 446 /* smallest move down */ 447 CF2_Fixed moveDown = FT_MAX( downMoveDown, upMoveDown ); 448 449 /* final amount to move edge or edge pair */ 450 CF2_Fixed move; 451 452 CF2_Fixed downMinCounter = CF2_MIN_COUNTER; 453 CF2_Fixed upMinCounter = CF2_MIN_COUNTER; 454 FT_Bool saveEdge = FALSE; 455 456 457 /* minimum counter constraint doesn't apply when adjacent edges */ 458 /* are synthetic */ 459 /* TODO: doesn't seem a big effect; for now, reduce the code */ 460#if 0 461 if ( i == 0 || 462 cf2_hint_isSynthetic( &hintmap->edge[i - 1] ) ) 463 downMinCounter = 0; 464 465 if ( j >= hintmap->count - 1 || 466 cf2_hint_isSynthetic( &hintmap->edge[j + 1] ) ) 467 upMinCounter = 0; 468#endif 469 470 /* is there room to move up? */ 471 /* there is if we are at top of array or the next edge is at or */ 472 /* beyond proposed move up? */ 473 if ( j >= hintmap->count - 1 || 474 hintmap->edge[j + 1].dsCoord >= 475 ADD_INT32( hintmap->edge[j].dsCoord, 476 moveUp + upMinCounter ) ) 477 { 478 /* there is room to move up; is there also room to move down? */ 479 if ( i == 0 || 480 hintmap->edge[i - 1].dsCoord <= 481 ADD_INT32( hintmap->edge[i].dsCoord, 482 moveDown - downMinCounter ) ) 483 { 484 /* move smaller absolute amount */ 485 move = ( -moveDown < moveUp ) ? moveDown : moveUp; /* optimum */ 486 } 487 else 488 move = moveUp; 489 } 490 else 491 { 492 /* is there room to move down? */ 493 if ( i == 0 || 494 hintmap->edge[i - 1].dsCoord <= 495 ADD_INT32( hintmap->edge[i].dsCoord, 496 moveDown - downMinCounter ) ) 497 { 498 move = moveDown; 499 /* true if non-optimum move */ 500 saveEdge = (FT_Bool)( moveUp < -moveDown ); 501 } 502 else 503 { 504 /* no room to move either way without overlapping or reducing */ 505 /* the counter too much */ 506 move = 0; 507 saveEdge = TRUE; 508 } 509 } 510 511 /* Identify non-moves and moves down that aren't optimal, and save */ 512 /* them for second pass. */ 513 /* Do this only if there is an unlocked edge above (which could */ 514 /* possibly move). */ 515 if ( saveEdge && 516 j < hintmap->count - 1 && 517 !cf2_hint_isLocked( &hintmap->edge[j + 1] ) ) 518 { 519 CF2_HintMoveRec savedMove; 520 521 522 savedMove.j = j; 523 /* desired adjustment in second pass */ 524 savedMove.moveUp = moveUp - move; 525 526 cf2_arrstack_push( hintmap->hintMoves, &savedMove ); 527 } 528 529 /* move the edge(s) */ 530 hintmap->edge[i].dsCoord = ADD_INT32( hintmap->edge[i].dsCoord, 531 move ); 532 if ( isPair ) 533 hintmap->edge[j].dsCoord = ADD_INT32( hintmap->edge[j].dsCoord, 534 move ); 535 } 536 537 /* assert there are no overlaps in device space */ 538 FT_ASSERT( i == 0 || 539 hintmap->edge[i - 1].dsCoord <= hintmap->edge[i].dsCoord ); 540 FT_ASSERT( i < j || 541 hintmap->edge[i].dsCoord <= hintmap->edge[j].dsCoord ); 542 543 /* adjust the scales, avoiding divide by zero */ 544 if ( i > 0 ) 545 { 546 if ( hintmap->edge[i].csCoord != hintmap->edge[i - 1].csCoord ) 547 hintmap->edge[i - 1].scale = 548 FT_DivFix( SUB_INT32( hintmap->edge[i].dsCoord, 549 hintmap->edge[i - 1].dsCoord ), 550 SUB_INT32( hintmap->edge[i].csCoord, 551 hintmap->edge[i - 1].csCoord ) ); 552 } 553 554 if ( isPair ) 555 { 556 if ( hintmap->edge[j].csCoord != hintmap->edge[j - 1].csCoord ) 557 hintmap->edge[j - 1].scale = 558 FT_DivFix( SUB_INT32( hintmap->edge[j].dsCoord, 559 hintmap->edge[j - 1].dsCoord ), 560 SUB_INT32( hintmap->edge[j].csCoord, 561 hintmap->edge[j - 1].csCoord ) ); 562 563 i += 1; /* skip upper edge on next loop */ 564 } 565 } 566 567 /* second pass tries to move non-optimal hints up, in case there is */ 568 /* room now */ 569 for ( i = cf2_arrstack_size( hintmap->hintMoves ); i > 0; i-- ) 570 { 571 CF2_HintMove hintMove = (CF2_HintMove) 572 cf2_arrstack_getPointer( hintmap->hintMoves, i - 1 ); 573 574 575 j = hintMove->j; 576 577 /* this was tested before the push, above */ 578 FT_ASSERT( j < hintmap->count - 1 ); 579 580 /* is there room to move up? */ 581 if ( hintmap->edge[j + 1].dsCoord >= 582 ADD_INT32( hintmap->edge[j].dsCoord, 583 hintMove->moveUp + CF2_MIN_COUNTER ) ) 584 { 585 /* there is more room now, move edge up */ 586 hintmap->edge[j].dsCoord = ADD_INT32( hintmap->edge[j].dsCoord, 587 hintMove->moveUp ); 588 589 if ( cf2_hint_isPair( &hintmap->edge[j] ) ) 590 { 591 FT_ASSERT( j > 0 ); 592 hintmap->edge[j - 1].dsCoord = 593 ADD_INT32( hintmap->edge[j - 1].dsCoord, hintMove->moveUp ); 594 } 595 } 596 } 597 } 598 599 600 /* insert hint edges into map, sorted by csCoord */ 601 static void 602 cf2_hintmap_insertHint( CF2_HintMap hintmap, 603 CF2_Hint bottomHintEdge, 604 CF2_Hint topHintEdge ) 605 { 606 CF2_UInt indexInsert; 607 608 /* set default values, then check for edge hints */ 609 FT_Bool isPair = TRUE; 610 CF2_Hint firstHintEdge = bottomHintEdge; 611 CF2_Hint secondHintEdge = topHintEdge; 612 613 614 /* one or none of the input params may be invalid when dealing with */ 615 /* edge hints; at least one edge must be valid */ 616 FT_ASSERT( cf2_hint_isValid( bottomHintEdge ) || 617 cf2_hint_isValid( topHintEdge ) ); 618 619 /* determine how many and which edges to insert */ 620 if ( !cf2_hint_isValid( bottomHintEdge ) ) 621 { 622 /* insert only the top edge */ 623 firstHintEdge = topHintEdge; 624 isPair = FALSE; 625 } 626 else if ( !cf2_hint_isValid( topHintEdge ) ) 627 { 628 /* insert only the bottom edge */ 629 isPair = FALSE; 630 } 631 632 /* paired edges must be in proper order */ 633 if ( isPair && 634 topHintEdge->csCoord < bottomHintEdge->csCoord ) 635 return; 636 637 /* linear search to find index value of insertion point */ 638 indexInsert = 0; 639 for ( ; indexInsert < hintmap->count; indexInsert++ ) 640 { 641 if ( hintmap->edge[indexInsert].csCoord >= firstHintEdge->csCoord ) 642 break; 643 } 644 645 FT_TRACE7(( " Got hint at %.2f (%.2f)\n", 646 firstHintEdge->csCoord / 65536.0, 647 firstHintEdge->dsCoord / 65536.0 )); 648 if ( isPair ) 649 FT_TRACE7(( " Got hint at %.2f (%.2f)\n", 650 secondHintEdge->csCoord / 65536.0, 651 secondHintEdge->dsCoord / 65536.0 )); 652 653 /* 654 * Discard any hints that overlap in character space. Most often, this 655 * is while building the initial map, where captured hints from all 656 * zones are combined. Define overlap to include hints that `touch' 657 * (overlap zero). Hiragino Sans/Gothic fonts have numerous hints that 658 * touch. Some fonts have non-ideographic glyphs that overlap our 659 * synthetic hints. 660 * 661 * Overlap also occurs when darkening stem hints that are close. 662 * 663 */ 664 if ( indexInsert < hintmap->count ) 665 { 666 /* we are inserting before an existing edge: */ 667 /* verify that an existing edge is not the same */ 668 if ( hintmap->edge[indexInsert].csCoord == firstHintEdge->csCoord ) 669 return; /* ignore overlapping stem hint */ 670 671 /* verify that a new pair does not straddle the next edge */ 672 if ( isPair && 673 hintmap->edge[indexInsert].csCoord <= secondHintEdge->csCoord ) 674 return; /* ignore overlapping stem hint */ 675 676 /* verify that we are not inserting between paired edges */ 677 if ( cf2_hint_isPairTop( &hintmap->edge[indexInsert] ) ) 678 return; /* ignore overlapping stem hint */ 679 } 680 681 /* recompute device space locations using initial hint map */ 682 if ( cf2_hintmap_isValid( hintmap->initialHintMap ) && 683 !cf2_hint_isLocked( firstHintEdge ) ) 684 { 685 if ( isPair ) 686 { 687 /* Use hint map to position the center of stem, and nominal scale */ 688 /* to position the two edges. This preserves the stem width. */ 689 CF2_Fixed midpoint = 690 cf2_hintmap_map( 691 hintmap->initialHintMap, 692 ADD_INT32( secondHintEdge->csCoord, 693 firstHintEdge->csCoord ) / 2 ); 694 CF2_Fixed halfWidth = 695 FT_MulFix( SUB_INT32( secondHintEdge->csCoord, 696 firstHintEdge->csCoord ) / 2, 697 hintmap->scale ); 698 699 700 firstHintEdge->dsCoord = SUB_INT32( midpoint, halfWidth ); 701 secondHintEdge->dsCoord = ADD_INT32( midpoint, halfWidth ); 702 } 703 else 704 firstHintEdge->dsCoord = cf2_hintmap_map( hintmap->initialHintMap, 705 firstHintEdge->csCoord ); 706 } 707 708 /* 709 * Discard any hints that overlap in device space; this can occur 710 * because locked hints have been moved to align with blue zones. 711 * 712 * TODO: Although we might correct this later during adjustment, we 713 * don't currently have a way to delete a conflicting hint once it has 714 * been inserted. See v2.030 MinionPro-Regular, 12 ppem darkened, 715 * initial hint map for second path, glyph 945 (the perispomeni (tilde) 716 * in U+1F6E, Greek omega with psili and perispomeni). Darkening is 717 * 25. Pair 667,747 initially conflicts in design space with top edge 718 * 660. This is because 667 maps to 7.87, and the top edge was 719 * captured by a zone at 8.0. The pair is later successfully inserted 720 * in a zone without the top edge. In this zone it is adjusted to 8.0, 721 * and no longer conflicts with the top edge in design space. This 722 * means it can be included in yet a later zone which does have the top 723 * edge hint. This produces a small mismatch between the first and 724 * last points of this path, even though the hint masks are the same. 725 * The density map difference is tiny (1/256). 726 * 727 */ 728 729 if ( indexInsert > 0 ) 730 { 731 /* we are inserting after an existing edge */ 732 if ( firstHintEdge->dsCoord < hintmap->edge[indexInsert - 1].dsCoord ) 733 return; 734 } 735 736 if ( indexInsert < hintmap->count ) 737 { 738 /* we are inserting before an existing edge */ 739 if ( isPair ) 740 { 741 if ( secondHintEdge->dsCoord > hintmap->edge[indexInsert].dsCoord ) 742 return; 743 } 744 else 745 { 746 if ( firstHintEdge->dsCoord > hintmap->edge[indexInsert].dsCoord ) 747 return; 748 } 749 } 750 751 /* make room to insert */ 752 { 753 CF2_UInt iSrc = hintmap->count - 1; 754 CF2_UInt iDst = isPair ? hintmap->count + 1 : hintmap->count; 755 756 CF2_UInt count = hintmap->count - indexInsert; 757 758 759 if ( iDst >= CF2_MAX_HINT_EDGES ) 760 { 761 FT_TRACE4(( "cf2_hintmap_insertHint: too many hintmaps\n" )); 762 return; 763 } 764 765 while ( count-- ) 766 hintmap->edge[iDst--] = hintmap->edge[iSrc--]; 767 768 /* insert first edge */ 769 hintmap->edge[indexInsert] = *firstHintEdge; /* copy struct */ 770 hintmap->count += 1; 771 772 FT_TRACE7(( " Inserting hint %.2f (%.2f)\n", 773 firstHintEdge->csCoord / 65536.0, 774 firstHintEdge->dsCoord / 65536.0 )); 775 776 if ( isPair ) 777 { 778 /* insert second edge */ 779 hintmap->edge[indexInsert + 1] = *secondHintEdge; /* copy struct */ 780 hintmap->count += 1; 781 782 FT_TRACE7(( " Inserting hint %.2f (%.2f)\n", 783 secondHintEdge->csCoord / 65536.0, 784 secondHintEdge->dsCoord / 65536.0 )); 785 786 } 787 } 788 789 return; 790 } 791 792 793 /* 794 * Build a map from hints and mask. 795 * 796 * This function may recur one level if `hintmap->initialHintMap' is not yet 797 * valid. 798 * If `initialMap' is true, simply build initial map. 799 * 800 * Synthetic hints are used in two ways. A hint at zero is inserted, if 801 * needed, in the initial hint map, to prevent translations from 802 * propagating across the origin. If synthetic em box hints are enabled 803 * for ideographic dictionaries, then they are inserted in all hint 804 * maps, including the initial one. 805 * 806 */ 807 FT_LOCAL_DEF( void ) 808 cf2_hintmap_build( CF2_HintMap hintmap, 809 CF2_ArrStack hStemHintArray, 810 CF2_ArrStack vStemHintArray, 811 CF2_HintMask hintMask, 812 CF2_Fixed hintOrigin, 813 FT_Bool initialMap ) 814 { 815 FT_Byte* maskPtr; 816 817 CF2_Font font = hintmap->font; 818 CF2_HintMaskRec tempHintMask; 819 820 size_t bitCount, i; 821 FT_Byte maskByte; 822 823 824 /* check whether initial map is constructed */ 825 if ( !initialMap && !cf2_hintmap_isValid( hintmap->initialHintMap ) ) 826 { 827 /* make recursive call with initialHintMap and temporary mask; */ 828 /* temporary mask will get all bits set, below */ 829 cf2_hintmask_init( &tempHintMask, hintMask->error ); 830 cf2_hintmap_build( hintmap->initialHintMap, 831 hStemHintArray, 832 vStemHintArray, 833 &tempHintMask, 834 hintOrigin, 835 TRUE ); 836 } 837 838 if ( !cf2_hintmask_isValid( hintMask ) ) 839 { 840 /* without a hint mask, assume all hints are active */ 841 cf2_hintmask_setAll( hintMask, 842 cf2_arrstack_size( hStemHintArray ) + 843 cf2_arrstack_size( vStemHintArray ) ); 844 if ( !cf2_hintmask_isValid( hintMask ) ) 845 { 846 if ( font->isT1 ) 847 { 848 /* no error, just continue unhinted */ 849 *hintMask->error = FT_Err_Ok; 850 hintmap->hinted = FALSE; 851 } 852 return; /* too many stem hints */ 853 } 854 } 855 856 /* begin by clearing the map */ 857 hintmap->count = 0; 858 hintmap->lastIndex = 0; 859 860 /* make a copy of the hint mask so we can modify it */ 861 tempHintMask = *hintMask; 862 maskPtr = cf2_hintmask_getMaskPtr( &tempHintMask ); 863 864 /* use the hStem hints only, which are first in the mask */ 865 bitCount = cf2_arrstack_size( hStemHintArray ); 866 867 /* Defense-in-depth. Should never return here. */ 868 if ( bitCount > hintMask->bitCount ) 869 return; 870 871 /* synthetic embox hints get highest priority */ 872 if ( font->blues.doEmBoxHints ) 873 { 874 CF2_HintRec dummy; 875 876 877 cf2_hint_initZero( &dummy ); /* invalid hint map element */ 878 879 /* ghost bottom */ 880 cf2_hintmap_insertHint( hintmap, 881 &font->blues.emBoxBottomEdge, 882 &dummy ); 883 /* ghost top */ 884 cf2_hintmap_insertHint( hintmap, 885 &dummy, 886 &font->blues.emBoxTopEdge ); 887 } 888 889 /* insert hints captured by a blue zone or already locked (higher */ 890 /* priority) */ 891 for ( i = 0, maskByte = 0x80; i < bitCount; i++ ) 892 { 893 if ( maskByte & *maskPtr ) 894 { 895 /* expand StemHint into two `CF2_Hint' elements */ 896 CF2_HintRec bottomHintEdge, topHintEdge; 897 898 899 cf2_hint_init( &bottomHintEdge, 900 hStemHintArray, 901 i, 902 font, 903 hintOrigin, 904 hintmap->scale, 905 TRUE /* bottom */ ); 906 cf2_hint_init( &topHintEdge, 907 hStemHintArray, 908 i, 909 font, 910 hintOrigin, 911 hintmap->scale, 912 FALSE /* top */ ); 913 914 if ( cf2_hint_isLocked( &bottomHintEdge ) || 915 cf2_hint_isLocked( &topHintEdge ) || 916 cf2_blues_capture( &font->blues, 917 &bottomHintEdge, 918 &topHintEdge ) ) 919 { 920 /* insert captured hint into map */ 921 cf2_hintmap_insertHint( hintmap, &bottomHintEdge, &topHintEdge ); 922 923 *maskPtr &= ~maskByte; /* turn off the bit for this hint */ 924 } 925 } 926 927 if ( ( i & 7 ) == 7 ) 928 { 929 /* move to next mask byte */ 930 maskPtr++; 931 maskByte = 0x80; 932 } 933 else 934 maskByte >>= 1; 935 } 936 937 /* initial hint map includes only captured hints plus maybe one at 0 */ 938 939 /* 940 * TODO: There is a problem here because we are trying to build a 941 * single hint map containing all captured hints. It is 942 * possible for there to be conflicts between captured hints, 943 * either because of darkening or because the hints are in 944 * separate hint zones (we are ignoring hint zones for the 945 * initial map). An example of the latter is MinionPro-Regular 946 * v2.030 glyph 883 (Greek Capital Alpha with Psili) at 15ppem. 947 * A stem hint for the psili conflicts with the top edge hint 948 * for the base character. The stem hint gets priority because 949 * of its sort order. In glyph 884 (Greek Capital Alpha with 950 * Psili and Oxia), the top of the base character gets a stem 951 * hint, and the psili does not. This creates different initial 952 * maps for the two glyphs resulting in different renderings of 953 * the base character. Will probably defer this either as not 954 * worth the cost or as a font bug. I don't think there is any 955 * good reason for an accent to be captured by an alignment 956 * zone. -darnold 2/12/10 957 */ 958 959 if ( initialMap ) 960 { 961 /* Apply a heuristic that inserts a point for (0,0), unless it's */ 962 /* already covered by a mapping. This locks the baseline for glyphs */ 963 /* that have no baseline hints. */ 964 965 if ( hintmap->count == 0 || 966 hintmap->edge[0].csCoord > 0 || 967 hintmap->edge[hintmap->count - 1].csCoord < 0 ) 968 { 969 /* all edges are above 0 or all edges are below 0; */ 970 /* construct a locked edge hint at 0 */ 971 972 CF2_HintRec edge, invalid; 973 974 975 cf2_hint_initZero( &edge ); 976 977 edge.flags = CF2_GhostBottom | 978 CF2_Locked | 979 CF2_Synthetic; 980 edge.scale = hintmap->scale; 981 982 cf2_hint_initZero( &invalid ); 983 cf2_hintmap_insertHint( hintmap, &edge, &invalid ); 984 } 985 } 986 else 987 { 988 /* insert remaining hints */ 989 990 maskPtr = cf2_hintmask_getMaskPtr( &tempHintMask ); 991 992 for ( i = 0, maskByte = 0x80; i < bitCount; i++ ) 993 { 994 if ( maskByte & *maskPtr ) 995 { 996 CF2_HintRec bottomHintEdge, topHintEdge; 997 998 999 cf2_hint_init( &bottomHintEdge, 1000 hStemHintArray, 1001 i, 1002 font, 1003 hintOrigin, 1004 hintmap->scale, 1005 TRUE /* bottom */ ); 1006 cf2_hint_init( &topHintEdge, 1007 hStemHintArray, 1008 i, 1009 font, 1010 hintOrigin, 1011 hintmap->scale, 1012 FALSE /* top */ ); 1013 1014 cf2_hintmap_insertHint( hintmap, &bottomHintEdge, &topHintEdge ); 1015 } 1016 1017 if ( ( i & 7 ) == 7 ) 1018 { 1019 /* move to next mask byte */ 1020 maskPtr++; 1021 maskByte = 0x80; 1022 } 1023 else 1024 maskByte >>= 1; 1025 } 1026 } 1027 1028 FT_TRACE6(( initialMap ? "flags: [p]air [g]host [t]op " 1029 "[b]ottom [L]ocked [S]ynthetic\n" 1030 "Initial hintmap\n" 1031 : "Hints:\n" )); 1032 cf2_hintmap_dump( hintmap ); 1033 1034 /* 1035 * Note: The following line is a convenient place to break when 1036 * debugging hinting. Examine `hintmap->edge' for the list of 1037 * enabled hints, then step over the call to see the effect of 1038 * adjustment. We stop here first on the recursive call that 1039 * creates the initial map, and then on each counter group and 1040 * hint zone. 1041 */ 1042 1043 /* adjust positions of hint edges that are not locked to blue zones */ 1044 cf2_hintmap_adjustHints( hintmap ); 1045 1046 FT_TRACE6(( "(adjusted)\n" )); 1047 cf2_hintmap_dump( hintmap ); 1048 1049 /* save the position of all hints that were used in this hint map; */ 1050 /* if we use them again, we'll locate them in the same position */ 1051 if ( !initialMap ) 1052 { 1053 for ( i = 0; i < hintmap->count; i++ ) 1054 { 1055 if ( !cf2_hint_isSynthetic( &hintmap->edge[i] ) ) 1056 { 1057 /* Note: include both valid and invalid edges */ 1058 /* Note: top and bottom edges are copied back separately */ 1059 CF2_StemHint stemhint = (CF2_StemHint) 1060 cf2_arrstack_getPointer( hStemHintArray, 1061 hintmap->edge[i].index ); 1062 1063 1064 if ( cf2_hint_isTop( &hintmap->edge[i] ) ) 1065 stemhint->maxDS = hintmap->edge[i].dsCoord; 1066 else 1067 stemhint->minDS = hintmap->edge[i].dsCoord; 1068 1069 stemhint->used = TRUE; 1070 } 1071 } 1072 } 1073 1074 /* hint map is ready to use */ 1075 hintmap->isValid = TRUE; 1076 1077 /* remember this mask has been used */ 1078 cf2_hintmask_setNew( hintMask, FALSE ); 1079 } 1080 1081 1082 FT_LOCAL_DEF( void ) 1083 cf2_glyphpath_init( CF2_GlyphPath glyphpath, 1084 CF2_Font font, 1085 CF2_OutlineCallbacks callbacks, 1086 CF2_Fixed scaleY, 1087 /* CF2_Fixed hShift, */ 1088 CF2_ArrStack hStemHintArray, 1089 CF2_ArrStack vStemHintArray, 1090 CF2_HintMask hintMask, 1091 CF2_Fixed hintOriginY, 1092 const CF2_Blues blues, 1093 const FT_Vector* fractionalTranslation ) 1094 { 1095 FT_ZERO( glyphpath ); 1096 1097 glyphpath->font = font; 1098 glyphpath->callbacks = callbacks; 1099 1100 cf2_arrstack_init( &glyphpath->hintMoves, 1101 font->memory, 1102 &font->error, 1103 sizeof ( CF2_HintMoveRec ) ); 1104 1105 cf2_hintmap_init( &glyphpath->initialHintMap, 1106 font, 1107 &glyphpath->initialHintMap, 1108 &glyphpath->hintMoves, 1109 scaleY ); 1110 cf2_hintmap_init( &glyphpath->firstHintMap, 1111 font, 1112 &glyphpath->initialHintMap, 1113 &glyphpath->hintMoves, 1114 scaleY ); 1115 cf2_hintmap_init( &glyphpath->hintMap, 1116 font, 1117 &glyphpath->initialHintMap, 1118 &glyphpath->hintMoves, 1119 scaleY ); 1120 1121 glyphpath->scaleX = font->innerTransform.a; 1122 glyphpath->scaleC = font->innerTransform.c; 1123 glyphpath->scaleY = font->innerTransform.d; 1124 1125 glyphpath->fractionalTranslation = *fractionalTranslation; 1126 1127#if 0 1128 glyphpath->hShift = hShift; /* for fauxing */ 1129#endif 1130 1131 glyphpath->hStemHintArray = hStemHintArray; 1132 glyphpath->vStemHintArray = vStemHintArray; 1133 glyphpath->hintMask = hintMask; /* ptr to current mask */ 1134 glyphpath->hintOriginY = hintOriginY; 1135 glyphpath->blues = blues; 1136 glyphpath->darken = font->darkened; /* TODO: should we make copies? */ 1137 glyphpath->xOffset = font->darkenX; 1138 glyphpath->yOffset = font->darkenY; 1139 glyphpath->miterLimit = 2 * FT_MAX( 1140 cf2_fixedAbs( glyphpath->xOffset ), 1141 cf2_fixedAbs( glyphpath->yOffset ) ); 1142 1143 /* .1 character space unit */ 1144 glyphpath->snapThreshold = cf2_doubleToFixed( 0.1 ); 1145 1146 glyphpath->moveIsPending = TRUE; 1147 glyphpath->pathIsOpen = FALSE; 1148 glyphpath->pathIsClosing = FALSE; 1149 glyphpath->elemIsQueued = FALSE; 1150 } 1151 1152 1153 FT_LOCAL_DEF( void ) 1154 cf2_glyphpath_finalize( CF2_GlyphPath glyphpath ) 1155 { 1156 cf2_arrstack_finalize( &glyphpath->hintMoves ); 1157 } 1158 1159 1160 /* 1161 * Hint point in y-direction and apply outerTransform. 1162 * Input `current' hint map (which is actually delayed by one element). 1163 * Input x,y point in Character Space. 1164 * Output x,y point in Device Space, including translation. 1165 */ 1166 static void 1167 cf2_glyphpath_hintPoint( CF2_GlyphPath glyphpath, 1168 CF2_HintMap hintmap, 1169 FT_Vector* ppt, 1170 CF2_Fixed x, 1171 CF2_Fixed y ) 1172 { 1173 FT_Vector pt; /* hinted point in upright DS */ 1174 1175 1176 pt.x = ADD_INT32( FT_MulFix( glyphpath->scaleX, x ), 1177 FT_MulFix( glyphpath->scaleC, y ) ); 1178 pt.y = cf2_hintmap_map( hintmap, y ); 1179 1180 ppt->x = ADD_INT32( 1181 FT_MulFix( glyphpath->font->outerTransform.a, pt.x ), 1182 ADD_INT32( 1183 FT_MulFix( glyphpath->font->outerTransform.c, pt.y ), 1184 glyphpath->fractionalTranslation.x ) ); 1185 ppt->y = ADD_INT32( 1186 FT_MulFix( glyphpath->font->outerTransform.b, pt.x ), 1187 ADD_INT32( 1188 FT_MulFix( glyphpath->font->outerTransform.d, pt.y ), 1189 glyphpath->fractionalTranslation.y ) ); 1190 } 1191 1192 1193 /* 1194 * From two line segments, (u1,u2) and (v1,v2), compute a point of 1195 * intersection on the corresponding lines. 1196 * Return false if no intersection is found, or if the intersection is 1197 * too far away from the ends of the line segments, u2 and v1. 1198 * 1199 */ 1200 static FT_Bool 1201 cf2_glyphpath_computeIntersection( CF2_GlyphPath glyphpath, 1202 const FT_Vector* u1, 1203 const FT_Vector* u2, 1204 const FT_Vector* v1, 1205 const FT_Vector* v2, 1206 FT_Vector* intersection ) 1207 { 1208 /* 1209 * Let `u' be a zero-based vector from the first segment, `v' from the 1210 * second segment. 1211 * Let `w 'be the zero-based vector from `u1' to `v1'. 1212 * `perp' is the `perpendicular dot product'; see 1213 * https://mathworld.wolfram.com/PerpDotProduct.html. 1214 * `s' is the parameter for the parametric line for the first segment 1215 * (`u'). 1216 * 1217 * See notation in 1218 * http://softsurfer.com/Archive/algorithm_0104/algorithm_0104B.htm. 1219 * Calculations are done in 16.16, but must handle the squaring of 1220 * line lengths in character space. We scale all vectors by 1/32 to 1221 * avoid overflow. This allows values up to 4095 to be squared. The 1222 * scale factor cancels in the divide. 1223 * 1224 * TODO: the scale factor could be computed from UnitsPerEm. 1225 * 1226 */ 1227 1228#define cf2_perp( a, b ) \ 1229 ( FT_MulFix( a.x, b.y ) - FT_MulFix( a.y, b.x ) ) 1230 1231 /* round and divide by 32 */ 1232#define CF2_CS_SCALE( x ) \ 1233 ( ( (x) + 0x10 ) >> 5 ) 1234 1235 FT_Vector u, v, w; /* scaled vectors */ 1236 CF2_Fixed denominator, s; 1237 1238 1239 u.x = CF2_CS_SCALE( SUB_INT32( u2->x, u1->x ) ); 1240 u.y = CF2_CS_SCALE( SUB_INT32( u2->y, u1->y ) ); 1241 v.x = CF2_CS_SCALE( SUB_INT32( v2->x, v1->x ) ); 1242 v.y = CF2_CS_SCALE( SUB_INT32( v2->y, v1->y ) ); 1243 w.x = CF2_CS_SCALE( SUB_INT32( v1->x, u1->x ) ); 1244 w.y = CF2_CS_SCALE( SUB_INT32( v1->y, u1->y ) ); 1245 1246 denominator = cf2_perp( u, v ); 1247 1248 if ( denominator == 0 ) 1249 return FALSE; /* parallel or coincident lines */ 1250 1251 s = FT_DivFix( cf2_perp( w, v ), denominator ); 1252 1253 intersection->x = ADD_INT32( u1->x, 1254 FT_MulFix( s, SUB_INT32( u2->x, u1->x ) ) ); 1255 intersection->y = ADD_INT32( u1->y, 1256 FT_MulFix( s, SUB_INT32( u2->y, u1->y ) ) ); 1257 1258 1259 /* 1260 * Special case snapping for horizontal and vertical lines. 1261 * This cleans up intersections and reduces problems with winding 1262 * order detection. 1263 * Sample case is sbc cd KozGoPr6N-Medium.otf 20 16685. 1264 * Note: these calculations are in character space. 1265 * 1266 */ 1267 1268 if ( u1->x == u2->x && 1269 cf2_fixedAbs( SUB_INT32( intersection->x, 1270 u1->x ) ) < glyphpath->snapThreshold ) 1271 intersection->x = u1->x; 1272 if ( u1->y == u2->y && 1273 cf2_fixedAbs( SUB_INT32( intersection->y, 1274 u1->y ) ) < glyphpath->snapThreshold ) 1275 intersection->y = u1->y; 1276 1277 if ( v1->x == v2->x && 1278 cf2_fixedAbs( SUB_INT32( intersection->x, 1279 v1->x ) ) < glyphpath->snapThreshold ) 1280 intersection->x = v1->x; 1281 if ( v1->y == v2->y && 1282 cf2_fixedAbs( SUB_INT32( intersection->y, 1283 v1->y ) ) < glyphpath->snapThreshold ) 1284 intersection->y = v1->y; 1285 1286 /* limit the intersection distance from midpoint of u2 and v1 */ 1287 if ( cf2_fixedAbs( intersection->x - ADD_INT32( u2->x, v1->x ) / 2 ) > 1288 glyphpath->miterLimit || 1289 cf2_fixedAbs( intersection->y - ADD_INT32( u2->y, v1->y ) / 2 ) > 1290 glyphpath->miterLimit ) 1291 return FALSE; 1292 1293 return TRUE; 1294 } 1295 1296 1297 /* 1298 * Push the cached element (glyphpath->prevElem*) to the outline 1299 * consumer. When a darkening offset is used, the end point of the 1300 * cached element may be adjusted to an intersection point or we may 1301 * synthesize a connecting line to the current element. If we are 1302 * closing a subpath, we may also generate a connecting line to the start 1303 * point. 1304 * 1305 * This is where Character Space (CS) is converted to Device Space (DS) 1306 * using a hint map. This calculation must use a HintMap that was valid 1307 * at the time the element was saved. For the first point in a subpath, 1308 * that is a saved HintMap. For most elements, it just means the caller 1309 * has delayed building a HintMap from the current HintMask. 1310 * 1311 * Transform each point with outerTransform and call the outline 1312 * callbacks. This is a general 3x3 transform: 1313 * 1314 * x' = a*x + c*y + tx, y' = b*x + d*y + ty 1315 * 1316 * but it uses 4 elements from CF2_Font and the translation part 1317 * from CF2_GlyphPath. 1318 * 1319 */ 1320 static void 1321 cf2_glyphpath_pushPrevElem( CF2_GlyphPath glyphpath, 1322 CF2_HintMap hintmap, 1323 FT_Vector* nextP0, 1324 FT_Vector nextP1, 1325 FT_Bool close ) 1326 { 1327 CF2_CallbackParamsRec params; 1328 1329 FT_Vector* prevP0; 1330 FT_Vector* prevP1; 1331 1332 FT_Vector intersection = { 0, 0 }; 1333 FT_Bool useIntersection = FALSE; 1334 1335 1336 FT_ASSERT( glyphpath->prevElemOp == CF2_PathOpLineTo || 1337 glyphpath->prevElemOp == CF2_PathOpCubeTo ); 1338 1339 if ( glyphpath->prevElemOp == CF2_PathOpLineTo ) 1340 { 1341 prevP0 = &glyphpath->prevElemP0; 1342 prevP1 = &glyphpath->prevElemP1; 1343 } 1344 else 1345 { 1346 prevP0 = &glyphpath->prevElemP2; 1347 prevP1 = &glyphpath->prevElemP3; 1348 } 1349 1350 /* optimization: if previous and next elements are offset by the same */ 1351 /* amount, then there will be no gap, and no need to compute an */ 1352 /* intersection. */ 1353 if ( prevP1->x != nextP0->x || prevP1->y != nextP0->y ) 1354 { 1355 /* previous element does not join next element: */ 1356 /* adjust end point of previous element to the intersection */ 1357 useIntersection = cf2_glyphpath_computeIntersection( glyphpath, 1358 prevP0, 1359 prevP1, 1360 nextP0, 1361 &nextP1, 1362 &intersection ); 1363 if ( useIntersection ) 1364 { 1365 /* modify the last point of the cached element (either line or */ 1366 /* curve) */ 1367 *prevP1 = intersection; 1368 } 1369 } 1370 1371 params.pt0 = glyphpath->currentDS; 1372 1373 switch( glyphpath->prevElemOp ) 1374 { 1375 case CF2_PathOpLineTo: 1376 params.op = CF2_PathOpLineTo; 1377 1378 /* note: pt2 and pt3 are unused */ 1379 1380 if ( close ) 1381 { 1382 /* use first hint map if closing */ 1383 cf2_glyphpath_hintPoint( glyphpath, 1384 &glyphpath->firstHintMap, 1385 ¶ms.pt1, 1386 glyphpath->prevElemP1.x, 1387 glyphpath->prevElemP1.y ); 1388 } 1389 else 1390 { 1391 cf2_glyphpath_hintPoint( glyphpath, 1392 hintmap, 1393 ¶ms.pt1, 1394 glyphpath->prevElemP1.x, 1395 glyphpath->prevElemP1.y ); 1396 } 1397 1398 /* output only non-zero length lines */ 1399 if ( params.pt0.x != params.pt1.x || params.pt0.y != params.pt1.y ) 1400 { 1401 glyphpath->callbacks->lineTo( glyphpath->callbacks, ¶ms ); 1402 1403 glyphpath->currentDS = params.pt1; 1404 } 1405 break; 1406 1407 case CF2_PathOpCubeTo: 1408 params.op = CF2_PathOpCubeTo; 1409 1410 /* TODO: should we intersect the interior joins (p1-p2 and p2-p3)? */ 1411 cf2_glyphpath_hintPoint( glyphpath, 1412 hintmap, 1413 ¶ms.pt1, 1414 glyphpath->prevElemP1.x, 1415 glyphpath->prevElemP1.y ); 1416 cf2_glyphpath_hintPoint( glyphpath, 1417 hintmap, 1418 ¶ms.pt2, 1419 glyphpath->prevElemP2.x, 1420 glyphpath->prevElemP2.y ); 1421 cf2_glyphpath_hintPoint( glyphpath, 1422 hintmap, 1423 ¶ms.pt3, 1424 glyphpath->prevElemP3.x, 1425 glyphpath->prevElemP3.y ); 1426 1427 glyphpath->callbacks->cubeTo( glyphpath->callbacks, ¶ms ); 1428 1429 glyphpath->currentDS = params.pt3; 1430 1431 break; 1432 } 1433 1434 if ( !useIntersection || close ) 1435 { 1436 /* insert connecting line between end of previous element and start */ 1437 /* of current one */ 1438 /* note: at the end of a subpath, we might do both, so use `nextP0' */ 1439 /* before we change it, below */ 1440 1441 if ( close ) 1442 { 1443 /* if we are closing the subpath, then nextP0 is in the first */ 1444 /* hint zone */ 1445 cf2_glyphpath_hintPoint( glyphpath, 1446 &glyphpath->firstHintMap, 1447 ¶ms.pt1, 1448 nextP0->x, 1449 nextP0->y ); 1450 } 1451 else 1452 { 1453 cf2_glyphpath_hintPoint( glyphpath, 1454 hintmap, 1455 ¶ms.pt1, 1456 nextP0->x, 1457 nextP0->y ); 1458 } 1459 1460 if ( params.pt1.x != glyphpath->currentDS.x || 1461 params.pt1.y != glyphpath->currentDS.y ) 1462 { 1463 /* length is nonzero */ 1464 params.op = CF2_PathOpLineTo; 1465 params.pt0 = glyphpath->currentDS; 1466 1467 /* note: pt2 and pt3 are unused */ 1468 glyphpath->callbacks->lineTo( glyphpath->callbacks, ¶ms ); 1469 1470 glyphpath->currentDS = params.pt1; 1471 } 1472 } 1473 1474 if ( useIntersection ) 1475 { 1476 /* return intersection point to caller */ 1477 *nextP0 = intersection; 1478 } 1479 } 1480 1481 1482 /* push a MoveTo element based on current point and offset of current */ 1483 /* element */ 1484 static void 1485 cf2_glyphpath_pushMove( CF2_GlyphPath glyphpath, 1486 FT_Vector start ) 1487 { 1488 CF2_CallbackParamsRec params; 1489 1490 1491 params.op = CF2_PathOpMoveTo; 1492 params.pt0 = glyphpath->currentDS; 1493 1494 /* Test if move has really happened yet; it would have called */ 1495 /* `cf2_hintmap_build' to set `isValid'. */ 1496 if ( !cf2_hintmap_isValid( &glyphpath->hintMap ) ) 1497 { 1498 /* we are here iff first subpath is missing a moveto operator: */ 1499 /* synthesize first moveTo to finish initialization of hintMap */ 1500 cf2_glyphpath_moveTo( glyphpath, 1501 glyphpath->start.x, 1502 glyphpath->start.y ); 1503 } 1504 1505 cf2_glyphpath_hintPoint( glyphpath, 1506 &glyphpath->hintMap, 1507 ¶ms.pt1, 1508 start.x, 1509 start.y ); 1510 1511 /* note: pt2 and pt3 are unused */ 1512 glyphpath->callbacks->moveTo( glyphpath->callbacks, ¶ms ); 1513 1514 glyphpath->currentDS = params.pt1; 1515 glyphpath->offsetStart0 = start; 1516 } 1517 1518 1519 /* 1520 * All coordinates are in character space. 1521 * On input, (x1, y1) and (x2, y2) give line segment. 1522 * On output, (x, y) give offset vector. 1523 * We use a piecewise approximation to trig functions. 1524 * 1525 * TODO: Offset true perpendicular and proper length 1526 * supply the y-translation for hinting here, too, 1527 * that adds yOffset unconditionally to *y. 1528 */ 1529 static void 1530 cf2_glyphpath_computeOffset( CF2_GlyphPath glyphpath, 1531 CF2_Fixed x1, 1532 CF2_Fixed y1, 1533 CF2_Fixed x2, 1534 CF2_Fixed y2, 1535 CF2_Fixed* x, 1536 CF2_Fixed* y ) 1537 { 1538 CF2_Fixed dx = SUB_INT32( x2, x1 ); 1539 CF2_Fixed dy = SUB_INT32( y2, y1 ); 1540 1541 1542 /* note: negative offsets don't work here; negate deltas to change */ 1543 /* quadrants, below */ 1544 if ( glyphpath->font->reverseWinding ) 1545 { 1546 dx = NEG_INT32( dx ); 1547 dy = NEG_INT32( dy ); 1548 } 1549 1550 *x = *y = 0; 1551 1552 if ( !glyphpath->darken ) 1553 return; 1554 1555 /* add momentum for this path element */ 1556 glyphpath->callbacks->windingMomentum = 1557 ADD_INT32( glyphpath->callbacks->windingMomentum, 1558 cf2_getWindingMomentum( x1, y1, x2, y2 ) ); 1559 1560 /* note: allow mixed integer and fixed multiplication here */ 1561 if ( dx >= 0 ) 1562 { 1563 if ( dy >= 0 ) 1564 { 1565 /* first quadrant, +x +y */ 1566 1567 if ( dx > MUL_INT32( 2, dy ) ) 1568 { 1569 /* +x */ 1570 *x = 0; 1571 *y = 0; 1572 } 1573 else if ( dy > MUL_INT32( 2, dx ) ) 1574 { 1575 /* +y */ 1576 *x = glyphpath->xOffset; 1577 *y = glyphpath->yOffset; 1578 } 1579 else 1580 { 1581 /* +x +y */ 1582 *x = FT_MulFix( cf2_doubleToFixed( 0.7 ), 1583 glyphpath->xOffset ); 1584 *y = FT_MulFix( cf2_doubleToFixed( 1.0 - 0.7 ), 1585 glyphpath->yOffset ); 1586 } 1587 } 1588 else 1589 { 1590 /* fourth quadrant, +x -y */ 1591 1592 if ( dx > MUL_INT32( -2, dy ) ) 1593 { 1594 /* +x */ 1595 *x = 0; 1596 *y = 0; 1597 } 1598 else if ( NEG_INT32( dy ) > MUL_INT32( 2, dx ) ) 1599 { 1600 /* -y */ 1601 *x = NEG_INT32( glyphpath->xOffset ); 1602 *y = glyphpath->yOffset; 1603 } 1604 else 1605 { 1606 /* +x -y */ 1607 *x = FT_MulFix( cf2_doubleToFixed( -0.7 ), 1608 glyphpath->xOffset ); 1609 *y = FT_MulFix( cf2_doubleToFixed( 1.0 - 0.7 ), 1610 glyphpath->yOffset ); 1611 } 1612 } 1613 } 1614 else 1615 { 1616 if ( dy >= 0 ) 1617 { 1618 /* second quadrant, -x +y */ 1619 1620 if ( NEG_INT32( dx ) > MUL_INT32( 2, dy ) ) 1621 { 1622 /* -x */ 1623 *x = 0; 1624 *y = MUL_INT32( 2, glyphpath->yOffset ); 1625 } 1626 else if ( dy > MUL_INT32( -2, dx ) ) 1627 { 1628 /* +y */ 1629 *x = glyphpath->xOffset; 1630 *y = glyphpath->yOffset; 1631 } 1632 else 1633 { 1634 /* -x +y */ 1635 *x = FT_MulFix( cf2_doubleToFixed( 0.7 ), 1636 glyphpath->xOffset ); 1637 *y = FT_MulFix( cf2_doubleToFixed( 1.0 + 0.7 ), 1638 glyphpath->yOffset ); 1639 } 1640 } 1641 else 1642 { 1643 /* third quadrant, -x -y */ 1644 1645 if ( NEG_INT32( dx ) > MUL_INT32( -2, dy ) ) 1646 { 1647 /* -x */ 1648 *x = 0; 1649 *y = MUL_INT32( 2, glyphpath->yOffset ); 1650 } 1651 else if ( NEG_INT32( dy ) > MUL_INT32( -2, dx ) ) 1652 { 1653 /* -y */ 1654 *x = NEG_INT32( glyphpath->xOffset ); 1655 *y = glyphpath->yOffset; 1656 } 1657 else 1658 { 1659 /* -x -y */ 1660 *x = FT_MulFix( cf2_doubleToFixed( -0.7 ), 1661 glyphpath->xOffset ); 1662 *y = FT_MulFix( cf2_doubleToFixed( 1.0 + 0.7 ), 1663 glyphpath->yOffset ); 1664 } 1665 } 1666 } 1667 } 1668 1669 1670 /* 1671 * The functions cf2_glyphpath_{moveTo,lineTo,curveTo,closeOpenPath} are 1672 * called by the interpreter with Character Space (CS) coordinates. Each 1673 * path element is placed into a queue of length one to await the 1674 * calculation of the following element. At that time, the darkening 1675 * offset of the following element is known and joins can be computed, 1676 * including possible modification of this element, before mapping to 1677 * Device Space (DS) and passing it on to the outline consumer. 1678 * 1679 */ 1680 FT_LOCAL_DEF( void ) 1681 cf2_glyphpath_moveTo( CF2_GlyphPath glyphpath, 1682 CF2_Fixed x, 1683 CF2_Fixed y ) 1684 { 1685 cf2_glyphpath_closeOpenPath( glyphpath ); 1686 1687 /* save the parameters of the move for later, when we'll know how to */ 1688 /* offset it; */ 1689 /* also save last move point */ 1690 glyphpath->currentCS.x = glyphpath->start.x = x; 1691 glyphpath->currentCS.y = glyphpath->start.y = y; 1692 1693 glyphpath->moveIsPending = TRUE; 1694 1695 /* ensure we have a valid map with current mask */ 1696 if ( !cf2_hintmap_isValid( &glyphpath->hintMap ) || 1697 cf2_hintmask_isNew( glyphpath->hintMask ) ) 1698 cf2_hintmap_build( &glyphpath->hintMap, 1699 glyphpath->hStemHintArray, 1700 glyphpath->vStemHintArray, 1701 glyphpath->hintMask, 1702 glyphpath->hintOriginY, 1703 FALSE ); 1704 1705 /* save a copy of current HintMap to use when drawing initial point */ 1706 glyphpath->firstHintMap = glyphpath->hintMap; /* structure copy */ 1707 } 1708 1709 1710 FT_LOCAL_DEF( void ) 1711 cf2_glyphpath_lineTo( CF2_GlyphPath glyphpath, 1712 CF2_Fixed x, 1713 CF2_Fixed y ) 1714 { 1715 CF2_Fixed xOffset, yOffset; 1716 FT_Vector P0, P1; 1717 FT_Bool newHintMap; 1718 1719 /* 1720 * New hints will be applied after cf2_glyphpath_pushPrevElem has run. 1721 * In case this is a synthesized closing line, any new hints should be 1722 * delayed until this path is closed (`cf2_hintmask_isNew' will be 1723 * called again before the next line or curve). 1724 */ 1725 1726 /* true if new hint map not on close */ 1727 newHintMap = cf2_hintmask_isNew( glyphpath->hintMask ) && 1728 !glyphpath->pathIsClosing; 1729 1730 /* 1731 * Zero-length lines may occur in the charstring. Because we cannot 1732 * compute darkening offsets or intersections from zero-length lines, 1733 * it is best to remove them and avoid artifacts. However, zero-length 1734 * lines in CS at the start of a new hint map can generate non-zero 1735 * lines in DS due to hint substitution. We detect a change in hint 1736 * map here and pass those zero-length lines along. 1737 */ 1738 1739 /* 1740 * Note: Find explicitly closed paths here with a conditional 1741 * breakpoint using 1742 * 1743 * !gp->pathIsClosing && gp->start.x == x && gp->start.y == y 1744 * 1745 */ 1746 1747 if ( glyphpath->currentCS.x == x && 1748 glyphpath->currentCS.y == y && 1749 !newHintMap ) 1750 /* 1751 * Ignore zero-length lines in CS where the hint map is the same 1752 * because the line in DS will also be zero length. 1753 * 1754 * Ignore zero-length lines when we synthesize a closing line because 1755 * the close will be handled in cf2_glyphPath_pushPrevElem. 1756 */ 1757 return; 1758 1759 cf2_glyphpath_computeOffset( glyphpath, 1760 glyphpath->currentCS.x, 1761 glyphpath->currentCS.y, 1762 x, 1763 y, 1764 &xOffset, 1765 &yOffset ); 1766 1767 /* construct offset points */ 1768 P0.x = ADD_INT32( glyphpath->currentCS.x, xOffset ); 1769 P0.y = ADD_INT32( glyphpath->currentCS.y, yOffset ); 1770 P1.x = ADD_INT32( x, xOffset ); 1771 P1.y = ADD_INT32( y, yOffset ); 1772 1773 if ( glyphpath->moveIsPending ) 1774 { 1775 /* emit offset 1st point as MoveTo */ 1776 cf2_glyphpath_pushMove( glyphpath, P0 ); 1777 1778 glyphpath->moveIsPending = FALSE; /* adjust state machine */ 1779 glyphpath->pathIsOpen = TRUE; 1780 1781 glyphpath->offsetStart1 = P1; /* record second point */ 1782 } 1783 1784 if ( glyphpath->elemIsQueued ) 1785 { 1786 FT_ASSERT( cf2_hintmap_isValid( &glyphpath->hintMap ) || 1787 glyphpath->hintMap.count == 0 ); 1788 1789 cf2_glyphpath_pushPrevElem( glyphpath, 1790 &glyphpath->hintMap, 1791 &P0, 1792 P1, 1793 FALSE ); 1794 } 1795 1796 /* queue the current element with offset points */ 1797 glyphpath->elemIsQueued = TRUE; 1798 glyphpath->prevElemOp = CF2_PathOpLineTo; 1799 glyphpath->prevElemP0 = P0; 1800 glyphpath->prevElemP1 = P1; 1801 1802 /* update current map */ 1803 if ( newHintMap ) 1804 cf2_hintmap_build( &glyphpath->hintMap, 1805 glyphpath->hStemHintArray, 1806 glyphpath->vStemHintArray, 1807 glyphpath->hintMask, 1808 glyphpath->hintOriginY, 1809 FALSE ); 1810 1811 glyphpath->currentCS.x = x; /* pre-offset current point */ 1812 glyphpath->currentCS.y = y; 1813 } 1814 1815 1816 FT_LOCAL_DEF( void ) 1817 cf2_glyphpath_curveTo( CF2_GlyphPath glyphpath, 1818 CF2_Fixed x1, 1819 CF2_Fixed y1, 1820 CF2_Fixed x2, 1821 CF2_Fixed y2, 1822 CF2_Fixed x3, 1823 CF2_Fixed y3 ) 1824 { 1825 CF2_Fixed xOffset1, yOffset1, xOffset3, yOffset3; 1826 FT_Vector P0, P1, P2, P3; 1827 1828 1829 /* TODO: ignore zero length portions of curve?? */ 1830 cf2_glyphpath_computeOffset( glyphpath, 1831 glyphpath->currentCS.x, 1832 glyphpath->currentCS.y, 1833 x1, 1834 y1, 1835 &xOffset1, 1836 &yOffset1 ); 1837 cf2_glyphpath_computeOffset( glyphpath, 1838 x2, 1839 y2, 1840 x3, 1841 y3, 1842 &xOffset3, 1843 &yOffset3 ); 1844 1845 /* add momentum from the middle segment */ 1846 glyphpath->callbacks->windingMomentum = 1847 ADD_INT32( glyphpath->callbacks->windingMomentum, 1848 cf2_getWindingMomentum( x1, y1, x2, y2 ) ); 1849 1850 /* construct offset points */ 1851 P0.x = ADD_INT32( glyphpath->currentCS.x, xOffset1 ); 1852 P0.y = ADD_INT32( glyphpath->currentCS.y, yOffset1 ); 1853 P1.x = ADD_INT32( x1, xOffset1 ); 1854 P1.y = ADD_INT32( y1, yOffset1 ); 1855 /* note: preserve angle of final segment by using offset3 at both ends */ 1856 P2.x = ADD_INT32( x2, xOffset3 ); 1857 P2.y = ADD_INT32( y2, yOffset3 ); 1858 P3.x = ADD_INT32( x3, xOffset3 ); 1859 P3.y = ADD_INT32( y3, yOffset3 ); 1860 1861 if ( glyphpath->moveIsPending ) 1862 { 1863 /* emit offset 1st point as MoveTo */ 1864 cf2_glyphpath_pushMove( glyphpath, P0 ); 1865 1866 glyphpath->moveIsPending = FALSE; 1867 glyphpath->pathIsOpen = TRUE; 1868 1869 glyphpath->offsetStart1 = P1; /* record second point */ 1870 } 1871 1872 if ( glyphpath->elemIsQueued ) 1873 { 1874 FT_ASSERT( cf2_hintmap_isValid( &glyphpath->hintMap ) || 1875 glyphpath->hintMap.count == 0 ); 1876 1877 cf2_glyphpath_pushPrevElem( glyphpath, 1878 &glyphpath->hintMap, 1879 &P0, 1880 P1, 1881 FALSE ); 1882 } 1883 1884 /* queue the current element with offset points */ 1885 glyphpath->elemIsQueued = TRUE; 1886 glyphpath->prevElemOp = CF2_PathOpCubeTo; 1887 glyphpath->prevElemP0 = P0; 1888 glyphpath->prevElemP1 = P1; 1889 glyphpath->prevElemP2 = P2; 1890 glyphpath->prevElemP3 = P3; 1891 1892 /* update current map */ 1893 if ( cf2_hintmask_isNew( glyphpath->hintMask ) ) 1894 cf2_hintmap_build( &glyphpath->hintMap, 1895 glyphpath->hStemHintArray, 1896 glyphpath->vStemHintArray, 1897 glyphpath->hintMask, 1898 glyphpath->hintOriginY, 1899 FALSE ); 1900 1901 glyphpath->currentCS.x = x3; /* pre-offset current point */ 1902 glyphpath->currentCS.y = y3; 1903 } 1904 1905 1906 FT_LOCAL_DEF( void ) 1907 cf2_glyphpath_closeOpenPath( CF2_GlyphPath glyphpath ) 1908 { 1909 if ( glyphpath->pathIsOpen ) 1910 { 1911 /* 1912 * A closing line in Character Space line is always generated below 1913 * with `cf2_glyphPath_lineTo'. It may be ignored later if it turns 1914 * out to be zero length in Device Space. 1915 */ 1916 glyphpath->pathIsClosing = TRUE; 1917 1918 cf2_glyphpath_lineTo( glyphpath, 1919 glyphpath->start.x, 1920 glyphpath->start.y ); 1921 1922 /* empty the final element from the queue and close the path */ 1923 if ( glyphpath->elemIsQueued ) 1924 cf2_glyphpath_pushPrevElem( glyphpath, 1925 &glyphpath->hintMap, 1926 &glyphpath->offsetStart0, 1927 glyphpath->offsetStart1, 1928 TRUE ); 1929 1930 /* reset state machine */ 1931 glyphpath->moveIsPending = TRUE; 1932 glyphpath->pathIsOpen = FALSE; 1933 glyphpath->pathIsClosing = FALSE; 1934 glyphpath->elemIsQueued = FALSE; 1935 } 1936 } 1937 1938 1939/* END */ 1940