src/ttfautohint.c

   1 /* ttfautohint.c */
   2
   3 /*
   4  * Copyright (C) 2011 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 /* This file needs FreeType 2.4.5 or newer. */
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <ctype.h>
  22
  23 #include "ta.h"
  24
  25
  26 #define COMPARE(str) (len == (sizeof (str) - 1) \
  27                       && !strncmp(start, str, sizeof (str) - 1))
  28
  29
  30 TA_Error
  31 TTF_autohint(const char* options,
  32              ...)
  33 {
  34   va_list ap;
  35
  36   FONT* font;
  37   FT_Error error;
  38   FT_Long i;
  39
  40   FILE* in_file = NULL;
  41   FILE* out_file = NULL;
  42
  43   const char* in_buf = NULL;
  44   size_t in_len = 0;
  45   char** out_bufp = NULL;
  46   size_t* out_lenp = NULL;
  47
  48   const unsigned char** error_stringp = NULL;
  49
  50   FT_Long hinting_range_min = -1;
  51   FT_Long hinting_range_max = -1;
  52
  53   TA_Progress_Func progress;
  54   void* progress_data;
  55
  56   FT_Bool ignore_permissions = 0;
  57   FT_UInt fallback_script = 0;
  58
  59   const char *op;
  60
  61
  62   if (!options || !*options)
  63   {
  64     error = FT_Err_Invalid_Argument;
  65     goto Err1;
  66   }
  67
  68   /* XXX */
  69   va_start(ap, options);
  70
  71   op = options;
  72
  73   for(;;)
  74   {
  75     const char* start;
  76     size_t len;
  77
  78
  79     start = op;
  80
  81     /* search comma */
  82     while (*op && *op != ',')
  83       op++;
  84
  85     /* remove leading whitespace */
  86     while (isspace(*start))
  87       start++;
  88
  89     /* check for empty option */
  90     if (start == op)
  91       goto End;
  92
  93     len = op - start;
  94
  95     /* the `COMPARE' macro uses `len' and `start' */
  96
  97     /* handle option */
  98     if (COMPARE("error-string"))
  99       error_stringp = va_arg(ap, const unsigned char**);
 100     else if (COMPARE("fallback-script"))
 101       fallback_script = va_arg(ap, FT_UInt);
 102     else if (COMPARE("hinting-range-max"))
 103       hinting_range_max = (FT_Long)va_arg(ap, FT_UInt);
 104     else if (COMPARE("hinting-range-min"))
 105       hinting_range_min = (FT_Long)va_arg(ap, FT_UInt);
 106     else if (COMPARE("ignore-permissions"))
 107       ignore_permissions = (FT_Bool)va_arg(ap, FT_Int);
 108     else if (COMPARE("in-buffer"))
 109     {
 110       in_file = NULL;
 111       in_buf = va_arg(ap, const char*);
 112     }
 113     else if (COMPARE("in-buffer-len"))
 114     {
 115       in_file = NULL;
 116       in_len = va_arg(ap, size_t);
 117     }
 118     else if (COMPARE("in-file"))
 119     {
 120       in_file = va_arg(ap, FILE*);
 121       in_buf = NULL;
 122       in_len = 0;
 123     }
 124     else if (COMPARE("out-buffer"))
 125     {
 126       out_file = NULL;
 127       out_bufp = va_arg(ap, char**);
 128     }
 129     else if (COMPARE("out-buffer-len"))
 130     {
 131       out_file = NULL;
 132       out_lenp = va_arg(ap, size_t*);
 133     }
 134     else if (COMPARE("out-file"))
 135     {
 136       out_file = va_arg(ap, FILE*);
 137       out_bufp = NULL;
 138       out_lenp = NULL;
 139     }
 140     else if (COMPARE("progress-callback"))
 141       progress = va_arg(ap, TA_Progress_Func);
 142     else if (COMPARE("progress-callback-data"))
 143       progress_data = va_arg(ap, void*);
 144
 145     /*
 146       pre-hinting
 147       x-height-snapping-exceptions
 148      */
 149
 150   End:
 151     if (!*op)
 152       break;
 153     op++;
 154   }
 155
 156   va_end(ap);
 157
 158   /* check options */
 159
 160   if (!(in_file
 161         || (in_buf && in_len)))
 162   {
 163     error = FT_Err_Invalid_Argument;
 164     goto Err1;
 165   }
 166
 167   if (!(out_file
 168         || (out_bufp && out_lenp)))
 169   {
 170     error = FT_Err_Invalid_Argument;
 171     goto Err1;
 172   }
 173
 174   font = (FONT*)calloc(1, sizeof (FONT));
 175   if (!font)
 176   {
 177     error = FT_Err_Out_Of_Memory;
 178     goto Err1;
 179   }
 180
 181   if (hinting_range_min >= 0 && hinting_range_min < 2)
 182   {
 183     error = FT_Err_Invalid_Argument;
 184     goto Err1;
 185   }
 186   if (hinting_range_min < 0)
 187     hinting_range_min = 8;
 188
 189   if (hinting_range_max >= 0 && hinting_range_max < hinting_range_min)
 190   {
 191     error = FT_Err_Invalid_Argument;
 192     goto Err1;
 193   }
 194   if (hinting_range_max < 0)
 195     hinting_range_max = 1000;
 196
 197   font->hinting_range_min = (FT_UInt)hinting_range_min;
 198   font->hinting_range_max = (FT_UInt)hinting_range_max;
 199
 200   font->progress = progress;
 201   font->progress_data = progress_data;
 202
 203   font->ignore_permissions = ignore_permissions;
 204   /* restrict value to two bits */
 205   font->fallback_script = fallback_script & 3;
 206
 207   /* now start with processing the data */
 208
 209   if (in_file)
 210   {
 211     error = TA_font_file_read(font, in_file);
 212     if (error)
 213       goto Err;
 214   }
 215   else
 216   {
 217     /* a valid TTF can never be that small */
 218     if (in_len < 100)
 219     {
 220       error = FT_Err_Invalid_Argument;
 221       goto Err1;
 222     }
 223     font->in_buf = (FT_Byte*)in_buf;
 224     font->in_len = in_len;
 225   }
 226
 227   error = TA_font_init(font);
 228   if (error)
 229     goto Err;
 230
 231   /* loop over subfonts */
 232   for (i = 0; i < font->num_sfnts; i++)
 233   {
 234     SFNT* sfnt = &font->sfnts[i];
 235
 236
 237     error = FT_New_Memory_Face(font->lib, font->in_buf, font->in_len,
 238                                i, &sfnt->face);
 239     if (error)
 240       goto Err;
 241
 242     error = TA_sfnt_split_into_SFNT_tables(sfnt, font);
 243     if (error)
 244       goto Err;
 245
 246     error = TA_sfnt_split_glyf_table(sfnt, font);
 247     if (error)
 248       goto Err;
 249
 250     /* check permission */
 251     if (sfnt->OS2_idx != MISSING)
 252     {
 253       SFNT_Table* OS2_table = &font->tables[sfnt->OS2_idx];
 254
 255
 256       /* check lower byte of the `fsType' field */
 257       if (OS2_table->buf[OS2_FSTYPE_OFFSET + 1] == 0x02
 258           && !font->ignore_permissions)
 259       {
 260         error = TA_Err_Missing_Legal_Permission;
 261         goto Err;
 262       }
 263     }
 264   }
 265
 266   /* build `gasp' table */
 267   error = TA_sfnt_build_gasp_table(&font->sfnts[0], font);
 268   if (error)
 269     goto Err;
 270
 271   /* XXX handle subfonts for bytecode tables */
 272
 273   /* build `cvt ' table */
 274   error = TA_sfnt_build_cvt_table(&font->sfnts[0], font);
 275   if (error)
 276     goto Err;
 277
 278   /* build `fpgm' table */
 279   error = TA_sfnt_build_fpgm_table(&font->sfnts[0], font);
 280   if (error)
 281     goto Err;
 282
 283   /* build `prep' table */
 284   error = TA_sfnt_build_prep_table(&font->sfnts[0], font);
 285   if (error)
 286     goto Err;
 287
 288   /* hint the glyphs and build bytecode */
 289   error = TA_sfnt_build_glyf_hints(&font->sfnts[0], font);
 290   if (error)
 291     goto Err;
 292
 293   /* loop again over subfonts */
 294   for (i = 0; i < font->num_sfnts; i++)
 295   {
 296     SFNT* sfnt = &font->sfnts[i];
 297
 298
 299     error = TA_sfnt_build_glyf_table(sfnt, font);
 300     if (error)
 301       goto Err;
 302     error = TA_sfnt_build_loca_table(sfnt, font);
 303     if (error)
 304       goto Err;
 305     error = TA_sfnt_update_maxp_table(sfnt, font);
 306     if (error)
 307       goto Err;
 308   }
 309
 310   if (font->num_sfnts == 1)
 311     error = TA_font_build_TTF(font);
 312   else
 313     error = TA_font_build_TTC(font);
 314   if (error)
 315     goto Err;
 316
 317   if (out_file)
 318   {
 319     error = TA_font_file_write(font, out_file);
 320     if (error)
 321       goto Err;
 322   }
 323   else
 324   {
 325     *out_bufp = (char*)font->out_buf;
 326     *out_lenp = font->out_len;
 327   }
 328
 329   error = TA_Err_Ok;
 330
 331 Err:
 332   TA_font_unload(font, in_buf, out_bufp);
 333
 334 Err1:
 335   if (error_stringp)
 336     *error_stringp = (const unsigned char*)TA_get_error_message(error);
 337
 338   return error;
 339 }
 340
 341 /* end of ttfautohint.c */