src/tabytecode.c

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