lib/taglobal.c

   1 /* taglobal.c */
   2
   3 /*
   4  * Copyright (C) 2011-2015 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 `afglobal.c' (2011-Mar-28) from FreeType */
  17
  18 /* heavily modified 2011 by Werner Lemberg <wl@gnu.org> */
  19
  20 #include <stdlib.h>
  21
  22 #include "taglobal.h"
  23 #include "taranges.h"
  24
  25
  26 #undef SCRIPT
  27 #define SCRIPT(s, S, d, h, sc1, sc2, sc3) \
  28           const TA_ScriptClassRec ta_ ## s ## _script_class = \
  29           { \
  30             TA_SCRIPT_ ## S, \
  31             ta_ ## s ## _uniranges, \
  32             sc1, sc2, sc3 \
  33           };
  34
  35 #include <ttfautohint-scripts.h>
  36
  37
  38 #undef STYLE
  39 #define STYLE(s, S, d, ws, sc, ss, c) \
  40           const TA_StyleClassRec ta_ ## s ## _style_class = \
  41           { \
  42             TA_STYLE_ ## S, \
  43             ws, \
  44             sc, \
  45             ss, \
  46             c \
  47           };
  48
  49 #include "tastyles.h"
  50
  51
  52 /* get writing system specific header files */
  53 #undef WRITING_SYSTEM
  54 #define WRITING_SYSTEM(ws, WS) /* empty */
  55 #include "tawrtsys.h"
  56
  57
  58 #undef WRITING_SYSTEM
  59 #define WRITING_SYSTEM(ws, WS) \
  60           &ta_ ## ws ## _writing_system_class,
  61
  62 TA_WritingSystemClass const ta_writing_system_classes[] =
  63 {
  64
  65 #include "tawrtsys.h"
  66
  67   NULL /* do not remove */
  68 };
  69
  70
  71 #undef SCRIPT
  72 #define SCRIPT(s, S, d, h, sc1, sc2, sc3) \
  73           &ta_ ## s ## _script_class,
  74
  75 TA_ScriptClass const ta_script_classes[] =
  76 {
  77
  78 #include <ttfautohint-scripts.h>
  79
  80   NULL /* do not remove */
  81 };
  82
  83
  84 #undef STYLE
  85 #define STYLE(s, S, d, ws, sc, ss, c) \
  86           &ta_ ## s ## _style_class,
  87
  88 TA_StyleClass const ta_style_classes[] =
  89 {
  90
  91 #include "tastyles.h"
  92
  93   NULL /* do not remove */
  94 };
  95
  96
  97 #ifdef TA_DEBUG
  98
  99 #undef STYLE
 100 #define STYLE(s, S, d, ws, sc, ss, c) #s,
 101
 102 const char* ta_style_names[] =
 103 {
 104
 105 #include <tastyles.h>
 106
 107 };
 108
 109 #endif /* TA_DEBUG */
 110
 111
 112 /* Recursively assign a style to all components of a composite glyph. */
 113
 114 static FT_Error
 115 ta_face_globals_scan_composite(FT_Face face,
 116                                FT_Long gindex,
 117                                FT_Byte gstyle,
 118                                FT_Byte* gstyles,
 119                                FT_Int nesting_level)
 120 {
 121   FT_Error error;
 122   FT_UInt i;
 123
 124   FT_GlyphSlot glyph;
 125
 126   FT_Int* subglyph_indices = NULL;
 127   FT_UInt used_subglyphs;
 128
 129   FT_Int p_index;
 130   FT_UInt p_flags;
 131   FT_Int p_arg1;
 132   FT_Int p_arg2;
 133   FT_Matrix p_transform;
 134
 135
 136   /* limit recursion arbitrarily */
 137   if (nesting_level > 100)
 138     return FT_Err_Invalid_Table;
 139
 140   error = FT_Load_Glyph(face, (FT_UInt)gindex, FT_LOAD_NO_RECURSE);
 141   if (error)
 142     return error;
 143
 144   glyph = face->glyph;
 145
 146   /* in FreeType < 2.5.4, FT_Get_SubGlyph_Info always returns an error */
 147   /* due to a bug even if the call was successful; */
 148   /* for this reason we do the argument checking by ourselves */
 149   /* and ignore the returned error code of FT_Get_SubGlyph_Info */
 150   if (!glyph->subglyphs
 151       || glyph->format != FT_GLYPH_FORMAT_COMPOSITE)
 152     return FT_Err_Ok;
 153
 154   /* since a call to FT_Load_Glyph changes `glyph', */
 155   /* we have to first store the subglyph indices, then do the recursion */
 156   subglyph_indices = (FT_Int*)malloc(sizeof (FT_Int) * glyph->num_subglyphs);
 157   if (!subglyph_indices)
 158     return FT_Err_Out_Of_Memory;
 159
 160   used_subglyphs = 0;
 161   for (i = 0; i < glyph->num_subglyphs; i++)
 162   {
 163     (void)FT_Get_SubGlyph_Info(glyph,
 164                                i,
 165                                &p_index,
 166                                &p_flags,
 167                                &p_arg1,
 168                                &p_arg2,
 169                                &p_transform);
 170
 171     if (p_index >= face->num_glyphs
 172         || (gstyles[p_index] & ~TA_DIGIT) != TA_STYLE_UNASSIGNED)
 173       continue;
 174
 175     /* only take subglyphs that are not shifted vertically; */
 176     /* otherwise blue zones don't fit */
 177     if (p_flags & ARGS_ARE_XY_VALUES
 178         && p_arg2 == 0)
 179     {
 180       gstyles[p_index] = gstyle;
 181       subglyph_indices[used_subglyphs++] = p_index;
 182     }
 183   }
 184
 185   /* recurse */
 186   for (i = 0; i < used_subglyphs; i++)
 187   {
 188     error = ta_face_globals_scan_composite(face,
 189                                            subglyph_indices[i],
 190                                            gstyle,
 191                                            gstyles,
 192                                            nesting_level + 1);
 193     if (error)
 194       break;
 195   }
 196
 197   free(subglyph_indices);
 198
 199   return error;
 200 }
 201
 202
 203 /* Compute the style index of each glyph within a given face. */
 204
 205 static FT_Error
 206 ta_face_globals_compute_style_coverage(TA_FaceGlobals globals)
 207 {
 208   FT_Error error;
 209   FT_Face face = globals->face;
 210   FT_CharMap old_charmap = face->charmap;
 211   FT_Byte* gstyles = globals->glyph_styles;
 212   FT_UInt ss;
 213   FT_UInt i;
 214   FT_UInt dflt = ~0U; /* a non-valid value */
 215
 216
 217   /* the value TA_STYLE_UNASSIGNED means `uncovered glyph' */
 218   memset(globals->glyph_styles,
 219          TA_STYLE_UNASSIGNED,
 220          (unsigned int)globals->glyph_count);
 221
 222   error = FT_Select_Charmap(face, FT_ENCODING_UNICODE);
 223   if (error)
 224   {
 225     /* ignore this error; we simply use the fallback style */
 226     /* XXX: Shouldn't we rather disable hinting? */
 227     error = FT_Err_Ok;
 228     goto Exit;
 229   }
 230
 231   /* scan each style in a Unicode charmap */
 232   for (ss = 0; ta_style_classes[ss]; ss++)
 233   {
 234     TA_StyleClass style_class = ta_style_classes[ss];
 235     TA_ScriptClass script_class = ta_script_classes[style_class->script];
 236     TA_Script_UniRange range;
 237
 238
 239     if (script_class->script_uni_ranges == NULL)
 240       continue;
 241
 242     /* scan all Unicode points in the range and */
 243     /* set the corresponding glyph style index */
 244     if (style_class->coverage == TA_COVERAGE_DEFAULT)
 245     {
 246       if ((FT_UInt)style_class->script == globals->font->default_script)
 247         dflt = ss;
 248
 249       for (range = script_class->script_uni_ranges; range->first != 0; range++)
 250       {
 251         FT_ULong charcode = range->first;
 252         FT_UInt gindex;
 253
 254
 255         gindex = FT_Get_Char_Index(face, charcode);
 256
 257         if (gindex != 0
 258             && gindex < (FT_ULong)globals->glyph_count
 259             && gstyles[gindex] == TA_STYLE_UNASSIGNED)
 260           gstyles[gindex] = (FT_Byte)ss;
 261
 262         for (;;)
 263         {
 264           charcode = FT_Get_Next_Char(face, charcode, &gindex);
 265
 266           if (gindex == 0 || charcode > range->last)
 267             break;
 268
 269           if (gindex < (FT_ULong)globals->glyph_count
 270               && gstyles[gindex] == TA_STYLE_UNASSIGNED)
 271             gstyles[gindex] = (FT_Byte)ss;
 272         }
 273       }
 274     }
 275     else
 276     {
 277       /* get glyphs not directly addressable by cmap */
 278       ta_get_coverage(globals, style_class, gstyles);
 279     }
 280   }
 281
 282   /* handle the default OpenType features of the default script ... */
 283   ta_get_coverage(globals, ta_style_classes[dflt], gstyles);
 284
 285   /* ... and the remaining default OpenType features */
 286   for (ss = 0; ta_style_classes[ss]; ss++)
 287   {
 288     TA_StyleClass  style_class = ta_style_classes[ss];
 289
 290
 291     if (ss != dflt && style_class->coverage == TA_COVERAGE_DEFAULT)
 292       ta_get_coverage(globals, style_class, gstyles);
 293   }
 294
 295   /* mark ASCII digits */
 296   for (i = 0x30; i <= 0x39; i++)
 297   {
 298     FT_UInt gindex = FT_Get_Char_Index(face, i);
 299
 300
 301     if (gindex != 0
 302         && gindex < (FT_ULong)globals->glyph_count)
 303       gstyles[gindex] |= TA_DIGIT;
 304   }
 305
 306   /* now walk over all glyphs and check for composites: */
 307   /* since subglyphs are hinted separately if option `hint-composites' */
 308   /* isn't set, we have to tag them with style indices, too */
 309   {
 310     FT_Long nn;
 311
 312
 313     for (nn = 0; nn < globals->glyph_count; nn++)
 314     {
 315       if ((gstyles[nn] & ~TA_DIGIT) == TA_STYLE_UNASSIGNED)
 316         continue;
 317
 318       error = ta_face_globals_scan_composite(globals->face,
 319                                              nn,
 320                                              gstyles[nn],
 321                                              gstyles,
 322                                              0);
 323       if (error)
 324         return error;
 325     }
 326   }
 327
 328 Exit:
 329   /* by default, all uncovered glyphs are set to the fallback style */
 330   /* XXX: Shouldn't we disable hinting or do something similar? */
 331   if (globals->font->fallback_style != (TA_Style)TA_STYLE_UNASSIGNED)
 332   {
 333     FT_Long nn;
 334
 335
 336     for (nn = 0; nn < globals->glyph_count; nn++)
 337     {
 338       if ((gstyles[nn] & ~TA_DIGIT) == TA_STYLE_UNASSIGNED)
 339       {
 340         gstyles[nn] &= ~TA_STYLE_UNASSIGNED;
 341         gstyles[nn] |= globals->font->fallback_style;
 342       }
 343     }
 344   }
 345
 346 #ifdef TA_DEBUG
 347
 348   if (face->num_faces > 1)
 349     TA_LOG_GLOBAL(("\n"
 350                    "style coverage (subfont %d, glyf table index %d)\n"
 351                    "================================================\n"
 352                    "\n",
 353                    face->face_index,
 354                    globals->font->sfnts[face->face_index].glyf_idx));
 355   else
 356     TA_LOG_GLOBAL(("\n"
 357                    "style coverage\n"
 358                    "==============\n"
 359                    "\n"));
 360
 361   for (ss = 0; ta_style_classes[ss]; ss++)
 362   {
 363     TA_StyleClass style_class = ta_style_classes[ss];
 364     FT_UInt count = 0;
 365     FT_Long idx;
 366
 367
 368     TA_LOG_GLOBAL(("%s:\n", ta_style_names[style_class->style]));
 369
 370     for (idx = 0; idx < globals->glyph_count; idx++)
 371     {
 372       if ((gstyles[idx] & ~TA_DIGIT) == style_class->style)
 373       {
 374         if (!(count % 10))
 375           TA_LOG_GLOBAL((" "));
 376
 377         TA_LOG_GLOBAL((" %d", idx));
 378         count++;
 379
 380         if (!(count % 10))
 381           TA_LOG_GLOBAL(("\n"));
 382       }
 383     }
 384
 385     if (!count)
 386       TA_LOG_GLOBAL(("  (none)\n"));
 387     if (count % 10)
 388       TA_LOG_GLOBAL(("\n"));
 389   }
 390
 391 #endif /* TA_DEBUG */
 392
 393   FT_Set_Charmap(face, old_charmap);
 394   return error;
 395 }
 396
 397
 398 FT_Error
 399 ta_face_globals_new(FT_Face face,
 400                     TA_FaceGlobals *aglobals,
 401                     FONT* font)
 402 {
 403   FT_Error error;
 404   TA_FaceGlobals globals;
 405
 406
 407   globals = (TA_FaceGlobals)calloc(
 408               1, sizeof (TA_FaceGlobalsRec) +
 409                  (FT_ULong)face->num_glyphs * sizeof (FT_Byte));
 410   if (!globals)
 411   {
 412     error = FT_Err_Out_Of_Memory;
 413     goto Err;
 414   }
 415
 416   globals->face = face;
 417   globals->glyph_count = face->num_glyphs;
 418   globals->glyph_styles = (FT_Byte*)(globals + 1);
 419   globals->font = font;
 420   globals->hb_font = hb_ft_font_create(face, NULL);
 421
 422   error = ta_face_globals_compute_style_coverage(globals);
 423   if (error)
 424   {
 425     ta_face_globals_free(globals);
 426     globals = NULL;
 427   }
 428   else
 429     globals->increase_x_height = TA_PROP_INCREASE_X_HEIGHT_MAX;
 430
 431 Err:
 432   *aglobals = globals;
 433   return error;
 434 }
 435
 436
 437 void
 438 ta_face_globals_free(TA_FaceGlobals globals)
 439 {
 440   if (globals)
 441   {
 442     FT_UInt nn;
 443
 444
 445     for (nn = 0; nn < TA_STYLE_MAX; nn++)
 446     {
 447       if (globals->metrics[nn])
 448       {
 449         TA_StyleClass style_class =
 450           ta_style_classes[nn];
 451         TA_WritingSystemClass writing_system_class =
 452           ta_writing_system_classes[style_class->writing_system];
 453
 454
 455         if (writing_system_class->style_metrics_done)
 456           writing_system_class->style_metrics_done(globals->metrics[nn]);
 457
 458         free(globals->metrics[nn]);
 459         globals->metrics[nn] = NULL;
 460       }
 461     }
 462
 463     hb_font_destroy(globals->hb_font);
 464
 465     globals->hb_font = NULL;
 466     globals->glyph_count = 0;
 467     globals->glyph_styles = NULL; /* no need to free this one! */
 468     globals->face = NULL;
 469
 470     free(globals);
 471   }
 472 }
 473
 474
 475 FT_Error
 476 ta_face_globals_get_metrics(TA_FaceGlobals globals,
 477                             FT_UInt gindex,
 478                             FT_UInt options,
 479                             TA_StyleMetrics *ametrics)
 480 {
 481   TA_StyleMetrics metrics = NULL;
 482   TA_Style style = (TA_Style)options;
 483   TA_WritingSystemClass writing_system_class;
 484   TA_StyleClass style_class;
 485   FT_Error error = FT_Err_Ok;
 486
 487
 488   if (gindex >= (FT_ULong)globals->glyph_count)
 489   {
 490     error = FT_Err_Invalid_Argument;
 491     goto Exit;
 492   }
 493
 494   /* if we have a forced style (via `options'), use it, */
 495   /* otherwise look into `glyph_styles' array */
 496   if (style == TA_STYLE_NONE_DFLT || style + 1 >= TA_STYLE_MAX)
 497     style = (TA_Style)(globals->glyph_styles[gindex]
 498                        & TA_STYLE_UNASSIGNED);
 499
 500   style_class =
 501     ta_style_classes[style];
 502   writing_system_class =
 503     ta_writing_system_classes[style_class->writing_system];
 504
 505   metrics = globals->metrics[style];
 506   if (metrics == NULL)
 507   {
 508     /* create the global metrics object if necessary */
 509     metrics = (TA_StyleMetrics)
 510                 calloc(1, writing_system_class->style_metrics_size);
 511     if (!metrics)
 512     {
 513       error = FT_Err_Out_Of_Memory;
 514       goto Exit;
 515     }
 516
 517     metrics->style_class = style_class;
 518     metrics->globals = globals;
 519
 520     if (writing_system_class->style_metrics_init)
 521     {
 522       error = writing_system_class->style_metrics_init(metrics,
 523                                                        globals->face);
 524       if (error)
 525       {
 526         if (writing_system_class->style_metrics_done)
 527           writing_system_class->style_metrics_done(metrics);
 528
 529         free(metrics);
 530         metrics = NULL;
 531         goto Exit;
 532       }
 533     }
 534
 535     globals->metrics[style] = metrics;
 536   }
 537
 538 Exit:
 539   *ametrics = metrics;
 540
 541   return error;
 542 }
 543
 544
 545 FT_Bool
 546 ta_face_globals_is_digit(TA_FaceGlobals globals,
 547                          FT_UInt gindex)
 548 {
 549   if (gindex < (FT_ULong)globals->glyph_count)
 550     return (FT_Bool)(globals->glyph_styles[gindex] & TA_DIGIT);
 551
 552   return (FT_Bool)0;
 553 }
 554
 555 /* end of taglobal.c */