lib/taglyf.c

   1 /* taglyf.c */
   2
   3 /*
   4  * Copyright (C) 2011-2015 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 static FT_Error
  20 TA_sfnt_build_glyf_hints(SFNT* sfnt,
  21                          FONT* font)
  22 {
  23   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
  24   glyf_Data* data = (glyf_Data*)glyf_table->data;
  25
  26   FT_Long idx;
  27   FT_Error error;
  28
  29   FT_UShort loop_count;
  30
  31
  32   /* this loop doesn't include the artificial `.ttfautohint' glyph */
  33   loop_count = data->num_glyphs;
  34   if (sfnt->max_components && font->hint_composites)
  35     loop_count--;
  36
  37   for (idx = 0; idx < loop_count; idx++)
  38   {
  39     error = TA_sfnt_build_glyph_instructions(sfnt, font, idx);
  40     if (error)
  41       return error;
  42     if (font->progress)
  43     {
  44       FT_Int ret;
  45
  46
  47       ret = font->progress(idx, loop_count,
  48                            sfnt - font->sfnts, font->num_sfnts,
  49                            font->progress_data);
  50       if (ret)
  51         return TA_Err_Canceled;
  52     }
  53   }
  54
  55   return FT_Err_Ok;
  56 }
  57
  58
  59 static FT_Error
  60 TA_glyph_get_components(GLYPH* glyph,
  61                         FT_Byte* buf,
  62                         FT_ULong len)
  63 {
  64   FT_UShort flags;
  65   FT_UShort component;
  66   FT_UShort* components_new;
  67
  68   FT_Byte* p;
  69   FT_Byte* endp;
  70
  71
  72   p = buf;
  73   endp = buf + len;
  74
  75   /* skip header */
  76   p += 10;
  77
  78   /* walk over component records */
  79   do
  80   {
  81     if (p + 4 > endp)
  82       return FT_Err_Invalid_Table;
  83
  84     flags = NEXT_USHORT(p);
  85
  86     /* add component to list */
  87     component = NEXT_USHORT(p);
  88
  89     glyph->num_components++;
  90     components_new = (FT_UShort*)realloc(glyph->components,
  91                                          glyph->num_components
  92                                          * sizeof (FT_UShort));
  93     if (!components_new)
  94     {
  95       glyph->num_components--;
  96       return FT_Err_Out_Of_Memory;
  97     }
  98     else
  99       glyph->components = components_new;
 100
 101     glyph->components[glyph->num_components - 1] = component;
 102
 103     /* skip scaling and offset arguments */
 104     if (flags & ARGS_ARE_WORDS)
 105       p += 4;
 106     else
 107       p += 2;
 108
 109     if (flags & WE_HAVE_A_SCALE)
 110       p += 2;
 111     else if (flags & WE_HAVE_AN_XY_SCALE)
 112       p += 4;
 113     else if (flags & WE_HAVE_A_2X2)
 114       p += 8;
 115   } while (flags & MORE_COMPONENTS);
 116
 117   return TA_Err_Ok;
 118 }
 119
 120
 121 static FT_Error
 122 TA_glyph_parse_composite(GLYPH* glyph,
 123                          FT_Byte* buf,
 124                          FT_ULong len,
 125                          FT_UShort num_glyphs,
 126                          FT_Bool hint_composites)
 127 {
 128   FT_ULong flags_offset; /* after the loop, this is the offset */
 129                          /* to the last element in the flags array */
 130   FT_UShort flags;
 131
 132   FT_Byte* p;
 133   FT_Byte* q;
 134
 135
 136   /* we allocate too large a buffer */
 137   /* (including space for the new component */
 138   /* and possible argument size changes for shifted point indices) */
 139   /* and reallocate it later to its real size */
 140   glyph->buf = (FT_Byte*)malloc(len + 8 + glyph->num_components * 2);
 141   if (!glyph->buf)
 142     return FT_Err_Out_Of_Memory;
 143
 144   p = buf;
 145   q = glyph->buf;
 146
 147   /* copy header */
 148   memcpy(q, p, 10);
 149   p += 10;
 150   q += 10;
 151
 152   /* if the composite glyph contains one or more contours, */
 153   /* we prepend a composite glyph component to call some bytecode */
 154   /* which eventually becomes the last glyph in the `glyf' table; */
 155   /* for convenience, however, it is not added to the `components' array */
 156   /* (doing so simplifies the conversion of point indices later on) */
 157   if (glyph->num_composite_contours && hint_composites)
 158   {
 159     FT_Short x_min;
 160     FT_Short x_max;
 161     FT_Short y_min;
 162     FT_Short y_max;
 163     FT_Short x_offset;
 164     FT_Short y_offset;
 165
 166
 167     /* the composite glyph's bounding box */
 168     x_min = (FT_Short)((buf[2] << 8) + buf[3]);
 169     y_min = (FT_Short)((buf[4] << 8) + buf[5]);
 170     x_max = (FT_Short)((buf[6] << 8) + buf[7]);
 171     y_max = (FT_Short)((buf[8] << 8) + buf[9]);
 172
 173     /* use ARGS_ARE_WORDS only if necessary; */
 174     /* note that the offset value of the component doesn't matter */
 175     /* as long as it stays within the bounding box */
 176     if (x_min <= 0 && x_max >= 0)
 177       x_offset = 0;
 178     else if (x_max < 0)
 179       x_offset = x_max;
 180     else
 181       x_offset = x_min;
 182
 183     if (y_min <= 0 && y_max >= 0)
 184       y_offset = 0;
 185     else if (y_max < 0)
 186       y_offset = y_max;
 187     else
 188       y_offset = y_min;
 189
 190     if (x_offset >= -128 && x_offset <= 127
 191         && y_offset >= -128 && y_offset <= 127)
 192     {
 193       *(q++) = 0x00;
 194       *(q++) = ARGS_ARE_XY_VALUES | MORE_COMPONENTS;
 195       *(q++) = HIGH(num_glyphs - 1);
 196       *(q++) = LOW(num_glyphs - 1);
 197       *(q++) = (FT_Byte)x_offset;
 198       *(q++) = (FT_Byte)y_offset;
 199     }
 200     else
 201     {
 202       *(q++) = 0x00;
 203       *(q++) = ARGS_ARE_WORDS | ARGS_ARE_XY_VALUES | MORE_COMPONENTS;
 204       *(q++) = HIGH(num_glyphs - 1);
 205       *(q++) = LOW(num_glyphs - 1);
 206       *(q++) = HIGH(x_offset);
 207       *(q++) = LOW(x_offset);
 208       *(q++) = HIGH(y_offset);
 209       *(q++) = LOW(y_offset);
 210     }
 211   }
 212
 213   /* walk over component records */
 214   do
 215   {
 216     flags_offset = q - glyph->buf;
 217
 218     *(q++) = *p;
 219     *(q++) = *(p + 1);
 220     flags = NEXT_USHORT(p);
 221
 222     /* copy component */
 223     *(q++) = *(p++);
 224     *(q++) = *(p++);
 225
 226     if (flags & ARGS_ARE_XY_VALUES)
 227     {
 228       /* copy offsets */
 229       *(q++) = *(p++);
 230       *(q++) = *(p++);
 231
 232       if (flags & ARGS_ARE_WORDS)
 233       {
 234         *(q++) = *(p++);
 235         *(q++) = *(p++);
 236       }
 237     }
 238     else
 239     {
 240       /* handle point numbers */
 241       FT_UShort arg1;
 242       FT_UShort arg2;
 243       FT_UShort i;
 244
 245
 246       if (flags & ARGS_ARE_WORDS)
 247       {
 248         arg1 = *(p++) >> 8;
 249         arg1 += *(p++);
 250         arg2 = *(p++) >> 8;
 251         arg2 += *(p++);
 252       }
 253       else
 254       {
 255         arg1 = *(p++);
 256         arg2 = *(p++);
 257       }
 258
 259       /* adjust point numbers */
 260       /* (see `TA_adjust_point_index' in `tabytecode.c' for more) */
 261       for (i = 0; i < glyph->num_pointsums; i++)
 262         if (arg1 < glyph->pointsums[i])
 263           break;
 264       arg1 += i;
 265
 266       for (i = 0; i < glyph->num_pointsums; i++)
 267         if (arg2 < glyph->pointsums[i])
 268           break;
 269       arg2 += i;
 270
 271       if (arg1 <= 0xFF && arg2 <= 0xFF)
 272       {
 273         glyph->buf[flags_offset + 1] &= ~ARGS_ARE_WORDS;
 274
 275         *(q++) = (FT_Byte)arg1;
 276         *(q++) = (FT_Byte)arg2;
 277       }
 278       else
 279       {
 280         glyph->buf[flags_offset + 1] |= ARGS_ARE_WORDS;
 281
 282         *(q++) = HIGH(arg1);
 283         *(q++) = LOW(arg1);
 284         *(q++) = HIGH(arg2);
 285         *(q++) = LOW(arg2);
 286       }
 287     }
 288
 289     /* copy scaling arguments */
 290     if (flags & (WE_HAVE_A_SCALE | WE_HAVE_AN_XY_SCALE | WE_HAVE_A_2X2))
 291     {
 292       *(q++) = *(p++);
 293       *(q++) = *(p++);
 294     }
 295     if (flags & (WE_HAVE_AN_XY_SCALE | WE_HAVE_A_2X2))
 296     {
 297       *(q++) = *(p++);
 298       *(q++) = *(p++);
 299     }
 300     if (flags & WE_HAVE_A_2X2)
 301     {
 302       *(q++) = *(p++);
 303       *(q++) = *(p++);
 304       *(q++) = *(p++);
 305       *(q++) = *(p++);
 306     }
 307   } while (flags & MORE_COMPONENTS);
 308
 309   glyph->len1 = q - glyph->buf;
 310   /* glyph->len2 = 0; */
 311   glyph->flags_offset = flags_offset;
 312   glyph->buf = (FT_Byte*)realloc(glyph->buf, glyph->len1);
 313
 314   /* we discard instructions (if any) */
 315   glyph->buf[glyph->flags_offset] &= ~(WE_HAVE_INSTR >> 8);
 316
 317   return TA_Err_Ok;
 318 }
 319
 320
 321 static FT_Error
 322 TA_glyph_parse_simple(GLYPH* glyph,
 323                       FT_Byte* buf,
 324                       FT_ULong len)
 325 {
 326   FT_ULong ins_offset;
 327   FT_Byte* flags_start;
 328
 329   FT_UShort num_ins;
 330
 331   FT_ULong flags_size; /* size of the flags array */
 332   FT_ULong xy_size; /* size of x and y coordinate arrays together */
 333
 334   FT_Byte* p;
 335   FT_Byte* endp;
 336
 337   FT_UShort i;
 338
 339
 340   p = buf;
 341   endp = buf + len;
 342
 343   ins_offset = 10 + glyph->num_contours * 2;
 344
 345   p += ins_offset;
 346
 347   if (p + 2 > endp)
 348     return FT_Err_Invalid_Table;
 349
 350   /* get number of instructions */
 351   num_ins = NEXT_USHORT(p);
 352
 353   /* assure that we don't process a font */
 354   /* which already contains a `.ttfautohint' glyph */
 355   /* (a font with a `post' table version 3.0 doesn't contain glyph names, */
 356   /* so we have to check it this way) */
 357   if (glyph->num_points == 1
 358       && num_ins >= sizeof (ttfautohint_glyph_bytecode))
 359   {
 360     if (!strncmp((char*)p, (char*)ttfautohint_glyph_bytecode,
 361                  sizeof (ttfautohint_glyph_bytecode)))
 362       return TA_Err_Already_Processed;
 363   }
 364
 365   p += num_ins;
 366
 367   if (p > endp)
 368     return FT_Err_Invalid_Table;
 369
 370   flags_start = p;
 371   xy_size = 0;
 372   i = 0;
 373
 374   while (i < glyph->num_points)
 375   {
 376     FT_Byte flags;
 377     FT_Byte x_short;
 378     FT_Byte y_short;
 379     FT_Byte have_x;
 380     FT_Byte have_y;
 381     FT_UInt count;
 382
 383
 384     if (p + 1 > endp)
 385       return FT_Err_Invalid_Table;
 386
 387     flags = *(p++);
 388
 389     x_short = (flags & X_SHORT_VECTOR) ? 1 : 2;
 390     y_short = (flags & Y_SHORT_VECTOR) ? 1 : 2;
 391
 392     have_x = ((flags & SAME_X) && !(flags & X_SHORT_VECTOR)) ? 0 : 1;
 393     have_y = ((flags & SAME_Y) && !(flags & Y_SHORT_VECTOR)) ? 0 : 1;
 394
 395     count = 1;
 396
 397     if (flags & REPEAT)
 398     {
 399       if (p + 1 > endp)
 400         return FT_Err_Invalid_Table;
 401
 402       count += *(p++);
 403
 404       if (i + count > glyph->num_points)
 405         return FT_Err_Invalid_Table;
 406     }
 407
 408     xy_size += count * x_short * have_x;
 409     xy_size += count * y_short * have_y;
 410
 411     i += count;
 412   }
 413
 414   if (p + xy_size > endp)
 415     return FT_Err_Invalid_Table;
 416
 417   flags_size = p - flags_start;
 418
 419   /* store the data before and after the bytecode instructions */
 420   /* in the same array */
 421   glyph->len1 = ins_offset;
 422   glyph->len2 = flags_size + xy_size;
 423   glyph->buf = (FT_Byte*)malloc(glyph->len1 + glyph->len2);
 424   if (!glyph->buf)
 425     return FT_Err_Out_Of_Memory;
 426
 427   /* now copy everything but the instructions */
 428   memcpy(glyph->buf, buf, glyph->len1);
 429   memcpy(glyph->buf + glyph->len1, flags_start, glyph->len2);
 430
 431   return TA_Err_Ok;
 432 }
 433
 434
 435 static FT_Error
 436 TA_iterate_composite_glyph(glyf_Data* data,
 437                            FT_UShort* components,
 438                            FT_UShort num_components,
 439                            FT_UShort** pointsums,
 440                            FT_UShort* num_pointsums,
 441                            FT_UShort* num_composite_contours,
 442                            FT_UShort* num_composite_points)
 443 {
 444   FT_UShort* pointsums_new;
 445   FT_UShort i;
 446
 447
 448   /* save current state */
 449
 450   if (*num_pointsums == 0xFFFF)
 451     return FT_Err_Invalid_Table;
 452
 453   (*num_pointsums)++;
 454   pointsums_new = (FT_UShort*)realloc(*pointsums,
 455                                       *num_pointsums
 456                                       * sizeof (FT_UShort));
 457   if (!pointsums_new)
 458   {
 459     (*num_pointsums)--;
 460     return FT_Err_Out_Of_Memory;
 461   }
 462   else
 463     *pointsums = pointsums_new;
 464
 465   (*pointsums)[*num_pointsums - 1] = *num_composite_points;
 466
 467   for (i = 0; i < num_components; i++)
 468   {
 469     GLYPH* glyph;
 470     FT_UShort component = components[i];
 471     FT_Error error;
 472
 473
 474     if (component >= data->num_glyphs)
 475       return FT_Err_Invalid_Table;
 476
 477     glyph = &data->glyphs[component];
 478
 479     if (glyph->num_components)
 480     {
 481       error = TA_iterate_composite_glyph(data,
 482                                          glyph->components,
 483                                          glyph->num_components,
 484                                          pointsums,
 485                                          num_pointsums,
 486                                          num_composite_contours,
 487                                          num_composite_points);
 488       if (error)
 489         return error;
 490     }
 491     else
 492     {
 493       /* no need for checking overflow of the number of contours */
 494       /* since the number of points is always larger or equal */
 495       if (*num_composite_points > 0xFFFF - glyph->num_points)
 496         return FT_Err_Invalid_Table;
 497
 498       *num_composite_contours += glyph->num_contours;
 499       *num_composite_points += glyph->num_points;
 500     }
 501   }
 502
 503   return TA_Err_Ok;
 504 }
 505
 506
 507 static FT_Error
 508 TA_sfnt_compute_composite_pointsums(SFNT* sfnt,
 509                                     FONT* font)
 510 {
 511   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
 512   glyf_Data* data = (glyf_Data*)glyf_table->data;
 513
 514   FT_UShort i;
 515
 516
 517   for (i = 0; i < data->num_glyphs; i++)
 518   {
 519     GLYPH* glyph = &data->glyphs[i];
 520
 521
 522     if (glyph->num_components)
 523     {
 524       FT_Error error;
 525       FT_UShort num_composite_contours = 0;
 526       FT_UShort num_composite_points = 0;
 527
 528
 529       error = TA_iterate_composite_glyph(data,
 530                                          glyph->components,
 531                                          glyph->num_components,
 532                                          &glyph->pointsums,
 533                                          &glyph->num_pointsums,
 534                                          &num_composite_contours,
 535                                          &num_composite_points);
 536       if (error)
 537         return error;
 538
 539       glyph->num_composite_contours = num_composite_contours;
 540
 541       if (font->hint_composites)
 542       {
 543         /* update maximum values, */
 544         /* including the subglyphs not in `components' array */
 545         /* (each of them has a single point in a single contour) */
 546         if (num_composite_points + glyph->num_pointsums
 547             > sfnt->max_composite_points)
 548           sfnt->max_composite_points = num_composite_points
 549                                        + glyph->num_pointsums;
 550         if (num_composite_contours + glyph->num_pointsums
 551             > sfnt->max_composite_contours)
 552           sfnt->max_composite_contours = num_composite_contours
 553                                          + glyph->num_pointsums;
 554       }
 555     }
 556   }
 557
 558   return TA_Err_Ok;
 559 }
 560
 561
 562 FT_Error
 563 TA_sfnt_split_glyf_table(SFNT* sfnt,
 564                          FONT* font)
 565 {
 566   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
 567   SFNT_Table* loca_table = &font->tables[sfnt->loca_idx];
 568   SFNT_Table* head_table = &font->tables[sfnt->head_idx];
 569
 570   glyf_Data* data;
 571   FT_Byte loca_format;
 572
 573   FT_ULong offset;
 574   FT_ULong offset_next;
 575
 576   FT_Byte* p;
 577   FT_UShort i;
 578   FT_UShort loop_count;
 579
 580   FT_Error error;
 581
 582
 583   /* in case of success, all allocated arrays are */
 584   /* linked and eventually freed in `TA_font_unload' */
 585
 586   /* nothing to do if table has already been split */
 587   if (glyf_table->data)
 588     return TA_Err_Ok;
 589
 590   data = (glyf_Data*)calloc(1, sizeof (glyf_Data));
 591   if (!data)
 592     return FT_Err_Out_Of_Memory;
 593
 594   glyf_table->data = data;
 595
 596   loca_format = head_table->buf[LOCA_FORMAT_OFFSET];
 597
 598   data->num_glyphs = (FT_UShort)(loca_format ? loca_table->len / 4
 599                                              : loca_table->len / 2);
 600   loop_count = data->num_glyphs - 1;
 601
 602   /* allocate one more glyph slot if we have composite glyphs */
 603   if (!sfnt->max_components || !font->hint_composites)
 604     data->num_glyphs -= 1;
 605   data->glyphs = (GLYPH*)calloc(1, data->num_glyphs * sizeof (GLYPH));
 606   if (!data->glyphs)
 607     return FT_Err_Out_Of_Memory;
 608
 609   data->master_globals = NULL;
 610   data->cvt_idx = MISSING;
 611   data->fpgm_idx = MISSING;
 612   data->prep_idx = MISSING;
 613
 614   /* first loop over `loca' and `glyf' data */
 615
 616   p = loca_table->buf;
 617
 618   if (loca_format)
 619     offset_next = NEXT_ULONG(p);
 620   else
 621   {
 622     offset_next = NEXT_USHORT(p);
 623     offset_next <<= 1;
 624   }
 625
 626   for (i = 0; i < loop_count; i++)
 627   {
 628     GLYPH* glyph = &data->glyphs[i];
 629     FT_ULong len;
 630
 631
 632     offset = offset_next;
 633
 634     if (loca_format)
 635       offset_next = NEXT_ULONG(p);
 636     else
 637     {
 638       offset_next = NEXT_USHORT(p);
 639       offset_next <<= 1;
 640     }
 641
 642     if (offset_next < offset
 643         || offset_next > glyf_table->len)
 644       return FT_Err_Invalid_Table;
 645
 646     len = offset_next - offset;
 647     if (!len)
 648       continue; /* empty glyph */
 649     else
 650     {
 651       FT_Byte* buf;
 652
 653
 654       /* check header size */
 655       if (len < 10)
 656         return FT_Err_Invalid_Table;
 657
 658       /* we need the number of contours and points for */
 659       /* `TA_sfnt_compute_composite_pointsums' */
 660       buf = glyf_table->buf + offset;
 661       glyph->num_contours = (FT_Short)((buf[0] << 8) + buf[1]);
 662
 663       if (glyph->num_contours < 0)
 664       {
 665         error = TA_glyph_get_components(glyph, buf, len);
 666         if (error)
 667           return error;
 668       }
 669       else
 670       {
 671         FT_ULong off;
 672
 673
 674         /* use the last contour's end point to compute number of points */
 675         off = 10 + (glyph->num_contours - 1) * 2;
 676         if (off >= len - 1)
 677           return FT_Err_Invalid_Table;
 678
 679         glyph->num_points = (FT_UShort)((buf[off] << 8) + buf[off + 1] + 1);
 680       }
 681     }
 682   }
 683
 684   if (sfnt->max_components && font->hint_composites)
 685   {
 686     error = TA_sfnt_compute_composite_pointsums(sfnt, font);
 687     if (error)
 688       return error;
 689   }
 690
 691   /* second loop over `loca' and `glyf' data */
 692
 693   p = loca_table->buf;
 694
 695   if (loca_format)
 696     offset_next = NEXT_ULONG(p);
 697   else
 698   {
 699     offset_next = NEXT_USHORT(p);
 700     offset_next <<= 1;
 701   }
 702
 703   for (i = 0; i < loop_count; i++)
 704   {
 705     GLYPH* glyph = &data->glyphs[i];
 706     FT_ULong len;
 707
 708
 709     offset = offset_next;
 710
 711     if (loca_format)
 712       offset_next = NEXT_ULONG(p);
 713     else
 714     {
 715       offset_next = NEXT_USHORT(p);
 716       offset_next <<= 1;
 717     }
 718
 719     len = offset_next - offset;
 720     if (!len)
 721       continue; /* empty glyph */
 722     else
 723     {
 724       FT_Byte* buf;
 725
 726
 727       buf = glyf_table->buf + offset;
 728
 729       /* We must parse the rest of the glyph record to get the exact */
 730       /* record length.  Since the `loca' table rounds record lengths */
 731       /* up to multiples of 4 (or 2 for older fonts), and we must round */
 732       /* up again after stripping off the instructions, it would be */
 733       /* possible otherwise to have more than 4 bytes of padding which */
 734       /* is more or less invalid. */
 735
 736       if (glyph->num_contours < 0)
 737         error = TA_glyph_parse_composite(glyph, buf, len,
 738                                          data->num_glyphs,
 739                                          font->hint_composites);
 740       else
 741         error = TA_glyph_parse_simple(glyph, buf, len);
 742       if (error)
 743         return error;
 744     }
 745   }
 746
 747   if (sfnt->max_components && font->hint_composites)
 748   {
 749     /* construct and append our special glyph used as a composite element */
 750     GLYPH* glyph = &data->glyphs[data->num_glyphs - 1];
 751     FT_Byte* buf;
 752
 753     glyph->len1 = 12;
 754     glyph->len2 = 1;
 755     glyph->buf = (FT_Byte*)malloc(glyph->len1 + glyph->len2);
 756     if (!glyph->buf)
 757       return FT_Err_Out_Of_Memory;
 758
 759     buf = glyph->buf;
 760
 761     buf[0] = 0x00; /* one contour */
 762     buf[1] = 0x01;
 763     buf[2] = 0x00; /* no dimensions */
 764     buf[3] = 0x00;
 765     buf[4] = 0x00;
 766     buf[5] = 0x00;
 767     buf[6] = 0x00;
 768     buf[7] = 0x00;
 769     buf[8] = 0x00;
 770     buf[9] = 0x00;
 771     buf[10] = 0x00; /* one contour end point */
 772     buf[11] = 0x00;
 773
 774     buf[12] = ON_CURVE | SAME_X | SAME_Y; /* the flags for a point at 0,0 */
 775
 776     /* add bytecode also; */
 777     /* this works because the loop in `TA_sfnt_build_glyf_hints' */
 778     /* doesn't include the newly appended glyph */
 779     glyph->ins_len = sizeof (ttfautohint_glyph_bytecode);
 780     glyph->ins_buf = (FT_Byte*)malloc(glyph->ins_len);
 781     if (!glyph->ins_buf)
 782       return FT_Err_Out_Of_Memory;
 783     memcpy(glyph->ins_buf, ttfautohint_glyph_bytecode, glyph->ins_len);
 784
 785     sfnt->max_components += 1;
 786   }
 787
 788   return TA_Err_Ok;
 789 }
 790
 791
 792 FT_Error
 793 TA_sfnt_build_glyf_table(SFNT* sfnt,
 794                          FONT* font)
 795 {
 796   FT_Error error;
 797
 798   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
 799   glyf_Data* data = (glyf_Data*)glyf_table->data;
 800
 801   GLYPH* glyph;
 802
 803   FT_ULong len;
 804   FT_Byte* buf_new;
 805   FT_Byte* p;
 806   FT_UShort i;
 807
 808
 809   if (glyf_table->processed)
 810     return TA_Err_Ok;
 811
 812   if (!font->dehint)
 813   {
 814     error = TA_sfnt_build_glyf_hints(sfnt, font);
 815     if (error)
 816       return error;
 817   }
 818
 819   /* get table size */
 820   len = 0;
 821   glyph = data->glyphs;
 822   for (i = 0; i < data->num_glyphs; i++, glyph++)
 823   {
 824     /* glyph records should have offsets which are multiples of 4 */
 825     len = (len + 3) & ~3U;
 826     len += glyph->len1 + glyph->len2
 827            + glyph->ins_extra_len + glyph->ins_len;
 828     /* add two bytes for the instructionLength field */
 829     if (glyph->len2 || glyph->ins_len)
 830       len += 2;
 831   }
 832
 833   /* to make the short format of the `loca' table always work, */
 834   /* assure an even length of the `glyf' table */
 835   glyf_table->len = (len + 1) & ~1U;
 836
 837   buf_new = (FT_Byte*)realloc(glyf_table->buf, (len + 3) & ~3U);
 838   if (!buf_new)
 839     return FT_Err_Out_Of_Memory;
 840   else
 841     glyf_table->buf = buf_new;
 842
 843   p = glyf_table->buf;
 844   glyph = data->glyphs;
 845   for (i = 0; i < data->num_glyphs; i++, glyph++)
 846   {
 847     len = glyph->len1 + glyph->len2
 848           + glyph->ins_extra_len + glyph->ins_len;
 849     if (glyph->len2 || glyph->ins_len)
 850       len += 2;
 851
 852     if (len)
 853     {
 854       /* copy glyph data and insert new instructions */
 855       memcpy(p, glyph->buf, glyph->len1);
 856
 857       if (glyph->len2)
 858       {
 859         /* simple glyph */
 860         p += glyph->len1;
 861         *(p++) = HIGH(glyph->ins_extra_len + glyph->ins_len);
 862         *(p++) = LOW(glyph->ins_extra_len + glyph->ins_len);
 863         if (glyph->ins_extra_len)
 864         {
 865           memcpy(p, ins_extra_buf, glyph->ins_extra_len);
 866           p += glyph->ins_extra_len;
 867         }
 868         memcpy(p, glyph->ins_buf, glyph->ins_len);
 869         p += glyph->ins_len;
 870         memcpy(p, glyph->buf + glyph->len1, glyph->len2);
 871         p += glyph->len2;
 872       }
 873       else
 874       {
 875         /* composite glyph */
 876         if (glyph->ins_len)
 877         {
 878           *(p + glyph->flags_offset) |= (WE_HAVE_INSTR >> 8);
 879           p += glyph->len1;
 880           *(p++) = HIGH(glyph->ins_extra_len + glyph->ins_len);
 881           *(p++) = LOW(glyph->ins_extra_len + glyph->ins_len);
 882           if (glyph->ins_extra_len)
 883           {
 884             memcpy(p, ins_extra_buf, glyph->ins_extra_len);
 885             p += glyph->ins_extra_len;
 886           }
 887           memcpy(p, glyph->ins_buf, glyph->ins_len);
 888           p += glyph->ins_len;
 889         }
 890         else
 891           p += glyph->len1;
 892       }
 893
 894       /* pad with zero bytes to have an offset which is a multiple of 4; */
 895       /* this works even for the last glyph record since the `glyf' */
 896       /* table length is a multiple of 4 also */
 897       switch (len % 4)
 898       {
 899       case 1:
 900         *(p++) = 0;
 901       case 2:
 902         *(p++) = 0;
 903       case 3:
 904         *(p++) = 0;
 905       default:
 906         break;
 907       }
 908     }
 909   }
 910
 911   glyf_table->checksum = TA_table_compute_checksum(glyf_table->buf,
 912                                                    glyf_table->len);
 913   glyf_table->processed = 1;
 914
 915   return TA_Err_Ok;
 916 }
 917
 918
 919 static FT_Error
 920 TA_create_glyph_data(FT_Outline* outline,
 921                      GLYPH* glyph)
 922 {
 923   FT_Error error = TA_Err_Ok;
 924
 925   FT_Pos xmin, ymin;
 926   FT_Pos xmax, ymax;
 927
 928   FT_Byte header[10];
 929   FT_Byte* flags = NULL;
 930   FT_Byte* flagsp;
 931   FT_Byte oldf, f;
 932   FT_Byte* x = NULL;
 933   FT_Byte* xp;
 934   FT_Byte* y = NULL;
 935   FT_Byte* yp;
 936
 937   FT_Pos lastx, lasty;
 938
 939   FT_Short i;
 940   FT_Byte* p;
 941
 942
 943   if (!outline->n_contours)
 944     return TA_Err_Ok; /* empty glyph */
 945
 946   /* in case of success, all non-local allocated arrays are */
 947   /* linked and eventually freed in `TA_font_unload' */
 948
 949   glyph->buf = NULL;
 950
 951   /* we use `calloc' since we rely on the array */
 952   /* being initialized to zero; */
 953   /* additionally, we need one more byte for a test after the loop */
 954   flags = (FT_Byte*)calloc(1, outline->n_points + 1);
 955   if (!flags)
 956   {
 957     error = FT_Err_Out_Of_Memory;
 958     goto Exit;
 959   }
 960
 961   /* we have either one-byte or two-byte elements */
 962   x = (FT_Byte*)malloc(2 * outline->n_points);
 963   if (!x)
 964   {
 965     error = FT_Err_Out_Of_Memory;
 966     goto Exit;
 967   }
 968
 969   y = (FT_Byte*)malloc(2 * outline->n_points);
 970   if (!y)
 971   {
 972     error = FT_Err_Out_Of_Memory;
 973     goto Exit;
 974   }
 975
 976   flagsp = flags;
 977   xp = x;
 978   yp = y;
 979   xmin = xmax = (outline->points[0].x + 32) >> 6;
 980   ymin = ymax = (outline->points[0].y + 32) >> 6;
 981   lastx = 0;
 982   lasty = 0;
 983   oldf = 0x80; /* start with an impossible value */
 984
 985   /* convert the FreeType representation of the glyph's outline */
 986   /* into the representation format of the `glyf' table */
 987   for (i = 0; i < outline->n_points; i++)
 988   {
 989     FT_Pos xcur = (outline->points[i].x + 32) >> 6;
 990     FT_Pos ycur = (outline->points[i].y + 32) >> 6;
 991
 992     FT_Pos xdelta = xcur - lastx;
 993     FT_Pos ydelta = ycur - lasty;
 994
 995
 996     /* we are only interested in bit 0 of the `tags' array */
 997     f = outline->tags[i] & ON_CURVE;
 998
 999     /* x value */
1000
1001     if (xdelta == 0)
1002       f |= SAME_X;
1003     else
1004     {
1005       if (xdelta < 256 && xdelta > -256)
1006       {
1007         f |= X_SHORT_VECTOR;
1008
1009         if (xdelta < 0)
1010           xdelta = -xdelta;
1011         else
1012           f |= SAME_X;
1013
1014         *(xp++) = (FT_Byte)xdelta;
1015       }
1016       else
1017       {
1018         *(xp++) = HIGH(xdelta);
1019         *(xp++) = LOW(xdelta);
1020       }
1021     }
1022
1023     /* y value */
1024
1025     if (ydelta == 0)
1026       f |= SAME_Y;
1027     else
1028     {
1029       if (ydelta < 256 && ydelta > -256)
1030       {
1031         f |= Y_SHORT_VECTOR;
1032
1033         if (ydelta < 0)
1034           ydelta = -ydelta;
1035         else
1036           f |= SAME_Y;
1037
1038         *(yp++) = (FT_Byte)ydelta;
1039       }
1040       else
1041       {
1042         *(yp++) = HIGH(ydelta);
1043         *(yp++) = LOW(ydelta);
1044       }
1045     }
1046
1047     if (f == oldf)
1048     {
1049       /* set repeat flag */
1050       *(flagsp - 1) |= REPEAT;
1051
1052       if (*flagsp == 255)
1053       {
1054         /* we can only handle 256 repetitions at once, */
1055         /* so use a new counter */
1056         flagsp++;
1057         *(flagsp++) = f;
1058       }
1059       else
1060         *flagsp += 1; /* increase repetition counter */
1061     }
1062     else
1063     {
1064       if (*flagsp)
1065         flagsp++; /* skip repetition counter */
1066       *(flagsp++) = f;
1067       oldf = f;
1068     }
1069
1070     if (xcur > xmax)
1071       xmax = xcur;
1072     if (ycur > ymax)
1073       ymax = ycur;
1074     if (xcur < xmin)
1075       xmin = xcur;
1076     if (ycur < ymin)
1077       ymin = ycur;
1078
1079     lastx = xcur;
1080     lasty = ycur;
1081   }
1082
1083   /* if the last byte was a repetition counter, */
1084   /* we must increase by one to get the correct array size */
1085   if (*flagsp)
1086     flagsp++;
1087
1088   header[0] = HIGH(outline->n_contours);
1089   header[1] = LOW(outline->n_contours);
1090   header[2] = HIGH(xmin);
1091   header[3] = LOW(xmin);
1092   header[4] = HIGH(ymin);
1093   header[5] = LOW(ymin);
1094   header[6] = HIGH(xmax);
1095   header[7] = LOW(xmax);
1096   header[8] = HIGH(ymax);
1097   header[9] = LOW(ymax);
1098
1099   /* concatenate all arrays and fill needed GLYPH structure elements */
1100
1101   glyph->len1 = 10 + 2 * outline->n_contours;
1102   glyph->len2 = (flagsp - flags) + (xp - x) + (yp - y);
1103
1104   glyph->buf = (FT_Byte*)malloc(glyph->len1 + glyph->len2);
1105   if (!glyph->buf)
1106   {
1107     error = FT_Err_Out_Of_Memory;
1108     goto Exit;
1109   }
1110
1111   p = glyph->buf;
1112   memcpy(p, header, 10);
1113   p += 10;
1114
1115   glyph->ins_extra_len = 0;
1116   glyph->ins_len = 0;
1117   glyph->ins_buf = NULL;
1118
1119   for (i = 0; i < outline->n_contours; i++)
1120   {
1121     *(p++) = HIGH(outline->contours[i]);
1122     *(p++) = LOW(outline->contours[i]);
1123   }
1124
1125   memcpy(p, flags, flagsp - flags);
1126   p += flagsp - flags;
1127   memcpy(p, x, xp - x);
1128   p += xp - x;
1129   memcpy(p, y, yp - y);
1130
1131 Exit:
1132   free(flags);
1133   free(x);
1134   free(y);
1135
1136   return error;
1137 }
1138
1139
1140 /* We hint each glyph at EM size and construct a new `glyf' table. */
1141 /* Some fonts need this; in particular, */
1142 /* there are CJK fonts which use hints to scale and position subglyphs. */
1143 /* As a consequence, there are no longer composite glyphs. */
1144
1145 FT_Error
1146 TA_sfnt_create_glyf_data(SFNT* sfnt,
1147                          FONT* font)
1148 {
1149   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
1150   FT_Face face = sfnt->face;
1151   FT_Error error;
1152
1153   glyf_Data* data;
1154
1155   FT_UShort i;
1156
1157
1158   /* in case of success, all allocated arrays are */
1159   /* linked and eventually freed in `TA_font_unload' */
1160
1161   /* nothing to do if table has already been created */
1162   if (glyf_table->data)
1163     return TA_Err_Ok;
1164
1165   data = (glyf_Data*)calloc(1, sizeof (glyf_Data));
1166   if (!data)
1167     return FT_Err_Out_Of_Memory;
1168
1169   glyf_table->data = data;
1170
1171   data->num_glyphs = (FT_UShort)face->num_glyphs;
1172   data->glyphs = (GLYPH*)calloc(1, data->num_glyphs * sizeof (GLYPH));
1173   if (!data->glyphs)
1174     return FT_Err_Out_Of_Memory;
1175
1176   /* XXX: Make size configurable */
1177   /* we use the EM size */
1178   /* so that the resulting coordinates can be used without transformation */
1179   error = FT_Set_Char_Size(face, face->units_per_EM * 64, 0, 72, 0);
1180   if (error)
1181     return error;
1182
1183   /* loop over all glyphs in font face */
1184   for (i = 0; i < data->num_glyphs; i++)
1185   {
1186     GLYPH* glyph = &data->glyphs[i];
1187
1188
1189     error = FT_Load_Glyph(face, i, FT_LOAD_NO_BITMAP | FT_LOAD_NO_AUTOHINT);
1190     if (error)
1191       return error;
1192
1193     error = TA_create_glyph_data(&face->glyph->outline, glyph);
1194     if (error)
1195       return error;
1196   }
1197
1198   return TA_Err_Ok;
1199 }
1200
1201
1202 /*
1203  * While the auto-hinter is glyph oriented (this is, using `glyf' data), it
1204  * relies on the `cmap' table and OpenType features to get style coverage
1205  * data.  In TTCs, subfonts normally share the same `glyf' table but use
1206  * different `cmap's and OpenType features (in `GSUB' and `GPOS' tables).
1207  * To handle this gracefully, ttfautohint collects (and merges) the coverage
1208  * information in the `glyf_Data' structure.
1209  */
1210
1211 FT_Error
1212 TA_sfnt_handle_coverage(SFNT* sfnt,
1213                         FONT* font)
1214 {
1215   FT_Error error;
1216
1217   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
1218   glyf_Data* data = (glyf_Data*)glyf_table->data;
1219
1220   FT_Face face = sfnt->face;
1221   TA_FaceGlobals curr_globals;
1222
1223   TA_Style saved_fallback_style = font->fallback_style;
1224
1225
1226   /* using TA_STYLE_UNASSIGNED as the fallback style ensures */
1227   /* that uncovered glyphs stay as-is */
1228   /* (we handle the fallback style later on) */
1229   font->fallback_style = (TA_Style)TA_STYLE_UNASSIGNED;
1230
1231   /* trigger computation of coverage */
1232   error = ta_loader_init(font);
1233   if (error)
1234     goto Exit;
1235   error = ta_loader_reset(font, face);
1236   if (error)
1237     goto Exit;
1238   ta_loader_done(font);
1239
1240   font->fallback_style = saved_fallback_style;
1241   curr_globals = (TA_FaceGlobals)face->autohint.data;
1242
1243   if (!data->master_globals)
1244   {
1245     /* initialize */
1246     data->master_globals = curr_globals;
1247     goto Exit;
1248   }
1249
1250   /* we have the same `glyf' table for another subfont; */
1251   /* merge the current coverage info into the `master' coverage info */
1252   {
1253     TA_FaceGlobals master_globals = data->master_globals;
1254     FT_Long count = master_globals->glyph_count;
1255
1256     FT_Byte* master = master_globals->glyph_styles;
1257     FT_Byte* curr = curr_globals->glyph_styles;
1258
1259     FT_Byte* limit = master + count;
1260
1261
1262     /* we simply copy the data, */
1263     /* assuming that a given glyph always has the same properties -- */
1264     /* as soon as we make the style selection more fine-grained, */
1265     /* it is possible that this assumption doesn't hold: */
1266     /* for example, glyph `A' can be used for both Cyrillic and Latin */
1267     while (master < limit)
1268     {
1269       if ((*curr & ~TA_DIGIT) != TA_STYLE_UNASSIGNED)
1270         *master = *curr;
1271
1272       master++;
1273       curr++;
1274     }
1275   }
1276
1277 Exit:
1278   return error;
1279 }
1280
1281
1282 void
1283 TA_sfnt_adjust_coverage(SFNT* sfnt,
1284                         FONT* font)
1285 {
1286   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
1287   glyf_Data* data = (glyf_Data*)glyf_table->data;
1288
1289   TA_FaceGlobals master_globals = data->master_globals;
1290
1291
1292   /* use fallback style for uncovered glyphs */
1293   if (!data->adjusted)
1294   {
1295     FT_Long nn;
1296     FT_Byte* gstyles = master_globals->glyph_styles;
1297 #ifdef TA_DEBUG
1298     FT_UInt count;
1299 #endif
1300
1301
1302     for (nn = 0; nn < master_globals->glyph_count; nn++)
1303     {
1304       if ((gstyles[nn] & ~TA_DIGIT) == TA_STYLE_UNASSIGNED)
1305       {
1306         gstyles[nn] &= ~TA_STYLE_UNASSIGNED;
1307         gstyles[nn] |= master_globals->font->fallback_style;
1308       }
1309     }
1310
1311 #ifdef TA_DEBUG
1312
1313     if (sfnt->face->num_faces > 1)
1314       TA_LOG_GLOBAL(("\n"
1315                      "using fallback style `%s' for unassigned glyphs"
1316                      " (glyf table index %d):\n",
1317                      ta_style_names[master_globals->font->fallback_style],
1318                      sfnt->glyf_idx));
1319     else
1320       TA_LOG_GLOBAL(("\n"
1321                      "using fallback style `%s' for unassigned glyphs:\n",
1322                      ta_style_names[master_globals->font->fallback_style]));
1323
1324     count = 0;
1325
1326     for (nn = 0; nn < master_globals->glyph_count; nn++)
1327     {
1328       if ((gstyles[nn] & ~TA_DIGIT) == master_globals->font->fallback_style)
1329       {
1330         if (!(count % 10))
1331           TA_LOG_GLOBAL((" "));
1332
1333         TA_LOG_GLOBAL((" %d", nn));
1334         count++;
1335
1336         if (!(count % 10))
1337           TA_LOG_GLOBAL(("\n"));
1338       }
1339     }
1340
1341     if (!count)
1342       TA_LOG_GLOBAL(("  (none)\n"));
1343     if (count % 10)
1344       TA_LOG_GLOBAL(("\n"));
1345
1346 #endif /* TA_DEBUG */
1347
1348     data->adjusted = 1;
1349   }
1350 }
1351
1352
1353 #if 0
1354
1355 void
1356 TA_sfnt_copy_master_coverage(SFNT* sfnt,
1357                              FONT* font)
1358 {
1359   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
1360   glyf_Data* data = (glyf_Data*)glyf_table->data;
1361
1362   FT_Face face = sfnt->face;
1363
1364   TA_FaceGlobals master_globals = data->master_globals;
1365   TA_FaceGlobals curr_globals = (TA_FaceGlobals)face->autohint.data;
1366
1367
1368   if (master_globals != curr_globals)
1369   {
1370     FT_Long count = master_globals->glyph_count;
1371     FT_Byte* master = master_globals->glyph_styles;
1372     FT_Byte* curr = curr_globals->glyph_styles;
1373
1374
1375     memcpy(curr, master, count);
1376   }
1377 }
1378
1379 #endif /* 0 */
1380
1381 /* end of taglyf.c */