lib/ttfautohint.c

   1 /* ttfautohint.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 /* This file needs FreeType 2.4.5 or newer. */
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <ctype.h>
  22
  23 #include "ta.h"
  24
  25
  26 #define DUMP_COLUMN "33"
  27
  28 #define COMPARE(str) \
  29           (len == (sizeof (str) - 1) \
  30            && !strncmp(start, str, sizeof (str) - 1))
  31 #define DUMPVAL(str, arg) \
  32           fprintf(stderr, "%" DUMP_COLUMN "s = %ld\n", \
  33                           (str), \
  34                           (FT_Long)(arg))
  35 #define DUMPSTR(str, arg) \
  36           fprintf(stderr, "%" DUMP_COLUMN "s = %s\n", \
  37                           (str), \
  38                           (arg))
  39 #define DUMPSTRX(arg) \
  40           fprintf(stderr, "%" DUMP_COLUMN "s   %s\n", \
  41                           "", \
  42                           (arg))
  43
  44
  45 void
  46 TA_sfnt_set_properties(SFNT* sfnt,
  47                        FONT* font)
  48 {
  49   TA_FaceGlobals globals = (TA_FaceGlobals)sfnt->face->autohint.data;
  50
  51
  52   globals->increase_x_height = font->increase_x_height;
  53 }
  54
  55
  56 TA_Error
  57 TTF_autohint(const char* options,
  58              ...)
  59 {
  60   va_list ap;
  61
  62   FONT* font;
  63   FT_Long i;
  64
  65   FT_Error error;
  66   const char* error_string = NULL;
  67   unsigned int errlinenum = 0;
  68   char* errline = NULL;
  69   char* errpos = NULL;
  70
  71   FILE* in_file = NULL;
  72   FILE* out_file = NULL;
  73
  74   const char* in_buf = NULL;
  75   size_t in_len = 0;
  76   char** out_bufp = NULL;
  77   size_t* out_lenp = NULL;
  78
  79   const unsigned char** error_stringp = NULL;
  80
  81   FT_Long hinting_range_min = -1;
  82   FT_Long hinting_range_max = -1;
  83   FT_Long hinting_limit = -1;
  84   FT_Long increase_x_height = -1;
  85
  86   const char* x_height_snapping_exceptions_string = NULL;
  87   number_range* x_height_snapping_exceptions = NULL;
  88
  89   FT_Long fallback_stem_width = 0;
  90
  91   FT_Bool gray_strong_stem_width = 0;
  92   FT_Bool gdi_cleartype_strong_stem_width = 1;
  93   FT_Bool dw_cleartype_strong_stem_width = 0;
  94
  95   TA_Progress_Func progress = NULL;
  96   void* progress_data = NULL;
  97   TA_Error_Func err = NULL;
  98   void* err_data = NULL;
  99   TA_Info_Func info = NULL;
 100   void* info_data = NULL;
 101
 102   FT_Bool windows_compatibility = 0;
 103   FT_Bool ignore_restrictions = 0;
 104   FT_Bool adjust_subglyphs = 0;
 105   FT_Bool hint_composites = 0;
 106   FT_Bool symbol = 0;
 107
 108   const char* fallback_script_string = NULL;
 109   const char* default_script_string = NULL;
 110   TA_Style fallback_style = TA_STYLE_NONE_DFLT;
 111   TA_Script default_script = TA_SCRIPT_LATN;
 112
 113   FT_Bool dehint = 0;
 114   FT_Bool debug = 0;
 115
 116   const char* op;
 117
 118 #undef SCRIPT
 119 #define SCRIPT(s, S, d, h, sc1, sc2, sc3) #s,
 120
 121   const char* script_names[] =
 122   {
 123
 124 #include <ttfautohint-scripts.h>
 125
 126   };
 127
 128
 129   if (!options || !*options)
 130   {
 131     error = FT_Err_Invalid_Argument;
 132     goto Err1;
 133   }
 134
 135   /* XXX */
 136   va_start(ap, options);
 137
 138   op = options;
 139
 140   for(;;)
 141   {
 142     const char* start;
 143     size_t len;
 144
 145
 146     start = op;
 147
 148     /* search comma */
 149     while (*op && *op != ',')
 150       op++;
 151
 152     /* remove leading whitespace */
 153     while (isspace(*start))
 154       start++;
 155
 156     /* check for empty option */
 157     if (start == op)
 158       goto End;
 159
 160     len = op - start;
 161
 162     /* the `COMPARE' macro uses `len' and `start' */
 163
 164     /* handle options -- don't forget to update parameter dump below! */
 165     if (COMPARE("adjust-subglyphs"))
 166       adjust_subglyphs = (FT_Bool)va_arg(ap, FT_Int);
 167     else if (COMPARE("debug"))
 168       debug = (FT_Bool)va_arg(ap, FT_Int);
 169     else if (COMPARE("default-script"))
 170       default_script_string = va_arg(ap, const char*);
 171     else if (COMPARE("dehint"))
 172       dehint = (FT_Bool)va_arg(ap, FT_Int);
 173     else if (COMPARE("dw-cleartype-strong-stem-width"))
 174       dw_cleartype_strong_stem_width = (FT_Bool)va_arg(ap, FT_Int);
 175     else if (COMPARE("error-callback"))
 176       err = va_arg(ap, TA_Error_Func);
 177     else if (COMPARE("error-callback-data"))
 178       err_data = va_arg(ap, void*);
 179     else if (COMPARE("error-string"))
 180       error_stringp = va_arg(ap, const unsigned char**);
 181     else if (COMPARE("fallback-script"))
 182       fallback_script_string = va_arg(ap, const char*);
 183     else if (COMPARE("fallback-stem-width"))
 184       fallback_stem_width = (FT_Long)va_arg(ap, FT_UInt);
 185     else if (COMPARE("gdi-cleartype-strong-stem-width"))
 186       gdi_cleartype_strong_stem_width = (FT_Bool)va_arg(ap, FT_Int);
 187     else if (COMPARE("gray-strong-stem-width"))
 188       gray_strong_stem_width = (FT_Bool)va_arg(ap, FT_Int);
 189     else if (COMPARE("hinting-limit"))
 190       hinting_limit = (FT_Long)va_arg(ap, FT_UInt);
 191     else if (COMPARE("hinting-range-max"))
 192       hinting_range_max = (FT_Long)va_arg(ap, FT_UInt);
 193     else if (COMPARE("hinting-range-min"))
 194       hinting_range_min = (FT_Long)va_arg(ap, FT_UInt);
 195     else if (COMPARE("hint-composites"))
 196       hint_composites = (FT_Bool)va_arg(ap, FT_Int);
 197     else if (COMPARE("ignore-restrictions"))
 198       ignore_restrictions = (FT_Bool)va_arg(ap, FT_Int);
 199     else if (COMPARE("in-buffer"))
 200     {
 201       in_file = NULL;
 202       in_buf = va_arg(ap, const char*);
 203     }
 204     else if (COMPARE("in-buffer-len"))
 205     {
 206       in_file = NULL;
 207       in_len = va_arg(ap, size_t);
 208     }
 209     else if (COMPARE("in-file"))
 210     {
 211       in_file = va_arg(ap, FILE*);
 212       in_buf = NULL;
 213       in_len = 0;
 214     }
 215     else if (COMPARE("increase-x-height"))
 216       increase_x_height = (FT_Long)va_arg(ap, FT_UInt);
 217     else if (COMPARE("info-callback"))
 218       info = va_arg(ap, TA_Info_Func);
 219     else if (COMPARE("info-callback-data"))
 220       info_data = va_arg(ap, void*);
 221     else if (COMPARE("out-buffer"))
 222     {
 223       out_file = NULL;
 224       out_bufp = va_arg(ap, char**);
 225     }
 226     else if (COMPARE("out-buffer-len"))
 227     {
 228       out_file = NULL;
 229       out_lenp = va_arg(ap, size_t*);
 230     }
 231     else if (COMPARE("out-file"))
 232     {
 233       out_file = va_arg(ap, FILE*);
 234       out_bufp = NULL;
 235       out_lenp = NULL;
 236     }
 237     else if (COMPARE("pre-hinting"))
 238       adjust_subglyphs = (FT_Bool)va_arg(ap, FT_Int);
 239     else if (COMPARE("progress-callback"))
 240       progress = va_arg(ap, TA_Progress_Func);
 241     else if (COMPARE("progress-callback-data"))
 242       progress_data = va_arg(ap, void*);
 243     else if (COMPARE("symbol"))
 244       symbol = (FT_Bool)va_arg(ap, FT_Int);
 245     else if (COMPARE("windows-compatibility"))
 246       windows_compatibility = (FT_Bool)va_arg(ap, FT_Int);
 247     else if (COMPARE("x-height-snapping-exceptions"))
 248       x_height_snapping_exceptions_string = va_arg(ap, const char*);
 249     else
 250     {
 251       error = TA_Err_Unknown_Argument;
 252       goto Err1;
 253     }
 254
 255   End:
 256     if (!*op)
 257       break;
 258     op++;
 259   }
 260
 261   va_end(ap);
 262
 263   /* check options */
 264
 265   if (!(in_file
 266         || (in_buf && in_len)))
 267   {
 268     error = FT_Err_Invalid_Argument;
 269     goto Err1;
 270   }
 271
 272   if (!(out_file
 273         || (out_bufp && out_lenp)))
 274   {
 275     error = FT_Err_Invalid_Argument;
 276     goto Err1;
 277   }
 278
 279   font = (FONT*)calloc(1, sizeof (FONT));
 280   if (!font)
 281   {
 282     error = FT_Err_Out_Of_Memory;
 283     goto Err1;
 284   }
 285
 286   if (dehint)
 287     goto No_check;
 288
 289   if (hinting_range_min >= 0 && hinting_range_min < 2)
 290   {
 291     error = FT_Err_Invalid_Argument;
 292     goto Err1;
 293   }
 294   if (hinting_range_min < 0)
 295     hinting_range_min = TA_HINTING_RANGE_MIN;
 296
 297   if (hinting_range_max >= 0 && hinting_range_max < hinting_range_min)
 298   {
 299     error = FT_Err_Invalid_Argument;
 300     goto Err1;
 301   }
 302   if (hinting_range_max < 0)
 303     hinting_range_max = TA_HINTING_RANGE_MAX;
 304
 305   /* value 0 is valid */
 306   if (hinting_limit > 0 && hinting_limit < hinting_range_max)
 307   {
 308     error = FT_Err_Invalid_Argument;
 309     goto Err1;
 310   }
 311   if (hinting_limit < 0)
 312     hinting_limit = TA_HINTING_LIMIT;
 313
 314   if (increase_x_height > 0
 315       && increase_x_height < TA_PROP_INCREASE_X_HEIGHT_MIN)
 316   {
 317     error = FT_Err_Invalid_Argument;
 318     goto Err1;
 319   }
 320   if (increase_x_height < 0)
 321     increase_x_height = TA_INCREASE_X_HEIGHT;
 322
 323   if (fallback_script_string)
 324   {
 325     int i;
 326
 327
 328     for (i = 0; i < TA_STYLE_MAX; i++)
 329     {
 330       TA_StyleClass style_class = ta_style_classes[i];
 331
 332
 333       if (style_class->coverage == TA_COVERAGE_DEFAULT
 334           && !strcmp(script_names[style_class->script],
 335                      fallback_script_string))
 336         break;
 337     }
 338     if (i == TA_STYLE_MAX)
 339     {
 340       error = FT_Err_Invalid_Argument;
 341       goto Err1;
 342     }
 343
 344     fallback_style = (TA_Style)i;
 345   }
 346
 347   if (default_script_string)
 348   {
 349     int i;
 350
 351
 352     for (i = 0; i < TA_SCRIPT_MAX; i++)
 353     {
 354       if (!strcmp(script_names[i], default_script_string))
 355         break;
 356     }
 357     if (i == TA_SCRIPT_MAX)
 358     {
 359       error = FT_Err_Invalid_Argument;
 360       goto Err1;
 361     }
 362
 363     default_script = (TA_Script)i;
 364   }
 365
 366   if (x_height_snapping_exceptions_string)
 367   {
 368     const char* s = number_set_parse(x_height_snapping_exceptions_string,
 369                                      &x_height_snapping_exceptions,
 370                                      TA_PROP_INCREASE_X_HEIGHT_MIN,
 371                                      0x7FFF);
 372     if (*s)
 373     {
 374       /* we map numberset.h's error codes to values starting with 0x100 */
 375       error = 0x100 - (FT_Error)x_height_snapping_exceptions;
 376       errlinenum = 0;
 377       errline = (char*)x_height_snapping_exceptions_string;
 378       errpos = (char*)s;
 379
 380       goto Err1;
 381     }
 382   }
 383
 384   font->hinting_range_min = (FT_UInt)hinting_range_min;
 385   font->hinting_range_max = (FT_UInt)hinting_range_max;
 386   font->hinting_limit = (FT_UInt)hinting_limit;
 387   font->increase_x_height = increase_x_height;
 388   font->x_height_snapping_exceptions = x_height_snapping_exceptions;
 389   font->fallback_stem_width = (FT_UInt)fallback_stem_width;
 390
 391   font->gray_strong_stem_width = gray_strong_stem_width;
 392   font->gdi_cleartype_strong_stem_width = gdi_cleartype_strong_stem_width;
 393   font->dw_cleartype_strong_stem_width = dw_cleartype_strong_stem_width;
 394
 395   font->windows_compatibility = windows_compatibility;
 396   font->ignore_restrictions = ignore_restrictions;
 397   font->adjust_subglyphs = adjust_subglyphs;
 398   font->hint_composites = hint_composites;
 399   font->fallback_style = fallback_style;
 400   font->default_script = default_script;
 401   font->symbol = symbol;
 402
 403 No_check:
 404   font->progress = progress;
 405   font->progress_data = progress_data;
 406   font->info = info;
 407   font->info_data = info_data;
 408
 409   font->debug = debug;
 410   font->dehint = dehint;
 411
 412   font->gasp_idx = MISSING;
 413
 414   /* dump parameters */
 415   if (debug)
 416   {
 417     fprintf(stderr, "TTF_autohint parameters\n"
 418                     "=======================\n"
 419                     "\n");
 420
 421     if (dehint)
 422       DUMPVAL("dehint",
 423               font->dehint);
 424     else
 425     {
 426       char *s;
 427
 428
 429       DUMPSTR("default-script",
 430               script_names[font->default_script]);
 431       DUMPVAL("dw-cleartype-strong-stem-width",
 432               font->dw_cleartype_strong_stem_width);
 433       DUMPSTR("fallback-script",
 434               script_names[ta_style_classes[font->fallback_style]->script]);
 435       DUMPVAL("fallback-stem-width",
 436               font->fallback_stem_width);
 437       DUMPVAL("gdi-cleartype-strong-stem-width",
 438               font->gdi_cleartype_strong_stem_width);
 439       DUMPVAL("gray-strong-stem-width",
 440               font->gray_strong_stem_width);
 441       DUMPVAL("hinting-limit",
 442               font->hinting_limit);
 443       DUMPVAL("hinting-range-max",
 444               font->hinting_range_max);
 445       DUMPVAL("hinting-range-min",
 446               font->hinting_range_min);
 447       DUMPVAL("hint-composites",
 448               font->hint_composites);
 449       DUMPVAL("ignore-restrictions",
 450               font->ignore_restrictions);
 451       DUMPVAL("increase-x-height",
 452               font->increase_x_height);
 453       DUMPVAL("adjust-subglyphs",
 454               font->adjust_subglyphs);
 455       DUMPVAL("symbol",
 456               font->symbol);
 457       DUMPVAL("windows-compatibility",
 458               font->windows_compatibility);
 459
 460       s = number_set_show(font->x_height_snapping_exceptions,
 461                           TA_PROP_INCREASE_X_HEIGHT_MIN, 0x7FFF);
 462       DUMPSTR("x-height-snapping-exceptions", s);
 463       free(s);
 464     }
 465
 466     fprintf(stderr, "\n");
 467   }
 468
 469   /* now start with processing the data */
 470
 471   if (in_file)
 472   {
 473     error = TA_font_file_read(font, in_file);
 474     if (error)
 475       goto Err;
 476   }
 477   else
 478   {
 479     /* a valid TTF can never be that small */
 480     if (in_len < 100)
 481     {
 482       error = TA_Err_Invalid_Font_Type;
 483       goto Err1;
 484     }
 485     font->in_buf = (FT_Byte*)in_buf;
 486     font->in_len = in_len;
 487   }
 488
 489   error = TA_font_init(font);
 490   if (error)
 491     goto Err;
 492
 493   if (font->debug)
 494   {
 495     _ta_debug = 1;
 496     _ta_debug_global = 1;
 497   }
 498
 499   /* we do some loops over all subfonts */
 500   for (i = 0; i < font->num_sfnts; i++)
 501   {
 502     SFNT* sfnt = &font->sfnts[i];
 503     FT_UInt idx;
 504
 505
 506     error = FT_New_Memory_Face(font->lib, font->in_buf, font->in_len,
 507                                i, &sfnt->face);
 508
 509     /* assure that the font hasn't been already processed by ttfautohint; */
 510     /* another, more thorough check is done in TA_glyph_parse_simple */
 511     idx = FT_Get_Name_Index(sfnt->face, (FT_String*)TTFAUTOHINT_GLYPH);
 512     if (idx)
 513     {
 514       error = TA_Err_Already_Processed;
 515       goto Err;
 516     }
 517
 518     if (error)
 519       goto Err;
 520
 521     error = TA_sfnt_split_into_SFNT_tables(sfnt, font);
 522     if (error)
 523       goto Err;
 524
 525     /* check permission */
 526     if (sfnt->OS2_idx != MISSING)
 527     {
 528       SFNT_Table* OS2_table = &font->tables[sfnt->OS2_idx];
 529
 530
 531       /* check lower byte of the `fsType' field */
 532       if (OS2_table->buf[OS2_FSTYPE_OFFSET + 1] == 0x02
 533           && !font->ignore_restrictions)
 534       {
 535         error = TA_Err_Missing_Legal_Permission;
 536         goto Err;
 537       }
 538     }
 539
 540     if (font->dehint)
 541     {
 542       error = TA_sfnt_split_glyf_table(sfnt, font);
 543       if (error)
 544         goto Err;
 545     }
 546     else
 547     {
 548       if (font->adjust_subglyphs)
 549         error = TA_sfnt_create_glyf_data(sfnt, font);
 550       else
 551         error = TA_sfnt_split_glyf_table(sfnt, font);
 552       if (error)
 553         goto Err;
 554
 555       /* this call creates a `globals' object... */
 556       error = TA_sfnt_handle_coverage(sfnt, font);
 557       if (error)
 558         goto Err;
 559
 560       /* ... so that we now can initialize its properties */
 561       TA_sfnt_set_properties(sfnt, font);
 562     }
 563   }
 564
 565   if (!font->dehint)
 566   {
 567     for (i = 0; i < font->num_sfnts; i++)
 568     {
 569       SFNT* sfnt = &font->sfnts[i];
 570
 571
 572       TA_sfnt_adjust_coverage(sfnt, font);
 573     }
 574   }
 575
 576 #if 0
 577   /* this code is here for completeness -- */
 578   /* right now, `glyf' tables get hinted only once, */
 579   /* and referring subfonts simply reuse it, */
 580   /* but this might change in the future */
 581
 582   if (!font->dehint)
 583   {
 584     for (i = 0; i < font->num_sfnts; i++)
 585     {
 586       SFNT* sfnt = &font->sfnts[i];
 587
 588
 589       TA_sfnt_copy_master_coverage(sfnt, font);
 590     }
 591   }
 592 #endif
 593
 594   /* loop again over subfonts */
 595   for (i = 0; i < font->num_sfnts; i++)
 596   {
 597     SFNT* sfnt = &font->sfnts[i];
 598
 599
 600     error = ta_loader_init(font);
 601     if (error)
 602       goto Err;
 603
 604     error = TA_sfnt_build_gasp_table(sfnt, font);
 605     if (error)
 606       goto Err;
 607     if (!font->dehint)
 608     {
 609       error = TA_sfnt_build_cvt_table(sfnt, font);
 610       if (error)
 611         goto Err;
 612       error = TA_sfnt_build_fpgm_table(sfnt, font);
 613       if (error)
 614         goto Err;
 615       error = TA_sfnt_build_prep_table(sfnt, font);
 616       if (error)
 617         goto Err;
 618     }
 619     error = TA_sfnt_build_glyf_table(sfnt, font);
 620     if (error)
 621       goto Err;
 622     error = TA_sfnt_build_loca_table(sfnt, font);
 623     if (error)
 624       goto Err;
 625
 626     if (font->loader)
 627       ta_loader_done(font);
 628   }
 629
 630   for (i = 0; i < font->num_sfnts; i++)
 631   {
 632     SFNT* sfnt = &font->sfnts[i];
 633
 634
 635     error = TA_sfnt_update_maxp_table(sfnt, font);
 636     if (error)
 637       goto Err;
 638
 639     if (!font->dehint)
 640     {
 641       /* we add one glyph for composites */
 642       if (sfnt->max_components
 643           && !font->adjust_subglyphs
 644           && font->hint_composites)
 645       {
 646         error = TA_sfnt_update_hmtx_table(sfnt, font);
 647         if (error)
 648           goto Err;
 649         error = TA_sfnt_update_post_table(sfnt, font);
 650         if (error)
 651           goto Err;
 652         error = TA_sfnt_update_GPOS_table(sfnt, font);
 653         if (error)
 654           goto Err;
 655       }
 656     }
 657
 658     if (font->info)
 659     {
 660       /* add info about ttfautohint to the version string */
 661       error = TA_sfnt_update_name_table(sfnt, font);
 662       if (error)
 663         goto Err;
 664     }
 665   }
 666
 667   if (font->num_sfnts == 1)
 668     error = TA_font_build_TTF(font);
 669   else
 670     error = TA_font_build_TTC(font);
 671   if (error)
 672     goto Err;
 673
 674   if (out_file)
 675   {
 676     error = TA_font_file_write(font, out_file);
 677     if (error)
 678       goto Err;
 679   }
 680   else
 681   {
 682     *out_bufp = (char*)font->out_buf;
 683     *out_lenp = font->out_len;
 684   }
 685
 686   error = TA_Err_Ok;
 687
 688 Err:
 689   TA_font_unload(font, in_buf, out_bufp);
 690
 691 Err1:
 692   error_string = TA_get_error_message(error);
 693
 694   if (error_stringp)
 695     *error_stringp = (const unsigned char*)error_string;
 696
 697   if (err)
 698     err(error,
 699         error_string,
 700         errlinenum,
 701         errline,
 702         errpos,
 703         err_data);
 704
 705   return error;
 706 }
 707
 708 /* end of ttfautohint.c */