lib/tabytecode.c

   1 /* tabytecode.c */
   2
   3 /*
   4  * Copyright (C) 2011-2013 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_composites)
 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_composites)
 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_composites)
 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
 589   FT_Byte* p = recorder->hints_record.buf;
 590   FT_UShort num_edges = axis->num_edges;
 591   FT_UShort num_strong_points = recorder->num_strong_points;
 592
 593   FT_UShort i;
 594   FT_UShort j;
 595   FT_UShort k;
 596
 597   FT_UShort* ip;
 598   FT_UShort* iq;
 599   FT_UShort* ir;
 600   FT_UShort* ip_limit;
 601   FT_UShort* iq_limit;
 602   FT_UShort* ir_limit;
 603
 604
 605   /* we store everything as 16bit numbers; */
 606   /* the function numbers (`ta_ip_before', etc.) */
 607   /* reflect the order in the TA_Action enumeration */
 608
 609   /* ip_before_points */
 610
 611   i = 0;
 612   ip = recorder->ip_before_points;
 613   ip_limit = ip + num_strong_points;
 614   for (; ip < ip_limit; ip++)
 615   {
 616     if (*ip != MISSING)
 617       i++;
 618     else
 619       break;
 620   }
 621
 622   if (i)
 623   {
 624     recorder->hints_record.num_actions++;
 625
 626     edge = edges;
 627
 628     *(p++) = 0;
 629     *(p++) = (FT_Byte)ta_ip_before + ACTION_OFFSET;
 630     *(p++) = HIGH(edge->first - segments);
 631     *(p++) = LOW(edge->first - segments);
 632     *(p++) = HIGH(i);
 633     *(p++) = LOW(i);
 634
 635     ip = recorder->ip_before_points;
 636     ip_limit = ip + i;
 637     for (; ip < ip_limit; ip++)
 638     {
 639       FT_UInt point = TA_adjust_point_index(recorder, *ip);
 640
 641
 642       *(p++) = HIGH(point);
 643       *(p++) = LOW(point);
 644     }
 645   }
 646
 647   /* ip_after_points */
 648
 649   i = 0;
 650   ip = recorder->ip_after_points;
 651   ip_limit = ip + num_strong_points;
 652   for (; ip < ip_limit; ip++)
 653   {
 654     if (*ip != MISSING)
 655       i++;
 656     else
 657       break;
 658   }
 659
 660   if (i)
 661   {
 662     recorder->hints_record.num_actions++;
 663
 664     edge = edges + axis->num_edges - 1;
 665
 666     *(p++) = 0;
 667     *(p++) = (FT_Byte)ta_ip_after + ACTION_OFFSET;
 668     *(p++) = HIGH(edge->first - segments);
 669     *(p++) = LOW(edge->first - segments);
 670     *(p++) = HIGH(i);
 671     *(p++) = LOW(i);
 672
 673     ip = recorder->ip_after_points;
 674     ip_limit = ip + i;
 675     for (; ip < ip_limit; ip++)
 676     {
 677       FT_UInt point = TA_adjust_point_index(recorder, *ip);
 678
 679
 680       *(p++) = HIGH(point);
 681       *(p++) = LOW(point);
 682     }
 683   }
 684
 685   /* ip_on_point_array */
 686
 687   i = 0;
 688   ip = recorder->ip_on_point_array;
 689   ip_limit = ip + num_edges * num_strong_points;
 690   for (; ip < ip_limit; ip += num_strong_points)
 691     if (*ip != MISSING)
 692       i++;
 693
 694   if (i)
 695   {
 696     recorder->hints_record.num_actions++;
 697
 698     *(p++) = 0;
 699     *(p++) = (FT_Byte)ta_ip_on + ACTION_OFFSET;
 700     *(p++) = HIGH(i);
 701     *(p++) = LOW(i);
 702
 703     i = 0;
 704     ip = recorder->ip_on_point_array;
 705     ip_limit = ip + num_edges * num_strong_points;
 706     for (; ip < ip_limit; ip += num_strong_points, i++)
 707     {
 708       if (*ip == MISSING)
 709         continue;
 710
 711       edge = edges + i;
 712
 713       *(p++) = HIGH(edge->first - segments);
 714       *(p++) = LOW(edge->first - segments);
 715
 716       j = 0;
 717       iq = ip;
 718       iq_limit = iq + num_strong_points;
 719       for (; iq < iq_limit; iq++)
 720       {
 721         if (*iq != MISSING)
 722           j++;
 723         else
 724           break;
 725       }
 726
 727       *(p++) = HIGH(j);
 728       *(p++) = LOW(j);
 729
 730       iq = ip;
 731       iq_limit = iq + j;
 732       for (; iq < iq_limit; iq++)
 733       {
 734         FT_UInt point = TA_adjust_point_index(recorder, *iq);
 735
 736
 737         *(p++) = HIGH(point);
 738         *(p++) = LOW(point);
 739       }
 740     }
 741   }
 742
 743   /* ip_between_point_array */
 744
 745   i = 0;
 746   ip = recorder->ip_between_point_array;
 747   ip_limit = ip + num_edges * num_edges * num_strong_points;
 748   for (; ip < ip_limit; ip += num_strong_points)
 749     if (*ip != MISSING)
 750       i++;
 751
 752   if (i)
 753   {
 754     recorder->hints_record.num_actions++;
 755
 756     *(p++) = 0;
 757     *(p++) = (FT_Byte)ta_ip_between + ACTION_OFFSET;
 758     *(p++) = HIGH(i);
 759     *(p++) = LOW(i);
 760
 761     i = 0;
 762     ip = recorder->ip_between_point_array;
 763     ip_limit = ip + num_edges * num_edges * num_strong_points;
 764     for (;
 765          ip < ip_limit;
 766          ip += num_edges * num_strong_points, i++)
 767     {
 768       TA_Edge before;
 769       TA_Edge after;
 770
 771
 772       before = edges + i;
 773
 774       j = 0;
 775       iq = ip;
 776       iq_limit = iq + num_edges * num_strong_points;
 777       for (; iq < iq_limit; iq += num_strong_points, j++)
 778       {
 779         if (*iq == MISSING)
 780           continue;
 781
 782         after = edges + j;
 783
 784         *(p++) = HIGH(after->first - segments);
 785         *(p++) = LOW(after->first - segments);
 786         *(p++) = HIGH(before->first - segments);
 787         *(p++) = LOW(before->first - segments);
 788
 789         k = 0;
 790         ir = iq;
 791         ir_limit = ir + num_strong_points;
 792         for (; ir < ir_limit; ir++)
 793         {
 794           if (*ir != MISSING)
 795             k++;
 796           else
 797             break;
 798         }
 799
 800         *(p++) = HIGH(k);
 801         *(p++) = LOW(k);
 802
 803         ir = iq;
 804         ir_limit = ir + k;
 805         for (; ir < ir_limit; ir++)
 806         {
 807           FT_UInt point = TA_adjust_point_index(recorder, *ir);
 808
 809
 810           *(p++) = HIGH(point);
 811           *(p++) = LOW(point);
 812         }
 813       }
 814     }
 815   }
 816
 817   recorder->hints_record.buf = p;
 818 }
 819
 820
 821 static FT_Bool
 822 TA_hints_record_is_different(Hints_Record* hints_records,
 823                              FT_UInt num_hints_records,
 824                              FT_Byte* start,
 825                              FT_Byte* end)
 826 {
 827   Hints_Record last_hints_record;
 828
 829
 830   if (!hints_records)
 831     return 1;
 832
 833   /* we only need to compare with the last hints record */
 834   last_hints_record = hints_records[num_hints_records - 1];
 835
 836   if ((FT_UInt)(end - start) != last_hints_record.buf_len)
 837     return 1;
 838
 839   if (memcmp(start, last_hints_record.buf, last_hints_record.buf_len))
 840     return 1;
 841
 842   return 0;
 843 }
 844
 845
 846 static FT_Error
 847 TA_add_hints_record(Hints_Record** hints_records,
 848                     FT_UInt* num_hints_records,
 849                     FT_Byte* start,
 850                     Hints_Record hints_record)
 851 {
 852   Hints_Record* hints_records_new;
 853   FT_UInt buf_len;
 854   /* at this point, `hints_record.buf' still points into `ins_buf' */
 855   FT_Byte* end = hints_record.buf;
 856
 857
 858   buf_len = (FT_UInt)(end - start);
 859
 860   /* now fill the structure completely */
 861   hints_record.buf_len = buf_len;
 862   hints_record.buf = (FT_Byte*)malloc(buf_len);
 863   if (!hints_record.buf)
 864     return FT_Err_Out_Of_Memory;
 865
 866   memcpy(hints_record.buf, start, buf_len);
 867
 868   (*num_hints_records)++;
 869   hints_records_new =
 870     (Hints_Record*)realloc(*hints_records, *num_hints_records
 871                                            * sizeof (Hints_Record));
 872   if (!hints_records_new)
 873   {
 874     free(hints_record.buf);
 875     (*num_hints_records)--;
 876     return FT_Err_Out_Of_Memory;
 877   }
 878   else
 879     *hints_records = hints_records_new;
 880
 881   (*hints_records)[*num_hints_records - 1] = hints_record;
 882
 883   return FT_Err_Ok;
 884 }
 885
 886
 887 static FT_Byte*
 888 TA_emit_hints_record(Recorder* recorder,
 889                      Hints_Record* hints_record,
 890                      FT_Byte* bufp,
 891                      FT_Bool optimize)
 892 {
 893   FT_Byte* p;
 894   FT_Byte* endp;
 895   FT_Bool need_words = 0;
 896
 897   FT_UInt i, j;
 898   FT_UInt num_arguments;
 899   FT_UInt num_args;
 900
 901
 902   /* check whether any argument is larger than 0xFF */
 903   endp = hints_record->buf + hints_record->buf_len;
 904   for (p = hints_record->buf; p < endp; p += 2)
 905     if (*p)
 906       need_words = 1;
 907
 908   /* with most fonts it is very rare */
 909   /* that any of the pushed arguments is larger than 0xFF, */
 910   /* thus we refrain from further optimizing this case */
 911
 912   num_arguments = hints_record->buf_len / 2;
 913   p = endp - 2;
 914
 915   if (need_words)
 916   {
 917     for (i = 0; i < num_arguments; i += 255)
 918     {
 919       num_args = (num_arguments - i > 255) ? 255 : (num_arguments - i);
 920
 921       if (optimize && num_args <= 8)
 922         BCI(PUSHW_1 - 1 + num_args);
 923       else
 924       {
 925         BCI(NPUSHW);
 926         BCI(num_args);
 927       }
 928       for (j = 0; j < num_args; j++)
 929       {
 930         BCI(*p);
 931         BCI(*(p + 1));
 932         p -= 2;
 933       }
 934     }
 935   }
 936   else
 937   {
 938     /* we only need the lower bytes */
 939     p++;
 940
 941     for (i = 0; i < num_arguments; i += 255)
 942     {
 943       num_args = (num_arguments - i > 255) ? 255 : (num_arguments - i);
 944
 945       if (optimize && num_args <= 8)
 946         BCI(PUSHB_1 - 1 + num_args);
 947       else
 948       {
 949         BCI(NPUSHB);
 950         BCI(num_args);
 951       }
 952       for (j = 0; j < num_args; j++)
 953       {
 954         BCI(*p);
 955         p -= 2;
 956       }
 957     }
 958   }
 959
 960   /* collect stack depth data */
 961   if (num_arguments > recorder->num_stack_elements)
 962     recorder->num_stack_elements = num_arguments;
 963
 964   return bufp;
 965 }
 966
 967
 968 static FT_Byte*
 969 TA_emit_hints_records(Recorder* recorder,
 970                       Hints_Record* hints_records,
 971                       FT_UInt num_hints_records,
 972                       FT_Byte* bufp,
 973                       FT_Bool optimize)
 974 {
 975   FT_UInt i;
 976   Hints_Record* hints_record;
 977
 978
 979   hints_record = hints_records;
 980
 981   for (i = 0; i < num_hints_records - 1; i++)
 982   {
 983     BCI(MPPEM);
 984     if (hints_record->size > 0xFF)
 985     {
 986       BCI(PUSHW_1);
 987       BCI(HIGH((hints_record + 1)->size));
 988       BCI(LOW((hints_record + 1)->size));
 989     }
 990     else
 991     {
 992       BCI(PUSHB_1);
 993       BCI((hints_record + 1)->size);
 994     }
 995     BCI(LT);
 996     BCI(IF);
 997     bufp = TA_emit_hints_record(recorder, hints_record, bufp, optimize);
 998     BCI(ELSE);
 999
1000     hints_record++;
1001   }
1002
1003   bufp = TA_emit_hints_record(recorder, hints_record, bufp, optimize);
1004
1005   for (i = 0; i < num_hints_records - 1; i++)
1006     BCI(EIF);
1007
1008   return bufp;
1009 }
1010
1011
1012 static void
1013 TA_free_hints_records(Hints_Record* hints_records,
1014                       FT_UInt num_hints_records)
1015 {
1016   FT_UInt i;
1017
1018
1019   for (i = 0; i < num_hints_records; i++)
1020     free(hints_records[i].buf);
1021
1022   free(hints_records);
1023 }
1024
1025
1026 static FT_Byte*
1027 TA_hints_recorder_handle_segments(FT_Byte* bufp,
1028                                   TA_AxisHints axis,
1029                                   TA_Edge edge,
1030                                   FT_UShort* wraps)
1031 {
1032   TA_Segment segments = axis->segments;
1033   TA_Segment seg;
1034   FT_UShort seg_idx;
1035   FT_UShort num_segs = 0;
1036   FT_UShort* wrap;
1037
1038
1039   seg_idx = edge->first - segments;
1040
1041   /* we store everything as 16bit numbers */
1042   *(bufp++) = HIGH(seg_idx);
1043   *(bufp++) = LOW(seg_idx);
1044
1045   /* wrap-around segments are stored as two segments */
1046   if (edge->first->first > edge->first->last)
1047     num_segs++;
1048
1049   seg = edge->first->edge_next;
1050   while (seg != edge->first)
1051   {
1052     num_segs++;
1053
1054     if (seg->first > seg->last)
1055       num_segs++;
1056
1057     seg = seg->edge_next;
1058   }
1059
1060   *(bufp++) = HIGH(num_segs);
1061   *(bufp++) = LOW(num_segs);
1062
1063   if (edge->first->first > edge->first->last)
1064   {
1065     /* emit second part of wrap-around segment; */
1066     /* the bytecode positions such segments after `normal' ones */
1067     wrap = wraps;
1068     for (;;)
1069     {
1070       if (seg_idx == *wrap)
1071         break;
1072       wrap++;
1073     }
1074
1075     *(bufp++) = HIGH(axis->num_segments + (wrap - wraps));
1076     *(bufp++) = LOW(axis->num_segments + (wrap - wraps));
1077   }
1078
1079   seg = edge->first->edge_next;
1080   while (seg != edge->first)
1081   {
1082     seg_idx = seg - segments;
1083
1084     *(bufp++) = HIGH(seg_idx);
1085     *(bufp++) = LOW(seg_idx);
1086
1087     if (seg->first > seg->last)
1088     {
1089       wrap = wraps;
1090       for (;;)
1091       {
1092         if (seg_idx == *wrap)
1093           break;
1094         wrap++;
1095       }
1096
1097       *(bufp++) = HIGH(axis->num_segments + (wrap - wraps));
1098       *(bufp++) = LOW(axis->num_segments + (wrap - wraps));
1099     }
1100
1101     seg = seg->edge_next;
1102   }
1103
1104   return bufp;
1105 }
1106
1107
1108 static void
1109 TA_hints_recorder(TA_Action action,
1110                   TA_GlyphHints hints,
1111                   TA_Dimension dim,
1112                   void* arg1,
1113                   TA_Edge arg2,
1114                   TA_Edge arg3,
1115                   TA_Edge lower_bound,
1116                   TA_Edge upper_bound)
1117 {
1118   TA_AxisHints axis = &hints->axis[dim];
1119   TA_Edge edges = axis->edges;
1120   TA_Segment segments = axis->segments;
1121   TA_Point points = hints->points;
1122
1123   Recorder* recorder = (Recorder*)hints->user;
1124   FONT* font = recorder->font;
1125   FT_UShort* wraps = recorder->wrap_around_segments;
1126   FT_Byte* p = recorder->hints_record.buf;
1127
1128   FT_UShort* ip;
1129   FT_UShort* limit;
1130
1131
1132   if (dim == TA_DIMENSION_HORZ)
1133     return;
1134
1135   /* we collect point hints for later processing */
1136   switch (action)
1137   {
1138   case ta_ip_before:
1139     {
1140       TA_Point point = (TA_Point)arg1;
1141
1142
1143       ip = recorder->ip_before_points;
1144       limit = ip + recorder->num_strong_points;
1145       for (; ip < limit; ip++)
1146       {
1147         if (*ip == MISSING)
1148         {
1149           *ip = point - points;
1150           break;
1151         }
1152       }
1153     }
1154     return;
1155
1156   case ta_ip_after:
1157     {
1158       TA_Point point = (TA_Point)arg1;
1159
1160
1161       ip = recorder->ip_after_points;
1162       limit = ip + recorder->num_strong_points;
1163       for (; ip < limit; ip++)
1164       {
1165         if (*ip == MISSING)
1166         {
1167           *ip = point - points;
1168           break;
1169         }
1170       }
1171     }
1172     return;
1173
1174   case ta_ip_on:
1175     {
1176       TA_Point point = (TA_Point)arg1;
1177       TA_Edge edge = arg2;
1178
1179
1180       ip = recorder->ip_on_point_array
1181            + recorder->num_strong_points
1182              * (edge - edges);
1183       limit = ip + recorder->num_strong_points;
1184       for (; ip < limit; ip++)
1185       {
1186         if (*ip == MISSING)
1187         {
1188           *ip = point - points;
1189           break;
1190         }
1191       }
1192     }
1193     return;
1194
1195   case ta_ip_between:
1196     {
1197       TA_Point point = (TA_Point)arg1;
1198       TA_Edge before = arg2;
1199       TA_Edge after = arg3;
1200
1201
1202       /* note that `recorder->num_segments' has been used for allocation, */
1203       /* but `axis->num_edges' is used for accessing this array */
1204       ip = recorder->ip_between_point_array
1205            + recorder->num_strong_points * axis->num_edges
1206              * (before - edges)
1207            + recorder->num_strong_points
1208              * (after - edges);
1209       limit = ip + recorder->num_strong_points;
1210       for (; ip < limit; ip++)
1211       {
1212         if (*ip == MISSING)
1213         {
1214           *ip = point - points;
1215           break;
1216         }
1217       }
1218     }
1219     return;
1220
1221   case ta_bound:
1222     /* we ignore the BOUND action since we signal this information */
1223     /* with the proper function number */
1224     return;
1225
1226   default:
1227     break;
1228   }
1229
1230   /* some enum values correspond to four or eight bytecode functions; */
1231   /* if the value is n, the function numbers are n, ..., n+7, */
1232   /* to be differentiated with flags */
1233
1234   switch (action)
1235   {
1236   case ta_link:
1237     {
1238       TA_Edge base_edge = (TA_Edge)arg1;
1239       TA_Edge stem_edge = arg2;
1240
1241
1242       *(p++) = 0;
1243       *(p++) = (FT_Byte)action + ACTION_OFFSET
1244                + ((stem_edge->flags & TA_EDGE_SERIF) != 0)
1245                + 2 * ((base_edge->flags & TA_EDGE_ROUND) != 0);
1246
1247       *(p++) = HIGH(base_edge->first - segments);
1248       *(p++) = LOW(base_edge->first - segments);
1249       *(p++) = HIGH(stem_edge->first - segments);
1250       *(p++) = LOW(stem_edge->first - segments);
1251
1252       p = TA_hints_recorder_handle_segments(p, axis, stem_edge, wraps);
1253     }
1254     break;
1255
1256   case ta_anchor:
1257     {
1258       TA_Edge edge = (TA_Edge)arg1;
1259       TA_Edge edge2 = arg2;
1260
1261
1262       *(p++) = 0;
1263       *(p++) = (FT_Byte)action + ACTION_OFFSET
1264                + ((edge2->flags & TA_EDGE_SERIF) != 0)
1265                + 2 * ((edge->flags & TA_EDGE_ROUND) != 0);
1266
1267       *(p++) = HIGH(edge->first - segments);
1268       *(p++) = LOW(edge->first - segments);
1269       *(p++) = HIGH(edge2->first - segments);
1270       *(p++) = LOW(edge2->first - segments);
1271
1272       p = TA_hints_recorder_handle_segments(p, axis, edge, wraps);
1273     }
1274     break;
1275
1276   case ta_adjust:
1277     {
1278       TA_Edge edge = (TA_Edge)arg1;
1279       TA_Edge edge2 = arg2;
1280       TA_Edge edge_minus_one = lower_bound;
1281
1282
1283       *(p++) = 0;
1284       *(p++) = (FT_Byte)action + ACTION_OFFSET
1285                + ((edge2->flags & TA_EDGE_SERIF) != 0)
1286                + 2 * ((edge->flags & TA_EDGE_ROUND) != 0)
1287                + 4 * (edge_minus_one != NULL);
1288
1289       *(p++) = HIGH(edge->first - segments);
1290       *(p++) = LOW(edge->first - segments);
1291       *(p++) = HIGH(edge2->first - segments);
1292       *(p++) = LOW(edge2->first - segments);
1293
1294       if (edge_minus_one)
1295       {
1296         *(p++) = HIGH(edge_minus_one->first - segments);
1297         *(p++) = LOW(edge_minus_one->first - segments);
1298       }
1299
1300       p = TA_hints_recorder_handle_segments(p, axis, edge, wraps);
1301     }
1302     break;
1303
1304   case ta_blue_anchor:
1305     {
1306       TA_Edge edge = (TA_Edge)arg1;
1307       TA_Edge blue = arg2;
1308
1309
1310       *(p++) = 0;
1311       *(p++) = (FT_Byte)action + ACTION_OFFSET;
1312
1313       *(p++) = HIGH(blue->first - segments);
1314       *(p++) = LOW(blue->first - segments);
1315
1316       if (edge->best_blue_is_shoot)
1317       {
1318         *(p++) = HIGH(CVT_BLUE_SHOOTS_OFFSET + edge->best_blue_idx);
1319         *(p++) = LOW(CVT_BLUE_SHOOTS_OFFSET + edge->best_blue_idx);
1320       }
1321       else
1322       {
1323         *(p++) = HIGH(CVT_BLUE_REFS_OFFSET + edge->best_blue_idx);
1324         *(p++) = LOW(CVT_BLUE_REFS_OFFSET + edge->best_blue_idx);
1325       }
1326
1327       *(p++) = HIGH(edge->first - segments);
1328       *(p++) = LOW(edge->first - segments);
1329
1330       p = TA_hints_recorder_handle_segments(p, axis, edge, wraps);
1331     }
1332     break;
1333
1334   case ta_stem:
1335     {
1336       TA_Edge edge = (TA_Edge)arg1;
1337       TA_Edge edge2 = arg2;
1338       TA_Edge edge_minus_one = lower_bound;
1339
1340
1341       *(p++) = 0;
1342       *(p++) = (FT_Byte)action + ACTION_OFFSET
1343                + ((edge2->flags & TA_EDGE_SERIF) != 0)
1344                + 2 * ((edge->flags & TA_EDGE_ROUND) != 0)
1345                + 4 * (edge_minus_one != NULL);
1346
1347       *(p++) = HIGH(edge->first - segments);
1348       *(p++) = LOW(edge->first - segments);
1349       *(p++) = HIGH(edge2->first - segments);
1350       *(p++) = LOW(edge2->first - segments);
1351
1352       if (edge_minus_one)
1353       {
1354         *(p++) = HIGH(edge_minus_one->first - segments);
1355         *(p++) = LOW(edge_minus_one->first - segments);
1356       }
1357
1358       p = TA_hints_recorder_handle_segments(p, axis, edge, wraps);
1359       p = TA_hints_recorder_handle_segments(p, axis, edge2, wraps);
1360     }
1361     break;
1362
1363   case ta_blue:
1364     {
1365       TA_Edge edge = (TA_Edge)arg1;
1366
1367
1368       *(p++) = 0;
1369       *(p++) = (FT_Byte)action + ACTION_OFFSET;
1370
1371       if (edge->best_blue_is_shoot)
1372       {
1373         *(p++) = HIGH(CVT_BLUE_SHOOTS_OFFSET + edge->best_blue_idx);
1374         *(p++) = LOW(CVT_BLUE_SHOOTS_OFFSET + edge->best_blue_idx);
1375       }
1376       else
1377       {
1378         *(p++) = HIGH(CVT_BLUE_REFS_OFFSET + edge->best_blue_idx);
1379         *(p++) = LOW(CVT_BLUE_REFS_OFFSET + edge->best_blue_idx);
1380       }
1381
1382       *(p++) = HIGH(edge->first - segments);
1383       *(p++) = LOW(edge->first - segments);
1384
1385       p = TA_hints_recorder_handle_segments(p, axis, edge, wraps);
1386     }
1387     break;
1388
1389   case ta_serif:
1390     {
1391       TA_Edge serif = (TA_Edge)arg1;
1392       TA_Edge base = serif->serif;
1393
1394
1395       *(p++) = 0;
1396       *(p++) = (FT_Byte)action + ACTION_OFFSET
1397                + (lower_bound != NULL)
1398                + 2 * (upper_bound != NULL);
1399
1400       *(p++) = HIGH(serif->first - segments);
1401       *(p++) = LOW(serif->first - segments);
1402       *(p++) = HIGH(base->first - segments);
1403       *(p++) = LOW(base->first - segments);
1404
1405       if (lower_bound)
1406       {
1407         *(p++) = HIGH(lower_bound->first - segments);
1408         *(p++) = LOW(lower_bound->first - segments);
1409       }
1410       if (upper_bound)
1411       {
1412         *(p++) = HIGH(upper_bound->first - segments);
1413         *(p++) = LOW(upper_bound->first - segments);
1414       }
1415
1416       p = TA_hints_recorder_handle_segments(p, axis, serif, wraps);
1417     }
1418     break;
1419
1420   case ta_serif_anchor:
1421   case ta_serif_link2:
1422     {
1423       TA_Edge edge = (TA_Edge)arg1;
1424
1425
1426       *(p++) = 0;
1427       *(p++) = (FT_Byte)action + ACTION_OFFSET
1428                + (lower_bound != NULL)
1429                + 2 * (upper_bound != NULL);
1430
1431       *(p++) = HIGH(edge->first - segments);
1432       *(p++) = LOW(edge->first - segments);
1433
1434       if (lower_bound)
1435       {
1436         *(p++) = HIGH(lower_bound->first - segments);
1437         *(p++) = LOW(lower_bound->first - segments);
1438       }
1439       if (upper_bound)
1440       {
1441         *(p++) = HIGH(upper_bound->first - segments);
1442         *(p++) = LOW(upper_bound->first - segments);
1443       }
1444
1445       p = TA_hints_recorder_handle_segments(p, axis, edge, wraps);
1446     }
1447     break;
1448
1449   case ta_serif_link1:
1450     {
1451       TA_Edge edge = (TA_Edge)arg1;
1452       TA_Edge before = arg2;
1453       TA_Edge after = arg3;
1454
1455
1456       *(p++) = 0;
1457       *(p++) = (FT_Byte)action + ACTION_OFFSET
1458                + (lower_bound != NULL)
1459                + 2 * (upper_bound != NULL);
1460
1461       *(p++) = HIGH(before->first - segments);
1462       *(p++) = LOW(before->first - segments);
1463       *(p++) = HIGH(edge->first - segments);
1464       *(p++) = LOW(edge->first - segments);
1465       *(p++) = HIGH(after->first - segments);
1466       *(p++) = LOW(after->first - segments);
1467
1468       if (lower_bound)
1469       {
1470         *(p++) = HIGH(lower_bound->first - segments);
1471         *(p++) = LOW(lower_bound->first - segments);
1472       }
1473       if (upper_bound)
1474       {
1475         *(p++) = HIGH(upper_bound->first - segments);
1476         *(p++) = LOW(upper_bound->first - segments);
1477       }
1478
1479       p = TA_hints_recorder_handle_segments(p, axis, edge, wraps);
1480     }
1481     break;
1482
1483   default:
1484     /* there are more cases in the enumeration */
1485     /* which are handled with flags */
1486     break;
1487   }
1488
1489   recorder->hints_record.num_actions++;
1490   recorder->hints_record.buf = p;
1491 }
1492
1493
1494 static FT_Error
1495 TA_init_recorder(Recorder* recorder,
1496                  FONT* font,
1497                  GLYPH* glyph,
1498                  TA_GlyphHints hints)
1499 {
1500   TA_AxisHints axis = &hints->axis[TA_DIMENSION_VERT];
1501   TA_Point points = hints->points;
1502   TA_Point point_limit = points + hints->num_points;
1503   TA_Point point;
1504
1505   TA_Segment segments = axis->segments;
1506   TA_Segment seg_limit = segments + axis->num_segments;
1507   TA_Segment seg;
1508
1509   FT_UShort num_strong_points = 0;
1510   FT_UShort* wrap_around_segment;
1511
1512   recorder->font = font;
1513   recorder->glyph = glyph;
1514   recorder->num_segments = axis->num_segments;
1515
1516   recorder->ip_before_points = NULL;
1517   recorder->ip_after_points = NULL;
1518   recorder->ip_on_point_array = NULL;
1519   recorder->ip_between_point_array = NULL;
1520
1521   recorder->num_stack_elements = 0;
1522
1523   /* no need to clean up allocated arrays in case of error; */
1524   /* this is handled later by `TA_free_recorder' */
1525
1526   recorder->num_wrap_around_segments = 0;
1527   for (seg = segments; seg < seg_limit; seg++)
1528     if (seg->first > seg->last)
1529       recorder->num_wrap_around_segments++;
1530
1531   recorder->wrap_around_segments =
1532     (FT_UShort*)malloc(recorder->num_wrap_around_segments
1533                        * sizeof (FT_UShort));
1534   if (!recorder->wrap_around_segments)
1535     return FT_Err_Out_Of_Memory;
1536
1537   wrap_around_segment = recorder->wrap_around_segments;
1538   for (seg = segments; seg < seg_limit; seg++)
1539     if (seg->first > seg->last)
1540       *(wrap_around_segment++) = seg - segments;
1541
1542   /* get number of strong points */
1543   for (point = points; point < point_limit; point++)
1544   {
1545     /* actually, we need to test `TA_FLAG_TOUCH_Y' also; */
1546     /* however, this value isn't known yet */
1547     /* (or rather, it can vary between different pixel sizes) */
1548     if (point->flags & TA_FLAG_WEAK_INTERPOLATION)
1549       continue;
1550
1551     num_strong_points++;
1552   }
1553
1554   recorder->num_strong_points = num_strong_points;
1555
1556   recorder->ip_before_points =
1557     (FT_UShort*)malloc(num_strong_points * sizeof (FT_UShort));
1558   if (!recorder->ip_before_points)
1559     return FT_Err_Out_Of_Memory;
1560
1561   recorder->ip_after_points =
1562     (FT_UShort*)malloc(num_strong_points * sizeof (FT_UShort));
1563   if (!recorder->ip_after_points)
1564     return FT_Err_Out_Of_Memory;
1565
1566   /* actually, we need `hints->num_edges' for the array sizes; */
1567   /* however, this value isn't known yet */
1568   /* (or rather, it can vary between different pixel sizes) */
1569   recorder->ip_on_point_array =
1570     (FT_UShort*)malloc(axis->num_segments
1571                        * num_strong_points * sizeof (FT_UShort));
1572   if (!recorder->ip_on_point_array)
1573     return FT_Err_Out_Of_Memory;
1574
1575   recorder->ip_between_point_array =
1576     (FT_UShort*)malloc(axis->num_segments * axis->num_segments
1577                        * num_strong_points * sizeof (FT_UShort));
1578   if (!recorder->ip_between_point_array)
1579     return FT_Err_Out_Of_Memory;
1580
1581   return FT_Err_Ok;
1582 }
1583
1584
1585 static void
1586 TA_reset_recorder(Recorder* recorder,
1587                   FT_Byte* bufp)
1588 {
1589   recorder->hints_record.buf = bufp;
1590   recorder->hints_record.num_actions = 0;
1591 }
1592
1593
1594 static void
1595 TA_rewind_recorder(Recorder* recorder,
1596                    FT_Byte* bufp,
1597                    FT_UInt size)
1598 {
1599   TA_reset_recorder(recorder, bufp);
1600
1601   recorder->hints_record.size = size;
1602
1603   /* We later check with MISSING (which expands to 0xFF bytes) */
1604
1605   memset(recorder->ip_before_points, 0xFF,
1606          recorder->num_strong_points * sizeof (FT_UShort));
1607   memset(recorder->ip_after_points, 0xFF,
1608          recorder->num_strong_points * sizeof (FT_UShort));
1609
1610   memset(recorder->ip_on_point_array, 0xFF,
1611          recorder->num_segments
1612          * recorder->num_strong_points * sizeof (FT_UShort));
1613   memset(recorder->ip_between_point_array, 0xFF,
1614          recorder->num_segments * recorder->num_segments
1615          * recorder->num_strong_points * sizeof (FT_UShort));
1616 }
1617
1618
1619 static void
1620 TA_free_recorder(Recorder* recorder)
1621 {
1622   free(recorder->wrap_around_segments);
1623
1624   free(recorder->ip_before_points);
1625   free(recorder->ip_after_points);
1626   free(recorder->ip_on_point_array);
1627   free(recorder->ip_between_point_array);
1628 }
1629
1630
1631 FT_Error
1632 TA_sfnt_build_glyph_instructions(SFNT* sfnt,
1633                                  FONT* font,
1634                                  FT_Long idx)
1635 {
1636   FT_Face face = sfnt->face;
1637   FT_Error error;
1638
1639   FT_Byte* ins_buf;
1640   FT_UInt ins_len;
1641   FT_Byte* bufp;
1642   FT_Byte* p;
1643
1644   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
1645   glyf_Data* data = (glyf_Data*)glyf_table->data;
1646   /* `idx' is never negative */
1647   GLYPH* glyph = &data->glyphs[idx];
1648
1649   TA_GlyphHints hints;
1650
1651   FT_UInt num_action_hints_records = 0;
1652   FT_UInt num_point_hints_records = 0;
1653   Hints_Record* action_hints_records = NULL;
1654   Hints_Record* point_hints_records = NULL;
1655
1656   Recorder recorder;
1657   FT_UShort num_stack_elements;
1658   FT_Bool optimize = 0;
1659
1660   FT_Int32 load_flags;
1661   FT_UInt size;
1662
1663   FT_Byte* pos[3];
1664
1665 #ifdef TA_DEBUG
1666   int _ta_debug_save;
1667 #endif
1668
1669
1670   /* XXX: right now, we abuse this flag to control */
1671   /*      the global behaviour of the auto-hinter */
1672   load_flags = 1 << 29; /* vertical hinting only */
1673   if (!font->pre_hinting)
1674   {
1675     if (font->hint_composites)
1676       load_flags |= FT_LOAD_NO_SCALE;
1677     else
1678       load_flags |= FT_LOAD_NO_RECURSE;
1679   }
1680
1681   /* computing the segments is resolution independent, */
1682   /* thus the pixel size in this call is arbitrary */
1683   error = FT_Set_Pixel_Sizes(face, 20, 20);
1684   if (error)
1685     return error;
1686
1687 #ifdef TA_DEBUG
1688   /* temporarily disable debugging output */
1689   /* to avoid getting the information twice */
1690   _ta_debug_save = _ta_debug;
1691   _ta_debug = 0;
1692 #endif
1693
1694   ta_loader_register_hints_recorder(font->loader, NULL, NULL);
1695   error = ta_loader_load_glyph(font, face, (FT_UInt)idx, load_flags);
1696
1697 #ifdef TA_DEBUG
1698   _ta_debug = _ta_debug_save;
1699 #endif
1700
1701   if (error)
1702     return error;
1703
1704   /* do nothing if we have an empty glyph */
1705   if (!face->glyph->outline.n_contours)
1706     return FT_Err_Ok;
1707
1708   hints = &font->loader->hints;
1709
1710   /* do nothing if the setup delivered the `dflt' script only */
1711   if (!hints->num_points)
1712     return FT_Err_Ok;
1713
1714   /* we allocate a buffer which is certainly large enough */
1715   /* to hold all of the created bytecode instructions; */
1716   /* later on it gets reallocated to its real size */
1717   ins_len = hints->num_points * 1000;
1718   ins_buf = (FT_Byte*)malloc(ins_len);
1719   if (!ins_buf)
1720     return FT_Err_Out_Of_Memory;
1721
1722   /* initialize array with an invalid bytecode */
1723   /* so that we can easily find the array length at reallocation time */
1724   memset(ins_buf, INS_A0, ins_len);
1725
1726   /* handle composite glyph */
1727   if (font->loader->gloader->base.num_subglyphs)
1728   {
1729     bufp = TA_font_build_subglyph_shifter(font, ins_buf);
1730     if (!bufp)
1731     {
1732       error = FT_Err_Out_Of_Memory;
1733       goto Err;
1734     }
1735
1736     goto Done1;
1737   }
1738
1739   /* only scale the glyph if the `dflt' script has been used */
1740   if (font->loader->metrics->script_class == &ta_dflt_script_class)
1741   {
1742     /* since `TA_init_recorder' hasn't been called yet, */
1743     /* we manually initialize the `font' and `glyph' fields */
1744     recorder.font = font;
1745     recorder.glyph = glyph;
1746
1747     bufp = TA_sfnt_build_glyph_scaler(sfnt, &recorder, ins_buf);
1748     if (!bufp)
1749     {
1750       error = FT_Err_Out_Of_Memory;
1751       goto Err;
1752     }
1753
1754     goto Done1;
1755   }
1756
1757   error = TA_init_recorder(&recorder, font, glyph, hints);
1758   if (error)
1759     goto Err;
1760
1761   /* loop over a large range of pixel sizes */
1762   /* to find hints records which get pushed onto the bytecode stack */
1763
1764 #ifdef DEBUGGING
1765   if (font->debug)
1766   {
1767     int num_chars, i;
1768     char buf[256];
1769
1770
1771     (void)FT_Get_Glyph_Name(face, idx, buf, 256);
1772
1773     num_chars = fprintf(stderr, "glyph %ld", idx);
1774     if (*buf)
1775       num_chars += fprintf(stderr, " (%s)", buf);
1776     fprintf(stderr, "\n");
1777     for (i = 0; i < num_chars; i++)
1778       putc('=', stderr);
1779     fprintf(stderr, "\n\n");
1780
1781   }
1782 #endif
1783
1784   /* we temporarily use `ins_buf' to record the current glyph hints */
1785   ta_loader_register_hints_recorder(font->loader,
1786                                     TA_hints_recorder,
1787                                     (void*)&recorder);
1788
1789   for (size = font->hinting_range_min;
1790        size <= font->hinting_range_max;
1791        size++)
1792   {
1793 #ifdef DEBUGGING
1794     int have_dumps = 0;
1795 #endif
1796
1797
1798     TA_rewind_recorder(&recorder, ins_buf, size);
1799
1800     error = FT_Set_Pixel_Sizes(face, size, size);
1801     if (error)
1802       goto Err;
1803
1804 #ifdef DEBUGGING
1805     if (font->debug)
1806     {
1807       int num_chars, i;
1808
1809
1810       num_chars = fprintf(stderr, "size %d\n", size);
1811       for (i = 0; i < num_chars - 1; i++)
1812         putc('-', stderr);
1813       fprintf(stderr, "\n\n");
1814     }
1815 #endif
1816
1817     /* calling `ta_loader_load_glyph' uses the */
1818     /* `TA_hints_recorder' function as a callback, */
1819     /* modifying `hints_record' */
1820     error = ta_loader_load_glyph(font, face, idx, load_flags);
1821     if (error)
1822       goto Err;
1823
1824     if (TA_hints_record_is_different(action_hints_records,
1825                                      num_action_hints_records,
1826                                      ins_buf, recorder.hints_record.buf))
1827     {
1828 #ifdef DEBUGGING
1829       if (font->debug)
1830       {
1831         have_dumps = 1;
1832
1833         ta_glyph_hints_dump_edges(_ta_debug_hints);
1834         ta_glyph_hints_dump_segments(_ta_debug_hints);
1835         ta_glyph_hints_dump_points(_ta_debug_hints);
1836
1837         fprintf(stderr, "action hints record:\n");
1838         if (ins_buf == recorder.hints_record.buf)
1839           fprintf(stderr, "  (none)");
1840         else
1841         {
1842           fprintf(stderr, "  ");
1843           for (p = ins_buf; p < recorder.hints_record.buf; p += 2)
1844             fprintf(stderr, " %2d", *p * 256 + *(p + 1));
1845         }
1846         fprintf(stderr, "\n");
1847       }
1848 #endif
1849
1850       error = TA_add_hints_record(&action_hints_records,
1851                                   &num_action_hints_records,
1852                                   ins_buf, recorder.hints_record);
1853       if (error)
1854         goto Err;
1855     }
1856
1857     /* now handle point records */
1858
1859     TA_reset_recorder(&recorder, ins_buf);
1860
1861     /* use the point hints data collected in `TA_hints_recorder' */
1862     TA_build_point_hints(&recorder, hints);
1863
1864     if (TA_hints_record_is_different(point_hints_records,
1865                                      num_point_hints_records,
1866                                      ins_buf, recorder.hints_record.buf))
1867     {
1868 #ifdef DEBUGGING
1869       if (font->debug)
1870       {
1871         if (!have_dumps)
1872         {
1873           int num_chars, i;
1874
1875
1876           num_chars = fprintf(stderr, "size %d\n", size);
1877           for (i = 0; i < num_chars - 1; i++)
1878             putc('-', stderr);
1879           fprintf(stderr, "\n\n");
1880
1881           ta_glyph_hints_dump_edges(_ta_debug_hints);
1882           ta_glyph_hints_dump_segments(_ta_debug_hints);
1883           ta_glyph_hints_dump_points(_ta_debug_hints);
1884         }
1885
1886         fprintf(stderr, "point hints record:\n");
1887         if (ins_buf == recorder.hints_record.buf)
1888           fprintf(stderr, "  (none)");
1889         else
1890         {
1891           fprintf(stderr, "  ");
1892           for (p = ins_buf; p < recorder.hints_record.buf; p += 2)
1893             fprintf(stderr, " %2d", *p * 256 + *(p + 1));
1894         }
1895         fprintf(stderr, "\n\n");
1896       }
1897 #endif
1898
1899       error = TA_add_hints_record(&point_hints_records,
1900                                   &num_point_hints_records,
1901                                   ins_buf, recorder.hints_record);
1902       if (error)
1903         goto Err;
1904     }
1905   }
1906
1907   if (num_action_hints_records == 1 && !action_hints_records[0].num_actions)
1908   {
1909     /* since we only have a single empty record we just scale the glyph */
1910     bufp = TA_sfnt_build_glyph_scaler(sfnt, &recorder, ins_buf);
1911     if (!bufp)
1912     {
1913       error = FT_Err_Out_Of_Memory;
1914       goto Err;
1915     }
1916
1917     /* clear the rest of the temporarily used part of `ins_buf' */
1918     p = bufp;
1919     while (*p != INS_A0)
1920       *(p++) = INS_A0;
1921
1922     goto Done;
1923   }
1924
1925   /* if there is only a single record, */
1926   /* we do a global optimization later on */
1927   if (num_action_hints_records > 1)
1928     optimize = 1;
1929
1930   /* store the hints records and handle stack depth */
1931   pos[0] = ins_buf;
1932   bufp = TA_emit_hints_records(&recorder,
1933                                point_hints_records,
1934                                num_point_hints_records,
1935                                ins_buf,
1936                                optimize);
1937
1938   num_stack_elements = recorder.num_stack_elements;
1939   recorder.num_stack_elements = 0;
1940
1941   pos[1] = bufp;
1942   bufp = TA_emit_hints_records(&recorder,
1943                                action_hints_records,
1944                                num_action_hints_records,
1945                                bufp,
1946                                optimize);
1947
1948   recorder.num_stack_elements += num_stack_elements;
1949
1950   pos[2] = bufp;
1951   bufp = TA_sfnt_build_glyph_segments(sfnt, &recorder, bufp, optimize);
1952   if (!bufp)
1953   {
1954     error = FT_Err_Out_Of_Memory;
1955     goto Err;
1956   }
1957
1958   /* XXX improve handling of NPUSHW */
1959   if (num_action_hints_records == 1
1960       && *(pos[0]) != NPUSHW && *(pos[1]) != NPUSHW && *(pos[2]) != NPUSHW)
1961   {
1962     /*
1963      * we optimize two common cases, replacing
1964      *
1965      *   NPUSHB A ... NPUSHB B [... NPUSHB C] ... CALL
1966      *
1967      * with
1968      *
1969      *   NPUSHB (A+B[+C]) ... CALL
1970      *
1971      * if possible
1972      */
1973     FT_Byte sizes[3];
1974     FT_Byte new_size1;
1975     FT_Byte new_size2;
1976
1977     FT_UInt sum;
1978     FT_UInt i;
1979     FT_UInt pos_idx;
1980
1981
1982     /* the point hints records block can be missing */
1983     if (pos[0] == pos[1])
1984     {
1985       pos[1] = pos[2];
1986       pos[2] = NULL;
1987     }
1988
1989     /* there are at least two NPUSHB instructions */
1990     /* (one of them directly at the start) */
1991     sizes[0] = *(pos[0] + 1);
1992     sizes[1] = *(pos[1] + 1);
1993     sizes[2] = pos[2] ? *(pos[2] + 1) : 0;
1994
1995     sum = sizes[0] + sizes[1] + sizes[2];
1996
1997     if (sum > 2 * 0xFF)
1998       goto Done2; /* nothing to do since we need three NPUSHB */
1999     else if (!sizes[2] && (sum > 0xFF))
2000       goto Done2; /* nothing to do since we need two NPUSHB */
2001
2002     if (sum > 0xFF)
2003     {
2004       /* reduce three NPUSHB to two */
2005       new_size1 = 0xFF;
2006       new_size2 = sum - 0xFF;
2007     }
2008     else
2009     {
2010       /* reduce two or three NPUSHB to one */
2011       new_size1 = sum;
2012       new_size2 = 0;
2013     }
2014
2015     /* pack data */
2016     p = ins_buf;
2017     bufp = ins_buf;
2018     pos_idx = 0;
2019
2020     if (new_size1 <= 8)
2021       BCI(PUSHB_1 - 1 + new_size1);
2022     else
2023     {
2024       BCI(NPUSHB);
2025       BCI(new_size1);
2026     }
2027     for (i = 0; i < new_size1; i++)
2028     {
2029       if (p == pos[pos_idx])
2030       {
2031         pos_idx++;
2032         p += 2; /* skip old NPUSHB */
2033       }
2034       *(bufp++) = *(p++);
2035     }
2036
2037     if (new_size2)
2038     {
2039       if (new_size2 <= 8)
2040         BCI(PUSHB_1 - 1 + new_size2);
2041       else
2042       {
2043         BCI(NPUSHB);
2044         BCI(new_size2);
2045       }
2046       for (i = 0; i < new_size2; i++)
2047       {
2048         if (p == pos[pos_idx])
2049         {
2050           pos_idx++;
2051           p += 2;
2052         }
2053         *(bufp++) = *(p++);
2054       }
2055     }
2056
2057     BCI(CALL);
2058   }
2059
2060 Done2:
2061   /* clear the rest of the temporarily used part of `ins_buf' */
2062   p = bufp;
2063   while (*p != INS_A0)
2064     *(p++) = INS_A0;
2065
2066 Done:
2067   TA_free_hints_records(action_hints_records, num_action_hints_records);
2068   TA_free_hints_records(point_hints_records, num_point_hints_records);
2069   TA_free_recorder(&recorder);
2070
2071   /* we are done, so reallocate the instruction array to its real size */
2072   if (*bufp == INS_A0)
2073   {
2074     /* search backwards */
2075     while (*bufp == INS_A0)
2076       bufp--;
2077     bufp++;
2078   }
2079   else
2080   {
2081     /* search forwards */
2082     while (*bufp != INS_A0)
2083       bufp++;
2084   }
2085
2086 Done1:
2087   ins_len = bufp - ins_buf;
2088
2089   if (ins_len > sfnt->max_instructions)
2090     sfnt->max_instructions = ins_len;
2091
2092   glyph->ins_buf = (FT_Byte*)realloc(ins_buf, ins_len);
2093   glyph->ins_len = ins_len;
2094
2095   return FT_Err_Ok;
2096
2097 Err:
2098   TA_free_hints_records(action_hints_records, num_action_hints_records);
2099   TA_free_hints_records(point_hints_records, num_point_hints_records);
2100   TA_free_recorder(&recorder);
2101   free(ins_buf);
2102
2103   return error;
2104 }
2105
2106
2107 /* end of tabytecode.c */