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