src/ttfautohint.c

   1 /* ttfautohint.c */
   2
   3 /* written 2011 by Werner Lemberg <wl@gnu.org> */
   4
   5 /* This file needs FreeType 2.4.5 or newer. */
   6
   7
   8 #include <config.h>
   9 #include <stdio.h>
  10 #include <string.h>
  11
  12 #include <ft2build.h>
  13 #include FT_FREETYPE_H
  14 #include FT_TRUETYPE_TABLES_H
  15 #include FT_TRUETYPE_TAGS_H
  16
  17 #include "ttfautohint.h"
  18
  19
  20 /* these macros convert 16bit and 32bit numbers into single bytes */
  21 /* using the byte order needed within SFNT files                  */
  22
  23 #define HIGH(x) (FT_Byte)(((x) & 0xFF00) >> 8)
  24 #define LOW(x) ((x) & 0x00FF)
  25
  26 #define BYTE1(x) (FT_Byte)(((x) & 0xFF000000UL) >> 24);
  27 #define BYTE2(x) (FT_Byte)(((x) & 0x00FF0000UL) >> 16);
  28 #define BYTE3(x) (FT_Byte)(((x) & 0x0000FF00UL) >> 8);
  29 #define BYTE4(x) ((x) & 0x000000FFUL);
  30
  31
  32 /* this structure represents both the data contained in the SFNT */
  33 /* table records and the actual SFNT table data */
  34 typedef struct SFNT_Table_ {
  35   FT_ULong tag;
  36   FT_ULong len;
  37   FT_Byte* buf;
  38   FT_ULong offset; /* used while building output font only */
  39 } SFNT_Table;
  40
  41 /* this structure is used to model a TTF or a subfont within a TTC */
  42 typedef struct SFNT_ {
  43   FT_Face face;
  44   SFNT_Table* table_infos;
  45   FT_ULong num_table_infos;
  46 } SFNT;
  47
  48 /* our font object */
  49 typedef struct FONT_ {
  50   FT_Library lib;
  51
  52   FT_Byte* in_buf;
  53   size_t in_len;
  54
  55   FT_Byte* out_buf;
  56   size_t out_len;
  57
  58   SFNT* sfnts;
  59   FT_Long num_sfnts;
  60
  61   SFNT_Table* tables;
  62   FT_ULong num_tables;
  63 } FONT;
  64
  65
  66 static FT_Error
  67 TA_font_read(FILE* in,
  68              FONT* font)
  69 {
  70   fseek(in, 0, SEEK_END);
  71   font->in_len = ftell(in);
  72   fseek(in, 0, SEEK_SET);
  73
  74   /* a valid TTF can never be that small */
  75   if (font->in_len < 100)
  76     return FT_Err_Invalid_Argument;
  77
  78   font->in_buf = (FT_Byte*)malloc(font->in_len * sizeof (FT_Byte));
  79   if (!font->in_buf)
  80     return FT_Err_Out_Of_Memory;
  81
  82   if (fread(font->in_buf, 1, font->in_len, in) != font->in_len)
  83     return FT_Err_Invalid_Stream_Read;
  84
  85   return TA_Err_Ok;
  86 }
  87
  88
  89 static FT_Error
  90 TA_font_init(FONT* font)
  91 {
  92   FT_Error error;
  93   FT_Face f;
  94
  95
  96   error = FT_Init_FreeType(&font->lib);
  97   if (error)
  98     return error;
  99
 100   /* get number of faces (i.e. subfonts) */
 101   error = FT_New_Memory_Face(font->lib, font->in_buf, font->in_len, -1, &f);
 102   if (error)
 103     return error;
 104   font->num_sfnts = f->num_faces;
 105   FT_Done_Face(f);
 106
 107   /* it is a TTC if we have more than a single subfont */
 108   font->sfnts = (SFNT*)calloc(1, font->num_sfnts * sizeof (SFNT));
 109   if (!font->sfnts)
 110     return FT_Err_Out_Of_Memory;
 111
 112   return TA_Err_Ok;
 113 }
 114
 115
 116 static FT_Error
 117 TA_sfnt_collect_table_info(SFNT* sfnt)
 118 {
 119   FT_Error error;
 120   FT_ULong glyf_idx;
 121   FT_ULong i;
 122
 123
 124   /* check that font is TTF or TTC */
 125   if (!FT_IS_SFNT(sfnt->face))
 126     return FT_Err_Invalid_Argument;
 127
 128   error = FT_Sfnt_Table_Info(sfnt->face, 0, NULL, &sfnt->num_table_infos);
 129   if (error)
 130     return error;
 131
 132   sfnt->table_infos =
 133     (SFNT_Table*)calloc(1, sfnt->num_table_infos * sizeof (SFNT_Table));
 134   if (!sfnt->table_infos)
 135     return FT_Err_Out_Of_Memory;
 136
 137   /* collect SFNT table information and search for `glyf' table */
 138   glyf_idx = sfnt->num_table_infos;
 139   for (i = 0; i < sfnt->num_table_infos; i++)
 140   {
 141     FT_ULong tag, len;
 142
 143
 144     error = FT_Sfnt_Table_Info(sfnt->face, i, &tag, &len);
 145     if (error && error != FT_Err_Table_Missing)
 146       return error;
 147
 148     if (!error)
 149     {
 150       if (tag == TTAG_glyf)
 151         glyf_idx = i;
 152
 153       /* ignore tables which we are going to create by ourselves */
 154       if (!(tag == TTAG_fpgm
 155             || tag == TTAG_prep
 156             || tag == TTAG_cvt
 157             || tag == TTAG_DSIG))
 158       {
 159         sfnt->table_infos[i].tag = tag;
 160         sfnt->table_infos[i].len = len;
 161       }
 162     }
 163   }
 164
 165   /* no (non-empty) `glyf' table; this can't be a TTF with outlines */
 166   if (glyf_idx == sfnt->num_table_infos)
 167     return FT_Err_Invalid_Argument;
 168
 169   return TA_Err_Ok;
 170 }
 171
 172
 173 static FT_Error
 174 TA_font_add_table(FONT* font,
 175                   SFNT_Table* table_info,
 176                   FT_Byte* buf)
 177 {
 178   SFNT_Table* tables_new;
 179   SFNT_Table* table_last;
 180
 181
 182   font->num_tables++;
 183   tables_new = (SFNT_Table*)realloc(font->tables,
 184                                     font->num_tables * sizeof (SFNT_Table));
 185   if (!tables_new)
 186     return FT_Err_Out_Of_Memory;
 187   else
 188     font->tables = tables_new;
 189
 190   table_last = &font->tables[font->num_tables - 1];
 191
 192   table_last->tag = table_info->tag;
 193   table_last->len = table_info->len;
 194   table_last->buf = buf;
 195
 196   /* link buffer pointer */
 197   table_info->buf = table_last->buf;
 198
 199   return TA_Err_Ok;
 200 }
 201
 202
 203 static FT_Error
 204 TA_font_split_into_SFNT_tables(SFNT* sfnt,
 205                                FONT* font)
 206 {
 207   FT_Error error;
 208   FT_ULong i;
 209
 210
 211   for (i = 0; i < sfnt->num_table_infos; i++)
 212   {
 213     SFNT_Table* table_info = &sfnt->table_infos[i];
 214
 215
 216     /* we ignore empty tables */
 217     if (table_info->len)
 218     {
 219       FT_Byte* buf;
 220       FT_ULong len;
 221       FT_ULong j;
 222
 223
 224       /* make the allocated buffer length a multiple of 4; */
 225       /* this simplifies writing the tables back */
 226       len = (table_info->len + 3) & ~3;
 227
 228       buf = (FT_Byte*)malloc(len * sizeof (FT_Byte));
 229       if (!buf)
 230         return FT_Err_Out_Of_Memory;
 231
 232       /* pad buffer with zeros */
 233       buf[len - 1] = 0;
 234       buf[len - 2] = 0;
 235       buf[len - 3] = 0;
 236
 237       /* load table */
 238       error = FT_Load_Sfnt_Table(sfnt->face, table_info->tag, 0,
 239                                  buf, &table_info->len);
 240       if (error)
 241         goto Err;
 242
 243       /* check whether we already have this table */
 244       for (j = 0; j < font->num_tables; j++)
 245       {
 246         SFNT_Table* table = &font->tables[j];
 247
 248
 249         if (table->tag == table_info->tag
 250             && table->len == table_info->len
 251             && !memcmp(table->buf, buf, table->len))
 252           break;
 253       }
 254
 255       if (j == font->num_tables)
 256       {
 257         /* add element to table array if it is missing or different */
 258         error = TA_font_add_table(font, table_info, buf);
 259         if (error)
 260           goto Err;
 261       }
 262       else
 263       {
 264         free(buf);
 265         table_info->buf = font->tables[j].buf;
 266       }
 267       continue;
 268
 269     Err:
 270       free(buf);
 271       return error;
 272     }
 273   }
 274
 275   return TA_Err_Ok;
 276 }
 277
 278
 279 static FT_ULong
 280 TA_table_compute_checksum(FT_Byte* buf,
 281                           FT_ULong len)
 282 {
 283   FT_Byte* end_buf = buf + len;
 284   FT_ULong checksum = 0;
 285
 286
 287   while (buf < end_buf)
 288   {
 289     checksum += *(buf++) << 24;
 290     checksum += *(buf++) << 16;
 291     checksum += *(buf++) << 8;
 292     checksum += *(buf++);
 293   }
 294
 295   return checksum;
 296 }
 297
 298
 299 static FT_Error
 300 TA_font_build_TTF(FONT* font)
 301 {
 302   SFNT* sfnt = &font->sfnts[0];
 303   SFNT_Table* table_infos = sfnt->table_infos;
 304   FT_ULong num_table_infos = sfnt->num_table_infos;
 305
 306   FT_ULong num_tables_in_header;
 307
 308   FT_Byte* header_buf;
 309   FT_ULong header_len;
 310
 311   FT_Byte* head_buf = NULL;
 312   FT_ULong head_checksum; /* checksum in `head' table */
 313
 314   FT_Byte* table_record;
 315   FT_ULong table_offset;
 316
 317   FT_ULong i;
 318   FT_Error error;
 319
 320
 321   num_tables_in_header = 0;
 322
 323   for (i = 0; i < num_table_infos; i++)
 324   {
 325     /* ignore empty tables */
 326     if (table_infos[i].len)
 327       num_tables_in_header++;
 328   }
 329
 330   if (num_tables_in_header > 0xFFFF)
 331     return FT_Err_Array_Too_Large;
 332
 333   /* construct TTF header */
 334
 335   header_len = 12 + 16 * num_tables_in_header;
 336   header_buf = (FT_Byte*)malloc(header_len * sizeof (FT_Byte));
 337   if (!header_buf)
 338     return FT_Err_Out_Of_Memory;
 339
 340   /* SFNT version */
 341   header_buf[0] = 0x00;
 342   header_buf[1] = 0x01;
 343   header_buf[2] = 0x00;
 344   header_buf[3] = 0x00;
 345
 346   /* number of tables */
 347   header_buf[4] = HIGH(num_tables_in_header);
 348   header_buf[5] = LOW(num_tables_in_header);
 349
 350   /* auxiliary data */
 351   {
 352     FT_ULong search_range, entry_selector, range_shift;
 353     FT_ULong i, j;
 354
 355
 356     for (i = 1, j = 2; j <= num_tables_in_header; i++, j <<= 1)
 357       ;
 358
 359     entry_selector = i - 1;
 360     search_range = 0x10 << entry_selector;
 361     range_shift = (num_tables_in_header << 4) - search_range;
 362
 363     header_buf[6] = HIGH(search_range);
 364     header_buf[7] = LOW(search_range);
 365     header_buf[8] = HIGH(entry_selector);
 366     header_buf[9] = LOW(entry_selector);
 367     header_buf[10] = HIGH(range_shift);
 368     header_buf[11] = LOW(range_shift);
 369   }
 370
 371   /* location of the first table record */
 372   table_record = &header_buf[12];
 373   /* the first table immediately follows the header */
 374   table_offset = header_len;
 375
 376   head_checksum = 0;
 377
 378   /* loop over all tables */
 379   for (i = 0; i < num_table_infos; i++)
 380   {
 381     SFNT_Table *table_info = &table_infos[i];
 382     FT_ULong table_checksum;
 383
 384
 385     /* ignore empty tables */
 386     if (!table_info->len)
 387       continue;
 388
 389     table_info->offset = table_offset;
 390
 391     if (table_info->tag == TTAG_head)
 392     {
 393       /* we always reach this IF clause since FreeType would */
 394       /* have aborted already if the `head' table were missing */
 395
 396       head_buf = table_info->buf;
 397
 398       /* reset checksum in `head' table for recalculation */
 399       head_buf[8] = 0x00;
 400       head_buf[9] = 0x00;
 401       head_buf[10] = 0x00;
 402       head_buf[11] = 0x00;
 403     }
 404
 405     table_checksum = TA_table_compute_checksum(table_info->buf,
 406                                                table_info->len);
 407     head_checksum += table_checksum;
 408
 409     table_record[0] = BYTE1(table_info->tag);
 410     table_record[1] = BYTE2(table_info->tag);
 411     table_record[2] = BYTE3(table_info->tag);
 412     table_record[3] = BYTE4(table_info->tag);
 413
 414     table_record[4] = BYTE1(table_checksum);
 415     table_record[5] = BYTE2(table_checksum);
 416     table_record[6] = BYTE3(table_checksum);
 417     table_record[7] = BYTE4(table_checksum);
 418
 419     table_record[8] = BYTE1(table_offset);
 420     table_record[9] = BYTE2(table_offset);
 421     table_record[10] = BYTE3(table_offset);
 422     table_record[11] = BYTE4(table_offset);
 423
 424     table_record[12] = BYTE1(table_info->len);
 425     table_record[13] = BYTE2(table_info->len);
 426     table_record[14] = BYTE3(table_info->len);
 427     table_record[15] = BYTE4(table_info->len);
 428
 429     table_record += 16;
 430     /* table offsets must be a multiple of 4; */
 431     /* this also fits the actual buffer length */
 432     table_offset += (table_info->len + 3) & ~3;
 433   }
 434
 435   /* the font header is complete; compute `head' checksum */
 436   head_checksum += TA_table_compute_checksum(header_buf, header_len);
 437   head_checksum = 0xB1B0AFBAUL - head_checksum;
 438
 439   /* store checksum in `head' table; */
 440   head_buf[8] = BYTE1(head_checksum);
 441   head_buf[9] = BYTE2(head_checksum);
 442   head_buf[10] = BYTE3(head_checksum);
 443   head_buf[11] = BYTE4(head_checksum);
 444
 445   /* build font */
 446   font->out_len = table_offset;
 447   font->out_buf = (FT_Byte*)malloc(font->out_len * sizeof (FT_Byte));
 448   if (!font->out_buf)
 449   {
 450     error = FT_Err_Out_Of_Memory;
 451     goto Err;
 452   }
 453
 454   memcpy(font->out_buf, header_buf, header_len);
 455
 456   for (i = 0; i < num_table_infos; i++)
 457   {
 458     SFNT_Table *table_info = &table_infos[i];
 459
 460
 461     if (!table_info->len)
 462       continue;
 463
 464     /* buffer length is a multiple of 4 */
 465     memcpy(font->out_buf + table_info->offset,
 466            table_info->buf, (table_info->len + 3) & ~3);
 467   }
 468
 469   error = TA_Err_Ok;
 470
 471 Err:
 472   free(header_buf);
 473
 474   return error;
 475 }
 476
 477
 478 static FT_Error
 479 TA_font_build_TTC(FONT* font)
 480 {
 481   return TA_Err_Ok;
 482 }
 483
 484
 485 static FT_Error
 486 TA_font_write(FILE* out,
 487               FONT* font)
 488 {
 489   if (fwrite(font->out_buf, 1, font->out_len, out) != font->out_len)
 490     return TA_Err_Invalid_Stream_Write;
 491
 492   return TA_Err_Ok;
 493 }
 494
 495
 496 static void
 497 TA_font_unload(FONT* font)
 498 {
 499   /* in case of error it is expected that unallocated pointers */
 500   /* are NULL (and counters are zero) */
 501
 502   if (!font)
 503     return;
 504
 505   if (font->tables)
 506   {
 507     FT_ULong i;
 508
 509
 510     for (i = 0; i < font->num_tables; i++)
 511       free(font->tables[i].buf);
 512     free(font->tables);
 513   }
 514
 515   if (font->sfnts)
 516   {
 517     FT_Long i;
 518
 519
 520     for (i = 0; i < font->num_sfnts; i++)
 521     {
 522       FT_Done_Face(font->sfnts[i].face);
 523       free(font->sfnts[i].table_infos);
 524     }
 525     free(font->sfnts);
 526   }
 527
 528   FT_Done_FreeType(font->lib);
 529   free(font->in_buf);
 530   free(font->out_buf);
 531   free(font);
 532 }
 533
 534
 535 TA_Error
 536 TTF_autohint(FILE* in,
 537              FILE* out)
 538 {
 539   FONT* font;
 540   FT_Error error;
 541   FT_Long i;
 542
 543
 544   font = (FONT*)calloc(1, sizeof (FONT));
 545   if (!font)
 546     return FT_Err_Out_Of_Memory;
 547
 548   error = TA_font_read(in, font);
 549   if (error)
 550     goto Err;
 551
 552   error = TA_font_init(font);
 553   if (error)
 554     goto Err;
 555
 556   /* loop over subfonts */
 557   for (i = 0; i < font->num_sfnts; i++)
 558   {
 559     SFNT* sfnt = &font->sfnts[i];
 560
 561
 562     error = FT_New_Memory_Face(font->lib, font->in_buf, font->in_len,
 563                                i, &sfnt->face);
 564     if (error)
 565       goto Err;
 566
 567     error = TA_sfnt_collect_table_info(sfnt);
 568     if (error)
 569       goto Err;
 570
 571     error = TA_font_split_into_SFNT_tables(sfnt, font);
 572     if (error)
 573       goto Err;
 574   }
 575
 576
 577   /* compute global hints */
 578   /* construct `fpgm' table */
 579   /* construct `prep' table */
 580   /* construct `cvt ' table */
 581
 582   /* split `glyf' table */
 583   /* handle all glyphs in a loop */
 584     /* strip bytecode */
 585     /* hint the glyph */
 586     /* construct bytecode */
 587
 588   /* construct `glyf' table */
 589
 590   /* build font from SFNT tables */
 591   if (font->num_sfnts == 1)
 592     error = TA_font_build_TTF(font);
 593   else
 594     error = TA_font_build_TTC(font);
 595   if (error)
 596     goto Err;
 597
 598   /* write font from memory */
 599   error = TA_font_write(out, font);
 600   if (error)
 601     goto Err;
 602
 603   error = TA_Err_Ok;
 604
 605 Err:
 606   TA_font_unload(font);
 607
 608   return error;
 609 }
 610
 611 /* end of ttfautohint.c */