lib/tabytecode.c

   1 /* tabytecode.c */
   2
   3 /*
   4  * Copyright (C) 2011-2015 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
  18 #include <stdbool.h> /* for llrb.h */
  19
  20 #include "llrb.h" /* a red-black tree implementation */
  21 #include "tahints.h"
  22
  23
  24 #define DEBUGGING
  25
  26
  27 #ifdef TA_DEBUG
  28 int _ta_debug = 0;
  29 int _ta_debug_global = 0;
  30 int _ta_debug_disable_horz_hints;
  31 int _ta_debug_disable_vert_hints;
  32 int _ta_debug_disable_blue_hints;
  33 void* _ta_debug_hints;
  34 #endif
  35
  36
  37 /* node structures for point hints */
  38
  39 typedef struct Node1 Node1;
  40 struct Node1
  41 {
  42   LLRB_ENTRY(Node1) entry1;
  43   FT_UShort point;
  44 };
  45
  46 typedef struct Node2 Node2;
  47 struct Node2
  48 {
  49   LLRB_ENTRY(Node2) entry2;
  50   FT_UShort edge;
  51   FT_UShort point;
  52 };
  53
  54 typedef struct Node3 Node3;
  55 struct Node3
  56 {
  57   LLRB_ENTRY(Node3) entry3;
  58   FT_UShort before_edge;
  59   FT_UShort after_edge;
  60   FT_UShort point;
  61 };
  62
  63
  64 /* comparison functions for our red-black trees */
  65
  66 static int
  67 node1cmp(Node1* e1,
  68          Node1* e2)
  69 {
  70   /* sort by points */
  71   return e1->point - e2->point;
  72 }
  73
  74 static int
  75 node2cmp(Node2* e1,
  76          Node2* e2)
  77 {
  78   FT_Int delta;
  79
  80
  81   /* sort by edges ... */
  82   delta = (FT_Int)e1->edge - (FT_Int)e2->edge;
  83   if (delta)
  84     return delta;
  85
  86   /* ... then by points */
  87   return (FT_Int)e1->point - (FT_Int)e2->point;
  88 }
  89
  90 static int
  91 node3cmp(Node3* e1,
  92          Node3* e2)
  93 {
  94   FT_Int delta;
  95
  96
  97   /* sort by `before' edges ... */
  98   delta = (FT_Int)e1->before_edge - (FT_Int)e2->before_edge;
  99   if (delta)
 100     return delta;
 101
 102   /* ... then by `after' edges ... */
 103   delta = (FT_Int)e1->after_edge - (FT_Int)e2->after_edge;
 104   if (delta)
 105     return delta;
 106
 107   /* ... then by points */
 108   return (FT_Int)e1->point - (FT_Int)e2->point;
 109 }
 110
 111
 112 /* the red-black tree function bodies */
 113 typedef struct ip_before_points ip_before_points;
 114 typedef struct ip_after_points ip_after_points;
 115 typedef struct ip_on_points ip_on_points;
 116 typedef struct ip_between_points ip_between_points;
 117
 118 LLRB_HEAD(ip_before_points, Node1);
 119 LLRB_HEAD(ip_after_points, Node1);
 120 LLRB_HEAD(ip_on_points, Node2);
 121 LLRB_HEAD(ip_between_points, Node3);
 122
 123 /* no trailing semicolon in the next four lines */
 124 LLRB_GENERATE_STATIC(ip_before_points, Node1, entry1, node1cmp)
 125 LLRB_GENERATE_STATIC(ip_after_points, Node1, entry1, node1cmp)
 126 LLRB_GENERATE_STATIC(ip_on_points, Node2, entry2, node2cmp)
 127 LLRB_GENERATE_STATIC(ip_between_points, Node3, entry3, node3cmp)
 128
 129
 130 typedef struct Hints_Record_
 131 {
 132   FT_UInt size;
 133   FT_UInt num_actions;
 134   FT_Byte* buf;
 135   FT_UInt buf_len;
 136 } Hints_Record;
 137
 138 typedef struct Recorder_
 139 {
 140   SFNT* sfnt;
 141   FONT* font;
 142   GLYPH* glyph; /* the current glyph */
 143   Hints_Record hints_record;
 144
 145   /* some segments can `wrap around' */
 146   /* a contour's start point like 24-25-26-0-1-2 */
 147   /* (there can be at most one such segment per contour); */
 148   /* later on we append additional records */
 149   /* to split them into 24-26 and 0-2 */
 150   FT_UShort* wrap_around_segments;
 151   FT_UShort num_wrap_around_segments;
 152
 153   FT_UShort num_stack_elements; /* the necessary stack depth so far */
 154
 155   /* data necessary for strong point interpolation */
 156   ip_before_points ip_before_points_head;
 157   ip_after_points ip_after_points_head;
 158   ip_on_points ip_on_points_head;
 159   ip_between_points ip_between_points_head;
 160
 161   FT_UShort num_strong_points;
 162   FT_UShort num_segments;
 163 } Recorder;
 164
 165
 166 /* this is the bytecode of the `.ttfautohint' glyph */
 167
 168 FT_Byte ttfautohint_glyph_bytecode[7] =
 169 {
 170
 171   /* increment `cvtl_is_subglyph' counter */
 172   PUSHB_3,
 173     cvtl_is_subglyph,
 174     100,
 175     cvtl_is_subglyph,
 176   RCVT,
 177   ADD,
 178   WCVTP,
 179
 180 };
 181
 182
 183 /* if we have y delta exceptions before IUP_y, this code gets inserted */
 184
 185 FT_Byte ins_extra_buf[4] =
 186 {
 187
 188   /* tell bci_{scale,scale_composite,hint}_glyph to not call IUP_y */
 189   PUSHB_2,
 190     cvtl_do_iup_y,
 191     0,
 192   WCVTP,
 193
 194 };
 195
 196
 197 /*
 198  * convert array `args' into a sequence of NPUSHB, NPUSHW, PUSHB_X, and
 199  * PUSHW_X instructions to be stored in `bufp' (the latter two instructions
 200  * only if `optimize' is not set); if `need_words' is set, NPUSHW and
 201  * PUSHW_X gets used
 202  */
 203
 204 FT_Byte*
 205 TA_build_push(FT_Byte* bufp,
 206               FT_UInt* args,
 207               FT_UInt num_args,
 208               FT_Bool need_words,
 209               FT_Bool optimize)
 210 {
 211   FT_UInt* arg = args;
 212   FT_UInt i, j, nargs;
 213
 214
 215   if (need_words)
 216   {
 217     for (i = 0; i < num_args; i += 255)
 218     {
 219       nargs = (num_args - i > 255) ? 255 : num_args - i;
 220
 221       if (optimize && nargs <= 8)
 222         BCI(PUSHW_1 - 1 + nargs);
 223       else
 224       {
 225         BCI(NPUSHW);
 226         BCI(nargs);
 227       }
 228       for (j = 0; j < nargs; j++)
 229       {
 230         BCI(HIGH(*arg));
 231         BCI(LOW(*arg));
 232         arg++;
 233       }
 234     }
 235   }
 236   else
 237   {
 238     for (i = 0; i < num_args; i += 255)
 239     {
 240       nargs = (num_args - i > 255) ? 255 : num_args - i;
 241
 242       if (optimize && nargs <= 8)
 243         BCI(PUSHB_1 - 1 + nargs);
 244       else
 245       {
 246         BCI(NPUSHB);
 247         BCI(nargs);
 248       }
 249       for (j = 0; j < nargs; j++)
 250       {
 251         BCI(*arg);
 252         arg++;
 253       }
 254     }
 255   }
 256
 257   return bufp;
 258 }
 259
 260
 261 /*
 262  * We optimize two common cases, replacing
 263  *
 264  *   NPUSHB A ... NPUSHB B [... NPUSHB C] ... CALL
 265  *
 266  * with
 267  *
 268  *   NPUSHB (A+B[+C]) ... CALL
 269  *
 270  * if possible
 271  */
 272
 273 FT_Byte*
 274 TA_optimize_push(FT_Byte* buf,
 275                  FT_Byte** pos)
 276 {
 277   FT_Byte sizes[3];
 278   FT_Byte new_size1;
 279   FT_Byte new_size2;
 280
 281   FT_UInt sum;
 282   FT_UInt i;
 283   FT_UInt pos_idx;
 284
 285   FT_Byte* p;
 286   FT_Byte* bufp;
 287
 288
 289   /* XXX improve handling of NPUSHW */
 290   if (*(pos[0]) == NPUSHW
 291       || *(pos[1]) == NPUSHW
 292       || *(pos[2]) == NPUSHW)
 293     return buf;
 294
 295   /* the point hints records block can be missing */
 296   if (pos[0] == pos[1])
 297   {
 298     pos[1] = pos[2];
 299     pos[2] = NULL;
 300   }
 301
 302   /* there are at least two NPUSHB instructions */
 303   /* (one of them directly at the start) */
 304   sizes[0] = *(pos[0] + 1);
 305   sizes[1] = *(pos[1] + 1);
 306   sizes[2] = pos[2] ? *(pos[2] + 1) : 0;
 307
 308   sum = sizes[0] + sizes[1] + sizes[2];
 309
 310   if (sum > 2 * 0xFF)
 311     return buf; /* nothing to do since we need three NPUSHB */
 312   else if (!sizes[2] && (sum > 0xFF))
 313     return buf; /* nothing to do since we need two NPUSHB */
 314
 315   if (sum > 0xFF)
 316   {
 317     /* reduce three NPUSHB to two */
 318     new_size1 = 0xFF;
 319     new_size2 = sum - 0xFF;
 320   }
 321   else
 322   {
 323     /* reduce two or three NPUSHB to one */
 324     new_size1 = sum;
 325     new_size2 = 0;
 326   }
 327
 328   /* pack data */
 329   p = buf;
 330   bufp = buf;
 331   pos_idx = 0;
 332
 333   if (new_size1 <= 8)
 334     BCI(PUSHB_1 - 1 + new_size1);
 335   else
 336   {
 337     BCI(NPUSHB);
 338     BCI(new_size1);
 339   }
 340   for (i = 0; i < new_size1; i++)
 341   {
 342     if (p == pos[pos_idx])
 343     {
 344       pos_idx++;
 345       p += 2; /* skip old NPUSHB */
 346     }
 347     *(bufp++) = *(p++);
 348   }
 349
 350   if (new_size2)
 351   {
 352     if (new_size2 <= 8)
 353       BCI(PUSHB_1 - 1 + new_size2);
 354     else
 355     {
 356       BCI(NPUSHB);
 357       BCI(new_size2);
 358     }
 359     for (i = 0; i < new_size2; i++)
 360     {
 361       if (p == pos[pos_idx])
 362       {
 363         pos_idx++;
 364         p += 2;
 365       }
 366       *(bufp++) = *(p++);
 367     }
 368   }
 369
 370   BCI(CALL);
 371
 372   return bufp;
 373 }
 374
 375
 376 /* We add a subglyph for each composite glyph. */
 377 /* Since subglyphs must contain at least one point, */
 378 /* we have to adjust all point indices accordingly. */
 379 /* Using the `pointsums' array of the `GLYPH' structure */
 380 /* it is straightforward to do that: */
 381 /* Assuming that point with index x is in the interval */
 382 /* pointsums[n] <= x < pointsums[n + 1], */
 383 /* the new point index is x + n. */
 384
 385 static FT_UInt
 386 TA_adjust_point_index(Recorder* recorder,
 387                       FT_UInt idx)
 388 {
 389   FONT* font = recorder->font;
 390   GLYPH* glyph = recorder->glyph;
 391   FT_UShort i;
 392
 393
 394   if (!glyph->num_components || !font->hint_composites)
 395     return idx; /* not a composite glyph */
 396
 397   for (i = 0; i < glyph->num_pointsums; i++)
 398     if (idx < glyph->pointsums[i])
 399       break;
 400
 401   return idx + i;
 402 }
 403
 404
 405 /* we store the segments in the storage area; */
 406 /* each segment record consists of the first and last point */
 407
 408 static FT_Byte*
 409 TA_sfnt_build_glyph_segments(SFNT* sfnt,
 410                              Recorder* recorder,
 411                              FT_Byte* bufp,
 412                              FT_Bool optimize)
 413 {
 414   FONT* font = recorder->font;
 415   TA_GlyphHints hints = &font->loader->hints;
 416   TA_AxisHints axis = &hints->axis[TA_DIMENSION_VERT];
 417   TA_Point points = hints->points;
 418   TA_Segment segments = axis->segments;
 419   TA_Segment seg;
 420   TA_Segment seg_limit;
 421
 422   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
 423   glyf_Data* data = (glyf_Data*)glyf_table->data;
 424
 425   FT_UInt style_id = data->style_ids
 426                        [font->loader->metrics->style_class->style];
 427
 428   FT_Outline outline = font->loader->gloader->base.outline;
 429
 430   FT_UInt* args;
 431   FT_UInt* arg;
 432   FT_UInt num_args;
 433   FT_UShort num_segments;
 434
 435   FT_Bool need_words = 0;
 436
 437   FT_Int n;
 438   FT_UInt base;
 439   FT_UShort num_packed_segments;
 440   FT_UShort num_storage;
 441   FT_UShort num_stack_elements;
 442   FT_UShort num_twilight_points;
 443
 444
 445   seg_limit = segments + axis->num_segments;
 446   num_segments = axis->num_segments;
 447
 448   /* to pack the data in the bytecode more tightly, */
 449   /* we store up to the first nine segments in nibbles if possible, */
 450   /* using delta values */
 451   base = 0;
 452   num_packed_segments = 0;
 453   for (seg = segments; seg < seg_limit; seg++)
 454   {
 455     FT_UInt first = seg->first - points;
 456     FT_UInt last = seg->last - points;
 457
 458
 459     first = TA_adjust_point_index(recorder, first);
 460     last = TA_adjust_point_index(recorder, last);
 461
 462     if (first - base >= 16)
 463       break;
 464     if (first > last || last - first >= 16)
 465       break;
 466     if (num_packed_segments == 9)
 467       break;
 468     num_packed_segments++;
 469     base = last;
 470   }
 471
 472   /* also handle wrap-around segments */
 473   num_segments += recorder->num_wrap_around_segments;
 474
 475   /* wrap-around segments are pushed with four arguments; */
 476   /* a segment stored in nibbles needs only one byte instead of two */
 477   num_args = num_packed_segments
 478              + 2 * (num_segments - num_packed_segments)
 479              + 2 * recorder->num_wrap_around_segments
 480              + 3;
 481
 482   /* collect all arguments temporarily in an array (in reverse order) */
 483   /* so that we can easily split into chunks of 255 args */
 484   /* as needed by NPUSHB and NPUSHW, respectively */
 485   args = (FT_UInt*)malloc(num_args * sizeof (FT_UInt));
 486   if (!args)
 487     return NULL;
 488
 489   arg = args + num_args - 1;
 490
 491   if (num_segments > 0xFF)
 492     need_words = 1;
 493
 494   /* the number of packed segments is indicated by the function number */
 495   if (recorder->glyph->num_components && font->hint_composites)
 496     *(arg--) = bci_create_segments_composite_0 + num_packed_segments;
 497   else
 498     *(arg--) = bci_create_segments_0 + num_packed_segments;
 499
 500   *(arg--) = CVT_SCALING_VALUE_OFFSET(style_id);
 501   *(arg--) = num_segments;
 502
 503   base = 0;
 504   for (seg = segments; seg < segments + num_packed_segments; seg++)
 505   {
 506     FT_UInt first = seg->first - points;
 507     FT_UInt last = seg->last - points;
 508     FT_UInt low_nibble;
 509     FT_UInt high_nibble;
 510
 511
 512     first = TA_adjust_point_index(recorder, first);
 513     last = TA_adjust_point_index(recorder, last);
 514
 515     low_nibble = first - base;
 516     high_nibble = last - first;
 517
 518     *(arg--) = 16 * high_nibble + low_nibble;
 519
 520     base = last;
 521   }
 522
 523   for (seg = segments + num_packed_segments; seg < seg_limit; seg++)
 524   {
 525     FT_UInt first = seg->first - points;
 526     FT_UInt last = seg->last - points;
 527
 528
 529     *(arg--) = TA_adjust_point_index(recorder, first);
 530     *(arg--) = TA_adjust_point_index(recorder, last);
 531
 532     /* we push the last and first contour point */
 533     /* as a third and fourth argument in wrap-around segments */
 534     if (first > last)
 535     {
 536       for (n = 0; n < outline.n_contours; n++)
 537       {
 538         FT_UInt end = (FT_UInt)outline.contours[n];
 539
 540
 541         if (first <= end)
 542         {
 543           *(arg--) = TA_adjust_point_index(recorder, end);
 544           if (end > 0xFF)
 545             need_words = 1;
 546
 547           if (n == 0)
 548             *(arg--) = TA_adjust_point_index(recorder, 0);
 549           else
 550             *(arg--) = TA_adjust_point_index(recorder,
 551                          (FT_UInt)outline.contours[n - 1] + 1);
 552           break;
 553         }
 554       }
 555     }
 556
 557     if (last > 0xFF)
 558       need_words = 1;
 559   }
 560
 561   /* emit the second part of wrap-around segments as separate segments */
 562   /* so that edges can easily link to them */
 563   for (seg = segments; seg < seg_limit; seg++)
 564   {
 565     FT_UInt first = seg->first - points;
 566     FT_UInt last = seg->last - points;
 567
 568
 569     if (first > last)
 570     {
 571       for (n = 0; n < outline.n_contours; n++)
 572       {
 573         if (first <= (FT_UInt)outline.contours[n])
 574         {
 575           if (n == 0)
 576             *(arg--) = TA_adjust_point_index(recorder, 0);
 577           else
 578             *(arg--) = TA_adjust_point_index(recorder,
 579                          (FT_UInt)outline.contours[n - 1] + 1);
 580           break;
 581         }
 582       }
 583
 584       *(arg--) = TA_adjust_point_index(recorder, last);
 585     }
 586   }
 587
 588   /* with most fonts it is very rare */
 589   /* that any of the pushed arguments is larger than 0xFF, */
 590   /* thus we refrain from further optimizing this case */
 591   bufp = TA_build_push(bufp, args, num_args, need_words, optimize);
 592
 593   BCI(CALL);
 594
 595   num_storage = sal_segment_offset + num_segments * 2;
 596   if (num_storage > sfnt->max_storage)
 597     sfnt->max_storage = num_storage;
 598
 599   num_twilight_points = num_segments * 2;
 600   if (num_twilight_points > sfnt->max_twilight_points)
 601     sfnt->max_twilight_points = num_twilight_points;
 602
 603   /* both this function and `TA_emit_hints_record' */
 604   /* push data onto the stack */
 605   num_stack_elements = ADDITIONAL_STACK_ELEMENTS
 606                        + recorder->num_stack_elements + num_args;
 607   if (num_stack_elements > sfnt->max_stack_elements)
 608     sfnt->max_stack_elements = num_stack_elements;
 609
 610   free(args);
 611
 612   return bufp;
 613 }
 614
 615
 616 static void
 617 build_delta_exception(const Ctrl* ctrl,
 618                       FT_UInt** delta_args,
 619                       int* num_delta_args)
 620 {
 621   int offset;
 622   int ppem;
 623   int x_shift;
 624   int y_shift;
 625
 626
 627   ppem = ctrl->ppem - CONTROL_DELTA_PPEM_MIN;
 628
 629   if (ppem < 16)
 630     offset = 0;
 631   else if (ppem < 32)
 632     offset = 1;
 633   else
 634     offset = 2;
 635
 636   ppem -= offset << 4;
 637
 638   /*
 639    * Using
 640    *
 641    *   delta_shift = 3   ,
 642    *
 643    * the possible shift values in the instructions are indexed as follows:
 644    *
 645    *    0   -1px
 646    *    1   -7/8px
 647    *   ...
 648    *    7   -1/8px
 649    *    8    1/8px
 650    *   ...
 651    *   14    7/8px
 652    *   15    1px
 653    *
 654    * (note that there is no index for a zero shift).
 655    */
 656
 657   if (ctrl->x_shift < 0)
 658     x_shift = ctrl->x_shift + 8;
 659   else
 660     x_shift = ctrl->x_shift + 7;
 661
 662   if (ctrl->y_shift < 0)
 663     y_shift = ctrl->y_shift + 8;
 664   else
 665     y_shift = ctrl->y_shift + 7;
 666
 667   /* add point index and exception specification to appropriate stack */
 668   if (ctrl->x_shift)
 669   {
 670     *(delta_args[offset] + num_delta_args[offset]++) =
 671       (ppem << 4) + x_shift;
 672     *(delta_args[offset] + num_delta_args[offset]++) =
 673       ctrl->point_idx;
 674   }
 675
 676   if (ctrl->y_shift)
 677   {
 678     offset += 3;
 679     *(delta_args[offset] + num_delta_args[offset]++) =
 680       (ppem << 4) + y_shift;
 681     *(delta_args[offset] + num_delta_args[offset]++) =
 682       ctrl->point_idx;
 683   }
 684 }
 685
 686
 687 static FT_Byte*
 688 TA_sfnt_build_delta_exceptions(SFNT* sfnt,
 689                                FONT* font,
 690                                FT_Long idx,
 691                                FT_Byte* bufp)
 692 {
 693   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
 694   glyf_Data* data = (glyf_Data*)glyf_table->data;
 695   GLYPH* glyph = &data->glyphs[idx];
 696
 697   FT_Face face = font->loader->face;
 698
 699   int num_points;
 700   int i;
 701
 702   FT_UShort num_before_IUP_stack_elements;
 703   FT_UShort num_after_IUP_stack_elements;
 704
 705   /* DELTAP[1-3] stacks for both x and y directions */
 706   FT_UInt* delta_before_IUP_args[6] = {NULL, NULL, NULL, NULL, NULL, NULL};
 707   FT_UInt* delta_after_IUP_args[6] = {NULL, NULL, NULL, NULL, NULL, NULL};
 708   int num_delta_before_IUP_args[6] = {0, 0, 0, 0, 0, 0};
 709   int num_delta_after_IUP_args[6] = {0, 0, 0, 0, 0, 0};
 710   FT_UInt* args = NULL;
 711
 712   FT_Bool need_before_IUP_words = 0;
 713   FT_Bool need_after_IUP_words = 0;
 714   FT_Bool need_before_IUP_word_counts = 0;
 715   FT_Bool need_after_IUP_word_counts = 0;
 716   FT_Bool allocated_before_IUP = 0;
 717   FT_Bool allocated_after_IUP = 0;
 718
 719
 720   num_points = font->loader->gloader->base.outline.n_points;
 721
 722   /* loop over all fitting control instructions */
 723   for (;;)
 724   {
 725     const Ctrl* ctrl = TA_control_get_ctrl(font);
 726
 727
 728     if (!ctrl)
 729       break;
 730
 731     /* check type */
 732     if (!(ctrl->type == Control_Delta_before_IUP
 733           || ctrl->type == Control_Delta_after_IUP))
 734       break;
 735
 736     /* too large values of font and glyph indices in `ctrl' */
 737     /* are handled by later calls of this function */
 738     if (face->face_index < ctrl->font_idx
 739         || idx < ctrl->glyph_idx)
 740       break;
 741
 742     if (ctrl->type == Control_Delta_before_IUP
 743         && !allocated_before_IUP)
 744     {
 745       for (i = 0; i < 6; i++)
 746       {
 747         /* see the comment on allocating `ins_buf' in function */
 748         /* `TA_sfnt_build_glyph_instructions' for more on the array sizes; */
 749         /* we have to increase by 2 to push the number of argument pairs */
 750         /* and the function for a LOOPCALL instruction */
 751         delta_before_IUP_args[i] = (FT_UInt*)malloc((16 * 2 * num_points + 2)
 752                                                     * sizeof (FT_UInt));
 753         if (!delta_before_IUP_args[i])
 754         {
 755           bufp = NULL;
 756           goto Done;
 757         }
 758       }
 759
 760       allocated_before_IUP = 1;
 761     }
 762
 763     if (ctrl->type == Control_Delta_after_IUP
 764         && !allocated_after_IUP)
 765     {
 766       for (i = 0; i < 6; i++)
 767       {
 768         /* we have to increase by 1 for the number of argument pairs */
 769         /* as needed by the DELTA instructions */
 770         delta_after_IUP_args[i] = (FT_UInt*)malloc((16 * 2 * num_points + 1)
 771                                                    * sizeof (FT_UInt));
 772         if (!delta_after_IUP_args[i])
 773         {
 774           bufp = NULL;
 775           goto Done;
 776         }
 777       }
 778
 779       allocated_after_IUP = 1;
 780     }
 781
 782     /* since we walk sequentially over all glyphs (with points), */
 783     /* and the control instruction entries have the same order, */
 784     /* we don't need to test for equality of font and glyph indices: */
 785     /* at this very point in the code we certainly have a hit */
 786     if (ctrl->type == Control_Delta_before_IUP)
 787     {
 788       build_delta_exception(ctrl,
 789                             delta_before_IUP_args,
 790                             num_delta_before_IUP_args);
 791
 792       if (ctrl->point_idx > 255)
 793         need_before_IUP_words = 1;
 794     }
 795     else
 796     {
 797       build_delta_exception(ctrl,
 798                             delta_after_IUP_args,
 799                             num_delta_after_IUP_args);
 800
 801       if (ctrl->point_idx > 255)
 802         need_after_IUP_words = 1;
 803     }
 804
 805     TA_control_get_next(font);
 806   }
 807
 808   /* nothing to do if no control instructions */
 809   if (!(allocated_before_IUP || allocated_after_IUP))
 810     return bufp;
 811
 812   /* add number of argument pairs and function number to the stacks */
 813   for (i = 0; i < 6; i++)
 814   {
 815     if (num_delta_before_IUP_args[i])
 816     {
 817       int n = num_delta_before_IUP_args[i] >> 1;
 818
 819
 820       if (n > 255)
 821         need_before_IUP_word_counts = 1;
 822
 823       *(delta_before_IUP_args[i] + num_delta_before_IUP_args[i]) = n;
 824       num_delta_before_IUP_args[i]++;
 825
 826       *(delta_before_IUP_args[i] + num_delta_before_IUP_args[i]) =
 827         bci_deltap1 + (i % 3);
 828       num_delta_before_IUP_args[i]++;
 829     }
 830   }
 831
 832   /* add number of argument pairs to the stacks */
 833   for (i = 0; i < 6; i++)
 834   {
 835     if (num_delta_after_IUP_args[i])
 836     {
 837       int n = num_delta_after_IUP_args[i] >> 1;
 838
 839
 840       if (n > 255)
 841         need_after_IUP_word_counts = 1;
 842
 843       *(delta_after_IUP_args[i] + num_delta_after_IUP_args[i]) = n;
 844       num_delta_after_IUP_args[i]++;
 845     }
 846   }
 847
 848   /* merge `before IUP' delta stacks into a single one */
 849   if (need_before_IUP_words
 850       || (!need_before_IUP_words && !need_before_IUP_word_counts))
 851   {
 852     FT_UInt num_args = 0;
 853
 854
 855     for (i = 0; i < 6; i++)
 856     {
 857       FT_UInt* args_new;
 858       FT_UInt num_args_new;
 859
 860
 861       if (!num_delta_before_IUP_args[i])
 862         continue;
 863
 864       num_args_new = num_args + num_delta_before_IUP_args[i];
 865       args_new = (FT_UInt*)realloc(args, num_args_new * sizeof (FT_UInt));
 866       if (!args_new)
 867       {
 868         bufp = NULL;
 869         goto Done;
 870       }
 871
 872       memcpy(args_new + num_args,
 873              delta_before_IUP_args[i],
 874              num_delta_before_IUP_args[i] * sizeof (FT_UInt));
 875
 876       args = args_new;
 877       num_args = num_args_new;
 878     }
 879
 880     num_before_IUP_stack_elements = num_args;
 881
 882     bufp = TA_build_push(bufp, args, num_args, need_before_IUP_words, 1);
 883   }
 884   else
 885   {
 886     num_before_IUP_stack_elements = 0;
 887
 888     /* stack elements are bytes, but counts need words */
 889     for (i = 0; i < 6; i++)
 890     {
 891       int num_delta_arg;
 892
 893
 894       if (!num_delta_before_IUP_args[i])
 895         continue;
 896
 897       num_delta_arg = num_delta_before_IUP_args[i] - 2;
 898
 899       bufp = TA_build_push(bufp,
 900                            delta_before_IUP_args[i],
 901                            num_delta_arg,
 902                            need_before_IUP_words,
 903                            1);
 904
 905       num_before_IUP_stack_elements += num_delta_arg + 2;
 906
 907       num_delta_arg >>= 1;
 908       BCI(PUSHW_1);
 909       BCI(HIGH(num_delta_arg));
 910       BCI(LOW(num_delta_arg));
 911
 912       /* the function number */
 913       BCI(PUSHB_1);
 914       BCI(delta_before_IUP_args[i][num_delta_before_IUP_args[i] - 1]);
 915     }
 916   }
 917
 918   /* emit y DELTA opcodes (via `bci_deltap[1-3]' functions) */
 919   if (num_delta_before_IUP_args[5])
 920     BCI(LOOPCALL);
 921   if (num_delta_before_IUP_args[4])
 922     BCI(LOOPCALL);
 923   if (num_delta_before_IUP_args[3])
 924     BCI(LOOPCALL);
 925
 926   if (num_delta_before_IUP_args[2]
 927       || num_delta_before_IUP_args[1]
 928       || num_delta_before_IUP_args[0])
 929     BCI(SVTCA_x);
 930
 931   /* emit x DELTA opcodes */
 932   if (num_delta_before_IUP_args[2])
 933     BCI(LOOPCALL);
 934   if (num_delta_before_IUP_args[1])
 935     BCI(LOOPCALL);
 936   if (num_delta_before_IUP_args[0])
 937     BCI(LOOPCALL);
 938
 939   if (num_delta_before_IUP_args[2]
 940       || num_delta_before_IUP_args[1]
 941       || num_delta_before_IUP_args[0])
 942     BCI(SVTCA_y);
 943
 944   if (num_delta_before_IUP_args[5]
 945       || num_delta_before_IUP_args[4]
 946       || num_delta_before_IUP_args[3])
 947     BCI(IUP_y);
 948
 949   /* merge `after IUP' delta stacks into a single one */
 950   if (need_after_IUP_words
 951       || (!need_after_IUP_words && !need_after_IUP_word_counts))
 952   {
 953     FT_UInt num_args = 0;
 954
 955
 956     for (i = 0; i < 6; i++)
 957     {
 958       FT_UInt* args_new;
 959       FT_UInt num_args_new;
 960
 961
 962       if (!num_delta_after_IUP_args[i])
 963         continue;
 964
 965       num_args_new = num_args + num_delta_after_IUP_args[i];
 966       args_new = (FT_UInt*)realloc(args, num_args_new * sizeof (FT_UInt));
 967       if (!args_new)
 968       {
 969         bufp = NULL;
 970         goto Done;
 971       }
 972
 973       memcpy(args_new + num_args,
 974              delta_after_IUP_args[i],
 975              num_delta_after_IUP_args[i] * sizeof (FT_UInt));
 976
 977       args = args_new;
 978       num_args = num_args_new;
 979     }
 980
 981     num_after_IUP_stack_elements = num_args;
 982
 983     bufp = TA_build_push(bufp, args, num_args, need_after_IUP_words, 1);
 984   }
 985   else
 986   {
 987     num_after_IUP_stack_elements = 0;
 988
 989     /* stack elements are bytes, but counts need words */
 990     for (i = 0; i < 6; i++)
 991     {
 992       int num_delta_arg;
 993
 994
 995       if (!num_delta_after_IUP_args[i])
 996         continue;
 997
 998       num_delta_arg = num_delta_after_IUP_args[i] - 1;
 999
1000       bufp = TA_build_push(bufp,
1001                            delta_after_IUP_args[i],
1002                            num_delta_arg,
1003                            need_after_IUP_words,
1004                            1);
1005
1006       num_after_IUP_stack_elements += num_delta_arg + 1;
1007
1008       num_delta_arg >>= 1;
1009       BCI(PUSHW_1);
1010       BCI(HIGH(num_delta_arg));
1011       BCI(LOW(num_delta_arg));
1012     }
1013   }
1014
1015   /* emit y DELTA opcodes */
1016   if (num_delta_after_IUP_args[5])
1017     BCI(DELTAP3);
1018   if (num_delta_after_IUP_args[4])
1019     BCI(DELTAP2);
1020   if (num_delta_after_IUP_args[3])
1021     BCI(DELTAP1);
1022
1023   if (num_delta_after_IUP_args[2]
1024       || num_delta_after_IUP_args[1]
1025       || num_delta_after_IUP_args[0])
1026     BCI(SVTCA_x);
1027
1028   /* emit x DELTA opcodes */
1029   if (num_delta_after_IUP_args[2])
1030     BCI(DELTAP3);
1031   if (num_delta_after_IUP_args[1])
1032     BCI(DELTAP2);
1033   if (num_delta_after_IUP_args[0])
1034     BCI(DELTAP1);
1035
1036   /* we need to insert a few extra bytecode instructions */
1037   /* if we have y delta exceptions before IUP */
1038   if (num_delta_before_IUP_args[5]
1039       || num_delta_before_IUP_args[4]
1040       || num_delta_before_IUP_args[3])
1041   {
1042     /* set `cvtl_do_iup_y' to zero at the beginning of the bytecode */
1043     /* by activating `ins_extra_buf' */
1044     glyph->ins_extra_len = sizeof (ins_extra_buf) / sizeof (FT_Byte);
1045
1046     /* reset `cvtl_do_iup_y' for next glyph */
1047     BCI(PUSHB_2);
1048     BCI(cvtl_do_iup_y);
1049     BCI(100);
1050     BCI(WCVTP);
1051   }
1052
1053 Done:
1054   for (i = 0; i < 6; i++)
1055   {
1056     free(delta_before_IUP_args[i]);
1057     free(delta_after_IUP_args[i]);
1058   }
1059   free(args);
1060
1061   if (num_before_IUP_stack_elements > sfnt->max_stack_elements)
1062     sfnt->max_stack_elements = num_before_IUP_stack_elements;
1063   if (num_after_IUP_stack_elements > sfnt->max_stack_elements)
1064     sfnt->max_stack_elements = num_after_IUP_stack_elements;
1065
1066   return bufp;
1067 }
1068
1069
1070 static FT_Byte*
1071 TA_sfnt_build_glyph_scaler(SFNT* sfnt,
1072                            Recorder* recorder,
1073                            FT_Byte* bufp)
1074 {
1075   FONT* font = recorder->font;
1076   FT_GlyphSlot glyph = sfnt->face->glyph;
1077   FT_Vector* points = glyph->outline.points;
1078   FT_Int num_contours = glyph->outline.n_contours;
1079
1080   FT_UInt* args;
1081   FT_UInt* arg;
1082   FT_UInt num_args;
1083
1084   FT_Bool need_words = 0;
1085   FT_Int p, q;
1086   FT_Int start, end;
1087   FT_UShort num_storage;
1088   FT_UShort num_stack_elements;
1089
1090
1091   num_args = 2 * num_contours + 2;
1092
1093   /* collect all arguments temporarily in an array (in reverse order) */
1094   /* so that we can easily split into chunks of 255 args */
1095   /* as needed by NPUSHB and NPUSHW, respectively */
1096   args = (FT_UInt*)malloc(num_args * sizeof (FT_UInt));
1097   if (!args)
1098     return NULL;
1099
1100   arg = args + num_args - 1;
1101
1102   if (num_args > 0xFF)
1103     need_words = 1;
1104
1105   if (recorder->glyph->num_components && font->hint_composites)
1106     *(arg--) = bci_scale_composite_glyph;
1107   else
1108     *(arg--) = bci_scale_glyph;
1109   *(arg--) = num_contours;
1110
1111   start = 0;
1112   end = 0;
1113
1114   for (p = 0; p < num_contours; p++)
1115   {
1116     FT_Int max = start;
1117     FT_Int min = start;
1118
1119
1120     end = glyph->outline.contours[p];
1121
1122     for (q = start; q <= end; q++)
1123     {
1124       if (points[q].y < points[min].y)
1125         min = q;
1126       if (points[q].y > points[max].y)
1127         max = q;
1128     }
1129
1130     if (min > max)
1131     {
1132       *(arg--) = TA_adjust_point_index(recorder, max);
1133       *(arg--) = TA_adjust_point_index(recorder, min);
1134     }
1135     else
1136     {
1137       *(arg--) = TA_adjust_point_index(recorder, min);
1138       *(arg--) = TA_adjust_point_index(recorder, max);
1139     }
1140
1141     start = end + 1;
1142   }
1143
1144   if (end > 0xFF)
1145     need_words = 1;
1146
1147   /* with most fonts it is very rare */
1148   /* that any of the pushed arguments is larger than 0xFF, */
1149   /* thus we refrain from further optimizing this case */
1150   bufp = TA_build_push(bufp, args, num_args, need_words, 1);
1151
1152   BCI(CALL);
1153
1154   num_storage = sal_segment_offset;
1155   if (num_storage > sfnt->max_storage)
1156     sfnt->max_storage = num_storage;
1157
1158   num_stack_elements = ADDITIONAL_STACK_ELEMENTS + num_args;
1159   if (num_stack_elements > sfnt->max_stack_elements)
1160     sfnt->max_stack_elements = num_stack_elements;
1161
1162   free(args);
1163
1164   return bufp;
1165 }
1166
1167
1168 static FT_Byte*
1169 TA_font_build_subglyph_shifter(FONT* font,
1170                                FT_Byte* bufp)
1171 {
1172   FT_Face face = font->loader->face;
1173   FT_GlyphSlot glyph = face->glyph;
1174
1175   TA_GlyphLoader gloader = font->loader->gloader;
1176
1177   TA_SubGlyph subglyphs = gloader->base.subglyphs;
1178   TA_SubGlyph subglyph_limit = subglyphs + gloader->base.num_subglyphs;
1179   TA_SubGlyph subglyph;
1180
1181   FT_Int curr_contour = 0;
1182
1183
1184   for (subglyph = subglyphs; subglyph < subglyph_limit; subglyph++)
1185   {
1186     FT_Error error;
1187
1188     FT_UShort flags = subglyph->flags;
1189     FT_Pos y_offset = subglyph->arg2;
1190
1191     FT_Int num_contours;
1192
1193
1194     /* load subglyph to get the number of contours */
1195     error = FT_Load_Glyph(face, subglyph->index, FT_LOAD_NO_SCALE);
1196     if (error)
1197       return NULL;
1198     num_contours = glyph->outline.n_contours;
1199
1200     /* nothing to do if there is a point-to-point alignment */
1201     if (!(flags & FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES))
1202       goto End;
1203
1204     /* nothing to do if y offset is zero */
1205     if (!y_offset)
1206       goto End;
1207
1208     /* nothing to do if there are no contours */
1209     if (!num_contours)
1210       goto End;
1211
1212     /* note that calling `FT_Load_Glyph' without FT_LOAD_NO_RECURSE */
1213     /* ensures that composite subglyphs are represented as simple glyphs */
1214
1215     if (num_contours > 0xFF
1216         || curr_contour > 0xFF)
1217     {
1218       BCI(PUSHW_2);
1219       BCI(HIGH(curr_contour));
1220       BCI(LOW(curr_contour));
1221       BCI(HIGH(num_contours));
1222       BCI(LOW(num_contours));
1223     }
1224     else
1225     {
1226       BCI(PUSHB_2);
1227       BCI(curr_contour);
1228       BCI(num_contours);
1229     }
1230
1231     /* there are high chances that this value needs PUSHW, */
1232     /* thus we handle it separately */
1233     if (y_offset > 0xFF || y_offset < 0)
1234     {
1235       BCI(PUSHW_1);
1236       BCI(HIGH(y_offset));
1237       BCI(LOW(y_offset));
1238     }
1239     else
1240     {
1241       BCI(PUSHB_1);
1242       BCI(y_offset);
1243     }
1244
1245     BCI(PUSHB_1);
1246     BCI(bci_shift_subglyph);
1247     BCI(CALL);
1248
1249   End:
1250     curr_contour += num_contours;
1251   }
1252
1253   return bufp;
1254 }
1255
1256
1257 /*
1258  * The four `ta_ip_*' actions in the `TA_hints_recorder' callback store its
1259  * data in four arrays (which are simple but waste a lot of memory).  The
1260  * function below converts them into bytecode.
1261  *
1262  * For `ta_ip_before' and `ta_ip_after', the collected points are emitted
1263  * together with the edge they correspond to.
1264  *
1265  * For both `ta_ip_on' and `ta_ip_between', an outer loop is constructed to
1266  * loop over the edge or edge pairs, respectively, and each edge or edge
1267  * pair contains an inner loop to emit the correponding points.
1268  */
1269
1270 static void
1271 TA_build_point_hints(Recorder* recorder,
1272                      TA_GlyphHints hints)
1273 {
1274   TA_AxisHints axis = &hints->axis[TA_DIMENSION_VERT];
1275   TA_Segment segments = axis->segments;
1276   TA_Edge edges = axis->edges;
1277
1278   FT_Byte* p = recorder->hints_record.buf;
1279
1280   FT_UShort i;
1281   FT_UShort j;
1282
1283   FT_UShort prev_edge;
1284   FT_UShort prev_before_edge;
1285   FT_UShort prev_after_edge;
1286
1287   Node1* before_node;
1288   Node1* after_node;
1289   Node2* on_node;
1290   Node3* between_node;
1291
1292
1293   /* we store everything as 16bit numbers; */
1294   /* the function numbers (`ta_ip_before', etc.) */
1295   /* reflect the order in the TA_Action enumeration */
1296
1297   /* ip_before_points */
1298
1299   i = 0;
1300   for (before_node = LLRB_MIN(ip_before_points,
1301                               &recorder->ip_before_points_head);
1302        before_node;
1303        before_node = LLRB_NEXT(ip_before_points,
1304                                &recorder->ip_before_points_head,
1305                                before_node))
1306   {
1307     /* count points */
1308     i++;
1309   }
1310
1311   if (i)
1312   {
1313     TA_Edge edge;
1314
1315
1316     recorder->hints_record.num_actions++;
1317
1318     edge = edges;
1319
1320     *(p++) = 0;
1321     *(p++) = (FT_Byte)ta_ip_before + ACTION_OFFSET;
1322     *(p++) = HIGH(edge->first - segments);
1323     *(p++) = LOW(edge->first - segments);
1324     *(p++) = HIGH(i);
1325     *(p++) = LOW(i);
1326
1327     for (before_node = LLRB_MIN(ip_before_points,
1328                                 &recorder->ip_before_points_head);
1329          before_node;
1330          before_node = LLRB_NEXT(ip_before_points,
1331                                  &recorder->ip_before_points_head,
1332                                  before_node))
1333     {
1334       FT_UInt point;
1335
1336
1337       point = TA_adjust_point_index(recorder, before_node->point);
1338       *(p++) = HIGH(point);
1339       *(p++) = LOW(point);
1340     }
1341   }
1342
1343   /* ip_after_points */
1344
1345   i = 0;
1346   for (after_node = LLRB_MIN(ip_after_points,
1347                              &recorder->ip_after_points_head);
1348        after_node;
1349        after_node = LLRB_NEXT(ip_after_points,
1350                               &recorder->ip_after_points_head,
1351                               after_node))
1352   {
1353     /* count points */
1354     i++;
1355   }
1356
1357   if (i)
1358   {
1359     TA_Edge edge;
1360
1361
1362     recorder->hints_record.num_actions++;
1363
1364     edge = edges + axis->num_edges - 1;
1365
1366     *(p++) = 0;
1367     *(p++) = (FT_Byte)ta_ip_after + ACTION_OFFSET;
1368     *(p++) = HIGH(edge->first - segments);
1369     *(p++) = LOW(edge->first - segments);
1370     *(p++) = HIGH(i);
1371     *(p++) = LOW(i);
1372
1373     for (after_node = LLRB_MIN(ip_after_points,
1374                                &recorder->ip_after_points_head);
1375          after_node;
1376          after_node = LLRB_NEXT(ip_after_points,
1377                                 &recorder->ip_after_points_head,
1378                                 after_node))
1379     {
1380       FT_UInt point;
1381
1382
1383       point = TA_adjust_point_index(recorder, after_node->point);
1384       *(p++) = HIGH(point);
1385       *(p++) = LOW(point);
1386     }
1387   }
1388
1389   /* ip_on_point_array */
1390
1391   prev_edge = 0xFFFF;
1392   i = 0;
1393   for (on_node = LLRB_MIN(ip_on_points,
1394                           &recorder->ip_on_points_head);
1395        on_node;
1396        on_node = LLRB_NEXT(ip_on_points,
1397                            &recorder->ip_on_points_head,
1398                            on_node))
1399   {
1400     /* count edges */
1401     if (on_node->edge != prev_edge)
1402     {
1403       i++;
1404       prev_edge = on_node->edge;
1405     }
1406   }
1407
1408   if (i)
1409   {
1410     recorder->hints_record.num_actions++;
1411
1412     *(p++) = 0;
1413     *(p++) = (FT_Byte)ta_ip_on + ACTION_OFFSET;
1414     *(p++) = HIGH(i);
1415     *(p++) = LOW(i);
1416
1417     for (on_node = LLRB_MIN(ip_on_points,
1418                             &recorder->ip_on_points_head);
1419          on_node;
1420          on_node = LLRB_NEXT(ip_on_points,
1421                              &recorder->ip_on_points_head,
1422                              on_node))
1423     {
1424       Node2* edge_node;
1425       TA_Edge edge;
1426
1427
1428       edge = edges + on_node->edge;
1429
1430       *(p++) = HIGH(edge->first - segments);
1431       *(p++) = LOW(edge->first - segments);
1432
1433       /* save current position */
1434       edge_node = on_node;
1435       j = 0;
1436       for (;
1437            on_node;
1438            on_node = LLRB_NEXT(ip_on_points,
1439                                &recorder->ip_on_points_head,
1440                                on_node))
1441       {
1442         /* count points on current edge */
1443         if (on_node->edge != edge_node->edge)
1444           break;
1445         j++;
1446       }
1447
1448       *(p++) = HIGH(j);
1449       *(p++) = LOW(j);
1450
1451       /* restore current position */
1452       on_node = edge_node;
1453       for (;
1454            on_node;
1455            on_node = LLRB_NEXT(ip_on_points,
1456                                &recorder->ip_on_points_head,
1457                                on_node))
1458       {
1459         FT_UInt point;
1460
1461
1462         if (on_node->edge != edge_node->edge)
1463           break;
1464
1465         point = TA_adjust_point_index(recorder, on_node->point);
1466         *(p++) = HIGH(point);
1467         *(p++) = LOW(point);
1468
1469         /* keep track of previous node */
1470         edge_node = on_node;
1471       }
1472
1473       /* reset loop iterator by one element, then continue */
1474       on_node = edge_node;
1475     }
1476   }
1477
1478   /* ip_between_point_array */
1479
1480   prev_before_edge = 0xFFFF;
1481   prev_after_edge = 0xFFFF;
1482   i = 0;
1483   for (between_node = LLRB_MIN(ip_between_points,
1484                                &recorder->ip_between_points_head);
1485        between_node;
1486        between_node = LLRB_NEXT(ip_between_points,
1487                                 &recorder->ip_between_points_head,
1488                                 between_node))
1489   {
1490     /* count `(before,after)' edge pairs */
1491     if (between_node->before_edge != prev_before_edge
1492         || between_node->after_edge != prev_after_edge)
1493     {
1494       i++;
1495       prev_before_edge = between_node->before_edge;
1496       prev_after_edge = between_node->after_edge;
1497     }
1498   }
1499
1500   if (i)
1501   {
1502     recorder->hints_record.num_actions++;
1503
1504     *(p++) = 0;
1505     *(p++) = (FT_Byte)ta_ip_between + ACTION_OFFSET;
1506     *(p++) = HIGH(i);
1507     *(p++) = LOW(i);
1508
1509     for (between_node = LLRB_MIN(ip_between_points,
1510                                  &recorder->ip_between_points_head);
1511          between_node;
1512          between_node = LLRB_NEXT(ip_between_points,
1513                                   &recorder->ip_between_points_head,
1514                                   between_node))
1515     {
1516       Node3* edge_pair_node;
1517       TA_Edge before;
1518       TA_Edge after;
1519
1520
1521       before = edges + between_node->before_edge;
1522       after = edges + between_node->after_edge;
1523
1524       *(p++) = HIGH(after->first - segments);
1525       *(p++) = LOW(after->first - segments);
1526       *(p++) = HIGH(before->first - segments);
1527       *(p++) = LOW(before->first - segments);
1528
1529       /* save current position */
1530       edge_pair_node = between_node;
1531       j = 0;
1532       for (;
1533            between_node;
1534            between_node = LLRB_NEXT(ip_between_points,
1535                                     &recorder->ip_between_points_head,
1536                                     between_node))
1537       {
1538         /* count points associated with current edge pair */
1539         if (between_node->before_edge != edge_pair_node->before_edge
1540             || between_node->after_edge != edge_pair_node->after_edge)
1541           break;
1542         j++;
1543       }
1544
1545       *(p++) = HIGH(j);
1546       *(p++) = LOW(j);
1547
1548       /* restore current position */
1549       between_node = edge_pair_node;
1550       for (;
1551            between_node;
1552            between_node = LLRB_NEXT(ip_between_points,
1553                                     &recorder->ip_between_points_head,
1554                                     between_node))
1555       {
1556         FT_UInt point;
1557
1558
1559         if (between_node->before_edge != edge_pair_node->before_edge
1560             || between_node->after_edge != edge_pair_node->after_edge)
1561           break;
1562
1563         point = TA_adjust_point_index(recorder, between_node->point);
1564         *(p++) = HIGH(point);
1565         *(p++) = LOW(point);
1566
1567         /* keep track of previous node */
1568         edge_pair_node = between_node;
1569       }
1570
1571       /* reset loop iterator by one element, then continue */
1572       between_node = edge_pair_node;
1573     }
1574   }
1575
1576   recorder->hints_record.buf = p;
1577 }
1578
1579
1580 static FT_Bool
1581 TA_hints_record_is_different(Hints_Record* hints_records,
1582                              FT_UInt num_hints_records,
1583                              FT_Byte* start,
1584                              FT_Byte* end)
1585 {
1586   Hints_Record last_hints_record;
1587
1588
1589   if (!hints_records)
1590     return 1;
1591
1592   /* we only need to compare with the last hints record */
1593   last_hints_record = hints_records[num_hints_records - 1];
1594
1595   if ((FT_UInt)(end - start) != last_hints_record.buf_len)
1596     return 1;
1597
1598   if (memcmp(start, last_hints_record.buf, last_hints_record.buf_len))
1599     return 1;
1600
1601   return 0;
1602 }
1603
1604
1605 static FT_Error
1606 TA_add_hints_record(Hints_Record** hints_records,
1607                     FT_UInt* num_hints_records,
1608                     FT_Byte* start,
1609                     Hints_Record hints_record)
1610 {
1611   Hints_Record* hints_records_new;
1612   FT_UInt buf_len;
1613   /* at this point, `hints_record.buf' still points into `ins_buf' */
1614   FT_Byte* end = hints_record.buf;
1615
1616
1617   buf_len = (FT_UInt)(end - start);
1618
1619   /* now fill the structure completely */
1620   hints_record.buf_len = buf_len;
1621   hints_record.buf = (FT_Byte*)malloc(buf_len);
1622   if (!hints_record.buf)
1623     return FT_Err_Out_Of_Memory;
1624
1625   memcpy(hints_record.buf, start, buf_len);
1626
1627   (*num_hints_records)++;
1628   hints_records_new =
1629     (Hints_Record*)realloc(*hints_records, *num_hints_records
1630                                            * sizeof (Hints_Record));
1631   if (!hints_records_new)
1632   {
1633     free(hints_record.buf);
1634     (*num_hints_records)--;
1635     return FT_Err_Out_Of_Memory;
1636   }
1637   else
1638     *hints_records = hints_records_new;
1639
1640   (*hints_records)[*num_hints_records - 1] = hints_record;
1641
1642   return FT_Err_Ok;
1643 }
1644
1645
1646 static FT_Byte*
1647 TA_emit_hints_record(Recorder* recorder,
1648                      Hints_Record* hints_record,
1649                      FT_Byte* bufp,
1650                      FT_Bool optimize)
1651 {
1652   FT_Byte* p;
1653   FT_Byte* endp;
1654   FT_Bool need_words = 0;
1655
1656   FT_UInt i, j;
1657   FT_UInt num_arguments;
1658   FT_UInt num_args;
1659
1660
1661   /* check whether any argument is larger than 0xFF */
1662   endp = hints_record->buf + hints_record->buf_len;
1663   for (p = hints_record->buf; p < endp; p += 2)
1664     if (*p)
1665     {
1666       need_words = 1;
1667       break;
1668     }
1669
1670   /* with most fonts it is very rare */
1671   /* that any of the pushed arguments is larger than 0xFF, */
1672   /* thus we refrain from further optimizing this case */
1673
1674   num_arguments = hints_record->buf_len / 2;
1675   p = endp - 2;
1676
1677   if (need_words)
1678   {
1679     for (i = 0; i < num_arguments; i += 255)
1680     {
1681       num_args = (num_arguments - i > 255) ? 255 : (num_arguments - i);
1682
1683       if (optimize && num_args <= 8)
1684         BCI(PUSHW_1 - 1 + num_args);
1685       else
1686       {
1687         BCI(NPUSHW);
1688         BCI(num_args);
1689       }
1690       for (j = 0; j < num_args; j++)
1691       {
1692         BCI(*p);
1693         BCI(*(p + 1));
1694         p -= 2;
1695       }
1696     }
1697   }
1698   else
1699   {
1700     /* we only need the lower bytes */
1701     p++;
1702
1703     for (i = 0; i < num_arguments; i += 255)
1704     {
1705       num_args = (num_arguments - i > 255) ? 255 : (num_arguments - i);
1706
1707       if (optimize && num_args <= 8)
1708         BCI(PUSHB_1 - 1 + num_args);
1709       else
1710       {
1711         BCI(NPUSHB);
1712         BCI(num_args);
1713       }
1714       for (j = 0; j < num_args; j++)
1715       {
1716         BCI(*p);
1717         p -= 2;
1718       }
1719     }
1720   }
1721
1722   /* collect stack depth data */
1723   if (num_arguments > recorder->num_stack_elements)
1724     recorder->num_stack_elements = num_arguments;
1725
1726   return bufp;
1727 }
1728
1729
1730 static FT_Byte*
1731 TA_emit_hints_records(Recorder* recorder,
1732                       Hints_Record* hints_records,
1733                       FT_UInt num_hints_records,
1734                       FT_Byte* bufp,
1735                       FT_Bool optimize)
1736 {
1737   FT_UInt i;
1738   Hints_Record* hints_record;
1739
1740
1741   hints_record = hints_records;
1742
1743   /* emit hints records in `if' clauses, */
1744   /* with the ppem size as the condition */
1745   for (i = 0; i < num_hints_records - 1; i++)
1746   {
1747     BCI(MPPEM);
1748     if (hints_record->size > 0xFF)
1749     {
1750       BCI(PUSHW_1);
1751       BCI(HIGH((hints_record + 1)->size));
1752       BCI(LOW((hints_record + 1)->size));
1753     }
1754     else
1755     {
1756       BCI(PUSHB_1);
1757       BCI((hints_record + 1)->size);
1758     }
1759     BCI(LT);
1760     BCI(IF);
1761     bufp = TA_emit_hints_record(recorder, hints_record, bufp, optimize);
1762     BCI(ELSE);
1763
1764     hints_record++;
1765   }
1766
1767   bufp = TA_emit_hints_record(recorder, hints_record, bufp, optimize);
1768
1769   for (i = 0; i < num_hints_records - 1; i++)
1770     BCI(EIF);
1771
1772   return bufp;
1773 }
1774
1775
1776 static void
1777 TA_free_hints_records(Hints_Record* hints_records,
1778                       FT_UInt num_hints_records)
1779 {
1780   FT_UInt i;
1781
1782
1783   for (i = 0; i < num_hints_records; i++)
1784     free(hints_records[i].buf);
1785
1786   free(hints_records);
1787 }
1788
1789
1790 static FT_Byte*
1791 TA_hints_recorder_handle_segments(FT_Byte* bufp,
1792                                   TA_AxisHints axis,
1793                                   TA_Edge edge,
1794                                   FT_UShort* wraps)
1795 {
1796   TA_Segment segments = axis->segments;
1797   TA_Segment seg;
1798   FT_UShort seg_idx;
1799   FT_UShort num_segs = 0;
1800   FT_UShort* wrap;
1801
1802
1803   seg_idx = edge->first - segments;
1804
1805   /* we store everything as 16bit numbers */
1806   *(bufp++) = HIGH(seg_idx);
1807   *(bufp++) = LOW(seg_idx);
1808
1809   /* wrap-around segments are stored as two segments */
1810   if (edge->first->first > edge->first->last)
1811     num_segs++;
1812
1813   seg = edge->first->edge_next;
1814   while (seg != edge->first)
1815   {
1816     num_segs++;
1817
1818     if (seg->first > seg->last)
1819       num_segs++;
1820
1821     seg = seg->edge_next;
1822   }
1823
1824   *(bufp++) = HIGH(num_segs);
1825   *(bufp++) = LOW(num_segs);
1826
1827   if (edge->first->first > edge->first->last)
1828   {
1829     /* emit second part of wrap-around segment; */
1830     /* the bytecode positions such segments after `normal' ones */
1831     wrap = wraps;
1832     for (;;)
1833     {
1834       if (seg_idx == *wrap)
1835         break;
1836       wrap++;
1837     }
1838
1839     *(bufp++) = HIGH(axis->num_segments + (wrap - wraps));
1840     *(bufp++) = LOW(axis->num_segments + (wrap - wraps));
1841   }
1842
1843   seg = edge->first->edge_next;
1844   while (seg != edge->first)
1845   {
1846     seg_idx = seg - segments;
1847
1848     *(bufp++) = HIGH(seg_idx);
1849     *(bufp++) = LOW(seg_idx);
1850
1851     if (seg->first > seg->last)
1852     {
1853       wrap = wraps;
1854       for (;;)
1855       {
1856         if (seg_idx == *wrap)
1857           break;
1858         wrap++;
1859       }
1860
1861       *(bufp++) = HIGH(axis->num_segments + (wrap - wraps));
1862       *(bufp++) = LOW(axis->num_segments + (wrap - wraps));
1863     }
1864
1865     seg = seg->edge_next;
1866   }
1867
1868   return bufp;
1869 }
1870
1871
1872 static void
1873 TA_hints_recorder(TA_Action action,
1874                   TA_GlyphHints hints,
1875                   TA_Dimension dim,
1876                   void* arg1,
1877                   TA_Edge arg2,
1878                   TA_Edge arg3,
1879                   TA_Edge lower_bound,
1880                   TA_Edge upper_bound)
1881 {
1882   TA_AxisHints axis = &hints->axis[dim];
1883   TA_Edge edges = axis->edges;
1884   TA_Segment segments = axis->segments;
1885   TA_Point points = hints->points;
1886
1887   Recorder* recorder = (Recorder*)hints->user;
1888   SFNT* sfnt = recorder->sfnt;
1889   FONT* font = recorder->font;
1890   FT_UShort* wraps = recorder->wrap_around_segments;
1891   FT_Byte* p = recorder->hints_record.buf;
1892
1893   FT_UInt style = font->loader->metrics->style_class->style;
1894
1895
1896   if (dim == TA_DIMENSION_HORZ)
1897     return;
1898
1899   /* we collect point hints for later processing */
1900   switch (action)
1901   {
1902   case ta_ip_before:
1903     {
1904       Node1* before_node;
1905       TA_Point point = (TA_Point)arg1;
1906
1907
1908       before_node = (Node1*)malloc(sizeof (Node1));
1909       if (!before_node)
1910         return;
1911       before_node->point = point - points;
1912
1913       LLRB_INSERT(ip_before_points,
1914                   &recorder->ip_before_points_head,
1915                   before_node);
1916     }
1917     return;
1918
1919   case ta_ip_after:
1920     {
1921       Node1* after_node;
1922       TA_Point point = (TA_Point)arg1;
1923
1924
1925       after_node = (Node1*)malloc(sizeof (Node1));
1926       if (!after_node)
1927         return;
1928       after_node->point = point - points;
1929
1930       LLRB_INSERT(ip_after_points,
1931                   &recorder->ip_after_points_head,
1932                   after_node);
1933     }
1934     return;
1935
1936   case ta_ip_on:
1937     {
1938       Node2* on_node;
1939       TA_Point point = (TA_Point)arg1;
1940       TA_Edge edge = arg2;
1941
1942
1943       on_node = (Node2*)malloc(sizeof (Node2));
1944       if (!on_node)
1945         return;
1946       on_node->edge = edge - edges;
1947       on_node->point = point - points;
1948
1949       LLRB_INSERT(ip_on_points,
1950                   &recorder->ip_on_points_head,
1951                   on_node);
1952     }
1953     return;
1954
1955   case ta_ip_between:
1956     {
1957       Node3* between_node;
1958       TA_Point point = (TA_Point)arg1;
1959       TA_Edge before = arg2;
1960       TA_Edge after = arg3;
1961
1962
1963       between_node = (Node3*)malloc(sizeof (Node3));
1964       if (!between_node)
1965         return;
1966       between_node->before_edge = before - edges;
1967       between_node->after_edge = after - edges;
1968       between_node->point = point - points;
1969
1970       LLRB_INSERT(ip_between_points,
1971                   &recorder->ip_between_points_head,
1972                   between_node);
1973     }
1974     return;
1975
1976   case ta_bound:
1977     /* we ignore the BOUND action since we signal this information */
1978     /* with the proper function number */
1979     return;
1980
1981   default:
1982     break;
1983   }
1984
1985   /* some enum values correspond to four or eight bytecode functions; */
1986   /* if the value is n, the function numbers are n, ..., n+7, */
1987   /* to be differentiated with flags */
1988
1989   switch (action)
1990   {
1991   case ta_link:
1992     {
1993       TA_Edge base_edge = (TA_Edge)arg1;
1994       TA_Edge stem_edge = arg2;
1995
1996
1997       *(p++) = 0;
1998       *(p++) = (FT_Byte)action + ACTION_OFFSET
1999                + ((stem_edge->flags & TA_EDGE_SERIF) != 0)
2000                + 2 * ((base_edge->flags & TA_EDGE_ROUND) != 0);
2001
2002       *(p++) = HIGH(base_edge->first - segments);
2003       *(p++) = LOW(base_edge->first - segments);
2004       *(p++) = HIGH(stem_edge->first - segments);
2005       *(p++) = LOW(stem_edge->first - segments);
2006
2007       p = TA_hints_recorder_handle_segments(p, axis, stem_edge, wraps);
2008     }
2009     break;
2010
2011   case ta_anchor:
2012     {
2013       TA_Edge edge = (TA_Edge)arg1;
2014       TA_Edge edge2 = arg2;
2015
2016
2017       *(p++) = 0;
2018       *(p++) = (FT_Byte)action + ACTION_OFFSET
2019                + ((edge2->flags & TA_EDGE_SERIF) != 0)
2020                + 2 * ((edge->flags & TA_EDGE_ROUND) != 0);
2021
2022       *(p++) = HIGH(edge->first - segments);
2023       *(p++) = LOW(edge->first - segments);
2024       *(p++) = HIGH(edge2->first - segments);
2025       *(p++) = LOW(edge2->first - segments);
2026
2027       p = TA_hints_recorder_handle_segments(p, axis, edge, wraps);
2028     }
2029     break;
2030
2031   case ta_adjust:
2032     {
2033       TA_Edge edge = (TA_Edge)arg1;
2034       TA_Edge edge2 = arg2;
2035       TA_Edge edge_minus_one = lower_bound;
2036
2037
2038       *(p++) = 0;
2039       *(p++) = (FT_Byte)action + ACTION_OFFSET
2040                + ((edge2->flags & TA_EDGE_SERIF) != 0)
2041                + 2 * ((edge->flags & TA_EDGE_ROUND) != 0)
2042                + 4 * (edge_minus_one != NULL);
2043
2044       *(p++) = HIGH(edge->first - segments);
2045       *(p++) = LOW(edge->first - segments);
2046       *(p++) = HIGH(edge2->first - segments);
2047       *(p++) = LOW(edge2->first - segments);
2048
2049       if (edge_minus_one)
2050       {
2051         *(p++) = HIGH(edge_minus_one->first - segments);
2052         *(p++) = LOW(edge_minus_one->first - segments);
2053       }
2054
2055       p = TA_hints_recorder_handle_segments(p, axis, edge, wraps);
2056     }
2057     break;
2058
2059   case ta_blue_anchor:
2060     {
2061       TA_Edge edge = (TA_Edge)arg1;
2062       TA_Edge blue = arg2;
2063
2064
2065       *(p++) = 0;
2066       *(p++) = (FT_Byte)action + ACTION_OFFSET;
2067
2068       *(p++) = HIGH(blue->first - segments);
2069       *(p++) = LOW(blue->first - segments);
2070
2071       if (edge->best_blue_is_shoot)
2072       {
2073         *(p++) = HIGH(CVT_BLUE_SHOOTS_OFFSET(style) + edge->best_blue_idx);
2074         *(p++) = LOW(CVT_BLUE_SHOOTS_OFFSET(style) + edge->best_blue_idx);
2075       }
2076       else
2077       {
2078         *(p++) = HIGH(CVT_BLUE_REFS_OFFSET(style) + edge->best_blue_idx);
2079         *(p++) = LOW(CVT_BLUE_REFS_OFFSET(style) + edge->best_blue_idx);
2080       }
2081
2082       *(p++) = HIGH(edge->first - segments);
2083       *(p++) = LOW(edge->first - segments);
2084
2085       p = TA_hints_recorder_handle_segments(p, axis, edge, wraps);
2086     }
2087     break;
2088
2089   case ta_stem:
2090     {
2091       TA_Edge edge = (TA_Edge)arg1;
2092       TA_Edge edge2 = arg2;
2093       TA_Edge edge_minus_one = lower_bound;
2094
2095
2096       *(p++) = 0;
2097       *(p++) = (FT_Byte)action + ACTION_OFFSET
2098                + ((edge2->flags & TA_EDGE_SERIF) != 0)
2099                + 2 * ((edge->flags & TA_EDGE_ROUND) != 0)
2100                + 4 * (edge_minus_one != NULL);
2101
2102       *(p++) = HIGH(edge->first - segments);
2103       *(p++) = LOW(edge->first - segments);
2104       *(p++) = HIGH(edge2->first - segments);
2105       *(p++) = LOW(edge2->first - segments);
2106
2107       if (edge_minus_one)
2108       {
2109         *(p++) = HIGH(edge_minus_one->first - segments);
2110         *(p++) = LOW(edge_minus_one->first - segments);
2111       }
2112
2113       p = TA_hints_recorder_handle_segments(p, axis, edge, wraps);
2114       p = TA_hints_recorder_handle_segments(p, axis, edge2, wraps);
2115     }
2116     break;
2117
2118   case ta_blue:
2119     {
2120       TA_Edge edge = (TA_Edge)arg1;
2121
2122
2123       *(p++) = 0;
2124       *(p++) = (FT_Byte)action + ACTION_OFFSET;
2125
2126       if (edge->best_blue_is_shoot)
2127       {
2128         *(p++) = HIGH(CVT_BLUE_SHOOTS_OFFSET(style) + edge->best_blue_idx);
2129         *(p++) = LOW(CVT_BLUE_SHOOTS_OFFSET(style) + edge->best_blue_idx);
2130       }
2131       else
2132       {
2133         *(p++) = HIGH(CVT_BLUE_REFS_OFFSET(style) + edge->best_blue_idx);
2134         *(p++) = LOW(CVT_BLUE_REFS_OFFSET(style) + edge->best_blue_idx);
2135       }
2136
2137       *(p++) = HIGH(edge->first - segments);
2138       *(p++) = LOW(edge->first - segments);
2139
2140       p = TA_hints_recorder_handle_segments(p, axis, edge, wraps);
2141     }
2142     break;
2143
2144   case ta_serif:
2145     {
2146       TA_Edge serif = (TA_Edge)arg1;
2147       TA_Edge base = serif->serif;
2148
2149
2150       *(p++) = 0;
2151       *(p++) = (FT_Byte)action + ACTION_OFFSET
2152                + (lower_bound != NULL)
2153                + 2 * (upper_bound != NULL);
2154
2155       *(p++) = HIGH(serif->first - segments);
2156       *(p++) = LOW(serif->first - segments);
2157       *(p++) = HIGH(base->first - segments);
2158       *(p++) = LOW(base->first - segments);
2159
2160       if (lower_bound)
2161       {
2162         *(p++) = HIGH(lower_bound->first - segments);
2163         *(p++) = LOW(lower_bound->first - segments);
2164       }
2165       if (upper_bound)
2166       {
2167         *(p++) = HIGH(upper_bound->first - segments);
2168         *(p++) = LOW(upper_bound->first - segments);
2169       }
2170
2171       p = TA_hints_recorder_handle_segments(p, axis, serif, wraps);
2172     }
2173     break;
2174
2175   case ta_serif_anchor:
2176   case ta_serif_link2:
2177     {
2178       TA_Edge edge = (TA_Edge)arg1;
2179
2180
2181       *(p++) = 0;
2182       *(p++) = (FT_Byte)action + ACTION_OFFSET
2183                + (lower_bound != NULL)
2184                + 2 * (upper_bound != NULL);
2185
2186       *(p++) = HIGH(edge->first - segments);
2187       *(p++) = LOW(edge->first - segments);
2188
2189       if (lower_bound)
2190       {
2191         *(p++) = HIGH(lower_bound->first - segments);
2192         *(p++) = LOW(lower_bound->first - segments);
2193       }
2194       if (upper_bound)
2195       {
2196         *(p++) = HIGH(upper_bound->first - segments);
2197         *(p++) = LOW(upper_bound->first - segments);
2198       }
2199
2200       p = TA_hints_recorder_handle_segments(p, axis, edge, wraps);
2201     }
2202     break;
2203
2204   case ta_serif_link1:
2205     {
2206       TA_Edge edge = (TA_Edge)arg1;
2207       TA_Edge before = arg2;
2208       TA_Edge after = arg3;
2209
2210
2211       *(p++) = 0;
2212       *(p++) = (FT_Byte)action + ACTION_OFFSET
2213                + (lower_bound != NULL)
2214                + 2 * (upper_bound != NULL);
2215
2216       *(p++) = HIGH(before->first - segments);
2217       *(p++) = LOW(before->first - segments);
2218       *(p++) = HIGH(edge->first - segments);
2219       *(p++) = LOW(edge->first - segments);
2220       *(p++) = HIGH(after->first - segments);
2221       *(p++) = LOW(after->first - segments);
2222
2223       if (lower_bound)
2224       {
2225         *(p++) = HIGH(lower_bound->first - segments);
2226         *(p++) = LOW(lower_bound->first - segments);
2227       }
2228       if (upper_bound)
2229       {
2230         *(p++) = HIGH(upper_bound->first - segments);
2231         *(p++) = LOW(upper_bound->first - segments);
2232       }
2233
2234       p = TA_hints_recorder_handle_segments(p, axis, edge, wraps);
2235     }
2236     break;
2237
2238   default:
2239     /* there are more cases in the enumeration */
2240     /* which are handled with flags */
2241     break;
2242   }
2243
2244   recorder->hints_record.num_actions++;
2245   recorder->hints_record.buf = p;
2246 }
2247
2248
2249 static FT_Error
2250 TA_init_recorder(Recorder* recorder,
2251                  SFNT* sfnt,
2252                  FONT* font,
2253                  GLYPH* glyph,
2254                  TA_GlyphHints hints)
2255 {
2256   TA_AxisHints axis = &hints->axis[TA_DIMENSION_VERT];
2257   TA_Point points = hints->points;
2258   TA_Point point_limit = points + hints->num_points;
2259   TA_Point point;
2260
2261   TA_Segment segments = axis->segments;
2262   TA_Segment seg_limit = segments + axis->num_segments;
2263   TA_Segment seg;
2264
2265   FT_UShort num_strong_points = 0;
2266   FT_UShort* wrap_around_segment;
2267
2268   recorder->sfnt = sfnt;
2269   recorder->font = font;
2270   recorder->glyph = glyph;
2271   recorder->num_segments = axis->num_segments;
2272
2273   LLRB_INIT(&recorder->ip_before_points_head);
2274   LLRB_INIT(&recorder->ip_after_points_head);
2275   LLRB_INIT(&recorder->ip_on_points_head);
2276   LLRB_INIT(&recorder->ip_between_points_head);
2277
2278   recorder->num_stack_elements = 0;
2279
2280   /* no need to clean up allocated arrays in case of error; */
2281   /* this is handled later by `TA_free_recorder' */
2282
2283   recorder->num_wrap_around_segments = 0;
2284   for (seg = segments; seg < seg_limit; seg++)
2285     if (seg->first > seg->last)
2286       recorder->num_wrap_around_segments++;
2287
2288   recorder->wrap_around_segments =
2289     (FT_UShort*)malloc(recorder->num_wrap_around_segments
2290                        * sizeof (FT_UShort));
2291   if (!recorder->wrap_around_segments)
2292     return FT_Err_Out_Of_Memory;
2293
2294   wrap_around_segment = recorder->wrap_around_segments;
2295   for (seg = segments; seg < seg_limit; seg++)
2296     if (seg->first > seg->last)
2297       *(wrap_around_segment++) = seg - segments;
2298
2299   /* get number of strong points */
2300   for (point = points; point < point_limit; point++)
2301   {
2302     /* actually, we need to test `TA_FLAG_TOUCH_Y' also; */
2303     /* however, this value isn't known yet */
2304     /* (or rather, it can vary between different pixel sizes) */
2305     if (point->flags & TA_FLAG_WEAK_INTERPOLATION)
2306       continue;
2307
2308     num_strong_points++;
2309   }
2310
2311   recorder->num_strong_points = num_strong_points;
2312
2313   return FT_Err_Ok;
2314 }
2315
2316
2317 static void
2318 TA_reset_recorder(Recorder* recorder,
2319                   FT_Byte* bufp)
2320 {
2321   recorder->hints_record.buf = bufp;
2322   recorder->hints_record.num_actions = 0;
2323 }
2324
2325
2326 static void
2327 TA_rewind_recorder(Recorder* recorder,
2328                    FT_Byte* bufp,
2329                    FT_UInt size)
2330 {
2331   Node1* before_node;
2332   Node1* after_node;
2333   Node2* on_node;
2334   Node3* between_node;
2335
2336   Node1* next_before_node;
2337   Node1* next_after_node;
2338   Node2* next_on_node;
2339   Node3* next_between_node;
2340
2341
2342   TA_reset_recorder(recorder, bufp);
2343
2344   recorder->hints_record.size = size;
2345
2346   /* deallocate our red-black trees */
2347
2348   for (before_node = LLRB_MIN(ip_before_points,
2349                               &recorder->ip_before_points_head);
2350        before_node;
2351        before_node = next_before_node)
2352   {
2353     next_before_node = LLRB_NEXT(ip_before_points,
2354                                  &recorder->ip_before_points_head,
2355                                  before_node);
2356     LLRB_REMOVE(ip_before_points,
2357                 &recorder->ip_before_points_head,
2358                 before_node);
2359     free(before_node);
2360   }
2361
2362   for (after_node = LLRB_MIN(ip_after_points,
2363                              &recorder->ip_after_points_head);
2364        after_node;
2365        after_node = next_after_node)
2366   {
2367     next_after_node = LLRB_NEXT(ip_after_points,
2368                                 &recorder->ip_after_points_head,
2369                                 after_node);
2370     LLRB_REMOVE(ip_after_points,
2371                 &recorder->ip_after_points_head,
2372                 after_node);
2373     free(after_node);
2374   }
2375
2376   for (on_node = LLRB_MIN(ip_on_points,
2377                           &recorder->ip_on_points_head);
2378        on_node;
2379        on_node = next_on_node)
2380   {
2381     next_on_node = LLRB_NEXT(ip_on_points,
2382                              &recorder->ip_on_points_head,
2383                              on_node);
2384     LLRB_REMOVE(ip_on_points,
2385                 &recorder->ip_on_points_head,
2386                 on_node);
2387     free(on_node);
2388   }
2389
2390   for (between_node = LLRB_MIN(ip_between_points,
2391                                &recorder->ip_between_points_head);
2392        between_node;
2393        between_node = next_between_node)
2394   {
2395     next_between_node = LLRB_NEXT(ip_between_points,
2396                                   &recorder->ip_between_points_head,
2397                                   between_node);
2398     LLRB_REMOVE(ip_between_points,
2399                 &recorder->ip_between_points_head,
2400                 between_node);
2401     free(between_node);
2402   }
2403 }
2404
2405
2406 static void
2407 TA_free_recorder(Recorder* recorder)
2408 {
2409   free(recorder->wrap_around_segments);
2410
2411   TA_rewind_recorder(recorder, NULL, 0);
2412 }
2413
2414
2415 FT_Error
2416 TA_sfnt_build_glyph_instructions(SFNT* sfnt,
2417                                  FONT* font,
2418                                  FT_Long idx)
2419 {
2420   FT_Face face = sfnt->face;
2421   FT_Error error;
2422
2423   FT_Byte* ins_buf;
2424   FT_UInt ins_len;
2425   FT_Byte* bufp;
2426   FT_Byte* p;
2427
2428   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
2429   glyf_Data* data = (glyf_Data*)glyf_table->data;
2430   /* `idx' is never negative */
2431   GLYPH* glyph = &data->glyphs[idx];
2432
2433   TA_GlyphHints hints;
2434
2435   FT_UInt num_action_hints_records = 0;
2436   FT_UInt num_point_hints_records = 0;
2437   Hints_Record* action_hints_records = NULL;
2438   Hints_Record* point_hints_records = NULL;
2439
2440   Recorder recorder;
2441   FT_UShort num_stack_elements;
2442   FT_Bool optimize = 0;
2443
2444   FT_Int32 load_flags;
2445   FT_UInt size;
2446
2447   FT_Byte* pos[3];
2448
2449 #ifdef TA_DEBUG
2450   int _ta_debug_save;
2451 #endif
2452
2453
2454   /* XXX: right now, we abuse this flag to control */
2455   /*      the global behaviour of the auto-hinter */
2456   load_flags = 1 << 29; /* vertical hinting only */
2457   if (!font->adjust_subglyphs)
2458   {
2459     if (font->hint_composites)
2460       load_flags |= FT_LOAD_NO_SCALE;
2461     else
2462       load_flags |= FT_LOAD_NO_RECURSE;
2463   }
2464
2465   /* computing the segments is resolution independent, */
2466   /* thus the pixel size in this call is arbitrary -- */
2467   /* however, we avoid unnecessary debugging output */
2468   /* if we use the lowest value of the hinting range */
2469   error = FT_Set_Pixel_Sizes(face,
2470                              font->hinting_range_min,
2471                              font->hinting_range_min);
2472   if (error)
2473     return error;
2474
2475   /* this data is needed for `ta_glyph_hints_reload' (in file `tahints.c') */
2476   /* to modify `out' directions of points at the user's request */
2477   /* (which will eventually become single-point segments) */
2478   error = TA_control_segment_dir_collect(font, face->face_index, idx);
2479   if (error)
2480     return error;
2481
2482 #ifdef TA_DEBUG
2483   /* temporarily disable some debugging output */
2484   /* to avoid getting the information twice */
2485   _ta_debug_save = _ta_debug;
2486   _ta_debug = 0;
2487 #endif
2488
2489   ta_loader_register_hints_recorder(font->loader, NULL, NULL);
2490   error = ta_loader_load_glyph(font, face, (FT_UInt)idx, load_flags);
2491
2492 #ifdef TA_DEBUG
2493   _ta_debug = _ta_debug_save;
2494 #endif
2495
2496   if (error)
2497     return error;
2498
2499   /* do nothing if we have an empty glyph */
2500   if (!face->glyph->outline.n_contours)
2501     return FT_Err_Ok;
2502
2503   hints = &font->loader->hints;
2504
2505   /* do nothing if the setup delivered the `none_dflt' style only */
2506   if (!hints->num_points)
2507     return FT_Err_Ok;
2508
2509   /*
2510    * We allocate a buffer which is certainly large enough
2511    * to hold all of the created bytecode instructions;
2512    * later on it gets reallocated to its real size.
2513    *
2514    * The value `1000' is a very rough guess, not tested well.
2515    *
2516    * For delta exceptions, we have three DELTA commands,
2517    * covering 3*16 ppem values.
2518    * Since a point index can be larger than 255,
2519    * we assume two bytes everywhere for the necessary PUSH calls.
2520    * This value must be doubled for the other arguments of DELTA.
2521    * Additionally, we have both x and y deltas,
2522    * which need to be handled separately in the bytecode.
2523    * In summary, this is approx. 3*16 * 2*2 * 2 = 400 bytes per point,
2524    * adding some bytes for the necessary overhead.
2525    */
2526   ins_len = hints->num_points
2527             * (1000 + ((font->control_data_head != NULL) ? 400 : 0));
2528   ins_buf = (FT_Byte*)malloc(ins_len);
2529   if (!ins_buf)
2530     return FT_Err_Out_Of_Memory;
2531
2532   /* handle composite glyph */
2533   if (font->loader->gloader->base.num_subglyphs)
2534   {
2535     bufp = TA_font_build_subglyph_shifter(font, ins_buf);
2536     if (!bufp)
2537     {
2538       error = FT_Err_Out_Of_Memory;
2539       goto Err;
2540     }
2541
2542     goto Done1;
2543   }
2544
2545   /* only scale the glyph if the `none_dflt' style has been used */
2546   if (font->loader->metrics->style_class == &ta_none_dflt_style_class)
2547   {
2548     /* since `TA_init_recorder' hasn't been called yet, */
2549     /* we manually initialize the `sfnt', `font', and `glyph' fields */
2550     recorder.sfnt = sfnt;
2551     recorder.font = font;
2552     recorder.glyph = glyph;
2553
2554     bufp = TA_sfnt_build_glyph_scaler(sfnt, &recorder, ins_buf);
2555     if (!bufp)
2556     {
2557       error = FT_Err_Out_Of_Memory;
2558       goto Err;
2559     }
2560
2561     goto Done1;
2562   }
2563
2564   error = TA_init_recorder(&recorder, sfnt, font, glyph, hints);
2565   if (error)
2566     goto Err;
2567
2568   /* loop over a large range of pixel sizes */
2569   /* to find hints records which get pushed onto the bytecode stack */
2570
2571 #ifdef DEBUGGING
2572   if (font->debug)
2573   {
2574     int num_chars, i;
2575     char buf[256];
2576
2577
2578     (void)FT_Get_Glyph_Name(face, idx, buf, 256);
2579
2580     num_chars = fprintf(stderr, "glyph %ld", idx);
2581     if (*buf)
2582       num_chars += fprintf(stderr, " (%s)", buf);
2583     fprintf(stderr, "\n");
2584     for (i = 0; i < num_chars; i++)
2585       putc('=', stderr);
2586     fprintf(stderr, "\n\n");
2587
2588   }
2589 #endif
2590
2591   /* we temporarily use `ins_buf' to record the current glyph hints */
2592   ta_loader_register_hints_recorder(font->loader,
2593                                     TA_hints_recorder,
2594                                     (void*)&recorder);
2595
2596   for (size = font->hinting_range_min;
2597        size <= font->hinting_range_max;
2598        size++)
2599   {
2600 #ifdef DEBUGGING
2601     int have_dumps = 0;
2602 #endif
2603
2604
2605     TA_rewind_recorder(&recorder, ins_buf, size);
2606
2607     error = FT_Set_Pixel_Sizes(face, size, size);
2608     if (error)
2609       goto Err;
2610
2611 #ifdef DEBUGGING
2612     if (font->debug)
2613     {
2614       int num_chars, i;
2615
2616
2617       num_chars = fprintf(stderr, "size %d\n", size);
2618       for (i = 0; i < num_chars - 1; i++)
2619         putc('-', stderr);
2620       fprintf(stderr, "\n\n");
2621     }
2622 #endif
2623
2624     /* calling `ta_loader_load_glyph' uses the */
2625     /* `TA_hints_recorder' function as a callback, */
2626     /* modifying `hints_record' */
2627     error = ta_loader_load_glyph(font, face, idx, load_flags);
2628     if (error)
2629       goto Err;
2630
2631     if (TA_hints_record_is_different(action_hints_records,
2632                                      num_action_hints_records,
2633                                      ins_buf, recorder.hints_record.buf))
2634     {
2635 #ifdef DEBUGGING
2636       if (font->debug)
2637       {
2638         have_dumps = 1;
2639
2640         ta_glyph_hints_dump_edges((TA_GlyphHints)_ta_debug_hints);
2641         ta_glyph_hints_dump_segments((TA_GlyphHints)_ta_debug_hints);
2642         ta_glyph_hints_dump_points((TA_GlyphHints)_ta_debug_hints);
2643
2644         fprintf(stderr, "action hints record:\n");
2645         if (ins_buf == recorder.hints_record.buf)
2646           fprintf(stderr, "  (none)");
2647         else
2648         {
2649           fprintf(stderr, "  ");
2650           for (p = ins_buf; p < recorder.hints_record.buf; p += 2)
2651             fprintf(stderr, " %2d", *p * 256 + *(p + 1));
2652         }
2653         fprintf(stderr, "\n");
2654       }
2655 #endif
2656
2657       error = TA_add_hints_record(&action_hints_records,
2658                                   &num_action_hints_records,
2659                                   ins_buf, recorder.hints_record);
2660       if (error)
2661         goto Err;
2662     }
2663
2664     /* now handle point records */
2665
2666     TA_reset_recorder(&recorder, ins_buf);
2667
2668     /* use the point hints data collected in `TA_hints_recorder' */
2669     TA_build_point_hints(&recorder, hints);
2670
2671     if (TA_hints_record_is_different(point_hints_records,
2672                                      num_point_hints_records,
2673                                      ins_buf, recorder.hints_record.buf))
2674     {
2675 #ifdef DEBUGGING
2676       if (font->debug)
2677       {
2678         if (!have_dumps)
2679         {
2680           int num_chars, i;
2681
2682
2683           num_chars = fprintf(stderr, "size %d\n", size);
2684           for (i = 0; i < num_chars - 1; i++)
2685             putc('-', stderr);
2686           fprintf(stderr, "\n\n");
2687
2688           ta_glyph_hints_dump_edges((TA_GlyphHints)_ta_debug_hints);
2689           ta_glyph_hints_dump_segments((TA_GlyphHints)_ta_debug_hints);
2690           ta_glyph_hints_dump_points((TA_GlyphHints)_ta_debug_hints);
2691         }
2692
2693         fprintf(stderr, "point hints record:\n");
2694         if (ins_buf == recorder.hints_record.buf)
2695           fprintf(stderr, "  (none)");
2696         else
2697         {
2698           fprintf(stderr, "  ");
2699           for (p = ins_buf; p < recorder.hints_record.buf; p += 2)
2700             fprintf(stderr, " %2d", *p * 256 + *(p + 1));
2701         }
2702         fprintf(stderr, "\n\n");
2703       }
2704 #endif
2705
2706       error = TA_add_hints_record(&point_hints_records,
2707                                   &num_point_hints_records,
2708                                   ins_buf, recorder.hints_record);
2709       if (error)
2710         goto Err;
2711     }
2712   }
2713
2714   if (num_action_hints_records == 1 && !action_hints_records[0].num_actions)
2715   {
2716     /* since we only have a single empty record we just scale the glyph */
2717     bufp = TA_sfnt_build_glyph_scaler(sfnt, &recorder, ins_buf);
2718     if (!bufp)
2719     {
2720       error = FT_Err_Out_Of_Memory;
2721       goto Err;
2722     }
2723
2724     goto Done;
2725   }
2726
2727   /* if there is only a single record, */
2728   /* we do a global optimization later on */
2729   if (num_action_hints_records > 1)
2730     optimize = 1;
2731
2732   /* store the hints records and handle stack depth */
2733   pos[0] = ins_buf;
2734   bufp = TA_emit_hints_records(&recorder,
2735                                point_hints_records,
2736                                num_point_hints_records,
2737                                ins_buf,
2738                                optimize);
2739
2740   num_stack_elements = recorder.num_stack_elements;
2741   recorder.num_stack_elements = 0;
2742
2743   pos[1] = bufp;
2744   bufp = TA_emit_hints_records(&recorder,
2745                                action_hints_records,
2746                                num_action_hints_records,
2747                                bufp,
2748                                optimize);
2749
2750   recorder.num_stack_elements += num_stack_elements;
2751
2752   pos[2] = bufp;
2753   bufp = TA_sfnt_build_glyph_segments(sfnt, &recorder, bufp, optimize);
2754   if (!bufp)
2755   {
2756     error = FT_Err_Out_Of_Memory;
2757     goto Err;
2758   }
2759
2760   if (num_action_hints_records == 1)
2761     bufp = TA_optimize_push(ins_buf, pos);
2762
2763 Done:
2764   TA_free_hints_records(action_hints_records, num_action_hints_records);
2765   TA_free_hints_records(point_hints_records, num_point_hints_records);
2766   TA_free_recorder(&recorder);
2767
2768 Done1:
2769   /* handle delta exceptions */
2770   if (font->control_data_head)
2771   {
2772     bufp = TA_sfnt_build_delta_exceptions(sfnt, font, idx, bufp);
2773     if (!bufp)
2774     {
2775       error = FT_Err_Out_Of_Memory;
2776       goto Err;
2777     }
2778   }
2779
2780   ins_len = bufp - ins_buf;
2781
2782   if (ins_len > sfnt->max_instructions)
2783     sfnt->max_instructions = ins_len;
2784
2785   glyph->ins_buf = (FT_Byte*)realloc(ins_buf, ins_len);
2786   glyph->ins_len = ins_len;
2787
2788   return FT_Err_Ok;
2789
2790 Err:
2791   TA_free_hints_records(action_hints_records, num_action_hints_records);
2792   TA_free_hints_records(point_hints_records, num_point_hints_records);
2793   TA_free_recorder(&recorder);
2794   free(ins_buf);
2795
2796   return error;
2797 }
2798
2799
2800 /* end of tabytecode.c */