lib/tabytecode.c

   1 /* tabytecode.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 #include "ta.h"
  17 #include <string.h>
  18
  19
  20 #undef MISSING
  21 #define MISSING (FT_UInt)~0
  22
  23 /* a simple macro to emit bytecode instructions */
  24 #define BCI(code) *(bufp++) = (code)
  25
  26 /* we increase the stack depth by this amount */
  27 #define ADDITIONAL_STACK_ELEMENTS 20
  28
  29
  30 /* #define DEBUGGING */
  31
  32
  33 #ifdef TA_DEBUG
  34 int _ta_debug = 1;
  35 int _ta_debug_disable_horz_hints;
  36 int _ta_debug_disable_vert_hints;
  37 int _ta_debug_disable_blue_hints;
  38 void* _ta_debug_hints;
  39 #endif
  40
  41
  42 typedef struct Hints_Record_
  43 {
  44   FT_UInt size;
  45   FT_UInt num_actions;
  46   FT_Byte* buf;
  47   FT_UInt buf_len;
  48 } Hints_Record;
  49
  50 typedef struct Recorder_
  51 {
  52   FONT* font;
  53   GLYPH* glyph; /* the current glyph */
  54   Hints_Record hints_record;
  55
  56   /* some segments can `wrap around' */
  57   /* a contour's start point like 24-25-26-0-1-2 */
  58   /* (there can be at most one such segment per contour); */
  59   /* later on we append additional records */
  60   /* to split them into 24-26 and 0-2 */
  61   FT_UInt* wrap_around_segments;
  62   FT_UInt num_wrap_around_segments;
  63
  64   FT_UShort num_stack_elements; /* the necessary stack depth so far */
  65
  66   /* data necessary for strong point interpolation */
  67   FT_UInt* ip_before_points;
  68   FT_UInt* ip_after_points;
  69   FT_UInt* ip_on_point_array;
  70   FT_UInt* ip_between_point_array;
  71
  72   FT_UInt num_strong_points;
  73   FT_UInt num_segments;
  74 } Recorder;
  75
  76
  77 /* We add a subglyph for each composite glyph. */
  78 /* Since subglyphs must contain at least one point, */
  79 /* we have to adjust all point indices accordingly. */
  80 /* Using the `pointsums' array of the `GLYPH' structure */
  81 /* it is straightforward to do that: */
  82 /* Assuming that point with index x is in the interval */
  83 /* pointsums[n] <= x < pointsums[n + 1], */
  84 /* the new point index is x + n. */
  85
  86 static FT_UInt
  87 TA_adjust_point_index(Recorder* recorder,
  88                       FT_UInt idx)
  89 {
  90   GLYPH* glyph = recorder->glyph;
  91   FT_UShort i;
  92
  93
  94   if (!glyph->num_components)
  95     return idx; /* not a composite glyph */
  96
  97   for (i = 0; i < glyph->num_pointsums; i++)
  98     if (idx < glyph->pointsums[i])
  99       break;
 100
 101   return idx + i;
 102 }
 103
 104
 105 /* we store the segments in the storage area; */
 106 /* each segment record consists of the first and last point */
 107
 108 static FT_Byte*
 109 TA_sfnt_build_glyph_segments(SFNT* sfnt,
 110                              Recorder* recorder,
 111                              FT_Byte* bufp,
 112                              FT_Bool optimize)
 113 {
 114   FONT* font = recorder->font;
 115   TA_GlyphHints hints = &font->loader->hints;
 116   TA_AxisHints axis = &hints->axis[TA_DIMENSION_VERT];
 117   TA_Point points = hints->points;
 118   TA_Segment segments = axis->segments;
 119   TA_Segment seg;
 120   TA_Segment seg_limit;
 121
 122   FT_Outline outline = font->loader->gloader->base.outline;
 123
 124   FT_UInt* args;
 125   FT_UInt* arg;
 126   FT_UInt num_args;
 127   FT_UInt nargs;
 128   FT_UInt num_segments;
 129
 130   FT_Bool need_words = 0;
 131
 132   FT_Int n;
 133   FT_UInt i, j;
 134   FT_UInt base;
 135   FT_UInt num_packed_segments;
 136   FT_UInt num_storage;
 137   FT_UInt num_stack_elements;
 138   FT_UInt num_twilight_points;
 139
 140
 141   seg_limit = segments + axis->num_segments;
 142   num_segments = axis->num_segments;
 143
 144   /* to pack the data in the bytecode more tightly, */
 145   /* we store up to the first nine segments in nibbles if possible, */
 146   /* using delta values */
 147   base = 0;
 148   num_packed_segments = 0;
 149   for (seg = segments; seg < seg_limit; seg++)
 150   {
 151     FT_UInt first = seg->first - points;
 152     FT_UInt last = seg->last - points;
 153
 154
 155     first = TA_adjust_point_index(recorder, first);
 156     last = TA_adjust_point_index(recorder, last);
 157
 158     if (first - base >= 16)
 159       break;
 160     if (first > last || last - first >= 16)
 161       break;
 162     if (num_packed_segments == 9)
 163       break;
 164     num_packed_segments++;
 165     base = last;
 166   }
 167
 168   /* also handle wrap-around segments */
 169   num_segments += recorder->num_wrap_around_segments;
 170
 171   /* wrap-around segments are pushed with four arguments; */
 172   /* a segment stored in nibbles needs only one byte instead of two */
 173   num_args = num_packed_segments
 174              + 2 * (num_segments - num_packed_segments)
 175              + 2 * recorder->num_wrap_around_segments
 176              + 2;
 177
 178   /* collect all arguments temporarily in an array (in reverse order) */
 179   /* so that we can easily split into chunks of 255 args */
 180   /* as needed by NPUSHB and NPUSHW, respectively */
 181   args = (FT_UInt*)malloc(num_args * sizeof (FT_UInt));
 182   if (!args)
 183     return NULL;
 184
 185   arg = args + num_args - 1;
 186
 187   if (num_segments > 0xFF)
 188     need_words = 1;
 189
 190   /* the number of packed segments is indicated by the function number */
 191   if (recorder->glyph->num_components)
 192     *(arg--) = bci_create_segments_composite_0 + num_packed_segments;
 193   else
 194     *(arg--) = bci_create_segments_0 + num_packed_segments;
 195   *(arg--) = num_segments;
 196
 197   base = 0;
 198   for (seg = segments; seg < segments + num_packed_segments; seg++)
 199   {
 200     FT_UInt first = seg->first - points;
 201     FT_UInt last = seg->last - points;
 202     FT_UInt low_nibble;
 203     FT_UInt high_nibble;
 204
 205
 206     first = TA_adjust_point_index(recorder, first);
 207     last = TA_adjust_point_index(recorder, last);
 208
 209     low_nibble = first - base;
 210     high_nibble = last - first;
 211
 212     *(arg--) = 16 * high_nibble + low_nibble;
 213
 214     base = last;
 215   }
 216
 217   for (seg = segments + num_packed_segments; seg < seg_limit; seg++)
 218   {
 219     FT_UInt first = seg->first - points;
 220     FT_UInt last = seg->last - points;
 221
 222
 223     *(arg--) = TA_adjust_point_index(recorder, first);
 224     *(arg--) = TA_adjust_point_index(recorder, last);
 225
 226     /* we push the last and first contour point */
 227     /* as a third and fourth argument in wrap-around segments */
 228     if (first > last)
 229     {
 230       for (n = 0; n < outline.n_contours; n++)
 231       {
 232         FT_UInt end = (FT_UInt)outline.contours[n];
 233
 234
 235         if (first <= end)
 236         {
 237           *(arg--) = TA_adjust_point_index(recorder, end);
 238           if (end > 0xFF)
 239             need_words = 1;
 240
 241           if (n == 0)
 242             *(arg--) = TA_adjust_point_index(recorder, 0);
 243           else
 244             *(arg--) = TA_adjust_point_index(recorder,
 245                          (FT_UInt)outline.contours[n - 1] + 1);
 246           break;
 247         }
 248       }
 249     }
 250
 251     if (last > 0xFF)
 252       need_words = 1;
 253   }
 254
 255   /* emit the second part of wrap-around segments as separate segments */
 256   /* so that edges can easily link to them */
 257   for (seg = segments; seg < seg_limit; seg++)
 258   {
 259     FT_UInt first = seg->first - points;
 260     FT_UInt last = seg->last - points;
 261
 262
 263     if (first > last)
 264     {
 265       for (n = 0; n < outline.n_contours; n++)
 266       {
 267         if (first <= (FT_UInt)outline.contours[n])
 268         {
 269           if (n == 0)
 270             *(arg--) = TA_adjust_point_index(recorder, 0);
 271           else
 272             *(arg--) = TA_adjust_point_index(recorder,
 273                          (FT_UInt)outline.contours[n - 1] + 1);
 274           break;
 275         }
 276       }
 277
 278       *(arg--) = TA_adjust_point_index(recorder, last);
 279     }
 280   }
 281   /* with most fonts it is very rare */
 282   /* that any of the pushed arguments is larger than 0xFF, */
 283   /* thus we refrain from further optimizing this case */
 284
 285   arg = args;
 286
 287   if (need_words)
 288   {
 289     for (i = 0; i < num_args; i += 255)
 290     {
 291       nargs = (num_args - i > 255) ? 255 : num_args - i;
 292
 293
 294       if (optimize && nargs <= 8)
 295         BCI(PUSHW_1 - 1 + nargs);
 296       else
 297       {
 298         BCI(NPUSHW);
 299         BCI(nargs);
 300       }
 301       for (j = 0; j < nargs; j++)
 302       {
 303         BCI(HIGH(*arg));
 304         BCI(LOW(*arg));
 305         arg++;
 306       }
 307     }
 308   }
 309   else
 310   {
 311     for (i = 0; i < num_args; i += 255)
 312     {
 313       nargs = (num_args - i > 255) ? 255 : num_args - i;
 314
 315       if (optimize && nargs <= 8)
 316         BCI(PUSHB_1 - 1 + nargs);
 317       else
 318       {
 319         BCI(NPUSHB);
 320         BCI(nargs);
 321       }
 322       for (j = 0; j < nargs; j++)
 323       {
 324         BCI(*arg);
 325         arg++;
 326       }
 327     }
 328   }
 329
 330   BCI(CALL);
 331
 332   num_storage = sal_segment_offset + num_segments * 2;
 333   if (num_storage > sfnt->max_storage)
 334     sfnt->max_storage = num_storage;
 335
 336   num_twilight_points = num_segments * 2;
 337   if (num_twilight_points > sfnt->max_twilight_points)
 338     sfnt->max_twilight_points = num_twilight_points;
 339
 340   /* both this function and `TA_emit_hints_record' */
 341   /* push data onto the stack */
 342   num_stack_elements = ADDITIONAL_STACK_ELEMENTS
 343                        + recorder->num_stack_elements + num_args;
 344   if (num_stack_elements > sfnt->max_stack_elements)
 345     sfnt->max_stack_elements = num_stack_elements;
 346
 347   free(args);
 348
 349   return bufp;
 350 }
 351
 352
 353 static FT_Byte*
 354 TA_sfnt_build_glyph_scaler(SFNT* sfnt,
 355                            Recorder* recorder,
 356                            FT_Byte* bufp)
 357 {
 358   FT_GlyphSlot glyph = sfnt->face->glyph;
 359   FT_Vector* points = glyph->outline.points;
 360   FT_Int num_contours = glyph->outline.n_contours;
 361
 362   FT_UInt* args;
 363   FT_UInt* arg;
 364   FT_UInt num_args;
 365   FT_UInt nargs;
 366
 367   FT_Bool need_words = 0;
 368   FT_Int p, q;
 369   FT_UInt i, j;
 370   FT_Int start, end;
 371   FT_UInt num_stack_elements;
 372
 373
 374   num_args = 2 * num_contours + 2;
 375
 376   /* collect all arguments temporarily in an array (in reverse order) */
 377   /* so that we can easily split into chunks of 255 args */
 378   /* as needed by NPUSHB and NPUSHW, respectively */
 379   args = (FT_UInt*)malloc(num_args * sizeof (FT_UInt));
 380   if (!args)
 381     return NULL;
 382
 383   arg = args + num_args - 1;
 384
 385   if (num_args > 0xFF)
 386     need_words = 1;
 387
 388   if (recorder->glyph->num_components)
 389     *(arg--) = bci_scale_composite_glyph;
 390   else
 391     *(arg--) = bci_scale_glyph;
 392   *(arg--) = num_contours;
 393
 394   start = 0;
 395   end = 0;
 396
 397   for (p = 0; p < num_contours; p++)
 398   {
 399     FT_Int max = start;
 400     FT_Int min = start;
 401
 402
 403     end = glyph->outline.contours[p];
 404
 405     for (q = start; q <= end; q++)
 406     {
 407       if (points[q].y < points[min].y)
 408         min = q;
 409       if (points[q].y > points[max].y)
 410         max = q;
 411     }
 412
 413     if (min > max)
 414     {
 415       *(arg--) = TA_adjust_point_index(recorder, max);
 416       *(arg--) = TA_adjust_point_index(recorder, min);
 417     }
 418     else
 419     {
 420       *(arg--) = TA_adjust_point_index(recorder, min);
 421       *(arg--) = TA_adjust_point_index(recorder, max);
 422     }
 423
 424     start = end + 1;
 425   }
 426
 427   if (end > 0xFF)
 428     need_words = 1;
 429
 430   /* with most fonts it is very rare */
 431   /* that any of the pushed arguments is larger than 0xFF, */
 432   /* thus we refrain from further optimizing this case */
 433
 434   arg = args;
 435
 436   if (need_words)
 437   {
 438     for (i = 0; i < num_args; i += 255)
 439     {
 440       nargs = (num_args - i > 255) ? 255 : num_args - i;
 441
 442       if (nargs <= 8)
 443         BCI(PUSHW_1 - 1 + nargs);
 444       else
 445       {
 446         BCI(NPUSHW);
 447         BCI(nargs);
 448       }
 449       for (j = 0; j < nargs; j++)
 450       {
 451         BCI(HIGH(*arg));
 452         BCI(LOW(*arg));
 453         arg++;
 454       }
 455     }
 456   }
 457   else
 458   {
 459     for (i = 0; i < num_args; i += 255)
 460     {
 461       nargs = (num_args - i > 255) ? 255 : num_args - i;
 462
 463       if (nargs <= 8)
 464         BCI(PUSHB_1 - 1 + nargs);
 465       else
 466       {
 467         BCI(NPUSHB);
 468         BCI(nargs);
 469       }
 470       for (j = 0; j < nargs; j++)
 471       {
 472         BCI(*arg);
 473         arg++;
 474       }
 475     }
 476   }
 477
 478   BCI(CALL);
 479
 480   num_stack_elements = ADDITIONAL_STACK_ELEMENTS + num_args;
 481   if (num_stack_elements > sfnt->max_stack_elements)
 482     sfnt->max_stack_elements = num_stack_elements;
 483
 484   free(args);
 485
 486   return bufp;
 487 }
 488
 489
 490 static FT_Byte*
 491 TA_font_build_subglyph_shifter(FONT* font,
 492                                FT_Byte* bufp)
 493 {
 494   FT_Face face = font->loader->face;
 495   FT_GlyphSlot glyph = face->glyph;
 496
 497   TA_GlyphLoader gloader = font->loader->gloader;
 498
 499   TA_SubGlyph subglyphs = gloader->base.subglyphs;
 500   TA_SubGlyph subglyph_limit = subglyphs + gloader->base.num_subglyphs;
 501   TA_SubGlyph subglyph;
 502
 503   FT_Int curr_contour = 0;
 504
 505
 506   for (subglyph = subglyphs; subglyph < subglyph_limit; subglyph++)
 507   {
 508     FT_Error error;
 509
 510     FT_UShort flags = subglyph->flags;
 511     FT_Pos y_offset = subglyph->arg2;
 512
 513     FT_Int num_contours;
 514
 515
 516     /* load subglyph to get the number of contours */
 517     error = FT_Load_Glyph(face, subglyph->index, FT_LOAD_NO_SCALE);
 518     if (error)
 519       return NULL;
 520     num_contours = glyph->outline.n_contours;
 521
 522     /* nothing to do if there is a point-to-point alignment */
 523     if (!(flags & FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES))
 524       goto End;
 525
 526     /* nothing to do if y offset is zero */
 527     if (!y_offset)
 528       goto End;
 529
 530     /* nothing to do if there are no contours */
 531     if (!num_contours)
 532       goto End;
 533
 534     /* note that calling `FT_Load_Glyph' without FT_LOAD_NO_RECURSE */
 535     /* ensures that composite subglyphs are represented as simple glyphs */
 536
 537     if (num_contours > 0xFF
 538         || curr_contour > 0xFF)
 539     {
 540       BCI(PUSHW_2);
 541       BCI(HIGH(curr_contour));
 542       BCI(LOW(curr_contour));
 543       BCI(HIGH(num_contours));
 544       BCI(LOW(num_contours));
 545     }
 546     else
 547     {
 548       BCI(PUSHB_2);
 549       BCI(curr_contour);
 550       BCI(num_contours);
 551     }
 552
 553     /* there are high chances that this value needs PUSHW, */
 554     /* thus we handle it separately */
 555     if (y_offset > 0xFF || y_offset < 0)
 556     {
 557       BCI(PUSHW_1);
 558       BCI(HIGH(y_offset));
 559       BCI(LOW(y_offset));
 560     }
 561     else
 562     {
 563       BCI(PUSHB_1);
 564       BCI(y_offset);
 565     }
 566
 567     BCI(PUSHB_1);
 568     BCI(bci_shift_subglyph);
 569     BCI(CALL);
 570
 571   End:
 572     curr_contour += num_contours;
 573   }
 574
 575   return bufp;
 576 }
 577
 578
 579 /*
 580  * The four `ta_ip_*' actions in the `TA_hints_recorder' callback store its
 581  * data in four arrays (which are simple but waste a lot of memory).  The
 582  * function below converts them into bytecode.
 583  *
 584  * For `ta_ip_before' and `ta_ip_after', the collected points are emitted
 585  * together with the edge they correspond to.
 586  *
 587  * For both `ta_ip_on' and `ta_ip_between', an outer loop is constructed to
 588  * loop over the edge or edge pairs, respectively, and each edge or edge
 589  * pair contains an inner loop to emit the correponding points.
 590  */
 591
 592 static void
 593 TA_build_point_hints(Recorder* recorder,
 594                      TA_GlyphHints hints)
 595 {
 596   TA_AxisHints axis = &hints->axis[TA_DIMENSION_VERT];
 597   TA_Segment segments = axis->segments;
 598   TA_Edge edges = axis->edges;
 599
 600   TA_Edge edge;
 601   TA_Edge before;
 602   TA_Edge after;
 603
 604   FT_Byte* p = recorder->hints_record.buf;
 605   FT_UInt num_edges = axis->num_edges;
 606   FT_UInt num_strong_points = recorder->num_strong_points;
 607
 608   FT_UInt i;
 609   FT_UInt j;
 610   FT_UInt k;
 611
 612   FT_UInt* ip;
 613   FT_UInt* iq;
 614   FT_UInt* ir;
 615   FT_UInt* ip_limit;
 616   FT_UInt* iq_limit;
 617   FT_UInt* ir_limit;
 618
 619
 620   /* we store everything as 16bit numbers; */
 621   /* the function numbers (`ta_ip_before', etc.) */
 622   /* reflect the order in the TA_Action enumeration */
 623
 624   /* ip_before_points */
 625
 626   i = 0;
 627   ip = recorder->ip_before_points;
 628   ip_limit = ip + num_strong_points;
 629   for (; ip < ip_limit; ip++)
 630   {
 631     if (*ip != MISSING)
 632       i++;
 633     else
 634       break;
 635   }
 636
 637   if (i)
 638   {
 639     recorder->hints_record.num_actions++;
 640
 641     edge = edges;
 642
 643     *(p++) = 0;
 644     *(p++) = (FT_Byte)ta_ip_before + ACTION_OFFSET;
 645     *(p++) = HIGH(edge->first - segments);
 646     *(p++) = LOW(edge->first - segments);
 647     *(p++) = HIGH(i);
 648     *(p++) = LOW(i);
 649
 650     ip = recorder->ip_before_points;
 651     ip_limit = ip + i;
 652     for (; ip < ip_limit; ip++)
 653     {
 654       FT_UInt point = TA_adjust_point_index(recorder, *ip);
 655
 656
 657       *(p++) = HIGH(point);
 658       *(p++) = LOW(point);
 659     }
 660   }
 661
 662   /* ip_after_points */
 663
 664   i = 0;
 665   ip = recorder->ip_after_points;
 666   ip_limit = ip + num_strong_points;
 667   for (; ip < ip_limit; ip++)
 668   {
 669     if (*ip != MISSING)
 670       i++;
 671     else
 672       break;
 673   }
 674
 675   if (i)
 676   {
 677     recorder->hints_record.num_actions++;
 678
 679     edge = edges + axis->num_edges - 1;
 680
 681     *(p++) = 0;
 682     *(p++) = (FT_Byte)ta_ip_after + ACTION_OFFSET;
 683     *(p++) = HIGH(edge->first - segments);
 684     *(p++) = LOW(edge->first - segments);
 685     *(p++) = HIGH(i);
 686     *(p++) = LOW(i);
 687
 688     ip = recorder->ip_after_points;
 689     ip_limit = ip + i;
 690     for (; ip < ip_limit; ip++)
 691     {
 692       FT_UInt point = TA_adjust_point_index(recorder, *ip);
 693
 694
 695       *(p++) = HIGH(point);
 696       *(p++) = LOW(point);
 697     }
 698   }
 699
 700   /* ip_on_point_array */
 701
 702   i = 0;
 703   ip = recorder->ip_on_point_array;
 704   ip_limit = ip + num_edges * num_strong_points;
 705   for (; ip < ip_limit; ip += num_strong_points)
 706     if (*ip != MISSING)
 707       i++;
 708
 709   if (i)
 710   {
 711     recorder->hints_record.num_actions++;
 712
 713     *(p++) = 0;
 714     *(p++) = (FT_Byte)ta_ip_on + ACTION_OFFSET;
 715     *(p++) = HIGH(i);
 716     *(p++) = LOW(i);
 717
 718     i = 0;
 719     ip = recorder->ip_on_point_array;
 720     ip_limit = ip + num_edges * num_strong_points;
 721     for (; ip < ip_limit; ip += num_strong_points, i++)
 722     {
 723       if (*ip == MISSING)
 724         continue;
 725
 726       edge = edges + i;
 727
 728       *(p++) = HIGH(edge->first - segments);
 729       *(p++) = LOW(edge->first - segments);
 730
 731       j = 0;
 732       iq = ip;
 733       iq_limit = iq + num_strong_points;
 734       for (; iq < iq_limit; iq++)
 735       {
 736         if (*iq != MISSING)
 737           j++;
 738         else
 739           break;
 740       }
 741
 742       *(p++) = HIGH(j);
 743       *(p++) = LOW(j);
 744
 745       iq = ip;
 746       iq_limit = iq + j;
 747       for (; iq < iq_limit; iq++)
 748       {
 749         FT_UInt point = TA_adjust_point_index(recorder, *iq);
 750
 751
 752         *(p++) = HIGH(point);
 753         *(p++) = LOW(point);
 754       }
 755     }
 756   }
 757
 758   /* ip_between_point_array */
 759
 760   i = 0;
 761   ip = recorder->ip_between_point_array;
 762   ip_limit = ip + num_edges * num_edges * num_strong_points;
 763   for (; ip < ip_limit; ip += num_strong_points)
 764     if (*ip != MISSING)
 765       i++;
 766
 767   if (i)
 768   {
 769     recorder->hints_record.num_actions++;
 770
 771     *(p++) = 0;
 772     *(p++) = (FT_Byte)ta_ip_between + ACTION_OFFSET;
 773     *(p++) = HIGH(i);
 774     *(p++) = LOW(i);
 775
 776     i = 0;
 777     ip = recorder->ip_between_point_array;
 778     ip_limit = ip + num_edges * num_edges * num_strong_points;
 779     for (;
 780          ip < ip_limit;
 781          ip += num_edges * num_strong_points, i++)
 782     {
 783       before = edges + i;
 784
 785       j = 0;
 786       iq = ip;
 787       iq_limit = iq + num_edges * num_strong_points;
 788       for (; iq < iq_limit; iq += num_strong_points, j++)
 789       {
 790         if (*iq == MISSING)
 791           continue;
 792
 793         after = edges + j;
 794
 795         *(p++) = HIGH(after->first - segments);
 796         *(p++) = LOW(after->first - segments);
 797         *(p++) = HIGH(before->first - segments);
 798         *(p++) = LOW(before->first - segments);
 799
 800         k = 0;
 801         ir = iq;
 802         ir_limit = ir + num_strong_points;
 803         for (; ir < ir_limit; ir++)
 804         {
 805           if (*ir != MISSING)
 806             k++;
 807           else
 808             break;
 809         }
 810
 811         *(p++) = HIGH(k);
 812         *(p++) = LOW(k);
 813
 814         ir = iq;
 815         ir_limit = ir + k;
 816         for (; ir < ir_limit; ir++)
 817         {
 818           FT_UInt point = TA_adjust_point_index(recorder, *ir);
 819
 820
 821           *(p++) = HIGH(point);
 822           *(p++) = LOW(point);
 823         }
 824       }
 825     }
 826   }
 827
 828   recorder->hints_record.buf = p;
 829 }
 830
 831
 832 static FT_Bool
 833 TA_hints_record_is_different(Hints_Record* hints_records,
 834                              FT_UInt num_hints_records,
 835                              FT_Byte* start,
 836                              FT_Byte* end)
 837 {
 838   Hints_Record last_hints_record;
 839
 840
 841   if (!hints_records)
 842     return 1;
 843
 844   /* we only need to compare with the last hints record */
 845   last_hints_record = hints_records[num_hints_records - 1];
 846
 847   if ((FT_UInt)(end - start) != last_hints_record.buf_len)
 848     return 1;
 849
 850   if (memcmp(start, last_hints_record.buf, last_hints_record.buf_len))
 851     return 1;
 852
 853   return 0;
 854 }
 855
 856
 857 static FT_Error
 858 TA_add_hints_record(Hints_Record** hints_records,
 859                     FT_UInt* num_hints_records,
 860                     FT_Byte* start,
 861                     Hints_Record hints_record)
 862 {
 863   Hints_Record* hints_records_new;
 864   FT_UInt buf_len;
 865   /* at this point, `hints_record.buf' still points into `ins_buf' */
 866   FT_Byte* end = hints_record.buf;
 867
 868
 869   buf_len = (FT_UInt)(end - start);
 870
 871   /* now fill the structure completely */
 872   hints_record.buf_len = buf_len;
 873   hints_record.buf = (FT_Byte*)malloc(buf_len);
 874   if (!hints_record.buf)
 875     return FT_Err_Out_Of_Memory;
 876
 877   memcpy(hints_record.buf, start, buf_len);
 878
 879   (*num_hints_records)++;
 880   hints_records_new =
 881     (Hints_Record*)realloc(*hints_records, *num_hints_records
 882                                            * sizeof (Hints_Record));
 883   if (!hints_records_new)
 884   {
 885     free(hints_record.buf);
 886     (*num_hints_records)--;
 887     return FT_Err_Out_Of_Memory;
 888   }
 889   else
 890     *hints_records = hints_records_new;
 891
 892   (*hints_records)[*num_hints_records - 1] = hints_record;
 893
 894   return FT_Err_Ok;
 895 }
 896
 897
 898 static FT_Byte*
 899 TA_emit_hints_record(Recorder* recorder,
 900                      Hints_Record* hints_record,
 901                      FT_Byte* bufp,
 902                      FT_Bool optimize)
 903 {
 904   FT_Byte* p;
 905   FT_Byte* endp;
 906   FT_Bool need_words = 0;
 907
 908   FT_UInt i, j;
 909   FT_UInt num_arguments;
 910   FT_UInt num_args;
 911
 912
 913   /* check whether any argument is larger than 0xFF */
 914   endp = hints_record->buf + hints_record->buf_len;
 915   for (p = hints_record->buf; p < endp; p += 2)
 916     if (*p)
 917       need_words = 1;
 918
 919   /* with most fonts it is very rare */
 920   /* that any of the pushed arguments is larger than 0xFF, */
 921   /* thus we refrain from further optimizing this case */
 922
 923   num_arguments = hints_record->buf_len / 2;
 924   p = endp - 2;
 925
 926   if (need_words)
 927   {
 928     for (i = 0; i < num_arguments; i += 255)
 929     {
 930       num_args = (num_arguments - i > 255) ? 255 : (num_arguments - i);
 931
 932       if (optimize && num_args <= 8)
 933         BCI(PUSHW_1 - 1 + num_args);
 934       else
 935       {
 936         BCI(NPUSHW);
 937         BCI(num_args);
 938       }
 939       for (j = 0; j < num_args; j++)
 940       {
 941         BCI(*p);
 942         BCI(*(p + 1));
 943         p -= 2;
 944       }
 945     }
 946   }
 947   else
 948   {
 949     /* we only need the lower bytes */
 950     p++;
 951
 952     for (i = 0; i < num_arguments; i += 255)
 953     {
 954       num_args = (num_arguments - i > 255) ? 255 : (num_arguments - i);
 955
 956       if (optimize && num_args <= 8)
 957         BCI(PUSHB_1 - 1 + num_args);
 958       else
 959       {
 960         BCI(NPUSHB);
 961         BCI(num_args);
 962       }
 963       for (j = 0; j < num_args; j++)
 964       {
 965         BCI(*p);
 966         p -= 2;
 967       }
 968     }
 969   }
 970
 971   /* collect stack depth data */
 972   if (num_arguments > recorder->num_stack_elements)
 973     recorder->num_stack_elements = num_arguments;
 974
 975   return bufp;
 976 }
 977
 978
 979 static FT_Byte*
 980 TA_emit_hints_records(Recorder* recorder,
 981                       Hints_Record* hints_records,
 982                       FT_UInt num_hints_records,
 983                       FT_Byte* bufp,
 984                       FT_Bool optimize)
 985 {
 986   FT_UInt i;
 987   Hints_Record* hints_record;
 988
 989
 990   hints_record = hints_records;
 991
 992   for (i = 0; i < num_hints_records - 1; i++)
 993   {
 994     BCI(MPPEM);
 995     if (hints_record->size > 0xFF)
 996     {
 997       BCI(PUSHW_1);
 998       BCI(HIGH((hints_record + 1)->size));
 999       BCI(LOW((hints_record + 1)->size));
1000     }
1001     else
1002     {
1003       BCI(PUSHB_1);
1004       BCI((hints_record + 1)->size);
1005     }
1006     BCI(LT);
1007     BCI(IF);
1008     bufp = TA_emit_hints_record(recorder, hints_record, bufp, optimize);
1009     BCI(ELSE);
1010
1011     hints_record++;
1012   }
1013
1014   bufp = TA_emit_hints_record(recorder, hints_record, bufp, optimize);
1015
1016   for (i = 0; i < num_hints_records - 1; i++)
1017     BCI(EIF);
1018
1019   return bufp;
1020 }
1021
1022
1023 static void
1024 TA_free_hints_records(Hints_Record* hints_records,
1025                       FT_UInt num_hints_records)
1026 {
1027   FT_UInt i;
1028
1029
1030   for (i = 0; i < num_hints_records; i++)
1031     free(hints_records[i].buf);
1032
1033   free(hints_records);
1034 }
1035
1036
1037 static FT_Byte*
1038 TA_hints_recorder_handle_segments(FT_Byte* bufp,
1039                                   TA_AxisHints axis,
1040                                   TA_Edge edge,
1041                                   FT_UInt* wraps)
1042 {
1043   TA_Segment segments = axis->segments;
1044   TA_Segment seg;
1045   FT_UInt seg_idx;
1046   FT_UInt num_segs = 0;
1047   FT_UInt* wrap;
1048
1049
1050   seg_idx = edge->first - segments;
1051
1052   /* we store everything as 16bit numbers */
1053   *(bufp++) = HIGH(seg_idx);
1054   *(bufp++) = LOW(seg_idx);
1055
1056   /* wrap-around segments are stored as two segments */
1057   if (edge->first->first > edge->first->last)
1058     num_segs++;
1059
1060   seg = edge->first->edge_next;
1061   while (seg != edge->first)
1062   {
1063     num_segs++;
1064
1065     if (seg->first > seg->last)
1066       num_segs++;
1067
1068     seg = seg->edge_next;
1069   }
1070
1071   *(bufp++) = HIGH(num_segs);
1072   *(bufp++) = LOW(num_segs);
1073
1074   if (edge->first->first > edge->first->last)
1075   {
1076     /* emit second part of wrap-around segment; */
1077     /* the bytecode positions such segments after `normal' ones */
1078     wrap = wraps;
1079     for (;;)
1080     {
1081       if (seg_idx == *wrap)
1082         break;
1083       wrap++;
1084     }
1085
1086     *(bufp++) = HIGH(axis->num_segments + (wrap - wraps));
1087     *(bufp++) = LOW(axis->num_segments + (wrap - wraps));
1088   }
1089
1090   seg = edge->first->edge_next;
1091   while (seg != edge->first)
1092   {
1093     seg_idx = seg - segments;
1094
1095     *(bufp++) = HIGH(seg_idx);
1096     *(bufp++) = LOW(seg_idx);
1097
1098     if (seg->first > seg->last)
1099     {
1100       wrap = wraps;
1101       for (;;)
1102       {
1103         if (seg_idx == *wrap)
1104           break;
1105         wrap++;
1106       }
1107
1108       *(bufp++) = HIGH(axis->num_segments + (wrap - wraps));
1109       *(bufp++) = LOW(axis->num_segments + (wrap - wraps));
1110     }
1111
1112     seg = seg->edge_next;
1113   }
1114
1115   return bufp;
1116 }
1117
1118
1119 static void
1120 TA_hints_recorder(TA_Action action,
1121                   TA_GlyphHints hints,
1122                   TA_Dimension dim,
1123                   void* arg1,
1124                   TA_Edge arg2,
1125                   TA_Edge arg3,
1126                   TA_Edge lower_bound,
1127                   TA_Edge upper_bound)
1128 {
1129   TA_AxisHints axis = &hints->axis[dim];
1130   TA_Edge edges = axis->edges;
1131   TA_Segment segments = axis->segments;
1132   TA_Point points = hints->points;
1133
1134   Recorder* recorder = (Recorder*)hints->user;
1135   FONT* font = recorder->font;
1136   FT_UInt* wraps = recorder->wrap_around_segments;
1137   FT_Byte* p = recorder->hints_record.buf;
1138
1139   FT_UInt* ip;
1140   FT_UInt* limit;
1141
1142
1143   if (dim == TA_DIMENSION_HORZ)
1144     return;
1145
1146   /* we collect point hints for later processing */
1147   switch (action)
1148   {
1149   case ta_ip_before:
1150     {
1151       TA_Point point = (TA_Point)arg1;
1152
1153
1154       ip = recorder->ip_before_points;
1155       limit = ip + recorder->num_strong_points;
1156       for (; ip < limit; ip++)
1157       {
1158         if (*ip == MISSING)
1159         {
1160           *ip = point - points;
1161           break;
1162         }
1163       }
1164     }
1165     return;
1166
1167   case ta_ip_after:
1168     {
1169       TA_Point point = (TA_Point)arg1;
1170
1171
1172       ip = recorder->ip_after_points;
1173       limit = ip + recorder->num_strong_points;
1174       for (; ip < limit; ip++)
1175       {
1176         if (*ip == MISSING)
1177         {
1178           *ip = point - points;
1179           break;
1180         }
1181       }
1182     }
1183     return;
1184
1185   case ta_ip_on:
1186     {
1187       TA_Point point = (TA_Point)arg1;
1188       TA_Edge edge = arg2;
1189
1190
1191       ip = recorder->ip_on_point_array
1192            + recorder->num_strong_points
1193              * (edge - edges);
1194       limit = ip + recorder->num_strong_points;
1195       for (; ip < limit; ip++)
1196       {
1197         if (*ip == MISSING)
1198         {
1199           *ip = point - points;
1200           break;
1201         }
1202       }
1203     }
1204     return;
1205
1206   case ta_ip_between:
1207     {
1208       TA_Point point = (TA_Point)arg1;
1209       TA_Edge before = arg2;
1210       TA_Edge after = arg3;
1211
1212
1213       /* note that `recorder->num_segments' has been used for allocation, */
1214       /* but `axis->num_edges' is used for accessing this array */
1215       ip = recorder->ip_between_point_array
1216            + recorder->num_strong_points * axis->num_edges
1217              * (before - edges)
1218            + recorder->num_strong_points
1219              * (after - edges);
1220       limit = ip + recorder->num_strong_points;
1221       for (; ip < limit; ip++)
1222       {
1223         if (*ip == MISSING)
1224         {
1225           *ip = point - points;
1226           break;
1227         }
1228       }
1229     }
1230     return;
1231
1232   case ta_bound:
1233     /* we ignore the BOUND action since we signal this information */
1234     /* with the proper function number */
1235     return;
1236
1237   default:
1238     break;
1239   }
1240
1241   /* some enum values correspond to four or eight bytecode functions; */
1242   /* if the value is n, the function numbers are n, ..., n+7, */
1243   /* to be differentiated with flags */
1244
1245   switch (action)
1246   {
1247   case ta_link:
1248     {
1249       TA_Edge base_edge = (TA_Edge)arg1;
1250       TA_Edge stem_edge = arg2;
1251
1252
1253       *(p++) = 0;
1254       *(p++) = (FT_Byte)action + ACTION_OFFSET
1255                + ((stem_edge->flags & TA_EDGE_SERIF) != 0)
1256                + 2 * ((base_edge->flags & TA_EDGE_ROUND) != 0);
1257
1258       *(p++) = HIGH(base_edge->first - segments);
1259       *(p++) = LOW(base_edge->first - segments);
1260       *(p++) = HIGH(stem_edge->first - segments);
1261       *(p++) = LOW(stem_edge->first - segments);
1262
1263       p = TA_hints_recorder_handle_segments(p, axis, stem_edge, wraps);
1264     }
1265     break;
1266
1267   case ta_anchor:
1268     {
1269       TA_Edge edge = (TA_Edge)arg1;
1270       TA_Edge edge2 = arg2;
1271
1272
1273       *(p++) = 0;
1274       *(p++) = (FT_Byte)action + ACTION_OFFSET
1275                + ((edge2->flags & TA_EDGE_SERIF) != 0)
1276                + 2 * ((edge->flags & TA_EDGE_ROUND) != 0);
1277
1278       *(p++) = HIGH(edge->first - segments);
1279       *(p++) = LOW(edge->first - segments);
1280       *(p++) = HIGH(edge2->first - segments);
1281       *(p++) = LOW(edge2->first - segments);
1282
1283       p = TA_hints_recorder_handle_segments(p, axis, edge, wraps);
1284     }
1285     break;
1286
1287   case ta_adjust:
1288     {
1289       TA_Edge edge = (TA_Edge)arg1;
1290       TA_Edge edge2 = arg2;
1291       TA_Edge edge_minus_one = lower_bound;
1292
1293
1294       *(p++) = 0;
1295       *(p++) = (FT_Byte)action + ACTION_OFFSET
1296                + ((edge2->flags & TA_EDGE_SERIF) != 0)
1297                + 2 * ((edge->flags & TA_EDGE_ROUND) != 0)
1298                + 4 * (edge_minus_one != NULL);
1299
1300       *(p++) = HIGH(edge->first - segments);
1301       *(p++) = LOW(edge->first - segments);
1302       *(p++) = HIGH(edge2->first - segments);
1303       *(p++) = LOW(edge2->first - segments);
1304
1305       if (edge_minus_one)
1306       {
1307         *(p++) = HIGH(edge_minus_one->first - segments);
1308         *(p++) = LOW(edge_minus_one->first - segments);
1309       }
1310
1311       p = TA_hints_recorder_handle_segments(p, axis, edge, wraps);
1312     }
1313     break;
1314
1315   case ta_blue_anchor:
1316     {
1317       TA_Edge edge = (TA_Edge)arg1;
1318       TA_Edge blue = arg2;
1319
1320
1321       *(p++) = 0;
1322       *(p++) = (FT_Byte)action + ACTION_OFFSET;
1323
1324       *(p++) = HIGH(blue->first - segments);
1325       *(p++) = LOW(blue->first - segments);
1326
1327       if (edge->best_blue_is_shoot)
1328       {
1329         *(p++) = HIGH(CVT_BLUE_SHOOTS_OFFSET(font) + edge->best_blue_idx);
1330         *(p++) = LOW(CVT_BLUE_SHOOTS_OFFSET(font) + edge->best_blue_idx);
1331       }
1332       else
1333       {
1334         *(p++) = HIGH(CVT_BLUE_REFS_OFFSET(font) + edge->best_blue_idx);
1335         *(p++) = LOW(CVT_BLUE_REFS_OFFSET(font) + edge->best_blue_idx);
1336       }
1337
1338       *(p++) = HIGH(edge->first - segments);
1339       *(p++) = LOW(edge->first - segments);
1340
1341       p = TA_hints_recorder_handle_segments(p, axis, edge, wraps);
1342     }
1343     break;
1344
1345   case ta_stem:
1346     {
1347       TA_Edge edge = (TA_Edge)arg1;
1348       TA_Edge edge2 = arg2;
1349       TA_Edge edge_minus_one = lower_bound;
1350
1351
1352       *(p++) = 0;
1353       *(p++) = (FT_Byte)action + ACTION_OFFSET
1354                + ((edge2->flags & TA_EDGE_SERIF) != 0)
1355                + 2 * ((edge->flags & TA_EDGE_ROUND) != 0)
1356                + 4 * (edge_minus_one != NULL);
1357
1358       *(p++) = HIGH(edge->first - segments);
1359       *(p++) = LOW(edge->first - segments);
1360       *(p++) = HIGH(edge2->first - segments);
1361       *(p++) = LOW(edge2->first - segments);
1362
1363       if (edge_minus_one)
1364       {
1365         *(p++) = HIGH(edge_minus_one->first - segments);
1366         *(p++) = LOW(edge_minus_one->first - segments);
1367       }
1368
1369       p = TA_hints_recorder_handle_segments(p, axis, edge, wraps);
1370       p = TA_hints_recorder_handle_segments(p, axis, edge2, wraps);
1371     }
1372     break;
1373
1374   case ta_blue:
1375     {
1376       TA_Edge edge = (TA_Edge)arg1;
1377
1378
1379       *(p++) = 0;
1380       *(p++) = (FT_Byte)action + ACTION_OFFSET;
1381
1382       if (edge->best_blue_is_shoot)
1383       {
1384         *(p++) = HIGH(CVT_BLUE_SHOOTS_OFFSET(font) + edge->best_blue_idx);
1385         *(p++) = LOW(CVT_BLUE_SHOOTS_OFFSET(font) + edge->best_blue_idx);
1386       }
1387       else
1388       {
1389         *(p++) = HIGH(CVT_BLUE_REFS_OFFSET(font) + edge->best_blue_idx);
1390         *(p++) = LOW(CVT_BLUE_REFS_OFFSET(font) + edge->best_blue_idx);
1391       }
1392
1393       *(p++) = HIGH(edge->first - segments);
1394       *(p++) = LOW(edge->first - segments);
1395
1396       p = TA_hints_recorder_handle_segments(p, axis, edge, wraps);
1397     }
1398     break;
1399
1400   case ta_serif:
1401     {
1402       TA_Edge serif = (TA_Edge)arg1;
1403       TA_Edge base = serif->serif;
1404
1405
1406       *(p++) = 0;
1407       *(p++) = (FT_Byte)action + ACTION_OFFSET
1408                + (lower_bound != NULL)
1409                + 2 * (upper_bound != NULL);
1410
1411       *(p++) = HIGH(serif->first - segments);
1412       *(p++) = LOW(serif->first - segments);
1413       *(p++) = HIGH(base->first - segments);
1414       *(p++) = LOW(base->first - segments);
1415
1416       if (lower_bound)
1417       {
1418         *(p++) = HIGH(lower_bound->first - segments);
1419         *(p++) = LOW(lower_bound->first - segments);
1420       }
1421       if (upper_bound)
1422       {
1423         *(p++) = HIGH(upper_bound->first - segments);
1424         *(p++) = LOW(upper_bound->first - segments);
1425       }
1426
1427       p = TA_hints_recorder_handle_segments(p, axis, serif, wraps);
1428     }
1429     break;
1430
1431   case ta_serif_anchor:
1432   case ta_serif_link2:
1433     {
1434       TA_Edge edge = (TA_Edge)arg1;
1435
1436
1437       *(p++) = 0;
1438       *(p++) = (FT_Byte)action + ACTION_OFFSET
1439                + (lower_bound != NULL)
1440                + 2 * (upper_bound != NULL);
1441
1442       *(p++) = HIGH(edge->first - segments);
1443       *(p++) = LOW(edge->first - segments);
1444
1445       if (lower_bound)
1446       {
1447         *(p++) = HIGH(lower_bound->first - segments);
1448         *(p++) = LOW(lower_bound->first - segments);
1449       }
1450       if (upper_bound)
1451       {
1452         *(p++) = HIGH(upper_bound->first - segments);
1453         *(p++) = LOW(upper_bound->first - segments);
1454       }
1455
1456       p = TA_hints_recorder_handle_segments(p, axis, edge, wraps);
1457     }
1458     break;
1459
1460   case ta_serif_link1:
1461     {
1462       TA_Edge edge = (TA_Edge)arg1;
1463       TA_Edge before = arg2;
1464       TA_Edge after = arg3;
1465
1466
1467       *(p++) = 0;
1468       *(p++) = (FT_Byte)action + ACTION_OFFSET
1469                + (lower_bound != NULL)
1470                + 2 * (upper_bound != NULL);
1471
1472       *(p++) = HIGH(before->first - segments);
1473       *(p++) = LOW(before->first - segments);
1474       *(p++) = HIGH(edge->first - segments);
1475       *(p++) = LOW(edge->first - segments);
1476       *(p++) = HIGH(after->first - segments);
1477       *(p++) = LOW(after->first - segments);
1478
1479       if (lower_bound)
1480       {
1481         *(p++) = HIGH(lower_bound->first - segments);
1482         *(p++) = LOW(lower_bound->first - segments);
1483       }
1484       if (upper_bound)
1485       {
1486         *(p++) = HIGH(upper_bound->first - segments);
1487         *(p++) = LOW(upper_bound->first - segments);
1488       }
1489
1490       p = TA_hints_recorder_handle_segments(p, axis, edge, wraps);
1491     }
1492     break;
1493
1494   default:
1495     /* there are more cases in the enumeration */
1496     /* which are handled with flags */
1497     break;
1498   }
1499
1500   recorder->hints_record.num_actions++;
1501   recorder->hints_record.buf = p;
1502 }
1503
1504
1505 static FT_Error
1506 TA_init_recorder(Recorder* recorder,
1507                  FONT* font,
1508                  GLYPH* glyph,
1509                  TA_GlyphHints hints)
1510 {
1511   TA_AxisHints axis = &hints->axis[TA_DIMENSION_VERT];
1512   TA_Point points = hints->points;
1513   TA_Point point_limit = points + hints->num_points;
1514   TA_Point point;
1515
1516   TA_Segment segments = axis->segments;
1517   TA_Segment seg_limit = segments + axis->num_segments;
1518   TA_Segment seg;
1519
1520   FT_UInt num_strong_points = 0;
1521   FT_UInt* wrap_around_segment;
1522
1523   recorder->font = font;
1524   recorder->glyph = glyph;
1525   recorder->num_segments = axis->num_segments;
1526
1527   recorder->ip_before_points = NULL;
1528   recorder->ip_after_points = NULL;
1529   recorder->ip_on_point_array = NULL;
1530   recorder->ip_between_point_array = NULL;
1531
1532   recorder->num_stack_elements = 0;
1533
1534   /* no need to clean up allocated arrays in case of error; */
1535   /* this is handled later by `TA_free_recorder' */
1536
1537   recorder->num_wrap_around_segments = 0;
1538   for (seg = segments; seg < seg_limit; seg++)
1539     if (seg->first > seg->last)
1540       recorder->num_wrap_around_segments++;
1541
1542   recorder->wrap_around_segments =
1543     (FT_UInt*)malloc(recorder->num_wrap_around_segments * sizeof (FT_UInt));
1544   if (!recorder->wrap_around_segments)
1545     return FT_Err_Out_Of_Memory;
1546
1547   wrap_around_segment = recorder->wrap_around_segments;
1548   for (seg = segments; seg < seg_limit; seg++)
1549     if (seg->first > seg->last)
1550       *(wrap_around_segment++) = seg - segments;
1551
1552   /* get number of strong points */
1553   for (point = points; point < point_limit; point++)
1554   {
1555     /* actually, we need to test `TA_FLAG_TOUCH_Y' also; */
1556     /* however, this value isn't known yet */
1557     /* (or rather, it can vary between different pixel sizes) */
1558     if (point->flags & TA_FLAG_WEAK_INTERPOLATION)
1559       continue;
1560
1561     num_strong_points++;
1562   }
1563
1564   recorder->num_strong_points = num_strong_points;
1565
1566   recorder->ip_before_points =
1567     (FT_UInt*)malloc(num_strong_points * sizeof (FT_UInt));
1568   if (!recorder->ip_before_points)
1569     return FT_Err_Out_Of_Memory;
1570
1571   recorder->ip_after_points =
1572     (FT_UInt*)malloc(num_strong_points * sizeof (FT_UInt));
1573   if (!recorder->ip_after_points)
1574     return FT_Err_Out_Of_Memory;
1575
1576   /* actually, we need `hints->num_edges' for the array sizes; */
1577   /* however, this value isn't known yet */
1578   /* (or rather, it can vary between different pixel sizes) */
1579   recorder->ip_on_point_array =
1580     (FT_UInt*)malloc(axis->num_segments
1581                      * num_strong_points * sizeof (FT_UInt));
1582   if (!recorder->ip_on_point_array)
1583     return FT_Err_Out_Of_Memory;
1584
1585   recorder->ip_between_point_array =
1586     (FT_UInt*)malloc(axis->num_segments * axis->num_segments
1587                      * num_strong_points * sizeof (FT_UInt));
1588   if (!recorder->ip_between_point_array)
1589     return FT_Err_Out_Of_Memory;
1590
1591   return FT_Err_Ok;
1592 }
1593
1594
1595 static void
1596 TA_reset_recorder(Recorder* recorder,
1597                   FT_Byte* bufp)
1598 {
1599   recorder->hints_record.buf = bufp;
1600   recorder->hints_record.num_actions = 0;
1601 }
1602
1603
1604 static void
1605 TA_rewind_recorder(Recorder* recorder,
1606                    FT_Byte* bufp,
1607                    FT_UInt size)
1608 {
1609   TA_reset_recorder(recorder, bufp);
1610
1611   recorder->hints_record.size = size;
1612
1613   /* We later check with MISSING (which expands to 0xFF bytes) */
1614
1615   memset(recorder->ip_before_points, 0xFF,
1616          recorder->num_strong_points * sizeof (FT_UInt));
1617   memset(recorder->ip_after_points, 0xFF,
1618          recorder->num_strong_points * sizeof (FT_UInt));
1619
1620   memset(recorder->ip_on_point_array, 0xFF,
1621          recorder->num_segments
1622          * recorder->num_strong_points * sizeof (FT_UInt));
1623   memset(recorder->ip_between_point_array, 0xFF,
1624          recorder->num_segments * recorder->num_segments
1625          * recorder->num_strong_points * sizeof (FT_UInt));
1626 }
1627
1628
1629 static void
1630 TA_free_recorder(Recorder* recorder)
1631 {
1632   free(recorder->wrap_around_segments);
1633
1634   free(recorder->ip_before_points);
1635   free(recorder->ip_after_points);
1636   free(recorder->ip_on_point_array);
1637   free(recorder->ip_between_point_array);
1638 }
1639
1640
1641 FT_Error
1642 TA_sfnt_build_glyph_instructions(SFNT* sfnt,
1643                                  FONT* font,
1644                                  FT_Long idx)
1645 {
1646   FT_Face face = sfnt->face;
1647   FT_Error error;
1648
1649   FT_Byte* ins_buf;
1650   FT_UInt ins_len;
1651   FT_Byte* bufp;
1652   FT_Byte* p;
1653
1654   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
1655   glyf_Data* data = (glyf_Data*)glyf_table->data;
1656   /* `idx' is never negative */
1657   GLYPH* glyph = &data->glyphs[idx];
1658
1659   TA_GlyphHints hints;
1660
1661   FT_UInt num_action_hints_records;
1662   FT_UInt num_point_hints_records;
1663   Hints_Record* action_hints_records;
1664   Hints_Record* point_hints_records;
1665
1666   Recorder recorder;
1667   FT_UInt num_stack_elements;
1668   FT_Bool optimize = 0;
1669
1670   FT_Int32 load_flags;
1671   FT_UInt size;
1672
1673   FT_Byte* pos[3];
1674
1675
1676   /* XXX: right now, we abuse this flag to control */
1677   /*      the global behaviour of the auto-hinter */
1678   load_flags = font->fallback_script << 30;
1679   load_flags |= 1 << 28; /* vertical hinting only */
1680   if (font->increase_x_height)
1681     load_flags |= 1 << 29;
1682   if (!font->pre_hinting)
1683     load_flags |= FT_LOAD_NO_SCALE;
1684
1685   /* computing the segments is resolution independent, */
1686   /* thus the pixel size in this call is arbitrary */
1687   error = FT_Set_Pixel_Sizes(face, 20, 20);
1688   if (error)
1689     return error;
1690
1691   ta_loader_register_hints_recorder(font->loader, NULL, NULL);
1692   error = ta_loader_load_glyph(font->loader, face, (FT_UInt)idx, load_flags);
1693   if (error)
1694     return error;
1695
1696   /* do nothing if we have an empty glyph */
1697   if (!face->glyph->outline.n_contours)
1698     return FT_Err_Ok;
1699
1700   hints = &font->loader->hints;
1701
1702   /* do nothing if the setup delivered the dummy module only */
1703   if (!hints->num_points)
1704     return FT_Err_Ok;
1705
1706   /* we allocate a buffer which is certainly large enough */
1707   /* to hold all of the created bytecode instructions; */
1708   /* later on it gets reallocated to its real size */
1709   ins_len = hints->num_points * 1000;
1710   ins_buf = (FT_Byte*)malloc(ins_len);
1711   if (!ins_buf)
1712     return FT_Err_Out_Of_Memory;
1713
1714   /* initialize array with an invalid bytecode */
1715   /* so that we can easily find the array length at reallocation time */
1716   memset(ins_buf, INS_A0, ins_len);
1717
1718   /* handle composite glyph */
1719   if (font->loader->gloader->base.num_subglyphs)
1720   {
1721     bufp = TA_font_build_subglyph_shifter(font, ins_buf);
1722     if (!bufp)
1723     {
1724       error = FT_Err_Out_Of_Memory;
1725       goto Err;
1726     }
1727
1728     goto Done1;
1729   }
1730
1731   /* only scale the glyph if the dummy hinter has been used */
1732   if (font->loader->metrics->clazz == &ta_dummy_script_class)
1733   {
1734     /* since `TA_init_recorder' hasn't been called yet, */
1735     /* we manually initialize the `glyph' field */
1736     recorder.glyph = glyph;
1737
1738     bufp = TA_sfnt_build_glyph_scaler(sfnt, &recorder, ins_buf);
1739     if (!bufp)
1740     {
1741       error = FT_Err_Out_Of_Memory;
1742       goto Err;
1743     }
1744
1745     goto Done1;
1746   }
1747
1748   error = TA_init_recorder(&recorder, font, glyph, hints);
1749   if (error)
1750     goto Err;
1751
1752   /* loop over a large range of pixel sizes */
1753   /* to find hints records which get pushed onto the bytecode stack */
1754
1755 #ifdef DEBUGGING
1756   {
1757     int num_chars, i;
1758
1759
1760     num_chars = fprintf(stderr, "glyph %ld\n", idx);
1761     for (i = 0; i < num_chars - 1; i++)
1762       putc('=', stderr);
1763     fprintf(stderr, "\n\n");
1764
1765   }
1766 #endif
1767
1768   /* we temporarily use `ins_buf' to record the current glyph hints */
1769   ta_loader_register_hints_recorder(font->loader,
1770                                     TA_hints_recorder,
1771                                     (void*)&recorder);
1772
1773   num_action_hints_records = 0;
1774   num_point_hints_records = 0;
1775   action_hints_records = NULL;
1776   point_hints_records = NULL;
1777
1778   for (size = font->hinting_range_min;
1779        size <= font->hinting_range_max;
1780        size++)
1781   {
1782 #ifdef DEBUGGING
1783     int have_dumps = 0;
1784 #endif
1785
1786
1787     TA_rewind_recorder(&recorder, ins_buf, size);
1788
1789     error = FT_Set_Pixel_Sizes(face, size, size);
1790     if (error)
1791       goto Err;
1792
1793     /* calling `ta_loader_load_glyph' uses the */
1794     /* `TA_hints_recorder' function as a callback, */
1795     /* modifying `hints_record' */
1796     error = ta_loader_load_glyph(font->loader, face, idx, load_flags);
1797     if (error)
1798       goto Err;
1799
1800     if (TA_hints_record_is_different(action_hints_records,
1801                                      num_action_hints_records,
1802                                      ins_buf, recorder.hints_record.buf))
1803     {
1804 #ifdef DEBUGGING
1805       {
1806         have_dumps = 1;
1807
1808         fprintf(stderr, "  size %d:\n", size);
1809
1810         ta_glyph_hints_dump_edges(_ta_debug_hints);
1811         ta_glyph_hints_dump_segments(_ta_debug_hints);
1812         ta_glyph_hints_dump_points(_ta_debug_hints);
1813
1814         fprintf(stderr, "  action hints record:\n");
1815         for (p = ins_buf; p < recorder.hints_record.buf; p += 2)
1816           fprintf(stderr, " %2d", *p * 256 + *(p + 1));
1817         fprintf(stderr, "\n");
1818       }
1819 #endif
1820
1821       error = TA_add_hints_record(&action_hints_records,
1822                                   &num_action_hints_records,
1823                                   ins_buf, recorder.hints_record);
1824       if (error)
1825         goto Err;
1826     }
1827
1828     /* now handle point records */
1829
1830     TA_reset_recorder(&recorder, ins_buf);
1831
1832     /* use the point hints data collected in `TA_hints_recorder' */
1833     TA_build_point_hints(&recorder, hints);
1834
1835     if (TA_hints_record_is_different(point_hints_records,
1836                                      num_point_hints_records,
1837                                      ins_buf, recorder.hints_record.buf))
1838     {
1839 #ifdef DEBUGGING
1840       {
1841         if (!have_dumps)
1842         {
1843           fprintf(stderr, "  size %d:\n", size);
1844
1845           ta_glyph_hints_dump_edges(_ta_debug_hints);
1846           ta_glyph_hints_dump_segments(_ta_debug_hints);
1847           ta_glyph_hints_dump_points(_ta_debug_hints);
1848         }
1849
1850         fprintf(stderr, "  point hints record:\n");
1851         for (p = ins_buf; p < recorder.hints_record.buf; p += 2)
1852           fprintf(stderr, " %2d", *p * 256 + *(p + 1));
1853         fprintf(stderr, "\n");
1854       }
1855 #endif
1856
1857       error = TA_add_hints_record(&point_hints_records,
1858                                   &num_point_hints_records,
1859                                   ins_buf, recorder.hints_record);
1860       if (error)
1861         goto Err;
1862     }
1863   }
1864
1865   if (num_action_hints_records == 1 && !action_hints_records[0].num_actions)
1866   {
1867     /* since we only have a single empty record we just scale the glyph */
1868     bufp = TA_sfnt_build_glyph_scaler(sfnt, &recorder, ins_buf);
1869     if (!bufp)
1870     {
1871       error = FT_Err_Out_Of_Memory;
1872       goto Err;
1873     }
1874
1875     /* clear the rest of the temporarily used part of `ins_buf' */
1876     p = bufp;
1877     while (*p != INS_A0)
1878       *(p++) = INS_A0;
1879
1880     goto Done;
1881   }
1882
1883   /* if there is only a single record, */
1884   /* we do a global optimization later on */
1885   if (num_action_hints_records > 1)
1886     optimize = 1;
1887
1888   /* store the hints records and handle stack depth */
1889   pos[0] = ins_buf;
1890   bufp = TA_emit_hints_records(&recorder,
1891                                point_hints_records,
1892                                num_point_hints_records,
1893                                ins_buf,
1894                                optimize);
1895
1896   num_stack_elements = recorder.num_stack_elements;
1897   recorder.num_stack_elements = 0;
1898
1899   pos[1] = bufp;
1900   bufp = TA_emit_hints_records(&recorder,
1901                                action_hints_records,
1902                                num_action_hints_records,
1903                                bufp,
1904                                optimize);
1905
1906   recorder.num_stack_elements += num_stack_elements;
1907
1908   pos[2] = bufp;
1909   bufp = TA_sfnt_build_glyph_segments(sfnt, &recorder, bufp, optimize);
1910   if (!bufp)
1911   {
1912     error = FT_Err_Out_Of_Memory;
1913     goto Err;
1914   }
1915
1916   /* XXX improve handling of NPUSHW */
1917   if (num_action_hints_records == 1
1918       && *(pos[0]) != NPUSHW && *(pos[1]) != NPUSHW && *(pos[2]) != NPUSHW)
1919   {
1920     /*
1921      * we optimize two common cases, replacing
1922      *
1923      *   NPUSHB A ... NPUSHB B [... NPUSHB C] ... CALL
1924      *
1925      * with
1926      *
1927      *   NPUSHB (A+B[+C]) ... CALL
1928      *
1929      * if possible
1930      */
1931     FT_Byte sizes[3];
1932     FT_Byte new_size1;
1933     FT_Byte new_size2;
1934
1935     FT_UInt sum;
1936     FT_UInt i;
1937     FT_UInt pos_idx;
1938
1939
1940     /* the point hints records block can be missing */
1941     if (pos[0] == pos[1])
1942     {
1943       pos[1] = pos[2];
1944       pos[2] = NULL;
1945     }
1946
1947     /* there are at least two NPUSHB instructions */
1948     /* (one of them directly at the start) */
1949     sizes[0] = *(pos[0] + 1);
1950     sizes[1] = *(pos[1] + 1);
1951     sizes[2] = pos[2] ? *(pos[2] + 1) : 0;
1952
1953     sum = sizes[0] + sizes[1] + sizes[2];
1954
1955     if (sum > 2 * 0xFF)
1956       goto Done2; /* nothing to do since we need three NPUSHB */
1957     else if (!sizes[2] && (sum > 0xFF))
1958       goto Done2; /* nothing to do since we need two NPUSHB */
1959
1960     if (sum > 0xFF)
1961     {
1962       /* reduce three NPUSHB to two */
1963       new_size1 = 0xFF;
1964       new_size2 = sum - 0xFF;
1965     }
1966     else
1967     {
1968       /* reduce two or three NPUSHB to one */
1969       new_size1 = sum;
1970       new_size2 = 0;
1971     }
1972
1973     /* pack data */
1974     p = ins_buf;
1975     bufp = ins_buf;
1976     pos_idx = 0;
1977
1978     if (new_size1 <= 8)
1979       BCI(PUSHB_1 - 1 + new_size1);
1980     else
1981     {
1982       BCI(NPUSHB);
1983       BCI(new_size1);
1984     }
1985     for (i = 0; i < new_size1; i++)
1986     {
1987       if (p == pos[pos_idx])
1988       {
1989         pos_idx++;
1990         p += 2; /* skip old NPUSHB */
1991       }
1992       *(bufp++) = *(p++);
1993     }
1994
1995     if (new_size2)
1996     {
1997       if (new_size2 <= 8)
1998         BCI(PUSHB_1 - 1 + new_size2);
1999       else
2000       {
2001         BCI(NPUSHB);
2002         BCI(new_size2);
2003       }
2004       for (i = 0; i < new_size2; i++)
2005       {
2006         if (p == pos[pos_idx])
2007         {
2008           pos_idx++;
2009           p += 2;
2010         }
2011         *(bufp++) = *(p++);
2012       }
2013     }
2014
2015     BCI(CALL);
2016   }
2017
2018 Done2:
2019   /* clear the rest of the temporarily used part of `ins_buf' */
2020   p = bufp;
2021   while (*p != INS_A0)
2022     *(p++) = INS_A0;
2023
2024 Done:
2025   TA_free_hints_records(action_hints_records, num_action_hints_records);
2026   TA_free_recorder(&recorder);
2027
2028   /* we are done, so reallocate the instruction array to its real size */
2029   if (*bufp == INS_A0)
2030   {
2031     /* search backwards */
2032     while (*bufp == INS_A0)
2033       bufp--;
2034     bufp++;
2035   }
2036   else
2037   {
2038     /* search forwards */
2039     while (*bufp != INS_A0)
2040       bufp++;
2041   }
2042
2043 Done1:
2044   ins_len = bufp - ins_buf;
2045
2046   if (ins_len > sfnt->max_instructions)
2047     sfnt->max_instructions = ins_len;
2048
2049   glyph->ins_buf = (FT_Byte*)realloc(ins_buf, ins_len);
2050   glyph->ins_len = ins_len;
2051
2052   return FT_Err_Ok;
2053
2054 Err:
2055   TA_free_hints_records(action_hints_records, num_action_hints_records);
2056   TA_free_recorder(&recorder);
2057   free(ins_buf);
2058
2059   return error;
2060 }
2061
2062
2063 /* end of tabytecode.c */