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 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10
  11 #include "ta.h"
  12
  13
  14 static FT_Error
  15 TA_font_read(FONT* font,
  16              FILE* in)
  17 {
  18   fseek(in, 0, SEEK_END);
  19   font->in_len = ftell(in);
  20   fseek(in, 0, SEEK_SET);
  21
  22   /* a valid TTF can never be that small */
  23   if (font->in_len < 100)
  24     return FT_Err_Invalid_Argument;
  25
  26   font->in_buf = (FT_Byte*)malloc(font->in_len);
  27   if (!font->in_buf)
  28     return FT_Err_Out_Of_Memory;
  29
  30   if (fread(font->in_buf, 1, font->in_len, in) != font->in_len)
  31     return FT_Err_Invalid_Stream_Read;
  32
  33   return TA_Err_Ok;
  34 }
  35
  36
  37 static FT_Error
  38 TA_font_init(FONT* font)
  39 {
  40   FT_Error error;
  41   FT_Face f;
  42
  43
  44   error = FT_Init_FreeType(&font->lib);
  45   if (error)
  46     return error;
  47
  48   /* get number of faces (i.e. subfonts) */
  49   error = FT_New_Memory_Face(font->lib, font->in_buf, font->in_len, -1, &f);
  50   if (error)
  51     return error;
  52   font->num_sfnts = f->num_faces;
  53   FT_Done_Face(f);
  54
  55   /* it is a TTC if we have more than a single subfont */
  56   font->sfnts = (SFNT*)calloc(1, font->num_sfnts * sizeof (SFNT));
  57   if (!font->sfnts)
  58     return FT_Err_Out_Of_Memory;
  59
  60   return TA_Err_Ok;
  61 }
  62
  63
  64 static FT_Error
  65 TA_sfnt_split_into_SFNT_tables(SFNT* sfnt,
  66                                FONT* font)
  67 {
  68   FT_Error error;
  69   FT_ULong i;
  70
  71
  72   /* basic check whether font is a TTF or TTC */
  73   if (!FT_IS_SFNT(sfnt->face))
  74     return FT_Err_Invalid_Argument;
  75
  76   error = FT_Sfnt_Table_Info(sfnt->face, 0, NULL, &sfnt->num_table_infos);
  77   if (error)
  78     return error;
  79
  80   sfnt->table_infos = (SFNT_Table_Info*)malloc(sfnt->num_table_infos
  81                                                * sizeof (SFNT_Table_Info));
  82   if (!sfnt->table_infos)
  83     return FT_Err_Out_Of_Memory;
  84
  85   /* collect SFNT tables and search for `glyf' and `loca' table */
  86   sfnt->glyf_idx = MISSING;
  87   sfnt->loca_idx = MISSING;
  88   sfnt->head_idx = MISSING;
  89   sfnt->maxp_idx = MISSING;
  90
  91   for (i = 0; i < sfnt->num_table_infos; i++)
  92   {
  93     SFNT_Table_Info* table_info = &sfnt->table_infos[i];
  94     FT_ULong tag;
  95     FT_ULong len;
  96     FT_Byte* buf;
  97
  98     FT_ULong buf_len;
  99     FT_ULong j;
 100
 101
 102     *table_info = MISSING;
 103
 104     error = FT_Sfnt_Table_Info(sfnt->face, i, &tag, &len);
 105     if (error)
 106     {
 107       /* this ignores both missing and zero-length tables */
 108       if (error == FT_Err_Table_Missing)
 109         continue;
 110       else
 111         return error;
 112     }
 113
 114     /* ignore tables which we are going to create by ourselves, */
 115     /* or which would become invalid otherwise */
 116     else if (tag == TTAG_fpgm
 117              || tag == TTAG_prep
 118              || tag == TTAG_cvt
 119              || tag == TTAG_DSIG
 120              || tag == TTAG_hdmx
 121              || tag == TTAG_VDMX
 122              || tag == TTAG_LTSH)
 123       continue;
 124
 125     /* make the allocated buffer length a multiple of 4 */
 126     buf_len = (len + 3) & -3;
 127     buf = (FT_Byte*)malloc(buf_len);
 128     if (!buf)
 129       return FT_Err_Out_Of_Memory;
 130
 131     /* pad end of buffer with zeros */
 132     buf[buf_len - 1] = 0x00;
 133     buf[buf_len - 2] = 0x00;
 134     buf[buf_len - 3] = 0x00;
 135
 136     /* load table */
 137     error = FT_Load_Sfnt_Table(sfnt->face, tag, 0, buf, &len);
 138     if (error)
 139       goto Err;
 140
 141     /* check whether we already have this table */
 142     for (j = 0; j < font->num_tables; j++)
 143     {
 144       SFNT_Table* table = &font->tables[j];
 145
 146
 147       if (table->tag == tag
 148           && table->len == len
 149           && !memcmp(table->buf, buf, len))
 150         break;
 151     }
 152
 153     if (tag == TTAG_head)
 154       sfnt->head_idx = j;
 155     else if (tag == TTAG_glyf)
 156       sfnt->glyf_idx = j;
 157     else if (tag == TTAG_loca)
 158       sfnt->loca_idx = j;
 159     else if (tag == TTAG_maxp)
 160       sfnt->maxp_idx = j;
 161
 162     if (j == font->num_tables)
 163     {
 164       /* add element to table array if it is missing or different; */
 165       /* in case of success, `buf' gets linked and is eventually */
 166       /* freed in `TA_font_unload' */
 167       error = TA_font_add_table(font, table_info, tag, len, buf);
 168       if (error)
 169         goto Err;
 170     }
 171     else
 172     {
 173       /* reuse existing SFNT table */
 174       free(buf);
 175       *table_info = j;
 176     }
 177     continue;
 178
 179   Err:
 180     free(buf);
 181     return error;
 182   }
 183
 184   /* no (non-empty) `glyf', `loca', `head', or `maxp' table; */
 185   /* this can't be a valid TTF with outlines */
 186   if (sfnt->glyf_idx == MISSING
 187       || sfnt->loca_idx == MISSING
 188       || sfnt->head_idx == MISSING
 189       || sfnt->maxp_idx == MISSING)
 190     return FT_Err_Invalid_Argument;
 191
 192   return TA_Err_Ok;
 193 }
 194
 195
 196 static FT_Error
 197 TA_glyph_parse_composite(GLYPH* glyph,
 198                          FT_Byte* buf,
 199                          FT_ULong len)
 200 {
 201   FT_ULong flags_offset; /* after the loop, this is the offset */
 202                          /* to the last element in the flags array */
 203   FT_UShort flags;
 204
 205   FT_Byte* p;
 206   FT_Byte* endp;
 207
 208
 209   p = buf;
 210   endp = buf + len;
 211
 212   /* skip header */
 213   p += 10;
 214
 215   /* walk over component records */
 216   do
 217   {
 218     if (p + 4 > endp)
 219       return FT_Err_Invalid_Table;
 220
 221     flags_offset = p - buf;
 222
 223     flags = *(p++) << 8;
 224     flags += *(p++);
 225
 226     /* skip glyph component index */
 227     p += 2;
 228
 229     /* skip scaling and offset arguments */
 230     if (flags & ARGS_ARE_WORDS)
 231       p += 4;
 232     else
 233       p += 2;
 234
 235     if (flags & WE_HAVE_A_SCALE)
 236       p += 2;
 237     else if (flags & WE_HAVE_AN_XY_SCALE)
 238       p += 4;
 239     else if (flags & WE_HAVE_A_2X2)
 240       p += 8;
 241   } while (flags & MORE_COMPONENTS);
 242
 243   glyph->flags_offset = flags_offset;
 244
 245   /* adjust glyph record length */
 246   len = p - buf;
 247
 248   glyph->len1 = len;
 249   /* glyph->len2 = 0; */
 250   glyph->buf = (FT_Byte*)malloc(len);
 251   if (!glyph->buf)
 252     return FT_Err_Out_Of_Memory;
 253
 254   /* copy record without instructions (if any) */
 255   memcpy(glyph->buf, buf, len);
 256   glyph->buf[flags_offset] &= ~(WE_HAVE_INSTR >> 8);
 257
 258   return TA_Err_Ok;
 259 }
 260
 261
 262 static FT_Error
 263 TA_glyph_parse_simple(GLYPH* glyph,
 264                       FT_Byte* buf,
 265                       FT_UShort num_contours,
 266                       FT_ULong len)
 267 {
 268   FT_ULong ins_offset;
 269   FT_Byte* flags_start;
 270
 271   FT_UShort num_ins;
 272   FT_UShort num_pts;
 273
 274   FT_ULong flags_size; /* size of the flags array */
 275   FT_ULong xy_size; /* size of x and y coordinate arrays together */
 276
 277   FT_Byte* p;
 278   FT_Byte* endp;
 279
 280   FT_UShort i;
 281
 282
 283   p = buf;
 284   endp = buf + len;
 285
 286   ins_offset = 10 + num_contours * 2;
 287
 288   p += ins_offset;
 289
 290   if (p + 2 > endp)
 291     return FT_Err_Invalid_Table;
 292
 293   /* get number of instructions */
 294   num_ins = *(p++) << 8;
 295   num_ins += *(p++);
 296
 297   p += num_ins;
 298
 299   if (p > endp)
 300     return FT_Err_Invalid_Table;
 301
 302   /* get number of points from last outline point */
 303   num_pts = buf[ins_offset - 2] << 8;
 304   num_pts += buf[ins_offset - 1];
 305   num_pts++;
 306
 307   flags_start = p;
 308   xy_size = 0;
 309   i = 0;
 310
 311   while (i < num_pts)
 312   {
 313     FT_Byte flags;
 314     FT_Byte x_short;
 315     FT_Byte y_short;
 316     FT_Byte have_x;
 317     FT_Byte have_y;
 318     FT_Byte count;
 319
 320
 321     if (p + 1 > endp)
 322       return FT_Err_Invalid_Table;
 323
 324     flags = *(p++);
 325
 326     x_short = (flags & X_SHORT_VECTOR) ? 1 : 2;
 327     y_short = (flags & Y_SHORT_VECTOR) ? 1 : 2;
 328
 329     have_x = ((flags & SAME_X) && !(flags & X_SHORT_VECTOR)) ? 0 : 1;
 330     have_y = ((flags & SAME_Y) && !(flags & Y_SHORT_VECTOR)) ? 0 : 1;
 331
 332     count = 1;
 333
 334     if (flags & REPEAT)
 335     {
 336       if (p + 1 > endp)
 337         return FT_Err_Invalid_Table;
 338
 339       count += *(p++);
 340
 341       if (i + count > num_pts)
 342         return FT_Err_Invalid_Table;
 343     }
 344
 345     xy_size += count * x_short * have_x;
 346     xy_size += count * y_short * have_y;
 347
 348     i += count;
 349   }
 350
 351   if (p + xy_size > endp)
 352     return FT_Err_Invalid_Table;
 353
 354   flags_size = p - flags_start;
 355
 356   /* store the data before and after the bytecode instructions */
 357   /* in the same array */
 358   glyph->len1 = ins_offset;
 359   glyph->len2 = flags_size + xy_size;
 360   glyph->buf = (FT_Byte*)malloc(glyph->len1 + glyph->len2);
 361   if (!glyph->buf)
 362     return FT_Err_Out_Of_Memory;
 363
 364   /* now copy everything but the instructions */
 365   memcpy(glyph->buf, buf, glyph->len1);
 366   memcpy(glyph->buf + glyph->len1, flags_start, glyph->len2);
 367
 368   return TA_Err_Ok;
 369 }
 370
 371
 372 static FT_Error
 373 TA_sfnt_split_glyf_table(SFNT* sfnt,
 374                          FONT* font)
 375 {
 376   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
 377   SFNT_Table* loca_table = &font->tables[sfnt->loca_idx];
 378   SFNT_Table* head_table = &font->tables[sfnt->head_idx];
 379
 380   glyf_Data* data;
 381   FT_Byte loca_format;
 382
 383   FT_ULong offset;
 384   FT_ULong offset_next;
 385
 386   FT_Byte* p;
 387   FT_UShort i;
 388
 389
 390   /* in case of success, all allocated arrays are */
 391   /* linked and eventually freed in `TA_font_unload' */
 392
 393   /* nothing to do if table has already been split */
 394   if (glyf_table->data)
 395     return TA_Err_Ok;
 396
 397   data = (glyf_Data*)calloc(1, sizeof (glyf_Data));
 398   if (!data)
 399     return FT_Err_Out_Of_Memory;
 400
 401   glyf_table->data = data;
 402
 403   loca_format = head_table->buf[LOCA_FORMAT_OFFSET];
 404
 405   data->num_glyphs = loca_format ? loca_table->len / 4 - 1
 406                                  : loca_table->len / 2 - 1;
 407   data->glyphs = (GLYPH*)calloc(1, data->num_glyphs * sizeof (GLYPH));
 408   if (!data->glyphs)
 409     return FT_Err_Out_Of_Memory;
 410
 411   p = loca_table->buf;
 412
 413   if (loca_format)
 414   {
 415     offset_next = *(p++) << 24;
 416     offset_next += *(p++) << 16;
 417     offset_next += *(p++) << 8;
 418     offset_next += *(p++);
 419   }
 420   else
 421   {
 422     offset_next = *(p++) << 8;
 423     offset_next += *(p++);
 424     offset_next <<= 1;
 425   }
 426
 427   /* loop over `loca' and `glyf' data */
 428   for (i = 0; i < data->num_glyphs; i++)
 429   {
 430     GLYPH* glyph = &data->glyphs[i];
 431     FT_ULong len;
 432
 433
 434     offset = offset_next;
 435
 436     if (loca_format)
 437     {
 438       offset_next = *(p++) << 24;
 439       offset_next += *(p++) << 16;
 440       offset_next += *(p++) << 8;
 441       offset_next += *(p++);
 442     }
 443     else
 444     {
 445       offset_next = *(p++) << 8;
 446       offset_next += *(p++);
 447       offset_next <<= 1;
 448     }
 449
 450     if (offset_next < offset
 451         || offset_next > glyf_table->len)
 452       return FT_Err_Invalid_Table;
 453
 454     len = offset_next - offset;
 455     if (!len)
 456       continue; /* empty glyph */
 457     else
 458     {
 459       FT_Byte* buf;
 460       FT_Short num_contours;
 461       FT_Error error;
 462
 463
 464       /* check header size */
 465       if (len < 10)
 466         return FT_Err_Invalid_Table;
 467
 468       buf = glyf_table->buf + offset;
 469       num_contours = (FT_Short)((buf[0] << 8) + buf[1]);
 470
 471       /* We must parse the rest of the glyph record to get the exact */
 472       /* record length.  Since the `loca' table rounds record lengths */
 473       /* up to multiples of 4 (or 2 for older fonts), and we must round */
 474       /* up again after stripping off the instructions, it would be */
 475       /* possible otherwise to have more than 4 bytes of padding which */
 476       /* is more or less invalid. */
 477
 478       if (num_contours < 0)
 479       {
 480         error = TA_glyph_parse_composite(glyph, buf, len);
 481         if (error)
 482           return error;
 483       }
 484       else
 485       {
 486         error = TA_glyph_parse_simple(glyph, buf, num_contours, len);
 487         if (error)
 488           return error;
 489       }
 490     }
 491   }
 492
 493   return TA_Err_Ok;
 494 }
 495
 496
 497 static FT_Error
 498 TA_sfnt_build_glyf_table(SFNT* sfnt,
 499                          FONT* font)
 500 {
 501   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
 502   glyf_Data* data = (glyf_Data*)glyf_table->data;
 503
 504   GLYPH* glyph;
 505
 506   FT_ULong len;
 507   FT_Byte* buf_new;
 508   FT_Byte* p;
 509   FT_UShort i;
 510
 511
 512   if (glyf_table->processed)
 513     return TA_Err_Ok;
 514
 515   /* get table size */
 516   len = 0;
 517   glyph = data->glyphs;
 518   for (i = 0; i < data->num_glyphs; i++, glyph++)
 519   {
 520     /* glyph records should have offsets which are multiples of 4 */
 521     len = (len + 3) & ~3;
 522     len += glyph->len1 + glyph->len2 + glyph->ins_len;
 523     /* add two bytes for the instructionLength field */
 524     if (glyph->len2 || glyph->ins_len)
 525       len += 2;
 526   }
 527
 528   glyf_table->len = len;
 529   buf_new = (FT_Byte*)realloc(glyf_table->buf, (len + 3) & ~3);
 530   if (!buf_new)
 531     return FT_Err_Out_Of_Memory;
 532   else
 533     glyf_table->buf = buf_new;
 534
 535   p = glyf_table->buf;
 536   glyph = data->glyphs;
 537   for (i = 0; i < data->num_glyphs; i++, glyph++)
 538   {
 539     len = glyph->len1 + glyph->len2 + glyph->ins_len;
 540     if (glyph->len2 || glyph->ins_len)
 541       len += 2;
 542
 543     if (len)
 544     {
 545       /* copy glyph data and insert new instructions */
 546       memcpy(p, glyph->buf, glyph->len1);
 547
 548       if (glyph->len2)
 549       {
 550         /* simple glyph */
 551         p += glyph->len1;
 552         *(p++) = HIGH(glyph->ins_len);
 553         *(p++) = LOW(glyph->ins_len);
 554         memcpy(p, glyph->ins_buf, glyph->ins_len);
 555         p += glyph->ins_len;
 556         memcpy(p, glyph->buf + glyph->len1, glyph->len2);
 557         p += glyph->len2;
 558       }
 559       else
 560       {
 561         /* composite glyph */
 562         if (glyph->ins_len)
 563         {
 564           *(p + glyph->flags_offset) |= (WE_HAVE_INSTR >> 8);
 565           p += glyph->len1;
 566           *(p++) = HIGH(glyph->ins_len);
 567           *(p++) = LOW(glyph->ins_len);
 568           memcpy(p, glyph->ins_buf, glyph->ins_len);
 569           p += glyph->ins_len;
 570         }
 571         else
 572           p += glyph->len1;
 573       }
 574
 575       /* pad with zero bytes to have an offset which is a multiple of 4; */
 576       /* this works even for the last glyph record since the `glyf' */
 577       /* table length is a multiple of 4 also */
 578       switch (len % 4)
 579       {
 580       case 1:
 581         *(p++) = 0;
 582       case 2:
 583         *(p++) = 0;
 584       case 3:
 585         *(p++) = 0;
 586       default:
 587         break;
 588       }
 589     }
 590   }
 591
 592   glyf_table->checksum = TA_table_compute_checksum(glyf_table->buf,
 593                                                    glyf_table->len);
 594   glyf_table->processed = 1;
 595
 596   return TA_Err_Ok;
 597 }
 598
 599
 600 static FT_Error
 601 TA_sfnt_build_loca_table(SFNT* sfnt,
 602                          FONT* font)
 603 {
 604   SFNT_Table* loca_table = &font->tables[sfnt->loca_idx];
 605   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
 606   SFNT_Table* head_table = &font->tables[sfnt->head_idx];
 607
 608   glyf_Data* data = (glyf_Data*)glyf_table->data;
 609   GLYPH* glyph;
 610
 611   FT_ULong offset;
 612   FT_Byte loca_format;
 613   FT_Byte* buf_new;
 614   FT_Byte* p;
 615   FT_UShort i;
 616
 617
 618   if (loca_table->processed)
 619     return TA_Err_Ok;
 620
 621   /* get largest offset */
 622   offset = 0;
 623   glyph = data->glyphs;
 624
 625   for (i = 0; i < data->num_glyphs; i++, glyph++)
 626   {
 627     /* glyph records should have offsets which are multiples of 4 */
 628     offset = (offset + 3) & ~3;
 629     offset += glyph->len1 + glyph->len2 + glyph->ins_len;
 630     /* add two bytes for the instructionLength field */
 631     if (glyph->len2 || glyph->ins_len)
 632       offset += 2;
 633   }
 634
 635   if (offset > 0xFFFF * 2)
 636     loca_format = 1;
 637   else
 638     loca_format = 0;
 639
 640   /* fill table */
 641   if (loca_format)
 642   {
 643     loca_table->len = (data->num_glyphs + 1) * 4;
 644     buf_new = (FT_Byte*)realloc(loca_table->buf, loca_table->len);
 645     if (!buf_new)
 646       return FT_Err_Out_Of_Memory;
 647     else
 648       loca_table->buf = buf_new;
 649
 650     p = loca_table->buf;
 651     offset = 0;
 652     glyph = data->glyphs;
 653
 654     for (i = 0; i < data->num_glyphs; i++, glyph++)
 655     {
 656       offset = (offset + 3) & ~3;
 657
 658       *(p++) = BYTE1(offset);
 659       *(p++) = BYTE2(offset);
 660       *(p++) = BYTE3(offset);
 661       *(p++) = BYTE4(offset);
 662
 663       offset += glyph->len1 + glyph->len2 + glyph->ins_len;
 664       if (glyph->len2 || glyph->ins_len)
 665         offset += 2;
 666     }
 667
 668     /* last element holds the size of the `glyf' table */
 669     *(p++) = BYTE1(offset);
 670     *(p++) = BYTE2(offset);
 671     *(p++) = BYTE3(offset);
 672     *(p++) = BYTE4(offset);
 673   }
 674   else
 675   {
 676     loca_table->len = (data->num_glyphs + 1) * 2;
 677     buf_new = (FT_Byte*)realloc(loca_table->buf,
 678                                 (loca_table->len + 3) & ~3);
 679     if (!buf_new)
 680       return FT_Err_Out_Of_Memory;
 681     else
 682       loca_table->buf = buf_new;
 683
 684     p = loca_table->buf;
 685     offset = 0;
 686     glyph = data->glyphs;
 687
 688     for (i = 0; i < data->num_glyphs; i++, glyph++)
 689     {
 690       offset = (offset + 1) & ~1;
 691
 692       *(p++) = HIGH(offset);
 693       *(p++) = LOW(offset);
 694
 695       offset += (glyph->len1 + glyph->len2 + glyph->ins_len + 1) >> 1;
 696       if (glyph->len2 || glyph->ins_len)
 697         offset += 1;
 698     }
 699
 700     /* last element holds the size of the `glyf' table */
 701     *(p++) = HIGH(offset);
 702     *(p++) = LOW(offset);
 703
 704     /* pad `loca' table to make its length a multiple of 4 */
 705     if (loca_table->len % 4 == 2)
 706     {
 707       *(p++) = 0;
 708       *(p++) = 0;
 709     }
 710   }
 711
 712   loca_table->checksum = TA_table_compute_checksum(loca_table->buf,
 713                                                    loca_table->len);
 714   loca_table->processed = 1;
 715
 716   head_table->buf[LOCA_FORMAT_OFFSET] = loca_format;
 717
 718   return TA_Err_Ok;
 719 }
 720
 721
 722 static FT_Error
 723 TA_sfnt_update_maxp_table(SFNT* sfnt,
 724                           FONT* font)
 725 {
 726   SFNT_Table* maxp_table = &font->tables[sfnt->maxp_idx];
 727   FT_Byte* buf = maxp_table->buf;
 728
 729
 730   if (maxp_table->processed)
 731     return TA_Err_Ok;
 732
 733   if (maxp_table->len != MAXP_LEN)
 734     return FT_Err_Invalid_Table;
 735
 736   buf[MAXP_MAX_ZONES_OFFSET] = 0;
 737   buf[MAXP_MAX_ZONES_OFFSET + 1] = 1;
 738   buf[MAXP_MAX_TWILIGHT_POINTS_OFFSET] = 0;
 739   buf[MAXP_MAX_TWILIGHT_POINTS_OFFSET + 1] = 0;
 740   buf[MAXP_MAX_STORAGE_OFFSET] = 0;
 741   buf[MAXP_MAX_STORAGE_OFFSET + 1] = 0;
 742   buf[MAXP_MAX_FUNCTION_DEFS_OFFSET] = 0;
 743   buf[MAXP_MAX_FUNCTION_DEFS_OFFSET + 1] = 0;
 744   buf[MAXP_MAX_INSTRUCTION_DEFS_OFFSET] = 0;
 745   buf[MAXP_MAX_INSTRUCTION_DEFS_OFFSET + 1] = 0;
 746   buf[MAXP_MAX_STACK_ELEMENTS_OFFSET] = 0;
 747   buf[MAXP_MAX_STACK_ELEMENTS_OFFSET + 1] = 0;
 748   buf[MAXP_MAX_INSTRUCTIONS_OFFSET] = 0;
 749   buf[MAXP_MAX_INSTRUCTIONS_OFFSET + 1] = 0;
 750
 751   maxp_table->checksum = TA_table_compute_checksum(maxp_table->buf,
 752                                                    maxp_table->len);
 753   maxp_table->processed = 1;
 754
 755   return TA_Err_Ok;
 756 }
 757
 758
 759 /* we build a dummy `DSIG' table only */
 760
 761 static FT_Error
 762 TA_table_build_DSIG(FT_Byte** DSIG)
 763 {
 764   FT_Byte* buf;
 765
 766
 767   buf = (FT_Byte*)malloc(DSIG_LEN);
 768   if (!buf)
 769     return FT_Err_Out_Of_Memory;
 770
 771   /* version */
 772   buf[0] = 0x00;
 773   buf[1] = 0x00;
 774   buf[2] = 0x00;
 775   buf[3] = 0x01;
 776
 777   /* zero signatures */
 778   buf[4] = 0x00;
 779   buf[5] = 0x00;
 780
 781   /* permission flags */
 782   buf[6] = 0x00;
 783   buf[7] = 0x00;
 784
 785   *DSIG = buf;
 786
 787   return TA_Err_Ok;
 788 }
 789
 790
 791 static void
 792 TA_font_compute_table_offsets(FONT* font,
 793                               FT_ULong start)
 794 {
 795   FT_ULong i;
 796   FT_ULong offset = start;
 797
 798
 799   for (i = 0; i < font->num_tables; i++)
 800   {
 801     SFNT_Table* table = &font->tables[i];
 802
 803
 804     table->offset = offset;
 805
 806     /* table offsets must be multiples of 4; */
 807     /* this also fits the actual buffer lengths */
 808     offset += (table->len + 3) & ~3;
 809   }
 810 }
 811
 812
 813 /* If `do_complete' is 0, only return `header_len'. */
 814
 815 static FT_Error
 816 TA_sfnt_build_TTF_header(SFNT* sfnt,
 817                          FONT* font,
 818                          FT_Byte** header_buf,
 819                          FT_ULong* header_len,
 820                          FT_Int do_complete)
 821 {
 822   SFNT_Table* tables = font->tables;
 823
 824   SFNT_Table_Info* table_infos = sfnt->table_infos;
 825   FT_ULong num_table_infos = sfnt->num_table_infos;
 826
 827   FT_Byte* buf;
 828   FT_ULong len;
 829
 830   FT_Byte* table_record;
 831
 832   FT_Byte* head_buf = NULL; /* pointer to `head' table */
 833   FT_ULong head_checksum; /* checksum in `head' table */
 834
 835   FT_ULong num_tables_in_header;
 836   FT_ULong i;
 837
 838
 839   num_tables_in_header = 0;
 840   for (i = 0; i < num_table_infos; i++)
 841   {
 842     /* ignore empty tables */
 843     if (table_infos[i] != MISSING)
 844       num_tables_in_header++;
 845   }
 846
 847   len = 12 + 16 * num_tables_in_header;
 848   if (!do_complete)
 849   {
 850     *header_len = len;
 851     return TA_Err_Ok;
 852   }
 853   buf = (FT_Byte*)malloc(len);
 854   if (!buf)
 855     return FT_Err_Out_Of_Memory;
 856
 857   /* SFNT version */
 858   buf[0] = 0x00;
 859   buf[1] = 0x01;
 860   buf[2] = 0x00;
 861   buf[3] = 0x00;
 862
 863   /* number of tables */
 864   buf[4] = HIGH(num_tables_in_header);
 865   buf[5] = LOW(num_tables_in_header);
 866
 867   /* auxiliary data */
 868   {
 869     FT_ULong search_range, entry_selector, range_shift;
 870     FT_ULong i, j;
 871
 872
 873     for (i = 1, j = 2; j <= num_tables_in_header; i++, j <<= 1)
 874       ;
 875
 876     entry_selector = i - 1;
 877     search_range = 0x10 << entry_selector;
 878     range_shift = (num_tables_in_header << 4) - search_range;
 879
 880     buf[6] = HIGH(search_range);
 881     buf[7] = LOW(search_range);
 882     buf[8] = HIGH(entry_selector);
 883     buf[9] = LOW(entry_selector);
 884     buf[10] = HIGH(range_shift);
 885     buf[11] = LOW(range_shift);
 886   }
 887
 888   /* location of the first table info record */
 889   table_record = &buf[12];
 890
 891   head_checksum = 0;
 892
 893   /* loop over all tables */
 894   for (i = 0; i < num_table_infos; i++)
 895   {
 896     SFNT_Table_Info table_info = table_infos[i];
 897     SFNT_Table* table;
 898
 899
 900     /* ignore empty slots */
 901     if (table_info == MISSING)
 902       continue;
 903
 904     table = &tables[table_info];
 905
 906     if (table->tag == TTAG_head)
 907     {
 908       /* we always reach this IF clause since FreeType would */
 909       /* have aborted already if the `head' table were missing */
 910
 911       head_buf = table->buf;
 912
 913       /* reset checksum in `head' table for recalculation */
 914       head_buf[8] = 0x00;
 915       head_buf[9] = 0x00;
 916       head_buf[10] = 0x00;
 917       head_buf[11] = 0x00;
 918     }
 919
 920     head_checksum += table->checksum;
 921
 922     table_record[0] = BYTE1(table->tag);
 923     table_record[1] = BYTE2(table->tag);
 924     table_record[2] = BYTE3(table->tag);
 925     table_record[3] = BYTE4(table->tag);
 926
 927     table_record[4] = BYTE1(table->checksum);
 928     table_record[5] = BYTE2(table->checksum);
 929     table_record[6] = BYTE3(table->checksum);
 930     table_record[7] = BYTE4(table->checksum);
 931
 932     table_record[8] = BYTE1(table->offset);
 933     table_record[9] = BYTE2(table->offset);
 934     table_record[10] = BYTE3(table->offset);
 935     table_record[11] = BYTE4(table->offset);
 936
 937     table_record[12] = BYTE1(table->len);
 938     table_record[13] = BYTE2(table->len);
 939     table_record[14] = BYTE3(table->len);
 940     table_record[15] = BYTE4(table->len);
 941
 942     table_record += 16;
 943   }
 944
 945   /* the font header is complete; compute `head' checksum */
 946   head_checksum += TA_table_compute_checksum(buf, len);
 947   head_checksum = 0xB1B0AFBAUL - head_checksum;
 948
 949   /* store checksum in `head' table; */
 950   head_buf[8] = BYTE1(head_checksum);
 951   head_buf[9] = BYTE2(head_checksum);
 952   head_buf[10] = BYTE3(head_checksum);
 953   head_buf[11] = BYTE4(head_checksum);
 954
 955   *header_buf = buf;
 956   *header_len = len;
 957
 958   return TA_Err_Ok;
 959 }
 960
 961
 962 static FT_Error
 963 TA_font_build_TTF(FONT* font)
 964 {
 965   SFNT* sfnt = &font->sfnts[0];
 966
 967   SFNT_Table* tables;
 968   FT_ULong num_tables;
 969
 970   FT_ULong SFNT_offset;
 971
 972   FT_Byte* DSIG_buf;
 973
 974   FT_Byte* header_buf;
 975   FT_ULong header_len;
 976
 977   FT_ULong i;
 978   FT_Error error;
 979
 980
 981   /* add a dummy `DSIG' table */
 982
 983   error = TA_sfnt_add_table_info(sfnt);
 984   if (error)
 985     return error;
 986
 987   error = TA_table_build_DSIG(&DSIG_buf);
 988   if (error)
 989     return error;
 990
 991   /* in case of success, `DSIG_buf' gets linked */
 992   /* and is eventually freed in `TA_font_unload' */
 993   error = TA_font_add_table(font,
 994                             &sfnt->table_infos[sfnt->num_table_infos - 1],
 995                             TTAG_DSIG, DSIG_LEN, DSIG_buf);
 996   if (error)
 997   {
 998     free(DSIG_buf);
 999     return error;
1000   }
1001
1002   TA_sfnt_sort_table_info(sfnt, font);
1003
1004   /* the first SFNT table immediately follows the header */
1005   (void)TA_sfnt_build_TTF_header(sfnt, font, NULL, &SFNT_offset, 0);
1006   TA_font_compute_table_offsets(font, SFNT_offset);
1007
1008   error = TA_sfnt_build_TTF_header(sfnt, font,
1009                                    &header_buf, &header_len, 1);
1010   if (error)
1011     return error;
1012
1013   /* build font */
1014
1015   tables = font->tables;
1016   num_tables = font->num_tables;
1017
1018   /* get font length from last SFNT table array element */
1019   font->out_len = tables[num_tables - 1].offset
1020                   + ((tables[num_tables - 1].len + 3) & ~3);
1021   font->out_buf = (FT_Byte*)malloc(font->out_len);
1022   if (!font->out_buf)
1023   {
1024     error = FT_Err_Out_Of_Memory;
1025     goto Err;
1026   }
1027
1028   memcpy(font->out_buf, header_buf, header_len);
1029
1030   for (i = 0; i < num_tables; i++)
1031   {
1032     SFNT_Table* table = &tables[i];
1033
1034
1035     /* buffer length is a multiple of 4 */
1036     memcpy(font->out_buf + table->offset,
1037            table->buf, (table->len + 3) & ~3);
1038   }
1039
1040   error = TA_Err_Ok;
1041
1042 Err:
1043   free(header_buf);
1044
1045   return error;
1046 }
1047
1048
1049 static FT_Error
1050 TA_font_build_TTC_header(FONT* font,
1051                          FT_Byte** header_buf,
1052                          FT_ULong* header_len)
1053 {
1054   SFNT* sfnts = font->sfnts;
1055   FT_Long num_sfnts = font->num_sfnts;
1056
1057   SFNT_Table* tables = font->tables;
1058   FT_ULong num_tables = font->num_tables;
1059
1060   FT_ULong TTF_offset;
1061   FT_ULong DSIG_offset;
1062
1063   FT_Byte* buf;
1064   FT_ULong len;
1065
1066   FT_Long i;
1067   FT_Byte* p;
1068
1069
1070   len = 24 + 4 * num_sfnts;
1071   buf = (FT_Byte*)malloc(len);
1072   if (!buf)
1073     return FT_Err_Out_Of_Memory;
1074
1075   p = buf;
1076
1077   /* TTC ID string */
1078   *(p++) = 't';
1079   *(p++) = 't';
1080   *(p++) = 'c';
1081   *(p++) = 'f';
1082
1083   /* TTC header version */
1084   *(p++) = 0x00;
1085   *(p++) = 0x02;
1086   *(p++) = 0x00;
1087   *(p++) = 0x00;
1088
1089   /* number of subfonts */
1090   *(p++) = BYTE1(num_sfnts);
1091   *(p++) = BYTE2(num_sfnts);
1092   *(p++) = BYTE3(num_sfnts);
1093   *(p++) = BYTE4(num_sfnts);
1094
1095   /* the first TTF subfont header immediately follows the TTC header */
1096   TTF_offset = len;
1097
1098   /* loop over all subfonts */
1099   for (i = 0; i < num_sfnts; i++)
1100   {
1101     SFNT* sfnt = &sfnts[i];
1102     FT_ULong l;
1103
1104
1105     TA_sfnt_sort_table_info(sfnt, font);
1106     /* only get header length */
1107     (void)TA_sfnt_build_TTF_header(sfnt, font, NULL, &l, 0);
1108
1109     *(p++) = BYTE1(TTF_offset);
1110     *(p++) = BYTE2(TTF_offset);
1111     *(p++) = BYTE3(TTF_offset);
1112     *(p++) = BYTE4(TTF_offset);
1113
1114     TTF_offset += l;
1115   }
1116
1117   /* the first SFNT table immediately follows the subfont TTF headers */
1118   TA_font_compute_table_offsets(font, TTF_offset);
1119
1120   /* DSIG tag */
1121   *(p++) = 'D';
1122   *(p++) = 'S';
1123   *(p++) = 'I';
1124   *(p++) = 'G';
1125
1126   /* DSIG length */
1127   *(p++) = 0x00;
1128   *(p++) = 0x00;
1129   *(p++) = 0x00;
1130   *(p++) = 0x08;
1131
1132   /* DSIG offset; in a TTC this is always the last SFNT table */
1133   DSIG_offset = tables[num_tables - 1].offset;
1134
1135   *(p++) = BYTE1(DSIG_offset);
1136   *(p++) = BYTE2(DSIG_offset);
1137   *(p++) = BYTE3(DSIG_offset);
1138   *(p++) = BYTE4(DSIG_offset);
1139
1140   *header_buf = buf;
1141   *header_len = len;
1142
1143   return TA_Err_Ok;
1144 }
1145
1146
1147 static FT_Error
1148 TA_font_build_TTC(FONT* font)
1149 {
1150   SFNT* sfnts = font->sfnts;
1151   FT_Long num_sfnts = font->num_sfnts;
1152
1153   SFNT_Table* tables;
1154   FT_ULong num_tables;
1155
1156   FT_Byte* DSIG_buf;
1157   SFNT_Table_Info dummy;
1158
1159   FT_Byte* TTC_header_buf;
1160   FT_ULong TTC_header_len;
1161
1162   FT_Byte** TTF_header_bufs;
1163   FT_ULong* TTF_header_lens;
1164
1165   FT_ULong offset;
1166   FT_Long i;
1167   FT_ULong j;
1168   FT_Error error;
1169
1170
1171   /* add a dummy `DSIG' table */
1172
1173   error = TA_table_build_DSIG(&DSIG_buf);
1174   if (error)
1175     return error;
1176
1177   /* in case of success, `DSIG_buf' gets linked */
1178   /* and is eventually freed in `TA_font_unload' */
1179   error = TA_font_add_table(font, &dummy, TTAG_DSIG, DSIG_LEN, DSIG_buf);
1180   if (error)
1181   {
1182     free(DSIG_buf);
1183     return error;
1184   }
1185
1186   /* this also computes the SFNT table offsets */
1187   error = TA_font_build_TTC_header(font,
1188                                    &TTC_header_buf, &TTC_header_len);
1189   if (error)
1190     return error;
1191
1192   TTF_header_bufs = (FT_Byte**)calloc(1, num_sfnts * sizeof (FT_Byte*));
1193   if (!TTF_header_bufs)
1194     goto Err;
1195
1196   TTF_header_lens = (FT_ULong*)malloc(num_sfnts * sizeof (FT_ULong));
1197   if (!TTF_header_lens)
1198     goto Err;
1199
1200   for (i = 0; i < num_sfnts; i++)
1201   {
1202     error = TA_sfnt_build_TTF_header(&sfnts[i], font,
1203                                      &TTF_header_bufs[i],
1204                                      &TTF_header_lens[i], 1);
1205     if (error)
1206       goto Err;
1207   }
1208
1209   /* build font */
1210
1211   tables = font->tables;
1212   num_tables = font->num_tables;
1213
1214   /* get font length from last SFNT table array element */
1215   font->out_len = tables[num_tables - 1].offset
1216                   + ((tables[num_tables - 1].len + 3) & ~3);
1217   font->out_buf = (FT_Byte*)malloc(font->out_len);
1218   if (!font->out_buf)
1219   {
1220     error = FT_Err_Out_Of_Memory;
1221     goto Err;
1222   }
1223
1224   memcpy(font->out_buf, TTC_header_buf, TTC_header_len);
1225
1226   offset = TTC_header_len;
1227
1228   for (i = 0; i < num_sfnts; i++)
1229   {
1230     memcpy(font->out_buf + offset,
1231            TTF_header_bufs[i], TTF_header_lens[i]);
1232
1233     offset += TTF_header_lens[i];
1234   }
1235
1236   for (j = 0; j < num_tables; j++)
1237   {
1238     SFNT_Table* table = &tables[j];
1239
1240
1241     /* buffer length is a multiple of 4 */
1242     memcpy(font->out_buf + table->offset,
1243            table->buf, (table->len + 3) & ~3);
1244   }
1245
1246   error = TA_Err_Ok;
1247
1248 Err:
1249   free(TTC_header_buf);
1250   if (TTF_header_bufs)
1251   {
1252     for (i = 0; i < font->num_sfnts; i++)
1253       free(TTF_header_bufs[i]);
1254     free(TTF_header_bufs);
1255   }
1256   free(TTF_header_lens);
1257
1258   return error;
1259 }
1260
1261
1262 static FT_Error
1263 TA_font_write(FONT* font,
1264               FILE* out)
1265 {
1266   if (fwrite(font->out_buf, 1, font->out_len, out) != font->out_len)
1267     return TA_Err_Invalid_Stream_Write;
1268
1269   return TA_Err_Ok;
1270 }
1271
1272
1273 static void
1274 TA_font_unload(FONT* font)
1275 {
1276   /* in case of error it is expected that unallocated pointers */
1277   /* are NULL (and counters are zero) */
1278
1279   if (!font)
1280     return;
1281
1282   if (font->loader)
1283     ta_loader_done(font->loader);
1284
1285   if (font->tables)
1286   {
1287     FT_ULong i;
1288
1289
1290     for (i = 0; i < font->num_tables; i++)
1291     {
1292       free(font->tables[i].buf);
1293       if (font->tables[i].data)
1294       {
1295         if (font->tables[i].tag == TTAG_glyf)
1296         {
1297           glyf_Data* data = (glyf_Data*)font->tables[i].data;
1298           FT_UShort j;
1299
1300
1301           for (j = 0; j < data->num_glyphs; j++)
1302             free(data->glyphs[j].buf);
1303           free(data->glyphs);
1304           free(data);
1305         }
1306       }
1307     }
1308     free(font->tables);
1309   }
1310
1311   if (font->sfnts)
1312   {
1313     FT_Long i;
1314
1315
1316     for (i = 0; i < font->num_sfnts; i++)
1317     {
1318       FT_Done_Face(font->sfnts[i].face);
1319       free(font->sfnts[i].table_infos);
1320     }
1321     free(font->sfnts);
1322   }
1323
1324   FT_Done_FreeType(font->lib);
1325   free(font->in_buf);
1326   free(font->out_buf);
1327   free(font);
1328 }
1329
1330
1331 TA_Error
1332 TTF_autohint(FILE* in,
1333              FILE* out)
1334 {
1335   FONT* font;
1336   FT_Error error;
1337   FT_Long i;
1338
1339
1340   font = (FONT*)calloc(1, sizeof (FONT));
1341   if (!font)
1342     return FT_Err_Out_Of_Memory;
1343
1344   error = TA_font_read(font, in);
1345   if (error)
1346     goto Err;
1347
1348   error = TA_font_init(font);
1349   if (error)
1350     goto Err;
1351
1352   /* loop over subfonts */
1353   for (i = 0; i < font->num_sfnts; i++)
1354   {
1355     SFNT* sfnt = &font->sfnts[i];
1356
1357
1358     error = FT_New_Memory_Face(font->lib, font->in_buf, font->in_len,
1359                                i, &sfnt->face);
1360     if (error)
1361       goto Err;
1362
1363     error = TA_sfnt_split_into_SFNT_tables(sfnt, font);
1364     if (error)
1365       goto Err;
1366
1367     error = TA_sfnt_split_glyf_table(sfnt, font);
1368     if (error)
1369       goto Err;
1370   }
1371
1372   /* XXX handle subfonts for bytecode tables? */
1373
1374   /* build `cvt ' table */
1375   error = TA_sfnt_build_cvt_table(&font->sfnts[0], font);
1376   if (error)
1377     goto Err;
1378
1379   /* build `fpgm' table */
1380   error = TA_sfnt_build_fpgm_table(&font->sfnts[0], font);
1381   if (error)
1382     goto Err;
1383
1384   /* build `prep' table */
1385
1386   /* handle all glyphs in a loop */
1387     /* hint the glyph */
1388     /* build bytecode */
1389
1390   /* adjust `maxp' table */
1391
1392   /* loop again over subfonts */
1393   for (i = 0; i < font->num_sfnts; i++)
1394   {
1395     SFNT* sfnt = &font->sfnts[i];
1396
1397
1398     error = TA_sfnt_build_glyf_table(sfnt, font);
1399     if (error)
1400       goto Err;
1401     error = TA_sfnt_build_loca_table(sfnt, font);
1402     if (error)
1403       goto Err;
1404     error = TA_sfnt_update_maxp_table(sfnt, font);
1405     if (error)
1406       goto Err;
1407   }
1408
1409   if (font->num_sfnts == 1)
1410     error = TA_font_build_TTF(font);
1411   else
1412     error = TA_font_build_TTC(font);
1413   if (error)
1414     goto Err;
1415
1416   error = TA_font_write(font, out);
1417   if (error)
1418     goto Err;
1419
1420   error = TA_Err_Ok;
1421
1422 Err:
1423   TA_font_unload(font);
1424
1425   return error;
1426 }
1427
1428 /* end of ttfautohint.c */