src/base/ftgloadr.c

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  ftgloadr.c                                                             */
   4 /*                                                                         */
   5 /*    The FreeType glyph loader (body).                                    */
   6 /*                                                                         */
   7 /*  Copyright 2002, 2003, 2004, 2005, 2006, 2010 by                        */
   8 /*  David Turner, Robert Wilhelm, and Werner Lemberg                       */
   9 /*                                                                         */
  10 /*  This file is part of the FreeType project, and may only be used,       */
  11 /*  modified, and distributed under the terms of the FreeType project      */
  12 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  13 /*  this file you indicate that you have read the license and              */
  14 /*  understand and accept it fully.                                        */
  15 /*                                                                         */
  16 /***************************************************************************/
  17
  18
  19 #include <ft2build.h>
  20 #include FT_INTERNAL_GLYPH_LOADER_H
  21 #include FT_INTERNAL_MEMORY_H
  22 #include FT_INTERNAL_OBJECTS_H
  23
  24 #undef  FT_COMPONENT
  25 #define FT_COMPONENT  trace_gloader
  26
  27
  28   /*************************************************************************/
  29   /*************************************************************************/
  30   /*************************************************************************/
  31   /*****                                                               *****/
  32   /*****                                                               *****/
  33   /*****                    G L Y P H   L O A D E R                    *****/
  34   /*****                                                               *****/
  35   /*****                                                               *****/
  36   /*************************************************************************/
  37   /*************************************************************************/
  38   /*************************************************************************/
  39
  40   /*************************************************************************/
  41   /*                                                                       */
  42   /* The glyph loader is a simple object which is used to load a set of    */
  43   /* glyphs easily.  It is critical for the correct loading of composites. */
  44   /*                                                                       */
  45   /* Ideally, one can see it as a stack of abstract `glyph' objects.       */
  46   /*                                                                       */
  47   /*   loader.base     Is really the bottom of the stack.  It describes a  */
  48   /*                   single glyph image made of the juxtaposition of     */
  49   /*                   several glyphs (those `in the stack').              */
  50   /*                                                                       */
  51   /*   loader.current  Describes the top of the stack, on which a new      */
  52   /*                   glyph can be loaded.                                */
  53   /*                                                                       */
  54   /*   Rewind          Clears the stack.                                   */
  55   /*   Prepare         Set up `loader.current' for addition of a new glyph */
  56   /*                   image.                                              */
  57   /*   Add             Add the `current' glyph image to the `base' one,    */
  58   /*                   and prepare for another one.                        */
  59   /*                                                                       */
  60   /* The glyph loader is now a base object.  Each driver used to           */
  61   /* re-implement it in one way or the other, which wasted code and        */
  62   /* energy.                                                               */
  63   /*                                                                       */
  64   /*************************************************************************/
  65
  66
  67   /* create a new glyph loader */
  68   FT_BASE_DEF( FT_Error )
  69   FT_GlyphLoader_New( FT_Memory        memory,
  70                       FT_GlyphLoader  *aloader )
  71   {
  72     FT_GlyphLoader  loader = NULL;
  73     FT_Error        error;
  74
  75
  76     if ( !FT_NEW( loader ) )
  77     {
  78       loader->memory = memory;
  79       *aloader       = loader;
  80     }
  81     return error;
  82   }
  83
  84
  85   /* rewind the glyph loader - reset counters to 0 */
  86   FT_BASE_DEF( void )
  87   FT_GlyphLoader_Rewind( FT_GlyphLoader  loader )
  88   {
  89     FT_GlyphLoad  base    = &loader->base;
  90     FT_GlyphLoad  current = &loader->current;
  91
  92
  93     base->outline.n_points   = 0;
  94     base->outline.n_contours = 0;
  95     base->num_subglyphs      = 0;
  96
  97     *current = *base;
  98   }
  99
 100
 101   /* reset the glyph loader, frees all allocated tables */
 102   /* and starts from zero                               */
 103   FT_BASE_DEF( void )
 104   FT_GlyphLoader_Reset( FT_GlyphLoader  loader )
 105   {
 106     FT_Memory memory = loader->memory;
 107
 108
 109     FT_FREE( loader->base.outline.points );
 110     FT_FREE( loader->base.outline.tags );
 111     FT_FREE( loader->base.outline.contours );
 112     FT_FREE( loader->base.extra_points );
 113     FT_FREE( loader->base.subglyphs );
 114
 115     loader->base.extra_points2 = NULL;
 116
 117     loader->max_points    = 0;
 118     loader->max_contours  = 0;
 119     loader->max_subglyphs = 0;
 120
 121     FT_GlyphLoader_Rewind( loader );
 122   }
 123
 124
 125   /* delete a glyph loader */
 126   FT_BASE_DEF( void )
 127   FT_GlyphLoader_Done( FT_GlyphLoader  loader )
 128   {
 129     if ( loader )
 130     {
 131       FT_Memory memory = loader->memory;
 132
 133
 134       FT_GlyphLoader_Reset( loader );
 135       FT_FREE( loader );
 136     }
 137   }
 138
 139
 140   /* re-adjust the `current' outline fields */
 141   static void
 142   FT_GlyphLoader_Adjust_Points( FT_GlyphLoader  loader )
 143   {
 144     FT_Outline*  base    = &loader->base.outline;
 145     FT_Outline*  current = &loader->current.outline;
 146
 147
 148     current->points   = base->points   + base->n_points;
 149     current->tags     = base->tags     + base->n_points;
 150     current->contours = base->contours + base->n_contours;
 151
 152     /* handle extra points table - if any */
 153     if ( loader->use_extra )
 154     {
 155       loader->current.extra_points  = loader->base.extra_points +
 156                                       base->n_points;
 157
 158       loader->current.extra_points2 = loader->base.extra_points2 +
 159                                       base->n_points;
 160     }
 161   }
 162
 163
 164   FT_BASE_DEF( FT_Error )
 165   FT_GlyphLoader_CreateExtra( FT_GlyphLoader  loader )
 166   {
 167     FT_Error   error;
 168     FT_Memory  memory = loader->memory;
 169
 170
 171     if ( !FT_NEW_ARRAY( loader->base.extra_points, 2 * loader->max_points ) )
 172     {
 173       loader->use_extra          = 1;
 174       loader->base.extra_points2 = loader->base.extra_points +
 175                                    loader->max_points;
 176
 177       FT_GlyphLoader_Adjust_Points( loader );
 178     }
 179     return error;
 180   }
 181
 182
 183   /* re-adjust the `current' subglyphs field */
 184   static void
 185   FT_GlyphLoader_Adjust_Subglyphs( FT_GlyphLoader  loader )
 186   {
 187     FT_GlyphLoad  base    = &loader->base;
 188     FT_GlyphLoad  current = &loader->current;
 189
 190
 191     current->subglyphs = base->subglyphs + base->num_subglyphs;
 192   }
 193
 194
 195   /* Ensure that we can add `n_points' and `n_contours' to our glyph.      */
 196   /* This function reallocates its outline tables if necessary.  Note that */
 197   /* it DOESN'T change the number of points within the loader!             */
 198   /*                                                                       */
 199   FT_BASE_DEF( FT_Error )
 200   FT_GlyphLoader_CheckPoints( FT_GlyphLoader  loader,
 201                               FT_UInt         n_points,
 202                               FT_UInt         n_contours )
 203   {
 204     FT_Memory    memory  = loader->memory;
 205     FT_Error     error   = FT_Err_Ok;
 206     FT_Outline*  base    = &loader->base.outline;
 207     FT_Outline*  current = &loader->current.outline;
 208     FT_Bool      adjust  = 0;
 209
 210     FT_UInt      new_max, old_max;
 211
 212
 213     /* check points & tags */
 214     new_max = base->n_points + current->n_points + n_points;
 215     old_max = loader->max_points;
 216
 217     if ( new_max > old_max )
 218     {
 219       new_max = FT_PAD_CEIL( new_max, 8 );
 220
 221       if ( new_max > FT_OUTLINE_POINTS_MAX )
 222         return FT_Err_Array_Too_Large;
 223
 224       if ( FT_RENEW_ARRAY( base->points, old_max, new_max ) ||
 225            FT_RENEW_ARRAY( base->tags,   old_max, new_max ) )
 226         goto Exit;
 227
 228       if ( loader->use_extra )
 229       {
 230         if ( FT_RENEW_ARRAY( loader->base.extra_points,
 231                              old_max * 2, new_max * 2 ) )
 232           goto Exit;
 233
 234         FT_ARRAY_MOVE( loader->base.extra_points + new_max,
 235                        loader->base.extra_points + old_max,
 236                        old_max );
 237
 238         loader->base.extra_points2 = loader->base.extra_points + new_max;
 239       }
 240
 241       adjust = 1;
 242       loader->max_points = new_max;
 243     }
 244
 245     /* check contours */
 246     old_max = loader->max_contours;
 247     new_max = base->n_contours + current->n_contours +
 248               n_contours;
 249     if ( new_max > old_max )
 250     {
 251       new_max = FT_PAD_CEIL( new_max, 4 );
 252
 253       if ( new_max > FT_OUTLINE_CONTOURS_MAX )
 254         return FT_Err_Array_Too_Large;
 255
 256       if ( FT_RENEW_ARRAY( base->contours, old_max, new_max ) )
 257         goto Exit;
 258
 259       adjust = 1;
 260       loader->max_contours = new_max;
 261     }
 262
 263     if ( adjust )
 264       FT_GlyphLoader_Adjust_Points( loader );
 265
 266   Exit:
 267     return error;
 268   }
 269
 270
 271   /* Ensure that we can add `n_subglyphs' to our glyph. this function */
 272   /* reallocates its subglyphs table if necessary.  Note that it DOES */
 273   /* NOT change the number of subglyphs within the loader!            */
 274   /*                                                                  */
 275   FT_BASE_DEF( FT_Error )
 276   FT_GlyphLoader_CheckSubGlyphs( FT_GlyphLoader  loader,
 277                                  FT_UInt         n_subs )
 278   {
 279     FT_Memory     memory = loader->memory;
 280     FT_Error      error  = FT_Err_Ok;
 281     FT_UInt       new_max, old_max;
 282
 283     FT_GlyphLoad  base    = &loader->base;
 284     FT_GlyphLoad  current = &loader->current;
 285
 286
 287     new_max = base->num_subglyphs + current->num_subglyphs + n_subs;
 288     old_max = loader->max_subglyphs;
 289     if ( new_max > old_max )
 290     {
 291       new_max = FT_PAD_CEIL( new_max, 2 );
 292       if ( FT_RENEW_ARRAY( base->subglyphs, old_max, new_max ) )
 293         goto Exit;
 294
 295       loader->max_subglyphs = new_max;
 296
 297       FT_GlyphLoader_Adjust_Subglyphs( loader );
 298     }
 299
 300   Exit:
 301     return error;
 302   }
 303
 304
 305   /* prepare loader for the addition of a new glyph on top of the base one */
 306   FT_BASE_DEF( void )
 307   FT_GlyphLoader_Prepare( FT_GlyphLoader  loader )
 308   {
 309     FT_GlyphLoad  current = &loader->current;
 310
 311
 312     current->outline.n_points   = 0;
 313     current->outline.n_contours = 0;
 314     current->num_subglyphs      = 0;
 315
 316     FT_GlyphLoader_Adjust_Points   ( loader );
 317     FT_GlyphLoader_Adjust_Subglyphs( loader );
 318   }
 319
 320
 321   /* add current glyph to the base image - and prepare for another */
 322   FT_BASE_DEF( void )
 323   FT_GlyphLoader_Add( FT_GlyphLoader  loader )
 324   {
 325     FT_GlyphLoad  base;
 326     FT_GlyphLoad  current;
 327
 328     FT_UInt       n_curr_contours;
 329     FT_UInt       n_base_points;
 330     FT_UInt       n;
 331
 332
 333     if ( !loader )
 334       return;
 335
 336     base    = &loader->base;
 337     current = &loader->current;
 338
 339     n_curr_contours = current->outline.n_contours;
 340     n_base_points   = base->outline.n_points;
 341
 342     base->outline.n_points =
 343       (short)( base->outline.n_points + current->outline.n_points );
 344     base->outline.n_contours =
 345       (short)( base->outline.n_contours + current->outline.n_contours );
 346
 347     base->num_subglyphs += current->num_subglyphs;
 348
 349     /* adjust contours count in newest outline */
 350     for ( n = 0; n < n_curr_contours; n++ )
 351       current->outline.contours[n] =
 352         (short)( current->outline.contours[n] + n_base_points );
 353
 354     /* prepare for another new glyph image */
 355     FT_GlyphLoader_Prepare( loader );
 356   }
 357
 358
 359   FT_BASE_DEF( FT_Error )
 360   FT_GlyphLoader_CopyPoints( FT_GlyphLoader  target,
 361                              FT_GlyphLoader  source )
 362   {
 363     FT_Error  error;
 364     FT_UInt   num_points   = source->base.outline.n_points;
 365     FT_UInt   num_contours = source->base.outline.n_contours;
 366
 367
 368     error = FT_GlyphLoader_CheckPoints( target, num_points, num_contours );
 369     if ( !error )
 370     {
 371       FT_Outline*  out = &target->base.outline;
 372       FT_Outline*  in  = &source->base.outline;
 373
 374
 375       FT_ARRAY_COPY( out->points, in->points,
 376                      num_points );
 377       FT_ARRAY_COPY( out->tags, in->tags,
 378                      num_points );
 379       FT_ARRAY_COPY( out->contours, in->contours,
 380                      num_contours );
 381
 382       /* do we need to copy the extra points? */
 383       if ( target->use_extra && source->use_extra )
 384       {
 385         FT_ARRAY_COPY( target->base.extra_points, source->base.extra_points,
 386                        num_points );
 387         FT_ARRAY_COPY( target->base.extra_points2, source->base.extra_points2,
 388                        num_points );
 389       }
 390
 391       out->n_points   = (short)num_points;
 392       out->n_contours = (short)num_contours;
 393
 394       FT_GlyphLoader_Adjust_Points( target );
 395     }
 396
 397     return error;
 398   }
 399
 400
 401 /* END */