lib/tagloadr.c

   1 /* tagloadr.c */
   2
   3 /*
   4  * Copyright (C) 2011-2022 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 /* originally file `ftgloadr.c' (2011-Mar-28) from FreeType */
  17
  18 /* heavily modified 2011 by Werner Lemberg <wl@gnu.org> */
  19
  20 #include <stdlib.h>
  21 #include <string.h>
  22
  23 #include "tatypes.h"
  24 #include "tagloadr.h"
  25
  26
  27   /*************************************************************************/
  28   /*                                                                       */
  29   /* The glyph loader is a simple object which is used to load a set of    */
  30   /* glyphs easily.  It is critical for the correct loading of composites. */
  31   /*                                                                       */
  32   /* Ideally, one can see it as a stack of abstract `glyph' objects.       */
  33   /*                                                                       */
  34   /*   loader.base     Is really the bottom of the stack.  It describes a  */
  35   /*                   single glyph image made of the juxtaposition of     */
  36   /*                   several glyphs (those `in the stack').              */
  37   /*                                                                       */
  38   /*   loader.current  Describes the top of the stack, on which a new      */
  39   /*                   glyph can be loaded.                                */
  40   /*                                                                       */
  41   /*   Rewind          Clears the stack.                                   */
  42   /*   Prepare         Set up `loader.current' for addition of a new glyph */
  43   /*                   image.                                              */
  44   /*   Add             Add the `current' glyph image to the `base' one,    */
  45   /*                   and prepare for another one.                        */
  46   /*                                                                       */
  47   /*************************************************************************/
  48
  49
  50 /* create a new glyph loader */
  51 FT_Error
  52 TA_GlyphLoader_New(TA_GlyphLoader *aloader)
  53 {
  54   TA_GlyphLoader loader;
  55
  56
  57   loader = (TA_GlyphLoader)calloc(1, sizeof (TA_GlyphLoaderRec));
  58
  59   if (!loader)
  60     return FT_Err_Out_Of_Memory;
  61
  62   *aloader = loader;
  63   return FT_Err_Ok;
  64 }
  65
  66
  67 /* rewind the glyph loader - reset counters to 0 */
  68 void
  69 TA_GlyphLoader_Rewind(TA_GlyphLoader loader)
  70 {
  71   TA_GlyphLoad base = &loader->base;
  72   TA_GlyphLoad current = &loader->current;
  73
  74
  75   base->outline.n_points = 0;
  76   base->outline.n_contours = 0;
  77   base->num_subglyphs = 0;
  78
  79   *current = *base;
  80 }
  81
  82
  83 /* reset the glyph loader, frees all allocated tables */
  84 /* and starts from zero */
  85 void
  86 TA_GlyphLoader_Reset(TA_GlyphLoader loader)
  87 {
  88   free(loader->base.outline.points);
  89   free(loader->base.outline.tags);
  90   free(loader->base.outline.contours);
  91   free(loader->base.extra_points);
  92   free(loader->base.subglyphs);
  93
  94   loader->base.outline.points = NULL;
  95   loader->base.outline.tags = NULL;
  96   loader->base.outline.contours = NULL;
  97   loader->base.extra_points = NULL;
  98   loader->base.subglyphs = NULL;
  99
 100   loader->base.extra_points2 = NULL;
 101
 102   loader->max_points = 0;
 103   loader->max_contours = 0;
 104   loader->max_subglyphs = 0;
 105
 106   TA_GlyphLoader_Rewind(loader);
 107 }
 108
 109
 110 /* delete a glyph loader */
 111 void
 112 TA_GlyphLoader_Done(TA_GlyphLoader loader)
 113 {
 114   if (loader)
 115   {
 116     TA_GlyphLoader_Reset(loader);
 117     free(loader);
 118   }
 119 }
 120
 121
 122 /* re-adjust the `current' outline fields */
 123 static void
 124 TA_GlyphLoader_Adjust_Points(TA_GlyphLoader loader)
 125 {
 126   FT_Outline* base = &loader->base.outline;
 127   FT_Outline* current = &loader->current.outline;
 128
 129
 130   current->points = base->points + base->n_points;
 131   current->tags = base->tags + base->n_points;
 132   current->contours = base->contours + base->n_contours;
 133
 134   /* handle extra points table - if any */
 135   if (loader->use_extra)
 136   {
 137     loader->current.extra_points = loader->base.extra_points
 138                                    + base->n_points;
 139
 140     loader->current.extra_points2 = loader->base.extra_points2
 141                                     + base->n_points;
 142   }
 143 }
 144
 145
 146 #if 0
 147 FT_Error
 148 TA_GlyphLoader_CreateExtra(TA_GlyphLoader loader)
 149 {
 150   loader->base.extra_points =
 151     (FT_Vector*)calloc(1, 2 * loader->max_points * sizeof (FT_Vector));
 152   if (!loader->base.extra_points)
 153     return FT_Err_Out_Of_Memory;
 154
 155   loader->use_extra = 1;
 156   loader->base.extra_points2 = loader->base.extra_points
 157                                + loader->max_points;
 158
 159   TA_GlyphLoader_Adjust_Points(loader);
 160
 161   return FT_Err_Ok;
 162 }
 163 #endif
 164
 165
 166 /* re-adjust the `current' subglyphs field */
 167 static void
 168 TA_GlyphLoader_Adjust_Subglyphs(TA_GlyphLoader loader)
 169 {
 170   TA_GlyphLoad base = &loader->base;
 171   TA_GlyphLoad current = &loader->current;
 172
 173
 174   current->subglyphs = base->subglyphs + base->num_subglyphs;
 175 }
 176
 177
 178 /* ensure that we can add `n_points' and `n_contours' to our glyph -- */
 179 /* this function reallocates its outline tables if necessary, */
 180 /* but it DOESN'T change the number of points within the loader */
 181 FT_Error
 182 TA_GlyphLoader_CheckPoints(TA_GlyphLoader loader,
 183                            FT_UInt n_points,
 184                            FT_UInt n_contours)
 185 {
 186   FT_Outline* base = &loader->base.outline;
 187   FT_Outline* current = &loader->current.outline;
 188   FT_Bool adjust = 0;
 189
 190   FT_UInt new_max, old_max;
 191
 192
 193   /* check points & tags */
 194   new_max = (FT_UInt)base->n_points + (FT_UInt)current->n_points
 195             + n_points;
 196   old_max = loader->max_points;
 197
 198   if (new_max > old_max)
 199   {
 200     FT_Vector* points_new;
 201     char* tags_new;
 202
 203
 204     new_max = TA_PAD_CEIL(new_max, 8);
 205
 206     if (new_max > FT_OUTLINE_POINTS_MAX)
 207       return FT_Err_Array_Too_Large;
 208
 209     points_new = (FT_Vector*)realloc(base->points,
 210                                      new_max * sizeof (FT_Vector));
 211     if (!points_new)
 212       return FT_Err_Out_Of_Memory;
 213     base->points = points_new;
 214
 215     tags_new = (char*)realloc(base->tags,
 216                               new_max * sizeof (char));
 217     if (!tags_new)
 218       return FT_Err_Out_Of_Memory;
 219     base->tags = tags_new;
 220
 221     if (loader->use_extra)
 222     {
 223       FT_Vector* extra_points_new;
 224
 225
 226       extra_points_new =
 227         (FT_Vector*)realloc(loader->base.extra_points,
 228                             new_max * 2 * sizeof (FT_Vector));
 229       if (!extra_points_new)
 230         return FT_Err_Out_Of_Memory;
 231       loader->base.extra_points = extra_points_new;
 232
 233       memmove(loader->base.extra_points + new_max,
 234               loader->base.extra_points + old_max,
 235               old_max * sizeof (FT_Vector));
 236
 237       loader->base.extra_points2 = loader->base.extra_points + new_max;
 238     }
 239
 240     adjust = 1;
 241     loader->max_points = new_max;
 242   }
 243
 244   /* check contours */
 245   old_max = loader->max_contours;
 246   new_max = (FT_UInt)base->n_contours + (FT_UInt)current->n_contours
 247             + n_contours;
 248   if (new_max > old_max)
 249   {
 250     short* contours_new;
 251
 252
 253     new_max = TA_PAD_CEIL(new_max, 4);
 254
 255     if (new_max > FT_OUTLINE_CONTOURS_MAX)
 256       return FT_Err_Array_Too_Large;
 257
 258     contours_new = (short*)realloc(base->contours,
 259                                    new_max * sizeof (short));
 260     if (!contours_new)
 261       return FT_Err_Out_Of_Memory;
 262     base->contours = contours_new;
 263
 264     adjust = 1;
 265     loader->max_contours = new_max;
 266   }
 267
 268   if (adjust)
 269     TA_GlyphLoader_Adjust_Points(loader);
 270
 271   return FT_Err_Ok;
 272 }
 273
 274
 275 /* ensure that we can add `n_subglyphs' to our glyph -- */
 276 /* this function reallocates its subglyphs table if necessary, */
 277 /* but it DOES NOT change the number of subglyphs within the loader */
 278 FT_Error
 279 TA_GlyphLoader_CheckSubGlyphs(TA_GlyphLoader loader,
 280                               FT_UInt n_subs)
 281 {
 282   FT_UInt new_max, old_max;
 283
 284   TA_GlyphLoad base = &loader->base;
 285   TA_GlyphLoad current = &loader->current;
 286
 287
 288   new_max = base->num_subglyphs + current->num_subglyphs + n_subs;
 289   old_max = loader->max_subglyphs;
 290   if (new_max > old_max)
 291   {
 292     TA_SubGlyph subglyphs_new;
 293
 294
 295     new_max = TA_PAD_CEIL(new_max, 2);
 296     subglyphs_new = (TA_SubGlyph)realloc(base->subglyphs,
 297                                          new_max * sizeof (TA_SubGlyphRec));
 298     if (!subglyphs_new)
 299       return FT_Err_Out_Of_Memory;
 300     base->subglyphs = subglyphs_new;
 301
 302     loader->max_subglyphs = new_max;
 303
 304     TA_GlyphLoader_Adjust_Subglyphs(loader);
 305   }
 306
 307   return FT_Err_Ok;
 308 }
 309
 310
 311 /* prepare loader for the addition of a new glyph on top of the base one */
 312 void
 313 TA_GlyphLoader_Prepare(TA_GlyphLoader loader)
 314 {
 315   TA_GlyphLoad current = &loader->current;
 316
 317
 318   current->outline.n_points = 0;
 319   current->outline.n_contours = 0;
 320   current->num_subglyphs = 0;
 321
 322   TA_GlyphLoader_Adjust_Points (loader);
 323   TA_GlyphLoader_Adjust_Subglyphs(loader);
 324 }
 325
 326
 327 /* add current glyph to the base image -- and prepare for another */
 328 void
 329 TA_GlyphLoader_Add(TA_GlyphLoader loader)
 330 {
 331   TA_GlyphLoad base;
 332   TA_GlyphLoad current;
 333
 334   FT_Int n_curr_contours;
 335   FT_Int n_base_points;
 336   FT_Int n;
 337
 338
 339   if (!loader)
 340     return;
 341
 342   base = &loader->base;
 343   current = &loader->current;
 344
 345   n_curr_contours = current->outline.n_contours;
 346   n_base_points = base->outline.n_points;
 347
 348   base->outline.n_points =
 349     (short)(base->outline.n_points + current->outline.n_points);
 350   base->outline.n_contours =
 351     (short)(base->outline.n_contours + current->outline.n_contours);
 352
 353   base->num_subglyphs += current->num_subglyphs;
 354
 355   /* adjust contours count in newest outline */
 356   for (n = 0; n < n_curr_contours; n++)
 357     current->outline.contours[n] =
 358       (short)(current->outline.contours[n] + n_base_points);
 359
 360   /* prepare for another new glyph image */
 361   TA_GlyphLoader_Prepare(loader);
 362 }
 363
 364
 365 #if 0
 366 FT_Error
 367 TA_GlyphLoader_CopyPoints(TA_GlyphLoader target,
 368                           TA_GlyphLoader source)
 369 {
 370   FT_Error error;
 371   FT_UInt num_points = (FT_UInt)source->base.outline.n_points;
 372   FT_UInt num_contours = (FT_UInt)source->base.outline.n_contours;
 373
 374
 375   error = TA_GlyphLoader_CheckPoints(target, num_points, num_contours);
 376   if (!error)
 377   {
 378     FT_Outline* out = &target->base.outline;
 379     FT_Outline* in = &source->base.outline;
 380
 381
 382     memcpy(out->points, in->points, num_points * sizeof (FT_Vector));
 383     memcpy(out->contours, in->contours, num_contours * sizeof (short));
 384     memcpy(out->tags, in->tags, num_points * sizeof (char));
 385
 386     /* do we need to copy the extra points? */
 387     if (target->use_extra && source->use_extra)
 388     {
 389       memcpy(target->base.extra_points, source->base.extra_points,
 390              num_points * sizeof (FT_Vector));
 391       memcpy(target->base.extra_points2, source->base.extra_points2,
 392              num_points * sizeof (FT_Vector));
 393     }
 394
 395     out->n_points = (short)num_points;
 396     out->n_contours = (short)num_contours;
 397
 398     TA_GlyphLoader_Adjust_Points(target);
 399   }
 400
 401   return error;
 402 }
 403 #endif
 404
 405 /* end of tagloadr.c */