lib/taloader.c

   1 /* taloader.c */
   2
   3 /*
   4  * Copyright (C) 2011-2018 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 `afloader.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_GLYPH_H
  24
  25 #include "ta.h"
  26 #include "tahints.h"
  27 #include "taglobal.h"
  28
  29
  30 /* from file `ftobjs.h' (2011-Mar-28) from FreeType */
  31 typedef struct FT_Slot_InternalRec_
  32 {
  33   TA_GlyphLoader loader;
  34   FT_UInt flags;
  35   FT_Bool glyph_transformed;
  36   FT_Matrix glyph_matrix;
  37   FT_Vector glyph_delta;
  38   void* glyph_hints;
  39 } FT_GlyphSlot_InternalRec;
  40
  41
  42 /* initialize glyph loader */
  43
  44 FT_Error
  45 ta_loader_init(FONT* font)
  46 {
  47   TA_Loader loader = font->loader;
  48
  49
  50   memset(loader, 0, sizeof (TA_LoaderRec));
  51
  52   ta_glyph_hints_init(&loader->hints);
  53 #ifdef TA_DEBUG
  54   _ta_debug_hints = &loader->hints;
  55 #endif
  56   return TA_GlyphLoader_New(&loader->gloader);
  57 }
  58
  59
  60 /* reset glyph loader and compute globals if necessary */
  61
  62 FT_Error
  63 ta_loader_reset(FONT* font,
  64                 FT_Face face)
  65 {
  66   FT_Error error = FT_Err_Ok;
  67   TA_Loader loader = font->loader;
  68
  69
  70   loader->face = face;
  71   loader->globals = (TA_FaceGlobals)face->autohint.data;
  72
  73   TA_GlyphLoader_Rewind(loader->gloader);
  74
  75   if (!loader->globals)
  76   {
  77     error = ta_face_globals_new(face, &loader->globals, font);
  78     if (!error)
  79     {
  80       face->autohint.data = (FT_Pointer)loader->globals;
  81       face->autohint.finalizer = (FT_Generic_Finalizer)ta_face_globals_free;
  82     }
  83   }
  84
  85   return error;
  86 }
  87
  88
  89 /* finalize glyph loader */
  90
  91 void
  92 ta_loader_done(FONT* font)
  93 {
  94   TA_Loader loader = font->loader;
  95
  96
  97   ta_glyph_hints_done(&loader->hints);
  98
  99   loader->face = NULL;
 100   loader->globals = NULL;
 101
 102 #ifdef TA_DEBUG
 103   _ta_debug_hints = NULL;
 104 #endif
 105   TA_GlyphLoader_Done(loader->gloader);
 106   loader->gloader = NULL;
 107 }
 108
 109
 110 /* load a single glyph component; this routine calls itself recursively, */
 111 /* if necessary, and does the main work of `ta_loader_load_glyph' */
 112
 113 static FT_Error
 114 ta_loader_load_g(TA_Loader loader,
 115                  TA_Scaler scaler,
 116                  FT_UInt glyph_index,
 117                  FT_Int32 load_flags,
 118                  FT_UInt depth)
 119 {
 120   FT_Error error;
 121   FT_Face face = loader->face;
 122   TA_GlyphLoader gloader = loader->gloader;
 123   TA_StyleMetrics metrics = loader->metrics;
 124   TA_GlyphHints hints = &loader->hints;
 125   FT_GlyphSlot slot = face->glyph;
 126 #if 0
 127   FT_Slot_Internal slot_internal = slot->internal;
 128 #endif
 129   FT_Int32 flags;
 130
 131
 132   flags = load_flags | FT_LOAD_LINEAR_DESIGN;
 133   error = FT_Load_Glyph(face, glyph_index, flags);
 134   if (error)
 135     goto Exit;
 136
 137 #if 0
 138   loader->transformed = slot_internal->glyph_transformed;
 139   if (loader->transformed)
 140   {
 141     FT_Matrix inverse;
 142
 143
 144     loader->trans_matrix = slot_internal->glyph_matrix;
 145     loader->trans_delta = slot_internal->glyph_delta;
 146
 147     inverse = loader->trans_matrix;
 148     if (!FT_Matrix_Invert(&inverse))
 149       FT_Vector_Transform(&loader->trans_delta, &inverse);
 150   }
 151 #endif
 152
 153   switch (slot->format)
 154   {
 155   case FT_GLYPH_FORMAT_OUTLINE:
 156     /* translate the loaded glyph when an internal transform is needed */
 157     if (loader->transformed)
 158       FT_Outline_Translate(&slot->outline,
 159                            loader->trans_delta.x,
 160                            loader->trans_delta.y);
 161
 162     /* copy the outline points in the loader's current extra points */
 163     /* which are used to keep original glyph coordinates */
 164     error = TA_GLYPHLOADER_CHECK_POINTS(gloader,
 165                                         slot->outline.n_points + 4,
 166                                         slot->outline.n_contours);
 167     if (error)
 168       goto Exit;
 169
 170     memcpy(gloader->current.outline.points,
 171            slot->outline.points,
 172            (size_t)slot->outline.n_points * sizeof (FT_Vector));
 173     memcpy(gloader->current.outline.contours,
 174            slot->outline.contours,
 175            (size_t)slot->outline.n_contours * sizeof (short));
 176     memcpy(gloader->current.outline.tags,
 177            slot->outline.tags,
 178            (size_t)slot->outline.n_points * sizeof (char));
 179
 180     gloader->current.outline.n_points = slot->outline.n_points;
 181     gloader->current.outline.n_contours = slot->outline.n_contours;
 182
 183     /* compute original horizontal phantom points */
 184     /* (and ignore vertical ones) */
 185     loader->pp1.x = hints->x_delta;
 186     loader->pp1.y = hints->y_delta;
 187     loader->pp2.x = FT_MulFix(slot->metrics.horiAdvance,
 188                               hints->x_scale) + hints->x_delta;
 189     loader->pp2.y = hints->y_delta;
 190
 191     /* be sure to check for spacing glyphs */
 192     if (slot->outline.n_points == 0)
 193       goto Hint_Metrics;
 194
 195     /* now load the slot image into the auto-outline */
 196     /* and run the automatic hinting process */
 197     {
 198       TA_StyleClass style_class = metrics->style_class;
 199       TA_WritingSystemClass writing_system_class =
 200         ta_writing_system_classes[style_class->writing_system];
 201
 202
 203       if (writing_system_class->style_hints_apply)
 204         writing_system_class->style_hints_apply(glyph_index,
 205                                                 hints,
 206                                                 &gloader->current.outline,
 207                                                 metrics);
 208     }
 209
 210     /* we now need to adjust the metrics according to the change in */
 211     /* width/positioning that occurred during the hinting process */
 212     if (scaler->render_mode != FT_RENDER_MODE_LIGHT)
 213     {
 214       TA_AxisHints axis = &hints->axis[TA_DIMENSION_HORZ];
 215
 216
 217       if (axis->num_edges > 1 && TA_HINTS_DO_ADVANCE(hints))
 218       {
 219         TA_Edge edge1 = axis->edges; /* leftmost edge */
 220         TA_Edge edge2 = edge1 +
 221                         axis->num_edges - 1; /* rightmost edge */
 222
 223         FT_Pos old_rsb = loader->pp2.x - edge2->opos;
 224         /* loader->pp1.x is always zero at this point of time */
 225         FT_Pos old_lsb = edge1->opos /* - loader->pp1.x */;
 226         FT_Pos new_lsb = edge1->pos;
 227
 228         /* remember unhinted values to later account */
 229         /* for rounding errors */
 230         FT_Pos pp1x_uh = new_lsb - old_lsb;
 231         FT_Pos pp2x_uh = edge2->pos + old_rsb;
 232
 233
 234         /* prefer too much space over too little space */
 235         /* for very small sizes */
 236
 237         if (old_lsb < 24)
 238           pp1x_uh -= 8;
 239         if (old_rsb < 24)
 240           pp2x_uh += 8;
 241
 242         loader->pp1.x = TA_PIX_ROUND(pp1x_uh);
 243         loader->pp2.x = TA_PIX_ROUND(pp2x_uh);
 244
 245         if (loader->pp1.x >= new_lsb
 246             && old_lsb > 0)
 247           loader->pp1.x -= 64;
 248         if (loader->pp2.x <= edge2->pos
 249             && old_rsb > 0)
 250           loader->pp2.x += 64;
 251
 252         slot->lsb_delta = loader->pp1.x - pp1x_uh;
 253         slot->rsb_delta = loader->pp2.x - pp2x_uh;
 254       }
 255       else
 256       {
 257         FT_Pos pp1x = loader->pp1.x;
 258         FT_Pos pp2x = loader->pp2.x;
 259
 260
 261         loader->pp1.x = TA_PIX_ROUND(pp1x + hints->xmin_delta);
 262         loader->pp2.x = TA_PIX_ROUND(pp2x + hints->xmax_delta);
 263
 264         slot->lsb_delta = loader->pp1.x - pp1x;
 265         slot->rsb_delta = loader->pp2.x - pp2x;
 266       }
 267     }
 268     /* `light' mode uses integer advance widths */
 269     /* but sets `lsb_delta' and `rsb_delta' */
 270     else
 271     {
 272       FT_Pos pp1x = loader->pp1.x;
 273       FT_Pos pp2x = loader->pp2.x;
 274
 275
 276       loader->pp1.x = TA_PIX_ROUND(pp1x);
 277       loader->pp2.x = TA_PIX_ROUND(pp2x);
 278
 279       slot->lsb_delta = loader->pp1.x - pp1x;
 280       slot->rsb_delta = loader->pp2.x - pp2x;
 281     }
 282
 283     /* good, we simply add the glyph to our loader's base */
 284     TA_GlyphLoader_Add(gloader);
 285     break;
 286
 287   case FT_GLYPH_FORMAT_COMPOSITE:
 288     {
 289       FT_UInt nn, num_subglyphs = slot->num_subglyphs;
 290       FT_UInt num_base_subgs, start_point;
 291       TA_SubGlyph subglyph;
 292
 293
 294       start_point = (FT_UInt)gloader->base.outline.n_points;
 295
 296       /* first of all, copy the subglyph descriptors in the glyph loader */
 297       error = TA_GlyphLoader_CheckSubGlyphs(gloader, num_subglyphs);
 298       if (error)
 299         goto Exit;
 300
 301       memcpy(gloader->current.subglyphs,
 302              slot->subglyphs,
 303              num_subglyphs * sizeof (TA_SubGlyphRec));
 304
 305       gloader->current.num_subglyphs = num_subglyphs;
 306
 307       /* stop processing if list of composites is requested */
 308       if ( load_flags & FT_LOAD_NO_RECURSE )
 309         goto Exit;
 310
 311       num_base_subgs = gloader->base.num_subglyphs;
 312
 313       /* now read each subglyph independently */
 314       for (nn = 0; nn < num_subglyphs; nn++)
 315       {
 316         FT_Vector pp1, pp2;
 317         FT_Pos x, y;
 318         FT_UInt num_points, num_new_points, num_base_points;
 319
 320
 321         /* gloader.current.subglyphs can change during glyph loading due */
 322         /* to re-allocation -- we must recompute the current subglyph on */
 323         /* each iteration */
 324         subglyph = gloader->base.subglyphs + num_base_subgs + nn;
 325
 326         pp1 = loader->pp1;
 327         pp2 = loader->pp2;
 328
 329         num_base_points = (FT_UInt)gloader->base.outline.n_points;
 330
 331         error = ta_loader_load_g(loader, scaler, (FT_UInt)subglyph->index,
 332                                  load_flags, depth + 1);
 333         if (error)
 334           goto Exit;
 335
 336         /* recompute subglyph pointer */
 337         subglyph = gloader->base.subglyphs + num_base_subgs + nn;
 338
 339         if (!(subglyph->flags & FT_SUBGLYPH_FLAG_USE_MY_METRICS))
 340         {
 341           loader->pp1 = pp1;
 342           loader->pp2 = pp2;
 343         }
 344
 345         num_points = (FT_UInt)gloader->base.outline.n_points;
 346         num_new_points = num_points - num_base_points;
 347
 348         /* now perform the transformation required for this subglyph */
 349         if (subglyph->flags & (FT_SUBGLYPH_FLAG_SCALE
 350                                | FT_SUBGLYPH_FLAG_XY_SCALE
 351                                | FT_SUBGLYPH_FLAG_2X2))
 352         {
 353           FT_Vector* cur = gloader->base.outline.points + num_base_points;
 354           FT_Vector* limit = cur + num_new_points;
 355
 356
 357           for (; cur < limit; cur++)
 358             FT_Vector_Transform(cur, &subglyph->transform);
 359         }
 360
 361         /* apply offset */
 362         if (!(subglyph->flags & FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES))
 363         {
 364           FT_UInt k = (FT_UInt)subglyph->arg1;
 365           FT_UInt l = (FT_UInt)subglyph->arg2;
 366           FT_Vector* p1;
 367           FT_Vector* p2;
 368
 369
 370           if (start_point + k >= num_base_points
 371               || l >= num_new_points)
 372           {
 373             error = FT_Err_Invalid_Composite;
 374             goto Exit;
 375           }
 376
 377           l += num_base_points;
 378
 379           /* for now, only use the current point coordinates; */
 380           /* we eventually may consider another approach */
 381           p1 = gloader->base.outline.points + start_point + k;
 382           p2 = gloader->base.outline.points + start_point + l;
 383
 384           x = p1->x - p2->x;
 385           y = p1->y - p2->y;
 386         }
 387         else
 388         {
 389           x = FT_MulFix(subglyph->arg1, hints->x_scale) + hints->x_delta;
 390           y = FT_MulFix(subglyph->arg2, hints->y_scale) + hints->y_delta;
 391
 392           x = TA_PIX_ROUND(x);
 393           y = TA_PIX_ROUND(y);
 394         }
 395
 396         {
 397           FT_Outline dummy = gloader->base.outline;
 398
 399
 400           dummy.points += num_base_points;
 401           dummy.n_points = (short)num_new_points;
 402
 403           FT_Outline_Translate(&dummy, x, y);
 404         }
 405       }
 406     }
 407     break;
 408
 409   default:
 410     /* we don't support other formats (yet?) */
 411     error = FT_Err_Unimplemented_Feature;
 412   }
 413
 414 Hint_Metrics:
 415   if (depth == 0)
 416   {
 417     FT_BBox bbox;
 418     FT_Vector vvector;
 419
 420
 421     vvector.x = slot->metrics.vertBearingX - slot->metrics.horiBearingX;
 422     vvector.y = slot->metrics.vertBearingY - slot->metrics.horiBearingY;
 423     vvector.x = FT_MulFix(vvector.x, metrics->scaler.x_scale);
 424     vvector.y = FT_MulFix(vvector.y, metrics->scaler.y_scale);
 425
 426     /* transform the hinted outline if needed */
 427     if (loader->transformed)
 428     {
 429       FT_Outline_Transform(&gloader->base.outline, &loader->trans_matrix);
 430       FT_Vector_Transform(&vvector, &loader->trans_matrix);
 431     }
 432 #if 1
 433     /* we must translate our final outline by -pp1.x */
 434     /* and compute the new metrics */
 435     if (loader->pp1.x)
 436       FT_Outline_Translate(&gloader->base.outline, -loader->pp1.x, 0);
 437 #endif
 438     FT_Outline_Get_CBox(&gloader->base.outline, &bbox);
 439
 440     bbox.xMin = TA_PIX_FLOOR(bbox.xMin);
 441     bbox.yMin = TA_PIX_FLOOR(bbox.yMin);
 442     bbox.xMax = TA_PIX_CEIL(bbox.xMax);
 443     bbox.yMax = TA_PIX_CEIL(bbox.yMax);
 444
 445     slot->metrics.width = bbox.xMax - bbox.xMin;
 446     slot->metrics.height = bbox.yMax - bbox.yMin;
 447     slot->metrics.horiBearingX = bbox.xMin;
 448     slot->metrics.horiBearingY = bbox.yMax;
 449
 450     slot->metrics.vertBearingX = TA_PIX_FLOOR(bbox.xMin + vvector.x);
 451     slot->metrics.vertBearingY = TA_PIX_FLOOR(bbox.yMax + vvector.y);
 452
 453     /* for mono-width fonts (like Andale, Courier, etc.) we need */
 454     /* to keep the original rounded advance width; ditto for */
 455     /* digits if all have the same advance width */
 456     if (scaler->render_mode != FT_RENDER_MODE_LIGHT
 457         && (FT_IS_FIXED_WIDTH(slot->face)
 458             || (ta_face_globals_is_digit(loader->globals, glyph_index)
 459                 && metrics->digits_have_same_width)))
 460     {
 461       slot->metrics.horiAdvance = FT_MulFix(slot->metrics.horiAdvance,
 462                                             metrics->scaler.x_scale);
 463
 464       /* set delta values to 0, otherwise code that uses them */
 465       /* is going to ruin the fixed advance width */
 466       slot->lsb_delta = 0;
 467       slot->rsb_delta = 0;
 468     }
 469     else
 470     {
 471       /* non-spacing glyphs must stay as-is */
 472       if (slot->metrics.horiAdvance)
 473         slot->metrics.horiAdvance = loader->pp2.x - loader->pp1.x;
 474     }
 475
 476     slot->metrics.vertAdvance = FT_MulFix(slot->metrics.vertAdvance,
 477                                           metrics->scaler.y_scale);
 478
 479     slot->metrics.horiAdvance = TA_PIX_ROUND(slot->metrics.horiAdvance);
 480     slot->metrics.vertAdvance = TA_PIX_ROUND(slot->metrics.vertAdvance);
 481
 482 #if 0
 483     /* now copy outline into glyph slot */
 484     TA_GlyphLoader_Rewind(internal->loader);
 485     error = TA_GlyphLoader_CopyPoints(internal->loader, gloader);
 486     if (error)
 487       goto Exit;
 488
 489     /* reassign all outline fields except flags to protect them */
 490     slot->outline.n_contours = internal->loader->base.outline.n_contours;
 491     slot->outline.n_points = internal->loader->base.outline.n_points;
 492     slot->outline.points = internal->loader->base.outline.points;
 493     slot->outline.tags = internal->loader->base.outline.tags;
 494     slot->outline.contours = internal->loader->base.outline.contours;
 495
 496     slot->format = FT_GLYPH_FORMAT_OUTLINE;
 497 #endif
 498   }
 499
 500 Exit:
 501   return error;
 502 }
 503
 504
 505 /* load a glyph */
 506
 507 FT_Error
 508 ta_loader_load_glyph(FONT* font,
 509                      FT_Face face,
 510                      FT_UInt gindex,
 511                      FT_Int32 load_flags)
 512 {
 513   FT_Error error;
 514   FT_Size size = face->size;
 515   TA_Loader loader = font->loader;
 516   TA_ScalerRec scaler;
 517
 518
 519   if (!size)
 520     return FT_Err_Invalid_Size_Handle;
 521
 522   memset(&scaler, 0, sizeof (TA_ScalerRec));
 523
 524   scaler.face = face;
 525   scaler.x_scale = size->metrics.x_scale;
 526   scaler.x_delta = 0;
 527   scaler.y_scale = size->metrics.y_scale;
 528   scaler.y_delta = 0;
 529
 530   scaler.render_mode = FT_LOAD_TARGET_MODE(load_flags);
 531   scaler.flags = 0; /* XXX: fix this */
 532
 533   /* XXX this is an ugly hack of ttfautohint: */
 534   /* bit 29 triggers vertical hinting only */
 535   if (load_flags & (1 << 29))
 536     scaler.flags |= TA_SCALER_FLAG_NO_HORIZONTAL;
 537
 538   /* note that the fallback style can't be changed anymore */
 539   /* after the first call of `ta_loader_load_glyph' */
 540   error = ta_loader_reset(font, face);
 541   if (!error)
 542   {
 543     TA_StyleMetrics metrics;
 544     FT_UInt options = TA_STYLE_NONE_DFLT;
 545
 546
 547 #ifdef FT_OPTION_AUTOFIT2
 548     /* XXX: undocumented hook to activate the latin2 hinter */
 549     if (load_flags & (1UL << 20))
 550       options = TA_STYLE_LTN2_DFLT;
 551 #endif
 552
 553     error = ta_face_globals_get_metrics(loader->globals, gindex,
 554                                         options, &metrics);
 555     if (!error)
 556     {
 557       TA_StyleClass style_class = metrics->style_class;
 558       TA_WritingSystemClass writing_system_class =
 559         ta_writing_system_classes[style_class->writing_system];
 560
 561
 562       loader->metrics = metrics;
 563
 564       if (writing_system_class->style_metrics_scale)
 565         writing_system_class->style_metrics_scale(metrics, &scaler);
 566       else
 567         metrics->scaler = scaler;
 568
 569       load_flags |= FT_LOAD_NO_SCALE
 570                     | FT_LOAD_IGNORE_TRANSFORM;
 571       load_flags &= ~FT_LOAD_RENDER;
 572
 573       if (writing_system_class->style_hints_init)
 574       {
 575         error = writing_system_class->style_hints_init(&loader->hints,
 576                                                        metrics);
 577         if (error)
 578           goto Exit;
 579       }
 580
 581       error = ta_loader_load_g(loader, &scaler, gindex, load_flags, 0);
 582     }
 583   }
 584 Exit:
 585   return error;
 586 }
 587
 588
 589 void
 590 ta_loader_register_hints_recorder(TA_Loader loader,
 591                                   TA_Hints_Recorder hints_recorder,
 592                                   void* user)
 593 {
 594   loader->hints.recorder = hints_recorder;
 595   loader->hints.user = user;
 596 }
 597
 598 /* end of taloader.c */