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 #ifdef TA_DEBUG
  10 int _ta_debug = 1;
  11 int _ta_debug_disable_horz_hints;
  12 int _ta_debug_disable_vert_hints;
  13 int _ta_debug_disable_blue_hints;
  14 void* _ta_debug_hints;
  15 #endif
  16
  17
  18 static FT_Error
  19 TA_sfnt_compute_global_hints(SFNT* sfnt,
  20                              FONT* font)
  21 {
  22   FT_Error error;
  23   FT_Face face = sfnt->face;
  24   FT_UInt enc;
  25   FT_UInt idx;
  26
  27   static const FT_Encoding latin_encs[] =
  28   {
  29     FT_ENCODING_UNICODE,
  30     FT_ENCODING_APPLE_ROMAN,
  31     FT_ENCODING_ADOBE_STANDARD,
  32     FT_ENCODING_ADOBE_LATIN_1,
  33
  34     FT_ENCODING_NONE /* end of list */
  35   };
  36
  37
  38   error = ta_loader_init(font->loader);
  39   if (error)
  40     return error;
  41
  42   /* try to select a latin charmap */
  43   for (enc = 0; latin_encs[enc] != FT_ENCODING_NONE; enc++)
  44   {
  45     error = FT_Select_Charmap(face, latin_encs[enc]);
  46     if (!error)
  47       break;
  48   }
  49
  50   /* load latin glyph `a' to trigger all initializations */
  51   idx = FT_Get_Char_Index(face, 'a');
  52   error = ta_loader_load_glyph(font->loader, face, idx, 0);
  53
  54   return error;
  55 }
  56
  57
  58 static FT_Error
  59 TA_table_build_cvt(FT_Byte** cvt,
  60                    FT_ULong* cvt_len,
  61                    SFNT* sfnt,
  62                    FONT* font)
  63 {
  64   TA_LatinAxis haxis;
  65   TA_LatinAxis vaxis;
  66   TA_LatinBlue blue;
  67
  68   FT_UInt i;
  69   FT_UInt buf_len;
  70   FT_Byte* buf;
  71   FT_Byte* buf_p;
  72
  73   FT_Error error;
  74
  75
  76   error = TA_sfnt_compute_global_hints(sfnt, font);
  77   if (error)
  78     return error;
  79
  80   /* XXX check validity of pointers */
  81   haxis = &((TA_LatinMetrics)font->loader->hints.metrics)->axis[0];
  82   vaxis = &((TA_LatinMetrics)font->loader->hints.metrics)->axis[1];
  83
  84   buf_len = 2 * (haxis->width_count + vaxis->width_count
  85                  + 2 * vaxis->blue_count);
  86   buf = (FT_Byte*)malloc(buf_len);
  87   if (!buf)
  88     return FT_Err_Out_Of_Memory;
  89
  90   buf_p = buf;
  91
  92   /* XXX emit standard_width also? */
  93
  94   for (i = 0; i < haxis->width_count; i++)
  95   {
  96     if (haxis->widths[i].org > 0xFFFF)
  97       goto Err;
  98     *(buf_p++) = HIGH(haxis->widths[i].org);
  99     *(buf_p++) = LOW(haxis->widths[i].org);
 100   }
 101
 102   for (i = 0; i < vaxis->width_count; i++)
 103   {
 104     if (vaxis->widths[i].org > 0xFFFF)
 105       goto Err;
 106     *(buf_p++) = HIGH(vaxis->widths[i].org);
 107     *(buf_p++) = LOW(vaxis->widths[i].org);
 108   }
 109
 110   for (i = 0; i < vaxis->blue_count; i++)
 111   {
 112     if (vaxis->blues[i].ref.org > 0xFFFF)
 113       goto Err;
 114     *(buf_p++) = HIGH(vaxis->blues[i].ref.org);
 115     *(buf_p++) = LOW(vaxis->blues[i].ref.org);
 116     if (vaxis->blues[i].shoot.org > 0xFFFF)
 117       goto Err;
 118     *(buf_p++) = HIGH(vaxis->blues[i].shoot.org);
 119     *(buf_p++) = LOW(vaxis->blues[i].shoot.org);
 120   }
 121
 122 #if 0
 123   TA_LOG(("--------------------------------------------------\n"));
 124   TA_LOG(("glyph %d:\n", idx));
 125   ta_glyph_hints_dump_edges(_ta_debug_hints);
 126   ta_glyph_hints_dump_segments(_ta_debug_hints);
 127   ta_glyph_hints_dump_points(_ta_debug_hints);
 128 #endif
 129
 130   *cvt = buf;
 131   *cvt_len = buf_len;
 132
 133   return FT_Err_Ok;
 134
 135 Err:
 136   free(buf);
 137   return TA_Err_Hinter_Overflow;
 138 }
 139
 140
 141 FT_Error
 142 TA_sfnt_build_cvt_table(SFNT* sfnt,
 143                         FONT* font)
 144 {
 145   FT_Error error;
 146
 147   FT_Byte* cvt_buf;
 148   FT_ULong cvt_len;
 149
 150
 151   error = TA_sfnt_add_table_info(sfnt);
 152   if (error)
 153     return error;
 154
 155   error = TA_table_build_cvt(&cvt_buf, &cvt_len, sfnt, font);
 156   if (error)
 157     return error;
 158
 159   /* in case of success, `cvt_buf' gets linked */
 160   /* and is eventually freed in `TA_font_unload' */
 161   error = TA_font_add_table(font,
 162                             &sfnt->table_infos[sfnt->num_table_infos - 1],
 163                             TTAG_cvt, cvt_len, cvt_buf);
 164   if (error)
 165   {
 166     free(cvt_buf);
 167     return error;
 168   }
 169 }
 170
 171
 172 /* the horizontal stem widths */
 173 #define CVT_HORZ_WIDTHS_OFFSET(font) 0
 174 #define CVT_HORZ_WIDTHS_SIZE(font) \
 175           ((TA_LatinMetrics)font->loader->hints.metrics)->axis[0].width_count
 176
 177 /* the vertical stem widths */
 178 #define CVT_VERT_WIDTHS_OFFSET(font) \
 179           CVT_HORZ_WIDTHS_OFFSET(font) \
 180           + ((TA_LatinMetrics)font->loader->hints.metrics)->axis[0].width_count
 181 #define CVT_VERT_WIDTHS_SIZE(font) \
 182           ((TA_LatinMetrics)font->loader->hints.metrics)->axis[1].width_count
 183
 184 /* the blue zone values for flat edges */
 185 #define CVT_BLUE_REFS_OFFSET(font) \
 186           CVT_VERT_WIDTHS_OFFSET(font) \
 187           + ((TA_LatinMetrics)font->loader->hints.metrics)->axis[1].width_count
 188 #define CVT_BLUE_REFS_SIZE(font) \
 189           ((TA_LatinMetrics)font->loader->hints.metrics)->axis[1].blue_count
 190
 191 /* the blue zone values for round edges */
 192 #define CVT_BLUE_SHOOTS_OFFSET(font) \
 193           CVT_BLUE_REFS_OFFSET(font) \
 194           + ((TA_LatinMetrics)font->loader->hints.metrics)->axis[1].blue_count
 195 #define CVT_BLUE_SHOOTS_SIZE(font) \
 196           ((TA_LatinMetrics)font->loader->hints.metrics)->axis[1].blue_count
 197
 198
 199 /* symbolic names for storage area locations */
 200
 201 #define sal_counter 0,
 202 #define sal_limit 1,
 203 #define sal_scale 2,
 204 #define sal_0x10000 3,
 205
 206
 207 /* in the comments below, the top of the stack (`s:') */
 208 /* is the rightmost element; the stack is shown */
 209 /* after the instruction on the same line has been executed */
 210
 211 /*
 212  * compute_stem_width
 213  *
 214  *   This is the equivalent to the following code from function
 215  *   `ta_latin_compute_stem_width':
 216  *
 217  *      dist = ABS(width)
 218  *
 219  *      if stem_is_serif
 220  *         && dist < 3*64:
 221  *        return width
 222  *      else if base_is_round:
 223  *        if dist < 80
 224  *          dist = 64
 225  *      else:
 226  *        dist = MIN(56, dist)
 227  *
 228  *      delta = ABS(dist - std_width)
 229  *
 230  *      if delta < 40:
 231  *        dist = MIN(48, std_width)
 232  *        goto End
 233  *
 234  *      if dist < 3*64:
 235  *        delta = dist
 236  *        dist = FLOOR(dist)
 237  *        delta = delta - dist
 238  *
 239  *        if delta < 10:
 240  *          dist = dist + delta
 241  *        else if delta < 32:
 242  *          dist = dist + 10
 243  *        else if delta < 54:
 244  *          dist = dist + 54
 245  *        else
 246  *          dist = dist + delta
 247  *      else
 248  *        dist = ROUND(dist)
 249  *
 250  *    End:
 251  *      if width < 0:
 252  *        dist = -dist
 253  *      return dist
 254  *
 255  *
 256  *
 257  * Function 0: compute_stem_width
 258  *
 259  * in: width
 260  *     stem_is_serif
 261  *     base_is_round
 262  * out: new_width
 263  * CVT: is_extra_light   XXX
 264  *      std_width
 265  */
 266
 267 #define compute_stem_width 0,
 268
 269 unsigned char fpgm_0a[] = {
 270
 271   PUSHB_1
 272     compute_stem_width
 273   FDEF
 274
 275   DUP
 276   ABS /* s: base_is_round stem_is_serif width dist */
 277
 278   DUP
 279   PUSHB_1
 280     3*64,
 281   LT /* dist < 3*64 */
 282
 283   PUSHB_1
 284     4,
 285   MINDEX /* s: base_is_round width dist (dist<3*64) stem_is_serif */
 286
 287   AND /* stem_is_serif && dist < 3*64 */
 288   IF /* s: base_is_round width dist */
 289     POP
 290     SWAP
 291     POP /* s: width */
 292
 293   ELSE
 294     ROLL /* s: width dist base_is_round */
 295     IF /* s: width dist */
 296       DUP
 297       PUSHB_1
 298         80,
 299       LT /* dist < 80 */
 300       IF /* s: width dist */
 301         POP
 302         PUSHB_1
 303           64, /* dist = 64 */
 304       EIF
 305
 306     ELSE
 307       PUSHB_1
 308         56,
 309       MIN /* dist = min(56, dist) */
 310     EIF
 311
 312     DUP /* s: width dist dist */
 313     PUSHB_1
 314
 315 };
 316
 317 /*    %c, index of std_width */
 318
 319 unsigned char fpgm_0b[] = {
 320
 321     RCVT
 322     SUB
 323     ABS /* s: width dist delta */
 324
 325     PUSHB_1
 326       40,
 327     LT /* delta < 40 */
 328     IF /* s: width dist */
 329       POP
 330       PUSHB_2
 331         48,
 332
 333 };
 334
 335 /*      %c, index of std_width */
 336
 337 unsigned char fpgm_0c[] = {
 338
 339       RCVT
 340       MIN /* dist = min(48, std_width) */
 341
 342     ELSE
 343       DUP /* s: width dist dist */
 344       PUSHB_1
 345         3*64,
 346       LT /* dist < 3*64 */
 347       IF
 348         DUP /* s: width delta dist */
 349         FLOOR /* dist = FLOOR(dist) */
 350         DUP /* s: width delta dist dist */
 351         ROLL
 352         ROLL /* s: width dist delta dist */
 353         SUB /* delta = delta - dist */
 354
 355         DUP /* s: width dist delta delta */
 356         PUSHB_1
 357           10,
 358         LT /* delta < 10 */
 359         IF /* s: width dist delta */
 360           ADD /* dist = dist + delta */
 361
 362         ELSE
 363           DUP
 364           PUSHB_1
 365             32,
 366           LT /* delta < 32 */
 367           IF
 368             POP
 369             PUSHB_1
 370               10,
 371             ADD /* dist = dist + 10 */
 372
 373           ELSE
 374             DUP
 375             PUSHB_1
 376               54,
 377             LT /* delta < 54 */
 378             IF
 379               POP
 380               PUSHB_1
 381                 54,
 382               ADD /* dist = dist + 54 */
 383
 384             ELSE
 385               ADD /* dist = dist + delta */
 386
 387             EIF
 388           EIF
 389         EIF
 390
 391         ELSE
 392           PUSHB_1
 393             32,
 394           ADD
 395           FLOOR /* dist = round(dist) */
 396
 397         EIF
 398       EIF
 399
 400       SWAP /* s: dist width */
 401       PUSHB_1
 402         0,
 403       LT /* width < 0 */
 404       NEG /* dist = -dist */
 405
 406     EIF
 407   EIF
 408
 409   ENDF
 410
 411 };
 412
 413
 414 /*
 415  * loop
 416  *
 417  *   Take a range and a function number and apply the function to all
 418  *   elements of the range.  The called function must not change the
 419  *   stack.
 420  *
 421  * Function 1: loop
 422  *
 423  * in: func_num
 424  *     end
 425  *     start
 426  *
 427  * uses: sal_counter (counter initialized with `start')
 428  *       sal_limit (`end')
 429  */
 430
 431 #define loop 1,
 432
 433 unsigned char fpgm_1[] = {
 434
 435   PUSHB_1
 436     loop
 437   FDEF
 438
 439   ROLL /* s: func_num start end */
 440   PUSHB_1
 441     sal_limit
 442   SWAP
 443   WS
 444
 445   PUSHB_1
 446     sal_counter
 447   SWAP
 448   WS
 449
 450 /* start_loop: */
 451   PUSHB_1
 452     sal_counter
 453   RS
 454   PUSHB_1
 455     sal_limit
 456   RS
 457   LTEQ /* start <= end */
 458   IF /* s: func_num */
 459     DUP
 460     CALL
 461     PUSHB_2
 462       1,
 463       sal_counter
 464     RS
 465     ADD /* start = start + 1 */
 466     PUSHB_1
 467       sal_counter
 468     SWAP
 469     WS
 470
 471     PUSHB_1
 472       22,
 473     NEG
 474     JMPR /* goto start_loop */
 475   ELSE
 476     POP
 477   EIF
 478
 479   ENDF
 480
 481 };
 482
 483
 484 /*
 485  * rescale_horizontally
 486  *
 487  *   All entries in the CVT table get scaled automatically using the
 488  *   vertical resolution.  However, some widths must be scaled with the
 489  *   horizontal resolution.
 490  *
 491  * Function 2: rescale_horizontally
 492  *
 493  * uses: sal_counter (CVT index)
 494  *       sal_scale (scale in 16.16 format)
 495  */
 496
 497 #define rescale_horizontally 2,
 498
 499 unsigned char fpgm_2[] = {
 500
 501   PUSHB_1
 502     rescale_horizontally
 503   FDEF
 504
 505   PUSHB_1
 506     sal_counter
 507   RS
 508   DUP
 509   RCVT
 510   PUSHB_1
 511     sal_scale
 512   RS
 513   MUL /* CVT * scale * 2^10 */
 514   PUSHB_1
 515     sal_0x10000
 516   RS
 517   DIV /* CVT * scale */
 518
 519   SWAP
 520   WCVTP
 521
 522   ENDF
 523
 524 };
 525
 526
 527 /* we often need 0x10000 which can't be pushed directly onto the stack, */
 528 /* thus we provide it in the storage area */
 529
 530 unsigned char fpgm_A[] = {
 531
 532   PUSHB_1
 533     sal_0x10000
 534   PUSHW_2
 535     0x08, /* 0x800 */
 536     0x00,
 537     0x08, /* 0x800 */
 538     0x00,
 539   MUL /* 0x10000 */
 540   WS
 541
 542 };
 543
 544
 545 static FT_Error
 546 TA_table_build_fpgm(FT_Byte** fpgm,
 547                     FT_ULong* fpgm_len,
 548                     FONT* font)
 549 {
 550   FT_UInt buf_len;
 551   FT_Byte* buf;
 552   FT_Byte* buf_p;
 553
 554
 555   buf_len = sizeof (fpgm_0a)
 556             + 1
 557             + sizeof (fpgm_0b)
 558             + 1
 559             + sizeof (fpgm_0c)
 560             + sizeof (fpgm_1)
 561             + sizeof (fpgm_2)
 562             + sizeof (fpgm_A);
 563   buf = (FT_Byte*)malloc(buf_len);
 564   if (!buf)
 565     return FT_Err_Out_Of_Memory;
 566
 567   /* copy font program into buffer and fill in the missing variables */
 568   buf_p = buf;
 569   memcpy(buf_p, fpgm_0a, sizeof (fpgm_0a));
 570   buf_p += sizeof (fpgm_0a);
 571   *(buf_p++) = (unsigned char)CVT_VERT_WIDTHS_OFFSET(font);
 572   memcpy(buf_p, fpgm_0b, sizeof (fpgm_0b));
 573   buf_p += sizeof (fpgm_0b);
 574   *(buf_p++) = (unsigned char)CVT_VERT_WIDTHS_OFFSET(font);
 575   memcpy(buf_p, fpgm_0c, sizeof (fpgm_0c));
 576   buf_p += sizeof (fpgm_0c);
 577   memcpy(buf_p, fpgm_1, sizeof (fpgm_1));
 578   buf_p += sizeof (fpgm_1);
 579   memcpy(buf_p, fpgm_2, sizeof (fpgm_2));
 580   buf_p += sizeof (fpgm_2);
 581   memcpy(buf_p, fpgm_A, sizeof (fpgm_A));
 582
 583   *fpgm = buf;
 584   *fpgm_len = buf_len;
 585
 586   return FT_Err_Ok;
 587 }
 588
 589
 590 FT_Error
 591 TA_sfnt_build_fpgm_table(SFNT* sfnt,
 592                          FONT* font)
 593 {
 594   FT_Error error;
 595
 596   FT_Byte* fpgm_buf;
 597   FT_ULong fpgm_len;
 598
 599
 600   error = TA_sfnt_add_table_info(sfnt);
 601   if (error)
 602     return error;
 603
 604   error = TA_table_build_fpgm(&fpgm_buf, &fpgm_len, font);
 605   if (error)
 606     return error;
 607
 608   /* in case of success, `fpgm_buf' gets linked */
 609   /* and is eventually freed in `TA_font_unload' */
 610   error = TA_font_add_table(font,
 611                             &sfnt->table_infos[sfnt->num_table_infos - 1],
 612                             TTAG_fpgm, fpgm_len, fpgm_buf);
 613   if (error)
 614   {
 615     free(fpgm_buf);
 616     return error;
 617   }
 618 }
 619
 620
 621 /* the `prep' instructions */
 622
 623 unsigned char prep_a[] = {
 624
 625   /* scale horizontal CVT entries */
 626   /* if horizontal and vertical resolutions differ */
 627
 628   SVTCA_x
 629   MPPEM
 630   SVTCA_y
 631   MPPEM
 632   NEQ /* horz_ppem != vert_ppem */
 633   IF
 634     SVTCA_x
 635     MPPEM
 636     PUSHB_1
 637       sal_0x10000
 638     RS
 639     MUL /* horz_ppem in 22.10 format */
 640
 641     SVTCA_y
 642     MPPEM
 643     DIV /* (horz_ppem / vert_ppem) in 16.16 format */
 644
 645     PUSHB_1
 646       sal_scale
 647     SWAP
 648     WS
 649
 650     /* loop over horizontal CVT entries */
 651     PUSHB_4
 652
 653 };
 654
 655 /*    %c, first horizontal index */
 656 /*    %c, last horizontal index */
 657
 658 unsigned char prep_b[] = {
 659
 660       rescale_horizontally
 661       loop
 662     CALL
 663   EIF
 664
 665 };
 666
 667
 668 static FT_Error
 669 TA_table_build_prep(FT_Byte** prep,
 670                     FT_ULong* prep_len,
 671                     FONT* font)
 672 {
 673   FT_UInt buf_len;
 674   FT_Byte* buf;
 675   FT_Byte* buf_p;
 676
 677
 678   buf_len = sizeof (prep_a)
 679             + 2
 680             + sizeof (prep_b);
 681   buf = (FT_Byte*)malloc(buf_len);
 682   if (!buf)
 683     return FT_Err_Out_Of_Memory;
 684
 685   /* copy cvt program into buffer and fill in the missing variables */
 686   buf_p = buf;
 687   memcpy(buf_p, prep_a, sizeof (prep_a));
 688   buf_p += sizeof (prep_a);
 689   *(buf_p++) = (unsigned char)CVT_HORZ_WIDTHS_OFFSET(font);
 690   *(buf_p++) = (unsigned char)(CVT_HORZ_WIDTHS_OFFSET(font)
 691                                + CVT_HORZ_WIDTHS_SIZE(font) - 1);
 692   memcpy(buf_p, prep_b, sizeof (prep_b));
 693
 694   *prep = buf;
 695   *prep_len = buf_len;
 696
 697   return FT_Err_Ok;
 698 }
 699
 700
 701 FT_Error
 702 TA_sfnt_build_prep_table(SFNT* sfnt,
 703                          FONT* font)
 704 {
 705   FT_Error error;
 706
 707   FT_Byte* prep_buf;
 708   FT_ULong prep_len;
 709
 710
 711   error = TA_sfnt_add_table_info(sfnt);
 712   if (error)
 713     return error;
 714
 715   error = TA_table_build_prep(&prep_buf, &prep_len, font);
 716   if (error)
 717     return error;
 718
 719   /* in case of success, `prep_buf' gets linked */
 720   /* and is eventually freed in `TA_font_unload' */
 721   error = TA_font_add_table(font,
 722                             &sfnt->table_infos[sfnt->num_table_infos - 1],
 723                             TTAG_prep, prep_len, prep_buf);
 724   if (error)
 725   {
 726     free(prep_buf);
 727     return error;
 728   }
 729 }
 730
 731 /* end of tabytecode.c */