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
  13 #ifdef TA_DEBUG
  14 int _ta_debug = 1;
  15 int _ta_debug_disable_horz_hints;
  16 int _ta_debug_disable_vert_hints;
  17 int _ta_debug_disable_blue_hints;
  18 void* _ta_debug_hints;
  19 #endif
  20
  21
  22 /* structures for hinting sets */
  23 typedef struct Edge2Blue_ {
  24   FT_UInt first_segment;
  25
  26   FT_Bool is_serif;
  27   FT_Bool is_round;
  28
  29   FT_UInt num_remaining_segments;
  30   FT_UInt* remaining_segments;
  31 } Edge2Blue;
  32
  33 typedef struct Edge2Link_ {
  34   FT_UInt first_segment;
  35
  36   FT_UInt num_remaining_segments;
  37   FT_UInt* remaining_segments;
  38 } Edge2Link;
  39
  40 typedef struct Hinting_Set_ {
  41   FT_UInt size;
  42
  43   FT_UInt num_edges2blues;
  44   Edge2Blue* edges2blues;
  45
  46   FT_UInt num_edges2links;
  47   Edge2Link* edges2links;
  48 } Hinting_Set;
  49
  50
  51 static FT_Error
  52 TA_sfnt_compute_global_hints(SFNT* sfnt,
  53                              FONT* font)
  54 {
  55   FT_Error error;
  56   FT_Face face = sfnt->face;
  57   FT_UInt enc;
  58   FT_UInt idx;
  59
  60   static const FT_Encoding latin_encs[] =
  61   {
  62     FT_ENCODING_UNICODE,
  63     FT_ENCODING_APPLE_ROMAN,
  64     FT_ENCODING_ADOBE_STANDARD,
  65     FT_ENCODING_ADOBE_LATIN_1,
  66
  67     FT_ENCODING_NONE /* end of list */
  68   };
  69
  70
  71   error = ta_loader_init(font->loader);
  72   if (error)
  73     return error;
  74
  75   /* try to select a latin charmap */
  76   for (enc = 0; latin_encs[enc] != FT_ENCODING_NONE; enc++)
  77   {
  78     error = FT_Select_Charmap(face, latin_encs[enc]);
  79     if (!error)
  80       break;
  81   }
  82
  83   /* load latin glyph `a' to trigger all initializations */
  84   idx = FT_Get_Char_Index(face, 'a');
  85   error = ta_loader_load_glyph(font->loader, face, idx, 0);
  86
  87   return error;
  88 }
  89
  90
  91 static FT_Error
  92 TA_table_build_cvt(FT_Byte** cvt,
  93                    FT_ULong* cvt_len,
  94                    SFNT* sfnt,
  95                    FONT* font)
  96 {
  97   TA_LatinAxis haxis;
  98   TA_LatinAxis vaxis;
  99
 100   FT_UInt i;
 101   FT_UInt buf_len;
 102   FT_UInt len;
 103   FT_Byte* buf;
 104   FT_Byte* buf_p;
 105
 106   FT_Error error;
 107
 108
 109   error = TA_sfnt_compute_global_hints(sfnt, font);
 110   if (error)
 111     return error;
 112
 113   /* XXX check validity of pointers */
 114   haxis = &((TA_LatinMetrics)font->loader->hints.metrics)->axis[0];
 115   vaxis = &((TA_LatinMetrics)font->loader->hints.metrics)->axis[1];
 116
 117   buf_len = 2 * (haxis->width_count + vaxis->width_count
 118                  + 2 * vaxis->blue_count);
 119
 120   /* buffer length must be a multiple of four */
 121   len = (buf_len + 3) & ~3;
 122   buf = (FT_Byte*)malloc(len);
 123   if (!buf)
 124     return FT_Err_Out_Of_Memory;
 125
 126   /* pad end of buffer with zeros */
 127   buf[len - 1] = 0x00;
 128   buf[len - 2] = 0x00;
 129   buf[len - 3] = 0x00;
 130
 131   buf_p = buf;
 132
 133   /* XXX emit standard_width also? */
 134
 135   for (i = 0; i < haxis->width_count; i++)
 136   {
 137     if (haxis->widths[i].org > 0xFFFF)
 138       goto Err;
 139     *(buf_p++) = HIGH(haxis->widths[i].org);
 140     *(buf_p++) = LOW(haxis->widths[i].org);
 141   }
 142
 143   for (i = 0; i < vaxis->width_count; i++)
 144   {
 145     if (vaxis->widths[i].org > 0xFFFF)
 146       goto Err;
 147     *(buf_p++) = HIGH(vaxis->widths[i].org);
 148     *(buf_p++) = LOW(vaxis->widths[i].org);
 149   }
 150
 151   for (i = 0; i < vaxis->blue_count; i++)
 152   {
 153     if (vaxis->blues[i].ref.org > 0xFFFF)
 154       goto Err;
 155     *(buf_p++) = HIGH(vaxis->blues[i].ref.org);
 156     *(buf_p++) = LOW(vaxis->blues[i].ref.org);
 157   }
 158
 159   for (i = 0; i < vaxis->blue_count; i++)
 160   {
 161     if (vaxis->blues[i].shoot.org > 0xFFFF)
 162       goto Err;
 163     *(buf_p++) = HIGH(vaxis->blues[i].shoot.org);
 164     *(buf_p++) = LOW(vaxis->blues[i].shoot.org);
 165   }
 166
 167 #if 0
 168   TA_LOG(("--------------------------------------------------\n"));
 169   TA_LOG(("glyph %d:\n", idx));
 170   ta_glyph_hints_dump_edges(_ta_debug_hints);
 171   ta_glyph_hints_dump_segments(_ta_debug_hints);
 172   ta_glyph_hints_dump_points(_ta_debug_hints);
 173 #endif
 174
 175   *cvt = buf;
 176   *cvt_len = buf_len;
 177
 178   return FT_Err_Ok;
 179
 180 Err:
 181   free(buf);
 182   return TA_Err_Hinter_Overflow;
 183 }
 184
 185
 186 FT_Error
 187 TA_sfnt_build_cvt_table(SFNT* sfnt,
 188                         FONT* font)
 189 {
 190   FT_Error error;
 191
 192   FT_Byte* cvt_buf;
 193   FT_ULong cvt_len;
 194
 195
 196   error = TA_sfnt_add_table_info(sfnt);
 197   if (error)
 198     return error;
 199
 200   error = TA_table_build_cvt(&cvt_buf, &cvt_len, sfnt, font);
 201   if (error)
 202     return error;
 203
 204   /* in case of success, `cvt_buf' gets linked */
 205   /* and is eventually freed in `TA_font_unload' */
 206   error = TA_font_add_table(font,
 207                             &sfnt->table_infos[sfnt->num_table_infos - 1],
 208                             TTAG_cvt, cvt_len, cvt_buf);
 209   if (error)
 210   {
 211     free(cvt_buf);
 212     return error;
 213   }
 214
 215   return FT_Err_Ok;
 216 }
 217
 218
 219 /* the horizontal stem widths */
 220 #define CVT_HORZ_WIDTHS_OFFSET(font) 0
 221 #define CVT_HORZ_WIDTHS_SIZE(font) \
 222           ((TA_LatinMetrics)font->loader->hints.metrics)->axis[0].width_count
 223
 224 /* the vertical stem widths */
 225 #define CVT_VERT_WIDTHS_OFFSET(font) \
 226           CVT_HORZ_WIDTHS_OFFSET(font) \
 227           + ((TA_LatinMetrics)font->loader->hints.metrics)->axis[0].width_count
 228 #define CVT_VERT_WIDTHS_SIZE(font) \
 229           ((TA_LatinMetrics)font->loader->hints.metrics)->axis[1].width_count
 230
 231 /* the blue zone values for flat edges */
 232 #define CVT_BLUE_REFS_OFFSET(font) \
 233           CVT_VERT_WIDTHS_OFFSET(font) \
 234           + ((TA_LatinMetrics)font->loader->hints.metrics)->axis[1].width_count
 235 #define CVT_BLUE_REFS_SIZE(font) \
 236           ((TA_LatinMetrics)font->loader->hints.metrics)->axis[1].blue_count
 237
 238 /* the blue zone values for round edges */
 239 #define CVT_BLUE_SHOOTS_OFFSET(font) \
 240           CVT_BLUE_REFS_OFFSET(font) \
 241           + ((TA_LatinMetrics)font->loader->hints.metrics)->axis[1].blue_count
 242 #define CVT_BLUE_SHOOTS_SIZE(font) \
 243           ((TA_LatinMetrics)font->loader->hints.metrics)->axis[1].blue_count
 244
 245
 246 /* symbolic names for storage area locations */
 247
 248 #define sal_counter 0
 249 #define sal_limit 1
 250 #define sal_scale 2
 251 #define sal_0x10000 3
 252 #define sal_segment_offset 4
 253
 254
 255 /* in the comments below, the top of the stack (`s:') */
 256 /* is the rightmost element; the stack is shown */
 257 /* after the instruction on the same line has been executed */
 258
 259 /*
 260  * compute_stem_width
 261  *
 262  *   This is the equivalent to the following code from function
 263  *   `ta_latin_compute_stem_width':
 264  *
 265  *      dist = ABS(width)
 266  *
 267  *      if stem_is_serif
 268  *         && dist < 3*64:
 269  *        return width
 270  *      else if base_is_round:
 271  *        if dist < 80
 272  *          dist = 64
 273  *      else:
 274  *        dist = MIN(56, dist)
 275  *
 276  *      delta = ABS(dist - std_width)
 277  *
 278  *      if delta < 40:
 279  *        dist = MIN(48, std_width)
 280  *        goto End
 281  *
 282  *      if dist < 3*64:
 283  *        delta = dist
 284  *        dist = FLOOR(dist)
 285  *        delta = delta - dist
 286  *
 287  *        if delta < 10:
 288  *          dist = dist + delta
 289  *        else if delta < 32:
 290  *          dist = dist + 10
 291  *        else if delta < 54:
 292  *          dist = dist + 54
 293  *        else
 294  *          dist = dist + delta
 295  *      else
 296  *        dist = ROUND(dist)
 297  *
 298  *    End:
 299  *      if width < 0:
 300  *        dist = -dist
 301  *      return dist
 302  *
 303  *
 304  *
 305  * Function 0: compute_stem_width
 306  *
 307  * in: width
 308  *     stem_is_serif
 309  *     base_is_round
 310  * out: new_width
 311  * CVT: is_extra_light   XXX
 312  *      std_width
 313  */
 314
 315 #define compute_stem_width 0
 316
 317 unsigned char fpgm_0a[] = {
 318
 319   PUSHB_1,
 320     compute_stem_width,
 321   FDEF,
 322
 323   DUP,
 324   ABS, /* s: base_is_round stem_is_serif width dist */
 325
 326   DUP,
 327   PUSHB_1,
 328     3*64,
 329   LT, /* dist < 3*64 */
 330
 331   PUSHB_1,
 332     4,
 333   MINDEX, /* s: base_is_round width dist (dist<3*64) stem_is_serif */
 334
 335   AND, /* stem_is_serif && dist < 3*64 */
 336   IF, /* s: base_is_round width dist */
 337     POP,
 338     SWAP,
 339     POP, /* s: width */
 340
 341   ELSE,
 342     ROLL, /* s: width dist base_is_round */
 343     IF, /* s: width dist */
 344       DUP,
 345       PUSHB_1,
 346         80,
 347       LT, /* dist < 80 */
 348       IF, /* s: width dist */
 349         POP,
 350         PUSHB_1,
 351           64, /* dist = 64 */
 352       EIF,
 353
 354     ELSE,
 355       PUSHB_1,
 356         56,
 357       MIN, /* dist = min(56, dist) */
 358     EIF,
 359
 360     DUP, /* s: width dist dist */
 361     PUSHB_1,
 362
 363 };
 364
 365 /*    %c, index of std_width */
 366
 367 unsigned char fpgm_0b[] = {
 368
 369     RCVT,
 370     SUB,
 371     ABS, /* s: width dist delta */
 372
 373     PUSHB_1,
 374       40,
 375     LT, /* delta < 40 */
 376     IF, /* s: width dist */
 377       POP,
 378       PUSHB_2,
 379         48,
 380
 381 };
 382
 383 /*      %c, index of std_width */
 384
 385 unsigned char fpgm_0c[] = {
 386
 387       RCVT,
 388       MIN, /* dist = min(48, std_width) */
 389
 390     ELSE,
 391       DUP, /* s: width dist dist */
 392       PUSHB_1,
 393         3*64,
 394       LT, /* dist < 3*64 */
 395       IF,
 396         DUP, /* s: width delta dist */
 397         FLOOR, /* dist = FLOOR(dist) */
 398         DUP, /* s: width delta dist dist */
 399         ROLL,
 400         ROLL, /* s: width dist delta dist */
 401         SUB, /* delta = delta - dist */
 402
 403         DUP, /* s: width dist delta delta */
 404         PUSHB_1,
 405           10,
 406         LT, /* delta < 10 */
 407         IF, /* s: width dist delta */
 408           ADD, /* dist = dist + delta */
 409
 410         ELSE,
 411           DUP,
 412           PUSHB_1,
 413             32,
 414           LT, /* delta < 32 */
 415           IF,
 416             POP,
 417             PUSHB_1,
 418               10,
 419             ADD, /* dist = dist + 10 */
 420
 421           ELSE,
 422             DUP,
 423             PUSHB_1,
 424               54,
 425             LT, /* delta < 54 */
 426             IF,
 427               POP,
 428               PUSHB_1,
 429                 54,
 430               ADD, /* dist = dist + 54 */
 431
 432             ELSE,
 433               ADD, /* dist = dist + delta */
 434
 435             EIF,
 436           EIF,
 437         EIF,
 438
 439         ELSE,
 440           PUSHB_1,
 441             32,
 442           ADD,
 443           FLOOR, /* dist = round(dist) */
 444
 445         EIF,
 446       EIF,
 447
 448       SWAP, /* s: dist width */
 449       PUSHB_1,
 450         0,
 451       LT, /* width < 0 */
 452       NEG, /* dist = -dist */
 453
 454     EIF,
 455   EIF,
 456
 457   ENDF,
 458
 459 };
 460
 461
 462 /*
 463  * loop
 464  *
 465  *   Take a range and a function number and apply the function to all
 466  *   elements of the range.  The called function must not change the
 467  *   stack.
 468  *
 469  * Function 1: loop
 470  *
 471  * in: func_num
 472  *     end
 473  *     start
 474  *
 475  * uses: sal_counter (counter initialized with `start')
 476  *       sal_limit (`end')
 477  */
 478
 479 #define loop 1
 480
 481 unsigned char fpgm_1[] = {
 482
 483   PUSHB_1,
 484     loop,
 485   FDEF,
 486
 487   ROLL,
 488   ROLL, /* s: func_num start end */
 489   PUSHB_1,
 490     sal_limit,
 491   SWAP,
 492   WS,
 493
 494   PUSHB_1,
 495     sal_counter,
 496   SWAP,
 497   WS,
 498
 499 /* start_loop: */
 500   PUSHB_1,
 501     sal_counter,
 502   RS,
 503   PUSHB_1,
 504     sal_limit,
 505   RS,
 506   LTEQ, /* start <= end */
 507   IF, /* s: func_num */
 508     DUP,
 509     CALL,
 510     PUSHB_2,
 511       1,
 512       sal_counter,
 513     RS,
 514     ADD, /* start = start + 1 */
 515     PUSHB_1,
 516       sal_counter,
 517     SWAP,
 518     WS,
 519
 520     PUSHB_1,
 521       22,
 522     NEG,
 523     JMPR, /* goto start_loop */
 524   ELSE,
 525     POP,
 526   EIF,
 527
 528   ENDF,
 529
 530 };
 531
 532
 533 /*
 534  * rescale
 535  *
 536  *   All entries in the CVT table get scaled automatically using the
 537  *   vertical resolution.  However, some widths must be scaled with the
 538  *   horizontal resolution, and others get adjusted later on.
 539  *
 540  * Function 2: rescale
 541  *
 542  * uses: sal_counter (CVT index)
 543  *       sal_scale (scale in 16.16 format)
 544  */
 545
 546 #define rescale 2
 547
 548 unsigned char fpgm_2[] = {
 549
 550   PUSHB_1,
 551     rescale,
 552   FDEF,
 553
 554   PUSHB_1,
 555     sal_counter,
 556   RS,
 557   DUP,
 558   RCVT,
 559   PUSHB_1,
 560     sal_scale,
 561   RS,
 562   MUL, /* CVT * scale * 2^10 */
 563   PUSHB_1,
 564     sal_0x10000,
 565   RS,
 566   DIV, /* CVT * scale */
 567
 568   WCVTP,
 569
 570   ENDF,
 571
 572 };
 573
 574
 575 /*
 576  * sal_loop_assign
 577  *
 578  *   Apply the WS instruction repeatedly to stack data.
 579  *
 580  * Function 3: sal_loop_assign
 581  *
 582  * in: counter (N)
 583  *     offset
 584  *     data_N-1
 585  *     data_N-2
 586  *     ...
 587  *     data_0
 588  *
 589  * uses: sal_assign
 590  */
 591
 592 #define sal_assign 3
 593
 594 unsigned char fpgm_3[] = {
 595
 596   PUSHB_1,
 597     sal_assign,
 598   FDEF,
 599
 600   DUP,
 601   ROLL, /* s: offset offset data */
 602   WS,
 603
 604   PUSHB_1,
 605     1,
 606   SUB, /* s: (offset - 1) */
 607
 608   ENDF,
 609
 610 };
 611
 612 #define sal_loop_assign 4
 613
 614 unsigned char fpgm_4[] = {
 615
 616   PUSHB_1,
 617     sal_loop_assign,
 618   FDEF,
 619
 620   DUP, /* s: offset counter counter */
 621   ROLL,
 622   ADD,
 623   PUSHB_1,
 624     1,
 625   SUB,
 626   SWAP, /* s: (offset + counter - 1) counter */
 627
 628   /* process the stack, popping off the elements in a loop */
 629   PUSHB_1,
 630     sal_assign,
 631   LOOPCALL,
 632   POP,
 633
 634   ENDF,
 635
 636 };
 637
 638
 639 static FT_Error
 640 TA_table_build_fpgm(FT_Byte** fpgm,
 641                     FT_ULong* fpgm_len,
 642                     FONT* font)
 643 {
 644   FT_UInt buf_len;
 645   FT_UInt len;
 646   FT_Byte* buf;
 647   FT_Byte* buf_p;
 648
 649
 650   buf_len = sizeof (fpgm_0a)
 651             + 1
 652             + sizeof (fpgm_0b)
 653             + 1
 654             + sizeof (fpgm_0c)
 655             + sizeof (fpgm_1)
 656             + sizeof (fpgm_2)
 657             + sizeof (fpgm_3)
 658             + sizeof (fpgm_4);
 659   /* buffer length must be a multiple of four */
 660   len = (buf_len + 3) & ~3;
 661   buf = (FT_Byte*)malloc(len);
 662   if (!buf)
 663     return FT_Err_Out_Of_Memory;
 664
 665   /* pad end of buffer with zeros */
 666   buf[len - 1] = 0x00;
 667   buf[len - 2] = 0x00;
 668   buf[len - 3] = 0x00;
 669
 670   /* copy font program into buffer and fill in the missing variables */
 671   buf_p = buf;
 672
 673   memcpy(buf_p, fpgm_0a, sizeof (fpgm_0a));
 674   buf_p += sizeof (fpgm_0a);
 675
 676   *(buf_p++) = (unsigned char)CVT_VERT_WIDTHS_OFFSET(font);
 677
 678   memcpy(buf_p, fpgm_0b, sizeof (fpgm_0b));
 679   buf_p += sizeof (fpgm_0b);
 680
 681   *(buf_p++) = (unsigned char)CVT_VERT_WIDTHS_OFFSET(font);
 682
 683   memcpy(buf_p, fpgm_0c, sizeof (fpgm_0c));
 684   buf_p += sizeof (fpgm_0c);
 685
 686   memcpy(buf_p, fpgm_1, sizeof (fpgm_1));
 687   buf_p += sizeof (fpgm_1);
 688
 689   memcpy(buf_p, fpgm_2, sizeof (fpgm_2));
 690   buf_p += sizeof (fpgm_2);
 691
 692   memcpy(buf_p, fpgm_3, sizeof (fpgm_3));
 693   buf_p += sizeof (fpgm_3);
 694
 695   memcpy(buf_p, fpgm_4, sizeof (fpgm_4));
 696
 697   *fpgm = buf;
 698   *fpgm_len = buf_len;
 699
 700   return FT_Err_Ok;
 701 }
 702
 703
 704 FT_Error
 705 TA_sfnt_build_fpgm_table(SFNT* sfnt,
 706                          FONT* font)
 707 {
 708   FT_Error error;
 709
 710   FT_Byte* fpgm_buf;
 711   FT_ULong fpgm_len;
 712
 713
 714   error = TA_sfnt_add_table_info(sfnt);
 715   if (error)
 716     return error;
 717
 718   error = TA_table_build_fpgm(&fpgm_buf, &fpgm_len, font);
 719   if (error)
 720     return error;
 721
 722   /* in case of success, `fpgm_buf' gets linked */
 723   /* and is eventually freed in `TA_font_unload' */
 724   error = TA_font_add_table(font,
 725                             &sfnt->table_infos[sfnt->num_table_infos - 1],
 726                             TTAG_fpgm, fpgm_len, fpgm_buf);
 727   if (error)
 728   {
 729     free(fpgm_buf);
 730     return error;
 731   }
 732
 733   return FT_Err_Ok;
 734 }
 735
 736
 737 /* the `prep' instructions */
 738
 739 /* we often need 0x10000 which can't be pushed directly onto the stack, */
 740 /* thus we provide it in the storage area */
 741
 742 unsigned char prep_A[] = {
 743
 744   PUSHB_1,
 745     sal_0x10000,
 746   PUSHW_2,
 747     0x08, /* 0x800 */
 748     0x00,
 749     0x08, /* 0x800 */
 750     0x00,
 751   MUL, /* 0x10000 */
 752   WS,
 753
 754 };
 755
 756
 757 unsigned char prep_a[] = {
 758
 759   /* scale horizontal CVT entries */
 760   /* if horizontal and vertical resolutions differ */
 761
 762   SVTCA_x,
 763   MPPEM,
 764   SVTCA_y,
 765   MPPEM,
 766   NEQ, /* horz_ppem != vert_ppem */
 767   IF,
 768     SVTCA_x,
 769     MPPEM,
 770     PUSHB_1,
 771       sal_0x10000,
 772     RS,
 773     MUL, /* horz_ppem in 22.10 format */
 774
 775     SVTCA_y,
 776     MPPEM,
 777     DIV, /* (horz_ppem / vert_ppem) in 16.16 format */
 778
 779     PUSHB_1,
 780       sal_scale,
 781     SWAP,
 782     WS,
 783
 784     /* loop over horizontal CVT entries */
 785     PUSHB_4,
 786
 787 };
 788
 789 /*    %c, first horizontal index */
 790 /*    %c, last horizontal index */
 791
 792 unsigned char prep_b[] = {
 793
 794       rescale,
 795       loop,
 796     CALL,
 797   EIF,
 798
 799 };
 800
 801 unsigned char prep_c[] = {
 802
 803   /* optimize the alignment of the top of small letters to the pixel grid */
 804
 805   PUSHB_1,
 806
 807 };
 808
 809 /*  %c, index of alignment blue zone */
 810
 811 unsigned char prep_d[] = {
 812
 813   RCVT,
 814   DUP,
 815   DUP,
 816   PUSHB_1,
 817     40,
 818   ADD,
 819   FLOOR, /* fitted = FLOOR(scaled + 40) */
 820   DUP, /* s: scaled scaled fitted fitted */
 821   ROLL,
 822   NEQ,
 823   IF, /* s: scaled fitted */
 824     PUSHB_1,
 825       sal_0x10000,
 826     RS,
 827     MUL, /* scaled in 16.16 format */
 828     SWAP,
 829     DIV, /* (fitted / scaled) in 16.16 format */
 830
 831     PUSHB_1,
 832       sal_scale,
 833     SWAP,
 834     WS,
 835
 836     /* loop over vertical CVT entries */
 837     PUSHB_4,
 838
 839 };
 840
 841 /*    %c, first vertical index */
 842 /*    %c, last vertical index */
 843
 844 unsigned char prep_e[] = {
 845
 846       rescale,
 847       loop,
 848     CALL,
 849
 850     /* loop over blue refs */
 851     PUSHB_4,
 852
 853 };
 854
 855 /*    %c, first blue ref index */
 856 /*    %c, last blue ref index */
 857
 858 unsigned char prep_f[] = {
 859
 860       rescale,
 861       loop,
 862     CALL,
 863
 864     /* loop over blue shoots */
 865     PUSHB_4,
 866
 867 };
 868
 869 /*    %c, first blue shoot index */
 870 /*    %c, last blue shoot index */
 871
 872 unsigned char prep_g[] = {
 873
 874       rescale,
 875       loop,
 876     CALL,
 877
 878   EIF,
 879
 880 };
 881
 882
 883 static FT_Error
 884 TA_table_build_prep(FT_Byte** prep,
 885                     FT_ULong* prep_len,
 886                     FONT* font)
 887 {
 888   TA_LatinAxis vaxis;
 889   TA_LatinBlue blue_adjustment;
 890   FT_UInt i;
 891
 892   FT_UInt buf_len;
 893   FT_UInt len;
 894   FT_Byte* buf;
 895   FT_Byte* buf_p;
 896
 897
 898   vaxis = &((TA_LatinMetrics)font->loader->hints.metrics)->axis[1];
 899   blue_adjustment = NULL;
 900
 901   for (i = 0; i < vaxis->blue_count; i++)
 902   {
 903     if (vaxis->blues[i].flags & TA_LATIN_BLUE_ADJUSTMENT)
 904     {
 905       blue_adjustment = &vaxis->blues[i];
 906       break;
 907     }
 908   }
 909
 910   buf_len = sizeof (prep_A)
 911             + sizeof (prep_a)
 912             + 2
 913             + sizeof (prep_b);
 914
 915   if (blue_adjustment)
 916   {
 917     buf_len += sizeof (prep_c)
 918                + 1
 919                + sizeof (prep_d)
 920                + 2
 921                + sizeof (prep_e)
 922                + 2
 923                + sizeof (prep_f)
 924                + 2
 925                + sizeof (prep_g);
 926   }
 927
 928   /* buffer length must be a multiple of four */
 929   len = (buf_len + 3) & ~3;
 930   buf = (FT_Byte*)malloc(len);
 931   if (!buf)
 932     return FT_Err_Out_Of_Memory;
 933
 934   /* pad end of buffer with zeros */
 935   buf[len - 1] = 0x00;
 936   buf[len - 2] = 0x00;
 937   buf[len - 3] = 0x00;
 938
 939   /* copy cvt program into buffer and fill in the missing variables */
 940   buf_p = buf;
 941
 942   memcpy(buf_p, prep_A, sizeof (prep_A));
 943   buf_p += sizeof (prep_A);
 944
 945   memcpy(buf_p, prep_a, sizeof (prep_a));
 946   buf_p += sizeof (prep_a);
 947
 948   *(buf_p++) = (unsigned char)CVT_HORZ_WIDTHS_OFFSET(font);
 949   *(buf_p++) = (unsigned char)(CVT_HORZ_WIDTHS_OFFSET(font)
 950                                + CVT_HORZ_WIDTHS_SIZE(font) - 1);
 951
 952   memcpy(buf_p, prep_b, sizeof (prep_b));
 953
 954   if (blue_adjustment)
 955   {
 956     buf_p += sizeof (prep_b);
 957
 958     memcpy(buf_p, prep_c, sizeof (prep_c));
 959     buf_p += sizeof (prep_c);
 960
 961     *(buf_p++) = blue_adjustment - vaxis->blues
 962                  + CVT_BLUE_SHOOTS_OFFSET(font);
 963
 964     memcpy(buf_p, prep_d, sizeof (prep_d));
 965     buf_p += sizeof (prep_d);
 966
 967     *(buf_p++) = (unsigned char)CVT_VERT_WIDTHS_OFFSET(font);
 968     *(buf_p++) = (unsigned char)(CVT_VERT_WIDTHS_OFFSET(font)
 969                                  + CVT_VERT_WIDTHS_SIZE(font) - 1);
 970
 971     memcpy(buf_p, prep_e, sizeof (prep_e));
 972     buf_p += sizeof (prep_e);
 973
 974     *(buf_p++) = (unsigned char)CVT_BLUE_REFS_OFFSET(font);
 975     *(buf_p++) = (unsigned char)(CVT_BLUE_REFS_OFFSET(font)
 976                                  + CVT_BLUE_REFS_SIZE(font) - 1);
 977
 978     memcpy(buf_p, prep_f, sizeof (prep_f));
 979     buf_p += sizeof (prep_f);
 980
 981     *(buf_p++) = (unsigned char)CVT_BLUE_SHOOTS_OFFSET(font);
 982     *(buf_p++) = (unsigned char)(CVT_BLUE_SHOOTS_OFFSET(font)
 983                                  + CVT_BLUE_SHOOTS_SIZE(font) - 1);
 984
 985     memcpy(buf_p, prep_g, sizeof (prep_g));
 986   }
 987
 988   /* XXX handle extra_light */
 989
 990   *prep = buf;
 991   *prep_len = buf_len;
 992
 993   return FT_Err_Ok;
 994 }
 995
 996
 997 FT_Error
 998 TA_sfnt_build_prep_table(SFNT* sfnt,
 999                          FONT* font)
