src/tabytecode.c

   1 /* tabytecode.c */
   2
   3 /* written 2011 by Werner Lemberg <wl@gnu.org> */
   4
   5 #include "ta.h"
   6 #include "tabytecode.h"
   7
   8
   9 /* a simple macro to emit bytecode instructions */
  10 #define BCI(code) *(bufp++) = (code)
  11
  12 /* we increase the stack depth by amount */
  13 #define ADDITIONAL_STACK_ELEMENTS 20
  14
  15
  16 #ifdef TA_DEBUG
  17 int _ta_debug = 1;
  18 int _ta_debug_disable_horz_hints;
  19 int _ta_debug_disable_vert_hints;
  20 int _ta_debug_disable_blue_hints;
  21 void* _ta_debug_hints;
  22 #endif
  23
  24
  25 /* structures for hinting sets */
  26 typedef struct Edge2Blue_ {
  27   FT_UInt first_segment;
  28
  29   FT_Bool is_serif;
  30   FT_Bool is_round;
  31
  32   FT_UInt num_remaining_segments;
  33   FT_UInt* remaining_segments;
  34 } Edge2Blue;
  35
  36 typedef struct Edge2Link_ {
  37   FT_UInt first_segment;
  38
  39   FT_UInt num_remaining_segments;
  40   FT_UInt* remaining_segments;
  41 } Edge2Link;
  42
  43 typedef struct Hinting_Set_ {
  44   FT_UInt size;
  45
  46   FT_UInt num_edges2blues;
  47   Edge2Blue* edges2blues;
  48
  49   FT_UInt num_edges2links;
  50   Edge2Link* edges2links;
  51
  52   FT_Bool need_words;
  53   FT_UInt num_args;
  54 } Hinting_Set;
  55
  56
  57 static FT_Error
  58 TA_sfnt_compute_global_hints(SFNT* sfnt,
  59                              FONT* font)
  60 {
  61   FT_Error error;
  62   FT_Face face = sfnt->face;
  63   FT_UInt enc;
  64   FT_UInt idx;
  65
  66   static const FT_Encoding latin_encs[] =
  67   {
  68     FT_ENCODING_UNICODE,
  69     FT_ENCODING_APPLE_ROMAN,
  70     FT_ENCODING_ADOBE_STANDARD,
  71     FT_ENCODING_ADOBE_LATIN_1,
  72
  73     FT_ENCODING_NONE /* end of list */
  74   };
  75
  76
  77   error = ta_loader_init(font->loader);
  78   if (error)
  79     return error;
  80
  81   /* try to select a latin charmap */
  82   for (enc = 0; latin_encs[enc] != FT_ENCODING_NONE; enc++)
  83   {
  84     error = FT_Select_Charmap(face, latin_encs[enc]);
  85     if (!error)
  86       break;
  87   }
  88
  89   /* load latin glyph `a' to trigger all initializations */
  90   idx = FT_Get_Char_Index(face, 'a');
  91   error = ta_loader_load_glyph(font->loader, face, idx, 0);
  92
  93   return error;
  94 }
  95
  96
  97 static FT_Error
  98 TA_table_build_cvt(FT_Byte** cvt,
  99                    FT_ULong* cvt_len,
 100                    SFNT* sfnt,
 101                    FONT* font)
 102 {
 103   TA_LatinAxis haxis;
 104   TA_LatinAxis vaxis;
 105
 106   FT_UInt i;
 107   FT_UInt buf_len;
 108   FT_UInt len;
 109   FT_Byte* buf;
 110   FT_Byte* buf_p;
 111
 112   FT_Error error;
 113
 114
 115   error = TA_sfnt_compute_global_hints(sfnt, font);
 116   if (error)
 117     return error;
 118
 119   /* XXX check validity of pointers */
 120   haxis = &((TA_LatinMetrics)font->loader->hints.metrics)->axis[0];
 121   vaxis = &((TA_LatinMetrics)font->loader->hints.metrics)->axis[1];
 122
 123   buf_len = 2 * (2
 124                  + haxis->width_count
 125                  + vaxis->width_count
 126                  + 2 * vaxis->blue_count);
 127
 128   /* buffer length must be a multiple of four */
 129   len = (buf_len + 3) & ~3;
 130   buf = (FT_Byte*)malloc(len);
 131   if (!buf)
 132     return FT_Err_Out_Of_Memory;
 133
 134   /* pad end of buffer with zeros */
 135   buf[len - 1] = 0x00;
 136   buf[len - 2] = 0x00;
 137   buf[len - 3] = 0x00;
 138
 139   buf_p = buf;
 140
 141   if (haxis->width_count > 0)
 142   {
 143     *(buf_p++) = HIGH(haxis->widths[0].org);
 144     *(buf_p++) = LOW(haxis->widths[0].org);
 145   }
 146   else
 147   {
 148     *(buf_p++) = 0;
 149     *(buf_p++) = 50;
 150   }
 151   if (vaxis->width_count > 0)
 152   {
 153     *(buf_p++) = HIGH(vaxis->widths[0].org);
 154     *(buf_p++) = LOW(vaxis->widths[0].org);
 155   }
 156   else
 157   {
 158     *(buf_p++) = 0;
 159     *(buf_p++) = 50;
 160   }
 161
 162   for (i = 0; i < haxis->width_count; i++)
 163   {
 164     if (haxis->widths[i].org > 0xFFFF)
 165       goto Err;
 166     *(buf_p++) = HIGH(haxis->widths[i].org);
 167     *(buf_p++) = LOW(haxis->widths[i].org);
 168   }
 169
 170   for (i = 0; i < vaxis->width_count; i++)
 171   {
 172     if (vaxis->widths[i].org > 0xFFFF)
 173       goto Err;
 174     *(buf_p++) = HIGH(vaxis->widths[i].org);
 175     *(buf_p++) = LOW(vaxis->widths[i].org);
 176   }
 177
 178   for (i = 0; i < vaxis->blue_count; i++)
 179   {
 180     if (vaxis->blues[i].ref.org > 0xFFFF)
 181       goto Err;
 182     *(buf_p++) = HIGH(vaxis->blues[i].ref.org);
 183     *(buf_p++) = LOW(vaxis->blues[i].ref.org);
 184   }
 185
 186   for (i = 0; i < vaxis->blue_count; i++)
 187   {
 188     if (vaxis->blues[i].shoot.org > 0xFFFF)
 189       goto Err;
 190     *(buf_p++) = HIGH(vaxis->blues[i].shoot.org);
 191     *(buf_p++) = LOW(vaxis->blues[i].shoot.org);
 192   }
 193
 194 #if 0
 195   TA_LOG(("--------------------------------------------------\n"));
 196   TA_LOG(("glyph %d:\n", idx));
 197   ta_glyph_hints_dump_edges(_ta_debug_hints);
 198   ta_glyph_hints_dump_segments(_ta_debug_hints);
 199   ta_glyph_hints_dump_points(_ta_debug_hints);
 200 #endif
 201
 202   *cvt = buf;
 203   *cvt_len = buf_len;
 204
 205   return FT_Err_Ok;
 206
 207 Err:
 208   free(buf);
 209   return TA_Err_Hinter_Overflow;
 210 }
 211
 212
 213 FT_Error
 214 TA_sfnt_build_cvt_table(SFNT* sfnt,
 215                         FONT* font)
 216 {
 217   FT_Error error;
 218
 219   FT_Byte* cvt_buf;
 220   FT_ULong cvt_len;
 221
 222
 223   error = TA_sfnt_add_table_info(sfnt);
 224   if (error)
 225     return error;
 226
 227   error = TA_table_build_cvt(&cvt_buf, &cvt_len, sfnt, font);
 228   if (error)
 229     return error;
 230
 231   /* in case of success, `cvt_buf' gets linked */
 232   /* and is eventually freed in `TA_font_unload' */
 233   error = TA_font_add_table(font,
 234                             &sfnt->table_infos[sfnt->num_table_infos - 1],
 235                             TTAG_cvt, cvt_len, cvt_buf);
 236   if (error)
 237   {
 238     free(cvt_buf);
 239     return error;
 240   }
 241
 242   return FT_Err_Ok;
 243 }
 244
 245
 246 /* the horizontal and vertical standard widths */
 247 #define CVT_HORZ_STANDARD_WIDTH_OFFSET(font) 0
 248 #define CVT_VERT_STANDARD_WIDTH_OFFSET(font) \
 249           CVT_HORZ_STANDARD_WIDTH_OFFSET(font) + 1
 250
 251 /* the horizontal stem widths */
 252 #define CVT_HORZ_WIDTHS_OFFSET(font) \
 253           CVT_VERT_STANDARD_WIDTH_OFFSET(font) + 1
 254 #define CVT_HORZ_WIDTHS_SIZE(font) \
 255           ((TA_LatinMetrics)font->loader->hints.metrics)->axis[0].width_count
 256
 257 /* the vertical stem widths */
 258 #define CVT_VERT_WIDTHS_OFFSET(font) \
 259           CVT_HORZ_WIDTHS_OFFSET(font) + CVT_HORZ_WIDTHS_SIZE(font)
 260 #define CVT_VERT_WIDTHS_SIZE(font) \
 261           ((TA_LatinMetrics)font->loader->hints.metrics)->axis[1].width_count
 262
 263 /* the number of blue zones */
 264 #define CVT_BLUES_SIZE(font) \
 265           ((TA_LatinMetrics)font->loader->hints.metrics)->axis[1].blue_count
 266
 267 /* the blue zone values for flat and round edges */
 268 #define CVT_BLUE_REFS_OFFSET(font) \
 269           CVT_VERT_WIDTHS_OFFSET(font) + CVT_VERT_WIDTHS_SIZE(font)
 270 #define CVT_BLUE_SHOOTS_OFFSET(font) \
 271           CVT_BLUE_REFS_OFFSET(font) + CVT_BLUES_SIZE(font)
 272
 273
 274 /* symbolic names for storage area locations */
 275
 276 #define sal_counter 0
 277 #define sal_limit sal_counter + 1
 278 #define sal_scale sal_limit + 1
 279 #define sal_0x10000 sal_scale + 1
 280 #define sal_is_extra_light sal_0x10000 + 1
 281 #define sal_segment_offset sal_is_extra_light + 1 /* must be last */
 282
 283
 284 /* we need the following macro */
 285 /* so that `func_name' doesn't get replaced with its #defined value */
 286 /* (as defined in `tabytecode.h') */
 287
 288 #define FPGM(func_name) fpgm_ ## func_name
 289
 290
 291 /* in the comments below, the top of the stack (`s:') */
 292 /* is the rightmost element; the stack is shown */
 293 /* after the instruction on the same line has been executed */
 294
 295 /*
 296  * bci_compute_stem_width
 297  *
 298  *   This is the equivalent to the following code from function
 299  *   `ta_latin_compute_stem_width':
 300  *
 301  *      dist = ABS(width)
 302  *
 303  *      if (stem_is_serif
 304  *          && dist < 3*64)
 305  *         || is_extra_light:
 306  *        return width
 307  *      else if base_is_round:
 308  *        if dist < 80
 309  *          dist = 64
 310  *      else:
 311  *        dist = MIN(56, dist)
 312  *
 313  *      delta = ABS(dist - std_width)
 314  *
 315  *      if delta < 40:
 316  *        dist = MIN(48, std_width)
 317  *        goto End
 318  *
 319  *      if dist < 3*64:
 320  *        delta = dist
 321  *        dist = FLOOR(dist)
 322  *        delta = delta - dist
 323  *
 324  *        if delta < 10:
 325  *          dist = dist + delta
 326  *        else if delta < 32:
 327  *          dist = dist + 10
 328  *        else if delta < 54:
 329  *          dist = dist + 54
 330  *        else
 331  *          dist = dist + delta
 332  *      else
 333  *        dist = ROUND(dist)
 334  *
 335  *    End:
 336  *      if width < 0:
 337  *        dist = -dist
 338  *      return dist
 339  *
 340  *
 341  * in: width
 342  *     stem_is_serif
 343  *     base_is_round
 344  * out: new_width
 345  * sal: is_extra_light
 346  * CVT: std_width
 347  */
 348
 349 unsigned char FPGM(bci_compute_stem_width_a) [] = {
 350
 351   PUSHB_1,
 352     bci_compute_stem_width,
 353   FDEF,
 354
 355   DUP,
 356   ABS, /* s: base_is_round stem_is_serif width dist */
 357
 358   DUP,
 359   PUSHB_1,
 360     3*64,
 361   LT, /* dist < 3*64 */
 362
 363   PUSHB_1,
 364     4,
 365   MINDEX, /* s: base_is_round width dist (dist<3*64) stem_is_serif */
 366   AND, /* stem_is_serif && dist < 3*64 */
 367
 368   PUSHB_1,
 369     sal_is_extra_light,
 370   RS,
 371   OR, /* (stem_is_serif && dist < 3*64) || is_extra_light */
 372
 373   IF, /* s: base_is_round width dist */
 374     POP,
 375     SWAP,
 376     POP, /* s: width */
 377
 378   ELSE,
 379     ROLL, /* s: width dist base_is_round */
 380     IF, /* s: width dist */
 381       DUP,
 382       PUSHB_1,
 383         80,
 384       LT, /* dist < 80 */
 385       IF, /* s: width dist */
 386         POP,
 387         PUSHB_1,
 388           64, /* dist = 64 */
 389       EIF,
 390
 391     ELSE,
 392       PUSHB_1,
 393         56,
 394       MIN, /* dist = min(56, dist) */
 395     EIF,
 396
 397     DUP, /* s: width dist dist */
 398     PUSHB_1,
 399
 400 };
 401
 402 /*    %c, index of std_width */
 403
 404 unsigned char FPGM(bci_compute_stem_width_b) [] = {
 405
 406     RCVT,
 407     SUB,
 408     ABS, /* s: width dist delta */
 409
 410     PUSHB_1,
 411       40,
 412     LT, /* delta < 40 */
 413     IF, /* s: width dist */
 414       POP,
 415       PUSHB_2,
 416         48,
 417
 418 };
 419
 420 /*      %c, index of std_width */
 421
 422 unsigned char FPGM(bci_compute_stem_width_c) [] = {
 423
 424       RCVT,
 425       MIN, /* dist = min(48, std_width) */
 426
 427     ELSE,
 428       DUP, /* s: width dist dist */
 429       PUSHB_1,
 430         3*64,
 431       LT, /* dist < 3*64 */
 432       IF,
 433         DUP, /* s: width delta dist */
 434         FLOOR, /* dist = FLOOR(dist) */
 435         DUP, /* s: width delta dist dist */
 436         ROLL,
 437         ROLL, /* s: width dist delta dist */
 438         SUB, /* delta = delta - dist */
 439
 440         DUP, /* s: width dist delta delta */
 441         PUSHB_1,
 442           10,
 443         LT, /* delta < 10 */
 444         IF, /* s: width dist delta */
 445           ADD, /* dist = dist + delta */
 446
 447         ELSE,
 448           DUP,
 449           PUSHB_1,
 450             32,
 451           LT, /* delta < 32 */
 452           IF,
 453             POP,
 454             PUSHB_1,
 455               10,
 456             ADD, /* dist = dist + 10 */
 457
 458           ELSE,
 459             DUP,
 460             PUSHB_1,
 461               54,
 462             LT, /* delta < 54 */
 463             IF,
 464               POP,
 465               PUSHB_1,
 466                 54,
 467               ADD, /* dist = dist + 54 */
 468
 469             ELSE,
 470               ADD, /* dist = dist + delta */
 471
 472             EIF,
 473           EIF,
 474         EIF,
 475
 476         ELSE,
 477           PUSHB_1,
 478             32,
 479           ADD,
 480           FLOOR, /* dist = round(dist) */
 481
 482         EIF,
 483       EIF,
 484
 485       SWAP, /* s: dist width */
 486       PUSHB_1,
 487         0,
 488       LT, /* width < 0 */
 489       IF,
 490         NEG, /* dist = -dist */
 491       EIF,
 492     EIF,
 493   EIF,
 494
 495   ENDF,
 496
 497 };
 498
 499
 500 /*
 501  * bci_loop
 502  *
 503  *   Take a range and a function number and apply the function to all
 504  *   elements of the range.  The called function must not change the
 505  *   stack.
 506  *
 507  * in: func_num
 508  *     end
 509  *     start
 510  *
 511  * uses: sal_counter (counter initialized with `start')
 512  *       sal_limit (`end')
 513  */
 514
 515 unsigned char FPGM(bci_loop) [] = {
 516
 517   PUSHB_1,
 518     bci_loop,
 519   FDEF,
 520
 521   ROLL,
 522   ROLL, /* s: func_num start end */
 523   PUSHB_1,
 524     sal_limit,
 525   SWAP,
 526   WS,
 527
 528   PUSHB_1,
 529     sal_counter,
 530   SWAP,
 531   WS,
 532
 533 /* start_loop: */
 534   PUSHB_1,
 535     sal_counter,
 536   RS,
 537   PUSHB_1,
 538     sal_limit,
 539   RS,
 540   LTEQ, /* start <= end */
 541   IF, /* s: func_num */
 542     DUP,
 543     CALL,
 544     PUSHB_2,
 545       1,
 546       sal_counter,
 547     RS,
 548     ADD, /* start = start + 1 */
 549     PUSHB_1,
 550       sal_counter,
 551     SWAP,
 552     WS,
 553
 554     PUSHB_1,
 555       22,
 556     NEG,
 557     JMPR, /* goto start_loop */
 558   ELSE,
 559     POP,
 560   EIF,
 561
 562   ENDF,
 563
 564 };
 565
 566
 567 /*
 568  * bci_cvt_rescale
 569  *
 570  *   Rescale CVT value by a given factor.
 571  *
 572  * uses: sal_counter (CVT index)
 573  *       sal_scale (scale in 16.16 format)
 574  */
 575
 576 unsigned char FPGM(bci_cvt_rescale) [] = {
 577
 578   PUSHB_1,
 579     bci_cvt_rescale,
 580   FDEF,
 581
 582   PUSHB_1,
 583     sal_counter,
 584   RS,
 585   DUP,
 586   RCVT,
 587   PUSHB_1,
 588     sal_scale,
 589   RS,
 590   MUL, /* CVT * scale * 2^10 */
 591   PUSHB_1,
 592     sal_0x10000,
 593   RS,
 594   DIV, /* CVT * scale */
 595
 596   WCVTP,
 597
 598   ENDF,
 599
 600 };
 601
 602
 603 /*
 604  * bci_loop_sal_assign
 605  *
 606  *   Apply the WS instruction repeatedly to stack data.
 607  *
 608  * in: counter (N)
 609  *     offset
 610  *     data_0
 611  *     data_1
 612  *     ...
 613  *     data_(N-1)
 614  *
 615  * uses: bci_sal_assign
 616  */
 617
 618 unsigned char FPGM(bci_sal_assign) [] = {
 619
 620   PUSHB_1,
 621     bci_sal_assign,
 622   FDEF,
 623
 624   DUP,
 625   ROLL, /* s: offset offset data */
 626   WS,
 627
 628   PUSHB_1,
 629     1,
 630   ADD, /* s: (offset + 1) */
 631
 632   ENDF,
 633
 634 };
 635
 636 unsigned char FPGM(bci_loop_sal_assign) [] = {
 637
 638   PUSHB_1,
 639     bci_loop_sal_assign,
 640   FDEF,
 641
 642   /* process the stack, popping off the elements in a loop */
 643   PUSHB_1,
 644     bci_sal_assign,
 645   LOOPCALL,
 646
 647   /* clean up stack */
 648   POP,
 649
 650   ENDF,
 651
 652 };
 653
 654
 655 /*
 656  * bci_blue_round
 657  *
 658  *   Round a blue ref value and adjust its corresponding shoot value.
 659  *
 660  * uses: sal_counter (CVT index)
 661  *
 662  */
 663
 664 unsigned char FPGM(bci_blue_round_a) [] = {
 665
 666   PUSHB_1,
 667     bci_blue_round,
 668   FDEF,
 669
 670   PUSHB_1,
 671     sal_counter,
 672   RS,
 673   DUP,
 674   RCVT, /* s: ref_idx ref */
 675
 676   DUP,
 677   PUSHB_1,
 678     32,
 679   ADD,
 680   FLOOR,
 681   SWAP, /* s: ref_idx round(ref) ref */
 682
 683   PUSHB_2,
 684
 685 };
 686
 687 /*  %c, blue_count */
 688
 689 unsigned char FPGM(bci_blue_round_b) [] = {
 690
 691     4,
 692   CINDEX,
 693   ADD, /* s: ref_idx round(ref) ref shoot_idx */
 694   DUP,
 695   RCVT, /* s: ref_idx round(ref) ref shoot_idx shoot */
 696
 697   ROLL, /* s: ref_idx round(ref) shoot_idx shoot ref */
 698   SWAP,
 699   SUB, /* s: ref_idx round(ref) shoot_idx dist */
 700   DUP,
 701   ABS, /* s: ref_idx round(ref) shoot_idx dist delta */
 702
 703   DUP,
 704   PUSHB_1,
 705     32,
 706   LT, /* delta < 32 */
 707   IF,
 708     POP,
 709     PUSHB_1,
 710       0, /* delta = 0 */
 711
 712   ELSE,
 713     PUSHB_1,
 714       48,
 715     LT, /* delta < 48 */
 716     IF,
 717       PUSHB_1,
 718         32, /* delta = 32 */
 719
 720     ELSE,
 721       PUSHB_1,
 722         64, /* delta = 64 */
 723     EIF,
 724   EIF,
 725
 726   SWAP, /* s: ref_idx round(ref) shoot_idx delta dist */
 727   PUSHB_1,
 728     0,
 729   LT, /* dist < 0 */
 730   IF,
 731     NEG, /* delta = -delta */
 732   EIF,
 733
 734   PUSHB_1,
 735     3,
 736   CINDEX,
 737   ADD, /* s: ref_idx round(ref) shoot_idx (round(ref) + delta) */
 738
 739   WCVTP,
 740   WCVTP,
 741
 742   ENDF,
 743
 744 };
 745
 746
 747 /*
 748  * bci_hint_glyph
 749  *
 750  *   This is the top-level glyph hinting function
 751  *   which parses the arguments on the stack and calls subroutines.
 752  *
 753  * in: num_edges2blues (M)
 754  *       edge2blue_0.first_segment
 755  *                  .is_serif
 756  *                  .is_round
 757  *                  .num_remaining_segments (N)
 758  *                  .remaining_segments_0
 759  *                                     _1
 760  *                                     ...
 761  *                                     _(N-1)
 762  *                _1
 763  *                ...
 764  *                _(M-1)
 765  *
 766  *     num_edges2links (P)
 767  *       edge2link_0.first_segment
 768  *                  .num_remaining_segments (Q)
 769  *                  .remaining_segments_0
 770  *                                     _1
 771  *                                     ...
 772  *                                     _(Q-1)
 773  *                _1
 774  *                ...
 775  *                _(P-1)
 776  *
 777  * uses: bci_edge2blue
 778  *       bci_edge2link
 779  */
 780
 781 unsigned char FPGM(bci_remaining_edges) [] = {
 782
 783   PUSHB_1,
 784     bci_remaining_edges,
 785   FDEF,
 786
 787   POP, /* XXX remaining segment */
 788
 789   ENDF,
 790
 791 };
 792
 793 unsigned char FPGM(bci_edge2blue) [] = {
 794
 795   PUSHB_1,
 796     bci_edge2blue,
 797   FDEF,
 798
 799   POP, /* XXX first_segment */
 800   POP, /* XXX is_serif */
 801   POP, /* XXX is_round */
 802   PUSHB_1,
 803     bci_remaining_edges,
 804   LOOPCALL,
 805
 806   ENDF,
 807
 808 };
 809
 810 unsigned char FPGM(bci_edge2link) [] = {
 811
 812   PUSHB_1,
 813     bci_edge2link,
 814   FDEF,
 815
 816   POP, /* XXX first_segment */
 817   PUSHB_1,
 818     bci_remaining_edges,
 819   LOOPCALL,
 820
 821   ENDF,
 822
 823 };
 824
 825 unsigned char FPGM(bci_hint_glyph) [] = {
 826
 827   PUSHB_1,
 828     bci_hint_glyph,
 829   FDEF,
 830
 831   PUSHB_1,
 832     bci_edge2blue,
 833   LOOPCALL,
 834
 835   PUSHB_1,
 836     bci_edge2link,
 837   LOOPCALL,
 838
 839   ENDF,
 840
 841 };
 842
 843
 844 #define COPY_FPGM(func_name) \
 845           memcpy(buf_p, fpgm_ ## func_name, \
 846                  sizeof (fpgm_ ## func_name)); \
 847           buf_p += sizeof (fpgm_ ## func_name) \
 848
 849 static FT_Error
 850 TA_table_build_fpgm(FT_Byte** fpgm,
 851                     FT_ULong* fpgm_len,
 852                     FONT* font)
 853 {
 854   FT_UInt buf_len;
 855   FT_UInt len;
 856   FT_Byte* buf;
 857   FT_Byte* buf_p;
 858
 859
 860   buf_len = sizeof (FPGM(bci_compute_stem_width_a))
 861             + 1
 862             + sizeof (FPGM(bci_compute_stem_width_b))
 863             + 1
 864             + sizeof (FPGM(bci_compute_stem_width_c))
 865             + sizeof (FPGM(bci_loop))
 866             + sizeof (FPGM(bci_cvt_rescale))
 867             + sizeof (FPGM(bci_sal_assign))
 868             + sizeof (FPGM(bci_loop_sal_assign))
 869             + sizeof (FPGM(bci_blue_round_a))
 870             + 1
 871             + sizeof (FPGM(bci_blue_round_b))
 872             + sizeof (FPGM(bci_remaining_edges))
 873             + sizeof (FPGM(bci_edge2blue))
 874             + sizeof (FPGM(bci_edge2link))
 875             + sizeof (FPGM(bci_hint_glyph));
 876   /* buffer length must be a multiple of four */
 877   len = (buf_len + 3) & ~3;
 878   buf = (FT_Byte*)malloc(len);
 879   if (!buf)
 880     return FT_Err_Out_Of_Memory;
 881
 882   /* pad end of buffer with zeros */
 883   buf[len - 1] = 0x00;
 884   buf[len - 2] = 0x00;
 885   buf[len - 3] = 0x00;
 886
 887   /* copy font program into buffer and fill in the missing variables */
 888   buf_p = buf;
 889
 890   COPY_FPGM(bci_compute_stem_width_a);
 891   *(buf_p++) = (unsigned char)CVT_VERT_WIDTHS_OFFSET(font);
 892   COPY_FPGM(bci_compute_stem_width_b);
 893   *(buf_p++) = (unsigned char)CVT_VERT_WIDTHS_OFFSET(font);
 894   COPY_FPGM(bci_compute_stem_width_c);
 895   COPY_FPGM(bci_loop);
 896   COPY_FPGM(bci_cvt_rescale);
 897   COPY_FPGM(bci_sal_assign);
 898   COPY_FPGM(bci_loop_sal_assign);
 899   COPY_FPGM(bci_blue_round_a);
 900   *(buf_p++) = (unsigned char)CVT_BLUES_SIZE(font);
 901   COPY_FPGM(bci_blue_round_b);
 902   COPY_FPGM(bci_remaining_edges);
 903   COPY_FPGM(bci_edge2blue);
 904   COPY_FPGM(bci_edge2link);
 905   COPY_FPGM(bci_hint_glyph);
 906
 907   *fpgm = buf;
 908   *fpgm_len = buf_len;
 909
 910   return FT_Err_Ok;
 911 }
 912
 913
 914 FT_Error
 915 TA_sfnt_build_fpgm_table(SFNT* sfnt,
 916                          FONT* font)
 917 {
 918   FT_Error error;
 919
 920   FT_Byte* fpgm_buf;
 921   FT_ULong fpgm_len;
 922
 923
 924   error = TA_sfnt_add_table_info(sfnt);
 925   if (error)
 926     return error;
 927
 928   error = TA_table_build_fpgm(&fpgm_buf, &fpgm_len, font);
 929   if (error)
 930     return error;
 931
 932   /* in case of success, `fpgm_buf' gets linked */
 933   /* and is eventually freed in `TA_font_unload' */
 934   error = TA_font_add_table(font,
 935                             &sfnt->table_infos[sfnt->num_table_infos - 1],
 936                             TTAG_fpgm, fpgm_len, fpgm_buf);
 937   if (error)
 938   {
 939     free(fpgm_buf);
 940     return error;
 941   }
 942
 943   return FT_Err_Ok;
 944 }
 945
 946
 947 /* the `prep' instructions */
 948
 949 #define PREP(snippet_name) prep_ ## snippet_name
 950
 951 /* we often need 0x10000 which can't be pushed directly onto the stack, */
 952 /* thus we provide it in the storage area */
 953
 954 unsigned char PREP(store_0x10000) [] = {
 955
 956   PUSHB_1,
 957     sal_0x10000,
 958   PUSHW_2,
 959     0x08, /* 0x800 */
 960     0x00,
 961     0x08, /* 0x800 */
 962     0x00,
 963   MUL, /* 0x10000 */
 964   WS,
 965
 966 };
 967
 968 unsigned char PREP(align_top_a) [] = {
 969
 970   /* optimize the alignment of the top of small letters to the pixel grid */
 971
 972   PUSHB_1,
 973
 974 };
 975
 976 /*  %c, index of alignment blue zone */
 977
 978 unsigned char PREP(align_top_b) [] = {
 979
 980   RCVT,
 981   DUP,
 982   DUP,
 983   PUSHB_1,
 984     40,
 985   ADD,
 986   FLOOR, /* fitted = FLOOR(scaled + 40) */
 987   DUP, /* s: scaled scaled fitted fitted */
 988   ROLL,
 989   NEQ,
 990   IF, /* s: scaled fitted */
 991     PUSHB_1,
 992       sal_0x10000,
 993     RS,
 994     MUL, /* scaled in 16.16 format */
 995     SWAP,
 996     DIV, /* (fitted / scaled) in 16.16 format */
 997
 998     PUSHB_1,
 999       sal_scale,
1000     SWAP,
1001     WS,
1002
1003 };
1004
1005 unsigned char PREP(loop_cvt_a) [] = {
1006
1007     /* loop over vertical CVT entries */
1008     PUSHB_4,
1009
1010 };
1011
1012 /*    %c, first vertical index */
1013 /*    %c, last vertical index */
1014
1015 unsigned char PREP(loop_cvt_b) [] = {
1016
1017       bci_cvt_rescale,
1018       bci_loop,
1019     CALL,
1020
1021     /* loop over blue refs */
1022     PUSHB_4,
1023
1024 };
1025
1026 /*    %c, first blue ref index */
1027 /*    %c, last blue ref index */
1028
1029 unsigned char PREP(loop_cvt_c) [] = {
1030
1031       bci_cvt_rescale,
1032       bci_loop,
1033     CALL,
1034
1035     /* loop over blue shoots */
1036     PUSHB_4,
1037
1038 };
1039
1040 /*    %c, first blue shoot index */
1041 /*    %c, last blue shoot index */
1042
1043 unsigned char PREP(loop_cvt_d) [] = {
1044
1045       bci_cvt_rescale,
1046       bci_loop,
1047     CALL,
1048   EIF,
1049
1050 };
1051
1052 unsigned char PREP(compute_extra_light_a) [] = {
1053
1054   /* compute (vertical) `extra_light' flag */
1055   PUSHB_3,
1056     sal_is_extra_light,
1057     40,
1058
1059 };
1060
1061 /*  %c, index of vertical standard_width */
1062
1063 unsigned char PREP(compute_extra_light_b) [] = {
1064
1065   RCVT,
1066   GT, /* standard_width < 40 */
1067   WS,
1068
1069 };
1070
1071 unsigned char PREP(round_blues_a) [] = {
1072
1073   /* use discrete values for blue zone widths */
1074   PUSHB_4,
1075
1076 };
1077
1078 /*  %c, first blue ref index */
1079 /*  %c, last blue ref index */
1080
1081 unsigned char PREP(round_blues_b) [] = {
1082
1083     bci_blue_round,
1084     bci_loop,
1085   CALL
1086
1087 };
1088
1089
1090 /* XXX talatin.c: 1671 */
1091 /* XXX talatin.c: 1708 */
1092 /* XXX talatin.c: 2182 */
1093
1094
1095 #define COPY_PREP(snippet_name) \
1096           memcpy(buf_p, prep_ ## snippet_name, \
1097                  sizeof (prep_ ## snippet_name)); \
1098           buf_p += sizeof (prep_ ## snippet_name);
1099
1100 static FT_Error
1101 TA_table_build_prep(FT_Byte** prep,
1102                     FT_ULong* prep_len,
1103                     FONT* font)
1104 {
1105   TA_LatinAxis vaxis;
1106   TA_LatinBlue blue_adjustment;
1107   FT_UInt i;
1108
1109   FT_UInt buf_len;
1110   FT_UInt len;
1111   FT_Byte* buf;
1112   FT_Byte* buf_p;
1113
1114
1115   vaxis = &((TA_LatinMetrics)font->loader->hints.metrics)->axis[1];
1116   blue_adjustment = NULL;
1117
1118   for (i = 0; i < vaxis->blue_count; i++)
1119   {
1120     if (vaxis->blues[i].flags & TA_LATIN_BLUE_ADJUSTMENT)
1121     {
1122       blue_adjustment = &vaxis->blues[i];
1123       break;
1124     }
1125   }
1126
1127   buf_len = sizeof (PREP(store_0x10000));
1128
1129   if (blue_adjustment)
1130     buf_len += sizeof (PREP(align_top_a))
1131                + 1
1132                + sizeof (PREP(align_top_b))
1133                + sizeof (PREP(loop_cvt_a))
1134                + 2
1135                + sizeof (PREP(loop_cvt_b))
1136                + 2
1137                + sizeof (PREP(loop_cvt_c))
1138                + 2
1139                + sizeof (PREP(loop_cvt_d));
1140
1141   buf_len += sizeof (PREP(compute_extra_light_a))
1142              + 1
1143              + sizeof (PREP(compute_extra_light_b));
1144
1145   if (CVT_BLUES_SIZE(font))
1146     buf_len += sizeof (PREP(round_blues_a))
1147                + 2
1148                + sizeof (PREP(round_blues_b));
1149
1150   /* buffer length must be a multiple of four */
1151   len = (buf_len + 3) & ~3;
1152   buf = (FT_Byte*)malloc(len);
1153   if (!buf)
1154     return FT_Err_Out_Of_Memory;
1155
1156   /* pad end of buffer with zeros */
1157   buf[len - 1] = 0x00;
1158   buf[len - 2] = 0x00;
1159   buf[len - 3] = 0x00;
1160
1161   /* copy cvt program into buffer and fill in the missing variables */
1162   buf_p = buf;
1163
1164   COPY_PREP(store_0x10000);
1165
1166   if (blue_adjustment)
1167   {
1168     COPY_PREP(align_top_a);
1169     *(buf_p++) = (unsigned char)(CVT_BLUE_SHOOTS_OFFSET(font)
1170                                  + blue_adjustment - vaxis->blues);
1171     COPY_PREP(align_top_b);
1172
1173     COPY_PREP(loop_cvt_a);
1174     *(buf_p++) = (unsigned char)CVT_VERT_WIDTHS_OFFSET(font);
1175     *(buf_p++) = (unsigned char)(CVT_VERT_WIDTHS_OFFSET(font)
1176                                  + CVT_VERT_WIDTHS_SIZE(font) - 1);
1177     COPY_PREP(loop_cvt_b);
1178     *(buf_p++) = (unsigned char)CVT_BLUE_REFS_OFFSET(font);
1179     *(buf_p++) = (unsigned char)(CVT_BLUE_REFS_OFFSET(font)
1180                                  + CVT_BLUES_SIZE(font) - 1);
1181     COPY_PREP(loop_cvt_c);
1182     *(buf_p++) = (unsigned char)CVT_BLUE_SHOOTS_OFFSET(font);
1183     *(buf_p++) = (unsigned char)(CVT_BLUE_SHOOTS_OFFSET(font)
1184                                  + CVT_BLUES_SIZE(font) - 1);
1185     COPY_PREP(loop_cvt_d);
1186   }
1187
1188   COPY_PREP(compute_extra_light_a);
1189   *(buf_p++) = (unsigned char)CVT_VERT_STANDARD_WIDTH_OFFSET(font);
1190   COPY_PREP(compute_extra_light_b);
1191
1192   if (CVT_BLUES_SIZE(font))
1193   {
1194     COPY_PREP(round_blues_a);
1195     *(buf_p++) = (unsigned char)CVT_BLUE_REFS_OFFSET(font);
1196     *(buf_p++) = (unsigned char)(CVT_BLUE_REFS_OFFSET(font)
1197                                  + CVT_BLUES_SIZE(font) - 1);
1198     COPY_PREP(round_blues_b);
1199   }
1200
1201   *prep = buf;
1202   *prep_len = buf_len;
1203
1204   return FT_Err_Ok;
1205 }
1206
1207
1208 FT_Error
1209 TA_sfnt_build_prep_table(SFNT* sfnt,
1210                          FONT* font)
1211 {
1212   FT_Error error;
1213
1214   FT_Byte* prep_buf;
1215   FT_ULong prep_len;
1216
1217
1218   error = TA_sfnt_add_table_info(sfnt);
1219   if (error)
1220     return error;
1221
1222   error = TA_table_build_prep(&prep_buf, &prep_len, font);
1223   if (error)
1224     return error;
1225
1226   /* in case of success, `prep_buf' gets linked */
1227   /* and is eventually freed in `TA_font_unload' */
1228   error = TA_font_add_table(font,
1229                             &sfnt->table_infos[sfnt->num_table_infos - 1],
1230                             TTAG_prep, prep_len, prep_buf);
1231   if (error)
1232   {
1233     free(prep_buf);
1234     return error;
1235   }
1236
1237   return FT_Err_Ok;
1238 }
1239
1240
1241 /* we store the segments in the storage area; */
1242 /* each segment record consists of the first and last point */
1243
1244 static FT_Byte*
1245 TA_sfnt_build_glyph_segments(SFNT* sfnt,
1246                              FONT* font,
1247                              FT_Byte* bufp)
1248 {
1249   TA_GlyphHints hints = &font->loader->hints;
1250   TA_AxisHints axis = &hints->axis[TA_DIMENSION_VERT];
1251   TA_Point points = hints->points;
1252   TA_Segment segments = axis->segments;
1253   TA_Segment seg;
1254   TA_Segment seg_limit;
1255
1256   FT_UInt* args;
1257   FT_UInt* arg;
1258   FT_UInt num_args;
1259   FT_UInt nargs;
1260
1261   FT_Bool need_words = 0;
1262
1263   FT_UInt i, j;
1264   FT_UInt num_storage;
1265   FT_UInt num_stack_elements;
1266
1267
1268   seg_limit = segments + axis->num_segments;
1269   num_args = 2 * axis->num_segments + 3;
1270
1271   /* collect all arguments temporarily in an array (in reverse order) */
1272   /* so that we can easily split into chunks of 255 args */
1273   /* as needed by NPUSHB and NPUSHW, respectively */
1274   args = (FT_UInt*)malloc(num_args * sizeof (FT_UInt));
1275   if (!args)
1276     return NULL;
1277
1278   arg = args + num_args - 1;
1279
1280   if (axis->num_segments > 0xFF)
1281     need_words = 1;
1282
1283   *(arg--) = bci_loop_sal_assign;
1284   *(arg--) = axis->num_segments * 2;
1285   *(arg--) = sal_segment_offset;
1286
1287   for (seg = segments; seg < seg_limit; seg++)
1288   {
1289     FT_UInt first = seg->first - points;
1290     FT_UInt last = seg->last - points;
1291
1292
1293     *(arg--) = first;
1294     *(arg--) = last;
1295
1296     if (first > 0xFF || last > 0xFF)
1297       need_words = 1;
1298   }
1299
1300   /* with most fonts it is very rare */
1301   /* that any of the pushed arguments is larger than 0xFF, */
1302   /* thus we refrain from further optimizing this case */
1303
1304   arg = args;
1305
1306   if (need_words)
1307   {
1308     for (i = 0; i < num_args; i += 255)
1309     {
1310       nargs = (num_args - i > 255) ? 255 : num_args - i;
1311
1312       BCI(NPUSHW);
1313       BCI(nargs);
1314       for (j = 0; j < nargs; j++)
1315       {
1316         BCI(HIGH(*arg));
1317         BCI(LOW(*arg));
1318         arg++;
1319       }
1320     }
1321   }
1322   else
1323   {
1324     for (i = 0; i < num_args; i += 255)
1325     {
1326       nargs = (num_args - i > 255) ? 255 : num_args - i;
1327
1328       BCI(NPUSHB);
1329       BCI(nargs);
1330       for (j = 0; j < nargs; j++)
1331       {
1332         BCI(*arg);
1333         arg++;
1334       }
1335     }
1336   }
1337
1338   BCI(CALL);
1339
1340   num_storage = sal_segment_offset + axis->num_segments;
1341   if (num_storage > sfnt->max_storage)
1342     sfnt->max_storage = num_storage;
1343
1344   num_stack_elements = ADDITIONAL_STACK_ELEMENTS + num_args;
1345   if (num_stack_elements > sfnt->max_stack_elements)
1346     sfnt->max_stack_elements = num_stack_elements;
1347
1348   free(args);
1349
1350   return bufp;
1351 }
1352
1353
1354 static void
1355 TA_font_clear_edge_DONE_flag(FONT* font)
1356 {
1357   TA_GlyphHints hints = &font->loader->hints;
1358   TA_AxisHints axis = &hints->axis[TA_DIMENSION_VERT];
1359   TA_Edge edges = axis->edges;
1360   TA_Edge edge_limit = edges + axis->num_edges;
1361   TA_Edge edge;
1362
1363
1364   for (edge = edges; edge < edge_limit; edge++)
1365     edge->flags &= ~TA_EDGE_DONE;
1366 }
1367
1368
1369 static FT_Error
1370 TA_construct_hinting_set(FONT* font,
1371                          FT_UInt size,
1372                          Hinting_Set* hinting_set)
1373 {
1374   TA_GlyphHints hints = &font->loader->hints;
1375   TA_AxisHints axis = &hints->axis[TA_DIMENSION_VERT];
1376   TA_Segment segments = axis->segments;
1377   TA_Edge edges = axis->edges;
1378   TA_Edge limit = edges + axis->num_edges;
1379   TA_Edge edge;
1380
1381   Edge2Blue* edge2blue;
1382   Edge2Link* edge2link;
1383
1384
1385   hinting_set->size = size;
1386   hinting_set->need_words = 0;
1387   hinting_set->num_args = 0;
1388
1389   hinting_set->num_edges2blues = 0;
1390   hinting_set->edges2blues = NULL;
1391   hinting_set->num_edges2links = 0;
1392   hinting_set->edges2links = NULL;
1393
1394   for (edge = edges; edge < limit; edge++)
1395   {
1396     if (edge->blue_edge)
1397       hinting_set->num_edges2blues++;
1398     else
1399       hinting_set->num_edges2links++;
1400   }
1401
1402   if (hinting_set->num_edges2blues > 0xFF
1403       || hinting_set->num_edges2links > 0xFF)
1404     hinting_set->need_words = 1;
1405
1406   /* we push num_edges2blues and num_edges2links */
1407   hinting_set->num_args += 2;
1408
1409   if (hinting_set->num_edges2blues)
1410   {
1411     hinting_set->edges2blues =
1412       (Edge2Blue*)calloc(1, hinting_set->num_edges2blues
1413                             * sizeof (Edge2Blue));
1414     if (!hinting_set->edges2blues)
1415       return FT_Err_Out_Of_Memory;
1416   }
1417
1418   if (hinting_set->num_edges2links)
1419   {
1420     hinting_set->edges2links =
1421       (Edge2Link*)calloc(1, hinting_set->num_edges2links
1422                             * sizeof (Edge2Link));
1423     if (!hinting_set->edges2links)
1424       return FT_Err_Out_Of_Memory;
1425   }
1426
1427   edge2blue = hinting_set->edges2blues;
1428   edge2link = hinting_set->edges2links;
1429
1430   for (edge = edges; edge < limit; edge++)
1431   {
1432     TA_Segment seg;
1433     FT_UInt* remaining_segment;
1434
1435
1436     if (edge->blue_edge)
1437     {
1438       edge2blue->first_segment = edge->first - segments;
1439       edge2blue->is_serif = edge->flags & TA_EDGE_SERIF;
1440       edge2blue->is_round = edge->flags & TA_EDGE_ROUND;
1441
1442       seg = edge->first->edge_next;
1443       while (seg != edge->first)
1444       {
1445         edge2blue->num_remaining_segments++;
1446         seg = seg->edge_next;
1447       }
1448
1449       if (edge2blue->first_segment > 0xFF
1450           || edge2blue->num_remaining_segments > 0xFF)
1451         hinting_set->need_words = 1;
1452
1453       if (edge2blue->num_remaining_segments)
1454       {
1455         edge2blue->remaining_segments =
1456           (FT_UInt*)calloc(1, edge2blue->num_remaining_segments
1457                               * sizeof (FT_UInt));
1458         if (!edge2blue->remaining_segments)
1459           return FT_Err_Out_Of_Memory;
1460       }
1461
1462       seg = edge->first->edge_next;
1463       remaining_segment = edge2blue->remaining_segments;
1464       while (seg != edge->first)
1465       {
1466         *remaining_segment = seg - segments;
1467         seg = seg->edge_next;
1468
1469         if (*remaining_segment > 0xFF)
1470           hinting_set->need_words = 1;
1471
1472         remaining_segment++;
1473       }
1474
1475       /* we push the number of remaining segments, is_serif, is_round, */
1476       /* the first segment, and the remaining segments */
1477       hinting_set->num_args += edge2blue->num_remaining_segments + 4;
1478
1479       edge2blue++;
1480     }
1481     else
1482     {
1483       edge2link->first_segment = edge->first - segments;
1484
1485       seg = edge->first->edge_next;
1486       while (seg != edge->first)
1487       {
1488         edge2link->num_remaining_segments++;
1489         seg = seg->edge_next;
1490       }
1491
1492       if (edge2link->first_segment > 0xFF
1493           || edge2link->num_remaining_segments > 0xFF)
1494         hinting_set->need_words = 1;
1495
1496       if (edge2link->num_remaining_segments)
1497       {
1498         edge2link->remaining_segments =
1499           (FT_UInt*)calloc(1, edge2link->num_remaining_segments
1500                               * sizeof (FT_UInt));
1501         if (!edge2link->remaining_segments)
1502           return FT_Err_Out_Of_Memory;
1503       }
1504
1505       seg = edge->first->edge_next;
1506       remaining_segment = edge2link->remaining_segments;
1507       while (seg != edge->first)
1508       {
1509         *remaining_segment = seg - segments;
1510         seg = seg->edge_next;
1511
1512         if (*remaining_segment > 0xFF)
1513           hinting_set->need_words = 1;
1514
1515         remaining_segment++;
1516       }
1517
1518       /* we push the number of remaining segments, */
1519       /* the first segment, and the remaining segments */
1520       hinting_set->num_args += edge2link->num_remaining_segments + 2;
1521
1522       edge2link++;
1523     }
1524   }
1525
1526   return FT_Err_Ok;
1527 }
1528
1529
1530 static FT_Bool
1531 TA_hinting_set_is_different(Hinting_Set* hinting_sets,
1532                             FT_UInt num_hinting_sets,
1533                             Hinting_Set hinting_set)
1534 {
1535   Hinting_Set last_hinting_set;
1536
1537   Edge2Blue* edge2blue;
1538   Edge2Blue* last_edge2blue;
1539   Edge2Link* edge2link;
1540   Edge2Link* last_edge2link;
1541
1542   FT_UInt i;
1543
1544
1545   if (!hinting_sets)
1546     return 1;
1547
1548   /* we only need to compare with the last hinting set */
1549   last_hinting_set = hinting_sets[num_hinting_sets - 1];
1550
1551   if (hinting_set.num_edges2blues
1552       != last_hinting_set.num_edges2blues)
1553     return 1;
1554
1555   edge2blue = hinting_set.edges2blues;
1556   last_edge2blue = last_hinting_set.edges2blues;
1557
1558   for (i = 0;
1559        i < hinting_set.num_edges2blues;
1560        i++, edge2blue++, last_edge2blue++)
1561   {
1562     if (edge2blue->num_remaining_segments
1563         != last_edge2blue->num_remaining_segments)
1564       return 1;
1565
1566     if (edge2blue->remaining_segments)
1567     {
1568       if (memcmp(edge2blue->remaining_segments,
1569                  last_edge2blue->remaining_segments,
1570                  sizeof (FT_UInt) * edge2blue->num_remaining_segments))
1571         return 1;
1572     }
1573   }
1574
1575   if (hinting_set.num_edges2links
1576       != last_hinting_set.num_edges2links)
1577     return 1;
1578
1579   edge2link = hinting_set.edges2links;
1580   last_edge2link = last_hinting_set.edges2links;
1581
1582   for (i = 0;
1583        i < hinting_set.num_edges2links;
1584        i++, edge2link++, last_edge2link++)
1585   {
1586     if (edge2link->num_remaining_segments
1587         != last_edge2link->num_remaining_segments)
1588       return 1;
1589
1590     if (edge2link->remaining_segments)
1591     {
1592       if (memcmp(edge2link->remaining_segments,
1593                  last_edge2link->remaining_segments,
1594                  sizeof (FT_UInt) * edge2link->num_remaining_segments))
1595         return 1;
1596     }
1597   }
1598
1599   return 0;
1600 }
1601
1602
1603 static FT_Error
1604 TA_add_hinting_set(Hinting_Set** hinting_sets,
1605                    FT_UInt* num_hinting_sets,
1606                    Hinting_Set hinting_set)
1607 {
1608   Hinting_Set* hinting_sets_new;
1609
1610
1611   (*num_hinting_sets)++;
1612   hinting_sets_new =
1613     (Hinting_Set*)realloc(*hinting_sets, *num_hinting_sets
1614                                          * sizeof (Hinting_Set));
1615   if (!hinting_sets_new)
1616   {
1617     (*num_hinting_sets)--;
1618     return FT_Err_Out_Of_Memory;
1619   }
1620   else
1621     *hinting_sets = hinting_sets_new;
1622
1623   (*hinting_sets)[*num_hinting_sets - 1] = hinting_set;
1624
1625   return FT_Err_Ok;
1626 }
1627
1628
1629 static FT_Byte*
1630 TA_sfnt_emit_hinting_set(SFNT* sfnt,
1631                          Hinting_Set* hinting_set,
1632                          FT_Byte* bufp)
1633 {
1634   FT_UInt* args;
1635   FT_UInt* arg;
1636
1637   Edge2Blue* edge2blue;
1638   Edge2Blue* edge2blue_limit;
1639   Edge2Link* edge2link;
1640   Edge2Link* edge2link_limit;
1641
1642   FT_UInt* seg;
1643   FT_UInt* seg_limit;
1644
1645   FT_UInt i, j;
1646   FT_UInt num_args;
1647   FT_UInt num_stack_elements;
1648
1649
1650   /* collect all arguments temporarily in an array (in reverse order) */
1651   /* so that we can easily split into chunks of 255 args */
1652   /* as needed by NPUSHB and NPUSHW, respectively */
1653   args = (FT_UInt*)malloc(hinting_set->num_args * sizeof (FT_UInt));
1654   if (!args)
1655     return NULL;
1656
1657   arg = args + hinting_set->num_args - 1;
1658
1659   *(arg--) = hinting_set->num_edges2blues;
1660
1661   edge2blue_limit = hinting_set->edges2blues
1662                     + hinting_set->num_edges2blues;
1663   for (edge2blue = hinting_set->edges2blues;
1664        edge2blue < edge2blue_limit;
1665        edge2blue++)
1666   {
1667     *(arg--) = edge2blue->first_segment;
1668     *(arg--) = edge2blue->is_serif;
1669     *(arg--) = edge2blue->is_round;
1670     *(arg--) = edge2blue->num_remaining_segments;
1671
1672     seg_limit = edge2blue->remaining_segments
1673                 + edge2blue->num_remaining_segments;
1674     for (seg = edge2blue->remaining_segments; seg < seg_limit; seg++)
1675       *(arg--) = *seg;
1676   }
1677
1678   *(arg--) = hinting_set->num_edges2links;
1679
1680   edge2link_limit = hinting_set->edges2links
1681                     + hinting_set->num_edges2links;
1682   for (edge2link = hinting_set->edges2links;
1683        edge2link < edge2link_limit;
1684        edge2link++)
1685   {
1686     *(arg--) = edge2link->first_segment;
1687     *(arg--) = edge2link->num_remaining_segments;
1688
1689     seg_limit = edge2link->remaining_segments
1690                 + edge2link->num_remaining_segments;
1691     for (seg = edge2link->remaining_segments; seg < seg_limit; seg++)
1692       *(arg--) = *seg;
1693   }
1694
1695   /* with most fonts it is very rare */
1696   /* that any of the pushed arguments is larger than 0xFF, */
1697   /* thus we refrain from further optimizing this case */
1698
1699   arg = args;
1700
1701   if (hinting_set->need_words)
1702   {
1703     for (i = 0; i < hinting_set->num_args; i += 255)
1704     {
1705       num_args = (hinting_set->num_args - i > 255)
1706                    ? 255
1707                    : hinting_set->num_args - i;
1708
1709       BCI(NPUSHW);
1710       BCI(num_args);
1711       for (j = 0; j < num_args; j++)
1712       {
1713         BCI(HIGH(*arg));
1714         BCI(LOW(*arg));
1715         arg++;
1716       }
1717     }
1718   }
1719   else
1720   {
1721     for (i = 0; i < hinting_set->num_args; i += 255)
1722     {
1723       num_args = (hinting_set->num_args - i > 255)
1724                    ? 255
1725                    : hinting_set->num_args - i;
1726
1727       BCI(NPUSHB);
1728       BCI(num_args);
1729       for (j = 0; j < num_args; j++)
1730       {
1731         BCI(*arg);
1732         arg++;
1733       }
1734     }
1735   }
1736
1737   free(args);
1738
1739   num_stack_elements = ADDITIONAL_STACK_ELEMENTS + hinting_set->num_args;
1740   if (num_stack_elements > sfnt->max_stack_elements)
1741     sfnt->max_stack_elements = sfnt->max_stack_elements;
1742
1743   return bufp;
1744 }
1745
1746
1747 static FT_Byte*
1748 TA_sfnt_emit_hinting_sets(SFNT* sfnt,
1749                           Hinting_Set* hinting_sets,
1750                           FT_UInt num_hinting_sets,
1751                           FT_Byte* bufp)
1752 {
1753   FT_UInt i;
1754   Hinting_Set* hinting_set;
1755
1756
1757   hinting_set = hinting_sets;
1758
1759   /* this instruction is essential for getting correct CVT values */
1760   /* if horizontal and vertical resolutions differ; */
1761   /* it assures that the projection vector is set to the y axis */
1762   /* so that CVT values are handled as being `vertical' */
1763   BCI(SVTCA_y);
1764
1765   for (i = 0; i < num_hinting_sets - 1; i++)
1766   {
1767     BCI(MPPEM);
1768     if (hinting_set->size > 0xFF)
1769     {
1770       BCI(PUSHW_1);
1771       BCI(HIGH((hinting_set + 1)->size));
1772       BCI(LOW((hinting_set + 1)->size));
1773     }
1774     else
1775     {
1776       BCI(PUSHB_1);
1777       BCI((hinting_set + 1)->size);
1778     }
1779     BCI(LT);
1780     BCI(IF);
1781     bufp = TA_sfnt_emit_hinting_set(sfnt, hinting_set, bufp);
1782     if (!bufp)
1783       return NULL;
1784     BCI(ELSE);
1785
1786     hinting_set++;
1787   }
1788
1789   bufp = TA_sfnt_emit_hinting_set(sfnt, hinting_set, bufp);
1790   if (!bufp)
1791     return NULL;
1792
1793   for (i = 0; i < num_hinting_sets - 1; i++)
1794     BCI(EIF);
1795
1796   BCI(PUSHB_1);
1797   BCI(bci_hint_glyph);
1798   BCI(CALL);
1799
1800   return bufp;
1801 }
1802
1803
1804 static void
1805 TA_free_hinting_set(Hinting_Set hinting_set)
1806 {
1807   FT_UInt i;
1808
1809
1810   for (i = 0; i < hinting_set.num_edges2blues; i++)
1811     free(hinting_set.edges2blues[i].remaining_segments);
1812   free(hinting_set.edges2blues);
1813
1814   for (i = 0; i < hinting_set.num_edges2links; i++)
1815     free(hinting_set.edges2links[i].remaining_segments);
1816   free(hinting_set.edges2links);
1817 }
1818
1819
1820 static void
1821 TA_free_hinting_sets(Hinting_Set* hinting_sets,
1822                      FT_UInt num_hinting_sets)
1823 {
1824   FT_UInt i;
1825
1826
1827   for (i = 0; i < num_hinting_sets; i++)
1828     TA_free_hinting_set(hinting_sets[i]);
1829
1830   free(hinting_sets);
1831 }
1832
1833
1834 static FT_Error
1835 TA_sfnt_build_glyph_instructions(SFNT* sfnt,
1836                                  FONT* font,
1837                                  FT_Long idx)
1838 {
1839   FT_Face face = sfnt->face;
1840   FT_Error error;
1841
1842   FT_Byte* ins_buf;
1843   FT_UInt ins_len;
1844   FT_Byte* bufp;
1845
1846   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
1847   glyf_Data* data = (glyf_Data*)glyf_table->data;
1848   GLYPH* glyph = &data->glyphs[idx];
1849
1850   TA_GlyphHints hints;
1851
1852   FT_UInt num_hinting_sets;
1853   Hinting_Set* hinting_sets;
1854
1855   FT_UInt size;
1856
1857
1858   if (idx < 0)
1859     return FT_Err_Invalid_Argument;
1860
1861   /* computing the segments is resolution independent, */
1862   /* thus the pixel size in this call is arbitrary */
1863   error = FT_Set_Pixel_Sizes(face, 20, 20);
1864   if (error)
1865     return error;
1866
1867   error = ta_loader_load_glyph(font->loader, face, (FT_UInt)idx, 0);
1868   if (error)
1869     return error;
1870
1871   /* do nothing if we have an empty glyph */
1872   if (!face->glyph->outline.n_contours)
1873     return FT_Err_Ok;
1874
1875   hints = &font->loader->hints;
1876
1877   /* we allocate a buffer which is certainly large enough */
1878   /* to hold all of the created bytecode instructions; */
1879   /* later on it gets reallocated to its real size */
1880   ins_len = hints->num_points * 1000;
1881   ins_buf = (FT_Byte*)malloc(ins_len);
1882   if (!ins_buf)
1883     return FT_Err_Out_Of_Memory;
1884
1885   /* initialize array with an invalid bytecode */
1886   /* so that we can easily find the array length at reallocation time */
1887   memset(ins_buf, INS_A0, ins_len);
1888
1889   bufp = TA_sfnt_build_glyph_segments(sfnt, font, ins_buf);
1890
1891   /* now we loop over a large range of pixel sizes */
1892   /* to find hinting sets which get pushed onto the bytecode stack */
1893   num_hinting_sets = 0;
1894   hinting_sets = NULL;
1895
1896 #if 0
1897   printf("glyph %ld\n", idx);
1898 #endif
1899
1900   for (size = 8; size <= 1000; size++)
1901   {
1902     Hinting_Set hinting_set;
1903
1904
1905     error = FT_Set_Pixel_Sizes(face, size, size);
1906     if (error)
1907       goto Err;
1908
1909     error = ta_loader_load_glyph(font->loader, face, idx, 0);
1910     if (error)
1911       goto Err;
1912
1913     TA_font_clear_edge_DONE_flag(font);
1914
1915     error = TA_construct_hinting_set(font, size, &hinting_set);
1916     if (error)
1917       goto Err;
1918
1919     if (TA_hinting_set_is_different(hinting_sets,
1920                                     num_hinting_sets,
1921                                     hinting_set))
1922     {
1923 #if 0
1924       if (num_hinting_sets > 0)
1925         printf("  additional hinting set for size %d\n", size);
1926 #endif
1927
1928       error = TA_add_hinting_set(&hinting_sets,
1929                                  &num_hinting_sets,
1930                                  hinting_set);
1931       if (error)
1932       {
1933         TA_free_hinting_set(hinting_set);
1934         goto Err;
1935       }
1936     }
1937     else
1938       TA_free_hinting_set(hinting_set);
1939   }
1940
1941   bufp = TA_sfnt_emit_hinting_sets(sfnt,
1942                                    hinting_sets, num_hinting_sets, bufp);
1943   if (!bufp)
1944     return FT_Err_Out_Of_Memory;
1945
1946   /* we are done, so reallocate the instruction array to its real size */
1947   bufp = (FT_Byte*)memchr((char*)ins_buf, INS_A0, ins_len);
1948   ins_len = bufp - ins_buf;
1949
1950   if (ins_len > sfnt->max_instructions)
1951     sfnt->max_instructions = ins_len;
1952
1953   glyph->ins_buf = (FT_Byte*)realloc(ins_buf, ins_len);
1954   glyph->ins_len = ins_len;
1955
1956   TA_free_hinting_sets(hinting_sets, num_hinting_sets);
1957
1958   return FT_Err_Ok;
1959
1960 Err:
1961   TA_free_hinting_sets(hinting_sets, num_hinting_sets);
1962   free(ins_buf);
1963
1964   return error;
1965 }
1966
1967
1968 FT_Error
1969 TA_sfnt_build_glyf_hints(SFNT* sfnt,
1970                          FONT* font)
1971 {
1972   FT_Face face = sfnt->face;
1973   FT_Long idx;
1974   FT_Error error;
1975
1976
1977   for (idx = 0; idx < face->num_glyphs; idx++)
1978   {
1979     error = TA_sfnt_build_glyph_instructions(sfnt, font, idx);
1980     if (error)
1981       return error;
1982   }
1983
1984   return FT_Err_Ok;
1985 }
1986
1987 /* end of tabytecode.c */