lib/taprep.c

   1 /* taprep.c */
   2
   3 /*
   4  * Copyright (C) 2011-2014 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 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 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 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 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 unsigned char PREP(align_top_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 unsigned char PREP(align_top_b) [] =
 102 {
 103
 104       bci_align_top,
 105     LOOPCALL,
 106
 107 };
 108
 109 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 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 unsigned char PREP(loop_cvt_c) [] =
 153 {
 154
 155       bci_cvt_rescale_range,
 156     LOOPCALL,
 157
 158 };
 159
 160 unsigned char PREP(test_exception_b) [] =
 161 {
 162
 163   EIF,
 164
 165 };
 166
 167 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 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 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 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 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 unsigned char PREP(set_smooth_or_strong_a) [] =
 227 {
 228
 229   /*
 230    * There are two ClearType flavours available on Windows: The older GDI
 231    * ClearType, introduced in 2000, and the recent DW ClearType, introduced
 232    * in 2008.  The main difference is that the older incarnation behaves
 233    * like a B/W renderer along the y axis, while the newer version does
 234    * vertical smoothing also.
 235    *
 236    * The only possibility to differentiate between GDI and DW ClearType is
 237    * testing bit 10 in the GETINFO instruction (with return value in bit 17;
 238    * this works for TrueType version >= 38), checking whether sub-pixel
 239    * positioning is available.
 240    *
 241    * If GDI ClearType is active, we use different functions for stem width
 242    * computation and blue zone rounding that snap to integer pixels as much
 243    * as possible.
 244    */
 245
 246   /* set default value */
 247   PUSHB_2,
 248     cvtl_use_strong_functions,
 249
 250 };
 251
 252 /*  %c, either 0 or 100 */
 253
 254 unsigned char PREP(set_smooth_or_strong_b) [] =
 255 {
 256
 257   WCVTP,
 258
 259   /* get rasterizer version (bit 0) */
 260   PUSHB_2,
 261     36,
 262     0x01,
 263   GETINFO,
 264
 265   /* `GDI ClearType': */
 266   /* version >= 36 and version < 38, ClearType enabled */
 267   LTEQ,
 268   IF,
 269     /* check whether ClearType is enabled (bit 6) */
 270     PUSHB_1,
 271       0x40,
 272     GETINFO,
 273     IF,
 274       PUSHB_2,
 275         cvtl_use_strong_functions,
 276 };
 277
 278 /*      %c, either 0 or 100 */
 279
 280 unsigned char PREP(set_smooth_or_strong_c) [] =
 281 {
 282
 283       WCVTP,
 284
 285       /* get rasterizer version (bit 0) */
 286       PUSHB_2,
 287         38,
 288         0x01,
 289       GETINFO,
 290
 291       /* `DW ClearType': */
 292       /* version >= 38, sub-pixel positioning is enabled */
 293       LTEQ,
 294       IF,
 295         /* check whether sub-pixel positioning is enabled (bit 10) -- */
 296         /* due to a bug in FreeType 2.5.0 and earlier, */
 297         /* bit 6 must be set also to get the correct information, */
 298         /* so we test that both return values (in bits 13 and 17) are set */
 299         PUSHW_3,
 300           0x08, /* bits 13 and 17 shifted by 6 bits */
 301           0x80,
 302           0x00, /* we do `MUL' with value 1, */
 303           0x01, /* which is essentially a division by 64 */
 304           0x04, /* bits 6 and 10 */
 305           0x40,
 306         GETINFO,
 307         MUL,
 308         EQ,
 309         IF,
 310           PUSHB_2,
 311             cvtl_use_strong_functions,
 312
 313 };
 314
 315 /*          %c, either 0 or 100 */
 316
 317 unsigned char PREP(set_smooth_or_strong_d) [] =
 318 {
 319
 320           WCVTP,
 321         EIF,
 322       EIF,
 323     EIF,
 324   EIF,
 325
 326 };
 327
 328 /*PUSHB (2*num_used_styles + 2) */
 329 /*  ... */
 330 /*  %c, style 1's first blue ref index */
 331 /*  %c, style 1's number of blue ref indices */
 332 /*  %c, style 0's first blue ref index */
 333 /*  %c, style 0's number of blue ref indices */
 334 /*  %c, num_used_styles */
 335
 336 unsigned char PREP(round_blues) [] =
 337 {
 338
 339     bci_blue_round_range,
 340   LOOPCALL,
 341
 342 };
 343
 344 unsigned char PREP(set_dropout_mode) [] =
 345 {
 346
 347   PUSHW_1,
 348     0x01, /* 0x01FF, activate dropout handling unconditionally */
 349     0xFF,
 350   SCANCTRL,
 351   PUSHB_1,
 352     4, /* smart dropout include stubs */
 353   SCANTYPE,
 354
 355 };
 356
 357 unsigned char PREP(reset_component_counter) [] =
 358 {
 359
 360   /* In case an application tries to render `.ttfautohint' */
 361   /* (which it should never do), */
 362   /* hinting of all glyphs rendered afterwards is disabled */
 363   /* because the `cvtl_is_subglyph' counter gets incremented, */
 364   /* but there is no counterpart to decrement it. */
 365   /* Font inspection tools like the FreeType demo programs */
 366   /* are an exception to that rule, however, */
 367   /* since they can directly access a font by glyph indices. */
 368   /* The following guard alleviates the problem a bit: */
 369   /* Any change of the graphics state */
 370   /* (for example, rendering at a different size or with a different mode) */
 371   /* resets the counter to zero. */
 372   PUSHB_2,
 373     cvtl_is_subglyph,
 374     0,
 375   WCVTP,
 376
 377 };
 378
 379
 380 /* this function allocates `buf', parsing `number_set' to create bytecode */
 381 /* which eventually sets CVT index `cvtl_is_element' */
 382 /* (in functions `bci_number_set_is_element' and */
 383 /* `bci_number_set_is_element2') */
 384
 385 static FT_Byte*
 386 TA_sfnt_build_number_set(SFNT* sfnt,
 387                          FT_Byte** buf,
 388                          number_range* number_set)
 389 {
 390   FT_Byte* bufp = NULL;
 391   number_range* nr;
 392
 393   FT_UInt num_singles2 = 0;
 394   FT_UInt* single2_args;
 395   FT_UInt* single2_arg;
 396   FT_UInt num_singles = 0;
 397   FT_UInt* single_args;
 398   FT_UInt* single_arg;
 399
 400   FT_UInt num_ranges2 = 0;
 401   FT_UInt* range2_args;
 402   FT_UInt* range2_arg;
 403   FT_UInt num_ranges = 0;
 404   FT_UInt* range_args;
 405   FT_UInt* range_arg;
 406
 407   FT_UInt have_single = 0;
 408   FT_UInt have_range = 0;
 409
 410   FT_UShort num_stack_elements;
 411
 412
 413   /* build up four stacks to stay as compact as possible */
 414   nr = number_set;
 415   while (nr)
 416   {
 417     if (nr->start == nr->end)
 418     {
 419       if (nr->start < 256)
 420         num_singles++;
 421       else
 422         num_singles2++;
 423     }
 424     else
 425     {
 426       if (nr->start < 256 && nr->end < 256)
 427         num_ranges++;
 428       else
 429         num_ranges2++;
 430     }
 431     nr = nr->next;
 432   }
 433
 434   /* collect all arguments temporarily in arrays (in reverse order) */
 435   /* so that we can easily split into chunks of 255 args */
 436   /* as needed by NPUSHB and friends; */
 437   /* for simplicity, always allocate an extra slot */
 438   single2_args = (FT_UInt*)malloc((num_singles2 + 1) * sizeof (FT_UInt));
 439   single_args = (FT_UInt*)malloc((num_singles + 1) * sizeof (FT_UInt));
 440   range2_args = (FT_UInt*)malloc((2 * num_ranges2 + 1) * sizeof (FT_UInt));
 441   range_args = (FT_UInt*)malloc((2 * num_ranges + 1) * sizeof (FT_UInt));
 442   if (!single2_args || !single_args
 443       || !range2_args || !range_args)
 444     goto Fail;
 445
 446   /* check whether we need the extra slot for the argument to CALL */
 447   if (num_singles || num_singles2)
 448     have_single = 1;
 449   if (num_ranges || num_ranges2)
 450     have_range = 1;
 451
 452   /* set function indices outside of argument loop (using the extra slot) */
 453   if (have_single)
 454     single_args[num_singles] = bci_number_set_is_element;
 455   if (have_range)
 456     range_args[2 * num_ranges] = bci_number_set_is_element2;
 457
 458   single2_arg = single2_args + num_singles2 - 1;
 459   single_arg = single_args + num_singles - 1;
 460   range2_arg = range2_args + 2 * num_ranges2 - 1;
 461   range_arg = range_args + 2 * num_ranges - 1;
 462
 463   nr = number_set;
 464   while (nr)
 465   {
 466     if (nr->start == nr->end)
 467     {
 468       if (nr->start < 256)
 469         *(single_arg--) = nr->start;
 470       else
 471         *(single2_arg--) = nr->start;
 472     }
 473     else
 474     {
 475       if (nr->start < 256 && nr->end < 256)
 476       {
 477         *(range_arg--) = nr->start;
 478         *(range_arg--) = nr->end;
 479       }
 480       else
 481       {
 482         *(range2_arg--) = nr->start;
 483         *(range2_arg--) = nr->end;
 484       }
 485     }
 486     nr = nr->next;
 487   }
 488
 489   /* this rough estimate of the buffer size gets adjusted later on */
 490   *buf = (FT_Byte*)malloc((2 + 1) * num_singles2
 491                           + (1 + 1) * num_singles
 492                           + (4 + 1) * num_ranges2
 493                           + (2 + 1) * num_ranges
 494                           + 10);
 495   if (!*buf)
 496     goto Fail;
 497   bufp = *buf;
 498
 499   BCI(PUSHB_2);
 500     BCI(cvtl_is_element);
 501     BCI(0);
 502   BCI(WCVTP);
 503
 504   bufp = TA_build_push(bufp, single2_args, num_singles2, 1, 1);
 505   bufp = TA_build_push(bufp, single_args, num_singles + have_single, 0, 1);
 506   if (have_single)
 507     BCI(CALL);
 508
 509   bufp = TA_build_push(bufp, range2_args, 2 * num_ranges2, 1, 1);
 510   bufp = TA_build_push(bufp, range_args, 2 * num_ranges + have_range, 0, 1);
 511   if (have_range)
 512     BCI(CALL);
 513
 514   num_stack_elements = num_singles + num_singles2;
 515   if (num_stack_elements > num_ranges + num_ranges2)
 516     num_stack_elements = num_ranges + num_ranges2;
 517   num_stack_elements += ADDITIONAL_STACK_ELEMENTS;
 518   if (num_stack_elements > sfnt->max_stack_elements)
 519     sfnt->max_stack_elements = num_stack_elements;
 520
 521 Fail:
 522   free(single2_args);
 523   free(single_args);
 524   free(range2_args);
 525   free(range_args);
 526
 527   return bufp;
 528 }
 529
 530
 531 #define COPY_PREP(snippet_name) \
 532           do \
 533           { \
 534             memcpy(bufp, prep_ ## snippet_name, \
 535                    sizeof (prep_ ## snippet_name)); \
 536             bufp += sizeof (prep_ ## snippet_name); \
 537           } while (0)
 538
 539 static FT_Error
 540 TA_table_build_prep(FT_Byte** prep,
 541                     FT_ULong* prep_len,
 542                     SFNT* sfnt,
 543                     FONT* font)
 544 {
 545   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
 546   glyf_Data* data = (glyf_Data*)glyf_table->data;
 547
 548   FT_Int i;
 549
 550   FT_Byte* buf = NULL;
 551   FT_Byte* buf_new;
 552   FT_UInt buf_len;
 553   FT_UInt buf_new_len;
 554
 555   FT_UInt len;
 556   FT_Byte* bufp = NULL;
 557
 558
 559   if (font->x_height_snapping_exceptions)
 560   {
 561     bufp = TA_sfnt_build_number_set(sfnt, &buf,
 562                                     font->x_height_snapping_exceptions);
 563     if (!bufp)
 564       return FT_Err_Out_Of_Memory;
 565   }
 566
 567   buf_len = bufp - buf;
 568   buf_new_len = buf_len;
 569
 570   if (font->hinting_limit)
 571     buf_new_len += sizeof (PREP(hinting_limit_a))
 572                    + 2
 573                    + sizeof (PREP(hinting_limit_b));
 574
 575   buf_new_len += sizeof (PREP(store_funits_to_pixels));
 576
 577   if (font->x_height_snapping_exceptions)
 578     buf_new_len += sizeof (PREP(test_exception_a));
 579
 580   buf_new_len += sizeof (PREP(align_top_a))
 581                  + (data->num_used_styles > 6
 582                       ? data->num_used_styles + 3
 583                       : data->num_used_styles + 2)
 584                  + sizeof (PREP(align_top_b));
 585   buf_new_len += sizeof (PREP(loop_cvt_a))
 586                  + (data->num_used_styles > 3
 587                      ? 2 * data->num_used_styles + 3
 588                      : 2 * data->num_used_styles + 2)
 589                  + sizeof (PREP(loop_cvt_b))
 590                  + (data->num_used_styles > 3
 591                      ? 2 * data->num_used_styles + 3
 592                      : 2 * data->num_used_styles + 2)
 593                  + sizeof (PREP(loop_cvt_c));
 594
 595   if (font->x_height_snapping_exceptions)
 596     buf_new_len += sizeof (PREP(test_exception_b));
 597
 598   buf_new_len += sizeof (PREP(store_vwidth_data_a))
 599                  + 1
 600                  + sizeof (PREP(store_vwidth_data_b))
 601                  + (data->num_used_styles > 6
 602                       ? 2 * (data->num_used_styles + 1) + 2
 603                       : 2 * (data->num_used_styles + 1) + 1)
 604                  + sizeof (PREP(store_vwidth_data_c))
 605                  + 1
 606                  + sizeof (PREP(store_vwidth_data_d))
 607                  + (data->num_used_styles > 6
 608                       ? 2 * (data->num_used_styles + 1) + 2
 609                       : 2 * (data->num_used_styles + 1) + 1)
 610                  + sizeof (PREP(store_vwidth_data_e));
 611   buf_new_len += sizeof (PREP(set_smooth_or_strong_a))
 612                  + 1
 613                  + sizeof (PREP(set_smooth_or_strong_b))
 614                  + 1
 615                  + sizeof (PREP(set_smooth_or_strong_c))
 616                  + 1
 617                  + sizeof (PREP(set_smooth_or_strong_d));
 618   buf_new_len += (data->num_used_styles > 3
 619                      ? 2 * data->num_used_styles + 3
 620                      : 2 * data->num_used_styles + 2)
 621                  + sizeof (PREP(round_blues));
 622   buf_new_len += sizeof (PREP(set_dropout_mode));
 623   buf_new_len += sizeof (PREP(reset_component_counter));
 624
 625   /* buffer length must be a multiple of four */
 626   len = (buf_new_len + 3) & ~3;
 627   buf_new = (FT_Byte*)realloc(buf, len);
 628   if (!buf_new)
 629   {
 630     free(buf);
 631     return FT_Err_Out_Of_Memory;
 632   }
 633   buf = buf_new;
 634
 635   /* pad end of buffer with zeros */
 636   buf[len - 1] = 0x00;
 637   buf[len - 2] = 0x00;
 638   buf[len - 3] = 0x00;
 639
 640   /* copy remaining cvt program into buffer */
 641   /* and fill in the missing variables */
 642   bufp = buf + buf_len;
 643
 644   if (font->hinting_limit)
 645   {
 646     COPY_PREP(hinting_limit_a);
 647     *(bufp++) = HIGH(font->hinting_limit);
 648     *(bufp++) = LOW(font->hinting_limit);
 649     COPY_PREP(hinting_limit_b);
 650   }
 651
 652   COPY_PREP(store_funits_to_pixels);
 653
 654   if (font->x_height_snapping_exceptions)
 655     COPY_PREP(test_exception_a);
 656
 657   COPY_PREP(align_top_a);
 658   if (data->num_used_styles > 6)
 659   {
 660     BCI(NPUSHB);
 661     BCI(data->num_used_styles + 2);
 662   }
 663   else
 664     BCI(PUSHB_1 - 1 + data->num_used_styles + 2);
 665   /* XXX: make this work for offsets > 255 */
 666   for (i = TA_STYLE_MAX - 1; i >= 0; i--)
 667   {
 668     if (data->style_ids[i] == 0xFFFFU)
 669       continue;
 670
 671     *(bufp++) = CVT_X_HEIGHT_BLUE_OFFSET(i) >= 0xFFFFU
 672                   ? 0
 673                   : (unsigned char)CVT_X_HEIGHT_BLUE_OFFSET(i);
 674   }
 675   *(bufp++) = data->num_used_styles;
 676   COPY_PREP(align_top_b);
 677
 678   COPY_PREP(loop_cvt_a);
 679   if (data->num_used_styles > 3)
 680   {
 681     BCI(NPUSHB);
 682     BCI(2 * data->num_used_styles + 2);
 683   }
 684   else
 685     BCI(PUSHB_1 - 1 + 2 * data->num_used_styles + 2);
 686   /* XXX: make this work for offsets > 255 */
 687   for (i = TA_STYLE_MAX - 1; i >= 0; i--)
 688   {
 689     if (data->style_ids[i] == 0xFFFFU)
 690       continue;
 691
 692     /* don't loop over artificial blue zones */
 693     *(bufp++) = (unsigned char)CVT_VERT_STANDARD_WIDTH_OFFSET(i);
 694     *(bufp++) = (unsigned char)(
 695                   1
 696                   + CVT_VERT_WIDTHS_SIZE(i)
 697                   + (CVT_BLUES_SIZE(i) > 1 ? CVT_BLUES_SIZE(i) - 2 : 0));
 698   }
 699   *(bufp++) = data->num_used_styles;
 700   COPY_PREP(loop_cvt_b);
 701   if (data->num_used_styles > 3)
 702   {
 703     BCI(NPUSHB);
 704     BCI(2 * data->num_used_styles + 2);
 705   }
 706   else
 707     BCI(PUSHB_1 - 1 + 2 * data->num_used_styles + 2);
 708   /* XXX: make this work for offsets > 255 */
 709   for (i = TA_STYLE_MAX - 1; i >= 0; i--)
 710   {
 711     if (data->style_ids[i] == 0xFFFFU)
 712       continue;
 713
 714     /* don't loop over artificial blue zones */
 715     *(bufp++) = (unsigned char)CVT_BLUE_SHOOTS_OFFSET(i);
 716     *(bufp++) = (unsigned char)(
 717                   CVT_BLUES_SIZE(i) > 1 ? CVT_BLUES_SIZE(i) - 2 : 0);
 718   }
 719   *(bufp++) = data->num_used_styles;
 720   COPY_PREP(loop_cvt_c);
 721
 722   if (font->x_height_snapping_exceptions)
 723     COPY_PREP(test_exception_b);
 724
 725   COPY_PREP(store_vwidth_data_a);
 726   *(bufp++) = (unsigned char)CVT_VWIDTH_OFFSET_DATA(0);
 727   COPY_PREP(store_vwidth_data_b);
 728   if (data->num_used_styles > 6)
 729   {
 730     BCI(NPUSHW);
 731     BCI(data->num_used_styles + 2);
 732   }
 733   else
 734     BCI(PUSHW_1 - 1 + data->num_used_styles + 2);
 735   for (i = TA_STYLE_MAX - 1; i >= 0; i--)
 736   {
 737     if (data->style_ids[i] == 0xFFFFU)
 738       continue;
 739
 740     *(bufp++) = HIGH(CVT_VERT_WIDTHS_OFFSET(i) * 64);
 741     *(bufp++) = LOW(CVT_VERT_WIDTHS_OFFSET(i) * 64);
 742   }
 743   *(bufp++) = HIGH(data->num_used_styles);
 744   *(bufp++) = LOW(data->num_used_styles);
 745   COPY_PREP(store_vwidth_data_c);
 746   *(bufp++) = (unsigned char)CVT_VWIDTH_SIZE_DATA(0);
 747   COPY_PREP(store_vwidth_data_d);
 748   if (data->num_used_styles > 6)
 749   {
 750     BCI(NPUSHW);
 751     BCI(data->num_used_styles + 2);
 752   }
 753   else
 754     BCI(PUSHW_1 - 1 + data->num_used_styles + 2);
 755   for (i = TA_STYLE_MAX - 1; i >= 0; i--)
 756   {
 757     if (data->style_ids[i] == 0xFFFFU)
 758       continue;
 759
 760     *(bufp++) = HIGH(CVT_VERT_WIDTHS_SIZE(i) * 64);
 761     *(bufp++) = LOW(CVT_VERT_WIDTHS_SIZE(i) * 64);
 762   }
 763   *(bufp++) = HIGH(data->num_used_styles);
 764   *(bufp++) = LOW(data->num_used_styles);
 765   COPY_PREP(store_vwidth_data_e);
 766
 767   COPY_PREP(set_smooth_or_strong_a);
 768   *(bufp++) = font->gray_strong_stem_width ? 100 : 0;
 769   COPY_PREP(set_smooth_or_strong_b);
 770   *(bufp++) = font->gdi_cleartype_strong_stem_width ? 100 : 0;
 771   COPY_PREP(set_smooth_or_strong_c);
 772   *(bufp++) = font->dw_cleartype_strong_stem_width ? 100 : 0;
 773   COPY_PREP(set_smooth_or_strong_d);
 774
 775   if (data->num_used_styles > 3)
 776   {
 777     BCI(NPUSHB);
 778     BCI(2 * data->num_used_styles + 2);
 779   }
 780   else
 781     BCI(PUSHB_1 - 1 + 2 * data->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     *(bufp++) = (unsigned char)CVT_BLUE_REFS_OFFSET(i);
 789     *(bufp++) = (unsigned char)CVT_BLUES_SIZE(i);
 790   }
 791   *(bufp++) = data->num_used_styles;
 792   COPY_PREP(round_blues);
 793
 794   COPY_PREP(set_dropout_mode);
 795   COPY_PREP(reset_component_counter);
 796
 797   *prep = buf;
 798   *prep_len = buf_new_len;
 799
 800   return FT_Err_Ok;
 801 }
 802
 803
 804 FT_Error
 805 TA_sfnt_build_prep_table(SFNT* sfnt,
 806                          FONT* font)
 807 {
 808   FT_Error error;
 809
 810   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
 811   glyf_Data* data = (glyf_Data*)glyf_table->data;
 812
 813   FT_Byte* prep_buf;
 814   FT_ULong prep_len;
 815
 816
 817   error = TA_sfnt_add_table_info(sfnt);
 818   if (error)
 819     goto Exit;
 820
 821   /* `glyf', `cvt', `fpgm', and `prep' are always used in parallel */
 822   if (glyf_table->processed)
 823   {
 824     sfnt->table_infos[sfnt->num_table_infos - 1] = data->prep_idx;
 825     goto Exit;
 826   }
 827
 828   error = TA_table_build_prep(&prep_buf, &prep_len, sfnt, font);
 829   if (error)
 830     goto Exit;
 831
 832 #if 0
 833   /* ttfautohint's bytecode in `fpgm' is larger */
 834   /* than the bytecode in `prep'; */
 835   /* this commented out code here is just for completeness */
 836   if (prep_len > sfnt->max_instructions)
 837     sfnt->max_instructions = prep_len;
 838 #endif
 839
 840   /* in case of success, `prep_buf' gets linked */
 841   /* and is eventually freed in `TA_font_unload' */
 842   error = TA_font_add_table(font,
 843                             &sfnt->table_infos[sfnt->num_table_infos - 1],
 844                             TTAG_prep, prep_len, prep_buf);
 845   if (error)
 846     free(prep_buf);
 847   else
 848     data->prep_idx = sfnt->table_infos[sfnt->num_table_infos - 1];
 849
 850 Exit:
 851   return error;
 852 }
 853
 854 /* end of taprep.c */