1000 {
1001   FT_Error error;
1002
1003   FT_Byte* prep_buf;
1004   FT_ULong prep_len;
1005
1006
1007   error = TA_sfnt_add_table_info(sfnt);
1008   if (error)
1009     return error;
1010
1011   error = TA_table_build_prep(&prep_buf, &prep_len, font);
1012   if (error)
1013     return error;
1014
1015   /* in case of success, `prep_buf' gets linked */
1016   /* and is eventually freed in `TA_font_unload' */
1017   error = TA_font_add_table(font,
1018                             &sfnt->table_infos[sfnt->num_table_infos - 1],
1019                             TTAG_prep, prep_len, prep_buf);
1020   if (error)
1021   {
1022     free(prep_buf);
1023     return error;
1024   }
1025
1026   return FT_Err_Ok;
1027 }
1028
1029
1030 /* we store the segments in the storage area; */
1031 /* each segment record consists of the first and last point */
1032
1033 static void
1034 TA_font_build_glyph_segments(FONT* font,
1035                              FT_Byte* bufp)
1036 {
1037   TA_GlyphHints hints = &font->loader->hints;
1038   TA_AxisHints axis = &hints->axis[TA_DIMENSION_VERT];
1039   TA_Point points = hints->points;
1040   TA_Segment segments = axis->segments;
1041   TA_Segment seg;
1042
1043   FT_UInt delta;
1044   FT_UInt count;
1045   FT_UInt limit;
1046   FT_UInt loop_limit;
1047   FT_UInt i;
1048
1049
1050   limit = axis->num_segments * 2 + 2;
1051   seg = segments;
1052
1053   /* NPUSHB and NPUSHW can't handle more than 256 stack elements */
1054
1055   if (hints->num_points > 0xFF)
1056   {
1057     count = 0;
1058
1059     if (limit - count > 256)
1060     {
1061       delta = 256;
1062       loop_limit = 128;
1063
1064       if (axis->num_segments == 127)
1065         loop_limit = 127;
1066     }
1067     else
1068     {
1069       delta = limit - count;
1070       loop_limit = (delta - 2) / 2;
1071     }
1072
1073     while (count < limit)
1074     {
1075       BCI(NPUSHW);
1076       BCI(delta);
1077
1078       for (i = 0; i < loop_limit; i++, seg++)
1079       {
1080         BCI(HIGH(seg->first - points));
1081         BCI(LOW(seg->first - points));
1082         BCI(HIGH(seg->last - points));
1083         BCI(LOW(seg->last - points));
1084       }
1085
1086       count += delta;
1087
1088       if (limit - count > 256)
1089       {
1090         delta = 256;
1091         loop_limit = 128;
1092
1093         if (axis->num_segments == 127)
1094           loop_limit = 127;
1095       }
1096       else
1097       {
1098         delta = limit - count;
1099         loop_limit = (delta - 2) / 2;
1100       }
1101     }
1102
1103     BCI(HIGH(sal_segment_offset));
1104     BCI(LOW(sal_segment_offset));
1105     BCI(HIGH(axis->num_segments * 2));
1106     BCI(LOW(axis->num_segments * 2));
1107   }
1108   else
1109   {
1110     count = 0;
1111
1112     if (limit - count > 256)
1113     {
1114       delta = 256;
1115       loop_limit = 128;
1116
1117       if (axis->num_segments == 127)
1118         loop_limit = 127;
1119     }
1120     else
1121     {
1122       delta = limit - count;
1123       loop_limit = (delta - 2) / 2;
1124     }
1125
1126     while (count < limit)
1127     {
1128       BCI(NPUSHB);
1129       BCI(delta);
1130
1131       for (i = 0; i < loop_limit; i++, seg++)
1132       {
1133         BCI(seg->first - points);
1134         BCI(seg->last - points);
1135       }
1136
1137       count += delta;
1138
1139       if (limit - count > 256)
1140       {
1141         delta = 256;
1142         loop_limit = 128;
1143
1144         if (axis->num_segments == 127)
1145           loop_limit = 127;
1146       }
1147       else
1148       {
1149         delta = limit - count;
1150         loop_limit = (delta - 2) / 2;
1151       }
1152     }
1153
1154     BCI(sal_segment_offset);
1155     BCI(axis->num_segments * 2);
1156   }
1157
1158   BCI(PUSHB_1);
1159   BCI(sal_loop_assign);
1160   BCI(CALL);
1161 }
1162
1163
1164 static void
1165 TA_font_clear_edge_DONE_flag(FONT* font)
1166 {
1167   TA_GlyphHints hints = &font->loader->hints;
1168   TA_AxisHints axis = &hints->axis[TA_DIMENSION_VERT];
1169   TA_Edge edges = axis->edges;
1170   TA_Edge edge_limit = edges + axis->num_edges;
1171   TA_Edge edge;
1172
1173
1174   for (edge = edges; edge < edge_limit; edge++)
1175     edge->flags &= ~TA_EDGE_DONE;
1176 }
1177
1178
1179 static FT_Error
1180 TA_construct_hinting_set(FONT* font,
1181                          FT_UInt size,
1182                          Hinting_Set* hinting_set)
1183 {
1184   hinting_set->size = size;
1185
1186   /* XXX use real values */
1187   hinting_set->num_edges2blues = 0;
1188   hinting_set->edges2blues = NULL;
1189   hinting_set->num_edges2links = 0;
1190   hinting_set->edges2links = NULL;
1191
1192   return FT_Err_Ok;
1193 }
1194
1195
1196 static FT_Bool
1197 TA_hinting_set_is_different(Hinting_Set* hinting_sets,
1198                             FT_UInt num_hinting_sets,
1199                             Hinting_Set hinting_set)
1200 {
1201   Hinting_Set last_hinting_set;
1202
1203   Edge2Blue* edge2blue;
1204   Edge2Blue* last_edge2blue;
1205   Edge2Link* edge2link;
1206   Edge2Link* last_edge2link;
1207
1208   FT_UInt i;
1209
1210
1211   if (!hinting_sets)
1212     return 1;
1213
1214   /* we only need to compare with the last hinting set */
1215   last_hinting_set = hinting_sets[num_hinting_sets - 1];
1216
1217   if (hinting_set.num_edges2blues
1218       != last_hinting_set.num_edges2blues)
1219     return 1;
1220
1221   edge2blue = hinting_set.edges2blues;
1222   last_edge2blue = last_hinting_set.edges2blues;
1223
1224   for (i = 0;
1225        i < hinting_set.num_edges2blues;
1226        i++, edge2blue++, last_edge2blue++)
1227   {
1228     if (edge2blue->num_remaining_segments
1229         != last_edge2blue->num_remaining_segments)
1230       return 1;
1231
1232     if (edge2blue->remaining_segments)
1233     {
1234       if (memcmp(edge2blue->remaining_segments,
1235                  last_edge2blue->remaining_segments,
1236                  sizeof (FT_UInt) * edge2blue->num_remaining_segments))
1237         return 1;
1238     }
1239   }
1240
1241   if (hinting_set.num_edges2links
1242       != last_hinting_set.num_edges2links)
1243     return 1;
1244
1245   edge2link = hinting_set.edges2links;
1246   last_edge2link = last_hinting_set.edges2links;
1247
1248   for (i = 0;
1249        i < hinting_set.num_edges2links;
1250        i++, edge2link++, last_edge2link++)
1251   {
1252     if (edge2link->num_remaining_segments
1253         != last_edge2link->num_remaining_segments)
1254       return 1;
1255
1256     if (edge2link->remaining_segments)
1257     {
1258       if (memcmp(edge2link->remaining_segments,
1259                  last_edge2link->remaining_segments,
1260                  sizeof (FT_UInt) * edge2link->num_remaining_segments))
1261         return 1;
1262     }
1263   }
1264
1265   return 0;
1266 }
1267
1268
1269 static FT_Error
1270 TA_add_hinting_set(Hinting_Set** hinting_sets,
1271                    FT_UInt* num_hinting_sets,
1272                    Hinting_Set hinting_set)
1273 {
1274   Hinting_Set* hinting_sets_new;
1275
1276
1277   (*num_hinting_sets)++;
1278   hinting_sets_new =
1279     (Hinting_Set*)realloc(*hinting_sets, *num_hinting_sets
1280                                          * sizeof (Hinting_Set));
1281   if (!hinting_sets_new)
1282   {
1283     (*num_hinting_sets)--;
1284     return FT_Err_Out_Of_Memory;
1285   }
1286   else
1287     *hinting_sets = hinting_sets_new;
1288
1289   *hinting_sets[*num_hinting_sets - 1] = hinting_set;
1290
1291   return FT_Err_Ok;
1292 }
1293
1294
1295 static void
1296 TA_free_hinting_set(Hinting_Set hinting_set)
1297 {
1298   FT_UInt i;
1299
1300
1301   for (i = 0; i < hinting_set.num_edges2blues; i++)
1302     free(hinting_set.edges2blues[i].remaining_segments);
1303   free(hinting_set.edges2blues);
1304
1305   for (i = 0; i < hinting_set.num_edges2links; i++)
1306     free(hinting_set.edges2links[i].remaining_segments);
1307   free(hinting_set.edges2links);
1308 }
1309
1310
1311 static void
1312 TA_free_hinting_sets(Hinting_Set* hinting_sets,
1313                      FT_UInt num_hinting_sets)
1314 {
1315   FT_UInt i;
1316
1317
1318   for (i = 0; i < num_hinting_sets; i++)
1319     TA_free_hinting_set(hinting_sets[i]);
1320
1321   free(hinting_sets);
1322 }
1323
1324
1325 static FT_Error
1326 TA_sfnt_build_glyph_instructions(SFNT* sfnt,
1327                                  FONT* font,
1328                                  FT_Long idx)
1329 {
1330   FT_Face face = sfnt->face;
1331   FT_Error error;
1332
1333   FT_Byte* ins_buf;
1334   FT_UInt ins_len;
1335   FT_Byte* p;
1336
1337   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
1338   glyf_Data* data = (glyf_Data*)glyf_table->data;
1339   GLYPH* glyph = &data->glyphs[idx];
1340
1341   TA_GlyphHints hints;
1342
1343   FT_UInt num_hinting_sets;
1344   Hinting_Set* hinting_sets;
1345
1346   FT_UInt size;
1347
1348
1349   if (idx < 0)
1350     return FT_Err_Invalid_Argument;
1351
1352   /* computing the segments is resolution independent, */
1353   /* thus the pixel size in this call is arbitrary */
1354   error = FT_Set_Pixel_Sizes(face, 20, 20);
1355   if (error)
1356     return error;
1357
1358   error = ta_loader_load_glyph(font->loader, face, (FT_UInt)idx, 0);
1359   if (error)
1360     return error;
1361
1362   /* do nothing if we have an empty glyph */
1363   if (!face->glyph->outline.n_contours)
1364     return FT_Err_Ok;
1365
1366   hints = &font->loader->hints;
1367
1368   /* we allocate a buffer which is certainly large enough */
1369   /* to hold all of the created bytecode instructions; */
1370   /* later on it gets reallocated to its real size */
1371   ins_len = hints->num_points * 1000;
1372   ins_buf = (FT_Byte*)malloc(ins_len);
1373   if (!ins_buf)
1374     return FT_Err_Out_Of_Memory;
1375
1376   /* initialize array with an invalid bytecode */
1377   /* so that we can easily find the array length at reallocation time */
1378   memset(ins_buf, INS_A0, ins_len);
1379
1380   TA_font_build_glyph_segments(font, ins_buf);
1381
1382   /* now we loop over a large range of pixel sizes */
1383   /* to find hinting sets which get pushed onto the bytecode stack */
1384   num_hinting_sets = 0;
1385   hinting_sets = NULL;
1386
1387   for (size = 8; size <= 10; size++)
1388   {
1389     Hinting_Set hinting_set;
1390
1391
1392     error = FT_Set_Pixel_Sizes(face, size, size);
1393     if (error)
1394       goto Err;
1395
1396     error = ta_loader_load_glyph(font->loader, face, idx, 0);
1397     if (error)
1398       goto Err;
1399
1400     TA_font_clear_edge_DONE_flag(font);
1401
1402     error = TA_construct_hinting_set(font, size, &hinting_set);
1403     if (error)
1404       goto Err;
1405
1406     if (TA_hinting_set_is_different(hinting_sets,
1407                                     num_hinting_sets,
1408                                     hinting_set))
1409     {
1410       error = TA_add_hinting_set(&hinting_sets,
1411                                  &num_hinting_sets,
1412                                  hinting_set);
1413       if (error)
1414       {
1415         TA_free_hinting_set(hinting_set);
1416         goto Err;
1417       }
1418     }
1419     else
1420       TA_free_hinting_set(hinting_set);
1421   }
1422
1423   /* push hinting sets */
1424   /* XXX: emit hinting instructions */
1425
1426   /* we are done, so reallocate the instruction array to its real size */
1427   p = (FT_Byte*)memchr((char*)ins_buf, INS_A0, ins_len);
1428   ins_len = p - ins_buf;
1429
1430   if (ins_len > sfnt->max_instructions)
1431     sfnt->max_instructions = ins_len;
1432
1433   glyph->ins_buf = realloc(ins_buf, ins_len);
1434   glyph->ins_len = ins_len;
1435
1436   TA_free_hinting_sets(hinting_sets, num_hinting_sets);
1437
1438   return FT_Err_Ok;
1439
1440 Err:
1441   TA_free_hinting_sets(hinting_sets, num_hinting_sets);
1442   free(ins_buf);
1443
1444   return error;
1445 }
1446
1447
1448 FT_Error
1449 TA_sfnt_build_glyf_hints(SFNT* sfnt,
1450                          FONT* font)
1451 {
1452   FT_Face face = sfnt->face;
1453   FT_Long idx;
1454   FT_Error error;
1455
1456
1457   for (idx = 0; idx < face->num_glyphs; idx++)
1458   {
1459     error = TA_sfnt_build_glyph_instructions(sfnt, font, idx);
1460     if (error)
1461       return error;
1462   }
1463
1464   /* XXX provide real values or better estimates */
1465   sfnt->max_storage = 1000;
1466   sfnt->max_stack_elements = 1000;
1467
1468   return FT_Err_Ok;
1469 }
1470
1471 /* end of tabytecode.c */