1/***************************************************************************/ 2/* */ 3/* pshalgo.c */ 4/* */ 5/* PostScript hinting algorithm (body). */ 6/* */ 7/* Copyright 2001-2010, 2012, 2013 by */ 8/* David Turner, Robert Wilhelm, and Werner Lemberg. */ 9/* */ 10/* This file is part of the FreeType project, and may only be used */ 11/* modified and distributed under the terms of the FreeType project */ 12/* license, LICENSE.TXT. By continuing to use, modify, or distribute */ 13/* this file you indicate that you have read the license and */ 14/* understand and accept it fully. */ 15/* */ 16/***************************************************************************/ 17 18 19#include <ft2build.h> 20#include FT_INTERNAL_OBJECTS_H 21#include FT_INTERNAL_DEBUG_H 22#include FT_INTERNAL_CALC_H 23#include "pshalgo.h" 24 25#include "pshnterr.h" 26 27 28#undef FT_COMPONENT 29#define FT_COMPONENT trace_pshalgo2 30 31 32#ifdef DEBUG_HINTER 33 PSH_Hint_Table ps_debug_hint_table = 0; 34 PSH_HintFunc ps_debug_hint_func = 0; 35 PSH_Glyph ps_debug_glyph = 0; 36#endif 37 38 39#define COMPUTE_INFLEXS /* compute inflection points to optimize `S' */ 40 /* and similar glyphs */ 41#define STRONGER /* slightly increase the contrast of smooth */ 42 /* hinting */ 43 44 45 /*************************************************************************/ 46 /*************************************************************************/ 47 /***** *****/ 48 /***** BASIC HINTS RECORDINGS *****/ 49 /***** *****/ 50 /*************************************************************************/ 51 /*************************************************************************/ 52 53 /* return true if two stem hints overlap */ 54 static FT_Int 55 psh_hint_overlap( PSH_Hint hint1, 56 PSH_Hint hint2 ) 57 { 58 return hint1->org_pos + hint1->org_len >= hint2->org_pos && 59 hint2->org_pos + hint2->org_len >= hint1->org_pos; 60 } 61 62 63 /* destroy hints table */ 64 static void 65 psh_hint_table_done( PSH_Hint_Table table, 66 FT_Memory memory ) 67 { 68 FT_FREE( table->zones ); 69 table->num_zones = 0; 70 table->zone = 0; 71 72 FT_FREE( table->sort ); 73 FT_FREE( table->hints ); 74 table->num_hints = 0; 75 table->max_hints = 0; 76 table->sort_global = 0; 77 } 78 79 80 /* deactivate all hints in a table */ 81 static void 82 psh_hint_table_deactivate( PSH_Hint_Table table ) 83 { 84 FT_UInt count = table->max_hints; 85 PSH_Hint hint = table->hints; 86 87 88 for ( ; count > 0; count--, hint++ ) 89 { 90 psh_hint_deactivate( hint ); 91 hint->order = -1; 92 } 93 } 94 95 96 /* internal function to record a new hint */ 97 static void 98 psh_hint_table_record( PSH_Hint_Table table, 99 FT_UInt idx ) 100 { 101 PSH_Hint hint = table->hints + idx; 102 103 104 if ( idx >= table->max_hints ) 105 { 106 FT_TRACE0(( "psh_hint_table_record: invalid hint index %d\n", idx )); 107 return; 108 } 109 110 /* ignore active hints */ 111 if ( psh_hint_is_active( hint ) ) 112 return; 113 114 psh_hint_activate( hint ); 115 116 /* now scan the current active hint set to check */ 117 /* whether `hint' overlaps with another hint */ 118 { 119 PSH_Hint* sorted = table->sort_global; 120 FT_UInt count = table->num_hints; 121 PSH_Hint hint2; 122 123 124 hint->parent = 0; 125 for ( ; count > 0; count--, sorted++ ) 126 { 127 hint2 = sorted[0]; 128 129 if ( psh_hint_overlap( hint, hint2 ) ) 130 { 131 hint->parent = hint2; 132 break; 133 } 134 } 135 } 136 137 if ( table->num_hints < table->max_hints ) 138 table->sort_global[table->num_hints++] = hint; 139 else 140 FT_TRACE0(( "psh_hint_table_record: too many sorted hints! BUG!\n" )); 141 } 142 143 144 static void 145 psh_hint_table_record_mask( PSH_Hint_Table table, 146 PS_Mask hint_mask ) 147 { 148 FT_Int mask = 0, val = 0; 149 FT_Byte* cursor = hint_mask->bytes; 150 FT_UInt idx, limit; 151 152 153 limit = hint_mask->num_bits; 154 155 for ( idx = 0; idx < limit; idx++ ) 156 { 157 if ( mask == 0 ) 158 { 159 val = *cursor++; 160 mask = 0x80; 161 } 162 163 if ( val & mask ) 164 psh_hint_table_record( table, idx ); 165 166 mask >>= 1; 167 } 168 } 169 170 171 /* create hints table */ 172 static FT_Error 173 psh_hint_table_init( PSH_Hint_Table table, 174 PS_Hint_Table hints, 175 PS_Mask_Table hint_masks, 176 PS_Mask_Table counter_masks, 177 FT_Memory memory ) 178 { 179 FT_UInt count; 180 FT_Error error; 181 182 FT_UNUSED( counter_masks ); 183 184 185 count = hints->num_hints; 186 187 /* allocate our tables */ 188 if ( FT_NEW_ARRAY( table->sort, 2 * count ) || 189 FT_NEW_ARRAY( table->hints, count ) || 190 FT_NEW_ARRAY( table->zones, 2 * count + 1 ) ) 191 goto Exit; 192 193 table->max_hints = count; 194 table->sort_global = table->sort + count; 195 table->num_hints = 0; 196 table->num_zones = 0; 197 table->zone = 0; 198 199 /* initialize the `table->hints' array */ 200 { 201 PSH_Hint write = table->hints; 202 PS_Hint read = hints->hints; 203 204 205 for ( ; count > 0; count--, write++, read++ ) 206 { 207 write->org_pos = read->pos; 208 write->org_len = read->len; 209 write->flags = read->flags; 210 } 211 } 212 213 /* we now need to determine the initial `parent' stems; first */ 214 /* activate the hints that are given by the initial hint masks */ 215 if ( hint_masks ) 216 { 217 PS_Mask mask = hint_masks->masks; 218 219 220 count = hint_masks->num_masks; 221 table->hint_masks = hint_masks; 222 223 for ( ; count > 0; count--, mask++ ) 224 psh_hint_table_record_mask( table, mask ); 225 } 226 227 /* finally, do a linear parse in case some hints were left alone */ 228 if ( table->num_hints != table->max_hints ) 229 { 230 FT_UInt idx; 231 232 233 FT_TRACE0(( "psh_hint_table_init: missing/incorrect hint masks\n" )); 234 235 count = table->max_hints; 236 for ( idx = 0; idx < count; idx++ ) 237 psh_hint_table_record( table, idx ); 238 } 239 240 Exit: 241 return error; 242 } 243 244 245 static void 246 psh_hint_table_activate_mask( PSH_Hint_Table table, 247 PS_Mask hint_mask ) 248 { 249 FT_Int mask = 0, val = 0; 250 FT_Byte* cursor = hint_mask->bytes; 251 FT_UInt idx, limit, count; 252 253 254 limit = hint_mask->num_bits; 255 count = 0; 256 257 psh_hint_table_deactivate( table ); 258 259 for ( idx = 0; idx < limit; idx++ ) 260 { 261 if ( mask == 0 ) 262 { 263 val = *cursor++; 264 mask = 0x80; 265 } 266 267 if ( val & mask ) 268 { 269 PSH_Hint hint = &table->hints[idx]; 270 271 272 if ( !psh_hint_is_active( hint ) ) 273 { 274 FT_UInt count2; 275 276#if 0 277 PSH_Hint* sort = table->sort; 278 PSH_Hint hint2; 279 280 281 for ( count2 = count; count2 > 0; count2--, sort++ ) 282 { 283 hint2 = sort[0]; 284 if ( psh_hint_overlap( hint, hint2 ) ) 285 FT_TRACE0(( "psh_hint_table_activate_mask:" 286 " found overlapping hints\n" )) 287 } 288#else 289 count2 = 0; 290#endif 291 292 if ( count2 == 0 ) 293 { 294 psh_hint_activate( hint ); 295 if ( count < table->max_hints ) 296 table->sort[count++] = hint; 297 else 298 FT_TRACE0(( "psh_hint_tableactivate_mask:" 299 " too many active hints\n" )); 300 } 301 } 302 } 303 304 mask >>= 1; 305 } 306 table->num_hints = count; 307 308 /* now, sort the hints; they are guaranteed to not overlap */ 309 /* so we can compare their "org_pos" field directly */ 310 { 311 FT_Int i1, i2; 312 PSH_Hint hint1, hint2; 313 PSH_Hint* sort = table->sort; 314 315 316 /* a simple bubble sort will do, since in 99% of cases, the hints */ 317 /* will be already sorted -- and the sort will be linear */ 318 for ( i1 = 1; i1 < (FT_Int)count; i1++ ) 319 { 320 hint1 = sort[i1]; 321 for ( i2 = i1 - 1; i2 >= 0; i2-- ) 322 { 323 hint2 = sort[i2]; 324 325 if ( hint2->org_pos < hint1->org_pos ) 326 break; 327 328 sort[i2 + 1] = hint2; 329 sort[i2] = hint1; 330 } 331 } 332 } 333 } 334 335 336 /*************************************************************************/ 337 /*************************************************************************/ 338 /***** *****/ 339 /***** HINTS GRID-FITTING AND OPTIMIZATION *****/ 340 /***** *****/ 341 /*************************************************************************/ 342 /*************************************************************************/ 343 344#if 1 345 static FT_Pos 346 psh_dimension_quantize_len( PSH_Dimension dim, 347 FT_Pos len, 348 FT_Bool do_snapping ) 349 { 350 if ( len <= 64 ) 351 len = 64; 352 else 353 { 354 FT_Pos delta = len - dim->stdw.widths[0].cur; 355 356 357 if ( delta < 0 ) 358 delta = -delta; 359 360 if ( delta < 40 ) 361 { 362 len = dim->stdw.widths[0].cur; 363 if ( len < 48 ) 364 len = 48; 365 } 366 367 if ( len < 3 * 64 ) 368 { 369 delta = ( len & 63 ); 370 len &= -64; 371 372 if ( delta < 10 ) 373 len += delta; 374 375 else if ( delta < 32 ) 376 len += 10; 377 378 else if ( delta < 54 ) 379 len += 54; 380 381 else 382 len += delta; 383 } 384 else 385 len = FT_PIX_ROUND( len ); 386 } 387 388 if ( do_snapping ) 389 len = FT_PIX_ROUND( len ); 390 391 return len; 392 } 393#endif /* 0 */ 394 395 396#ifdef DEBUG_HINTER 397 398 static void 399 ps_simple_scale( PSH_Hint_Table table, 400 FT_Fixed scale, 401 FT_Fixed delta, 402 FT_Int dimension ) 403 { 404 FT_UInt count; 405 406 407 for ( count = 0; count < table->max_hints; count++ ) 408 { 409 PSH_Hint hint = table->hints + count; 410 411 412 hint->cur_pos = FT_MulFix( hint->org_pos, scale ) + delta; 413 hint->cur_len = FT_MulFix( hint->org_len, scale ); 414 415 if ( ps_debug_hint_func ) 416 ps_debug_hint_func( hint, dimension ); 417 } 418 } 419 420#endif /* DEBUG_HINTER */ 421 422 423 static FT_Fixed 424 psh_hint_snap_stem_side_delta( FT_Fixed pos, 425 FT_Fixed len ) 426 { 427 FT_Fixed delta1 = FT_PIX_ROUND( pos ) - pos; 428 FT_Fixed delta2 = FT_PIX_ROUND( pos + len ) - pos - len; 429 430 431 if ( FT_ABS( delta1 ) <= FT_ABS( delta2 ) ) 432 return delta1; 433 else 434 return delta2; 435 } 436 437 438 static void 439 psh_hint_align( PSH_Hint hint, 440 PSH_Globals globals, 441 FT_Int dimension, 442 PSH_Glyph glyph ) 443 { 444 PSH_Dimension dim = &globals->dimension[dimension]; 445 FT_Fixed scale = dim->scale_mult; 446 FT_Fixed delta = dim->scale_delta; 447 448 449 if ( !psh_hint_is_fitted( hint ) ) 450 { 451 FT_Pos pos = FT_MulFix( hint->org_pos, scale ) + delta; 452 FT_Pos len = FT_MulFix( hint->org_len, scale ); 453 454 FT_Int do_snapping; 455 FT_Pos fit_len; 456 PSH_AlignmentRec align; 457 458 459 /* ignore stem alignments when requested through the hint flags */ 460 if ( ( dimension == 0 && !glyph->do_horz_hints ) || 461 ( dimension == 1 && !glyph->do_vert_hints ) ) 462 { 463 hint->cur_pos = pos; 464 hint->cur_len = len; 465 466 psh_hint_set_fitted( hint ); 467 return; 468 } 469 470 /* perform stem snapping when requested - this is necessary 471 * for monochrome and LCD hinting modes only 472 */ 473 do_snapping = ( dimension == 0 && glyph->do_horz_snapping ) || 474 ( dimension == 1 && glyph->do_vert_snapping ); 475 476 hint->cur_len = fit_len = len; 477 478 /* check blue zones for horizontal stems */ 479 align.align = PSH_BLUE_ALIGN_NONE; 480 align.align_bot = align.align_top = 0; 481 482 if ( dimension == 1 ) 483 psh_blues_snap_stem( &globals->blues, 484 hint->org_pos + hint->org_len, 485 hint->org_pos, 486 &align ); 487 488 switch ( align.align ) 489 { 490 case PSH_BLUE_ALIGN_TOP: 491 /* the top of the stem is aligned against a blue zone */ 492 hint->cur_pos = align.align_top - fit_len; 493 break; 494 495 case PSH_BLUE_ALIGN_BOT: 496 /* the bottom of the stem is aligned against a blue zone */ 497 hint->cur_pos = align.align_bot; 498 break; 499 500 case PSH_BLUE_ALIGN_TOP | PSH_BLUE_ALIGN_BOT: 501 /* both edges of the stem are aligned against blue zones */ 502 hint->cur_pos = align.align_bot; 503 hint->cur_len = align.align_top - align.align_bot; 504 break; 505 506 default: 507 { 508 PSH_Hint parent = hint->parent; 509 510 511 if ( parent ) 512 { 513 FT_Pos par_org_center, par_cur_center; 514 FT_Pos cur_org_center, cur_delta; 515 516 517 /* ensure that parent is already fitted */ 518 if ( !psh_hint_is_fitted( parent ) ) 519 psh_hint_align( parent, globals, dimension, glyph ); 520 521 /* keep original relation between hints, this is, use the */ 522 /* scaled distance between the centers of the hints to */ 523 /* compute the new position */ 524 par_org_center = parent->org_pos + ( parent->org_len >> 1 ); 525 par_cur_center = parent->cur_pos + ( parent->cur_len >> 1 ); 526 cur_org_center = hint->org_pos + ( hint->org_len >> 1 ); 527 528 cur_delta = FT_MulFix( cur_org_center - par_org_center, scale ); 529 pos = par_cur_center + cur_delta - ( len >> 1 ); 530 } 531 532 hint->cur_pos = pos; 533 hint->cur_len = fit_len; 534 535 /* Stem adjustment tries to snap stem widths to standard 536 * ones. This is important to prevent unpleasant rounding 537 * artefacts. 538 */ 539 if ( glyph->do_stem_adjust ) 540 { 541 if ( len <= 64 ) 542 { 543 /* the stem is less than one pixel; we will center it 544 * around the nearest pixel center 545 */ 546 if ( len >= 32 ) 547 { 548 /* This is a special case where we also widen the stem 549 * and align it to the pixel grid. 550 * 551 * stem_center = pos + (len/2) 552 * nearest_pixel_center = FT_ROUND(stem_center-32)+32 553 * new_pos = nearest_pixel_center-32 554 * = FT_ROUND(stem_center-32) 555 * = FT_FLOOR(stem_center-32+32) 556 * = FT_FLOOR(stem_center) 557 * new_len = 64 558 */ 559 pos = FT_PIX_FLOOR( pos + ( len >> 1 ) ); 560 len = 64; 561 } 562 else if ( len > 0 ) 563 { 564 /* This is a very small stem; we simply align it to the 565 * pixel grid, trying to find the minimum displacement. 566 * 567 * left = pos 568 * right = pos + len 569 * left_nearest_edge = ROUND(pos) 570 * right_nearest_edge = ROUND(right) 571 * 572 * if ( ABS(left_nearest_edge - left) <= 573 * ABS(right_nearest_edge - right) ) 574 * new_pos = left 575 * else 576 * new_pos = right 577 */ 578 FT_Pos left_nearest = FT_PIX_ROUND( pos ); 579 FT_Pos right_nearest = FT_PIX_ROUND( pos + len ); 580 FT_Pos left_disp = left_nearest - pos; 581 FT_Pos right_disp = right_nearest - ( pos + len ); 582 583 584 if ( left_disp < 0 ) 585 left_disp = -left_disp; 586 if ( right_disp < 0 ) 587 right_disp = -right_disp; 588 if ( left_disp <= right_disp ) 589 pos = left_nearest; 590 else 591 pos = right_nearest; 592 } 593 else 594 { 595 /* this is a ghost stem; we simply round it */ 596 pos = FT_PIX_ROUND( pos ); 597 } 598 } 599 else 600 { 601 len = psh_dimension_quantize_len( dim, len, 0 ); 602 } 603 } 604 605 /* now that we have a good hinted stem width, try to position */ 606 /* the stem along a pixel grid integer coordinate */ 607 hint->cur_pos = pos + psh_hint_snap_stem_side_delta( pos, len ); 608 hint->cur_len = len; 609 } 610 } 611 612 if ( do_snapping ) 613 { 614 pos = hint->cur_pos; 615 len = hint->cur_len; 616 617 if ( len < 64 ) 618 len = 64; 619 else 620 len = FT_PIX_ROUND( len ); 621 622 switch ( align.align ) 623 { 624 case PSH_BLUE_ALIGN_TOP: 625 hint->cur_pos = align.align_top - len; 626 hint->cur_len = len; 627 break; 628 629 case PSH_BLUE_ALIGN_BOT: 630 hint->cur_len = len; 631 break; 632 633 case PSH_BLUE_ALIGN_BOT | PSH_BLUE_ALIGN_TOP: 634 /* don't touch */ 635 break; 636 637 638 default: 639 hint->cur_len = len; 640 if ( len & 64 ) 641 pos = FT_PIX_FLOOR( pos + ( len >> 1 ) ) + 32; 642 else 643 pos = FT_PIX_ROUND( pos + ( len >> 1 ) ); 644 645 hint->cur_pos = pos - ( len >> 1 ); 646 hint->cur_len = len; 647 } 648 } 649 650 psh_hint_set_fitted( hint ); 651 652#ifdef DEBUG_HINTER 653 if ( ps_debug_hint_func ) 654 ps_debug_hint_func( hint, dimension ); 655#endif 656 } 657 } 658 659 660#if 0 /* not used for now, experimental */ 661 662 /* 663 * A variant to perform "light" hinting (i.e. FT_RENDER_MODE_LIGHT) 664 * of stems 665 */ 666 static void 667 psh_hint_align_light( PSH_Hint hint, 668 PSH_Globals globals, 669 FT_Int dimension, 670 PSH_Glyph glyph ) 671 { 672 PSH_Dimension dim = &globals->dimension[dimension]; 673 FT_Fixed scale = dim->scale_mult; 674 FT_Fixed delta = dim->scale_delta; 675 676 677 if ( !psh_hint_is_fitted( hint ) ) 678 { 679 FT_Pos pos = FT_MulFix( hint->org_pos, scale ) + delta; 680 FT_Pos len = FT_MulFix( hint->org_len, scale ); 681 682 FT_Pos fit_len; 683 684 PSH_AlignmentRec align; 685 686 687 /* ignore stem alignments when requested through the hint flags */ 688 if ( ( dimension == 0 && !glyph->do_horz_hints ) || 689 ( dimension == 1 && !glyph->do_vert_hints ) ) 690 { 691 hint->cur_pos = pos; 692 hint->cur_len = len; 693 694 psh_hint_set_fitted( hint ); 695 return; 696 } 697 698 fit_len = len; 699 700 hint->cur_len = fit_len; 701 702 /* check blue zones for horizontal stems */ 703 align.align = PSH_BLUE_ALIGN_NONE; 704 align.align_bot = align.align_top = 0; 705 706 if ( dimension == 1 ) 707 psh_blues_snap_stem( &globals->blues, 708 hint->org_pos + hint->org_len, 709 hint->org_pos, 710 &align ); 711 712 switch ( align.align ) 713 { 714 case PSH_BLUE_ALIGN_TOP: 715 /* the top of the stem is aligned against a blue zone */ 716 hint->cur_pos = align.align_top - fit_len; 717 break; 718 719 case PSH_BLUE_ALIGN_BOT: 720 /* the bottom of the stem is aligned against a blue zone */ 721 hint->cur_pos = align.align_bot; 722 break; 723 724 case PSH_BLUE_ALIGN_TOP | PSH_BLUE_ALIGN_BOT: 725 /* both edges of the stem are aligned against blue zones */ 726 hint->cur_pos = align.align_bot; 727 hint->cur_len = align.align_top - align.align_bot; 728 break; 729 730 default: 731 { 732 PSH_Hint parent = hint->parent; 733 734 735 if ( parent ) 736 { 737 FT_Pos par_org_center, par_cur_center; 738 FT_Pos cur_org_center, cur_delta; 739 740 741 /* ensure that parent is already fitted */ 742 if ( !psh_hint_is_fitted( parent ) ) 743 psh_hint_align_light( parent, globals, dimension, glyph ); 744 745 par_org_center = parent->org_pos + ( parent->org_len / 2 ); 746 par_cur_center = parent->cur_pos + ( parent->cur_len / 2 ); 747 cur_org_center = hint->org_pos + ( hint->org_len / 2 ); 748 749 cur_delta = FT_MulFix( cur_org_center - par_org_center, scale ); 750 pos = par_cur_center + cur_delta - ( len >> 1 ); 751 } 752 753 /* Stems less than one pixel wide are easy -- we want to 754 * make them as dark as possible, so they must fall within 755 * one pixel. If the stem is split between two pixels 756 * then snap the edge that is nearer to the pixel boundary 757 * to the pixel boundary. 758 */ 759 if ( len <= 64 ) 760 { 761 if ( ( pos + len + 63 ) / 64 != pos / 64 + 1 ) 762 pos += psh_hint_snap_stem_side_delta ( pos, len ); 763 } 764 765 /* Position stems other to minimize the amount of mid-grays. 766 * There are, in general, two positions that do this, 767 * illustrated as A) and B) below. 768 * 769 * + + + + 770 * 771 * A) |--------------------------------| 772 * B) |--------------------------------| 773 * C) |--------------------------------| 774 * 775 * Position A) (split the excess stem equally) should be better 776 * for stems of width N + f where f < 0.5. 777 * 778 * Position B) (split the deficiency equally) should be better 779 * for stems of width N + f where f > 0.5. 780 * 781 * It turns out though that minimizing the total number of lit 782 * pixels is also important, so position C), with one edge 783 * aligned with a pixel boundary is actually preferable 784 * to A). There are also more possibile positions for C) than 785 * for A) or B), so it involves less distortion of the overall 786 * character shape. 787 */ 788 else /* len > 64 */ 789 { 790 FT_Fixed frac_len = len & 63; 791 FT_Fixed center = pos + ( len >> 1 ); 792 FT_Fixed delta_a, delta_b; 793 794 795 if ( ( len / 64 ) & 1 ) 796 { 797 delta_a = FT_PIX_FLOOR( center ) + 32 - center; 798 delta_b = FT_PIX_ROUND( center ) - center; 799 } 800 else 801 { 802 delta_a = FT_PIX_ROUND( center ) - center; 803 delta_b = FT_PIX_FLOOR( center ) + 32 - center; 804 } 805 806 /* We choose between B) and C) above based on the amount 807 * of fractinal stem width; for small amounts, choose 808 * C) always, for large amounts, B) always, and inbetween, 809 * pick whichever one involves less stem movement. 810 */ 811 if ( frac_len < 32 ) 812 { 813 pos += psh_hint_snap_stem_side_delta ( pos, len ); 814 } 815 else if ( frac_len < 48 ) 816 { 817 FT_Fixed side_delta = psh_hint_snap_stem_side_delta ( pos, 818 len ); 819 820 if ( FT_ABS( side_delta ) < FT_ABS( delta_b ) ) 821 pos += side_delta; 822 else 823 pos += delta_b; 824 } 825 else 826 { 827 pos += delta_b; 828 } 829 } 830 831 hint->cur_pos = pos; 832 } 833 } /* switch */ 834 835 psh_hint_set_fitted( hint ); 836 837#ifdef DEBUG_HINTER 838 if ( ps_debug_hint_func ) 839 ps_debug_hint_func( hint, dimension ); 840#endif 841 } 842 } 843 844#endif /* 0 */ 845 846 847 static void 848 psh_hint_table_align_hints( PSH_Hint_Table table, 849 PSH_Globals globals, 850 FT_Int dimension, 851 PSH_Glyph glyph ) 852 { 853 PSH_Hint hint; 854 FT_UInt count; 855 856#ifdef DEBUG_HINTER 857 858 PSH_Dimension dim = &globals->dimension[dimension]; 859 FT_Fixed scale = dim->scale_mult; 860 FT_Fixed delta = dim->scale_delta; 861 862 863 if ( ps_debug_no_vert_hints && dimension == 0 ) 864 { 865 ps_simple_scale( table, scale, delta, dimension ); 866 return; 867 } 868 869 if ( ps_debug_no_horz_hints && dimension == 1 ) 870 { 871 ps_simple_scale( table, scale, delta, dimension ); 872 return; 873 } 874 875#endif /* DEBUG_HINTER*/ 876 877 hint = table->hints; 878 count = table->max_hints; 879 880 for ( ; count > 0; count--, hint++ ) 881 psh_hint_align( hint, globals, dimension, glyph ); 882 } 883 884 885 /*************************************************************************/ 886 /*************************************************************************/ 887 /***** *****/ 888 /***** POINTS INTERPOLATION ROUTINES *****/ 889 /***** *****/ 890 /*************************************************************************/ 891 /*************************************************************************/ 892 893#define PSH_ZONE_MIN -3200000L 894#define PSH_ZONE_MAX +3200000L 895 896#define xxDEBUG_ZONES 897 898 899#ifdef DEBUG_ZONES 900 901#include FT_CONFIG_STANDARD_LIBRARY_H 902 903 static void 904 psh_print_zone( PSH_Zone zone ) 905 { 906 printf( "zone [scale,delta,min,max] = [%.3f,%.3f,%d,%d]\n", 907 zone->scale / 65536.0, 908 zone->delta / 64.0, 909 zone->min, 910 zone->max ); 911 } 912 913#else 914 915#define psh_print_zone( x ) do { } while ( 0 ) 916 917#endif /* DEBUG_ZONES */ 918 919 920 /*************************************************************************/ 921 /*************************************************************************/ 922 /***** *****/ 923 /***** HINTER GLYPH MANAGEMENT *****/ 924 /***** *****/ 925 /*************************************************************************/ 926 /*************************************************************************/ 927 928#if 1 929 930#define psh_corner_is_flat ft_corner_is_flat 931#define psh_corner_orientation ft_corner_orientation 932 933#else 934 935 FT_LOCAL_DEF( FT_Int ) 936 psh_corner_is_flat( FT_Pos x_in, 937 FT_Pos y_in, 938 FT_Pos x_out, 939 FT_Pos y_out ) 940 { 941 FT_Pos ax = x_in; 942 FT_Pos ay = y_in; 943 944 FT_Pos d_in, d_out, d_corner; 945 946 947 if ( ax < 0 ) 948 ax = -ax; 949 if ( ay < 0 ) 950 ay = -ay; 951 d_in = ax + ay; 952 953 ax = x_out; 954 if ( ax < 0 ) 955 ax = -ax; 956 ay = y_out; 957 if ( ay < 0 ) 958 ay = -ay; 959 d_out = ax + ay; 960 961 ax = x_out + x_in; 962 if ( ax < 0 ) 963 ax = -ax; 964 ay = y_out + y_in; 965 if ( ay < 0 ) 966 ay = -ay; 967 d_corner = ax + ay; 968 969 return ( d_in + d_out - d_corner ) < ( d_corner >> 4 ); 970 } 971 972 static FT_Int 973 psh_corner_orientation( FT_Pos in_x, 974 FT_Pos in_y, 975 FT_Pos out_x, 976 FT_Pos out_y ) 977 { 978 FT_Int result; 979 980 981 /* deal with the trivial cases quickly */ 982 if ( in_y == 0 ) 983 { 984 if ( in_x >= 0 ) 985 result = out_y; 986 else 987 result = -out_y; 988 } 989 else if ( in_x == 0 ) 990 { 991 if ( in_y >= 0 ) 992 result = -out_x; 993 else 994 result = out_x; 995 } 996 else if ( out_y == 0 ) 997 { 998 if ( out_x >= 0 ) 999 result = in_y; 1000 else 1001 result = -in_y; 1002 } 1003 else if ( out_x == 0 ) 1004 { 1005 if ( out_y >= 0 ) 1006 result = -in_x; 1007 else 1008 result = in_x; 1009 } 1010 else /* general case */ 1011 { 1012 long long delta = (long long)in_x * out_y - (long long)in_y * out_x; 1013 1014 if ( delta == 0 ) 1015 result = 0; 1016 else 1017 result = 1 - 2 * ( delta < 0 ); 1018 } 1019 1020 return result; 1021 } 1022 1023#endif /* !1 */ 1024 1025 1026#ifdef COMPUTE_INFLEXS 1027 1028 /* compute all inflex points in a given glyph */ 1029 static void 1030 psh_glyph_compute_inflections( PSH_Glyph glyph ) 1031 { 1032 FT_UInt n; 1033 1034 1035 for ( n = 0; n < glyph->num_contours; n++ ) 1036 { 1037 PSH_Point first, start, end, before, after; 1038 FT_Pos in_x, in_y, out_x, out_y; 1039 FT_Int orient_prev, orient_cur; 1040 FT_Int finished = 0; 1041 1042 1043 /* we need at least 4 points to create an inflection point */ 1044 if ( glyph->contours[n].count < 4 ) 1045 continue; 1046 1047 /* compute first segment in contour */ 1048 first = glyph->contours[n].start; 1049 1050 start = end = first; 1051 do 1052 { 1053 end = end->next; 1054 if ( end == first ) 1055 goto Skip; 1056 1057 in_x = end->org_u - start->org_u; 1058 in_y = end->org_v - start->org_v; 1059 1060 } while ( in_x == 0 && in_y == 0 ); 1061 1062 /* extend the segment start whenever possible */ 1063 before = start; 1064 do 1065 { 1066 do 1067 { 1068 start = before; 1069 before = before->prev; 1070 if ( before == first ) 1071 goto Skip; 1072 1073 out_x = start->org_u - before->org_u; 1074 out_y = start->org_v - before->org_v; 1075 1076 } while ( out_x == 0 && out_y == 0 ); 1077 1078 orient_prev = psh_corner_orientation( in_x, in_y, out_x, out_y ); 1079 1080 } while ( orient_prev == 0 ); 1081 1082 first = start; 1083 in_x = out_x; 1084 in_y = out_y; 1085 1086 /* now, process all segments in the contour */ 1087 do 1088 { 1089 /* first, extend current segment's end whenever possible */ 1090 after = end; 1091 do 1092 { 1093 do 1094 { 1095 end = after; 1096 after = after->next; 1097 if ( after == first ) 1098 finished = 1; 1099 1100 out_x = after->org_u - end->org_u; 1101 out_y = after->org_v - end->org_v; 1102 1103 } while ( out_x == 0 && out_y == 0 ); 1104 1105 orient_cur = psh_corner_orientation( in_x, in_y, out_x, out_y ); 1106 1107 } while ( orient_cur == 0 ); 1108 1109 if ( ( orient_cur ^ orient_prev ) < 0 ) 1110 { 1111 do 1112 { 1113 psh_point_set_inflex( start ); 1114 start = start->next; 1115 } 1116 while ( start != end ); 1117 1118 psh_point_set_inflex( start ); 1119 } 1120 1121 start = end; 1122 end = after; 1123 orient_prev = orient_cur; 1124 in_x = out_x; 1125 in_y = out_y; 1126 1127 } while ( !finished ); 1128 1129 Skip: 1130 ; 1131 } 1132 } 1133 1134#endif /* COMPUTE_INFLEXS */ 1135 1136 1137 static void 1138 psh_glyph_done( PSH_Glyph glyph ) 1139 { 1140 FT_Memory memory = glyph->memory; 1141 1142 1143 psh_hint_table_done( &glyph->hint_tables[1], memory ); 1144 psh_hint_table_done( &glyph->hint_tables[0], memory ); 1145 1146 FT_FREE( glyph->points ); 1147 FT_FREE( glyph->contours ); 1148 1149 glyph->num_points = 0; 1150 glyph->num_contours = 0; 1151 1152 glyph->memory = 0; 1153 } 1154 1155 1156 static int 1157 psh_compute_dir( FT_Pos dx, 1158 FT_Pos dy ) 1159 { 1160 FT_Pos ax, ay; 1161 int result = PSH_DIR_NONE; 1162 1163 1164 ax = FT_ABS( dx ); 1165 ay = FT_ABS( dy ); 1166 1167 if ( ay * 12 < ax ) 1168 { 1169 /* |dy| <<< |dx| means a near-horizontal segment */ 1170 result = ( dx >= 0 ) ? PSH_DIR_RIGHT : PSH_DIR_LEFT; 1171 } 1172 else if ( ax * 12 < ay ) 1173 { 1174 /* |dx| <<< |dy| means a near-vertical segment */ 1175 result = ( dy >= 0 ) ? PSH_DIR_UP : PSH_DIR_DOWN; 1176 } 1177 1178 return result; 1179 } 1180 1181 1182 /* load outline point coordinates into hinter glyph */ 1183 static void 1184 psh_glyph_load_points( PSH_Glyph glyph, 1185 FT_Int dimension ) 1186 { 1187 FT_Vector* vec = glyph->outline->points; 1188 PSH_Point point = glyph->points; 1189 FT_UInt count = glyph->num_points; 1190 1191 1192 for ( ; count > 0; count--, point++, vec++ ) 1193 { 1194 point->flags2 = 0; 1195 point->hint = NULL; 1196 if ( dimension == 0 ) 1197 { 1198 point->org_u = vec->x; 1199 point->org_v = vec->y; 1200 } 1201 else 1202 { 1203 point->org_u = vec->y; 1204 point->org_v = vec->x; 1205 } 1206 1207#ifdef DEBUG_HINTER 1208 point->org_x = vec->x; 1209 point->org_y = vec->y; 1210#endif 1211 1212 } 1213 } 1214 1215 1216 /* save hinted point coordinates back to outline */ 1217 static void 1218 psh_glyph_save_points( PSH_Glyph glyph, 1219 FT_Int dimension ) 1220 { 1221 FT_UInt n; 1222 PSH_Point point = glyph->points; 1223 FT_Vector* vec = glyph->outline->points; 1224 char* tags = glyph->outline->tags; 1225 1226 1227 for ( n = 0; n < glyph->num_points; n++ ) 1228 { 1229 if ( dimension == 0 ) 1230 vec[n].x = point->cur_u; 1231 else 1232 vec[n].y = point->cur_u; 1233 1234 if ( psh_point_is_strong( point ) ) 1235 tags[n] |= (char)( ( dimension == 0 ) ? 32 : 64 ); 1236 1237#ifdef DEBUG_HINTER 1238 1239 if ( dimension == 0 ) 1240 { 1241 point->cur_x = point->cur_u; 1242 point->flags_x = point->flags2 | point->flags; 1243 } 1244 else 1245 { 1246 point->cur_y = point->cur_u; 1247 point->flags_y = point->flags2 | point->flags; 1248 } 1249 1250#endif 1251 1252 point++; 1253 } 1254 } 1255 1256 1257 static FT_Error 1258 psh_glyph_init( PSH_Glyph glyph, 1259 FT_Outline* outline, 1260 PS_Hints ps_hints, 1261 PSH_Globals globals ) 1262 { 1263 FT_Error error; 1264 FT_Memory memory; 1265 1266 1267 /* clear all fields */ 1268 FT_MEM_ZERO( glyph, sizeof ( *glyph ) ); 1269 1270 memory = glyph->memory = globals->memory; 1271 1272 /* allocate and setup points + contours arrays */ 1273 if ( FT_NEW_ARRAY( glyph->points, outline->n_points ) || 1274 FT_NEW_ARRAY( glyph->contours, outline->n_contours ) ) 1275 goto Exit; 1276 1277 glyph->num_points = outline->n_points; 1278 glyph->num_contours = outline->n_contours; 1279 1280 { 1281 FT_UInt first = 0, next, n; 1282 PSH_Point points = glyph->points; 1283 PSH_Contour contour = glyph->contours; 1284 1285 1286 for ( n = 0; n < glyph->num_contours; n++ ) 1287 { 1288 FT_Int count; 1289 PSH_Point point; 1290 1291 1292 next = outline->contours[n] + 1; 1293 count = next - first; 1294 1295 contour->start = points + first; 1296 contour->count = (FT_UInt)count; 1297 1298 if ( count > 0 ) 1299 { 1300 point = points + first; 1301 1302 point->prev = points + next - 1; 1303 point->contour = contour; 1304 1305 for ( ; count > 1; count-- ) 1306 { 1307 point[0].next = point + 1; 1308 point[1].prev = point; 1309 point++; 1310 point->contour = contour; 1311 } 1312 point->next = points + first; 1313 } 1314 1315 contour++; 1316 first = next; 1317 } 1318 } 1319 1320 { 1321 PSH_Point points = glyph->points; 1322 PSH_Point point = points; 1323 FT_Vector* vec = outline->points; 1324 FT_UInt n; 1325 1326 1327 for ( n = 0; n < glyph->num_points; n++, point++ ) 1328 { 1329 FT_Int n_prev = (FT_Int)( point->prev - points ); 1330 FT_Int n_next = (FT_Int)( point->next - points ); 1331 FT_Pos dxi, dyi, dxo, dyo; 1332 1333 1334 if ( !( outline->tags[n] & FT_CURVE_TAG_ON ) ) 1335 point->flags = PSH_POINT_OFF; 1336 1337 dxi = vec[n].x - vec[n_prev].x; 1338 dyi = vec[n].y - vec[n_prev].y; 1339 1340 point->dir_in = (FT_Char)psh_compute_dir( dxi, dyi ); 1341 1342 dxo = vec[n_next].x - vec[n].x; 1343 dyo = vec[n_next].y - vec[n].y; 1344 1345 point->dir_out = (FT_Char)psh_compute_dir( dxo, dyo ); 1346 1347 /* detect smooth points */ 1348 if ( point->flags & PSH_POINT_OFF ) 1349 point->flags |= PSH_POINT_SMOOTH; 1350 1351 else if ( point->dir_in == point->dir_out ) 1352 { 1353 if ( point->dir_out != PSH_DIR_NONE || 1354 psh_corner_is_flat( dxi, dyi, dxo, dyo ) ) 1355 point->flags |= PSH_POINT_SMOOTH; 1356 } 1357 } 1358 } 1359 1360 glyph->outline = outline; 1361 glyph->globals = globals; 1362 1363#ifdef COMPUTE_INFLEXS 1364 psh_glyph_load_points( glyph, 0 ); 1365 psh_glyph_compute_inflections( glyph ); 1366#endif /* COMPUTE_INFLEXS */ 1367 1368 /* now deal with hints tables */ 1369 error = psh_hint_table_init( &glyph->hint_tables [0], 1370 &ps_hints->dimension[0].hints, 1371 &ps_hints->dimension[0].masks, 1372 &ps_hints->dimension[0].counters, 1373 memory ); 1374 if ( error ) 1375 goto Exit; 1376 1377 error = psh_hint_table_init( &glyph->hint_tables [1], 1378 &ps_hints->dimension[1].hints, 1379 &ps_hints->dimension[1].masks, 1380 &ps_hints->dimension[1].counters, 1381 memory ); 1382 if ( error ) 1383 goto Exit; 1384 1385 Exit: 1386 return error; 1387 } 1388 1389 1390 /* compute all extrema in a glyph for a given dimension */ 1391 static void 1392 psh_glyph_compute_extrema( PSH_Glyph glyph ) 1393 { 1394 FT_UInt n; 1395 1396 1397 /* first of all, compute all local extrema */ 1398 for ( n = 0; n < glyph->num_contours; n++ ) 1399 { 1400 PSH_Point first = glyph->contours[n].start; 1401 PSH_Point point, before, after; 1402 1403 1404 if ( glyph->contours[n].count == 0 ) 1405 continue; 1406 1407 point = first; 1408 before = point; 1409 after = point; 1410 1411 do 1412 { 1413 before = before->prev; 1414 if ( before == first ) 1415 goto Skip; 1416 1417 } while ( before->org_u == point->org_u ); 1418 1419 first = point = before->next; 1420 1421 for (;;) 1422 { 1423 after = point; 1424 do 1425 { 1426 after = after->next; 1427 if ( after == first ) 1428 goto Next; 1429 1430 } while ( after->org_u == point->org_u ); 1431 1432 if ( before->org_u < point->org_u ) 1433 { 1434 if ( after->org_u < point->org_u ) 1435 { 1436 /* local maximum */ 1437 goto Extremum; 1438 } 1439 } 1440 else /* before->org_u > point->org_u */ 1441 { 1442 if ( after->org_u > point->org_u ) 1443 { 1444 /* local minimum */ 1445 Extremum: 1446 do 1447 { 1448 psh_point_set_extremum( point ); 1449 point = point->next; 1450 1451 } while ( point != after ); 1452 } 1453 } 1454 1455 before = after->prev; 1456 point = after; 1457 1458 } /* for */ 1459 1460 Next: 1461 ; 1462 } 1463 1464 /* for each extremum, determine its direction along the */ 1465 /* orthogonal axis */ 1466 for ( n = 0; n < glyph->num_points; n++ ) 1467 { 1468 PSH_Point point, before, after; 1469 1470 1471 point = &glyph->points[n]; 1472 before = point; 1473 after = point; 1474 1475 if ( psh_point_is_extremum( point ) ) 1476 { 1477 do 1478 { 1479 before = before->prev; 1480 if ( before == point ) 1481 goto Skip; 1482 1483 } while ( before->org_v == point->org_v ); 1484 1485 do 1486 { 1487 after = after->next; 1488 if ( after == point ) 1489 goto Skip; 1490 1491 } while ( after->org_v == point->org_v ); 1492 } 1493 1494 if ( before->org_v < point->org_v && 1495 after->org_v > point->org_v ) 1496 { 1497 psh_point_set_positive( point ); 1498 } 1499 else if ( before->org_v > point->org_v && 1500 after->org_v < point->org_v ) 1501 { 1502 psh_point_set_negative( point ); 1503 } 1504 1505 Skip: 1506 ; 1507 } 1508 } 1509 1510 1511 /* major_dir is the direction for points on the bottom/left of the stem; */ 1512 /* Points on the top/right of the stem will have a direction of */ 1513 /* -major_dir. */ 1514 1515 static void 1516 psh_hint_table_find_strong_points( PSH_Hint_Table table, 1517 PSH_Point point, 1518 FT_UInt count, 1519 FT_Int threshold, 1520 FT_Int major_dir ) 1521 { 1522 PSH_Hint* sort = table->sort; 1523 FT_UInt num_hints = table->num_hints; 1524 1525 1526 for ( ; count > 0; count--, point++ ) 1527 { 1528 FT_Int point_dir = 0; 1529 FT_Pos org_u = point->org_u; 1530 1531 1532 if ( psh_point_is_strong( point ) ) 1533 continue; 1534 1535 if ( PSH_DIR_COMPARE( point->dir_in, major_dir ) ) 1536 point_dir = point->dir_in; 1537 1538 else if ( PSH_DIR_COMPARE( point->dir_out, major_dir ) ) 1539 point_dir = point->dir_out; 1540 1541 if ( point_dir ) 1542 { 1543 if ( point_dir == major_dir ) 1544 { 1545 FT_UInt nn; 1546 1547 1548 for ( nn = 0; nn < num_hints; nn++ ) 1549 { 1550 PSH_Hint hint = sort[nn]; 1551 FT_Pos d = org_u - hint->org_pos; 1552 1553 1554 if ( d < threshold && -d < threshold ) 1555 { 1556 psh_point_set_strong( point ); 1557 point->flags2 |= PSH_POINT_EDGE_MIN; 1558 point->hint = hint; 1559 break; 1560 } 1561 } 1562 } 1563 else if ( point_dir == -major_dir ) 1564 { 1565 FT_UInt nn; 1566 1567 1568 for ( nn = 0; nn < num_hints; nn++ ) 1569 { 1570 PSH_Hint hint = sort[nn]; 1571 FT_Pos d = org_u - hint->org_pos - hint->org_len; 1572 1573 1574 if ( d < threshold && -d < threshold ) 1575 { 1576 psh_point_set_strong( point ); 1577 point->flags2 |= PSH_POINT_EDGE_MAX; 1578 point->hint = hint; 1579 break; 1580 } 1581 } 1582 } 1583 } 1584 1585#if 1 1586 else if ( psh_point_is_extremum( point ) ) 1587 { 1588 /* treat extrema as special cases for stem edge alignment */ 1589 FT_UInt nn, min_flag, max_flag; 1590 1591 1592 if ( major_dir == PSH_DIR_HORIZONTAL ) 1593 { 1594 min_flag = PSH_POINT_POSITIVE; 1595 max_flag = PSH_POINT_NEGATIVE; 1596 } 1597 else 1598 { 1599 min_flag = PSH_POINT_NEGATIVE; 1600 max_flag = PSH_POINT_POSITIVE; 1601 } 1602 1603 if ( point->flags2 & min_flag ) 1604 { 1605 for ( nn = 0; nn < num_hints; nn++ ) 1606 { 1607 PSH_Hint hint = sort[nn]; 1608 FT_Pos d = org_u - hint->org_pos; 1609 1610 1611 if ( d < threshold && -d < threshold ) 1612 { 1613 point->flags2 |= PSH_POINT_EDGE_MIN; 1614 point->hint = hint; 1615 psh_point_set_strong( point ); 1616 break; 1617 } 1618 } 1619 } 1620 else if ( point->flags2 & max_flag ) 1621 { 1622 for ( nn = 0; nn < num_hints; nn++ ) 1623 { 1624 PSH_Hint hint = sort[nn]; 1625 FT_Pos d = org_u - hint->org_pos - hint->org_len; 1626 1627 1628 if ( d < threshold && -d < threshold ) 1629 { 1630 point->flags2 |= PSH_POINT_EDGE_MAX; 1631 point->hint = hint; 1632 psh_point_set_strong( point ); 1633 break; 1634 } 1635 } 1636 } 1637 1638 if ( point->hint == NULL ) 1639 { 1640 for ( nn = 0; nn < num_hints; nn++ ) 1641 { 1642 PSH_Hint hint = sort[nn]; 1643 1644 1645 if ( org_u >= hint->org_pos && 1646 org_u <= hint->org_pos + hint->org_len ) 1647 { 1648 point->hint = hint; 1649 break; 1650 } 1651 } 1652 } 1653 } 1654 1655#endif /* 1 */ 1656 } 1657 } 1658 1659 1660 /* the accepted shift for strong points in fractional pixels */ 1661#define PSH_STRONG_THRESHOLD 32 1662 1663 /* the maximum shift value in font units */ 1664#define PSH_STRONG_THRESHOLD_MAXIMUM 30 1665 1666 1667 /* find strong points in a glyph */ 1668 static void 1669 psh_glyph_find_strong_points( PSH_Glyph glyph, 1670 FT_Int dimension ) 1671 { 1672 /* a point is `strong' if it is located on a stem edge and */ 1673 /* has an `in' or `out' tangent parallel to the hint's direction */ 1674 1675 PSH_Hint_Table table = &glyph->hint_tables[dimension]; 1676 PS_Mask mask = table->hint_masks->masks; 1677 FT_UInt num_masks = table->hint_masks->num_masks; 1678 FT_UInt first = 0; 1679 FT_Int major_dir = dimension == 0 ? PSH_DIR_VERTICAL 1680 : PSH_DIR_HORIZONTAL; 1681 PSH_Dimension dim = &glyph->globals->dimension[dimension]; 1682 FT_Fixed scale = dim->scale_mult; 1683 FT_Int threshold; 1684 1685 1686 threshold = (FT_Int)FT_DivFix( PSH_STRONG_THRESHOLD, scale ); 1687 if ( threshold > PSH_STRONG_THRESHOLD_MAXIMUM ) 1688 threshold = PSH_STRONG_THRESHOLD_MAXIMUM; 1689 1690 /* process secondary hints to `selected' points */ 1691 if ( num_masks > 1 && glyph->num_points > 0 ) 1692 { 1693 /* the `endchar' op can reduce the number of points */ 1694 first = mask->end_point > glyph->num_points 1695 ? glyph->num_points 1696 : mask->end_point; 1697 mask++; 1698 for ( ; num_masks > 1; num_masks--, mask++ ) 1699 { 1700 FT_UInt next; 1701 FT_Int count; 1702 1703 1704 next = mask->end_point > glyph->num_points 1705 ? glyph->num_points 1706 : mask->end_point; 1707 count = next - first; 1708 if ( count > 0 ) 1709 { 1710 PSH_Point point = glyph->points + first; 1711 1712 1713 psh_hint_table_activate_mask( table, mask ); 1714 1715 psh_hint_table_find_strong_points( table, point, count, 1716 threshold, major_dir ); 1717 } 1718 first = next; 1719 } 1720 } 1721 1722 /* process primary hints for all points */ 1723 if ( num_masks == 1 ) 1724 { 1725 FT_UInt count = glyph->num_points; 1726 PSH_Point point = glyph->points; 1727 1728 1729 psh_hint_table_activate_mask( table, table->hint_masks->masks ); 1730 1731 psh_hint_table_find_strong_points( table, point, count, 1732 threshold, major_dir ); 1733 } 1734 1735 /* now, certain points may have been attached to a hint and */ 1736 /* not marked as strong; update their flags then */ 1737 { 1738 FT_UInt count = glyph->num_points; 1739 PSH_Point point = glyph->points; 1740 1741 1742 for ( ; count > 0; count--, point++ ) 1743 if ( point->hint && !psh_point_is_strong( point ) ) 1744 psh_point_set_strong( point ); 1745 } 1746 } 1747 1748 1749 /* find points in a glyph which are in a blue zone and have `in' or */ 1750 /* `out' tangents parallel to the horizontal axis */ 1751 static void 1752 psh_glyph_find_blue_points( PSH_Blues blues, 1753 PSH_Glyph glyph ) 1754 { 1755 PSH_Blue_Table table; 1756 PSH_Blue_Zone zone; 1757 FT_UInt glyph_count = glyph->num_points; 1758 FT_UInt blue_count; 1759 PSH_Point point = glyph->points; 1760 1761 1762 for ( ; glyph_count > 0; glyph_count--, point++ ) 1763 { 1764 FT_Pos y; 1765 1766 1767 /* check tangents */ 1768 if ( !PSH_DIR_COMPARE( point->dir_in, PSH_DIR_HORIZONTAL ) && 1769 !PSH_DIR_COMPARE( point->dir_out, PSH_DIR_HORIZONTAL ) ) 1770 continue; 1771 1772 /* skip strong points */ 1773 if ( psh_point_is_strong( point ) ) 1774 continue; 1775 1776 y = point->org_u; 1777 1778 /* look up top zones */ 1779 table = &blues->normal_top; 1780 blue_count = table->count; 1781 zone = table->zones; 1782 1783 for ( ; blue_count > 0; blue_count--, zone++ ) 1784 { 1785 FT_Pos delta = y - zone->org_bottom; 1786 1787 1788 if ( delta < -blues->blue_fuzz ) 1789 break; 1790 1791 if ( y <= zone->org_top + blues->blue_fuzz ) 1792 if ( blues->no_overshoots || delta <= blues->blue_threshold ) 1793 { 1794 point->cur_u = zone->cur_bottom; 1795 psh_point_set_strong( point ); 1796 psh_point_set_fitted( point ); 1797 } 1798 } 1799 1800 /* look up bottom zones */ 1801 table = &blues->normal_bottom; 1802 blue_count = table->count; 1803 zone = table->zones + blue_count - 1; 1804 1805 for ( ; blue_count > 0; blue_count--, zone-- ) 1806 { 1807 FT_Pos delta = zone->org_top - y; 1808 1809 1810 if ( delta < -blues->blue_fuzz ) 1811 break; 1812 1813 if ( y >= zone->org_bottom - blues->blue_fuzz ) 1814 if ( blues->no_overshoots || delta < blues->blue_threshold ) 1815 { 1816 point->cur_u = zone->cur_top; 1817 psh_point_set_strong( point ); 1818 psh_point_set_fitted( point ); 1819 } 1820 } 1821 } 1822 } 1823 1824 1825 /* interpolate strong points with the help of hinted coordinates */ 1826 static void 1827 psh_glyph_interpolate_strong_points( PSH_Glyph glyph, 1828 FT_Int dimension ) 1829 { 1830 PSH_Dimension dim = &glyph->globals->dimension[dimension]; 1831 FT_Fixed scale = dim->scale_mult; 1832 1833 FT_UInt count = glyph->num_points; 1834 PSH_Point point = glyph->points; 1835 1836 1837 for ( ; count > 0; count--, point++ ) 1838 { 1839 PSH_Hint hint = point->hint; 1840 1841 1842 if ( hint ) 1843 { 1844 FT_Pos delta; 1845 1846 1847 if ( psh_point_is_edge_min( point ) ) 1848 point->cur_u = hint->cur_pos; 1849 1850 else if ( psh_point_is_edge_max( point ) ) 1851 point->cur_u = hint->cur_pos + hint->cur_len; 1852 1853 else 1854 { 1855 delta = point->org_u - hint->org_pos; 1856 1857 if ( delta <= 0 ) 1858 point->cur_u = hint->cur_pos + FT_MulFix( delta, scale ); 1859 1860 else if ( delta >= hint->org_len ) 1861 point->cur_u = hint->cur_pos + hint->cur_len + 1862 FT_MulFix( delta - hint->org_len, scale ); 1863 1864 else /* hint->org_len > 0 */ 1865 point->cur_u = hint->cur_pos + 1866 FT_MulDiv( delta, hint->cur_len, 1867 hint->org_len ); 1868 } 1869 psh_point_set_fitted( point ); 1870 } 1871 } 1872 } 1873 1874 1875#define PSH_MAX_STRONG_INTERNAL 16 1876 1877 static void 1878 psh_glyph_interpolate_normal_points( PSH_Glyph glyph, 1879 FT_Int dimension ) 1880 { 1881 1882#if 1 1883 /* first technique: a point is strong if it is a local extremum */ 1884 1885 PSH_Dimension dim = &glyph->globals->dimension[dimension]; 1886 FT_Fixed scale = dim->scale_mult; 1887 FT_Memory memory = glyph->memory; 1888 1889 PSH_Point* strongs = NULL; 1890 PSH_Point strongs_0[PSH_MAX_STRONG_INTERNAL]; 1891 FT_UInt num_strongs = 0; 1892 1893 PSH_Point points = glyph->points; 1894 PSH_Point points_end = points + glyph->num_points; 1895 PSH_Point point; 1896 1897 1898 /* first count the number of strong points */ 1899 for ( point = points; point < points_end; point++ ) 1900 { 1901 if ( psh_point_is_strong( point ) ) 1902 num_strongs++; 1903 } 1904 1905 if ( num_strongs == 0 ) /* nothing to do here */ 1906 return; 1907 1908 /* allocate an array to store a list of points, */ 1909 /* stored in increasing org_u order */ 1910 if ( num_strongs <= PSH_MAX_STRONG_INTERNAL ) 1911 strongs = strongs_0; 1912 else 1913 { 1914 FT_Error error; 1915 1916 1917 if ( FT_NEW_ARRAY( strongs, num_strongs ) ) 1918 return; 1919 } 1920 1921 num_strongs = 0; 1922 for ( point = points; point < points_end; point++ ) 1923 { 1924 PSH_Point* insert; 1925 1926 1927 if ( !psh_point_is_strong( point ) ) 1928 continue; 1929 1930 for ( insert = strongs + num_strongs; insert > strongs; insert-- ) 1931 { 1932 if ( insert[-1]->org_u <= point->org_u ) 1933 break; 1934 1935 insert[0] = insert[-1]; 1936 } 1937 insert[0] = point; 1938 num_strongs++; 1939 } 1940 1941 /* now try to interpolate all normal points */ 1942 for ( point = points; point < points_end; point++ ) 1943 { 1944 if ( psh_point_is_strong( point ) ) 1945 continue; 1946 1947 /* sometimes, some local extrema are smooth points */ 1948 if ( psh_point_is_smooth( point ) ) 1949 { 1950 if ( point->dir_in == PSH_DIR_NONE || 1951 point->dir_in != point->dir_out ) 1952 continue; 1953 1954 if ( !psh_point_is_extremum( point ) && 1955 !psh_point_is_inflex( point ) ) 1956 continue; 1957 1958 point->flags &= ~PSH_POINT_SMOOTH; 1959 } 1960 1961 /* find best enclosing point coordinates then interpolate */ 1962 { 1963 PSH_Point before, after; 1964 FT_UInt nn; 1965 1966 1967 for ( nn = 0; nn < num_strongs; nn++ ) 1968 if ( strongs[nn]->org_u > point->org_u ) 1969 break; 1970 1971 if ( nn == 0 ) /* point before the first strong point */ 1972 { 1973 after = strongs[0]; 1974 1975 point->cur_u = after->cur_u + 1976 FT_MulFix( point->org_u - after->org_u, 1977 scale ); 1978 } 1979 else 1980 { 1981 before = strongs[nn - 1]; 1982 1983 for ( nn = num_strongs; nn > 0; nn-- ) 1984 if ( strongs[nn - 1]->org_u < point->org_u ) 1985 break; 1986 1987 if ( nn == num_strongs ) /* point is after last strong point */ 1988 { 1989 before = strongs[nn - 1]; 1990 1991 point->cur_u = before->cur_u + 1992 FT_MulFix( point->org_u - before->org_u, 1993 scale ); 1994 } 1995 else 1996 { 1997 FT_Pos u; 1998 1999 2000 after = strongs[nn]; 2001 2002 /* now interpolate point between before and after */ 2003 u = point->org_u; 2004 2005 if ( u == before->org_u ) 2006 point->cur_u = before->cur_u; 2007 2008 else if ( u == after->org_u ) 2009 point->cur_u = after->cur_u; 2010 2011 else 2012 point->cur_u = before->cur_u + 2013 FT_MulDiv( u - before->org_u, 2014 after->cur_u - before->cur_u, 2015 after->org_u - before->org_u ); 2016 } 2017 } 2018 psh_point_set_fitted( point ); 2019 } 2020 } 2021 2022 if ( strongs != strongs_0 ) 2023 FT_FREE( strongs ); 2024 2025#endif /* 1 */ 2026 2027 } 2028 2029 2030 /* interpolate other points */ 2031 static void 2032 psh_glyph_interpolate_other_points( PSH_Glyph glyph, 2033 FT_Int dimension ) 2034 { 2035 PSH_Dimension dim = &glyph->globals->dimension[dimension]; 2036 FT_Fixed scale = dim->scale_mult; 2037 FT_Fixed delta = dim->scale_delta; 2038 PSH_Contour contour = glyph->contours; 2039 FT_UInt num_contours = glyph->num_contours; 2040 2041 2042 for ( ; num_contours > 0; num_contours--, contour++ ) 2043 { 2044 PSH_Point start = contour->start; 2045 PSH_Point first, next, point; 2046 FT_UInt fit_count; 2047 2048 2049 /* count the number of strong points in this contour */ 2050 next = start + contour->count; 2051 fit_count = 0; 2052 first = 0; 2053 2054 for ( point = start; point < next; point++ ) 2055 if ( psh_point_is_fitted( point ) ) 2056 { 2057 if ( !first ) 2058 first = point; 2059 2060 fit_count++; 2061 } 2062 2063 /* if there are less than 2 fitted points in the contour, we */ 2064 /* simply scale and eventually translate the contour points */ 2065 if ( fit_count < 2 ) 2066 { 2067 if ( fit_count == 1 ) 2068 delta = first->cur_u - FT_MulFix( first->org_u, scale ); 2069 2070 for ( point = start; point < next; point++ ) 2071 if ( point != first ) 2072 point->cur_u = FT_MulFix( point->org_u, scale ) + delta; 2073 2074 goto Next_Contour; 2075 } 2076 2077 /* there are more than 2 strong points in this contour; we */ 2078 /* need to interpolate weak points between them */ 2079 start = first; 2080 do 2081 { 2082 point = first; 2083 2084 /* skip consecutive fitted points */ 2085 for (;;) 2086 { 2087 next = first->next; 2088 if ( next == start ) 2089 goto Next_Contour; 2090 2091 if ( !psh_point_is_fitted( next ) ) 2092 break; 2093 2094 first = next; 2095 } 2096 2097 /* find next fitted point after unfitted one */ 2098 for (;;) 2099 { 2100 next = next->next; 2101 if ( psh_point_is_fitted( next ) ) 2102 break; 2103 } 2104 2105 /* now interpolate between them */ 2106 { 2107 FT_Pos org_a, org_ab, cur_a, cur_ab; 2108 FT_Pos org_c, org_ac, cur_c; 2109 FT_Fixed scale_ab; 2110 2111 2112 if ( first->org_u <= next->org_u ) 2113 { 2114 org_a = first->org_u; 2115 cur_a = first->cur_u; 2116 org_ab = next->org_u - org_a; 2117 cur_ab = next->cur_u - cur_a; 2118 } 2119 else 2120 { 2121 org_a = next->org_u; 2122 cur_a = next->cur_u; 2123 org_ab = first->org_u - org_a; 2124 cur_ab = first->cur_u - cur_a; 2125 } 2126 2127 scale_ab = 0x10000L; 2128 if ( org_ab > 0 ) 2129 scale_ab = FT_DivFix( cur_ab, org_ab ); 2130 2131 point = first->next; 2132 do 2133 { 2134 org_c = point->org_u; 2135 org_ac = org_c - org_a; 2136 2137 if ( org_ac <= 0 ) 2138 { 2139 /* on the left of the interpolation zone */ 2140 cur_c = cur_a + FT_MulFix( org_ac, scale ); 2141 } 2142 else if ( org_ac >= org_ab ) 2143 { 2144 /* on the right on the interpolation zone */ 2145 cur_c = cur_a + cur_ab + FT_MulFix( org_ac - org_ab, scale ); 2146 } 2147 else 2148 { 2149 /* within the interpolation zone */ 2150 cur_c = cur_a + FT_MulFix( org_ac, scale_ab ); 2151 } 2152 2153 point->cur_u = cur_c; 2154 2155 point = point->next; 2156 2157 } while ( point != next ); 2158 } 2159 2160 /* keep going until all points in the contours have been processed */ 2161 first = next; 2162 2163 } while ( first != start ); 2164 2165 Next_Contour: 2166 ; 2167 } 2168 } 2169 2170 2171 /*************************************************************************/ 2172 /*************************************************************************/ 2173 /***** *****/ 2174 /***** HIGH-LEVEL INTERFACE *****/ 2175 /***** *****/ 2176 /*************************************************************************/ 2177 /*************************************************************************/ 2178 2179 FT_Error 2180 ps_hints_apply( PS_Hints ps_hints, 2181 FT_Outline* outline, 2182 PSH_Globals globals, 2183 FT_Render_Mode hint_mode ) 2184 { 2185 PSH_GlyphRec glyphrec; 2186 PSH_Glyph glyph = &glyphrec; 2187 FT_Error error; 2188#ifdef DEBUG_HINTER 2189 FT_Memory memory; 2190#endif 2191 FT_Int dimension; 2192 2193 2194 /* something to do? */ 2195 if ( outline->n_points == 0 || outline->n_contours == 0 ) 2196 return FT_Err_Ok; 2197 2198#ifdef DEBUG_HINTER 2199 2200 memory = globals->memory; 2201 2202 if ( ps_debug_glyph ) 2203 { 2204 psh_glyph_done( ps_debug_glyph ); 2205 FT_FREE( ps_debug_glyph ); 2206 } 2207 2208 if ( FT_NEW( glyph ) ) 2209 return error; 2210 2211 ps_debug_glyph = glyph; 2212 2213#endif /* DEBUG_HINTER */ 2214 2215 error = psh_glyph_init( glyph, outline, ps_hints, globals ); 2216 if ( error ) 2217 goto Exit; 2218 2219 /* try to optimize the y_scale so that the top of non-capital letters 2220 * is aligned on a pixel boundary whenever possible 2221 */ 2222 { 2223 PSH_Dimension dim_x = &glyph->globals->dimension[0]; 2224 PSH_Dimension dim_y = &glyph->globals->dimension[1]; 2225 2226 FT_Fixed x_scale = dim_x->scale_mult; 2227 FT_Fixed y_scale = dim_y->scale_mult; 2228 2229 FT_Fixed old_x_scale = x_scale; 2230 FT_Fixed old_y_scale = y_scale; 2231 2232 FT_Fixed scaled; 2233 FT_Fixed fitted; 2234 2235 FT_Bool rescale = FALSE; 2236 2237 2238 scaled = FT_MulFix( globals->blues.normal_top.zones->org_ref, y_scale ); 2239 fitted = FT_PIX_ROUND( scaled ); 2240 2241 if ( fitted != 0 && scaled != fitted ) 2242 { 2243 rescale = TRUE; 2244 2245 y_scale = FT_MulDiv( y_scale, fitted, scaled ); 2246 2247 if ( fitted < scaled ) 2248 x_scale -= x_scale / 50; 2249 2250 psh_globals_set_scale( glyph->globals, x_scale, y_scale, 0, 0 ); 2251 } 2252 2253 glyph->do_horz_hints = 1; 2254 glyph->do_vert_hints = 1; 2255 2256 glyph->do_horz_snapping = FT_BOOL( hint_mode == FT_RENDER_MODE_MONO || 2257 hint_mode == FT_RENDER_MODE_LCD ); 2258 2259 glyph->do_vert_snapping = FT_BOOL( hint_mode == FT_RENDER_MODE_MONO || 2260 hint_mode == FT_RENDER_MODE_LCD_V ); 2261 2262 glyph->do_stem_adjust = FT_BOOL( hint_mode != FT_RENDER_MODE_LIGHT ); 2263 2264 for ( dimension = 0; dimension < 2; dimension++ ) 2265 { 2266 /* load outline coordinates into glyph */ 2267 psh_glyph_load_points( glyph, dimension ); 2268 2269 /* compute local extrema */ 2270 psh_glyph_compute_extrema( glyph ); 2271 2272 /* compute aligned stem/hints positions */ 2273 psh_hint_table_align_hints( &glyph->hint_tables[dimension], 2274 glyph->globals, 2275 dimension, 2276 glyph ); 2277 2278 /* find strong points, align them, then interpolate others */ 2279 psh_glyph_find_strong_points( glyph, dimension ); 2280 if ( dimension == 1 ) 2281 psh_glyph_find_blue_points( &globals->blues, glyph ); 2282 psh_glyph_interpolate_strong_points( glyph, dimension ); 2283 psh_glyph_interpolate_normal_points( glyph, dimension ); 2284 psh_glyph_interpolate_other_points( glyph, dimension ); 2285 2286 /* save hinted coordinates back to outline */ 2287 psh_glyph_save_points( glyph, dimension ); 2288 2289 if ( rescale ) 2290 psh_globals_set_scale( glyph->globals, 2291 old_x_scale, old_y_scale, 0, 0 ); 2292 } 2293 } 2294 2295 Exit: 2296 2297#ifndef DEBUG_HINTER 2298 psh_glyph_done( glyph ); 2299#endif 2300 2301 return error; 2302 } 2303 2304 2305/* END */ 2306