src/taglyf.c

   1 /* taglyf.c */
   2
   3 /*
   4  * Copyright (C) 2011 by Werner Lemberg.
   5  *
   6  * This file is part of the ttfautohint library, and may only be used,
   7  * modified, and distributed under the terms given in `COPYING'.  By
   8  * continuing to use, modify, or distribute this file you indicate that you
   9  * have read `COPYING' and understand and accept it fully.
  10  *
  11  * The file `COPYING' mentioned in the previous paragraph is distributed
  12  * with the ttfautohint library.
  13  */
  14
  15
  16 #include "ta.h"
  17
  18
  19 FT_Error
  20 TA_sfnt_build_glyf_hints(SFNT* sfnt,
  21                          FONT* font)
  22 {
  23   FT_Face face = sfnt->face;
  24   FT_Long idx;
  25   FT_Error error;
  26
  27
  28   for (idx = 0; idx < face->num_glyphs; idx++)
  29   {
  30     error = TA_sfnt_build_glyph_instructions(sfnt, font, idx);
  31     if (error)
  32       return error;
  33     if (font->progress)
  34       font->progress(idx, face->num_glyphs,
  35                      sfnt - font->sfnts, font->num_sfnts,
  36                      font->progress_data);
  37   }
  38
  39   return FT_Err_Ok;
  40 }
  41
  42
  43 static FT_Error
  44 TA_glyph_parse_composite(GLYPH* glyph,
  45                          FT_Byte* buf,
  46                          FT_ULong len)
  47 {
  48   FT_ULong flags_offset; /* after the loop, this is the offset */
  49                          /* to the last element in the flags array */
  50   FT_UShort flags;
  51
  52   FT_Byte* p;
  53   FT_Byte* endp;
  54
  55
  56   p = buf;
  57   endp = buf + len;
  58
  59   /* skip header */
  60   p += 10;
  61
  62   /* walk over component records */
  63   do
  64   {
  65     if (p + 4 > endp)
  66       return FT_Err_Invalid_Table;
  67
  68     flags_offset = p - buf;
  69
  70     flags = *(p++) << 8;
  71     flags += *(p++);
  72
  73     /* skip glyph component index */
  74     p += 2;
  75
  76     /* skip scaling and offset arguments */
  77     if (flags & ARGS_ARE_WORDS)
  78       p += 4;
  79     else
  80       p += 2;
  81
  82     if (flags & WE_HAVE_A_SCALE)
  83       p += 2;
  84     else if (flags & WE_HAVE_AN_XY_SCALE)
  85       p += 4;
  86     else if (flags & WE_HAVE_A_2X2)
  87       p += 8;
  88   } while (flags & MORE_COMPONENTS);
  89
  90   glyph->flags_offset = flags_offset;
  91
  92   /* adjust glyph record length */
  93   len = p - buf;
  94
  95   glyph->len1 = len;
  96   /* glyph->len2 = 0; */
  97   glyph->buf = (FT_Byte*)malloc(len);
  98   if (!glyph->buf)
  99     return FT_Err_Out_Of_Memory;
 100
 101   /* copy record without instructions (if any) */
 102   memcpy(glyph->buf, buf, len);
 103   glyph->buf[flags_offset] &= ~(WE_HAVE_INSTR >> 8);
 104
 105   return TA_Err_Ok;
 106 }
 107
 108
 109 static FT_Error
 110 TA_glyph_parse_simple(GLYPH* glyph,
 111                       FT_Byte* buf,
 112                       FT_UShort num_contours,
 113                       FT_ULong len)
 114 {
 115   FT_ULong ins_offset;
 116   FT_Byte* flags_start;
 117
 118   FT_UShort num_ins;
 119   FT_UShort num_pts;
 120
 121   FT_ULong flags_size; /* size of the flags array */
 122   FT_ULong xy_size; /* size of x and y coordinate arrays together */
 123
 124   FT_Byte* p;
 125   FT_Byte* endp;
 126
 127   FT_UShort i;
 128
 129
 130   p = buf;
 131   endp = buf + len;
 132
 133   ins_offset = 10 + num_contours * 2;
 134
 135   p += ins_offset;
 136
 137   if (p + 2 > endp)
 138     return FT_Err_Invalid_Table;
 139
 140   /* get number of instructions */
 141   num_ins = *(p++) << 8;
 142   num_ins += *(p++);
 143
 144   p += num_ins;
 145
 146   if (p > endp)
 147     return FT_Err_Invalid_Table;
 148
 149   /* get number of points from last outline point */
 150   num_pts = buf[ins_offset - 2] << 8;
 151   num_pts += buf[ins_offset - 1];
 152   num_pts++;
 153
 154   flags_start = p;
 155   xy_size = 0;
 156   i = 0;
 157
 158   while (i < num_pts)
 159   {
 160     FT_Byte flags;
 161     FT_Byte x_short;
 162     FT_Byte y_short;
 163     FT_Byte have_x;
 164     FT_Byte have_y;
 165     FT_Byte count;
 166
 167
 168     if (p + 1 > endp)
 169       return FT_Err_Invalid_Table;
 170
 171     flags = *(p++);
 172
 173     x_short = (flags & X_SHORT_VECTOR) ? 1 : 2;
 174     y_short = (flags & Y_SHORT_VECTOR) ? 1 : 2;
 175
 176     have_x = ((flags & SAME_X) && !(flags & X_SHORT_VECTOR)) ? 0 : 1;
 177     have_y = ((flags & SAME_Y) && !(flags & Y_SHORT_VECTOR)) ? 0 : 1;
 178
 179     count = 1;
 180
 181     if (flags & REPEAT)
 182     {
 183       if (p + 1 > endp)
 184         return FT_Err_Invalid_Table;
 185
 186       count += *(p++);
 187
 188       if (i + count > num_pts)
 189         return FT_Err_Invalid_Table;
 190     }
 191
 192     xy_size += count * x_short * have_x;
 193     xy_size += count * y_short * have_y;
 194
 195     i += count;
 196   }
 197
 198   if (p + xy_size > endp)
 199     return FT_Err_Invalid_Table;
 200
 201   flags_size = p - flags_start;
 202
 203   /* store the data before and after the bytecode instructions */
 204   /* in the same array */
 205   glyph->len1 = ins_offset;
 206   glyph->len2 = flags_size + xy_size;
 207   glyph->buf = (FT_Byte*)malloc(glyph->len1 + glyph->len2);
 208   if (!glyph->buf)
 209     return FT_Err_Out_Of_Memory;
 210
 211   /* now copy everything but the instructions */
 212   memcpy(glyph->buf, buf, glyph->len1);
 213   memcpy(glyph->buf + glyph->len1, flags_start, glyph->len2);
 214
 215   return TA_Err_Ok;
 216 }
 217
 218
 219 FT_Error
 220 TA_sfnt_split_glyf_table(SFNT* sfnt,
 221                          FONT* font)
 222 {
 223   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
 224   SFNT_Table* loca_table = &font->tables[sfnt->loca_idx];
 225   SFNT_Table* head_table = &font->tables[sfnt->head_idx];
 226
 227   glyf_Data* data;
 228   FT_Byte loca_format;
 229
 230   FT_ULong offset;
 231   FT_ULong offset_next;
 232
 233   FT_Byte* p;
 234   FT_UShort i;
 235
 236
 237   /* in case of success, all allocated arrays are */
 238   /* linked and eventually freed in `TA_font_unload' */
 239
 240   /* nothing to do if table has already been split */
 241   if (glyf_table->data)
 242     return TA_Err_Ok;
 243
 244   data = (glyf_Data*)calloc(1, sizeof (glyf_Data));
 245   if (!data)
 246     return FT_Err_Out_Of_Memory;
 247
 248   glyf_table->data = data;
 249
 250   loca_format = head_table->buf[LOCA_FORMAT_OFFSET];
 251
 252   data->num_glyphs = loca_format ? loca_table->len / 4 - 1
 253                                  : loca_table->len / 2 - 1;
 254   data->glyphs = (GLYPH*)calloc(1, data->num_glyphs * sizeof (GLYPH));
 255   if (!data->glyphs)
 256     return FT_Err_Out_Of_Memory;
 257
 258   p = loca_table->buf;
 259
 260   if (loca_format)
 261   {
 262     offset_next = *(p++) << 24;
 263     offset_next += *(p++) << 16;
 264     offset_next += *(p++) << 8;
 265     offset_next += *(p++);
 266   }
 267   else
 268   {
 269     offset_next = *(p++) << 8;
 270     offset_next += *(p++);
 271     offset_next <<= 1;
 272   }
 273
 274   /* loop over `loca' and `glyf' data */
 275   for (i = 0; i < data->num_glyphs; i++)
 276   {
 277     GLYPH* glyph = &data->glyphs[i];
 278     FT_ULong len;
 279
 280
 281     offset = offset_next;
 282
 283     if (loca_format)
 284     {
 285       offset_next = *(p++) << 24;
 286       offset_next += *(p++) << 16;
 287       offset_next += *(p++) << 8;
 288       offset_next += *(p++);
 289     }
 290     else
 291     {
 292       offset_next = *(p++) << 8;
 293       offset_next += *(p++);
 294       offset_next <<= 1;
 295     }
 296
 297     if (offset_next < offset
 298         || offset_next > glyf_table->len)
 299       return FT_Err_Invalid_Table;
 300
 301     len = offset_next - offset;
 302     if (!len)
 303       continue; /* empty glyph */
 304     else
 305     {
 306       FT_Byte* buf;
 307       FT_Short num_contours;
 308       FT_Error error;
 309
 310
 311       /* check header size */
 312       if (len < 10)
 313         return FT_Err_Invalid_Table;
 314
 315       buf = glyf_table->buf + offset;
 316       num_contours = (FT_Short)((buf[0] << 8) + buf[1]);
 317
 318       /* We must parse the rest of the glyph record to get the exact */
 319       /* record length.  Since the `loca' table rounds record lengths */
 320       /* up to multiples of 4 (or 2 for older fonts), and we must round */
 321       /* up again after stripping off the instructions, it would be */
 322       /* possible otherwise to have more than 4 bytes of padding which */
 323       /* is more or less invalid. */
 324
 325       if (num_contours < 0)
 326       {
 327         error = TA_glyph_parse_composite(glyph, buf, len);
 328         if (error)
 329           return error;
 330       }
 331       else
 332       {
 333         error = TA_glyph_parse_simple(glyph, buf, num_contours, len);
 334         if (error)
 335           return error;
 336       }
 337     }
 338   }
 339
 340   return TA_Err_Ok;
 341 }
 342
 343
 344 FT_Error
 345 TA_sfnt_build_glyf_table(SFNT* sfnt,
 346                          FONT* font)
 347 {
 348   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
 349   glyf_Data* data = (glyf_Data*)glyf_table->data;
 350
 351   GLYPH* glyph;
 352
 353   FT_ULong len;
 354   FT_Byte* buf_new;
 355   FT_Byte* p;
 356   FT_UShort i;
 357
 358
 359   if (glyf_table->processed)
 360     return TA_Err_Ok;
 361
 362   /* get table size */
 363   len = 0;
 364   glyph = data->glyphs;
 365   for (i = 0; i < data->num_glyphs; i++, glyph++)
 366   {
 367     /* glyph records should have offsets which are multiples of 4 */
 368     len = (len + 3) & ~3;
 369     len += glyph->len1 + glyph->len2 + glyph->ins_len;
 370     /* add two bytes for the instructionLength field */
 371     if (glyph->len2 || glyph->ins_len)
 372       len += 2;
 373   }
 374
 375   /* to make the short format of the `loca' table always work, */
 376   /* assure an even length of the `glyf' table */
 377   glyf_table->len = (len + 1) & ~1;
 378
 379   buf_new = (FT_Byte*)realloc(glyf_table->buf, (len + 3) & ~3);
 380   if (!buf_new)
 381     return FT_Err_Out_Of_Memory;
 382   else
 383     glyf_table->buf = buf_new;
 384
 385   p = glyf_table->buf;
 386   glyph = data->glyphs;
 387   for (i = 0; i < data->num_glyphs; i++, glyph++)
 388   {
 389     len = glyph->len1 + glyph->len2 + glyph->ins_len;
 390     if (glyph->len2 || glyph->ins_len)
 391       len += 2;
 392
 393     if (len)
 394     {
 395       /* copy glyph data and insert new instructions */
 396       memcpy(p, glyph->buf, glyph->len1);
 397
 398       if (glyph->len2)
 399       {
 400         /* simple glyph */
 401         p += glyph->len1;
 402         *(p++) = HIGH(glyph->ins_len);
 403         *(p++) = LOW(glyph->ins_len);
 404         memcpy(p, glyph->ins_buf, glyph->ins_len);
 405         p += glyph->ins_len;
 406         memcpy(p, glyph->buf + glyph->len1, glyph->len2);
 407         p += glyph->len2;
 408       }
 409       else
 410       {
 411         /* composite glyph */
 412         if (glyph->ins_len)
 413         {
 414           *(p + glyph->flags_offset) |= (WE_HAVE_INSTR >> 8);
 415           p += glyph->len1;
 416           *(p++) = HIGH(glyph->ins_len);
 417           *(p++) = LOW(glyph->ins_len);
 418           memcpy(p, glyph->ins_buf, glyph->ins_len);
 419           p += glyph->ins_len;
 420         }
 421         else
 422           p += glyph->len1;
 423       }
 424
 425       /* pad with zero bytes to have an offset which is a multiple of 4; */
 426       /* this works even for the last glyph record since the `glyf' */
 427       /* table length is a multiple of 4 also */
 428       switch (len % 4)
 429       {
 430       case 1:
 431         *(p++) = 0;
 432       case 2:
 433         *(p++) = 0;
 434       case 3:
 435         *(p++) = 0;
 436       default:
 437         break;
 438       }
 439     }
 440   }
 441
 442   glyf_table->checksum = TA_table_compute_checksum(glyf_table->buf,
 443                                                    glyf_table->len);
 444   glyf_table->processed = 1;
 445
 446   return TA_Err_Ok;
 447 }
 448
 449 /* end of taglyf.c */