src/taprep.c

   1 /* taprep.c */
   2
   3 /*
   4  * Copyright (C) 2011-2012 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 /* we often need 0x10000 which can't be pushed directly onto the stack, */
  22 /* thus we provide it in the CVT as `cvtl_0x10000'; */
  23 /* at the same time, we store it in CVT index `cvtl_funits_to_pixels' also */
  24 /* as a scaled value to have a conversion factor from FUnits to pixels */
  25
  26 unsigned char PREP(store_0x10000) [] = {
  27
  28   PUSHW_2,
  29     0x08, /* 0x800 */
  30     0x00,
  31     0x08, /* 0x800 */
  32     0x00,
  33   MUL, /* 0x10000 */
  34
  35   DUP,
  36   PUSHB_1,
  37     cvtl_0x10000,
  38   SWAP,
  39   WCVTP,
  40
  41   DUP,
  42   PUSHB_1,
  43     cvtl_funits_to_pixels,
  44   SWAP,
  45   WCVTF, /* store value 1 in 16.16 format, scaled */
  46
  47 };
  48
  49 unsigned char PREP(align_top_a) [] = {
  50
  51   /* optimize the alignment of the top of small letters to the pixel grid */
  52
  53   PUSHB_1,
  54
  55 };
  56
  57 /*  %c, index of alignment blue zone */
  58
  59 unsigned char PREP(align_top_b) [] = {
  60
  61   RCVT,
  62   DUP,
  63   DUP,
  64   PUSHB_1,
  65     40,
  66   ADD,
  67   FLOOR, /* fitted = FLOOR(scaled + 40) */
  68   DUP, /* s: scaled scaled fitted fitted */
  69   ROLL,
  70   NEQ,
  71   IF, /* s: scaled fitted */
  72     PUSHB_1,
  73       2,
  74     CINDEX,
  75     SUB, /* s: scaled (fitted-scaled) */
  76     PUSHB_1,
  77       cvtl_0x10000,
  78     RCVT,
  79     MUL, /* (fitted-scaled) in 16.16 format */
  80     SWAP,
  81     DIV, /* ((fitted-scaled) / scaled) in 16.16 format */
  82
  83     PUSHB_1,
  84       cvtl_scale,
  85     SWAP,
  86     WCVTP,
  87
  88 };
  89
  90 unsigned char PREP(loop_cvt_a) [] = {
  91
  92     /* loop over vertical CVT entries */
  93     PUSHB_4,
  94
  95 };
  96
  97 /*    %c, first vertical index */
  98 /*    %c, last vertical index */
  99
 100 unsigned char PREP(loop_cvt_b) [] = {
 101
 102       bci_cvt_rescale,
 103       bci_loop,
 104     CALL,
 105
 106     /* loop over blue refs */
 107     PUSHB_4,
 108
 109 };
 110
 111 /*    %c, first blue ref index */
 112 /*    %c, last blue ref index */
 113
 114 unsigned char PREP(loop_cvt_c) [] = {
 115
 116       bci_cvt_rescale,
 117       bci_loop,
 118     CALL,
 119
 120     /* loop over blue shoots */
 121     PUSHB_4,
 122
 123 };
 124
 125 /*    %c, first blue shoot index */
 126 /*    %c, last blue shoot index */
 127
 128 unsigned char PREP(loop_cvt_d) [] = {
 129
 130       bci_cvt_rescale,
 131       bci_loop,
 132     CALL,
 133   EIF,
 134
 135 };
 136
 137 unsigned char PREP(compute_extra_light_a) [] = {
 138
 139   /* compute (vertical) `extra_light' flag */
 140   PUSHB_3,
 141     cvtl_is_extra_light,
 142     40,
 143
 144 };
 145
 146 /*  %c, index of vertical standard_width */
 147
 148 unsigned char PREP(compute_extra_light_b) [] = {
 149
 150   RCVT,
 151   GT, /* standard_width < 40 */
 152   WCVTP,
 153
 154 };
 155
 156 unsigned char PREP(round_blues_a) [] = {
 157
 158   /* use discrete values for blue zone widths */
 159   PUSHB_4,
 160
 161 };
 162
 163 /*  %c, first blue ref index */
 164 /*  %c, last blue ref index */
 165
 166 unsigned char PREP(round_blues_b) [] = {
 167
 168     bci_blue_round,
 169     bci_loop,
 170   CALL
 171
 172 };
 173
 174 unsigned char PREP(set_dropout_mode) [] = {
 175
 176   PUSHW_1,
 177     0x01, /* 0x01FF, activate dropout handling unconditionally */
 178     0xFF,
 179   SCANCTRL,
 180   PUSHB_1,
 181     4, /* smart dropout include stubs */
 182   SCANTYPE,
 183
 184 };
 185
 186 unsigned char PREP(reset_component_counter) [] = {
 187
 188   /* In case an application tries to render `.ttfautohint' */
 189   /* (which it should never do), */
 190   /* hinting of all glyphs rendered afterwards is disabled */
 191   /* because the `cvtl_is_subglyph' counter gets incremented, */
 192   /* but there is no counterpart to decrement it. */
 193   /* Font inspection tools like the FreeType demo programs */
 194   /* are an exception to that rule, however, */
 195   /* since they can directly access a font by glyph indices. */
 196   /* The following guard alleviates the problem a bit: */
 197   /* Any change of the graphics state */
 198   /* (for example, rendering at a different size or with a different mode) */
 199   /* resets the counter to zero. */
 200   PUSHB_2,
 201     cvtl_is_subglyph,
 202     0,
 203   WCVTP,
 204
 205 };
 206
 207
 208 #define COPY_PREP(snippet_name) \
 209           memcpy(buf_p, prep_ ## snippet_name, \
 210                  sizeof (prep_ ## snippet_name)); \
 211           buf_p += sizeof (prep_ ## snippet_name);
 212
 213 static FT_Error
 214 TA_table_build_prep(FT_Byte** prep,
 215                     FT_ULong* prep_len,
 216                     FONT* font)
 217 {
 218   TA_LatinAxis vaxis;
 219   TA_LatinBlue blue_adjustment;
 220   FT_UInt i;
 221
 222   FT_UInt buf_len;
 223   FT_UInt len;
 224   FT_Byte* buf;
 225   FT_Byte* buf_p;
 226
 227
 228   vaxis = &((TA_LatinMetrics)font->loader->hints.metrics)->axis[1];
 229   blue_adjustment = NULL;
 230
 231   for (i = 0; i < vaxis->blue_count; i++)
 232   {
 233     if (vaxis->blues[i].flags & TA_LATIN_BLUE_ADJUSTMENT)
 234     {
 235       blue_adjustment = &vaxis->blues[i];
 236       break;
 237     }
 238   }
 239
 240   buf_len = sizeof (PREP(store_0x10000));
 241
 242   if (blue_adjustment)
 243     buf_len += sizeof (PREP(align_top_a))
 244                + 1
 245                + sizeof (PREP(align_top_b))
 246                + sizeof (PREP(loop_cvt_a))
 247                + 2
 248                + sizeof (PREP(loop_cvt_b))
 249                + 2
 250                + sizeof (PREP(loop_cvt_c))
 251                + 2
 252                + sizeof (PREP(loop_cvt_d));
 253
 254   buf_len += sizeof (PREP(compute_extra_light_a))
 255              + 1
 256              + sizeof (PREP(compute_extra_light_b));
 257
 258   if (CVT_BLUES_SIZE(font))
 259     buf_len += sizeof (PREP(round_blues_a))
 260                + 2
 261                + sizeof (PREP(round_blues_b));
 262
 263   buf_len += sizeof (PREP(set_dropout_mode));
 264   buf_len += sizeof (PREP(reset_component_counter));
 265
 266   /* buffer length must be a multiple of four */
 267   len = (buf_len + 3) & ~3;
 268   buf = (FT_Byte*)malloc(len);
 269   if (!buf)
 270     return FT_Err_Out_Of_Memory;
 271
 272   /* pad end of buffer with zeros */
 273   buf[len - 1] = 0x00;
 274   buf[len - 2] = 0x00;
 275   buf[len - 3] = 0x00;
 276
 277   /* copy cvt program into buffer and fill in the missing variables */
 278   buf_p = buf;
 279
 280   COPY_PREP(store_0x10000);
 281
 282   if (blue_adjustment)
 283   {
 284     COPY_PREP(align_top_a);
 285     *(buf_p++) = (unsigned char)(CVT_BLUE_SHOOTS_OFFSET(font)
 286                                  + blue_adjustment - vaxis->blues);
 287     COPY_PREP(align_top_b);
 288
 289     COPY_PREP(loop_cvt_a);
 290     *(buf_p++) = (unsigned char)CVT_VERT_WIDTHS_OFFSET(font);
 291     *(buf_p++) = (unsigned char)(CVT_VERT_WIDTHS_OFFSET(font)
 292                                  + CVT_VERT_WIDTHS_SIZE(font) - 1);
 293     COPY_PREP(loop_cvt_b);
 294     *(buf_p++) = (unsigned char)CVT_BLUE_REFS_OFFSET(font);
 295     *(buf_p++) = (unsigned char)(CVT_BLUE_REFS_OFFSET(font)
 296                                  + CVT_BLUES_SIZE(font) - 1);
 297     COPY_PREP(loop_cvt_c);
 298     *(buf_p++) = (unsigned char)CVT_BLUE_SHOOTS_OFFSET(font);
 299     *(buf_p++) = (unsigned char)(CVT_BLUE_SHOOTS_OFFSET(font)
 300                                  + CVT_BLUES_SIZE(font) - 1);
 301     COPY_PREP(loop_cvt_d);
 302   }
 303
 304   COPY_PREP(compute_extra_light_a);
 305   *(buf_p++) = (unsigned char)CVT_VERT_STANDARD_WIDTH_OFFSET(font);
 306   COPY_PREP(compute_extra_light_b);
 307
 308   if (CVT_BLUES_SIZE(font))
 309   {
 310     COPY_PREP(round_blues_a);
 311     *(buf_p++) = (unsigned char)CVT_BLUE_REFS_OFFSET(font);
 312     *(buf_p++) = (unsigned char)(CVT_BLUE_REFS_OFFSET(font)
 313                                  + CVT_BLUES_SIZE(font) - 1);
 314     COPY_PREP(round_blues_b);
 315   }
 316
 317   COPY_PREP(set_dropout_mode);
 318   COPY_PREP(reset_component_counter);
 319
 320   *prep = buf;
 321   *prep_len = buf_len;
 322
 323   return FT_Err_Ok;
 324 }
 325
 326
 327 FT_Error
 328 TA_sfnt_build_prep_table(SFNT* sfnt,
 329                          FONT* font)
 330 {
 331   FT_Error error;
 332
 333   FT_Byte* prep_buf;
 334   FT_ULong prep_len;
 335
 336
 337   error = TA_sfnt_add_table_info(sfnt);
 338   if (error)
 339     return error;
 340
 341   error = TA_table_build_prep(&prep_buf, &prep_len, font);
 342   if (error)
 343     return error;
 344
 345 #if 0
 346   /* ttfautohint's bytecode in `fpgm' is larger */
 347   /* than the bytecode in `prep'; */
 348   /* this commented out code here is just for completeness */
 349   if (prep_len > sfnt->max_instructions)
 350     sfnt->max_instructions = prep_len;
 351 #endif
 352
 353   /* in case of success, `prep_buf' gets linked */
 354   /* and is eventually freed in `TA_font_unload' */
 355   error = TA_font_add_table(font,
 356                             &sfnt->table_infos[sfnt->num_table_infos - 1],
 357                             TTAG_prep, prep_len, prep_buf);
 358   if (error)
 359   {
 360     free(prep_buf);
 361     return error;
 362   }
 363
 364   return FT_Err_Ok;
 365 }
 366
 367 /* end of taprep.c */