src/truetype/ttgload.c

   1 /****************************************************************************
   2  *
   3  * ttgload.c
   4  *
   5  *   TrueType Glyph Loader (body).
   6  *
   7  * Copyright (C) 1996-2023 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 <freetype/internal/ftdebug.h>
  21 #include FT_CONFIG_CONFIG_H
  22 #include <freetype/internal/ftcalc.h>
  23 #include <freetype/internal/ftstream.h>
  24 #include <freetype/internal/sfnt.h>
  25 #include <freetype/tttags.h>
  26 #include <freetype/ftoutln.h>
  27 #include <freetype/ftdriver.h>
  28 #include <freetype/ftlist.h>
  29
  30 #include "ttgload.h"
  31 #include "ttpload.h"
  32
  33 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
  34 #include "ttgxvar.h"
  35 #endif
  36
  37 #include "tterrors.h"
  38
  39
  40   /**************************************************************************
  41    *
  42    * The macro FT_COMPONENT is used in trace mode.  It is an implicit
  43    * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
  44    * messages during execution.
  45    */
  46 #undef  FT_COMPONENT
  47 #define FT_COMPONENT  ttgload
  48
  49
  50   /**************************************************************************
  51    *
  52    * Simple glyph flags.
  53    */
  54 #define ON_CURVE_POINT  0x01  /* same value as FT_CURVE_TAG_ON            */
  55 #define X_SHORT_VECTOR  0x02
  56 #define Y_SHORT_VECTOR  0x04
  57 #define REPEAT_FLAG     0x08
  58 #define X_POSITIVE      0x10  /* two meanings depending on X_SHORT_VECTOR */
  59 #define SAME_X          0x10
  60 #define Y_POSITIVE      0x20  /* two meanings depending on Y_SHORT_VECTOR */
  61 #define SAME_Y          0x20
  62 #define OVERLAP_SIMPLE  0x40  /* retained as FT_OUTLINE_OVERLAP           */
  63
  64
  65   /**************************************************************************
  66    *
  67    * Composite glyph flags.
  68    */
  69 #define ARGS_ARE_WORDS             0x0001
  70 #define ARGS_ARE_XY_VALUES         0x0002
  71 #define ROUND_XY_TO_GRID           0x0004
  72 #define WE_HAVE_A_SCALE            0x0008
  73 /* reserved                        0x0010 */
  74 #define MORE_COMPONENTS            0x0020
  75 #define WE_HAVE_AN_XY_SCALE        0x0040
  76 #define WE_HAVE_A_2X2              0x0080
  77 #define WE_HAVE_INSTR              0x0100
  78 #define USE_MY_METRICS             0x0200
  79 #define OVERLAP_COMPOUND           0x0400  /* retained as FT_OUTLINE_OVERLAP */
  80 #define SCALED_COMPONENT_OFFSET    0x0800
  81 #define UNSCALED_COMPONENT_OFFSET  0x1000
  82
  83
  84 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
  85 #define IS_DEFAULT_INSTANCE( _face )             \
  86           ( !( FT_IS_NAMED_INSTANCE( _face ) ||  \
  87                FT_IS_VARIATION( _face )      ) )
  88 #else
  89 #define IS_DEFAULT_INSTANCE( _face )  1
  90 #endif
  91
  92
  93   /**************************************************************************
  94    *
  95    * Return the horizontal metrics in font units for a given glyph.
  96    */
  97   FT_LOCAL_DEF( void )
  98   TT_Get_HMetrics( TT_Face     face,
  99                    FT_UInt     idx,
 100                    FT_Short*   lsb,
 101                    FT_UShort*  aw )
 102   {
 103     ( (SFNT_Service)face->sfnt )->get_metrics( face, 0, idx, lsb, aw );
 104
 105     FT_TRACE5(( "  advance width (font units): %d\n", *aw ));
 106     FT_TRACE5(( "  left side bearing (font units): %d\n", *lsb ));
 107   }
 108
 109
 110   /**************************************************************************
 111    *
 112    * Return the vertical metrics in font units for a given glyph.
 113    * See function `tt_loader_set_pp' below for explanations.
 114    */
 115   FT_LOCAL_DEF( void )
 116   TT_Get_VMetrics( TT_Face     face,
 117                    FT_UInt     idx,
 118                    FT_Pos      yMax,
 119                    FT_Short*   tsb,
 120                    FT_UShort*  ah )
 121   {
 122     if ( face->vertical_info )
 123       ( (SFNT_Service)face->sfnt )->get_metrics( face, 1, idx, tsb, ah );
 124
 125     else if ( face->os2.version != 0xFFFFU )
 126     {
 127       *tsb = (FT_Short)( face->os2.sTypoAscender - yMax );
 128       *ah  = (FT_UShort)FT_ABS( face->os2.sTypoAscender -
 129                                 face->os2.sTypoDescender );
 130     }
 131
 132     else
 133     {
 134       *tsb = (FT_Short)( face->horizontal.Ascender - yMax );
 135       *ah  = (FT_UShort)FT_ABS( face->horizontal.Ascender -
 136                                 face->horizontal.Descender );
 137     }
 138
 139 #ifdef FT_DEBUG_LEVEL_TRACE
 140     if ( !face->vertical_info )
 141       FT_TRACE5(( "  [vertical metrics missing, computing values]\n" ));
 142 #endif
 143
 144     FT_TRACE5(( "  advance height (font units): %d\n", *ah ));
 145     FT_TRACE5(( "  top side bearing (font units): %d\n", *tsb ));
 146   }
 147
 148
 149   static FT_Error
 150   tt_get_metrics( TT_Loader  loader,
 151                   FT_UInt    glyph_index )
 152   {
 153     TT_Face    face   = loader->face;
 154
 155     FT_Error   error;
 156     FT_Stream  stream = loader->stream;
 157
 158     FT_Short   left_bearing = 0, top_bearing = 0;
 159     FT_UShort  advance_width = 0, advance_height = 0;
 160
 161     /* we must preserve the stream position          */
 162     /* (which gets altered by the metrics functions) */
 163     FT_ULong  pos = FT_STREAM_POS();
 164
 165
 166     TT_Get_HMetrics( face, glyph_index,
 167                      &left_bearing,
 168                      &advance_width );
 169     TT_Get_VMetrics( face, glyph_index,
 170                      loader->bbox.yMax,
 171                      &top_bearing,
 172                      &advance_height );
 173
 174     if ( FT_STREAM_SEEK( pos ) )
 175       return error;
 176
 177     loader->left_bearing = left_bearing;
 178     loader->advance      = advance_width;
 179     loader->top_bearing  = top_bearing;
 180     loader->vadvance     = advance_height;
 181
 182 #ifdef FT_CONFIG_OPTION_INCREMENTAL
 183     /* With the incremental interface, these values are set by  */
 184     /* a call to `tt_get_metrics_incremental'.                  */
 185     if ( face->root.internal->incremental_interface == NULL )
 186 #endif
 187     {
 188       if ( !loader->linear_def )
 189       {
 190         loader->linear_def = 1;
 191         loader->linear     = advance_width;
 192       }
 193     }
 194
 195     return FT_Err_Ok;
 196   }
 197
 198
 199 #ifdef FT_CONFIG_OPTION_INCREMENTAL
 200
 201   static void
 202   tt_get_metrics_incremental( TT_Loader  loader,
 203                               FT_UInt    glyph_index )
 204   {
 205     TT_Face  face = loader->face;
 206
 207     FT_Short   left_bearing = 0, top_bearing = 0;
 208     FT_UShort  advance_width = 0, advance_height = 0;
 209
 210
 211     /* If this is an incrementally loaded font check whether there are */
 212     /* overriding metrics for this glyph.                              */
 213     if ( face->root.internal->incremental_interface                           &&
 214          face->root.internal->incremental_interface->funcs->get_glyph_metrics )
 215     {
 216       FT_Incremental_MetricsRec  incr_metrics;
 217       FT_Error                   error;
 218
 219
 220       incr_metrics.bearing_x = loader->left_bearing;
 221       incr_metrics.bearing_y = 0;
 222       incr_metrics.advance   = loader->advance;
 223       incr_metrics.advance_v = 0;
 224
 225       error = face->root.internal->incremental_interface->funcs->get_glyph_metrics(
 226                 face->root.internal->incremental_interface->object,
 227                 glyph_index, FALSE, &incr_metrics );
 228       if ( error )
 229         goto Exit;
 230
 231       left_bearing  = (FT_Short)incr_metrics.bearing_x;
 232       advance_width = (FT_UShort)incr_metrics.advance;
 233
 234 #if 0
 235
 236       /* GWW: Do I do the same for vertical metrics? */
 237       incr_metrics.bearing_x = 0;
 238       incr_metrics.bearing_y = loader->top_bearing;
 239       incr_metrics.advance   = loader->vadvance;
 240
 241       error = face->root.internal->incremental_interface->funcs->get_glyph_metrics(
 242                 face->root.internal->incremental_interface->object,
 243                 glyph_index, TRUE, &incr_metrics );
 244       if ( error )
 245         goto Exit;
 246
 247       top_bearing    = (FT_Short)incr_metrics.bearing_y;
 248       advance_height = (FT_UShort)incr_metrics.advance;
 249
 250 #endif /* 0 */
 251
 252       loader->left_bearing = left_bearing;
 253       loader->advance      = advance_width;
 254       loader->top_bearing  = top_bearing;
 255       loader->vadvance     = advance_height;
 256
 257       if ( !loader->linear_def )
 258       {
 259         loader->linear_def = 1;
 260         loader->linear     = advance_width;
 261       }
 262     }
 263
 264   Exit:
 265     return;
 266   }
 267
 268 #endif /* FT_CONFIG_OPTION_INCREMENTAL */
 269
 270
 271   /**************************************************************************
 272    *
 273    * The following functions are used by default with TrueType fonts.
 274    * However, they can be replaced by alternatives if we need to support
 275    * TrueType-compressed formats (like MicroType) in the future.
 276    *
 277    */
 278
 279   FT_CALLBACK_DEF( FT_Error )
 280   TT_Access_Glyph_Frame( TT_Loader  loader,
 281                          FT_UInt    glyph_index,
 282                          FT_ULong   offset,
 283                          FT_UInt    byte_count )
 284   {
 285     FT_Error   error;
 286     FT_Stream  stream = loader->stream;
 287
 288     FT_UNUSED( glyph_index );
 289
 290
 291     /* the following line sets the `error' variable through macros! */
 292     if ( FT_STREAM_SEEK( offset ) || FT_FRAME_ENTER( byte_count ) )
 293       return error;
 294
 295     loader->cursor = stream->cursor;
 296     loader->limit  = stream->limit;
 297
 298     return FT_Err_Ok;
 299   }
 300
 301
 302   FT_CALLBACK_DEF( void )
 303   TT_Forget_Glyph_Frame( TT_Loader  loader )
 304   {
 305     FT_Stream  stream = loader->stream;
 306
 307
 308     FT_FRAME_EXIT();
 309   }
 310
 311
 312   FT_CALLBACK_DEF( FT_Error )
 313   TT_Load_Glyph_Header( TT_Loader  loader )
 314   {
 315     FT_Byte*  p     = loader->cursor;
 316     FT_Byte*  limit = loader->limit;
 317
 318
 319     if ( p + 10 > limit )
 320       return FT_THROW( Invalid_Outline );
 321
 322     loader->n_contours = FT_NEXT_SHORT( p );
 323
 324     loader->bbox.xMin = FT_NEXT_SHORT( p );
 325     loader->bbox.yMin = FT_NEXT_SHORT( p );
 326     loader->bbox.xMax = FT_NEXT_SHORT( p );
 327     loader->bbox.yMax = FT_NEXT_SHORT( p );
 328
 329     FT_TRACE5(( "  # of contours: %d\n", loader->n_contours ));
 330     FT_TRACE5(( "  xMin: %4ld  xMax: %4ld\n", loader->bbox.xMin,
 331                                             loader->bbox.xMax ));
 332     FT_TRACE5(( "  yMin: %4ld  yMax: %4ld\n", loader->bbox.yMin,
 333                                             loader->bbox.yMax ));
 334     loader->cursor = p;
 335
 336     return FT_Err_Ok;
 337   }
 338
 339
 340   FT_CALLBACK_DEF( FT_Error )
 341   TT_Load_Simple_Glyph( TT_Loader  load )
 342   {
 343     FT_Error        error;
 344     FT_Byte*        p          = load->cursor;
 345     FT_Byte*        limit      = load->limit;
 346     FT_GlyphLoader  gloader    = load->gloader;
 347     FT_Outline*     outline    = &gloader->current.outline;
 348     FT_Int          n_contours = load->n_contours;
 349     FT_Int          n_points;
 350     FT_UShort       n_ins;
 351
 352     FT_Byte         *flag, *flag_limit;
 353     FT_Byte         c, count;
 354     FT_Vector       *vec, *vec_limit;
 355     FT_Pos          x, y;
 356     FT_Short        *cont, *cont_limit, last;
 357
 358
 359     /* check that we can add the contours to the glyph */
 360     error = FT_GLYPHLOADER_CHECK_POINTS( gloader, 0, n_contours );
 361     if ( error )
 362       goto Fail;
 363
 364     /* check space for contours array + instructions count */
 365     if ( n_contours >= 0xFFF || p + 2 * n_contours + 2 > limit )
 366       goto Invalid_Outline;
 367
 368     /* reading the contours' endpoints & number of points */
 369     cont       = outline->contours;
 370     cont_limit = cont + n_contours;
 371
 372     last = -1;
 373     for ( ; cont < cont_limit; cont++ )
 374     {
 375       *cont = FT_NEXT_SHORT( p );
 376
 377       if ( *cont <= last )
 378         goto Invalid_Outline;
 379
 380       last = *cont;
 381     }
 382
 383     n_points = last + 1;
 384
 385     FT_TRACE5(( "  # of points: %d\n", n_points ));
 386
 387     /* note that we will add four phantom points later */
 388     error = FT_GLYPHLOADER_CHECK_POINTS( gloader, n_points + 4, 0 );
 389     if ( error )
 390       goto Fail;
 391
 392     /* space checked above */
 393     n_ins = FT_NEXT_USHORT( p );
 394
 395     FT_TRACE5(( "  Instructions size: %u\n", n_ins ));
 396
 397     /* check instructions size */
 398     if ( p + n_ins > limit )
 399     {
 400       FT_TRACE1(( "TT_Load_Simple_Glyph: excessive instruction count\n" ));
 401       error = FT_THROW( Too_Many_Hints );
 402       goto Fail;
 403     }
 404
 405 #ifdef TT_USE_BYTECODE_INTERPRETER
 406
 407     if ( IS_HINTED( load->load_flags ) )
 408     {
 409       TT_ExecContext  exec = load->exec;
 410       FT_Memory       memory = exec->memory;
 411
 412
 413       if ( exec->glyphSize )
 414         FT_FREE( exec->glyphIns );
 415       exec->glyphSize = 0;
 416
 417       /* we don't trust `maxSizeOfInstructions' in the `maxp' table */
 418       /* and thus allocate the bytecode array size by ourselves     */
 419       if ( n_ins )
 420       {
 421         if ( FT_QNEW_ARRAY( exec->glyphIns, n_ins ) )
 422           return error;
 423
 424         FT_MEM_COPY( exec->glyphIns, p, (FT_Long)n_ins );
 425
 426         exec->glyphSize  = n_ins;
 427       }
 428     }
 429
 430 #endif /* TT_USE_BYTECODE_INTERPRETER */
 431
 432     p += n_ins;
 433
 434     /* reading the point tags */
 435     flag       = (FT_Byte*)outline->tags;
 436     flag_limit = flag + n_points;
 437
 438     FT_ASSERT( flag );
 439
 440     while ( flag < flag_limit )
 441     {
 442       if ( p + 1 > limit )
 443         goto Invalid_Outline;
 444
 445       *flag++ = c = FT_NEXT_BYTE( p );
 446       if ( c & REPEAT_FLAG )
 447       {
 448         if ( p + 1 > limit )
 449           goto Invalid_Outline;
 450
 451         count = FT_NEXT_BYTE( p );
 452         if ( flag + (FT_Int)count > flag_limit )
 453           goto Invalid_Outline;
 454
 455         for ( ; count > 0; count-- )
 456           *flag++ = c;
 457       }
 458     }
 459
 460     /* retain the overlap flag */
 461     if ( n_points && outline->tags[0] & OVERLAP_SIMPLE )
 462       gloader->base.outline.flags |= FT_OUTLINE_OVERLAP;
 463
 464     /* reading the X coordinates */
 465
 466     vec       = outline->points;
 467     vec_limit = vec + n_points;
 468     flag      = (FT_Byte*)outline->tags;
 469     x         = 0;
 470
 471     for ( ; vec < vec_limit; vec++, flag++ )
 472     {
 473       FT_Pos   delta = 0;
 474       FT_Byte  f     = *flag;
 475
 476
 477       if ( f & X_SHORT_VECTOR )
 478       {
 479         if ( p + 1 > limit )
 480           goto Invalid_Outline;
 481
 482         delta = (FT_Pos)FT_NEXT_BYTE( p );
 483         if ( !( f & X_POSITIVE ) )
 484           delta = -delta;
 485       }
 486       else if ( !( f & SAME_X ) )
 487       {
 488         if ( p + 2 > limit )
 489           goto Invalid_Outline;
 490
 491         delta = (FT_Pos)FT_NEXT_SHORT( p );
 492       }
 493
 494       x     += delta;
 495       vec->x = x;
 496     }
 497
 498     /* reading the Y coordinates */
 499
 500     vec       = outline->points;
 501     vec_limit = vec + n_points;
 502     flag      = (FT_Byte*)outline->tags;
 503     y         = 0;
 504
 505     for ( ; vec < vec_limit; vec++, flag++ )
 506     {
 507       FT_Pos   delta = 0;
 508       FT_Byte  f     = *flag;
 509
 510
 511       if ( f & Y_SHORT_VECTOR )
 512       {
 513         if ( p + 1 > limit )
 514           goto Invalid_Outline;
 515
 516         delta = (FT_Pos)FT_NEXT_BYTE( p );
 517         if ( !( f & Y_POSITIVE ) )
 518           delta = -delta;
 519       }
 520       else if ( !( f & SAME_Y ) )
 521       {
 522         if ( p + 2 > limit )
 523           goto Invalid_Outline;
 524
 525         delta = (FT_Pos)FT_NEXT_SHORT( p );
 526       }
 527
 528       y     += delta;
 529       vec->y = y;
 530
 531       /* the cast is for stupid compilers */
 532       *flag  = (FT_Byte)( f & ON_CURVE_POINT );
 533     }
 534
 535     outline->n_points   = (FT_Short)n_points;
 536     outline->n_contours = (FT_Short)n_contours;
 537
 538     load->cursor = p;
 539
 540   Fail:
 541     return error;
 542
 543   Invalid_Outline:
 544     error = FT_THROW( Invalid_Outline );
 545     goto Fail;
 546   }
 547
 548
 549   FT_CALLBACK_DEF( FT_Error )
 550   TT_Load_Composite_Glyph( TT_Loader  loader )
 551   {
 552     FT_Error        error;
 553     FT_Byte*        p          = loader->cursor;
 554     FT_Byte*        limit      = loader->limit;
 555     FT_GlyphLoader  gloader    = loader->gloader;
 556     FT_Long         num_glyphs = loader->face->root.num_glyphs;
 557     FT_SubGlyph     subglyph;
 558     FT_UInt         num_subglyphs;
 559
 560
 561     num_subglyphs = 0;
 562
 563     do
 564     {
 565       FT_Fixed  xx, xy, yy, yx;
 566       FT_UInt   count;
 567
 568
 569       /* check that we can load a new subglyph */
 570       error = FT_GlyphLoader_CheckSubGlyphs( gloader, num_subglyphs + 1 );
 571       if ( error )
 572         goto Fail;
 573
 574       /* check space */
 575       if ( p + 4 > limit )
 576         goto Invalid_Composite;
 577
 578       subglyph = gloader->current.subglyphs + num_subglyphs;
 579
 580       subglyph->arg1 = subglyph->arg2 = 0;
 581
 582       subglyph->flags = FT_NEXT_USHORT( p );
 583       subglyph->index = FT_NEXT_USHORT( p );
 584
 585       /* we reject composites that have components */
 586       /* with invalid glyph indices                */
 587       if ( subglyph->index >= num_glyphs )
 588         goto Invalid_Composite;
 589
 590       /* check space */
 591       count = 2;
 592       if ( subglyph->flags & ARGS_ARE_WORDS )
 593         count += 2;
 594       if ( subglyph->flags & WE_HAVE_A_SCALE )
 595         count += 2;
 596       else if ( subglyph->flags & WE_HAVE_AN_XY_SCALE )
 597         count += 4;
 598       else if ( subglyph->flags & WE_HAVE_A_2X2 )
 599         count += 8;
 600
 601       if ( p + count > limit )
 602         goto Invalid_Composite;
 603
 604       /* read arguments */
 605       if ( subglyph->flags & ARGS_ARE_XY_VALUES )
 606       {
 607         if ( subglyph->flags & ARGS_ARE_WORDS )
 608         {
 609           subglyph->arg1 = FT_NEXT_SHORT( p );
 610           subglyph->arg2 = FT_NEXT_SHORT( p );
 611         }
 612         else
 613         {
 614           subglyph->arg1 = FT_NEXT_CHAR( p );
 615           subglyph->arg2 = FT_NEXT_CHAR( p );
 616         }
 617       }
 618       else
 619       {
 620         if ( subglyph->flags & ARGS_ARE_WORDS )
 621         {
 622           subglyph->arg1 = (FT_Int)FT_NEXT_USHORT( p );
 623           subglyph->arg2 = (FT_Int)FT_NEXT_USHORT( p );
 624         }
 625         else
 626         {
 627           subglyph->arg1 = (FT_Int)FT_NEXT_BYTE( p );
 628           subglyph->arg2 = (FT_Int)FT_NEXT_BYTE( p );
 629         }
 630       }
 631
 632       /* read transform */
 633       xx = yy = 0x10000L;
 634       xy = yx = 0;
 635
 636       if ( subglyph->flags & WE_HAVE_A_SCALE )
 637       {
 638         xx = (FT_Fixed)FT_NEXT_SHORT( p ) * 4;
 639         yy = xx;
 640       }
 641       else if ( subglyph->flags & WE_HAVE_AN_XY_SCALE )
 642       {
 643         xx = (FT_Fixed)FT_NEXT_SHORT( p ) * 4;
 644         yy = (FT_Fixed)FT_NEXT_SHORT( p ) * 4;
 645       }
 646       else if ( subglyph->flags & WE_HAVE_A_2X2 )
 647       {
 648         xx = (FT_Fixed)FT_NEXT_SHORT( p ) * 4;
 649         yx = (FT_Fixed)FT_NEXT_SHORT( p ) * 4;
 650         xy = (FT_Fixed)FT_NEXT_SHORT( p ) * 4;
 651         yy = (FT_Fixed)FT_NEXT_SHORT( p ) * 4;
 652       }
 653
 654       subglyph->transform.xx = xx;
 655       subglyph->transform.xy = xy;
 656       subglyph->transform.yx = yx;
 657       subglyph->transform.yy = yy;
 658
 659       num_subglyphs++;
 660
 661     } while ( subglyph->flags & MORE_COMPONENTS );
 662
 663     gloader->current.num_subglyphs = num_subglyphs;
 664     FT_TRACE5(( "  %d component%s\n",
 665                 num_subglyphs,
 666                 num_subglyphs > 1 ? "s" : "" ));
 667
 668 #ifdef FT_DEBUG_LEVEL_TRACE
 669     {
 670       FT_UInt  i;
 671
 672
 673       subglyph = gloader->current.subglyphs;
 674
 675       for ( i = 0; i < num_subglyphs; i++ )
 676       {
 677         if ( num_subglyphs > 1 )
 678           FT_TRACE7(( "    subglyph %d:\n", i ));
 679
 680         FT_TRACE7(( "      glyph index: %d\n", subglyph->index ));
 681
 682         if ( subglyph->flags & ARGS_ARE_XY_VALUES )
 683           FT_TRACE7(( "      offset: x=%d, y=%d\n",
 684                       subglyph->arg1,
 685                       subglyph->arg2 ));
 686         else
 687           FT_TRACE7(( "      matching points: base=%d, component=%d\n",
 688                       subglyph->arg1,
 689                       subglyph->arg2 ));
 690
 691         if ( subglyph->flags & WE_HAVE_A_SCALE )
 692           FT_TRACE7(( "      scaling: %f\n",
 693                       (double)subglyph->transform.xx / 65536 ));
 694         else if ( subglyph->flags & WE_HAVE_AN_XY_SCALE )
 695           FT_TRACE7(( "      scaling: x=%f, y=%f\n",
 696                       (double)subglyph->transform.xx / 65536,
 697                       (double)subglyph->transform.yy / 65536 ));
 698         else if ( subglyph->flags & WE_HAVE_A_2X2 )
 699         {
 700           FT_TRACE7(( "      scaling: xx=%f, yx=%f\n",
 701                       (double)subglyph->transform.xx / 65536,
 702                       (double)subglyph->transform.yx / 65536 ));
 703           FT_TRACE7(( "               xy=%f, yy=%f\n",
 704                       (double)subglyph->transform.xy / 65536,
 705                       (double)subglyph->transform.yy / 65536 ));
 706         }
 707
 708         subglyph++;
 709       }
 710     }
 711 #endif /* FT_DEBUG_LEVEL_TRACE */
 712
 713 #ifdef TT_USE_BYTECODE_INTERPRETER
 714
 715     {
 716       FT_Stream  stream = loader->stream;
 717
 718
 719       /* we must undo the FT_FRAME_ENTER in order to point */
 720       /* to the composite instructions, if we find some.   */
 721       /* We will process them later.                       */
 722       /*                                                   */
 723       loader->ins_pos = (FT_ULong)( FT_STREAM_POS() +
 724                                     p - limit );
 725     }
 726
 727 #endif
 728
 729     loader->cursor = p;
 730
 731   Fail:
 732     return error;
 733
 734   Invalid_Composite:
 735     error = FT_THROW( Invalid_Composite );
 736     goto Fail;
 737   }
 738
 739
 740   FT_LOCAL_DEF( void )
 741   TT_Init_Glyph_Loading( TT_Face  face )
 742   {
 743     face->access_glyph_frame   = TT_Access_Glyph_Frame;
 744     face->read_glyph_header    = TT_Load_Glyph_Header;
 745     face->read_simple_glyph    = TT_Load_Simple_Glyph;
 746     face->read_composite_glyph = TT_Load_Composite_Glyph;
 747     face->forget_glyph_frame   = TT_Forget_Glyph_Frame;
 748   }
 749
 750
 751   static void
 752   tt_prepare_zone( TT_GlyphZone  zone,
 753                    FT_GlyphLoad  load,
 754                    FT_UInt       start_point,
 755                    FT_UInt       start_contour )
 756   {
 757     zone->n_points    = (FT_UShort)load->outline.n_points + 4 -
 758                           (FT_UShort)start_point;
 759     zone->n_contours  = load->outline.n_contours -
 760                           (FT_Short)start_contour;
 761     zone->org         = load->extra_points + start_point;
 762     zone->cur         = load->outline.points + start_point;
 763     zone->orus        = load->extra_points2 + start_point;
 764     zone->tags        = (FT_Byte*)load->outline.tags + start_point;
 765     zone->contours    = (FT_UShort*)load->outline.contours + start_contour;
 766     zone->first_point = (FT_UShort)start_point;
 767   }
 768
 769
 770   /**************************************************************************
 771    *
 772    * @Function:
 773    *   TT_Hint_Glyph
 774    *
 775    * @Description:
 776    *   Hint the glyph using the zone prepared by the caller.  Note that
 777    *   the zone is supposed to include four phantom points.
 778    */
 779   static FT_Error
 780   TT_Hint_Glyph( TT_Loader  loader,
 781                  FT_Bool    is_composite )
 782   {
 783 #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL
 784     TT_Face    face   = loader->face;
 785     TT_Driver  driver = (TT_Driver)FT_FACE_DRIVER( face );
 786 #endif
 787
 788     TT_GlyphZone  zone = &loader->zone;
 789
 790 #ifdef TT_USE_BYTECODE_INTERPRETER
 791     TT_ExecContext  exec  = loader->exec;
 792     FT_Long         n_ins = exec->glyphSize;
 793 #else
 794     FT_UNUSED( is_composite );
 795 #endif
 796
 797
 798 #ifdef TT_USE_BYTECODE_INTERPRETER
 799     /* save original point positions in `org' array */
 800     if ( n_ins > 0 )
 801       FT_ARRAY_COPY( zone->org, zone->cur, zone->n_points );
 802
 803     /* Reset graphics state. */
 804     exec->GS = loader->size->GS;
 805
 806     /* XXX: UNDOCUMENTED! Hinting instructions of a composite glyph */
 807     /*      completely refer to the (already) hinted subglyphs.     */
 808     if ( is_composite )
 809     {
 810       exec->metrics.x_scale = 1 << 16;
 811       exec->metrics.y_scale = 1 << 16;
 812
 813       FT_ARRAY_COPY( zone->orus, zone->cur, zone->n_points );
 814     }
 815     else
 816     {
 817       exec->metrics.x_scale = loader->size->metrics->x_scale;
 818       exec->metrics.y_scale = loader->size->metrics->y_scale;
 819     }
 820 #endif
 821
 822     /* round phantom points */
 823     zone->cur[zone->n_points - 4].x =
 824       FT_PIX_ROUND( zone->cur[zone->n_points - 4].x );
 825     zone->cur[zone->n_points - 3].x =
 826       FT_PIX_ROUND( zone->cur[zone->n_points - 3].x );
 827     zone->cur[zone->n_points - 2].y =
 828       FT_PIX_ROUND( zone->cur[zone->n_points - 2].y );
 829     zone->cur[zone->n_points - 1].y =
 830       FT_PIX_ROUND( zone->cur[zone->n_points - 1].y );
 831
 832 #ifdef TT_USE_BYTECODE_INTERPRETER
 833
 834     if ( n_ins > 0 )
 835     {
 836       FT_Error  error;
 837
 838
 839       TT_Set_CodeRange( exec, tt_coderange_glyph, exec->glyphIns, n_ins );
 840
 841       exec->is_composite = is_composite;
 842       exec->pts          = *zone;
 843
 844       error = TT_Run_Context( exec );
 845       if ( error && exec->pedantic_hinting )
 846         return error;
 847
 848       /* store drop-out mode in bits 5-7; set bit 2 also as a marker */
 849       loader->gloader->current.outline.tags[0] |=
 850         ( exec->GS.scan_type << 5 ) | FT_CURVE_TAG_HAS_SCANMODE;
 851     }
 852
 853 #endif
 854
 855     /* Save possibly modified glyph phantom points unless in v40 backward  */
 856     /* compatibility mode, where no movement on the x axis means no reason */
 857     /* to change bearings or advance widths.                               */
 858
 859 #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL
 860     if ( driver->interpreter_version == TT_INTERPRETER_VERSION_40 &&
 861          exec->backward_compatibility )
 862       return FT_Err_Ok;
 863 #endif
 864
 865     loader->pp1 = zone->cur[zone->n_points - 4];
 866     loader->pp2 = zone->cur[zone->n_points - 3];
 867     loader->pp3 = zone->cur[zone->n_points - 2];
 868     loader->pp4 = zone->cur[zone->n_points - 1];
 869
 870     return FT_Err_Ok;
 871   }
 872
 873
 874   /**************************************************************************
 875    *
 876    * @Function:
 877    *   TT_Process_Simple_Glyph
 878    *
 879    * @Description:
 880    *   Once a simple glyph has been loaded, it needs to be processed.
 881    *   Usually, this means scaling and hinting through bytecode
 882    *   interpretation.
 883    */
 884   static FT_Error
 885   TT_Process_Simple_Glyph( TT_Loader  loader )
 886   {
 887     FT_Error        error    = FT_Err_Ok;
 888     FT_GlyphLoader  gloader  = loader->gloader;
 889     FT_Outline*     outline  = &gloader->current.outline;
 890     FT_Int          n_points = outline->n_points;
 891
 892 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
 893     FT_Memory   memory    = loader->face->root.memory;
 894     FT_Vector*  unrounded = NULL;
 895 #endif
 896
 897
 898     /* set phantom points */
 899     outline->points[n_points    ] = loader->pp1;
 900     outline->points[n_points + 1] = loader->pp2;
 901     outline->points[n_points + 2] = loader->pp3;
 902     outline->points[n_points + 3] = loader->pp4;
 903
 904     n_points += 4;
 905
 906 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
 907
 908     if ( !IS_DEFAULT_INSTANCE( FT_FACE( loader->face ) ) )
 909     {
 910       if ( FT_QNEW_ARRAY( unrounded, n_points ) )
 911         goto Exit;
 912
 913       /* Deltas apply to the unscaled data. */
 914       error = TT_Vary_Apply_Glyph_Deltas( loader,
 915                                           outline,
 916                                           unrounded );
 917       if ( error )
 918         goto Exit;
 919     }
 920
 921 #endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */
 922
 923     if ( IS_HINTED( loader->load_flags ) )
 924     {
 925       tt_prepare_zone( &loader->zone, &gloader->current, 0, 0 );
 926
 927       FT_ARRAY_COPY( loader->zone.orus, loader->zone.cur,
 928                      loader->zone.n_points );
 929     }
 930
 931     {
 932       FT_Vector*  vec   = outline->points;
 933       FT_Vector*  limit = outline->points + n_points;
 934
 935       FT_Fixed  x_scale = 0; /* pacify compiler */
 936       FT_Fixed  y_scale = 0;
 937
 938       FT_Bool  do_scale = FALSE;
 939
 940
 941       {
 942         /* scale the glyph */
 943         if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 )
 944         {
 945           x_scale = loader->size->metrics->x_scale;
 946           y_scale = loader->size->metrics->y_scale;
 947
 948           do_scale = TRUE;
 949         }
 950       }
 951
 952       if ( do_scale )
 953       {
 954 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
 955         if ( !IS_DEFAULT_INSTANCE( FT_FACE( loader->face ) ) )
 956         {
 957           FT_Vector*  u = unrounded;
 958
 959
 960           for ( ; vec < limit; vec++, u++ )
 961           {
 962             vec->x = ADD_LONG( FT_MulFix( u->x, x_scale ), 32 ) >> 6;
 963             vec->y = ADD_LONG( FT_MulFix( u->y, y_scale ), 32 ) >> 6;
 964           }
 965         }
 966         else
 967 #endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */
 968         {
 969           for ( ; vec < limit; vec++ )
 970           {
 971             vec->x = FT_MulFix( vec->x, x_scale );
 972             vec->y = FT_MulFix( vec->y, y_scale );
 973           }
 974         }
 975       }
 976
 977 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
 978       /* if we have a HVAR table, `pp1' and/or `pp2' */
 979       /* are already adjusted but unscaled           */
 980       if ( ( loader->face->variation_support & TT_FACE_FLAG_VAR_HADVANCE ) &&
 981            IS_HINTED( loader->load_flags )                                 )
 982       {
 983         loader->pp1.x = FT_MulFix( loader->pp1.x, x_scale );
 984         loader->pp2.x = FT_MulFix( loader->pp2.x, x_scale );
 985         /* pp1.y and pp2.y are always zero */
 986       }
 987       else
 988 #endif
 989       {
 990         loader->pp1 = outline->points[n_points - 4];
 991         loader->pp2 = outline->points[n_points - 3];
 992       }
 993
 994 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
 995       /* if we have a VVAR table, `pp3' and/or `pp4' */
 996       /* are already adjusted but unscaled           */
 997       if ( ( loader->face->variation_support & TT_FACE_FLAG_VAR_VADVANCE ) &&
 998            IS_HINTED( loader->load_flags )                                 )
 999       {
1000         loader->pp3.x = FT_MulFix( loader->pp3.x, x_scale );
1001         loader->pp3.y = FT_MulFix( loader->pp3.y, y_scale );
1002         loader->pp4.x = FT_MulFix( loader->pp4.x, x_scale );
1003         loader->pp4.y = FT_MulFix( loader->pp4.y, y_scale );
1004       }
1005       else
1006 #endif
1007       {
1008         loader->pp3 = outline->points[n_points - 2];
1009         loader->pp4 = outline->points[n_points - 1];
1010       }
1011     }
1012
1013     if ( IS_HINTED( loader->load_flags ) )
1014       error = TT_Hint_Glyph( loader, 0 );
1015
1016 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
1017   Exit:
1018     FT_FREE( unrounded );
1019 #endif
1020
1021     return error;
1022   }
1023
1024
1025   /**************************************************************************
1026    *
1027    * @Function:
1028    *   TT_Process_Composite_Component
1029    *
1030    * @Description:
1031    *   Once a composite component has been loaded, it needs to be
1032    *   processed.  Usually, this means transforming and translating.
1033    */
1034   static FT_Error
1035   TT_Process_Composite_Component( TT_Loader    loader,
1036                                   FT_SubGlyph  subglyph,
1037                                   FT_UInt      start_point,
1038                                   FT_UInt      num_base_points )
1039   {
1040     FT_GlyphLoader  gloader = loader->gloader;
1041     FT_Outline      current;
1042     FT_Bool         have_scale;
1043     FT_Pos          x, y;
1044
1045
1046     current.points   = gloader->base.outline.points +
1047                          num_base_points;
1048     current.n_points = gloader->base.outline.n_points -
1049                          (short)num_base_points;
1050
1051     have_scale = FT_BOOL( subglyph->flags & ( WE_HAVE_A_SCALE     |
1052                                               WE_HAVE_AN_XY_SCALE |
1053                                               WE_HAVE_A_2X2       ) );
1054
1055     /* perform the transform required for this subglyph */
1056     if ( have_scale )
1057       FT_Outline_Transform( &current, &subglyph->transform );
1058
1059     /* get offset */
1060     if ( !( subglyph->flags & ARGS_ARE_XY_VALUES ) )
1061     {
1062       FT_UInt     num_points = (FT_UInt)gloader->base.outline.n_points;
1063       FT_UInt     k = (FT_UInt)subglyph->arg1;
1064       FT_UInt     l = (FT_UInt)subglyph->arg2;
1065       FT_Vector*  p1;
1066       FT_Vector*  p2;
1067
1068
1069       /* match l-th point of the newly loaded component to the k-th point */
1070       /* of the previously loaded components.                             */
1071
1072       /* change to the point numbers used by our outline */
1073       k += start_point;
1074       l += num_base_points;
1075       if ( k >= num_base_points ||
1076            l >= num_points      )
1077         return FT_THROW( Invalid_Composite );
1078
1079       p1 = gloader->base.outline.points + k;
1080       p2 = gloader->base.outline.points + l;
1081
1082       x = SUB_LONG( p1->x, p2->x );
1083       y = SUB_LONG( p1->y, p2->y );
1084     }
1085     else
1086     {
1087       x = subglyph->arg1;
1088       y = subglyph->arg2;
1089
1090       if ( !x && !y )
1091         return FT_Err_Ok;
1092
1093       /* Use a default value dependent on                                  */
1094       /* TT_CONFIG_OPTION_COMPONENT_OFFSET_SCALED.  This is useful for old */
1095       /* TT fonts which don't set the xxx_COMPONENT_OFFSET bit.            */
1096
1097       if ( have_scale &&
1098 #ifdef TT_CONFIG_OPTION_COMPONENT_OFFSET_SCALED
1099            !( subglyph->flags & UNSCALED_COMPONENT_OFFSET ) )
1100 #else
1101             ( subglyph->flags & SCALED_COMPONENT_OFFSET ) )
1102 #endif
1103       {
1104
1105 #if 0
1106
1107         /********************************************************************
1108          *
1109          * This algorithm is what Apple documents.  But it doesn't work.
1110          */
1111         int  a = subglyph->transform.xx > 0 ?  subglyph->transform.xx
1112                                             : -subglyph->transform.xx;
1113         int  b = subglyph->transform.yx > 0 ?  subglyph->transform.yx
1114                                             : -subglyph->transform.yx;
1115         int  c = subglyph->transform.xy > 0 ?  subglyph->transform.xy
1116                                             : -subglyph->transform.xy;
1117         int  d = subglyph->transform.yy > 0 ?  subglyph->transform.yy
1118                                             : -subglyph->transform.yy;
1119         int  m = a > b ? a : b;
1120         int  n = c > d ? c : d;
1121
1122
1123         if ( a - b <= 33 && a - b >= -33 )
1124           m *= 2;
1125         if ( c - d <= 33 && c - d >= -33 )
1126           n *= 2;
1127         x = FT_MulFix( x, m );
1128         y = FT_MulFix( y, n );
1129
1130 #else /* 1 */
1131
1132         /********************************************************************
1133          *
1134          * This algorithm is a guess and works much better than the above.
1135          */
1136         FT_Fixed  mac_xscale = FT_Hypot( subglyph->transform.xx,
1137                                          subglyph->transform.xy );
1138         FT_Fixed  mac_yscale = FT_Hypot( subglyph->transform.yy,
1139                                          subglyph->transform.yx );
1140
1141
1142         x = FT_MulFix( x, mac_xscale );
1143         y = FT_MulFix( y, mac_yscale );
1144
1145 #endif /* 1 */
1146
1147       }
1148
1149       if ( !( loader->load_flags & FT_LOAD_NO_SCALE ) )
1150       {
1151         FT_Fixed  x_scale = loader->size->metrics->x_scale;
1152         FT_Fixed  y_scale = loader->size->metrics->y_scale;
1153
1154
1155         x = FT_MulFix( x, x_scale );
1156         y = FT_MulFix( y, y_scale );
1157
1158         if ( subglyph->flags & ROUND_XY_TO_GRID )
1159         {
1160           TT_Face    face   = loader->face;
1161           TT_Driver  driver = (TT_Driver)FT_FACE_DRIVER( face );
1162
1163
1164           if ( IS_HINTED( loader->load_flags ) )
1165           {
1166             /*
1167              * We round the horizontal offset only if there is hinting along
1168              * the x axis; this corresponds to integer advance width values.
1169              *
1170              * Theoretically, a glyph's bytecode can toggle ClearType's
1171              * `backward compatibility' mode, which would allow modification
1172              * of the advance width.  In reality, however, applications
1173              * neither allow nor expect modified advance widths if subpixel
1174              * rendering is active.
1175              *
1176              */
1177             if ( driver->interpreter_version == TT_INTERPRETER_VERSION_35 )
1178               x = FT_PIX_ROUND( x );
1179
1180             y = FT_PIX_ROUND( y );
1181           }
1182         }
1183       }
1184     }
1185
1186     if ( x || y )
1187       FT_Outline_Translate( &current, x, y );
1188
1189     return FT_Err_Ok;
1190   }
1191
1192
1193   /**************************************************************************
1194    *
1195    * @Function:
1196    *   TT_Process_Composite_Glyph
1197    *
1198    * @Description:
1199    *   This is slightly different from TT_Process_Simple_Glyph, in that
1200    *   its sole purpose is to hint the glyph.  Thus this function is
1201    *   only available when bytecode interpreter is enabled.
1202    */
1203   static FT_Error
1204   TT_Process_Composite_Glyph( TT_Loader  loader,
1205                               FT_UInt    start_point,
1206                               FT_UInt    start_contour )
1207   {
1208     FT_Error     error;
1209     FT_Outline*  outline = &loader->gloader->base.outline;
1210     FT_Stream    stream = loader->stream;
1211     FT_UShort    n_ins;
1212     FT_UInt      i;
1213
1214
1215     /* make room for phantom points */
1216     error = FT_GLYPHLOADER_CHECK_POINTS( loader->gloader,
1217                                          outline->n_points + 4,
1218                                          0 );
1219     if ( error )
1220       return error;
1221
1222     outline->points[outline->n_points    ] = loader->pp1;
1223     outline->points[outline->n_points + 1] = loader->pp2;
1224     outline->points[outline->n_points + 2] = loader->pp3;
1225     outline->points[outline->n_points + 3] = loader->pp4;
1226
1227 #ifdef TT_USE_BYTECODE_INTERPRETER
1228
1229     {
1230       TT_ExecContext  exec = loader->exec;
1231       FT_Memory       memory = exec->memory;
1232
1233
1234       if ( exec->glyphSize )
1235         FT_FREE( exec->glyphIns );
1236       exec->glyphSize = 0;
1237
1238       /* TT_Load_Composite_Glyph only gives us the offset of instructions */
1239       /* so we read them here                                             */
1240       if ( FT_STREAM_SEEK( loader->ins_pos ) ||
1241            FT_READ_USHORT( n_ins )           )
1242         return error;
1243
1244       FT_TRACE5(( "  Instructions size = %hu\n", n_ins ));
1245
1246       if ( !n_ins )
1247         return FT_Err_Ok;
1248
1249       /* don't trust `maxSizeOfInstructions'; */
1250       /* only do a rough safety check         */
1251       if ( n_ins > loader->byte_len )
1252       {
1253         FT_TRACE1(( "TT_Process_Composite_Glyph:"
1254                     " too many instructions (%hu) for glyph with length %u\n",
1255                     n_ins, loader->byte_len ));
1256         return FT_THROW( Too_Many_Hints );
1257       }
1258
1259       if ( FT_QNEW_ARRAY( exec->glyphIns, n_ins )  ||
1260            FT_STREAM_READ( exec->glyphIns, n_ins ) )
1261         return error;
1262
1263       exec->glyphSize = n_ins;
1264     }
1265
1266 #endif
1267
1268     tt_prepare_zone( &loader->zone, &loader->gloader->base,
1269                      start_point, start_contour );
1270
1271     /* Some points are likely touched during execution of  */
1272     /* instructions on components.  So let's untouch them. */
1273     for ( i = 0; i < loader->zone.n_points - 4U; i++ )
1274       loader->zone.tags[i] &= ~FT_CURVE_TAG_TOUCH_BOTH;
1275
1276     return TT_Hint_Glyph( loader, 1 );
1277   }
1278
1279
1280   /*
1281    * Calculate the phantom points
1282    *
1283    * Defining the right side bearing (rsb) as
1284    *
1285    *   rsb = aw - (lsb + xmax - xmin)
1286    *
1287    * (with `aw' the advance width, `lsb' the left side bearing, and `xmin'
1288    * and `xmax' the glyph's minimum and maximum x value), the OpenType
1289    * specification defines the initial position of horizontal phantom points
1290    * as
1291    *
1292    *   pp1 = (round(xmin - lsb), 0)      ,
1293    *   pp2 = (round(pp1 + aw), 0)        .
1294    *
1295    * Note that the rounding to the grid (in the device space) is not
1296    * documented currently in the specification.
1297    *
1298    * However, the specification lacks the precise definition of vertical
1299    * phantom points.  Greg Hitchcock provided the following explanation.
1300    *
1301    * - a `vmtx' table is present
1302    *
1303    *   For any glyph, the minimum and maximum y values (`ymin' and `ymax')
1304    *   are given in the `glyf' table, the top side bearing (tsb) and advance
1305    *   height (ah) are given in the `vmtx' table.  The bottom side bearing
1306    *   (bsb) is then calculated as
1307    *
1308    *     bsb = ah - (tsb + ymax - ymin)       ,
1309    *
1310    *   and the initial position of vertical phantom points is
1311    *
1312    *     pp3 = (x, round(ymax + tsb))       ,
1313    *     pp4 = (x, round(pp3 - ah))         .
1314    *
1315    *   See below for value `x'.
1316    *
1317    * - no `vmtx' table in the font
1318    *
1319    *   If there is an `OS/2' table, we set
1320    *
1321    *     DefaultAscender = sTypoAscender       ,
1322    *     DefaultDescender = sTypoDescender     ,
1323    *
1324    *   otherwise we use data from the `hhea' table:
1325    *
1326    *     DefaultAscender = Ascender         ,
1327    *     DefaultDescender = Descender       .
1328    *
1329    *   With these two variables we can now set
1330    *
1331    *     ah = DefaultAscender - sDefaultDescender    ,
1332    *     tsb = DefaultAscender - yMax                ,
1333    *
1334    *   and proceed as if a `vmtx' table was present.
1335    *
1336    * Usually we have
1337    *
1338    *   x = aw / 2      ,                                                (1)
1339    *
1340    * but there is one compatibility case where it can be set to
1341    *
1342    *   x = -DefaultDescender -
1343    *         ((DefaultAscender - DefaultDescender - aw) / 2)     .      (2)
1344    *
1345    * and another one with
1346    *
1347    *   x = 0     .                                                      (3)
1348    *
1349    * In Windows, the history of those values is quite complicated,
1350    * depending on the hinting engine (that is, the graphics framework).
1351    *
1352    *   framework        from                 to       formula
1353    *  ----------------------------------------------------------
1354    *    GDI       Windows 98               current      (1)
1355    *              (Windows 2000 for NT)
1356    *    GDI+      Windows XP               Windows 7    (2)
1357    *    GDI+      Windows 8                current      (3)
1358    *    DWrite    Windows 7                current      (3)
1359    *
1360    * For simplicity, FreeType uses (1) for grayscale subpixel hinting and
1361    * (3) for everything else.
1362    *
1363    */
1364   static void
1365   tt_loader_set_pp( TT_Loader  loader )
1366   {
1367     loader->pp1.x = loader->bbox.xMin - loader->left_bearing;
1368     loader->pp1.y = 0;
1369     loader->pp2.x = loader->pp1.x + loader->advance;
1370     loader->pp2.y = 0;
1371
1372     loader->pp3.x = 0;
1373     loader->pp3.y = loader->bbox.yMax + loader->top_bearing;
1374     loader->pp4.x = 0;
1375     loader->pp4.y = loader->pp3.y - loader->vadvance;
1376
1377 #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL
1378     {
1379       TT_Driver driver = (TT_Driver)FT_FACE_DRIVER( loader->face );
1380
1381
1382       if ( driver->interpreter_version == TT_INTERPRETER_VERSION_40 &&
1383            loader->exec                                             &&
1384            loader->exec->subpixel_hinting_lean                      &&
1385            loader->exec->grayscale_cleartype                        )
1386       {
1387         loader->pp3.x = loader->advance / 2;
1388         loader->pp4.x = loader->advance / 2;
1389       }
1390     }
1391 #endif
1392   }
1393
1394
1395   /* a utility function to retrieve i-th node from given FT_List */
1396   static FT_ListNode
1397   ft_list_get_node_at( FT_List  list,
1398                        FT_UInt  idx )
1399   {
1400     FT_ListNode  cur;
1401
1402
1403     if ( !list )
1404       return NULL;
1405
1406     for ( cur = list->head; cur; cur = cur->next )
1407     {
1408       if ( !idx )
1409         return cur;
1410
1411       idx--;
1412     }
1413
1414     return NULL;
1415   }
1416
1417
1418   /**************************************************************************
1419    *
1420    * @Function:
1421    *   load_truetype_glyph
1422    *
1423    * @Description:
1424    *   Loads a given truetype glyph.  Handles composites and uses a
1425    *   TT_Loader object.
1426    */
1427   static FT_Error
1428   load_truetype_glyph( TT_Loader  loader,
1429                        FT_UInt    glyph_index,
1430                        FT_UInt    recurse_count,
1431                        FT_Bool    header_only )
1432   {
1433     FT_Error        error   = FT_Err_Ok;
1434     FT_Fixed        x_scale, y_scale;
1435     FT_ULong        offset;
1436     TT_Face         face    = loader->face;
1437     FT_GlyphLoader  gloader = loader->gloader;
1438
1439     FT_Bool  opened_frame = 0;
1440
1441 #ifdef FT_CONFIG_OPTION_INCREMENTAL
1442     FT_StreamRec    inc_stream;
1443     FT_Data         glyph_data;
1444     FT_Bool         glyph_data_loaded = 0;
1445 #endif
1446
1447
1448 #ifdef FT_DEBUG_LEVEL_TRACE
1449     if ( recurse_count )
1450       FT_TRACE5(( "  nesting level: %d\n", recurse_count ));
1451 #endif
1452
1453     /* some fonts have an incorrect value of `maxComponentDepth' */
1454     if ( recurse_count > face->max_profile.maxComponentDepth )
1455     {
1456       FT_TRACE1(( "load_truetype_glyph: maxComponentDepth set to %d\n",
1457                   recurse_count ));
1458       face->max_profile.maxComponentDepth = (FT_UShort)recurse_count;
1459     }
1460
1461 #ifndef FT_CONFIG_OPTION_INCREMENTAL
1462     /* check glyph index */
1463     if ( glyph_index >= (FT_UInt)face->root.num_glyphs )
1464     {
1465       error = FT_THROW( Invalid_Glyph_Index );
1466       goto Exit;
1467     }
1468 #endif
1469
1470     loader->glyph_index = glyph_index;
1471
1472     if ( loader->load_flags & FT_LOAD_NO_SCALE )
1473     {
1474       x_scale = 0x10000L;
1475       y_scale = 0x10000L;
1476     }
1477     else
1478     {
1479       x_scale = loader->size->metrics->x_scale;
1480       y_scale = loader->size->metrics->y_scale;
1481     }
1482
1483     /* Set `offset' to the start of the glyph relative to the start of */
1484     /* the `glyf' table, and `byte_len' to the length of the glyph in  */
1485     /* bytes.                                                          */
1486
1487 #ifdef FT_CONFIG_OPTION_INCREMENTAL
1488
1489     /* If we are loading glyph data via the incremental interface, set */
1490     /* the loader stream to a memory stream reading the data returned  */
1491     /* by the interface.                                               */
1492     if ( face->root.internal->incremental_interface )
1493     {
1494       error = face->root.internal->incremental_interface->funcs->get_glyph_data(
1495                 face->root.internal->incremental_interface->object,
1496                 glyph_index, &glyph_data );
1497       if ( error )
1498         goto Exit;
1499
1500       glyph_data_loaded = 1;
1501       offset            = 0;
1502       loader->byte_len  = glyph_data.length;
1503
1504       FT_ZERO( &inc_stream );
1505       FT_Stream_OpenMemory( &inc_stream,
1506                             glyph_data.pointer,
1507                             glyph_data.length );
1508
1509       loader->stream = &inc_stream;
1510     }
1511     else
1512
1513 #endif /* FT_CONFIG_OPTION_INCREMENTAL */
1514     {
1515       FT_ULong  len;
1516
1517
1518       offset = tt_face_get_location( FT_FACE( face ), glyph_index, &len );
1519
1520       loader->byte_len = (FT_UInt)len;
1521     }
1522
1523     if ( loader->byte_len > 0 )
1524     {
1525 #ifdef FT_CONFIG_OPTION_INCREMENTAL
1526       /* for the incremental interface, `glyf_offset' is always zero */
1527       if ( !face->glyf_offset                          &&
1528            !face->root.internal->incremental_interface )
1529 #else
1530       if ( !face->glyf_offset )
1531 #endif /* FT_CONFIG_OPTION_INCREMENTAL */
1532       {
1533         FT_TRACE2(( "no `glyf' table but non-zero `loca' entry\n" ));
1534         error = FT_THROW( Invalid_Table );
1535         goto Exit;
1536       }
1537
1538       error = face->access_glyph_frame( loader, glyph_index,
1539                                         face->glyf_offset + offset,
1540                                         loader->byte_len );
1541       if ( error )
1542         goto Exit;
1543
1544       /* read glyph header first */
1545       error = face->read_glyph_header( loader );
1546
1547       face->forget_glyph_frame( loader );
1548
1549       if ( error )
1550         goto Exit;
1551     }
1552
1553     /* a space glyph */
1554     if ( loader->byte_len == 0 || loader->n_contours == 0 )
1555     {
1556       loader->bbox.xMin = 0;
1557       loader->bbox.xMax = 0;
1558       loader->bbox.yMin = 0;
1559       loader->bbox.yMax = 0;
1560     }
1561
1562     /* the metrics must be computed after loading the glyph header */
1563     /* since we need the glyph's `yMax' value in case the vertical */
1564     /* metrics must be emulated                                    */
1565     error = tt_get_metrics( loader, glyph_index );
1566     if ( error )
1567       goto Exit;
1568
1569     if ( header_only )
1570       goto Exit;
1571
1572     if ( loader->byte_len == 0 || loader->n_contours == 0 )
1573     {
1574 #ifdef FT_CONFIG_OPTION_INCREMENTAL
1575       tt_get_metrics_incremental( loader, glyph_index );
1576 #endif
1577       tt_loader_set_pp( loader );
1578
1579
1580 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
1581
1582       if ( FT_IS_NAMED_INSTANCE( FT_FACE( face ) ) ||
1583            FT_IS_VARIATION( FT_FACE( face ) )      )
1584       {
1585         /* a small outline structure with four elements for */
1586         /* communication with `TT_Vary_Apply_Glyph_Deltas'  */
1587         FT_Vector   points[4];
1588         FT_Outline  outline;
1589
1590         /* unrounded values */
1591         FT_Vector  unrounded[4] = { {0, 0}, {0, 0}, {0, 0}, {0, 0} };
1592
1593
1594         points[0] = loader->pp1;
1595         points[1] = loader->pp2;
1596         points[2] = loader->pp3;
1597         points[3] = loader->pp4;
1598
1599         outline.n_points   = 0;
1600         outline.n_contours = 0;
1601         outline.points     = points;
1602         outline.tags       = NULL;
1603         outline.contours   = NULL;
1604
1605         /* this must be done before scaling */
1606         error = TT_Vary_Apply_Glyph_Deltas( loader,
1607                                             &outline,
1608                                             unrounded );
1609         if ( error )
1610           goto Exit;
1611       }
1612
1613 #endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */
1614
1615       /* scale phantom points, if necessary; */
1616       /* they get rounded in `TT_Hint_Glyph' */
1617       if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 )
1618       {
1619         loader->pp1.x = FT_MulFix( loader->pp1.x, x_scale );
1620         loader->pp2.x = FT_MulFix( loader->pp2.x, x_scale );
1621         /* pp1.y and pp2.y are always zero */
1622
1623         loader->pp3.x = FT_MulFix( loader->pp3.x, x_scale );
1624         loader->pp3.y = FT_MulFix( loader->pp3.y, y_scale );
1625         loader->pp4.x = FT_MulFix( loader->pp4.x, x_scale );
1626         loader->pp4.y = FT_MulFix( loader->pp4.y, y_scale );
1627       }
1628
1629       error = FT_Err_Ok;
1630       goto Exit;
1631     }
1632
1633 #ifdef FT_CONFIG_OPTION_INCREMENTAL
1634     tt_get_metrics_incremental( loader, glyph_index );
1635 #endif
1636     tt_loader_set_pp( loader );
1637
1638
1639     /***********************************************************************/
1640     /***********************************************************************/
1641     /***********************************************************************/
1642
1643     /* we now open a frame again, right after the glyph header */
1644     /* (which consists of 10 bytes)                            */
1645     error = face->access_glyph_frame( loader, glyph_index,
1646                                       face->glyf_offset + offset + 10,
1647                                       loader->byte_len - 10 );
1648     if ( error )
1649       goto Exit;
1650
1651     opened_frame = 1;
1652
1653     /* if it is a simple glyph, load it */
1654
1655     if ( loader->n_contours > 0 )
1656     {
1657       error = face->read_simple_glyph( loader );
1658       if ( error )
1659         goto Exit;
1660
1661       /* all data have been read */
1662       face->forget_glyph_frame( loader );
1663       opened_frame = 0;
1664
1665       error = TT_Process_Simple_Glyph( loader );
1666       if ( error )
1667         goto Exit;
1668
1669       FT_GlyphLoader_Add( gloader );
1670     }
1671
1672     /***********************************************************************/
1673     /***********************************************************************/
1674     /***********************************************************************/
1675
1676     /* otherwise, load a composite! */
1677     else if ( loader->n_contours < 0 )
1678     {
1679       FT_Memory  memory = face->root.memory;
1680
1681       FT_UInt   start_point;
1682       FT_UInt   start_contour;
1683       FT_ULong  ins_pos;  /* position of composite instructions, if any */
1684
1685       FT_ListNode  node, node2;
1686
1687
1688       /* normalize the `n_contours' value */
1689       loader->n_contours = -1;
1690
1691       /*
1692        * We store the glyph index directly in the `node->data' pointer,
1693        * following the glib solution (cf. macro `GUINT_TO_POINTER') with a
1694        * double cast to make this portable.  Note, however, that this needs
1695        * pointers with a width of at least 32 bits.
1696        */
1697
1698       /* clear the nodes filled by sibling chains */
1699       node = ft_list_get_node_at( &loader->composites, recurse_count );
1700       for ( node2 = node; node2; node2 = node2->next )
1701         node2->data = (void*)-1;
1702
1703       /* check whether we already have a composite glyph with this index */
1704       if ( FT_List_Find( &loader->composites,
1705                          FT_UINT_TO_POINTER( glyph_index ) ) )
1706       {
1707         FT_TRACE1(( "TT_Load_Composite_Glyph:"
1708                     " infinite recursion detected\n" ));
1709         error = FT_THROW( Invalid_Composite );
1710         goto Exit;
1711       }
1712
1713       else if ( node )
1714         node->data = FT_UINT_TO_POINTER( glyph_index );
1715
1716       else
1717       {
1718         if ( FT_QNEW( node ) )
1719           goto Exit;
1720         node->data = FT_UINT_TO_POINTER( glyph_index );
1721         FT_List_Add( &loader->composites, node );
1722       }
1723
1724       start_point   = (FT_UInt)gloader->base.outline.n_points;
1725       start_contour = (FT_UInt)gloader->base.outline.n_contours;
1726
1727       /* for each subglyph, read composite header */
1728       error = face->read_composite_glyph( loader );
1729       if ( error )
1730         goto Exit;
1731
1732       /* store the offset of instructions */
1733       ins_pos = loader->ins_pos;
1734
1735       /* all data we need are read */
1736       face->forget_glyph_frame( loader );
1737       opened_frame = 0;
1738
1739 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
1740
1741       if ( FT_IS_NAMED_INSTANCE( FT_FACE( face ) ) ||
1742            FT_IS_VARIATION( FT_FACE( face ) )      )
1743       {
1744         short        i, limit;
1745         FT_SubGlyph  subglyph;
1746
1747         FT_Outline  outline = { 0, 0, NULL, NULL, NULL, 0 };
1748         FT_Vector*  unrounded = NULL;
1749
1750
1751         limit = (short)gloader->current.num_subglyphs;
1752
1753         /* construct an outline structure for              */
1754         /* communication with `TT_Vary_Apply_Glyph_Deltas' */
1755         if ( FT_QNEW_ARRAY( outline.points, limit + 4 ) ||
1756              FT_QNEW_ARRAY( outline.tags, limit )       ||
1757              FT_QNEW_ARRAY( outline.contours, limit )   ||
1758              FT_QNEW_ARRAY( unrounded, limit + 4 )      )
1759           goto Exit1;
1760
1761         outline.n_contours = outline.n_points = limit;
1762
1763         subglyph = gloader->current.subglyphs;
1764
1765         for ( i = 0; i < limit; i++, subglyph++ )
1766         {
1767           /* applying deltas for anchor points doesn't make sense, */
1768           /* but we don't have to specially check this since       */
1769           /* unused delta values are zero anyways                  */
1770           outline.points[i].x = subglyph->arg1;
1771           outline.points[i].y = subglyph->arg2;
1772           outline.tags[i]     = ON_CURVE_POINT;
1773           outline.contours[i] = i;
1774         }
1775
1776         outline.points[i++] = loader->pp1;
1777         outline.points[i++] = loader->pp2;
1778         outline.points[i++] = loader->pp3;
1779         outline.points[i  ] = loader->pp4;
1780
1781         /* this call provides additional offsets */
1782         /* for each component's translation      */
1783         if ( FT_SET_ERROR( TT_Vary_Apply_Glyph_Deltas( loader,
1784                                                        &outline,
1785                                                        unrounded ) ) )
1786           goto Exit1;
1787
1788         subglyph = gloader->current.subglyphs;
1789
1790         for ( i = 0; i < limit; i++, subglyph++ )
1791         {
1792           if ( subglyph->flags & ARGS_ARE_XY_VALUES )
1793           {
1794             subglyph->arg1 = (FT_Int16)outline.points[i].x;
1795             subglyph->arg2 = (FT_Int16)outline.points[i].y;
1796           }
1797         }
1798
1799       Exit1:
1800         FT_FREE( outline.points );
1801         FT_FREE( outline.tags );
1802         FT_FREE( outline.contours );
1803         FT_FREE( unrounded );
1804
1805         if ( error )
1806           goto Exit;
1807       }
1808
1809 #endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */
1810
1811       /* scale phantom points, if necessary; */
1812       /* they get rounded in `TT_Hint_Glyph' */
1813       if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 )
1814       {
1815         loader->pp1.x = FT_MulFix( loader->pp1.x, x_scale );
1816         loader->pp2.x = FT_MulFix( loader->pp2.x, x_scale );
1817         /* pp1.y and pp2.y are always zero */
1818
1819         loader->pp3.x = FT_MulFix( loader->pp3.x, x_scale );
1820         loader->pp3.y = FT_MulFix( loader->pp3.y, y_scale );
1821         loader->pp4.x = FT_MulFix( loader->pp4.x, x_scale );
1822         loader->pp4.y = FT_MulFix( loader->pp4.y, y_scale );
1823       }
1824
1825       /* if the flag FT_LOAD_NO_RECURSE is set, we return the subglyph */
1826       /* `as is' in the glyph slot (the client application will be     */
1827       /* responsible for interpreting these data)...                   */
1828       if ( loader->load_flags & FT_LOAD_NO_RECURSE )
1829       {
1830         FT_GlyphLoader_Add( gloader );
1831         loader->glyph->format = FT_GLYPH_FORMAT_COMPOSITE;
1832
1833         goto Exit;
1834       }
1835
1836       /*********************************************************************/
1837       /*********************************************************************/
1838       /*********************************************************************/
1839
1840       {
1841         FT_UInt      n, num_base_points;
1842         FT_SubGlyph  subglyph       = NULL;
1843
1844         FT_UInt      num_points     = start_point;
1845         FT_UInt      num_subglyphs  = gloader->current.num_subglyphs;
1846         FT_UInt      num_base_subgs = gloader->base.num_subglyphs;
1847
1848         FT_Stream    old_stream     = loader->stream;
1849         FT_UInt      old_byte_len   = loader->byte_len;
1850
1851
1852         FT_GlyphLoader_Add( gloader );
1853
1854         /* read each subglyph independently */
1855         for ( n = 0; n < num_subglyphs; n++ )
1856         {
1857           FT_Vector  pp[4];
1858
1859           FT_Int  linear_hadvance;
1860           FT_Int  linear_vadvance;
1861
1862
1863           /* Each time we call `load_truetype_glyph' in this loop, the */
1864           /* value of `gloader.base.subglyphs' can change due to table */
1865           /* reallocations.  We thus need to recompute the subglyph    */
1866           /* pointer on each iteration.                                */
1867           subglyph = gloader->base.subglyphs + num_base_subgs + n;
1868
1869           pp[0] = loader->pp1;
1870           pp[1] = loader->pp2;
1871           pp[2] = loader->pp3;
1872           pp[3] = loader->pp4;
1873
1874           linear_hadvance = loader->linear;
1875           linear_vadvance = loader->vadvance;
1876
1877           num_base_points = (FT_UInt)gloader->base.outline.n_points;
1878
1879           error = load_truetype_glyph( loader,
1880                                        (FT_UInt)subglyph->index,
1881                                        recurse_count + 1,
1882                                        FALSE );
1883           if ( error )
1884             goto Exit;
1885
1886           /* restore subglyph pointer */
1887           subglyph = gloader->base.subglyphs + num_base_subgs + n;
1888
1889           /* restore phantom points if necessary */
1890           if ( !( subglyph->flags & USE_MY_METRICS ) )
1891           {
1892             loader->pp1 = pp[0];
1893             loader->pp2 = pp[1];
1894             loader->pp3 = pp[2];
1895             loader->pp4 = pp[3];
1896
1897             loader->linear   = linear_hadvance;
1898             loader->vadvance = linear_vadvance;
1899           }
1900
1901           num_points = (FT_UInt)gloader->base.outline.n_points;
1902
1903           if ( num_points == num_base_points )
1904             continue;
1905
1906           /* gloader->base.outline consists of three parts:           */
1907           /*                                                          */
1908           /* 0 ----> start_point ----> num_base_points ----> n_points */
1909           /*    (1)               (2)                   (3)           */
1910           /*                                                          */
1911           /* (1) points that exist from the beginning                 */
1912           /* (2) component points that have been loaded so far        */
1913           /* (3) points of the newly loaded component                 */
1914           error = TT_Process_Composite_Component( loader,
1915                                                   subglyph,
1916                                                   start_point,
1917                                                   num_base_points );
1918           if ( error )
1919             goto Exit;
1920         }
1921
1922         loader->stream   = old_stream;
1923         loader->byte_len = old_byte_len;
1924
1925         /* process the glyph */
1926         loader->ins_pos = ins_pos;
1927         if ( IS_HINTED( loader->load_flags ) &&
1928 #ifdef TT_USE_BYTECODE_INTERPRETER
1929              subglyph                        &&
1930              subglyph->flags & WE_HAVE_INSTR &&
1931 #endif
1932              num_points > start_point )
1933         {
1934           error = TT_Process_Composite_Glyph( loader,
1935                                               start_point,
1936                                               start_contour );
1937           if ( error )
1938             goto Exit;
1939         }
1940       }
1941
1942       /* retain the overlap flag */
1943       if ( gloader->base.num_subglyphs                         &&
1944            gloader->base.subglyphs[0].flags & OVERLAP_COMPOUND )
1945         gloader->base.outline.flags |= FT_OUTLINE_OVERLAP;
1946     }
1947
1948     /***********************************************************************/
1949     /***********************************************************************/
1950     /***********************************************************************/
1951
1952   Exit:
1953
1954     if ( opened_frame )
1955       face->forget_glyph_frame( loader );
1956
1957 #ifdef FT_CONFIG_OPTION_INCREMENTAL
1958
1959     if ( glyph_data_loaded )
1960       face->root.internal->incremental_interface->funcs->free_glyph_data(
1961         face->root.internal->incremental_interface->object,
1962         &glyph_data );
1963
1964 #endif
1965
1966     return error;
1967   }
1968
1969
1970   static FT_Error
1971   compute_glyph_metrics( TT_Loader  loader,
1972                          FT_UInt    glyph_index )
1973   {
1974     TT_Face       face  = loader->face;
1975     TT_Size       size  = loader->size;
1976     TT_GlyphSlot  glyph = loader->glyph;
1977     FT_BBox       bbox;
1978     FT_Fixed      y_scale;
1979
1980
1981     y_scale = 0x10000L;
1982     if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 )
1983       y_scale = size->metrics->y_scale;
1984
1985     if ( glyph->format != FT_GLYPH_FORMAT_COMPOSITE )
1986       FT_Outline_Get_CBox( &glyph->outline, &bbox );
1987     else
1988       bbox = loader->bbox;
1989
1990     /* get the device-independent horizontal advance; it is scaled later */
1991     /* by the base layer.                                                */
1992     glyph->linearHoriAdvance = loader->linear;
1993
1994     glyph->metrics.horiBearingX = bbox.xMin;
1995     glyph->metrics.horiBearingY = bbox.yMax;
1996     if ( loader->widthp )
1997       glyph->metrics.horiAdvance = loader->widthp[glyph_index] * 64;
1998     else
1999       glyph->metrics.horiAdvance = SUB_LONG( loader->pp2.x, loader->pp1.x );
2000
2001     /* set glyph dimensions */
2002     glyph->metrics.width  = SUB_LONG( bbox.xMax, bbox.xMin );
2003     glyph->metrics.height = SUB_LONG( bbox.yMax, bbox.yMin );
2004
2005     /* Now take care of vertical metrics.  In the case where there is */
2006     /* no vertical information within the font (relatively common),   */
2007     /* create some metrics manually                                   */
2008     {
2009       FT_Pos  top;      /* scaled vertical top side bearing  */
2010       FT_Pos  advance;  /* scaled vertical advance height    */
2011
2012
2013       /* Get the unscaled top bearing and advance height. */
2014       if ( face->vertical_info                   &&
2015            face->vertical.number_Of_VMetrics > 0 )
2016       {
2017         top = (FT_Short)FT_DivFix( SUB_LONG( loader->pp3.y, bbox.yMax ),
2018                                    y_scale );
2019
2020         if ( loader->pp3.y <= loader->pp4.y )
2021           advance = 0;
2022         else
2023           advance = (FT_UShort)FT_DivFix( SUB_LONG( loader->pp3.y,
2024                                                     loader->pp4.y ),
2025                                           y_scale );
2026       }
2027       else
2028       {
2029         FT_Pos  height;
2030
2031
2032         /* XXX Compute top side bearing and advance height in  */
2033         /*     Get_VMetrics instead of here.                   */
2034
2035         /* NOTE: The OS/2 values are the only `portable' ones, */
2036         /*       which is why we use them, if there is an OS/2 */
2037         /*       table in the font.  Otherwise, we use the     */
2038         /*       values defined in the horizontal header.      */
2039
2040         height = (FT_Short)FT_DivFix( SUB_LONG( bbox.yMax,
2041                                                 bbox.yMin ),
2042                                       y_scale );
2043         if ( face->os2.version != 0xFFFFU )
2044           advance = (FT_Pos)( face->os2.sTypoAscender -
2045                               face->os2.sTypoDescender );
2046         else
2047           advance = (FT_Pos)( face->horizontal.Ascender -
2048                               face->horizontal.Descender );
2049
2050         top = ( advance - height ) / 2;
2051       }
2052
2053 #ifdef FT_CONFIG_OPTION_INCREMENTAL
2054       {
2055         FT_Incremental_InterfaceRec*  incr;
2056         FT_Incremental_MetricsRec     incr_metrics;
2057         FT_Error                      error;
2058
2059
2060         incr = face->root.internal->incremental_interface;
2061
2062         /* If this is an incrementally loaded font see if there are */
2063         /* overriding metrics for this glyph.                       */
2064         if ( incr && incr->funcs->get_glyph_metrics )
2065         {
2066           incr_metrics.bearing_x = 0;
2067           incr_metrics.bearing_y = top;
2068           incr_metrics.advance   = advance;
2069
2070           error = incr->funcs->get_glyph_metrics( incr->object,
2071                                                   glyph_index,
2072                                                   TRUE,
2073                                                   &incr_metrics );
2074           if ( error )
2075             return error;
2076
2077           top     = incr_metrics.bearing_y;
2078           advance = incr_metrics.advance;
2079         }
2080       }
2081
2082       /* GWW: Do vertical metrics get loaded incrementally too? */
2083
2084 #endif /* FT_CONFIG_OPTION_INCREMENTAL */
2085
2086       glyph->linearVertAdvance = advance;
2087
2088       /* scale the metrics */
2089       if ( !( loader->load_flags & FT_LOAD_NO_SCALE ) )
2090       {
2091         top     = FT_MulFix( top,     y_scale );
2092         advance = FT_MulFix( advance, y_scale );
2093       }
2094
2095       /* XXX: for now, we have no better algorithm for the lsb, but it */
2096       /*      should work fine.                                        */
2097       /*                                                               */
2098       glyph->metrics.vertBearingX = SUB_LONG( glyph->metrics.horiBearingX,
2099                                               glyph->metrics.horiAdvance / 2 );
2100       glyph->metrics.vertBearingY = top;
2101       glyph->metrics.vertAdvance  = advance;
2102     }
2103
2104     return FT_Err_Ok;
2105   }
2106
2107
2108 #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
2109
2110   static FT_Error
2111   load_sbit_image( TT_Size       size,
2112                    TT_GlyphSlot  glyph,
2113                    FT_UInt       glyph_index,
2114                    FT_Int32      load_flags )
2115   {
2116     TT_Face             face   = (TT_Face)glyph->face;
2117     SFNT_Service        sfnt   = (SFNT_Service)face->sfnt;
2118     FT_Stream           stream = face->root.stream;
2119     FT_Error            error;
2120     TT_SBit_MetricsRec  sbit_metrics;
2121
2122
2123     error = sfnt->load_sbit_image( face,
2124                                    size->strike_index,
2125                                    glyph_index,
2126                                    (FT_UInt)load_flags,
2127                                    stream,
2128                                    &glyph->bitmap,
2129                                    &sbit_metrics );
2130     if ( !error )
2131     {
2132       glyph->outline.n_points   = 0;
2133       glyph->outline.n_contours = 0;
2134
2135       glyph->metrics.width  = (FT_Pos)sbit_metrics.width  * 64;
2136       glyph->metrics.height = (FT_Pos)sbit_metrics.height * 64;
2137
2138       glyph->metrics.horiBearingX = (FT_Pos)sbit_metrics.horiBearingX * 64;
2139       glyph->metrics.horiBearingY = (FT_Pos)sbit_metrics.horiBearingY * 64;
2140       glyph->metrics.horiAdvance  = (FT_Pos)sbit_metrics.horiAdvance  * 64;
2141
2142       glyph->metrics.vertBearingX = (FT_Pos)sbit_metrics.vertBearingX * 64;
2143       glyph->metrics.vertBearingY = (FT_Pos)sbit_metrics.vertBearingY * 64;
2144       glyph->metrics.vertAdvance  = (FT_Pos)sbit_metrics.vertAdvance  * 64;
2145
2146       glyph->format = FT_GLYPH_FORMAT_BITMAP;
2147
2148       if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )
2149       {
2150         glyph->bitmap_left = sbit_metrics.vertBearingX;
2151         glyph->bitmap_top  = sbit_metrics.vertBearingY;
2152       }
2153       else
2154       {
2155         glyph->bitmap_left = sbit_metrics.horiBearingX;
2156         glyph->bitmap_top  = sbit_metrics.horiBearingY;
2157       }
2158     }
2159
2160     return error;
2161   }
2162
2163 #endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
2164
2165
2166   static FT_Error
2167   tt_loader_init( TT_Loader     loader,
2168                   TT_Size       size,
2169                   TT_GlyphSlot  glyph,
2170                   FT_Int32      load_flags,
2171                   FT_Bool       glyf_table_only )
2172   {
2173     TT_Face    face   = (TT_Face)glyph->face;
2174     FT_Stream  stream = face->root.stream;
2175
2176 #ifdef TT_USE_BYTECODE_INTERPRETER
2177     FT_Error   error;
2178     FT_Bool    pedantic = FT_BOOL( load_flags & FT_LOAD_PEDANTIC );
2179 #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL
2180     TT_Driver  driver   = (TT_Driver)FT_FACE_DRIVER( glyph->face );
2181 #endif
2182 #endif
2183
2184
2185     FT_ZERO( loader );
2186
2187 #ifdef TT_USE_BYTECODE_INTERPRETER
2188
2189     /* load execution context */
2190     if ( IS_HINTED( load_flags ) && !glyf_table_only )
2191     {
2192       TT_ExecContext  exec;
2193       FT_Bool         grayscale = TRUE;
2194 #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL
2195       FT_Bool         subpixel_hinting_lean;
2196       FT_Bool         grayscale_cleartype;
2197 #endif
2198
2199       FT_Bool  reexecute = FALSE;
2200
2201
2202       if ( size->bytecode_ready < 0 || size->cvt_ready < 0 )
2203       {
2204         error = tt_size_ready_bytecode( size, pedantic );
2205         if ( error )
2206           return error;
2207       }
2208       else if ( size->bytecode_ready )
2209         return size->bytecode_ready;
2210       else if ( size->cvt_ready )
2211         return size->cvt_ready;
2212
2213       /* query new execution context */
2214       exec = size->context;
2215       if ( !exec )
2216         return FT_THROW( Could_Not_Find_Context );
2217
2218       grayscale = FT_BOOL( FT_LOAD_TARGET_MODE( load_flags ) !=
2219                              FT_RENDER_MODE_MONO             );
2220
2221 #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL
2222       if ( driver->interpreter_version == TT_INTERPRETER_VERSION_40 )
2223       {
2224         subpixel_hinting_lean =
2225           FT_BOOL( FT_LOAD_TARGET_MODE( load_flags ) !=
2226                    FT_RENDER_MODE_MONO               );
2227         grayscale_cleartype =
2228           FT_BOOL( subpixel_hinting_lean         &&
2229                    !( ( load_flags         &
2230                         FT_LOAD_TARGET_LCD )   ||
2231                       ( load_flags           &
2232                         FT_LOAD_TARGET_LCD_V ) ) );
2233         exec->vertical_lcd_lean =
2234           FT_BOOL( subpixel_hinting_lean    &&
2235                    ( load_flags           &
2236                      FT_LOAD_TARGET_LCD_V ) );
2237         grayscale = FT_BOOL( grayscale && !subpixel_hinting_lean );
2238       }
2239       else
2240       {
2241         subpixel_hinting_lean   = FALSE;
2242         grayscale_cleartype     = FALSE;
2243         exec->vertical_lcd_lean = FALSE;
2244       }
2245 #endif
2246
2247       error = TT_Load_Context( exec, face, size );
2248       if ( error )
2249         return error;
2250
2251       {
2252 #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL
2253         if ( driver->interpreter_version == TT_INTERPRETER_VERSION_40 )
2254         {
2255           /* a change from mono to subpixel rendering (and vice versa) */
2256           /* requires a re-execution of the CVT program                */
2257           if ( subpixel_hinting_lean != exec->subpixel_hinting_lean )
2258           {
2259             FT_TRACE4(( "tt_loader_init: subpixel hinting change,"
2260                         " re-executing `prep' table\n" ));
2261
2262             exec->subpixel_hinting_lean = subpixel_hinting_lean;
2263             reexecute                   = TRUE;
2264           }
2265
2266           /* a change from colored to grayscale subpixel rendering (and */
2267           /* vice versa) requires a re-execution of the CVT program     */
2268           if ( grayscale_cleartype != exec->grayscale_cleartype )
2269           {
2270             FT_TRACE4(( "tt_loader_init: grayscale subpixel hinting change,"
2271                         " re-executing `prep' table\n" ));
2272
2273             exec->grayscale_cleartype = grayscale_cleartype;
2274             reexecute                 = TRUE;
2275           }
2276         }
2277 #endif
2278
2279         /* a change from mono to grayscale rendering (and vice versa) */
2280         /* requires a re-execution of the CVT program                 */
2281         if ( grayscale != exec->grayscale )
2282         {
2283           FT_TRACE4(( "tt_loader_init: grayscale hinting change,"
2284                       " re-executing `prep' table\n" ));
2285
2286           exec->grayscale = grayscale;
2287           reexecute       = TRUE;
2288         }
2289       }
2290
2291       if ( reexecute )
2292       {
2293         error = tt_size_run_prep( size, pedantic );
2294         if ( error )
2295           return error;
2296         error = TT_Load_Context( exec, face, size );
2297         if ( error )
2298           return error;
2299       }
2300
2301       /* check whether the cvt program has disabled hinting */
2302       if ( exec->GS.instruct_control & 1 )
2303         load_flags |= FT_LOAD_NO_HINTING;
2304
2305       /* load default graphics state -- if needed */
2306       if ( exec->GS.instruct_control & 2 )
2307         exec->GS = tt_default_graphics_state;
2308
2309 #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL
2310       /*
2311        * Toggle backward compatibility according to what font wants, except
2312        * when
2313        *
2314        * 1) we have a `tricky' font that heavily relies on the interpreter to
2315        *    render glyphs correctly, for example DFKai-SB, or
2316        * 2) FT_RENDER_MODE_MONO (i.e, monochome rendering) is requested.
2317        *
2318        * In those cases, backward compatibility needs to be turned off to get
2319        * correct rendering.  The rendering is then completely up to the
2320        * font's programming.
2321        *
2322        */
2323       if ( driver->interpreter_version == TT_INTERPRETER_VERSION_40 &&
2324            subpixel_hinting_lean                                    &&
2325            !FT_IS_TRICKY( glyph->face )                             )
2326         exec->backward_compatibility = !( exec->GS.instruct_control & 4 );
2327       else
2328         exec->backward_compatibility = FALSE;
2329 #endif /* TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL */
2330
2331       exec->pedantic_hinting = FT_BOOL( load_flags & FT_LOAD_PEDANTIC );
2332       loader->exec = exec;
2333       loader->instructions = exec->glyphIns;
2334
2335       /* Use the hdmx table if any unless FT_LOAD_COMPUTE_METRICS */
2336       /* is set or backward compatibility mode of the v38 or v40  */
2337       /* interpreters is active.  See `ttinterp.h' for details on */
2338       /* backward compatibility mode.                             */
2339       if ( IS_HINTED( loader->load_flags )                                &&
2340            !( loader->load_flags & FT_LOAD_COMPUTE_METRICS )              &&
2341 #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL
2342            !( driver->interpreter_version == TT_INTERPRETER_VERSION_40  &&
2343               exec->backward_compatibility                              ) &&
2344 #endif
2345            !face->postscript.isFixedPitch                                 )
2346       {
2347         loader->widthp = size->widthp;
2348       }
2349       else
2350         loader->widthp = NULL;
2351     }
2352
2353 #endif /* TT_USE_BYTECODE_INTERPRETER */
2354
2355     /* get face's glyph loader */
2356     if ( !glyf_table_only )
2357     {
2358       FT_GlyphLoader  gloader = glyph->internal->loader;
2359
2360
2361       FT_GlyphLoader_Rewind( gloader );
2362       loader->gloader = gloader;
2363     }
2364
2365     loader->load_flags = (FT_ULong)load_flags;
2366
2367     loader->face   = face;
2368     loader->size   = size;
2369     loader->glyph  = (FT_GlyphSlot)glyph;
2370     loader->stream = stream;
2371
2372     loader->composites.head = NULL;
2373     loader->composites.tail = NULL;
2374
2375     return FT_Err_Ok;
2376   }
2377
2378
2379   static void
2380   tt_loader_done( TT_Loader  loader )
2381   {
2382     FT_List_Finalize( &loader->composites,
2383                       NULL,
2384                       loader->face->root.memory,
2385                       NULL );
2386   }
2387
2388
2389   /**************************************************************************
2390    *
2391    * @Function:
2392    *   TT_Load_Glyph
2393    *
2394    * @Description:
2395    *   A function used to load a single glyph within a given glyph slot,
2396    *   for a given size.
2397    *
2398    * @InOut:
2399    *   glyph ::
2400    *     A handle to a target slot object where the glyph
2401    *     will be loaded.
2402    *
2403    * @Input:
2404    *   size ::
2405    *     A handle to the source face size at which the glyph
2406    *     must be scaled/loaded.
2407    *
2408    *   glyph_index ::
2409    *     The index of the glyph in the font file.
2410    *
2411    *   load_flags ::
2412    *     A flag indicating what to load for this glyph.  The
2413    *     FT_LOAD_XXX constants can be used to control the
2414    *     glyph loading process (e.g., whether the outline
2415    *     should be scaled, whether to load bitmaps or not,
2416    *     whether to hint the outline, etc).
2417    *
2418    * @Return:
2419    *   FreeType error code.  0 means success.
2420    */
2421   FT_LOCAL_DEF( FT_Error )
2422   TT_Load_Glyph( TT_Size       size,
2423                  TT_GlyphSlot  glyph,
2424                  FT_UInt       glyph_index,
2425                  FT_Int32      load_flags )
2426   {
2427     TT_Face       face = (TT_Face)glyph->face;
2428     FT_Error      error;
2429     TT_LoaderRec  loader;
2430
2431
2432     FT_TRACE1(( "TT_Load_Glyph: glyph index %d\n", glyph_index ));
2433
2434 #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
2435
2436     /* try to load embedded bitmap (if any) */
2437     if ( size->strike_index != 0xFFFFFFFFUL      &&
2438          ( load_flags & FT_LOAD_NO_BITMAP ) == 0 &&
2439          IS_DEFAULT_INSTANCE( glyph->face )      )
2440     {
2441       FT_Fixed  x_scale = size->root.metrics.x_scale;
2442       FT_Fixed  y_scale = size->root.metrics.y_scale;
2443
2444
2445       error = load_sbit_image( size, glyph, glyph_index, load_flags );
2446       if ( FT_ERR_EQ( error, Missing_Bitmap ) )
2447       {
2448         /* the bitmap strike is incomplete and misses the requested glyph; */
2449         /* if we have a bitmap-only font, return an empty glyph            */
2450         if ( !FT_IS_SCALABLE( glyph->face ) )
2451         {
2452           FT_Short  left_bearing = 0;
2453           FT_Short  top_bearing  = 0;
2454
2455           FT_UShort  advance_width  = 0;
2456           FT_UShort  advance_height = 0;
2457
2458
2459           /* to return an empty glyph, however, we need metrics data   */
2460           /* from the `hmtx' (or `vmtx') table; the assumption is that */
2461           /* empty glyphs are missing intentionally, representing      */
2462           /* whitespace - not having at least horizontal metrics is    */
2463           /* thus considered an error                                  */
2464           if ( !face->horz_metrics_size )
2465             return error;
2466
2467           /* we now construct an empty bitmap glyph */
2468           TT_Get_HMetrics( face, glyph_index,
2469                            &left_bearing,
2470                            &advance_width );
2471           TT_Get_VMetrics( face, glyph_index,
2472                            0,
2473                            &top_bearing,
2474                            &advance_height );
2475
2476           glyph->outline.n_points   = 0;
2477           glyph->outline.n_contours = 0;
2478
2479           glyph->metrics.width  = 0;
2480           glyph->metrics.height = 0;
2481
2482           glyph->metrics.horiBearingX = FT_MulFix( left_bearing, x_scale );
2483           glyph->metrics.horiBearingY = 0;
2484           glyph->metrics.horiAdvance  = FT_MulFix( advance_width, x_scale );
2485
2486           glyph->metrics.vertBearingX = 0;
2487           glyph->metrics.vertBearingY = FT_MulFix( top_bearing, y_scale );
2488           glyph->metrics.vertAdvance  = FT_MulFix( advance_height, y_scale );
2489
2490           glyph->format            = FT_GLYPH_FORMAT_BITMAP;
2491           glyph->bitmap.pixel_mode = FT_PIXEL_MODE_MONO;
2492
2493           glyph->bitmap_left = 0;
2494           glyph->bitmap_top  = 0;
2495
2496           return FT_Err_Ok;
2497         }
2498       }
2499       else if ( error )
2500       {
2501         /* return error if font is not scalable */
2502         if ( !FT_IS_SCALABLE( glyph->face ) )
2503           return error;
2504       }
2505       else
2506       {
2507         if ( FT_IS_SCALABLE( glyph->face ) ||
2508              FT_HAS_SBIX( glyph->face )    )
2509         {
2510           /* for the bbox we need the header only */
2511           (void)tt_loader_init( &loader, size, glyph, load_flags, TRUE );
2512           (void)load_truetype_glyph( &loader, glyph_index, 0, TRUE );
2513           tt_loader_done( &loader );
2514           glyph->linearHoriAdvance = loader.linear;
2515           glyph->linearVertAdvance = loader.vadvance;
2516
2517           /* Bitmaps from the 'sbix' table need special treatment:  */
2518           /* if there is a glyph contour, the bitmap origin must be */
2519           /* shifted to be relative to the lower left corner of the */
2520           /* glyph bounding box, also taking the left-side bearing  */
2521           /* (or top bearing) into account.                         */
2522           if ( face->sbit_table_type == TT_SBIT_TABLE_TYPE_SBIX &&
2523                loader.n_contours > 0                            )
2524           {
2525             FT_Int  bitmap_left;
2526             FT_Int  bitmap_top;
2527
2528
2529             if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )
2530             {
2531               /* This is a guess, since Apple's CoreText engine doesn't */
2532               /* really do vertical typesetting.                        */
2533               bitmap_left = loader.bbox.xMin;
2534               bitmap_top  = loader.top_bearing;
2535             }
2536             else
2537             {
2538               bitmap_left = loader.left_bearing;
2539               bitmap_top  = loader.bbox.yMin;
2540             }
2541
2542             glyph->bitmap_left += FT_MulFix( bitmap_left, x_scale ) >> 6;
2543             glyph->bitmap_top  += FT_MulFix( bitmap_top,  y_scale ) >> 6;
2544           }
2545
2546           /* sanity checks: if `xxxAdvance' in the sbit metric */
2547           /* structure isn't set, use `linearXXXAdvance'      */
2548           if ( !glyph->metrics.horiAdvance && glyph->linearHoriAdvance )
2549             glyph->metrics.horiAdvance = FT_MulFix( glyph->linearHoriAdvance,
2550                                                     x_scale );
2551           if ( !glyph->metrics.vertAdvance && glyph->linearVertAdvance )
2552             glyph->metrics.vertAdvance = FT_MulFix( glyph->linearVertAdvance,
2553                                                     y_scale );
2554         }
2555
2556         return FT_Err_Ok;
2557       }
2558     }
2559
2560     if ( load_flags & FT_LOAD_SBITS_ONLY )
2561     {
2562       error = FT_THROW( Invalid_Argument );
2563       goto Exit;
2564     }
2565
2566 #endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
2567
2568     /* if FT_LOAD_NO_SCALE is not set, `ttmetrics' must be valid */
2569     if ( !( load_flags & FT_LOAD_NO_SCALE ) && !size->ttmetrics.valid )
2570     {
2571       error = FT_THROW( Invalid_Size_Handle );
2572       goto Exit;
2573     }
2574
2575 #ifdef FT_CONFIG_OPTION_SVG
2576
2577     /* check for OT-SVG */
2578     if ( ( load_flags & FT_LOAD_NO_SVG ) == 0 &&
2579          ( load_flags & FT_LOAD_COLOR )       &&
2580          face->svg                            )
2581     {
2582       SFNT_Service  sfnt = (SFNT_Service)face->sfnt;
2583
2584
2585       FT_TRACE3(( "Trying to load SVG glyph\n" ));
2586
2587       error = sfnt->load_svg_doc( glyph, glyph_index );
2588       if ( !error )
2589       {
2590         FT_Fixed  x_scale = size->root.metrics.x_scale;
2591         FT_Fixed  y_scale = size->root.metrics.y_scale;
2592
2593         FT_Short   leftBearing;
2594         FT_Short   topBearing;
2595         FT_UShort  advanceX;
2596         FT_UShort  advanceY;
2597
2598
2599         FT_TRACE3(( "Successfully loaded SVG glyph\n" ));
2600
2601         glyph->format = FT_GLYPH_FORMAT_SVG;
2602
2603         sfnt->get_metrics( face,
2604                            FALSE,
2605                            glyph_index,
2606                            &leftBearing,
2607                            &advanceX );
2608         sfnt->get_metrics( face,
2609                            TRUE,
2610                            glyph_index,
2611                            &topBearing,
2612                            &advanceY );
2613
2614         glyph->linearHoriAdvance = advanceX;
2615         glyph->linearVertAdvance = advanceY;
2616
2617         glyph->metrics.horiAdvance = FT_MulFix( advanceX, x_scale );
2618         glyph->metrics.vertAdvance = FT_MulFix( advanceY, y_scale );
2619
2620         return error;
2621       }
2622
2623       FT_TRACE3(( "Failed to load SVG glyph\n" ));
2624     }
2625
2626     /* return immediately if we only want SVG glyphs */
2627     if ( load_flags & FT_LOAD_SVG_ONLY )
2628     {
2629       error = FT_THROW( Invalid_Argument );
2630       goto Exit;
2631     }
2632
2633 #endif /* FT_CONFIG_OPTION_SVG */
2634
2635     error = tt_loader_init( &loader, size, glyph, load_flags, FALSE );
2636     if ( error )
2637       goto Exit;
2638
2639     /* done if we are only interested in the `hdmx` advance */
2640     if ( load_flags & FT_LOAD_ADVANCE_ONLY         &&
2641          !( load_flags & FT_LOAD_VERTICAL_LAYOUT ) &&
2642          loader.widthp                             )
2643     {
2644       glyph->metrics.horiAdvance = loader.widthp[glyph_index] * 64;
2645       goto Done;
2646     }
2647
2648     glyph->format        = FT_GLYPH_FORMAT_OUTLINE;
2649     glyph->num_subglyphs = 0;
2650     glyph->outline.flags = 0;
2651
2652     /* main loading loop */
2653     error = load_truetype_glyph( &loader, glyph_index, 0, FALSE );
2654     if ( !error )
2655     {
2656       if ( glyph->format == FT_GLYPH_FORMAT_COMPOSITE )
2657       {
2658         glyph->num_subglyphs = loader.gloader->base.num_subglyphs;
2659         glyph->subglyphs     = loader.gloader->base.subglyphs;
2660       }
2661       else
2662       {
2663         glyph->outline        = loader.gloader->base.outline;
2664         glyph->outline.flags &= ~FT_OUTLINE_SINGLE_PASS;
2665
2666         /* Translate array so that (0,0) is the glyph's origin.  Note  */
2667         /* that this behaviour is independent on the value of bit 1 of */
2668         /* the `flags' field in the `head' table -- at least major     */
2669         /* applications like Acroread indicate that.                   */
2670         if ( loader.pp1.x )
2671           FT_Outline_Translate( &glyph->outline, -loader.pp1.x, 0 );
2672       }
2673
2674 #ifdef TT_USE_BYTECODE_INTERPRETER
2675
2676       if ( IS_HINTED( load_flags ) )
2677       {
2678         glyph->control_data = loader.exec->glyphIns;
2679         glyph->control_len  = loader.exec->glyphSize;
2680
2681         if ( loader.exec->GS.scan_control )
2682         {
2683           /* convert scan conversion mode to FT_OUTLINE_XXX flags */
2684           switch ( loader.exec->GS.scan_type )
2685           {
2686           case 0: /* simple drop-outs including stubs */
2687             glyph->outline.flags |= FT_OUTLINE_INCLUDE_STUBS;
2688             break;
2689           case 1: /* simple drop-outs excluding stubs */
2690             /* nothing; it's the default rendering mode */
2691             break;
2692           case 4: /* smart drop-outs including stubs */
2693             glyph->outline.flags |= FT_OUTLINE_SMART_DROPOUTS |
2694                                     FT_OUTLINE_INCLUDE_STUBS;
2695             break;
2696           case 5: /* smart drop-outs excluding stubs  */
2697             glyph->outline.flags |= FT_OUTLINE_SMART_DROPOUTS;
2698             break;
2699
2700           default: /* no drop-out control */
2701             glyph->outline.flags |= FT_OUTLINE_IGNORE_DROPOUTS;
2702             break;
2703           }
2704         }
2705         else
2706           glyph->outline.flags |= FT_OUTLINE_IGNORE_DROPOUTS;
2707       }
2708
2709 #endif /* TT_USE_BYTECODE_INTERPRETER */
2710
2711       error = compute_glyph_metrics( &loader, glyph_index );
2712     }
2713
2714     /* Set the `high precision' bit flag.                           */
2715     /* This is _critical_ to get correct output for monochrome      */
2716     /* TrueType glyphs at all sizes using the bytecode interpreter. */
2717     /*                                                              */
2718     if ( !( load_flags & FT_LOAD_NO_SCALE ) &&
2719          size->metrics->y_ppem < 24         )
2720       glyph->outline.flags |= FT_OUTLINE_HIGH_PRECISION;
2721
2722     FT_TRACE1(( "  subglyphs = %u, contours = %hd, points = %hd,"
2723                 " flags = 0x%.3x\n",
2724                 loader.gloader->base.num_subglyphs,
2725                 glyph->outline.n_contours,
2726                 glyph->outline.n_points,
2727                 glyph->outline.flags ));
2728
2729   Done:
2730     tt_loader_done( &loader );
2731
2732   Exit:
2733 #ifdef FT_DEBUG_LEVEL_TRACE
2734     if ( error )
2735       FT_TRACE1(( "  failed (error code 0x%x)\n",
2736                   error ));
2737 #endif
2738
2739     return error;
2740   }
2741
2742
2743 /* END */