lib/talatin.c

   1 /* talatin.c */
   2
   3 /*
   4  * Copyright (C) 2011-2014 by Werner Lemberg.
   5  *
   6  * This file is part of the ttfautohint library, and may only be used,
   7  * modified, and distributed under the terms given in `COPYING'.  By
   8  * continuing to use, modify, or distribute this file you indicate that you
   9  * have read `COPYING' and understand and accept it fully.
  10  *
  11  * The file `COPYING' mentioned in the previous paragraph is distributed
  12  * with the ttfautohint library.
  13  */
  14
  15
  16 /* originally file `aflatin.c' (2011-Mar-28) from FreeType */
  17
  18 /* heavily modified 2011 by Werner Lemberg <wl@gnu.org> */
  19
  20 #include <string.h>
  21
  22 #include <ft2build.h>
  23 #include FT_ADVANCES_H
  24 #include FT_TRUETYPE_TABLES_H
  25
  26 #include "taglobal.h"
  27 #include "talatin.h"
  28 #include "tasort.h"
  29
  30
  31 #ifdef TA_CONFIG_OPTION_USE_WARPER
  32 #include "tawarp.h"
  33 #endif
  34
  35 #include <numberset.h>
  36
  37
  38 /* find segments and links, compute all stem widths, and initialize */
  39 /* standard width and height for the glyph with given charcode */
  40
  41 void
  42 ta_latin_metrics_init_widths(TA_LatinMetrics metrics,
  43                              FT_Face face,
  44                              FT_Bool use_cmap)
  45 {
  46   /* scan the array of segments in each direction */
  47   TA_GlyphHintsRec hints[1];
  48
  49
  50   TA_LOG_GLOBAL(("\n"
  51                  "latin standard widths computation (style `%s')\n"
  52                  "=====================================================\n"
  53                  "\n",
  54                  ta_style_names[metrics->root.style_class->style]));
  55
  56   ta_glyph_hints_init(hints);
  57
  58   metrics->axis[TA_DIMENSION_HORZ].width_count = 0;
  59   metrics->axis[TA_DIMENSION_VERT].width_count = 0;
  60
  61   {
  62     FT_Error error;
  63     FT_ULong glyph_index;
  64     FT_Long y_offset;
  65     int dim;
  66     TA_LatinMetricsRec dummy[1];
  67     TA_Scaler scaler = &dummy->root.scaler;
  68
  69     TA_StyleClass style_class = metrics->root.style_class;
  70     TA_ScriptClass script_class = ta_script_classes[style_class->script];
  71
  72     FT_UInt32 standard_char;
  73
  74
  75     if (!use_cmap)
  76       goto Exit;
  77
  78     /*
  79      * We check more than a single standard character to catch features
  80      * like `c2sc' (small caps from caps) that don't contain lowercase
  81      * letters by definition, or other features that mainly operate on
  82      * numerals.
  83      */
  84     standard_char = script_class->standard_char1;
  85     ta_get_char_index(&metrics->root,
  86                       standard_char,
  87                       &glyph_index,
  88                       &y_offset);
  89     if (!glyph_index)
  90     {
  91       if (script_class->standard_char2)
  92       {
  93         standard_char = script_class->standard_char2;
  94         ta_get_char_index(&metrics->root,
  95                           standard_char,
  96                           &glyph_index,
  97                           &y_offset);
  98         if (!glyph_index)
  99         {
 100           if (script_class->standard_char3)
 101           {
 102             standard_char = script_class->standard_char3;
 103             ta_get_char_index(&metrics->root,
 104                               standard_char,
 105                               &glyph_index,
 106                               &y_offset);
 107             if (!glyph_index)
 108               goto Exit;
 109           }
 110           else
 111             goto Exit;
 112         }
 113       }
 114       else
 115         goto Exit;
 116     }
 117
 118     TA_LOG_GLOBAL(("standard character: U+%04lX (glyph index %d)\n",
 119                    standard_char, glyph_index));
 120
 121     error = FT_Load_Glyph(face, glyph_index, FT_LOAD_NO_SCALE);
 122     if (error || face->glyph->outline.n_points <= 0)
 123       goto Exit;
 124
 125     memset(dummy, 0, sizeof (TA_LatinMetricsRec));
 126
 127     dummy->units_per_em = metrics->units_per_em;
 128
 129     scaler->x_scale = 0x10000L;
 130     scaler->y_scale = 0x10000L;
 131     scaler->x_delta = 0;
 132     scaler->y_delta = 0;
 133
 134     scaler->face = face;
 135     scaler->render_mode = FT_RENDER_MODE_NORMAL;
 136     scaler->flags = 0;
 137
 138     ta_glyph_hints_rescale(hints, (TA_StyleMetrics)dummy);
 139
 140     error = ta_glyph_hints_reload(hints, &face->glyph->outline);
 141     if (error)
 142       goto Exit;
 143
 144     for (dim = 0; dim < TA_DIMENSION_MAX; dim++)
 145     {
 146       TA_LatinAxis axis = &metrics->axis[dim];
 147       TA_AxisHints axhints = &hints->axis[dim];
 148
 149       TA_Segment seg, limit, link;
 150       FT_UInt num_widths = 0;
 151
 152
 153       error = ta_latin_hints_compute_segments(hints, (TA_Dimension)dim);
 154       if (error)
 155         goto Exit;
 156
 157       /*
 158        * We assume that the glyphs selected for the stem width
 159        * computation are `featureless' enough so that the linking
 160        * algorithm works fine without adjustments of its scoring
 161        * function.
 162        */
 163       ta_latin_hints_link_segments(hints, 0, NULL, (TA_Dimension)dim);
 164
 165       seg = axhints->segments;
 166       limit = seg + axhints->num_segments;
 167
 168       for (; seg < limit; seg++)
 169       {
 170         link = seg->link;
 171
 172         /* we only consider stem segments there! */
 173         if (link
 174             && link->link == seg
 175             && link > seg)
 176         {
 177           FT_Pos dist;
 178
 179
 180           dist = seg->pos - link->pos;
 181           if (dist < 0)
 182             dist = -dist;
 183
 184           if (num_widths < TA_LATIN_MAX_WIDTHS)
 185             axis->widths[num_widths++].org = dist;
 186         }
 187       }
 188
 189       /* this also replaces multiple almost identical stem widths */
 190       /* with a single one (the value 100 is heuristic) */
 191       ta_sort_and_quantize_widths(&num_widths, axis->widths,
 192                                   dummy->units_per_em / 100);
 193       axis->width_count = num_widths;
 194     }
 195
 196   Exit:
 197     for (dim = 0; dim < TA_DIMENSION_MAX; dim++)
 198     {
 199       FONT* font = metrics->root.globals->font;
 200       TA_LatinAxis axis = &metrics->axis[dim];
 201       FT_Pos stdw;
 202
 203
 204       if (!axis->width_count)
 205       {
 206         /* if we have no standard characters, */
 207         /* use `fallback-stem-width', if available, */
 208         /* or a default width (value 50 is heuristic) */
 209         stdw = (dim == TA_DIMENSION_VERT && font->fallback_stem_width)
 210                  ? (FT_Pos)font->fallback_stem_width
 211                  : TA_LATIN_CONSTANT(metrics, 50);
 212
 213         /* set one width value if we do hinting */
 214         if (style_class->style != TA_STYLE_NONE_DFLT)
 215         {
 216           axis->width_count++;
 217           axis->widths[0].org = stdw;
 218         }
 219       }
 220
 221       stdw = axis->widths[0].org;
 222
 223       /* let's try 20% of the smallest width */
 224       axis->edge_distance_threshold = stdw / 5;
 225       axis->standard_width = stdw;
 226       axis->extra_light = 0;
 227
 228 #ifdef TA_DEBUG
 229       {
 230         FT_UInt i;
 231
 232
 233         TA_LOG_GLOBAL(("%s widths:\n",
 234                        dim == TA_DIMENSION_VERT ? "horizontal"
 235                                                 : "vertical"));
 236
 237         TA_LOG_GLOBAL(("  %d (standard)", axis->standard_width));
 238         for (i = 1; i < axis->width_count; i++)
 239           TA_LOG_GLOBAL((" %d", axis->widths[i].org));
 240
 241         TA_LOG_GLOBAL(("\n"));
 242       }
 243 #endif
 244     }
 245   }
 246
 247   TA_LOG_GLOBAL(("\n"));
 248
 249   ta_glyph_hints_done(hints);
 250 }
 251
 252
 253 /* find all blue zones; flat segments give the reference points, */
 254 /* round segments the overshoot positions */
 255
 256 static void
 257 ta_latin_metrics_init_blues(TA_LatinMetrics metrics,
 258                             FT_Face face)
 259 {
 260   FT_Pos flats[TA_BLUE_STRING_MAX_LEN];
 261   FT_Pos rounds[TA_BLUE_STRING_MAX_LEN];
 262   FT_Int num_flats;
 263   FT_Int num_rounds;
 264
 265   TA_LatinBlue blue;
 266   FT_Error error;
 267   TA_LatinAxis axis = &metrics->axis[TA_DIMENSION_VERT];
 268   FT_Outline outline;
 269
 270   TA_StyleClass sc = metrics->root.style_class;
 271
 272   TA_Blue_Stringset bss = sc->blue_stringset;
 273   const TA_Blue_StringRec* bs = &ta_blue_stringsets[bss];
 274
 275
 276   /* we walk over the blue character strings as specified in the  */
 277   /* style's entry in the `ta_blue_stringset' array */
 278
 279   TA_LOG_GLOBAL(("latin blue zones computation\n"
 280                  "============================\n"
 281                  "\n"));
 282
 283   for (; bs->string != TA_BLUE_STRING_MAX; bs++)
 284   {
 285     const char* p = &ta_blue_strings[bs->string];
 286     FT_Pos* blue_ref;
 287     FT_Pos* blue_shoot;
 288
 289
 290 #ifdef TA_DEBUG
 291     {
 292       FT_Bool have_flag = 0;
 293
 294
 295       TA_LOG_GLOBAL(("blue zone %d", axis->blue_count));
 296
 297       if (bs->properties)
 298       {
 299         TA_LOG_GLOBAL((" ("));
 300
 301         if (TA_LATIN_IS_TOP_BLUE(bs))
 302         {
 303           TA_LOG_GLOBAL(("top"));
 304           have_flag = 1;
 305         }
 306
 307         if (TA_LATIN_IS_NEUTRAL_BLUE(bs))
 308         {
 309           if (have_flag)
 310             TA_LOG_GLOBAL((", "));
 311           TA_LOG_GLOBAL(("neutral"));
 312           have_flag = 1;
 313         }
 314
 315         if (TA_LATIN_IS_X_HEIGHT_BLUE(bs))
 316         {
 317           if (have_flag)
 318             TA_LOG_GLOBAL((", "));
 319           TA_LOG_GLOBAL(("small top"));
 320           have_flag = 1;
 321         }
 322
 323         if (TA_LATIN_IS_LONG_BLUE(bs))
 324         {
 325           if (have_flag)
 326             TA_LOG_GLOBAL((", "));
 327           TA_LOG_GLOBAL(("long"));
 328         }
 329
 330         TA_LOG_GLOBAL((")"));
 331       }
 332
 333       TA_LOG_GLOBAL((":\n"));
 334     }
 335 #endif /* TA_DEBUG */
 336
 337     num_flats = 0;
 338     num_rounds = 0;
 339
 340     while (*p)
 341     {
 342       FT_ULong ch;
 343       FT_ULong glyph_index;
 344       FT_Long y_offset;
 345       FT_Pos best_y; /* same as points.y */
 346       FT_Int best_point, best_contour_first, best_contour_last;
 347       FT_Vector* points;
 348       FT_Bool round = 0;
 349
 350
 351       GET_UTF8_CHAR(ch, p);
 352
 353       /* load the character in the face -- skip unknown or empty ones */
 354       ta_get_char_index(&metrics->root, ch, &glyph_index, &y_offset);
 355       if (glyph_index == 0)
 356       {
 357         TA_LOG_GLOBAL(("  U+%04lX unavailable\n", ch));
 358         continue;
 359       }
 360
 361       error = FT_Load_Glyph(face, glyph_index, FT_LOAD_NO_SCALE);
 362       outline = face->glyph->outline;
 363       if (error || outline.n_points <= 0)
 364       {
 365         TA_LOG_GLOBAL(("  U+%04lX contains no outlines\n", ch));
 366         continue;
 367       }
 368
 369       /* now compute min or max point indices and coordinates */
 370       points = outline.points;
 371       best_point = -1;
 372       best_y = 0; /* make compiler happy */
 373       best_contour_first = 0; /* ditto */
 374       best_contour_last = 0; /* ditto */
 375
 376       {
 377         FT_Int nn;
 378         FT_Int first = 0;
 379         FT_Int last = -1;
 380
 381
 382         for (nn = 0; nn < outline.n_contours; first = last + 1, nn++)
 383         {
 384           FT_Int old_best_point = best_point;
 385           FT_Int pp;
 386
 387
 388           last = outline.contours[nn];
 389
 390           /* avoid single-point contours since they are never rasterized; */
 391           /* in some fonts, they correspond to mark attachment points */
 392           /* that are way outside of the glyph's real outline */
 393           if (last <= first)
 394             continue;
 395
 396           if (TA_LATIN_IS_TOP_BLUE(bs))
 397           {
 398             for (pp = first; pp <= last; pp++)
 399               if (best_point < 0
 400                   || points[pp].y > best_y)
 401               {
 402                 best_point = pp;
 403                 best_y = points[pp].y;
 404               }
 405           }
 406           else
 407           {
 408             for (pp = first; pp <= last; pp++)
 409               if (best_point < 0
 410                   || points[pp].y < best_y)
 411               {
 412                 best_point = pp;
 413                 best_y = points[pp].y;
 414               }
 415           }
 416
 417           if (best_point != old_best_point)
 418           {
 419             best_contour_first = first;
 420             best_contour_last = last;
 421           }
 422         }
 423       }
 424
 425       /* now check whether the point belongs to a straight or round */
 426       /* segment; we first need to find in which contour the extremum */
 427       /* lies, then inspect its previous and next points */
 428       if (best_point >= 0)
 429       {
 430         FT_Pos best_x = points[best_point].x;
 431         FT_Int prev, next;
 432         FT_Int best_segment_first, best_segment_last;
 433         FT_Int best_on_point_first, best_on_point_last;
 434         FT_Pos dist;
 435
 436
 437         best_segment_first = best_point;
 438         best_segment_last = best_point;
 439
 440         if (FT_CURVE_TAG(outline.tags[best_point]) == FT_CURVE_TAG_ON)
 441         {
 442           best_on_point_first = best_point;
 443           best_on_point_last = best_point;
 444         }
 445         else
 446         {
 447           best_on_point_first = -1;
 448           best_on_point_last = -1;
 449         }
 450
 451         /* look for the previous and next points on the contour */
 452         /* that are not on the same Y coordinate, then threshold */
 453         /* the `closeness'... */
 454         prev = best_point;
 455         next = prev;
 456
 457         do
 458         {
 459           if (prev > best_contour_first)
 460             prev--;
 461           else
 462             prev = best_contour_last;
 463
 464           dist = TA_ABS(points[prev].y - best_y);
 465           /* accept a small distance or a small angle (both values are */
 466           /* heuristic; value 20 corresponds to approx. 2.9 degrees) */
 467           if (dist > 5)
 468             if (TA_ABS(points[prev].x - best_x) <= 20 * dist)
 469               break;
 470
 471           best_segment_first = prev;
 472
 473           if (FT_CURVE_TAG(outline.tags[prev]) == FT_CURVE_TAG_ON)
 474           {
 475             best_on_point_first = prev;
 476             if (best_on_point_last < 0)
 477               best_on_point_last = prev;
 478           }
 479
 480         } while (prev != best_point);
 481
 482         do
 483         {
 484           if (next < best_contour_last)
 485             next++;
 486           else
 487             next = best_contour_first;
 488
 489           dist = TA_ABS(points[next].y - best_y);
 490           if (dist > 5)
 491             if (TA_ABS(points[next].x - best_x) <= 20 * dist)
 492               break;
 493
 494           best_segment_last = next;
 495
 496           if (FT_CURVE_TAG(outline.tags[next]) == FT_CURVE_TAG_ON)
 497           {
 498             best_on_point_last = next;
 499             if (best_on_point_first < 0)
 500               best_on_point_first = next;
 501           }
 502
 503         } while (next != best_point);
 504
 505         if (TA_LATIN_IS_LONG_BLUE(bs))
 506         {
 507           /* If this flag is set, we have an additional constraint to */
 508           /* get the blue zone distance: Find a segment of the topmost */
 509           /* (or bottommost) contour that is longer than a heuristic */
 510           /* threshold.  This ensures that small bumps in the outline */
 511           /* are ignored (for example, the `vertical serifs' found in */
 512           /* many Hebrew glyph designs). */
 513
 514           /* If this segment is long enough, we are done.  Otherwise, */
 515           /* search the segment next to the extremum that is long */
 516           /* enough, has the same direction, and a not too large */
 517           /* vertical distance from the extremum.  Note that the */
 518           /* algorithm doesn't check whether the found segment is */
 519           /* actually the one (vertically) nearest to the extremum. */
 520
 521           /* heuristic threshold value */
 522           FT_Pos length_threshold = metrics->units_per_em / 25;
 523
 524
 525           dist = TA_ABS(points[best_segment_last].x -
 526                           points[best_segment_first].x);
 527
 528           if (dist < length_threshold
 529               && best_segment_last - best_segment_first + 2 <=
 530                    best_contour_last - best_contour_first)
 531           {
 532             /* heuristic threshold value */
 533             FT_Pos height_threshold = metrics->units_per_em / 4;
 534
 535             FT_Int first;
 536             FT_Int last;
 537             FT_Bool hit;
 538
 539             /* we intentionally declare these two variables */
 540             /* outside of the loop since various compilers emit */
 541             /* incorrect warning messages otherwise, talking about */
 542             /* `possibly uninitialized variables' */
 543             FT_Int p_first = 0; /* make compiler happy */
 544             FT_Int p_last  = 0;
 545
 546             FT_Bool left2right;
 547
 548
 549             /* compute direction */
 550             prev = best_point;
 551
 552             do
 553             {
 554               if (prev > best_contour_first)
 555                 prev--;
 556               else
 557                 prev = best_contour_last;
 558
 559               if (points[prev].x != best_x)
 560                 break;
 561             } while (prev != best_point);
 562
 563             /* skip glyph for the degenerate case */
 564             if (prev == best_point)
 565               continue;
 566
 567             left2right = FT_BOOL(points[prev].x < points[best_point].x);
 568
 569             first = best_segment_last;
 570             last = first;
 571             hit = 0;
 572
 573             do
 574             {
 575               FT_Bool l2r;
 576               FT_Pos d;
 577
 578
 579               if (!hit)
 580               {
 581                 /* no hit; adjust first point */
 582                 first = last;
 583
 584                 /* also adjust first and last on point */
 585                 if (FT_CURVE_TAG(outline.tags[first]) == FT_CURVE_TAG_ON)
 586                 {
 587                   p_first = first;
 588                   p_last = first;
 589                 }
 590                 else
 591                 {
 592                   p_first = -1;
 593                   p_last = -1;
 594                 }
 595
 596                 hit = 1;
 597               }
 598
 599               if (last < best_contour_last)
 600                 last++;
 601               else
 602                 last = best_contour_first;
 603
 604               if (TA_ABS(best_y - points[first].y) > height_threshold)
 605               {
 606                 /* vertical distance too large */
 607                 hit = 0;
 608                 continue;
 609               }
 610
 611               /* same test as above */
 612               dist = TA_ABS(points[last].y - points[first].y);
 613               if (dist > 5)
 614                 if (TA_ABS(points[last].x - points[first].x) <= 20 * dist)
 615                 {
 616                   hit = 0;
 617                   continue;
 618                 }
 619
 620               if (FT_CURVE_TAG(outline.tags[last]) == FT_CURVE_TAG_ON)
 621               {
 622                 p_last = last;
 623                 if (p_first < 0)
 624                   p_first = last;
 625               }
 626
 627               l2r = FT_BOOL(points[first].x < points[last].x);
 628               d = TA_ABS(points[last].x - points[first].x);
 629
 630               if (l2r == left2right
 631                   && d >= length_threshold)
 632               {
 633                 /* all constraints are met; update segment after finding */
 634                 /* its end */
 635                 do
 636                 {
 637                   if (last < best_contour_last)
 638                     last++;
 639                   else
 640                     last = best_contour_first;
 641
 642                   d = TA_ABS(points[last].y - points[first].y);
 643                   if (d > 5)
 644                     if (TA_ABS(points[next].x - points[first].x) <=
 645                           20 * dist)
 646                     {
 647                       if (last > best_contour_first)
 648                         last--;
 649                       else
 650                         last = best_contour_last;
 651                       break;
 652                     }
 653
 654                   p_last = last;
 655
 656                   if (FT_CURVE_TAG(outline.tags[last]) == FT_CURVE_TAG_ON)
 657                   {
 658                     p_last = last;
 659                     if (p_first < 0)
 660                       p_first = last;
 661                   }
 662                 } while (last != best_segment_first);
 663
 664                 best_y = points[first].y;
 665
 666                 best_segment_first = first;
 667                 best_segment_last = last;
 668
 669                 best_on_point_first = p_first;
 670                 best_on_point_last = p_last;
 671
 672                 break;
 673               }
 674             } while (last != best_segment_first);
 675           }
 676         }
 677
 678         /*
 679          * for computing blue zones, we add the y offset as returned
 680          * by the currently used OpenType feature --
 681          * for example, superscript glyphs might be identical
 682          * to subscript glyphs with a vertical shift
 683          */
 684         best_y += y_offset;
 685
 686         TA_LOG_GLOBAL(("  U+%04lX: best_y = %5ld", ch, best_y));
 687
 688         /*
 689          * now set the `round' flag depending on the segment's kind:
 690          *
 691          * - if the horizontal distance between the first and last
 692          *   `on' point is larger than upem/8 (value 8 is heuristic)
 693          *   we have a flat segment
 694          * - if either the first or the last point of the segment is
 695          *   an `off' point, the segment is round, otherwise it is
 696          *   flat
 697          */
 698         if (best_on_point_first >= 0
 699             && best_on_point_last >= 0
 700             && (FT_UInt)(TA_ABS(points[best_on_point_last].x
 701                                 - points[best_on_point_first].x))
 702                  > metrics->units_per_em / 8)
 703           round = 0;
 704         else
 705           round = FT_BOOL(FT_CURVE_TAG(outline.tags[best_segment_first])
 706                             != FT_CURVE_TAG_ON
 707                           || FT_CURVE_TAG(outline.tags[best_segment_last])
 708                                != FT_CURVE_TAG_ON);
 709
 710         if (round && TA_LATIN_IS_NEUTRAL_BLUE(bs))
 711         {
 712           /* only use flat segments for a neutral blue zone */
 713           TA_LOG_GLOBAL((" (round, skipped)\n"));
 714           continue;
 715         }
 716
 717         TA_LOG_GLOBAL((" (%s)\n", round ? "round" : "flat"));
 718       }
 719
 720       if (round)
 721         rounds[num_rounds++] = best_y;
 722       else
 723         flats[num_flats++] = best_y;
 724     }
 725
 726     if (num_flats == 0 && num_rounds == 0)
 727     {
 728       /* we couldn't find a single glyph to compute this blue zone, */
 729       /* we will simply ignore it then */
 730       TA_LOG_GLOBAL(("  empty\n"));
 731       continue;
 732     }
 733
 734     /* we have computed the contents of the `rounds' and `flats' tables, */
 735     /* now determine the reference and overshoot position of the blue -- */
 736     /* we simply take the median value after a simple sort */
 737     ta_sort_pos(num_rounds, rounds);
 738     ta_sort_pos(num_flats, flats);
 739
 740     blue = &axis->blues[axis->blue_count];
 741     blue_ref = &blue->ref.org;
 742     blue_shoot = &blue->shoot.org;
 743
 744     axis->blue_count++;
 745
 746     if (num_flats == 0)
 747     {
 748       *blue_ref =
 749       *blue_shoot = rounds[num_rounds / 2];
 750     }
 751     else if (num_rounds == 0)
 752     {
 753       *blue_ref =
 754       *blue_shoot = flats[num_flats / 2];
 755     }
 756     else
 757     {
 758       *blue_ref = flats[num_flats / 2];
 759       *blue_shoot = rounds[num_rounds / 2];
 760     }
 761
 762     /* there are sometimes problems if the overshoot position of top */
 763     /* zones is under its reference position, or the opposite for bottom */
 764     /* zones; we must thus check everything there and correct the errors */
 765     if (*blue_shoot != *blue_ref)
 766     {
 767       FT_Pos ref = *blue_ref;
 768       FT_Pos shoot = *blue_shoot;
 769       FT_Bool over_ref = FT_BOOL(shoot > ref);
 770
 771
 772       if (TA_LATIN_IS_TOP_BLUE(bs) ^ over_ref)
 773       {
 774         *blue_ref =
 775         *blue_shoot = (shoot + ref) / 2;
 776
 777         TA_LOG_GLOBAL(("  [overshoot smaller than reference,"
 778                        " taking mean value]\n"));
 779       }
 780     }
 781
 782     blue->flags = 0;
 783     if (TA_LATIN_IS_TOP_BLUE(bs))
 784       blue->flags |= TA_LATIN_BLUE_TOP;
 785     if (TA_LATIN_IS_NEUTRAL_BLUE(bs))
 786       blue->flags |= TA_LATIN_BLUE_NEUTRAL;
 787
 788     /* the following flag is used later to adjust the y and x scales */
 789     /* in order to optimize the pixel grid alignment */
 790     /* of the top of small letters */
 791     if (TA_LATIN_IS_X_HEIGHT_BLUE(bs))
 792       blue->flags |= TA_LATIN_BLUE_ADJUSTMENT;
 793
 794     TA_LOG_GLOBAL(("    -> reference = %ld\n"
 795                    "       overshoot = %ld\n",
 796                    *blue_ref, *blue_shoot));
 797   }
 798
 799   /* add two blue zones for usWinAscent and usWinDescent */
 800   /* just in case the above algorithm has missed them -- */
 801   /* Windows cuts off everything outside of those two values */
 802   {
 803     TT_OS2* os2;
 804
 805
 806     os2 = (TT_OS2*)FT_Get_Sfnt_Table(face, ft_sfnt_os2);
 807
 808     if (os2)
 809     {
 810       blue = &axis->blues[axis->blue_count];
 811       blue->flags = TA_LATIN_BLUE_TOP | TA_LATIN_BLUE_ACTIVE;
 812       blue->ref.org =
 813       blue->shoot.org = os2->usWinAscent;
 814
 815       TA_LOG_GLOBAL(("artificial blue zone for usWinAscent:\n"
 816                      "    -> reference = %ld\n"
 817                      "       overshoot = %ld\n",
 818                      blue->ref.org, blue->shoot.org));
 819
 820       blue = &axis->blues[axis->blue_count + 1];
 821       blue->flags = TA_LATIN_BLUE_ACTIVE;
 822       blue->ref.org =
 823       blue->shoot.org = -os2->usWinDescent;
 824
 825       TA_LOG_GLOBAL(("artificial blue zone for usWinDescent:\n"
 826                      "    -> reference = %ld\n"
 827                      "       overshoot = %ld\n",
 828                      blue->ref.org, blue->shoot.org));
 829     }
 830     else
 831     {
 832       blue = &axis->blues[axis->blue_count];
 833       blue->flags =
 834       blue->ref.org =
 835       blue->shoot.org = 0;
 836
 837       blue = &axis->blues[axis->blue_count + 1];
 838       blue->flags =
 839       blue->ref.org =
 840       blue->shoot.org = 0;
 841     }
 842   }
 843
 844   TA_LOG_GLOBAL(("\n"));
 845
 846   return;
 847 }
 848
 849
 850 /* check whether all ASCII digits have the same advance width */
 851
 852 void
 853 ta_latin_metrics_check_digits(TA_LatinMetrics metrics,
 854                               FT_Face face)
 855 {
 856   FT_UInt i;
 857   FT_Bool started = 0, same_width = 1;
 858   FT_Fixed advance, old_advance = 0;
 859
 860
 861   /* digit `0' is 0x30 in all supported charmaps */
 862   for (i = 0x30; i <= 0x39; i++)
 863   {
 864     FT_ULong glyph_index;
 865     FT_Long y_offset;
 866
 867
 868     ta_get_char_index(&metrics->root, i, &glyph_index, &y_offset);
 869     if (glyph_index == 0)
 870       continue;
 871
 872     if (FT_Get_Advance(face, glyph_index,
 873                        FT_LOAD_NO_SCALE
 874                        | FT_LOAD_NO_HINTING
 875                        | FT_LOAD_IGNORE_TRANSFORM,
 876                        &advance))
 877       continue;
 878
 879     if (started)
 880     {
 881       if (advance != old_advance)
 882       {
 883         same_width = 0;
 884         break;
 885       }
 886     }
 887     else
 888     {
 889       old_advance = advance;
 890       started = 1;
 891     }
 892   }
 893
 894   metrics->root.digits_have_same_width = same_width;
 895 }
 896
 897
 898 /* initialize global metrics */
 899
 900 FT_Error
 901 ta_latin_metrics_init(TA_LatinMetrics metrics,
 902                       FT_Face face)
 903 {
 904   FT_CharMap oldmap = face->charmap;
 905
 906
 907   metrics->units_per_em = face->units_per_EM;
 908
 909   if (!FT_Select_Charmap(face, FT_ENCODING_UNICODE))
 910   {
 911     ta_latin_metrics_init_widths(metrics, face, 1);
 912     ta_latin_metrics_init_blues(metrics, face);
 913     ta_latin_metrics_check_digits(metrics, face);
 914   }
 915   else
 916   {
 917     /* we only have a symbol font encoding */
 918     ta_latin_metrics_init_widths(metrics, face, 0);
 919   }
 920
 921   FT_Set_Charmap(face, oldmap);
 922   return FT_Err_Ok;
 923 }
 924
 925
 926 /* adjust scaling value, then scale and shift widths */
 927 /* and blue zones (if applicable) for given dimension */
 928
 929 static void
 930 ta_latin_metrics_scale_dim(TA_LatinMetrics metrics,
 931                            TA_Scaler scaler,
 932                            TA_Dimension dim)
 933 {
 934   FT_Fixed scale;
 935   FT_Pos delta;
 936   TA_LatinAxis axis;
 937   FT_UInt ppem;
 938   FT_UInt nn;
 939
 940
 941   ppem = metrics->root.scaler.face->size->metrics.x_ppem;
 942
 943   if (dim == TA_DIMENSION_HORZ)
 944   {
 945     scale = scaler->x_scale;
 946     delta = scaler->x_delta;
 947   }
 948   else
 949   {
 950     scale = scaler->y_scale;
 951     delta = scaler->y_delta;
 952   }
 953
 954   axis = &metrics->axis[dim];
 955
 956   if (axis->org_scale == scale && axis->org_delta == delta)
 957     return;
 958
 959   axis->org_scale = scale;
 960   axis->org_delta = delta;
 961
 962   /* correct Y scale to optimize the alignment of the top of */
 963   /* small letters to the pixel grid */
 964   /* (if we do x-height snapping for this ppem value) */
 965   if (!number_set_is_element(
 966         metrics->root.globals->font->x_height_snapping_exceptions,
 967         ppem))
 968   {
 969     TA_LatinAxis Axis = &metrics->axis[TA_DIMENSION_VERT];
 970     TA_LatinBlue blue = NULL;
 971
 972
 973     for (nn = 0; nn < Axis->blue_count; nn++)
 974     {
 975       if (Axis->blues[nn].flags & TA_LATIN_BLUE_ADJUSTMENT)
 976       {
 977         blue = &Axis->blues[nn];
 978         break;
 979       }
 980     }
 981
 982     if (blue)
 983     {
 984       FT_Pos scaled;
 985       FT_Pos threshold;
 986       FT_Pos fitted;
 987       FT_UInt limit;
 988
 989
 990       scaled = FT_MulFix(blue->shoot.org, scaler->y_scale);
 991       limit = metrics->root.globals->increase_x_height;
 992       threshold = 40;
 993
 994       /* if the `increase-x-height' property is active, */
 995       /* we round up much more often                    */
 996       if (limit
 997           && ppem <= limit
 998           && ppem >= TA_PROP_INCREASE_X_HEIGHT_MIN)
 999         threshold = 52;
1000
1001       fitted = (scaled + threshold) & ~63;
1002
1003       if (scaled != fitted)
1004       {
1005         if (dim == TA_DIMENSION_VERT)
1006         {
1007           scale = FT_MulDiv(scale, fitted, scaled);
1008
1009           TA_LOG_GLOBAL((
1010             "ta_latin_metrics_scale_dim:"
1011             " x height alignment (style `%s'):\n"
1012             "                           "
1013             " vertical scaling changed from %.4f to %.4f (by %d%%)\n"
1014             "\n",
1015             ta_style_names[metrics->root.style_class->style],
1016             axis->org_scale / 65536.0,
1017             scale / 65536.0,
1018             (fitted - scaled) * 100 / scaled));
1019         }
1020       }
1021     }
1022   }
1023
1024   axis->scale = scale;
1025   axis->delta = delta;
1026
1027   if (dim == TA_DIMENSION_HORZ)
1028   {
1029     metrics->root.scaler.x_scale = scale;
1030     metrics->root.scaler.x_delta = delta;
1031   }
1032   else
1033   {
1034     metrics->root.scaler.y_scale = scale;
1035     metrics->root.scaler.y_delta = delta;
1036   }
1037
1038   TA_LOG_GLOBAL(("%s widths (style `%s')\n",
1039                  dim == TA_DIMENSION_HORZ ? "horizontal" : "vertical",
1040                  ta_style_names[metrics->root.style_class->style]));
1041
1042   /* scale the widths */
1043   for (nn = 0; nn < axis->width_count; nn++)
1044   {
1045     TA_Width width = axis->widths + nn;
1046
1047
1048     width->cur = FT_MulFix(width->org, scale);
1049     width->fit = width->cur;
1050
1051     TA_LOG_GLOBAL(("  %d scaled to %.2f\n",
1052                    width->org,
1053                    width->cur / 64.0));
1054   }
1055
1056   TA_LOG_GLOBAL(("\n"));
1057
1058   /* an extra-light axis corresponds to a standard width that is */
1059   /* smaller than 5/8 pixels */
1060   axis->extra_light =
1061     (FT_Bool)(FT_MulFix(axis->standard_width, scale) < 32 + 8);
1062
1063 #ifdef TA_DEBUG
1064   if (axis->extra_light)
1065     TA_LOG_GLOBAL(("`%s' style is extra light (at current resolution)\n"
1066                    "\n",
1067                    ta_style_names[metrics->root.style_class->style]));
1068 #endif
1069
1070   if (dim == TA_DIMENSION_VERT)
1071   {
1072     TA_LOG_GLOBAL(("blue zones (style `%s')\n",
1073                    ta_style_names[metrics->root.style_class->style]));
1074
1075     /* scale the blue zones */
1076     for (nn = 0; nn < axis->blue_count; nn++)
1077     {
1078       TA_LatinBlue blue = &axis->blues[nn];
1079       FT_Pos dist;
1080
1081
1082       blue->ref.cur = FT_MulFix(blue->ref.org, scale) + delta;
1083       blue->ref.fit = blue->ref.cur;
1084       blue->shoot.cur = FT_MulFix(blue->shoot.org, scale) + delta;
1085       blue->shoot.fit = blue->shoot.cur;
1086       blue->flags &= ~TA_LATIN_BLUE_ACTIVE;
1087
1088       /* a blue zone is only active if it is less than 3/4 pixels tall */
1089       dist = FT_MulFix(blue->ref.org - blue->shoot.org, scale);
1090       if (dist <= 48 && dist >= -48)
1091       {
1092 #if 0
1093         FT_Pos delta1;
1094 #endif
1095         FT_Pos delta2;
1096
1097
1098         /* use discrete values for blue zone widths */
1099
1100 #if 0
1101         /* generic, original code */
1102         delta1 = blue->shoot.org - blue->ref.org;
1103         delta2 = delta1;
1104         if (delta1 < 0)
1105           delta2 = -delta2;
1106
1107         delta2 = FT_MulFix(delta2, scale);
1108
1109         if (delta2 < 32)
1110           delta2 = 0;
1111         else if (delta2 < 64)
1112           delta2 = 32 + (((delta2 - 32) + 16) & ~31);
1113         else
1114           delta2 = TA_PIX_ROUND(delta2);
1115
1116         if (delta1 < 0)
1117           delta2 = -delta2;
1118
1119         blue->ref.fit = TA_PIX_ROUND(blue->ref.cur);
1120         blue->shoot.fit = blue->ref.fit + delta2;
1121 #else
1122         /* simplified version due to abs(dist) <= 48 */
1123         delta2 = dist;
1124         if (dist < 0)
1125           delta2 = -delta2;
1126
1127         if (delta2 < 32)
1128           delta2 = 0;
1129         else if (delta2 < 48)
1130           delta2 = 32;
1131         else
1132           delta2 = 64;
1133
1134         if (dist < 0)
1135           delta2 = -delta2;
1136
1137         blue->ref.fit = TA_PIX_ROUND(blue->ref.cur);
1138         blue->shoot.fit = blue->ref.fit - delta2;
1139 #endif
1140
1141         blue->flags |= TA_LATIN_BLUE_ACTIVE;
1142
1143         TA_LOG_GLOBAL(("  reference %d: %d scaled to %.2f%s\n"
1144                        "  overshoot %d: %d scaled to %.2f%s\n",
1145                        nn,
1146                        blue->ref.org,
1147                        blue->ref.fit / 64.0,
1148                        blue->flags & TA_LATIN_BLUE_ACTIVE ? ""
1149                                                           : " (inactive)",
1150                        nn,
1151                        blue->shoot.org,
1152                        blue->shoot.fit / 64.0,
1153                        blue->flags & TA_LATIN_BLUE_ACTIVE ? ""
1154                                                           : " (inactive)"));
1155       }
1156     }
1157
1158     /* the last two artificial blue zones are to be scaled */
1159     /* with uncorrected scaling values */
1160     {
1161       TA_LatinAxis a = &metrics->axis[TA_DIMENSION_VERT];
1162       TA_LatinBlue b;
1163
1164
1165       b = &a->blues[a->blue_count];
1166       b->ref.cur =
1167       b->ref.fit =
1168       b->shoot.cur =
1169       b->shoot.fit = FT_MulFix(b->ref.org, a->org_scale) + delta;
1170
1171       TA_LOG_GLOBAL(("  reference %d: %d scaled to %.2f (artificial)\n"
1172                      "  overshoot %d: %d scaled to %.2f (artificial)\n",
1173                      a->blue_count,
1174                      b->ref.org,
1175                      b->ref.fit / 64.0,
1176                      a->blue_count,
1177                      b->shoot.org,
1178                      b->shoot.fit / 64.0));
1179
1180       b = &a->blues[a->blue_count + 1];
1181       b->ref.cur =
1182       b->ref.fit =
1183       b->shoot.cur =
1184       b->shoot.fit = FT_MulFix(b->ref.org, a->org_scale) + delta;
1185
1186       TA_LOG_GLOBAL(("  reference %d: %d scaled to %.2f (artificial)\n"
1187                      "  overshoot %d: %d scaled to %.2f (artificial)\n",
1188                      a->blue_count + 1,
1189                      b->ref.org,
1190                      b->ref.fit / 64.0,
1191                      a->blue_count + 1,
1192                      b->shoot.org,
1193                      b->shoot.fit / 64.0));
1194     }
1195
1196     TA_LOG_GLOBAL(("\n"));
1197   }
1198 }
1199
1200
1201 /* scale global values in both directions */
1202
1203 void
1204 ta_latin_metrics_scale(TA_LatinMetrics metrics,
1205                        TA_Scaler scaler)
1206 {
1207   metrics->root.scaler.render_mode = scaler->render_mode;
1208   metrics->root.scaler.face = scaler->face;
1209   metrics->root.scaler.flags = scaler->flags;
1210
1211   ta_latin_metrics_scale_dim(metrics, scaler, TA_DIMENSION_HORZ);
1212   ta_latin_metrics_scale_dim(metrics, scaler, TA_DIMENSION_VERT);
1213 }
1214
1215
1216 /* walk over all contours and compute its segments */
1217
1218 FT_Error
1219 ta_latin_hints_compute_segments(TA_GlyphHints hints,
1220                                 TA_Dimension dim)
1221 {
1222   TA_AxisHints axis = &hints->axis[dim];
1223   FT_Error error = FT_Err_Ok;
1224
1225   TA_Segment segment = NULL;
1226   TA_SegmentRec seg0;
1227
1228   TA_Point* contour = hints->contours;
1229   TA_Point* contour_limit = contour + hints->num_contours;
1230   TA_Direction major_dir, segment_dir;
1231
1232
1233   memset(&seg0, 0, sizeof (TA_SegmentRec));
1234   seg0.score = 32000;
1235   seg0.flags = TA_EDGE_NORMAL;
1236
1237   major_dir = (TA_Direction)TA_ABS(axis->major_dir);
1238   segment_dir = major_dir;
1239
1240   axis->num_segments = 0;
1241
1242   /* set up (u,v) in each point */
1243   if (dim == TA_DIMENSION_HORZ)
1244   {
1245     TA_Point point = hints->points;
1246     TA_Point limit = point + hints->num_points;
1247
1248
1249     for (; point < limit; point++)
1250     {
1251       point->u = point->fx;
1252       point->v = point->fy;
1253     }
1254   }
1255   else
1256   {
1257     TA_Point point = hints->points;
1258     TA_Point limit = point + hints->num_points;
1259
1260
1261     for (; point < limit; point++)
1262     {
1263       point->u = point->fy;
1264       point->v = point->fx;
1265     }
1266   }
1267
1268   /* do each contour separately */
1269   for (; contour < contour_limit; contour++)
1270   {
1271     TA_Point point = contour[0];
1272     TA_Point last = point->prev;
1273
1274     int on_edge = 0;
1275
1276     FT_Pos min_pos = 32000; /* minimum segment pos != min_coord */
1277     FT_Pos max_pos = -32000; /* maximum segment pos != max_coord */
1278     FT_Bool passed;
1279
1280
1281     if (point == last) /* skip singletons -- just in case */
1282       continue;
1283
1284     if (TA_ABS(last->out_dir) == major_dir
1285         && TA_ABS(point->out_dir) == major_dir)
1286     {
1287       /* we are already on an edge, try to locate its start */
1288       last = point;
1289
1290       for (;;)
1291       {
1292         point = point->prev;
1293         if (TA_ABS(point->out_dir) != major_dir)
1294         {
1295           point = point->next;
1296           break;
1297         }
1298         if (point == last)
1299           break;
1300       }
1301     }
1302
1303     last = point;
1304     passed = 0;
1305
1306     for (;;)
1307     {
1308       FT_Pos u, v;
1309
1310
1311       if (on_edge)
1312       {
1313         u = point->u;
1314         if (u < min_pos)
1315           min_pos = u;
1316         if (u > max_pos)
1317           max_pos = u;
1318
1319         if (point->out_dir != segment_dir
1320             || point == last)
1321         {
1322           /* we are just leaving an edge; record a new segment! */
1323           segment->last = point;
1324           segment->pos = (FT_Short)((min_pos + max_pos) >> 1);
1325
1326           /* a segment is round if either its first or last point */
1327           /* is a control point */
1328           if ((segment->first->flags | point->flags) & TA_FLAG_CONTROL)
1329             segment->flags |= TA_EDGE_ROUND;
1330
1331           /* compute segment size */
1332           min_pos = max_pos = point->v;
1333
1334           v = segment->first->v;
1335           if (v < min_pos)
1336             min_pos = v;
1337           if (v > max_pos)
1338             max_pos = v;
1339
1340           segment->min_coord = (FT_Short)min_pos;
1341           segment->max_coord = (FT_Short)max_pos;
1342           segment->height = (FT_Short)(segment->max_coord -
1343                                          segment->min_coord);
1344
1345           on_edge = 0;
1346           segment = NULL;
1347           /* fall through */
1348         }
1349       }
1350
1351       /* now exit if we are at the start/end point */
1352       if (point == last)
1353       {
1354         if (passed)
1355           break;
1356         passed = 1;
1357       }
1358
1359       if (!on_edge
1360           && TA_ABS(point->out_dir) == major_dir)
1361       {
1362         /* this is the start of a new segment! */
1363         segment_dir = (TA_Direction)point->out_dir;
1364
1365         error = ta_axis_hints_new_segment(axis, &segment);
1366         if (error)
1367           goto Exit;
1368
1369         /* clear all segment fields */
1370         segment[0] = seg0;
1371
1372         segment->dir = (FT_Char)segment_dir;
1373         min_pos = max_pos = point->u;
1374         segment->first = point;
1375         segment->last = point;
1376
1377         on_edge = 1;
1378
1379         if (point->out_dir != point->next->in_dir)
1380         {
1381           /* we have a one-point segment */
1382           segment->pos = (FT_Short)min_pos;
1383
1384           if (point->flags & TA_FLAG_CONTROL)
1385             segment->flags |= TA_EDGE_ROUND;
1386
1387           segment->min_coord = (FT_Short)point->v;
1388           segment->max_coord = (FT_Short)point->v;
1389           segment->height = 0;
1390
1391           on_edge = 0;
1392           segment = NULL;
1393         }
1394       }
1395
1396       point = point->next;
1397     }
1398   } /* contours */
1399
1400
1401   /* now slightly increase the height of segments if this makes sense -- */
1402   /* this is used to better detect and ignore serifs */
1403   {
1404     TA_Segment segments = axis->segments;
1405     TA_Segment segments_end = segments + axis->num_segments;
1406
1407
1408     for (segment = segments; segment < segments_end; segment++)
1409     {
1410       TA_Point first = segment->first;
1411       TA_Point last = segment->last;
1412
1413       FT_Pos first_v = first->v;
1414       FT_Pos last_v = last->v;
1415
1416
1417       if (first_v < last_v)
1418       {
1419         TA_Point p;
1420
1421
1422         p = first->prev;
1423         if (p->v < first_v)
1424           segment->height = (FT_Short)(segment->height +
1425                                         ((first_v - p->v) >> 1));
1426
1427         p = last->next;
1428         if (p->v > last_v)
1429           segment->height = (FT_Short)(segment->height +
1430                                         ((p->v - last_v) >> 1));
1431       }
1432       else
1433       {
1434         TA_Point p;
1435
1436
1437         p = first->prev;
1438         if (p->v > first_v)
1439           segment->height = (FT_Short)(segment->height +
1440                                         ((p->v - first_v) >> 1));
1441
1442         p = last->next;
1443         if (p->v < last_v)
1444           segment->height = (FT_Short)(segment->height +
1445                                         ((last_v - p->v) >> 1));
1446       }
1447     }
1448   }
1449
1450 Exit:
1451   return error;
1452 }
1453
1454
1455 /* link segments to form stems and serifs; if `width_count' and */
1456 /* `widths' are non-zero, use them to fine-tune the scoring function */
1457
1458 void
1459 ta_latin_hints_link_segments(TA_GlyphHints hints,
1460                              FT_UInt width_count,
1461                              TA_WidthRec* widths,
1462                              TA_Dimension dim)
1463 {
1464   TA_AxisHints axis = &hints->axis[dim];
1465
1466   TA_Segment segments = axis->segments;
1467   TA_Segment segment_limit = segments + axis->num_segments;
1468
1469   FT_Pos len_threshold, len_score, dist_score, max_width;
1470   TA_Segment seg1, seg2;
1471
1472
1473   if (width_count)
1474     max_width = widths[width_count - 1].org;
1475   else
1476     max_width = 0;
1477
1478   /* a heuristic value to set up a minimum value for overlapping */
1479   len_threshold = TA_LATIN_CONSTANT(hints->metrics, 8);
1480   if (len_threshold == 0)
1481     len_threshold = 1;
1482
1483   /* a heuristic value to weight lengths */
1484   len_score = TA_LATIN_CONSTANT(hints->metrics, 6000);
1485
1486   /* a heuristic value to weight distances (no call to */
1487   /* TA_LATIN_CONSTANT needed, since we work on multiples */
1488   /* of the stem width) */
1489   dist_score = 3000;
1490
1491   /* now compare each segment to the others */
1492   for (seg1 = segments; seg1 < segment_limit; seg1++)
1493   {
1494     if (seg1->dir != axis->major_dir)
1495       continue;
1496
1497     /* search for stems having opposite directions, */
1498     /* with seg1 to the `left' of seg2 */
1499     for (seg2 = segments; seg2 < segment_limit; seg2++)
1500     {
1501       FT_Pos pos1 = seg1->pos;
1502       FT_Pos pos2 = seg2->pos;
1503
1504
1505       if (seg1->dir + seg2->dir == 0
1506           && pos2 > pos1)
1507       {
1508         /* compute distance between the two segments */
1509         FT_Pos min = seg1->min_coord;
1510         FT_Pos max = seg1->max_coord;
1511         FT_Pos len;
1512
1513
1514         if (min < seg2->min_coord)
1515           min = seg2->min_coord;
1516         if (max > seg2->max_coord)
1517           max = seg2->max_coord;
1518
1519         /* compute maximum coordinate difference of the two segments */
1520         /* (this is, how much they overlap) */
1521         len = max - min;
1522
1523         /* for one-point segments, `len' is zero if there is an overlap */
1524         /* (and negative otherwise); we have to correct this */
1525         if (len == 0
1526             && (seg1->min_coord == seg1->max_coord
1527                 || seg2->min_coord == seg2->max_coord))
1528           len = len_threshold;
1529
1530         if (len >= len_threshold)
1531         {
1532           /*
1533            * The score is the sum of two demerits indicating the
1534            * `badness' of a fit, measured along the segments' main axis
1535            * and orthogonal to it, respectively.
1536            *
1537            * o The less overlapping along the main axis, the worse it
1538            *   is, causing a larger demerit.
1539            *
1540            * o The nearer the orthogonal distance to a stem width, the
1541            *   better it is, causing a smaller demerit.  For simplicity,
1542            *   however, we only increase the demerit for values that
1543            *   exceed the largest stem width.
1544            */
1545
1546           FT_Pos dist = pos2 - pos1;
1547
1548           FT_Pos dist_demerit, score;
1549
1550
1551           if (max_width)
1552           {
1553             /* distance demerits are based on multiples of `max_width'; */
1554             /* we scale by 1024 for getting more precision */
1555             FT_Pos delta = (dist << 10) / max_width - (1 << 10);
1556
1557
1558             if (delta > 10000)
1559               dist_demerit = 32000;
1560             else if (delta > 0)
1561               dist_demerit = delta * delta / dist_score;
1562             else
1563               dist_demerit = 0;
1564           }
1565           else
1566             dist_demerit = dist; /* default if no widths available */
1567
1568           score = dist_demerit + len_score / len;
1569
1570           /* and we search for the smallest score */
1571           if (score < seg1->score)
1572           {
1573             seg1->score = score;
1574             seg1->link = seg2;
1575           }
1576
1577           if (score < seg2->score)
1578           {
1579             seg2->score = score;
1580             seg2->link = seg1;
1581           }
1582         }
1583       }
1584     }
1585   }
1586
1587   /* now compute the `serif' segments, cf. explanations in `tahints.h' */
1588   for (seg1 = segments; seg1 < segment_limit; seg1++)
1589   {
1590     seg2 = seg1->link;
1591
1592     if (seg2)
1593     {
1594       if (seg2->link != seg1)
1595       {
1596         seg1->link = 0;
1597         seg1->serif = seg2->link;
1598       }
1599     }
1600   }
1601 }
1602
1603
1604 /* link segments to edges, using feature analysis for selection */
1605
1606 FT_Error
1607 ta_latin_hints_compute_edges(TA_GlyphHints hints,
1608                              TA_Dimension dim)
1609 {
1610   TA_AxisHints axis = &hints->axis[dim];
1611   FT_Error error = FT_Err_Ok;
1612   TA_LatinAxis laxis = &((TA_LatinMetrics)hints->metrics)->axis[dim];
1613
1614   TA_Segment segments = axis->segments;
1615   TA_Segment segment_limit = segments + axis->num_segments;
1616   TA_Segment seg;
1617
1618 #if 0
1619   TA_Direction up_dir;
1620 #endif
1621   FT_Fixed scale;
1622   FT_Pos edge_distance_threshold;
1623   FT_Pos segment_length_threshold;
1624
1625
1626   axis->num_edges = 0;
1627
1628   scale = (dim == TA_DIMENSION_HORZ) ? hints->x_scale
1629                                      : hints->y_scale;
1630
1631 #if 0
1632   up_dir = (dim == TA_DIMENSION_HORZ) ? TA_DIR_UP
1633                                       : TA_DIR_RIGHT;
1634 #endif
1635
1636   /* we ignore all segments that are less than 1 pixel in length */
1637   /* to avoid many problems with serif fonts */
1638   /* (the corresponding threshold is computed in font units) */
1639   if (dim == TA_DIMENSION_HORZ)
1640     segment_length_threshold = FT_DivFix(64, hints->y_scale);
1641   else
1642     segment_length_threshold = 0;
1643
1644   /********************************************************************/
1645   /*                                                                  */
1646   /* We begin by generating a sorted table of edges for the current   */
1647   /* direction. To do so, we simply scan each segment and try to find */
1648   /* an edge in our table that corresponds to its position.           */
1649   /*                                                                  */
1650   /* If no edge is found, we create and insert a new edge in the      */
1651   /* sorted table. Otherwise, we simply add the segment to the edge's */
1652   /* list which gets processed in the second step to compute the      */
1653   /* edge's properties.                                               */
1654   /*                                                                  */
1655   /* Note that the table of edges is sorted along the segment/edge    */
1656   /* position.                                                        */
1657   /*                                                                  */
1658   /********************************************************************/
1659
1660   /* assure that edge distance threshold is at most 0.25px */
1661   edge_distance_threshold = FT_MulFix(laxis->edge_distance_threshold,
1662                                       scale);
1663   if (edge_distance_threshold > 64 / 4)
1664     edge_distance_threshold = 64 / 4;
1665
1666   edge_distance_threshold = FT_DivFix(edge_distance_threshold,
1667                                       scale);
1668
1669   for (seg = segments; seg < segment_limit; seg++)
1670   {
1671     TA_Edge found = NULL;
1672     FT_Int ee;
1673
1674
1675     if (seg->height < segment_length_threshold)
1676       continue;
1677
1678     /* a special case for serif edges: */
1679     /* if they are smaller than 1.5 pixels we ignore them */
1680     if (seg->serif
1681         && 2 * seg->height < 3 * segment_length_threshold)
1682       continue;
1683
1684     /* look for an edge corresponding to the segment */
1685     for (ee = 0; ee < axis->num_edges; ee++)
1686     {
1687       TA_Edge edge = axis->edges + ee;
1688       FT_Pos dist;
1689
1690
1691       dist = seg->pos - edge->fpos;
1692       if (dist < 0)
1693         dist = -dist;
1694
1695       if (dist < edge_distance_threshold && edge->dir == seg->dir)
1696       {
1697         found = edge;
1698         break;
1699       }
1700     }
1701
1702     if (!found)
1703     {
1704       TA_Edge edge;
1705
1706
1707       /* insert a new edge in the list and sort according to the position */
1708       error = ta_axis_hints_new_edge(axis, seg->pos,
1709                                      (TA_Direction)seg->dir,
1710                                      &edge);
1711       if (error)
1712         goto Exit;
1713
1714       /* add the segment to the new edge's list */
1715       memset(edge, 0, sizeof (TA_EdgeRec));
1716       edge->first = seg;
1717       edge->last = seg;
1718       edge->dir = seg->dir;
1719       edge->fpos = seg->pos;
1720       edge->opos = FT_MulFix(seg->pos, scale);
1721       edge->pos = edge->opos;
1722       seg->edge_next = seg;
1723     }
1724     else
1725     {
1726       /* if an edge was found, simply add the segment to the edge's list */
1727       seg->edge_next = found->first;
1728       found->last->edge_next = seg;
1729       found->last = seg;
1730     }
1731   }
1732
1733   /*****************************************************************/
1734   /*                                                               */
1735   /* Good, we now compute each edge's properties according to      */
1736   /* the segments found on its position.  Basically, these are     */
1737   /*                                                               */
1738   /* - the edge's main direction                                   */
1739   /* - stem edge, serif edge or both (which defaults to stem then) */
1740   /* - rounded edge, straight or both (which defaults to straight) */
1741   /* - link for edge                                               */
1742   /*                                                               */
1743   /*****************************************************************/
1744
1745   /* first of all, set the `edge' field in each segment -- this is */
1746   /* required in order to compute edge links */
1747
1748   /* note that removing this loop and setting the `edge' field of each */
1749   /* segment directly in the code above slows down execution speed for */
1750   /* some reasons on platforms like the Sun */
1751   {
1752     TA_Edge edges = axis->edges;
1753     TA_Edge edge_limit = edges + axis->num_edges;
1754     TA_Edge edge;
1755
1756
1757     for (edge = edges; edge < edge_limit; edge++)
1758     {
1759       seg = edge->first;
1760       if (seg)
1761         do
1762         {
1763           seg->edge = edge;
1764           seg = seg->edge_next;
1765         } while (seg != edge->first);
1766     }
1767
1768     /* now compute each edge properties */
1769     for (edge = edges; edge < edge_limit; edge++)
1770     {
1771       FT_Int is_round = 0; /* does it contain round segments? */
1772       FT_Int is_straight = 0; /* does it contain straight segments? */
1773 #if 0
1774       FT_Pos ups = 0; /* number of upwards segments */
1775       FT_Pos downs = 0; /* number of downwards segments */
1776 #endif
1777
1778
1779       seg = edge->first;
1780
1781       do
1782       {
1783         FT_Bool is_serif;
1784
1785
1786         /* check for roundness of segment */
1787         if (seg->flags & TA_EDGE_ROUND)
1788           is_round++;
1789         else
1790           is_straight++;
1791
1792 #if 0
1793         /* check for segment direction */
1794         if (seg->dir == up_dir)
1795           ups += seg->max_coord - seg->min_coord;
1796         else
1797           downs += seg->max_coord - seg->min_coord;
1798 #endif
1799
1800         /* check for links -- */
1801         /* if seg->serif is set, then seg->link must be ignored */
1802         is_serif = (FT_Bool)(seg->serif
1803                              && seg->serif->edge
1804                              && seg->serif->edge != edge);
1805
1806         if ((seg->link && seg->link->edge != NULL)
1807             || is_serif)
1808         {
1809           TA_Edge edge2;
1810           TA_Segment seg2;
1811
1812
1813           edge2 = edge->link;
1814           seg2 = seg->link;
1815
1816           if (is_serif)
1817           {
1818             seg2 = seg->serif;
1819             edge2 = edge->serif;
1820           }
1821
1822           if (edge2)
1823           {
1824             FT_Pos edge_delta;
1825             FT_Pos seg_delta;
1826
1827
1828             edge_delta = edge->fpos - edge2->fpos;
1829             if (edge_delta < 0)
1830               edge_delta = -edge_delta;
1831
1832             seg_delta = seg->pos - seg2->pos;
1833             if (seg_delta < 0)
1834               seg_delta = -seg_delta;
1835
1836             if (seg_delta < edge_delta)
1837               edge2 = seg2->edge;
1838           }
1839           else
1840             edge2 = seg2->edge;
1841
1842           if (is_serif)
1843           {
1844             edge->serif = edge2;
1845             edge2->flags |= TA_EDGE_SERIF;
1846           }
1847           else
1848             edge->link = edge2;
1849         }
1850
1851         seg = seg->edge_next;
1852       } while (seg != edge->first);
1853
1854       /* set the round/straight flags */
1855       edge->flags = TA_EDGE_NORMAL;
1856
1857       if (is_round > 0
1858           && is_round >= is_straight)
1859         edge->flags |= TA_EDGE_ROUND;
1860
1861 #if 0
1862       /* set the edge's main direction */
1863       edge->dir = TA_DIR_NONE;
1864
1865       if (ups > downs)
1866         edge->dir = (FT_Char)up_dir;
1867
1868       else if (ups < downs)
1869         edge->dir = (FT_Char)-up_dir;
1870
1871       else if (ups == downs)
1872         edge->dir = 0; /* both up and down! */
1873 #endif
1874
1875       /* get rid of serifs if link is set */
1876       /* XXX: this gets rid of many unpleasant artefacts! */
1877       /* example: the `c' in cour.pfa at size 13 */
1878
1879       if (edge->serif && edge->link)
1880         edge->serif = 0;
1881     }
1882   }
1883
1884 Exit:
1885   return error;
1886 }
1887
1888
1889 /* detect segments and edges for given dimension */
1890
1891 FT_Error
1892 ta_latin_hints_detect_features(TA_GlyphHints hints,
1893                                FT_UInt width_count,
1894                                TA_WidthRec* widths,
1895                                TA_Dimension dim)
1896 {
1897   FT_Error error;
1898
1899
1900   error = ta_latin_hints_compute_segments(hints, dim);
1901   if (!error)
1902   {
1903     ta_latin_hints_link_segments(hints, width_count, widths, dim);
1904
1905     error = ta_latin_hints_compute_edges(hints, dim);
1906   }
1907
1908   return error;
1909 }
1910
1911
1912 /* compute all edges which lie within blue zones */
1913
1914 void
1915 ta_latin_hints_compute_blue_edges(TA_GlyphHints hints,
1916                                   TA_LatinMetrics metrics)
1917 {
1918   TA_AxisHints axis = &hints->axis[TA_DIMENSION_VERT];
1919
1920   TA_Edge edge = axis->edges;
1921   TA_Edge edge_limit = edge + axis->num_edges;
1922
1923   TA_LatinAxis latin = &metrics->axis[TA_DIMENSION_VERT];
1924   FT_Fixed scale = latin->scale;
1925
1926
1927   /* compute which blue zones are active, */
1928   /* i.e. have their scaled size < 3/4 pixels */
1929
1930   /* for each horizontal edge search the blue zone which is closest */
1931   for (; edge < edge_limit; edge++)
1932   {
1933     FT_UInt bb;
1934     TA_Width best_blue = NULL;
1935     FT_Bool best_blue_is_neutral = 0;
1936     FT_Pos best_dist; /* initial threshold */
1937
1938     FT_UInt best_blue_idx = 0;
1939     FT_Bool best_blue_is_shoot = 0;
1940
1941
1942     /* compute the initial threshold as a fraction of the EM size */
1943     /* (the value 40 is heuristic) */
1944     best_dist = FT_MulFix(metrics->units_per_em / 40, scale);
1945
1946     /* assure a minimum distance of 0.5px */
1947     if (best_dist > 64 / 2)
1948       best_dist = 64 / 2;
1949
1950     /* this loop also handles the two extra blue zones */
1951     /* for usWinAscent and usWinDescent */
1952     /* if option `windows-compatibility' is set */
1953     for (bb = 0;
1954          bb < latin->blue_count
1955               + (metrics->root.globals->font->windows_compatibility ? 2 : 0);
1956          bb++)
1957     {
1958       TA_LatinBlue blue = latin->blues + bb;
1959       FT_Bool is_top_blue, is_neutral_blue, is_major_dir;
1960
1961
1962       /* skip inactive blue zones (i.e., those that are too large) */
1963       if (!(blue->flags & TA_LATIN_BLUE_ACTIVE))
1964         continue;
1965
1966       /* if it is a top zone, check for right edges (against the major */
1967       /* direction); if it is a bottom zone, check for left edges (in */
1968       /* the major direction) */
1969       is_top_blue = (FT_Byte)((blue->flags & TA_LATIN_BLUE_TOP) != 0);
1970       is_neutral_blue = (FT_Byte)((blue->flags & TA_LATIN_BLUE_NEUTRAL) != 0);
1971       is_major_dir = FT_BOOL(edge->dir == axis->major_dir);
1972
1973       /* neutral blue zones are handled for both directions */
1974       if (is_top_blue ^ is_major_dir || is_neutral_blue)
1975       {
1976         FT_Pos dist;
1977
1978
1979         /* first of all, compare it to the reference position */
1980         dist = edge->fpos - blue->ref.org;
1981         if (dist < 0)
1982           dist = -dist;
1983
1984         dist = FT_MulFix(dist, scale);
1985         if (dist < best_dist)
1986         {
1987           best_dist = dist;
1988           best_blue = &blue->ref;
1989           best_blue_is_neutral = is_neutral_blue;
1990
1991           best_blue_idx = bb;
1992           best_blue_is_shoot = 0;
1993         }
1994
1995         /* now compare it to the overshoot position and check whether */
1996         /* the edge is rounded, and whether the edge is over the */
1997         /* reference position of a top zone, or under the reference */
1998         /* position of a bottom zone (provided we don't have a */
1999         /* neutral blue zone) */
2000         if (edge->flags & TA_EDGE_ROUND
2001             && dist != 0
2002             && !is_neutral_blue)
2003         {
2004           FT_Bool is_under_ref = FT_BOOL(edge->fpos < blue->ref.org);
2005
2006
2007           if (is_top_blue ^ is_under_ref)
2008           {
2009             dist = edge->fpos - blue->shoot.org;
2010             if (dist < 0)
2011               dist = -dist;
2012
2013             dist = FT_MulFix(dist, scale);
2014             if (dist < best_dist)
2015             {
2016               best_dist = dist;
2017               best_blue = &blue->shoot;
2018               best_blue_is_neutral = is_neutral_blue;
2019
2020               best_blue_idx = bb;
2021               best_blue_is_shoot = 1;
2022             }
2023           }
2024         }
2025       }
2026     }
2027
2028     if (best_blue)
2029     {
2030       edge->blue_edge = best_blue;
2031       edge->best_blue_idx = best_blue_idx;
2032       edge->best_blue_is_shoot = best_blue_is_shoot;
2033       if (best_blue_is_neutral)
2034         edge->flags |= TA_EDGE_NEUTRAL;
2035     }
2036   }
2037 }
2038
2039
2040 /* initalize hinting engine */
2041
2042 static FT_Error
2043 ta_latin_hints_init(TA_GlyphHints hints,
2044                     TA_LatinMetrics metrics)
2045 {
2046   FT_Render_Mode mode;
2047   FT_UInt32 scaler_flags, other_flags;
2048   FT_Face face = metrics->root.scaler.face;
2049
2050
2051   ta_glyph_hints_rescale(hints, (TA_StyleMetrics)metrics);
2052
2053   /* correct x_scale and y_scale if needed, since they may have */
2054   /* been modified by `ta_latin_metrics_scale_dim' above */
2055   hints->x_scale = metrics->axis[TA_DIMENSION_HORZ].scale;
2056   hints->x_delta = metrics->axis[TA_DIMENSION_HORZ].delta;
2057   hints->y_scale = metrics->axis[TA_DIMENSION_VERT].scale;
2058   hints->y_delta = metrics->axis[TA_DIMENSION_VERT].delta;
2059
2060   /* compute flags depending on render mode, etc. */
2061   mode = metrics->root.scaler.render_mode;
2062
2063 #if 0 /* #ifdef TA_CONFIG_OPTION_USE_WARPER */
2064   if (mode == FT_RENDER_MODE_LCD
2065       || mode == FT_RENDER_MODE_LCD_V)
2066     metrics->root.scaler.render_mode =
2067     mode = FT_RENDER_MODE_NORMAL;
2068 #endif
2069
2070   scaler_flags = hints->scaler_flags;
2071   other_flags = 0;
2072
2073   /* we snap the width of vertical stems for the monochrome */
2074   /* and horizontal LCD rendering targets only */
2075   if (mode == FT_RENDER_MODE_MONO
2076       || mode == FT_RENDER_MODE_LCD)
2077     other_flags |= TA_LATIN_HINTS_HORZ_SNAP;
2078
2079   /* we snap the width of horizontal stems for the monochrome */
2080   /* and vertical LCD rendering targets only */
2081   if (mode == FT_RENDER_MODE_MONO
2082       || mode == FT_RENDER_MODE_LCD_V)
2083     other_flags |= TA_LATIN_HINTS_VERT_SNAP;
2084
2085   /* we adjust stems to full pixels only if we don't use the `light' mode */
2086   if (mode != FT_RENDER_MODE_LIGHT)
2087     other_flags |= TA_LATIN_HINTS_STEM_ADJUST;
2088
2089   if (mode == FT_RENDER_MODE_MONO)
2090     other_flags |= TA_LATIN_HINTS_MONO;
2091
2092   /* in `light' hinting mode we disable horizontal hinting completely; */
2093   /* we also do it if the face is italic */
2094   if (mode == FT_RENDER_MODE_LIGHT
2095       || (face->style_flags & FT_STYLE_FLAG_ITALIC) != 0)
2096     scaler_flags |= TA_SCALER_FLAG_NO_HORIZONTAL;
2097
2098   hints->scaler_flags = scaler_flags;
2099   hints->other_flags = other_flags;
2100
2101   return FT_Err_Ok;
2102 }
2103
2104
2105 /* snap a given width in scaled coordinates to */
2106 /* one of the current standard widths */
2107
2108 static FT_Pos
2109 ta_latin_snap_width(TA_Width widths,
2110                     FT_Int count,
2111                     FT_Pos width)
2112 {
2113   int n;
2114   FT_Pos best = 64 + 32 + 2;
2115   FT_Pos reference = width;
2116   FT_Pos scaled;
2117
2118
2119   for (n = 0; n < count; n++)
2120   {
2121     FT_Pos w;
2122     FT_Pos dist;
2123
2124
2125     w = widths[n].cur;
2126     dist = width - w;
2127     if (dist < 0)
2128       dist = -dist;
2129     if (dist < best)
2130     {
2131       best = dist;
2132       reference = w;
2133     }
2134   }
2135
2136   scaled = TA_PIX_ROUND(reference);
2137
2138   if (width >= reference)
2139   {
2140     if (width < scaled + 48)
2141       width = reference;
2142   }
2143   else
2144   {
2145     if (width > scaled - 48)
2146       width = reference;
2147   }
2148
2149    return width;
2150 }
2151
2152
2153 /* compute the snapped width of a given stem, ignoring very thin ones */
2154
2155 /* there is a lot of voodoo in this function; changing the hard-coded */
2156 /* parameters influences the whole hinting process */
2157
2158 static FT_Pos
2159 ta_latin_compute_stem_width(TA_GlyphHints hints,
2160                             TA_Dimension dim,
2161                             FT_Pos width,
2162                             FT_Byte base_flags,
2163                             FT_Byte stem_flags)
2164 {
2165   TA_LatinMetrics metrics = (TA_LatinMetrics) hints->metrics;
2166   TA_LatinAxis axis = &metrics->axis[dim];
2167
2168   FT_Pos dist = width;
2169   FT_Int sign = 0;
2170   FT_Int vertical = (dim == TA_DIMENSION_VERT);
2171
2172
2173   if (!TA_LATIN_HINTS_DO_STEM_ADJUST(hints)
2174       || axis->extra_light)
2175     return width;
2176
2177   if (dist < 0)
2178   {
2179     dist = -width;
2180     sign = 1;
2181   }
2182
2183   if ((vertical && !TA_LATIN_HINTS_DO_VERT_SNAP(hints))
2184       || (!vertical && !TA_LATIN_HINTS_DO_HORZ_SNAP(hints)))
2185   {
2186     /* smooth hinting process: very lightly quantize the stem width */
2187
2188     /* leave the widths of serifs alone */
2189     if ((stem_flags & TA_EDGE_SERIF)
2190         && vertical
2191         && (dist < 3 * 64))
2192       goto Done_Width;
2193     else if (base_flags & TA_EDGE_ROUND)
2194     {
2195       if (dist < 80)
2196         dist = 64;
2197     }
2198     else if (dist < 56)
2199       dist = 56;
2200
2201     if (axis->width_count > 0)
2202     {
2203       FT_Pos delta;
2204
2205
2206       /* compare to standard width */
2207       delta = dist - axis->widths[0].cur;
2208
2209       if (delta < 0)
2210         delta = -delta;
2211
2212       if (delta < 40)
2213       {
2214         dist = axis->widths[0].cur;
2215         if (dist < 48)
2216           dist = 48;
2217
2218         goto Done_Width;
2219       }
2220
2221       if (dist < 3 * 64)
2222       {
2223         delta = dist & 63;
2224         dist &= -64;
2225
2226         if (delta < 10)
2227           dist += delta;
2228         else if (delta < 32)
2229           dist += 10;
2230         else if (delta < 54)
2231           dist += 54;
2232         else
2233           dist += delta;
2234       }
2235       else
2236         dist = (dist + 32) & ~63;
2237     }
2238   }
2239   else
2240   {
2241     /* strong hinting process: snap the stem width to integer pixels */
2242
2243     FT_Pos org_dist = dist;
2244
2245
2246     dist = ta_latin_snap_width(axis->widths, axis->width_count, dist);
2247
2248     if (vertical)
2249     {
2250       /* in the case of vertical hinting, */
2251       /* always round the stem heights to integer pixels */
2252
2253       if (dist >= 64)
2254         dist = (dist + 16) & ~63;
2255       else
2256         dist = 64;
2257     }
2258     else
2259     {
2260       if (TA_LATIN_HINTS_DO_MONO(hints))
2261       {
2262         /* monochrome horizontal hinting: */
2263         /* snap widths to integer pixels with a different threshold */
2264
2265         if (dist < 64)
2266           dist = 64;
2267         else
2268           dist = (dist + 32) & ~63;
2269       }
2270       else
2271       {
2272         /* for horizontal anti-aliased hinting, we adopt a more subtle */
2273         /* approach: we strengthen small stems, round stems whose size */
2274         /* is between 1 and 2 pixels to an integer, otherwise nothing */
2275
2276         if (dist < 48)
2277           dist = (dist + 64) >> 1;
2278
2279         else if (dist < 128)
2280         {
2281           /* we only round to an integer width if the corresponding */
2282           /* distortion is less than 1/4 pixel -- otherwise, this */
2283           /* makes everything worse since the diagonals, which are */
2284           /* not hinted, appear a lot bolder or thinner than the */
2285           /* vertical stems */
2286
2287           FT_Pos delta;
2288
2289
2290           dist = (dist + 22) & ~63;
2291           delta = dist - org_dist;
2292           if (delta < 0)
2293             delta = -delta;
2294
2295           if (delta >= 16)
2296           {
2297             dist = org_dist;
2298             if (dist < 48)
2299               dist = (dist + 64) >> 1;
2300           }
2301         }
2302         else
2303           /* round otherwise to prevent color fringes in LCD mode */
2304           dist = (dist + 32) & ~63;
2305       }
2306     }
2307   }
2308
2309 Done_Width:
2310   if (sign)
2311     dist = -dist;
2312
2313   return dist;
2314 }
2315
2316
2317 /* align one stem edge relative to the previous stem edge */
2318
2319 static void
2320 ta_latin_align_linked_edge(TA_GlyphHints hints,
2321                            TA_Dimension dim,
2322                            TA_Edge base_edge,
2323                            TA_Edge stem_edge)
2324 {
2325   FT_Pos dist = stem_edge->opos - base_edge->opos;
2326
2327   FT_Pos fitted_width = ta_latin_compute_stem_width(
2328                            hints, dim, dist,
2329                            base_edge->flags,
2330                            stem_edge->flags);
2331
2332
2333   stem_edge->pos = base_edge->pos + fitted_width;
2334
2335   TA_LOG(("  LINK: edge %d (opos=%.2f) linked to %.2f,"
2336             " dist was %.2f, now %.2f\n",
2337           stem_edge - hints->axis[dim].edges, stem_edge->opos / 64.0,
2338           stem_edge->pos / 64.0, dist / 64.0, fitted_width / 64.0));
2339
2340   if (hints->recorder)
2341     hints->recorder(ta_link, hints, dim,
2342                     base_edge, stem_edge, NULL, NULL, NULL);
2343 }
2344
2345
2346 /* shift the coordinates of the `serif' edge by the same amount */
2347 /* as the corresponding `base' edge has been moved already */
2348
2349 static void
2350 ta_latin_align_serif_edge(TA_GlyphHints hints,
2351                           TA_Edge base,
2352                           TA_Edge serif)
2353 {
2354   FT_UNUSED(hints);
2355
2356   serif->pos = base->pos + (serif->opos - base->opos);
2357 }
2358
2359
2360 /* the main grid-fitting routine */
2361
2362 void
2363 ta_latin_hint_edges(TA_GlyphHints hints,
2364                     TA_Dimension dim)
2365 {
2366   TA_AxisHints axis = &hints->axis[dim];
2367
2368   TA_Edge edges = axis->edges;
2369   TA_Edge edge_limit = edges + axis->num_edges;
2370   FT_PtrDist n_edges;
2371   TA_Edge edge;
2372
2373   TA_Edge anchor = NULL;
2374   FT_Int has_serifs = 0;
2375
2376 #ifdef TA_DEBUG
2377   FT_UInt num_actions = 0;
2378 #endif
2379
2380   TA_LOG(("latin %s edge hinting (style `%s')\n",
2381           dim == TA_DIMENSION_VERT ? "horizontal" : "vertical",
2382           ta_style_names[hints->metrics->style_class->style]));
2383
2384   /* we begin by aligning all stems relative to the blue zone if needed -- */
2385   /* that's only for horizontal edges */
2386
2387   if (dim == TA_DIMENSION_VERT
2388       && TA_HINTS_DO_BLUES(hints))
2389   {
2390     for (edge = edges; edge < edge_limit; edge++)
2391     {
2392       TA_Width blue;
2393       TA_Edge edge1, edge2; /* these edges form the stem to check */
2394
2395
2396       if (edge->flags & TA_EDGE_DONE)
2397         continue;
2398
2399       edge1 = NULL;
2400       edge2 = edge->link;
2401
2402       /*
2403        * If a stem contains both a neutral and a non-neutral blue zone,
2404        * skip the neutral one.  Otherwise, outlines with different
2405        * directions might be incorrectly aligned at the same vertical
2406        * position.
2407        *
2408        * If we have two neutral blue zones, skip one of them.
2409        */
2410       if (edge->blue_edge && edge2 && edge2->blue_edge)
2411       {
2412         FT_Byte neutral = edge->flags & TA_EDGE_NEUTRAL;
2413         FT_Byte neutral2 = edge2->flags & TA_EDGE_NEUTRAL;
2414
2415
2416         if ((neutral && neutral2) || neutral2)
2417         {
2418           edge2->blue_edge = NULL;
2419           edge2->flags &= ~TA_EDGE_NEUTRAL;
2420         }
2421         else if (neutral)
2422         {
2423           edge->blue_edge = NULL;
2424           edge->flags &= ~TA_EDGE_NEUTRAL;
2425         }
2426       }
2427
2428       blue = edge->blue_edge;
2429       if (blue)
2430         edge1 = edge;
2431
2432       /* flip edges if the other edge is aligned to a blue zone */
2433       else if (edge2 && edge2->blue_edge)
2434       {
2435         blue = edge2->blue_edge;
2436         edge1 = edge2;
2437         edge2 = edge;
2438       }
2439
2440       if (!edge1)
2441         continue;
2442
2443 #ifdef TA_DEBUG
2444       if (!anchor)
2445         TA_LOG(("  BLUE_ANCHOR: edge %d (opos=%.2f) snapped to %.2f,"
2446                   " was %.2f (anchor=edge %d)\n",
2447                 edge1 - edges, edge1->opos / 64.0, blue->fit / 64.0,
2448                 edge1->pos / 64.0, edge - edges));
2449       else
2450         TA_LOG(("  BLUE: edge %d (opos=%.2f) snapped to %.2f, was %.2f\n",
2451                 edge1 - edges, edge1->opos / 64.0, blue->fit / 64.0,
2452                 edge1->pos / 64.0));
2453
2454       num_actions++;
2455 #endif
2456
2457       edge1->pos = blue->fit;
2458       edge1->flags |= TA_EDGE_DONE;
2459
2460       if (hints->recorder)
2461       {
2462         if (!anchor)
2463           hints->recorder(ta_blue_anchor, hints, dim,
2464                           edge1, edge, NULL, NULL, NULL);
2465         else
2466           hints->recorder(ta_blue, hints, dim,
2467                           edge1, NULL, NULL, NULL, NULL);
2468       }
2469
2470       if (edge2 && !edge2->blue_edge)
2471       {
2472         ta_latin_align_linked_edge(hints, dim, edge1, edge2);
2473         edge2->flags |= TA_EDGE_DONE;
2474
2475 #ifdef TA_DEBUG
2476         num_actions++;
2477 #endif
2478       }
2479
2480       if (!anchor)
2481         anchor = edge;
2482     }
2483   }
2484
2485   /* now we align all other stem edges, */
2486   /* trying to maintain the relative order of stems in the glyph */
2487   for (edge = edges; edge < edge_limit; edge++)
2488   {
2489     TA_Edge edge2;
2490
2491
2492     if (edge->flags & TA_EDGE_DONE)
2493       continue;
2494
2495     /* skip all non-stem edges */
2496     edge2 = edge->link;
2497     if (!edge2)
2498     {
2499       has_serifs++;
2500       continue;
2501     }
2502
2503     /* now align the stem */
2504
2505     /* this should not happen, but it's better to be safe */
2506     if (edge2->blue_edge)
2507     {
2508       TA_LOG(("  ASSERTION FAILED for edge %d\n", edge2 - edges));
2509
2510       ta_latin_align_linked_edge(hints, dim, edge2, edge);
2511       edge->flags |= TA_EDGE_DONE;
2512
2513 #ifdef TA_DEBUG
2514       num_actions++;
2515 #endif
2516       continue;
2517     }
2518
2519     if (!anchor)
2520     {
2521       /* if we reach this if clause, no stem has been aligned yet */
2522
2523       FT_Pos org_len, org_center, cur_len;
2524       FT_Pos cur_pos1, error1, error2, u_off, d_off;
2525
2526
2527       org_len = edge2->opos - edge->opos;
2528       cur_len = ta_latin_compute_stem_width(hints, dim, org_len,
2529                                             edge->flags, edge2->flags);
2530
2531       /* some voodoo to specially round edges for small stem widths; */
2532       /* the idea is to align the center of a stem, */
2533       /* then shifting the stem edges to suitable positions */
2534       if (cur_len <= 64)
2535       {
2536         /* width <= 1px */
2537         u_off = 32;
2538         d_off = 32;
2539       }
2540       else
2541       {
2542         /* 1px < width < 1.5px */
2543         u_off = 38;
2544         d_off = 26;
2545       }
2546
2547       if (cur_len < 96)
2548       {
2549         org_center = edge->opos + (org_len >> 1);
2550         cur_pos1 = TA_PIX_ROUND(org_center);
2551
2552         error1 = org_center - (cur_pos1 - u_off);
2553         if (error1 < 0)
2554           error1 = -error1;
2555
2556         error2 = org_center - (cur_pos1 + d_off);
2557         if (error2 < 0)
2558           error2 = -error2;
2559
2560         if (error1 < error2)
2561           cur_pos1 -= u_off;
2562         else
2563           cur_pos1 += d_off;
2564
2565         edge->pos = cur_pos1 - cur_len / 2;
2566         edge2->pos = edge->pos + cur_len;
2567       }
2568       else
2569         edge->pos = TA_PIX_ROUND(edge->opos);
2570
2571       anchor = edge;
2572       edge->flags |= TA_EDGE_DONE;
2573
2574       TA_LOG(("  ANCHOR: edge %d (opos=%.2f) and %d (opos=%.2f)"
2575                 " snapped to %.2f and %.2f\n",
2576               edge - edges, edge->opos / 64.0,
2577               edge2 - edges, edge2->opos / 64.0,
2578               edge->pos / 64.0, edge2->pos / 64.0));
2579
2580       if (hints->recorder)
2581         hints->recorder(ta_anchor, hints, dim,
2582                         edge, edge2, NULL, NULL, NULL);
2583
2584       ta_latin_align_linked_edge(hints, dim, edge, edge2);
2585
2586 #ifdef TA_DEBUG
2587       num_actions += 2;
2588 #endif
2589     }
2590     else
2591     {
2592       FT_Pos org_pos, org_len, org_center, cur_len;
2593       FT_Pos cur_pos1, cur_pos2, delta1, delta2;
2594
2595
2596       org_pos = anchor->pos + (edge->opos - anchor->opos);
2597       org_len = edge2->opos - edge->opos;
2598       org_center = org_pos + (org_len >> 1);
2599
2600       cur_len = ta_latin_compute_stem_width(hints, dim, org_len,
2601                                             edge->flags, edge2->flags);
2602
2603       if (edge2->flags & TA_EDGE_DONE)
2604       {
2605         TA_LOG(("  ADJUST: edge %d (pos=%.2f) moved to %.2f\n",
2606                 edge - edges, edge->pos / 64.0,
2607                 (edge2->pos - cur_len) / 64.0));
2608
2609         edge->pos = edge2->pos - cur_len;
2610
2611         if (hints->recorder)
2612         {
2613           TA_Edge bound = NULL;
2614
2615
2616           if (edge > edges)
2617             bound = &edge[-1];
2618
2619           hints->recorder(ta_adjust, hints, dim,
2620                           edge, edge2, NULL, bound, NULL);
2621         }
2622       }
2623
2624       else if (cur_len < 96)
2625       {
2626         FT_Pos u_off, d_off;
2627
2628
2629         cur_pos1 = TA_PIX_ROUND(org_center);
2630
2631         if (cur_len <= 64)
2632         {
2633           u_off = 32;
2634           d_off = 32;
2635         }
2636         else
2637         {
2638           u_off = 38;
2639           d_off = 26;
2640         }
2641
2642         delta1 = org_center - (cur_pos1 - u_off);
2643         if (delta1 < 0)
2644           delta1 = -delta1;
2645
2646         delta2 = org_center - (cur_pos1 + d_off);
2647         if (delta2 < 0)
2648           delta2 = -delta2;
2649
2650         if (delta1 < delta2)
2651           cur_pos1 -= u_off;
2652         else
2653           cur_pos1 += d_off;
2654
2655         edge->pos = cur_pos1 - cur_len / 2;
2656         edge2->pos = cur_pos1 + cur_len / 2;
2657
2658         TA_LOG(("  STEM: edge %d (opos=%.2f) linked to %d (opos=%.2f)"
2659                   " snapped to %.2f and %.2f\n",
2660                 edge - edges, edge->opos / 64.0,
2661                 edge2 - edges, edge2->opos / 64.0,
2662                 edge->pos / 64.0, edge2->pos / 64.0));
2663
2664         if (hints->recorder)
2665         {
2666           TA_Edge bound = NULL;
2667
2668
2669           if (edge > edges)
2670             bound = &edge[-1];
2671
2672           hints->recorder(ta_stem, hints, dim,
2673                           edge, edge2, NULL, bound, NULL);
2674         }
2675       }
2676
2677       else
2678       {
2679         org_pos = anchor->pos + (edge->opos - anchor->opos);
2680         org_len = edge2->opos - edge->opos;
2681         org_center = org_pos + (org_len >> 1);
2682
2683         cur_len = ta_latin_compute_stem_width(hints, dim, org_len,
2684                                               edge->flags, edge2->flags);
2685
2686         cur_pos1 = TA_PIX_ROUND(org_pos);
2687         delta1 = cur_pos1 + (cur_len >> 1) - org_center;
2688         if (delta1 < 0)
2689           delta1 = -delta1;
2690
2691         cur_pos2 = TA_PIX_ROUND(org_pos + org_len) - cur_len;
2692         delta2 = cur_pos2 + (cur_len >> 1) - org_center;
2693         if (delta2 < 0)
2694           delta2 = -delta2;
2695
2696         edge->pos = (delta1 < delta2) ? cur_pos1 : cur_pos2;
2697         edge2->pos = edge->pos + cur_len;
2698
2699         TA_LOG(("  STEM: edge %d (opos=%.2f) linked to %d (opos=%.2f)"
2700                   " snapped to %.2f and %.2f\n",
2701                 edge - edges, edge->opos / 64.0,
2702                 edge2 - edges, edge2->opos / 64.0,
2703                 edge->pos / 64.0, edge2->pos / 64.0));
2704
2705         if (hints->recorder)
2706         {
2707           TA_Edge bound = NULL;
2708
2709
2710           if (edge > edges)
2711             bound = &edge[-1];
2712
2713           hints->recorder(ta_stem, hints, dim,
2714                           edge, edge2, NULL, bound, NULL);
2715         }
2716       }
2717
2718 #ifdef TA_DEBUG
2719       num_actions++;
2720 #endif
2721
2722       edge->flags |= TA_EDGE_DONE;
2723       edge2->flags |= TA_EDGE_DONE;
2724
2725       if (edge > edges
2726           && edge->pos < edge[-1].pos)
2727       {
2728 #ifdef TA_DEBUG
2729         TA_LOG(("  BOUND: edge %d (pos=%.2f) moved to %.2f\n",
2730                 edge - edges, edge->pos / 64.0, edge[-1].pos / 64.0));
2731
2732         num_actions++;
2733 #endif
2734
2735         edge->pos = edge[-1].pos;
2736
2737         if (hints->recorder)
2738           hints->recorder(ta_bound, hints, dim,
2739                           edge, &edge[-1], NULL, NULL, NULL);
2740       }
2741     }
2742   }
2743
2744   /* make sure that lowercase m's maintain their symmetry */
2745
2746   /* In general, lowercase m's have six vertical edges if they are sans */
2747   /* serif, or twelve if they are with serifs.  This implementation is  */
2748   /* based on that assumption, and seems to work very well with most    */
2749   /* faces.  However, if for a certain face this assumption is not      */
2750   /* true, the m is just rendered like before.  In addition, any stem   */
2751   /* correction will only be applied to symmetrical glyphs (even if the */
2752   /* glyph is not an m), so the potential for unwanted distortion is    */
2753   /* relatively low.                                                    */
2754
2755   /* we don't handle horizontal edges since we can't easily assure that */
2756   /* the third (lowest) stem aligns with the base line; it might end up */
2757   /* one pixel higher or lower */
2758
2759   n_edges = edge_limit - edges;
2760   if (dim == TA_DIMENSION_HORZ
2761       && (n_edges == 6 || n_edges == 12))
2762   {
2763     TA_Edge edge1, edge2, edge3;
2764     FT_Pos dist1, dist2, span, delta;
2765
2766
2767     if (n_edges == 6)
2768     {
2769       edge1 = edges;
2770       edge2 = edges + 2;
2771       edge3 = edges + 4;
2772     }
2773     else
2774     {
2775       edge1 = edges + 1;
2776       edge2 = edges + 5;
2777       edge3 = edges + 9;
2778     }
2779
2780     dist1 = edge2->opos - edge1->opos;
2781     dist2 = edge3->opos - edge2->opos;
2782
2783     span = dist1 - dist2;
2784     if (span < 0)
2785       span = -span;
2786
2787     if (span < 8)
2788     {
2789       delta = edge3->pos - (2 * edge2->pos - edge1->pos);
2790       edge3->pos -= delta;
2791       if (edge3->link)
2792         edge3->link->pos -= delta;
2793
2794       /* move the serifs along with the stem */
2795       if (n_edges == 12)
2796       {
2797         (edges + 8)->pos -= delta;
2798         (edges + 11)->pos -= delta;
2799       }
2800
2801       edge3->flags |= TA_EDGE_DONE;
2802       if (edge3->link)
2803         edge3->link->flags |= TA_EDGE_DONE;
2804     }
2805   }
2806
2807   if (has_serifs || !anchor)
2808   {
2809     /* now hint the remaining edges (serifs and single) */
2810     /* in order to complete our processing */
2811     for (edge = edges; edge < edge_limit; edge++)
2812     {
2813       TA_Edge lower_bound = NULL;
2814       TA_Edge upper_bound = NULL;
2815
2816       FT_Pos delta;
2817
2818
2819       if (edge->flags & TA_EDGE_DONE)
2820         continue;
2821
2822       delta = 1000;
2823
2824       if (edge->serif)
2825       {
2826         delta = edge->serif->opos - edge->opos;
2827         if (delta < 0)
2828           delta = -delta;
2829       }
2830
2831       if (edge > edges)
2832         lower_bound = &edge[-1];
2833
2834       if (edge + 1 < edge_limit
2835           && edge[1].flags & TA_EDGE_DONE)
2836         upper_bound = &edge[1];
2837
2838
2839       if (delta < 64 + 16)
2840       {
2841         ta_latin_align_serif_edge(hints, edge->serif, edge);
2842
2843         TA_LOG(("  SERIF: edge %d (opos=%.2f) serif to %d (opos=%.2f)"
2844                   " aligned to %.2f\n",
2845                 edge - edges, edge->opos / 64.0,
2846                 edge->serif - edges, edge->serif->opos / 64.0,
2847                 edge->pos / 64.0));
2848
2849         if (hints->recorder)
2850           hints->recorder(ta_serif, hints, dim,
2851                           edge, NULL, NULL, lower_bound, upper_bound);
2852       }
2853       else if (!anchor)
2854       {
2855         edge->pos = TA_PIX_ROUND(edge->opos);
2856         anchor = edge;
2857
2858         TA_LOG(("  SERIF_ANCHOR: edge %d (opos=%.2f) snapped to %.2f\n",
2859                 edge - edges, edge->opos / 64.0, edge->pos / 64.0));
2860
2861         if (hints->recorder)
2862           hints->recorder(ta_serif_anchor, hints, dim,
2863                           edge, NULL, NULL, lower_bound, upper_bound);
2864       }
2865       else
2866       {
2867         TA_Edge before, after;
2868
2869
2870         for (before = edge - 1; before >= edges; before--)
2871           if (before->flags & TA_EDGE_DONE)
2872             break;
2873
2874         for (after = edge + 1; after < edge_limit; after++)
2875           if (after->flags & TA_EDGE_DONE)
2876             break;
2877
2878         if (before >= edges && before < edge
2879             && after < edge_limit && after > edge)
2880         {
2881           if (after->opos == before->opos)
2882             edge->pos = before->pos;
2883           else
2884             edge->pos = before->pos + FT_MulDiv(edge->opos - before->opos,
2885                                                 after->pos - before->pos,
2886                                                 after->opos - before->opos);
2887
2888           TA_LOG(("  SERIF_LINK1: edge %d (opos=%.2f) snapped to %.2f"
2889                     " from %d (opos=%.2f)\n",
2890                   edge - edges, edge->opos / 64.0,
2891                   edge->pos / 64.0,
2892                   before - edges, before->opos / 64.0));
2893
2894           if (hints->recorder)
2895             hints->recorder(ta_serif_link1, hints, dim,
2896                             edge, before, after, lower_bound, upper_bound);
2897         }
2898         else
2899         {
2900           edge->pos = anchor->pos + ((edge->opos - anchor->opos + 16) & ~31);
2901           TA_LOG(("  SERIF_LINK2: edge %d (opos=%.2f) snapped to %.2f\n",
2902                   edge - edges, edge->opos / 64.0, edge->pos / 64.0));
2903
2904           if (hints->recorder)
2905             hints->recorder(ta_serif_link2, hints, dim,
2906                             edge, NULL, NULL, lower_bound, upper_bound);
2907         }
2908       }
2909
2910 #ifdef TA_DEBUG
2911       num_actions++;
2912 #endif
2913       edge->flags |= TA_EDGE_DONE;
2914
2915       if (edge > edges
2916           && edge->pos < edge[-1].pos)
2917       {
2918 #ifdef TA_DEBUG
2919         TA_LOG(("  BOUND: edge %d (pos=%.2f) moved to %.2f\n",
2920                 edge - edges, edge->pos / 64.0, edge[-1].pos / 64.0));
2921         num_actions++;
2922 #endif
2923
2924         edge->pos = edge[-1].pos;
2925
2926         if (hints->recorder)
2927           hints->recorder(ta_bound, hints, dim,
2928                           edge, &edge[-1], NULL, NULL, NULL);
2929       }
2930
2931       if (edge + 1 < edge_limit
2932           && edge[1].flags & TA_EDGE_DONE
2933           && edge->pos > edge[1].pos)
2934       {
2935 #ifdef TA_DEBUG
2936         TA_LOG(("  BOUND: edge %d (pos=%.2f) moved to %.2f\n",
2937                 edge - edges, edge->pos / 64.0, edge[1].pos / 64.0));
2938
2939         num_actions++;
2940 #endif
2941
2942         edge->pos = edge[1].pos;
2943
2944         if (hints->recorder)
2945           hints->recorder(ta_bound, hints, dim,
2946                           edge, &edge[1], NULL, NULL, NULL);
2947       }
2948     }
2949   }
2950
2951 #ifdef TA_DEBUG
2952   if (!num_actions)
2953     TA_LOG(("  (none)\n"));
2954   TA_LOG(("\n"));
2955 #endif
2956 }
2957
2958
2959 /* apply the complete hinting algorithm to a latin glyph */
2960
2961 static FT_Error
2962 ta_latin_hints_apply(TA_GlyphHints hints,
2963                      FT_Outline* outline,
2964                      TA_LatinMetrics metrics)
2965 {
2966   FT_Error error;
2967   int dim;
2968
2969   TA_LatinAxis axis;
2970
2971
2972   error = ta_glyph_hints_reload(hints, outline);
2973   if (error)
2974     goto Exit;
2975
2976   /* analyze glyph outline */
2977 #ifdef TA_CONFIG_OPTION_USE_WARPER
2978   if (metrics->root.scaler.render_mode == FT_RENDER_MODE_LIGHT
2979       || TA_HINTS_DO_HORIZONTAL(hints))
2980 #else
2981   if (TA_HINTS_DO_HORIZONTAL(hints))
2982 #endif
2983   {
2984     axis = &metrics->axis[TA_DIMENSION_HORZ];
2985     error = ta_latin_hints_detect_features(hints,
2986                                            axis->width_count,
2987                                            axis->widths,
2988                                            TA_DIMENSION_HORZ);
2989     if (error)
2990       goto Exit;
2991   }
2992
2993   if (TA_HINTS_DO_VERTICAL(hints))
2994   {
2995     axis = &metrics->axis[TA_DIMENSION_VERT];
2996     error = ta_latin_hints_detect_features(hints,
2997                                            axis->width_count,
2998                                            axis->widths,
2999                                            TA_DIMENSION_VERT);
3000     if (error)
3001       goto Exit;
3002
3003     ta_latin_hints_compute_blue_edges(hints, metrics);
3004   }
3005
3006   /* grid-fit the outline */
3007   for (dim = 0; dim < TA_DIMENSION_MAX; dim++)
3008   {
3009 #ifdef TA_CONFIG_OPTION_USE_WARPER
3010     if (dim == TA_DIMENSION_HORZ
3011         && metrics->root.scaler.render_mode == FT_RENDER_MODE_LIGHT)
3012     {
3013       TA_WarperRec warper;
3014       FT_Fixed scale;
3015       FT_Pos delta;
3016
3017
3018       ta_warper_compute(&warper, hints, (TA_Dimension)dim, &scale, &delta);
3019       ta_glyph_hints_scale_dim(hints, (TA_Dimension)dim, scale, delta);
3020
3021       continue;
3022     }
3023 #endif
3024
3025     if ((dim == TA_DIMENSION_HORZ && TA_HINTS_DO_HORIZONTAL(hints))
3026         || (dim == TA_DIMENSION_VERT && TA_HINTS_DO_VERTICAL(hints)))
3027     {
3028       ta_latin_hint_edges(hints, (TA_Dimension)dim);
3029       ta_glyph_hints_align_edge_points(hints, (TA_Dimension)dim);
3030       ta_glyph_hints_align_strong_points(hints, (TA_Dimension)dim);
3031       ta_glyph_hints_align_weak_points(hints, (TA_Dimension)dim);
3032     }
3033   }
3034
3035   ta_glyph_hints_save(hints, outline);
3036
3037 Exit:
3038   return error;
3039 }
3040
3041
3042 const TA_WritingSystemClassRec ta_latin_writing_system_class =
3043 {
3044   TA_WRITING_SYSTEM_LATIN,
3045
3046   sizeof (TA_LatinMetricsRec),
3047
3048   (TA_WritingSystem_InitMetricsFunc)ta_latin_metrics_init,
3049   (TA_WritingSystem_ScaleMetricsFunc)ta_latin_metrics_scale,
3050   (TA_WritingSystem_DoneMetricsFunc)NULL,
3051
3052   (TA_WritingSystem_InitHintsFunc)ta_latin_hints_init,
3053   (TA_WritingSystem_ApplyHintsFunc)ta_latin_hints_apply
3054 };
3055
3056 /* end of talatin.c */