lib/taprep.c

   1 /* taprep.c */
   2
   3 /*
   4  * Copyright (C) 2011-2017 by Werner Lemberg.
   5  *
   6  * This file is part of the ttfautohint library, and may only be used,
   7  * modified, and distributed under the terms given in `COPYING'.  By
   8  * continuing to use, modify, or distribute this file you indicate that you
   9  * have read `COPYING' and understand and accept it fully.
  10  *
  11  * The file `COPYING' mentioned in the previous paragraph is distributed
  12  * with the ttfautohint library.
  13  */
  14
  15
  16 #include "ta.h"
  17
  18
  19 #define PREP(snippet_name) prep_ ## snippet_name
  20
  21
  22 static const unsigned char PREP(hinting_limit_a) [] =
  23 {
  24
  25   /* all our measurements are taken along the y axis, */
  26   /* including the ppem and CVT values */
  27   SVTCA_y,
  28
  29   /* first of all, check whether we do hinting at all */
  30   MPPEM,
  31   PUSHW_1,
  32
  33 };
  34
  35 /*  %d, hinting size limit */
  36
  37 static const unsigned char PREP(hinting_limit_b) [] =
  38 {
  39
  40   GT,
  41   IF,
  42     PUSHB_2,
  43       1, /* switch off hinting */
  44       1,
  45     INSTCTRL,
  46   EIF,
  47
  48 };
  49
  50 /* we store 0x10000 in CVT index `cvtl_funits_to_pixels' as a scaled value */
  51 /* to have a conversion factor from FUnits to pixels */
  52
  53 static const unsigned char PREP(store_funits_to_pixels) [] =
  54 {
  55
  56   PUSHB_1,
  57     cvtl_funits_to_pixels,
  58
  59   PUSHW_2,
  60     0x08, /* 0x800 */
  61     0x00,
  62     0x08, /* 0x800 */
  63     0x00,
  64   MUL, /* 0x10000 */
  65
  66   WCVTF, /* store value 1 in 16.16 format, scaled */
  67
  68 };
  69
  70 /* if the current ppem value is an exception, don't apply scaling */
  71
  72 static const unsigned char PREP(test_exception_a) [] =
  73 {
  74
  75   PUSHB_1,
  76     cvtl_is_element,
  77   RCVT,
  78   NOT,
  79   IF,
  80
  81 };
  82
  83 /* provide scaling factors for all styles */
  84
  85 static const unsigned char PREP(align_x_height_a) [] =
  86 {
  87
  88     PUSHB_2,
  89       sal_i,
  90       CVT_SCALING_VALUE_OFFSET(0),
  91     WS,
  92
  93 };
  94
  95 /*  PUSHB (num_used_styles + 2) */
  96 /*    ... */
  97 /*    %c, style 1's x height blue zone idx */
  98 /*    %c, style 0's x height blue zone idx */
  99 /*    %c, num_used_styles */
 100
 101 static const unsigned char PREP(align_x_height_b) [] =
 102 {
 103
 104       bci_align_x_height,
 105     LOOPCALL,
 106
 107 };
 108
 109 static const unsigned char PREP(loop_cvt_a) [] =
 110 {
 111
 112     /* loop over (almost all) vertical CVT entries of all styles, part 1 */
 113     PUSHB_2,
 114       sal_i,
 115       CVT_SCALING_VALUE_OFFSET(0),
 116     WS,
 117
 118 };
 119
 120 /*  PUSHB (2*num_used_styles + 2) */
 121 /*    ... */
 122 /*    %c, style 1's first vertical index */
 123 /*    %c, style 1's number of vertical indices */
 124 /*        (std. width, widths, flat blues zones without artifical ones) */
 125 /*    %c, style 0's first vertical index */
 126 /*    %c, style 0's number of vertical indices */
 127 /*        (std. width, widths, flat blues zones without artifical ones) */
 128 /*    %c, num_used_styles */
 129
 130 static const unsigned char PREP(loop_cvt_b) [] =
 131 {
 132
 133       bci_cvt_rescale_range,
 134     LOOPCALL,
 135
 136     /* loop over (almost all) vertical CVT entries of all styles, part 2 */
 137     PUSHB_2,
 138       sal_i,
 139       CVT_SCALING_VALUE_OFFSET(0),
 140     WS,
 141
 142 };
 143
 144 /*  PUSHB (2*num_used_styles + 2) */
 145 /*    ... */
 146 /*    %c, style 1's first round blue zone index */
 147 /*    %c, style 1's number of round blue zones (without artificial ones) */
 148 /*    %c, style 0's first round blue zone index */
 149 /*    %c, style 0's number of round blue zones (without artificial ones) */
 150 /*    %c, num_used_styles */
 151
 152 static const unsigned char PREP(loop_cvt_c) [] =
 153 {
 154
 155       bci_cvt_rescale_range,
 156     LOOPCALL,
 157
 158 };
 159
 160 static const unsigned char PREP(test_exception_b) [] =
 161 {
 162
 163   EIF,
 164
 165 };
 166
 167 static const unsigned char PREP(store_vwidth_data_a) [] =
 168 {
 169
 170   PUSHB_2,
 171     sal_i,
 172
 173 };
 174
 175 /*  %c, offset to vertical width offset data in CVT */
 176
 177 static const unsigned char PREP(store_vwidth_data_b) [] =
 178 {
 179
 180   WS,
 181
 182 };
 183
 184 /*PUSHW (num_used_styles + 2) */
 185 /*  ... */
 186 /*  %d, style 1's first vertical width index (in multiples of 64) */
 187 /*  %d, style 0's first vertical width index (in multiples of 64) */
 188 /*  %d, num_used_styles */
 189
 190 static const unsigned char PREP(store_vwidth_data_c) [] =
 191 {
 192
 193     0x00, /* high byte */
 194     bci_vwidth_data_store, /* low byte */
 195   LOOPCALL,
 196
 197   PUSHB_2,
 198     sal_i,
 199
 200 };
 201
 202 /*  %c, offset to vertical width size data in CVT */
 203
 204 static const unsigned char PREP(store_vwidth_data_d) [] =
 205 {
 206
 207   WS,
 208
 209 };
 210
 211 /*PUSHW (num_used_styles + 2) */
 212 /*  ... */
 213 /*  %d, style 1's number of vertical widths (in multiples of 64) */
 214 /*  %d, style 0's number of vertical widths (in multiples of 64) */
 215 /*  %d, num_used_styles */
 216
 217 static const unsigned char PREP(store_vwidth_data_e) [] =
 218 {
 219
 220     0x00, /* high byte */
 221     bci_vwidth_data_store, /* low byte */
 222   LOOPCALL,
 223
 224 };
 225
 226 static const unsigned char PREP(set_smooth_or_strong_a) [] =
 227 {
 228   /*
 229    * ttfautohint provides two different functions for stem width computation
 230    * and blue zone rounding: `smooth' and `strong'.  The former tries to
 231    * align stem widths and blue zones to some discrete, possibly non-integer
 232    * values.  The latter snaps everything to integer pixels as much as
 233    * possible.
 234    *
 235    * We test ClearType capabilities to find out which of the two functions
 236    * should be used.  Due to the various TrueType interpreter versions this
 237    * is quite convoluted.
 238    *
 239    *   interpreter version  action
 240    *   ---------------------------------------------------------------------
 241    *          <= 35         this version predates ClearType -> smooth
 242    *
 243    *          36-38         use bit 6 in the GETINFO instruction to check
 244    *                        whether ClearType is enabled; if set, we have
 245    *                        (old) GDI ClearType -> strong, otherwise
 246    *                        grayscale rendering -> smooth
 247    *
 248    *          39            if ClearType is enabled, use bit 10 in the
 249    *                        GETINFO instruction to check whether ClearType
 250    *                        sub-pixel positioning is available; if set, we
 251    *                        have DW ClearType -> smooth, else GDI ClearType
 252    *                        -> strong
 253    *
 254    *          >= 40         if ClearType is enabled, use bit 11 in the
 255    *                        GETINFO instruction to check whether ClearType
 256    *                        symmetric rendering is available; if not set,
 257    *                        the engine behaves like a B/W renderer along the
 258    *                        y axis -> strong, else it does vertical
 259    *                        smoothing -> smooth
 260    *
 261    * ClearType on Windows was introduced in 2000 for the GDI framework (no
 262    * symmetric rendering, no sub-pixel positioning).  In 2008, Windows got
 263    * the DirectWrite (DW) framework which uses symmetric rendering and
 264    * sub-pixel positioning.
 265    *
 266    * Note that in 2017 GDI on Windows 10 has changed rendering parameters:
 267    * it now uses symmetric rendering but no sub-pixel positioning.
 268    * Consequently, we treat this as `DW ClearType' also.
 269    */
 270
 271   /* set default value */
 272   PUSHB_2,
 273     cvtl_use_strong_functions, /* target: grayscale rendering */
 274
 275 };
 276
 277 /*  %c, either 0 or 100 */
 278
 279 static const unsigned char PREP(set_smooth_or_strong_b) [] =
 280 {
 281
 282   WCVTP,
 283
 284   /* get rasterizer version (bit 0) */
 285   PUSHB_2,
 286     36,
 287     0x01,
 288   GETINFO,
 289
 290   /* `(old) GDI ClearType': version >= 36 || version <= 38 */
 291   LTEQ,
 292   IF,
 293     /* check whether ClearType is enabled (bit 6) */
 294     PUSHB_1,
 295       0x40,
 296     GETINFO,
 297     IF,
 298       PUSHB_2,
 299         cvtl_use_strong_functions, /* target: GDI ClearType */
 300 };
 301
 302 /*      %c, either 0 or 100 */
 303
 304 static const unsigned char PREP(set_smooth_or_strong_c) [] =
 305 {
 306
 307       WCVTP,
 308
 309       /* get rasterizer version (bit 0) */
 310       PUSHB_2,
 311         40,
 312         0x01,
 313       GETINFO,
 314
 315       /* `DW ClearType': version >= 40 */
 316       LTEQ,
 317       IF,
 318         /* check whether symmetric rendering is enabled (bit 11) */
 319         PUSHW_1,
 320           0x08,
 321           0x00,
 322         GETINFO,
 323         IF,
 324           PUSHB_2,
 325             cvtl_use_strong_functions, /* target: DirectWrite ClearType */
 326
 327 };
 328
 329 /*          %c, either 0 or 100 */
 330
 331 static const unsigned char PREP(set_smooth_or_strong_d) [] =
 332 {
 333
 334           WCVTP,
 335         EIF,
 336
 337       ELSE,
 338         /* get rasterizer version (bit 0) */
 339         PUSHB_2,
 340           39,
 341           0x01,
 342         GETINFO,
 343
 344         /* `DW ClearType': version == 39 */
 345         LTEQ,
 346         IF,
 347           /* check whether sub-pixel positioning is enabled (bit 10) -- */
 348           /* due to a bug in FreeType 2.5.0 and earlier, */
 349           /* bit 6 must be set also to get the correct information, */
 350           /* so we test that both return values (in bits 13 and 17) are set */
 351           PUSHW_3,
 352             0x08, /* bits 13 and 17 right-shifted by 6 bits */
 353             0x80,
 354             0x00, /* we do `MUL' with value 1, */
 355             0x01, /* which is essentially a division by 64 */
 356             0x04, /* bits 6 and 10 */
 357             0x40,
 358           GETINFO,
 359           MUL,
 360           EQ,
 361           IF,
 362             PUSHB_2,
 363               cvtl_use_strong_functions, /* target: DirectWrite ClearType */
 364
 365 };
 366
 367 /*            %c, either 0 or 100 */
 368
 369 static const unsigned char PREP(set_smooth_or_strong_e) [] =
 370 {
 371
 372             WCVTP,
 373           EIF,
 374         EIF,
 375       EIF,
 376     EIF,
 377   EIF,
 378
 379 };
 380
 381 /*PUSHB (2*num_used_styles + 2) */
 382 /*  ... */
 383 /*  %c, style 1's first blue ref index */
 384 /*  %c, style 1's number of blue ref indices */
 385 /*  %c, style 0's first blue ref index */
 386 /*  %c, style 0's number of blue ref indices */
 387 /*  %c, num_used_styles */
 388
 389 static const unsigned char PREP(round_blues) [] =
 390 {
 391
 392     bci_blue_round_range,
 393   LOOPCALL,
 394
 395 };
 396
 397 static const unsigned char PREP(set_dropout_mode) [] =
 398 {
 399
 400   PUSHW_1,
 401     0x01, /* 0x01FF, activate dropout handling unconditionally */
 402     0xFF,
 403   SCANCTRL,
 404   PUSHB_1,
 405     4, /* smart dropout include stubs */
 406   SCANTYPE,
 407
 408 };
 409
 410 static const unsigned char PREP(reset_component_counter) [] =
 411 {
 412
 413   /* In case an application tries to render `.ttfautohint' */
 414   /* (which it should never do), */
 415   /* hinting of all glyphs rendered afterwards is disabled */
 416   /* because the `cvtl_is_subglyph' counter gets incremented, */
 417   /* but there is no counterpart to decrement it. */
 418   /* Font inspection tools like the FreeType demo programs */
 419   /* are an exception to that rule, however, */
 420   /* since they can directly access a font by glyph indices. */
 421   /* The following guard alleviates the problem a bit: */
 422   /* Any change of the graphics state */
 423   /* (for example, rendering at a different size or with a different mode) */
 424   /* resets the counter to zero. */
 425   PUSHB_2,
 426     cvtl_is_subglyph,
 427     0,
 428   WCVTP,
 429
 430 };
 431
 432 static const unsigned char PREP(adjust_delta_exceptions) [] =
 433 {
 434
 435   /* set delta base */
 436   PUSHB_1,
 437     CONTROL_DELTA_PPEM_MIN,
 438   SDB,
 439
 440 };
 441
 442
 443 static const unsigned char PREP(set_default_cvs_values) [] =
 444 {
 445
 446   /* We set a default value for `cvtl_do_iup_y'. */
 447   /* If we have delta exceptions before IUP_y, */
 448   /* the glyph's bytecode sets this CVT value temporarily to zero */
 449   /* and manually inserts IUP_y afterwards. */
 450
 451   /* We set a default value for `cvtl_ignore_std_width'. */
 452   /* As the name implies, the stem width computation routines */
 453   /* ignore the standard width(s) if this flag gets set. */
 454
 455   /* It would be more elegant to use storage area locations instead, */
 456   /* however, it is not possible to have default values for them */
 457   /* since storage area locations might be reset on a per-glyph basis */
 458   /* (this is dependent on the bytecode interpreter implementation). */
 459
 460   PUSHB_4,
 461     cvtl_do_iup_y,
 462     100,
 463     cvtl_ignore_std_width,
 464     0,
 465   WCVTP,
 466   WCVTP,
 467
 468 };
 469
 470
 471 /* this function allocates `buf', parsing `number_set' to create bytecode */
 472 /* which eventually sets CVT index `cvtl_is_element' */
 473 /* (in functions `bci_number_set_is_element' and */
 474 /* `bci_number_set_is_element2') */
 475
 476 static FT_Byte*
 477 TA_sfnt_build_number_set(SFNT* sfnt,
 478                          FT_Byte** buf,
 479                          number_range* number_set)
 480 {
 481   FT_Byte* bufp = NULL;
 482   number_range* nr;
 483
 484   FT_UInt num_singles2 = 0;
 485   FT_UInt* single2_args;
 486   FT_UInt* single2_arg;
 487   FT_UInt num_singles = 0;
 488   FT_UInt* single_args;
 489   FT_UInt* single_arg;
 490
 491   FT_UInt num_ranges2 = 0;
 492   FT_UInt* range2_args;
 493   FT_UInt* range2_arg;
 494   FT_UInt num_ranges = 0;
 495   FT_UInt* range_args;
 496   FT_UInt* range_arg;
 497
 498   FT_UInt have_single = 0;
 499   FT_UInt have_range = 0;
 500
 501   FT_UShort num_stack_elements;
 502
 503
 504   /* build up four stacks to stay as compact as possible */
 505   nr = number_set;
 506   while (nr)
 507   {
 508     if (nr->start == nr->end)
 509     {
 510       if (nr->start < 256)
 511         num_singles++;
 512       else
 513         num_singles2++;
 514     }
 515     else
 516     {
 517       if (nr->start < 256 && nr->end < 256)
 518         num_ranges++;
 519       else
 520         num_ranges2++;
 521     }
 522     nr = nr->next;
 523   }
 524
 525   /* collect all arguments temporarily in arrays (in reverse order) */
 526   /* so that we can easily split into chunks of 255 args */
 527   /* as needed by NPUSHB and friends; */
 528   /* for simplicity, always allocate an extra slot */
 529   single2_args = (FT_UInt*)malloc((num_singles2 + 1) * sizeof (FT_UInt));
 530   single_args = (FT_UInt*)malloc((num_singles + 1) * sizeof (FT_UInt));
 531   range2_args = (FT_UInt*)malloc((2 * num_ranges2 + 1) * sizeof (FT_UInt));
 532   range_args = (FT_UInt*)malloc((2 * num_ranges + 1) * sizeof (FT_UInt));
 533   if (!single2_args || !single_args
 534       || !range2_args || !range_args)
 535     goto Fail;
 536
 537   /* check whether we need the extra slot for the argument to CALL */
 538   if (num_singles || num_singles2)
 539     have_single = 1;
 540   if (num_ranges || num_ranges2)
 541     have_range = 1;
 542
 543   /* set function indices outside of argument loop (using the extra slot) */
 544   if (have_single)
 545     single_args[num_singles] = bci_number_set_is_element;
 546   if (have_range)
 547     range_args[2 * num_ranges] = bci_number_set_is_element2;
 548
 549   single2_arg = single2_args + num_singles2 - 1;
 550   single_arg = single_args + num_singles - 1;
 551   range2_arg = range2_args + 2 * num_ranges2 - 1;
 552   range_arg = range_args + 2 * num_ranges - 1;
 553
 554   nr = number_set;
 555   while (nr)
 556   {
 557     FT_UInt start = (FT_UInt)nr->start;
 558     FT_UInt end = (FT_UInt)nr->end;
 559
 560
 561     if (start == end)
 562     {
 563       if (start < 256)
 564         *(single_arg--) = start;
 565       else
 566         *(single2_arg--) = start;
 567     }
 568     else
 569     {
 570       if (start < 256 && end < 256)
 571       {
 572         *(range_arg--) = start;
 573         *(range_arg--) = end;
 574       }
 575       else
 576       {
 577         *(range2_arg--) = start;
 578         *(range2_arg--) = end;
 579       }
 580     }
 581     nr = nr->next;
 582   }
 583
 584   /* this rough estimate of the buffer size gets adjusted later on */
 585   *buf = (FT_Byte*)malloc((2 + 1) * num_singles2
 586                           + (1 + 1) * num_singles
 587                           + (4 + 1) * num_ranges2
 588                           + (2 + 1) * num_ranges
 589                           + 10);
 590   if (!*buf)
 591     goto Fail;
 592   bufp = *buf;
 593
 594   BCI(PUSHB_2);
 595     BCI(cvtl_is_element);
 596     BCI(0);
 597   BCI(WCVTP);
 598
 599   bufp = TA_build_push(bufp, single2_args, num_singles2, 1, 1);
 600   bufp = TA_build_push(bufp, single_args, num_singles + have_single, 0, 1);
 601   if (have_single)
 602     BCI(CALL);
 603
 604   bufp = TA_build_push(bufp, range2_args, 2 * num_ranges2, 1, 1);
 605   bufp = TA_build_push(bufp, range_args, 2 * num_ranges + have_range, 0, 1);
 606   if (have_range)
 607     BCI(CALL);
 608
 609   num_stack_elements = (FT_UShort)(num_singles + num_singles2);
 610   if (num_stack_elements > num_ranges + num_ranges2)
 611     num_stack_elements = (FT_UShort)(num_ranges + num_ranges2);
 612   num_stack_elements += ADDITIONAL_STACK_ELEMENTS;
 613   if (num_stack_elements > sfnt->max_stack_elements)
 614     sfnt->max_stack_elements = num_stack_elements;
 615
 616 Fail:
 617   free(single2_args);
 618   free(single_args);
 619   free(range2_args);
 620   free(range_args);
 621
 622   return bufp;
 623 }
 624
 625
 626 #define COPY_PREP(snippet_name) \
 627           do \
 628           { \
 629             memcpy(bufp, prep_ ## snippet_name, \
 630                    sizeof (prep_ ## snippet_name)); \
 631             bufp += sizeof (prep_ ## snippet_name); \
 632           } while (0)
 633
 634 static FT_Error
 635 TA_table_build_prep(FT_Byte** prep,
 636                     FT_ULong* prep_len,
 637                     SFNT* sfnt,
 638                     FONT* font)
 639 {
 640   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
 641   glyf_Data* data = (glyf_Data*)glyf_table->data;
 642   /* XXX: make this work for more than 256 styles */
 643   FT_Byte num_used_styles = (FT_Byte)data->num_used_styles;
 644
 645   FT_Int i;
 646
 647   FT_Byte* buf = NULL;
 648   FT_Byte* buf_new;
 649   FT_UInt buf_len;
 650   FT_UInt buf_new_len;
 651
 652   FT_UInt len;
 653   FT_Byte* bufp = NULL;
 654
 655
 656   if (font->x_height_snapping_exceptions)
 657   {
 658     bufp = TA_sfnt_build_number_set(sfnt, &buf,
 659                                     font->x_height_snapping_exceptions);
 660     if (!bufp)
 661       return FT_Err_Out_Of_Memory;
 662   }
 663
 664   buf_len = (FT_UInt)(bufp - buf);
 665   buf_new_len = buf_len;
 666
 667   if (font->hinting_limit)
 668     buf_new_len += sizeof (PREP(hinting_limit_a))
 669                    + 2
 670                    + sizeof (PREP(hinting_limit_b));
 671
 672   buf_new_len += sizeof (PREP(store_funits_to_pixels));
 673
 674   if (font->x_height_snapping_exceptions)
 675     buf_new_len += sizeof (PREP(test_exception_a));
 676
 677   buf_new_len += sizeof (PREP(align_x_height_a))
 678                  + (num_used_styles > 6 ? num_used_styles + 3
 679                                         : num_used_styles + 2)
 680                  + sizeof (PREP(align_x_height_b));
 681   buf_new_len += sizeof (PREP(loop_cvt_a))
 682                  + (num_used_styles > 3 ? 2 * num_used_styles + 3
 683                                         : 2 * num_used_styles + 2)
 684                  + sizeof (PREP(loop_cvt_b))
 685                  + (num_used_styles > 3 ? 2 * num_used_styles + 3
 686                                         : 2 * num_used_styles + 2)
 687                  + sizeof (PREP(loop_cvt_c));
 688
 689   if (font->x_height_snapping_exceptions)
 690     buf_new_len += sizeof (PREP(test_exception_b));
 691
 692   buf_new_len += sizeof (PREP(store_vwidth_data_a))
 693                  + 1
 694                  + sizeof (PREP(store_vwidth_data_b))
 695                  + (num_used_styles > 6 ? 2 * (num_used_styles + 1) + 2
 696                                         : 2 * (num_used_styles + 1) + 1)
 697                  + sizeof (PREP(store_vwidth_data_c))
 698                  + 1
 699                  + sizeof (PREP(store_vwidth_data_d))
 700                  + (num_used_styles > 6 ? 2 * (num_used_styles + 1) + 2
 701                                         : 2 * (num_used_styles + 1) + 1)
 702                  + sizeof (PREP(store_vwidth_data_e));
 703   buf_new_len += sizeof (PREP(set_smooth_or_strong_a))
 704                  + 1
 705                  + sizeof (PREP(set_smooth_or_strong_b))
 706                  + 1
 707                  + sizeof (PREP(set_smooth_or_strong_c))
 708                  + 1
 709                  + sizeof (PREP(set_smooth_or_strong_d))
 710                  + 1
 711                  + sizeof (PREP(set_smooth_or_strong_e));
 712   buf_new_len += (num_used_styles > 3 ? 2 * num_used_styles + 3
 713                                       : 2 * num_used_styles + 2)
 714                  + sizeof (PREP(round_blues));
 715   buf_new_len += sizeof (PREP(set_dropout_mode));
 716   buf_new_len += sizeof (PREP(reset_component_counter));
 717   if (font->control_data_head)
 718     buf_new_len += sizeof (PREP(adjust_delta_exceptions));
 719   buf_new_len += sizeof (PREP(set_default_cvs_values));
 720
 721   /* buffer length must be a multiple of four */
 722   len = (buf_new_len + 3) & ~3U;
 723   buf_new = (FT_Byte*)realloc(buf, len);
 724   if (!buf_new)
 725   {
 726     free(buf);
 727     return FT_Err_Out_Of_Memory;
 728   }
 729   buf = buf_new;
 730
 731   /* pad end of buffer with zeros */
 732   buf[len - 1] = 0x00;
 733   buf[len - 2] = 0x00;
 734   buf[len - 3] = 0x00;
 735
 736   /* copy remaining cvt program into buffer */
 737   /* and fill in the missing variables */
 738   bufp = buf + buf_len;
 739
 740   if (font->hinting_limit)
 741   {
 742     COPY_PREP(hinting_limit_a);
 743     *(bufp++) = HIGH(font->hinting_limit);
 744     *(bufp++) = LOW(font->hinting_limit);
 745     COPY_PREP(hinting_limit_b);
 746   }
 747
 748   COPY_PREP(store_funits_to_pixels);
 749
 750   if (font->x_height_snapping_exceptions)
 751     COPY_PREP(test_exception_a);
 752
 753   COPY_PREP(align_x_height_a);
 754   if (num_used_styles > 6)
 755   {
 756     BCI(NPUSHB);
 757     BCI(num_used_styles + 2);
 758   }
 759   else
 760     BCI(PUSHB_1 - 1 + num_used_styles + 2);
 761   /* XXX: make this work for offsets > 255 */
 762   for (i = TA_STYLE_MAX - 1; i >= 0; i--)
 763   {
 764     if (data->style_ids[i] == 0xFFFFU)
 765       continue;
 766
 767     *(bufp++) = CVT_X_HEIGHT_BLUE_OFFSET(i) >= 0xFFFFU
 768                   ? 0
 769                   : (unsigned char)CVT_X_HEIGHT_BLUE_OFFSET(i);
 770   }
 771   *(bufp++) = num_used_styles;
 772   COPY_PREP(align_x_height_b);
 773
 774   COPY_PREP(loop_cvt_a);
 775   if (num_used_styles > 3)
 776   {
 777     BCI(NPUSHB);
 778     BCI(2 * num_used_styles + 2);
 779   }
 780   else
 781     BCI(PUSHB_1 - 1 + 2 * num_used_styles + 2);
 782   /* XXX: make this work for offsets > 255 */
 783   for (i = TA_STYLE_MAX - 1; i >= 0; i--)
 784   {
 785     if (data->style_ids[i] == 0xFFFFU)
 786       continue;
 787
 788     /* don't loop over artificial blue zones */
 789     *(bufp++) = (unsigned char)CVT_VERT_STANDARD_WIDTH_OFFSET(i);
 790     *(bufp++) = (unsigned char)(
 791                   1
 792                   + CVT_VERT_WIDTHS_SIZE(i)
 793                   + (CVT_BLUES_SIZE(i) > 1
 794                      ? CVT_BLUES_SIZE(i) - (font->windows_compatibility ? 2
 795                                                                         : 0)
 796                      : 0));
 797   }
 798   *(bufp++) = num_used_styles;
 799   COPY_PREP(loop_cvt_b);
 800   if (num_used_styles > 3)
 801   {
 802     BCI(NPUSHB);
 803     BCI(2 * num_used_styles + 2);
 804   }
 805   else
 806     BCI(PUSHB_1 - 1 + 2 * num_used_styles + 2);
 807   /* XXX: make this work for offsets > 255 */
 808   for (i = TA_STYLE_MAX - 1; i >= 0; i--)
 809   {
 810     if (data->style_ids[i] == 0xFFFFU)
 811       continue;
 812
 813     /* don't loop over artificial blue zones */
 814     *(bufp++) = (unsigned char)CVT_BLUE_SHOOTS_OFFSET(i);
 815     *(bufp++) = (unsigned char)(
 816                   CVT_BLUES_SIZE(i) > 1
 817                   ? CVT_BLUES_SIZE(i) - (font->windows_compatibility ? 2
 818                                                                      : 0)
 819                   : 0);
 820   }
 821   *(bufp++) = num_used_styles;
 822   COPY_PREP(loop_cvt_c);
 823
 824   if (font->x_height_snapping_exceptions)
 825     COPY_PREP(test_exception_b);
 826
 827   COPY_PREP(store_vwidth_data_a);
 828   *(bufp++) = (unsigned char)CVT_VWIDTH_OFFSET_DATA(0);
 829   COPY_PREP(store_vwidth_data_b);
 830   if (num_used_styles > 6)
 831   {
 832     BCI(NPUSHW);
 833     BCI(num_used_styles + 2);
 834   }
 835   else
 836     BCI(PUSHW_1 - 1 + num_used_styles + 2);
 837   for (i = TA_STYLE_MAX - 1; i >= 0; i--)
 838   {
 839     if (data->style_ids[i] == 0xFFFFU)
 840       continue;
 841
 842     *(bufp++) = HIGH(CVT_VERT_WIDTHS_OFFSET(i) * 64);
 843     *(bufp++) = LOW(CVT_VERT_WIDTHS_OFFSET(i) * 64);
 844   }
 845   *(bufp++) = HIGH(num_used_styles);
 846   *(bufp++) = LOW(num_used_styles);
 847   COPY_PREP(store_vwidth_data_c);
 848   *(bufp++) = (unsigned char)CVT_VWIDTH_SIZE_DATA(0);
 849   COPY_PREP(store_vwidth_data_d);
 850   if (num_used_styles > 6)
 851   {
 852     BCI(NPUSHW);
 853     BCI(num_used_styles + 2);
 854   }
 855   else
 856     BCI(PUSHW_1 - 1 + num_used_styles + 2);
 857   for (i = TA_STYLE_MAX - 1; i >= 0; i--)
 858   {
 859     if (data->style_ids[i] == 0xFFFFU)
 860       continue;
 861
 862     *(bufp++) = HIGH(CVT_VERT_WIDTHS_SIZE(i) * 64);
 863     *(bufp++) = LOW(CVT_VERT_WIDTHS_SIZE(i) * 64);
 864   }
 865   *(bufp++) = HIGH(num_used_styles);
 866   *(bufp++) = LOW(num_used_styles);
 867   COPY_PREP(store_vwidth_data_e);
 868
 869   COPY_PREP(set_smooth_or_strong_a);
 870   *(bufp++) = font->gray_strong_stem_width ? 100 : 0;
 871   COPY_PREP(set_smooth_or_strong_b);
 872   *(bufp++) = font->gdi_cleartype_strong_stem_width ? 100 : 0;
 873   COPY_PREP(set_smooth_or_strong_c);
 874   *(bufp++) = font->dw_cleartype_strong_stem_width ? 100 : 0;
 875   COPY_PREP(set_smooth_or_strong_d);
 876   *(bufp++) = font->dw_cleartype_strong_stem_width ? 100 : 0;
 877   COPY_PREP(set_smooth_or_strong_e);
 878
 879   if (num_used_styles > 3)
 880   {
 881     BCI(NPUSHB);
 882     BCI(2 * num_used_styles + 2);
 883   }
 884   else
 885     BCI(PUSHB_1 - 1 + 2 * num_used_styles + 2);
 886   /* XXX: make this work for offsets > 255 */
 887   for (i = TA_STYLE_MAX - 1; i >= 0; i--)
 888   {
 889     if (data->style_ids[i] == 0xFFFFU)
 890       continue;
 891
 892     *(bufp++) = (unsigned char)CVT_BLUE_REFS_OFFSET(i);
 893     *(bufp++) = (unsigned char)CVT_BLUES_SIZE(i);
 894   }
 895   *(bufp++) = num_used_styles;
 896   COPY_PREP(round_blues);
 897
 898   COPY_PREP(set_dropout_mode);
 899   COPY_PREP(reset_component_counter);
 900   if (font->control_data_head)
 901     COPY_PREP(adjust_delta_exceptions);
 902   COPY_PREP(set_default_cvs_values);
 903
 904   *prep = buf;
 905   *prep_len = buf_new_len;
 906
 907   return FT_Err_Ok;
 908 }
 909
 910
 911 FT_Error
 912 TA_sfnt_build_prep_table(SFNT* sfnt,
 913                          FONT* font)
 914 {
 915   FT_Error error;
 916
 917   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
 918   glyf_Data* data = (glyf_Data*)glyf_table->data;
 919
 920   FT_Byte* prep_buf;
 921   FT_ULong prep_len;
 922
 923
 924   error = TA_sfnt_add_table_info(sfnt);
 925   if (error)
 926     goto Exit;
 927
 928   /* `glyf', `cvt', `fpgm', and `prep' are always used in parallel */
 929   if (glyf_table->processed)
 930   {
 931     sfnt->table_infos[sfnt->num_table_infos - 1] = data->prep_idx;
 932     goto Exit;
 933   }
 934
 935   error = TA_table_build_prep(&prep_buf, &prep_len, sfnt, font);
 936   if (error)
 937     goto Exit;
 938
 939 #if 0
 940   /* ttfautohint's bytecode in `fpgm' is larger */
 941   /* than the bytecode in `prep'; */
 942   /* this commented out code here is just for completeness */
 943   if (prep_len > sfnt->max_instructions)
 944     sfnt->max_instructions = prep_len;
 945 #endif
 946
 947   /* in case of success, `prep_buf' gets linked */
 948   /* and is eventually freed in `TA_font_unload' */
 949   error = TA_font_add_table(font,
 950                             &sfnt->table_infos[sfnt->num_table_infos - 1],
 951                             TTAG_prep, prep_len, prep_buf);
 952   if (error)
 953     free(prep_buf);
 954   else
 955     data->prep_idx = sfnt->table_infos[sfnt->num_table_infos - 1];
 956
 957 Exit:
 958   return error;
 959 }
 960
 961 /* end of taprep.c */