lib/taloader.c

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