src/truetype/ttgxvar.c

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  ttgxvar.c                                                              */
   4 /*                                                                         */
   5 /*    TrueType GX Font Variation loader                                    */
   6 /*                                                                         */
   7 /*  Copyright 2004-2014 by                                                 */
   8 /*  David Turner, Robert Wilhelm, Werner Lemberg, and George Williams.     */
   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   /*************************************************************************/
  20   /*                                                                       */
  21   /* Apple documents the `fvar', `gvar', `cvar', and `avar' tables at      */
  22   /*                                                                       */
  23   /*   http://developer.apple.com/fonts/TTRefMan/RM06/Chap6[fgca]var.html  */
  24   /*                                                                       */
  25   /* The documentation for `fvar' is inconsistent.  At one point it says   */
  26   /* that `countSizePairs' should be 3, at another point 2.  It should     */
  27   /* be 2.                                                                 */
  28   /*                                                                       */
  29   /* The documentation for `gvar' is not intelligible; `cvar' refers you   */
  30   /* to `gvar' and is thus also incomprehensible.                          */
  31   /*                                                                       */
  32   /* The documentation for `avar' appears correct, but Apple has no fonts  */
  33   /* with an `avar' table, so it is hard to test.                          */
  34   /*                                                                       */
  35   /* Many thanks to John Jenkins (at Apple) in figuring this out.          */
  36   /*                                                                       */
  37   /*                                                                       */
  38   /* Apple's `kern' table has some references to tuple indices, but as     */
  39   /* there is no indication where these indices are defined, nor how to    */
  40   /* interpolate the kerning values (different tuples have different       */
  41   /* classes) this issue is ignored.                                       */
  42   /*                                                                       */
  43   /*************************************************************************/
  44
  45
  46 #include <ft2build.h>
  47 #include FT_INTERNAL_DEBUG_H
  48 #include FT_CONFIG_CONFIG_H
  49 #include FT_INTERNAL_STREAM_H
  50 #include FT_INTERNAL_SFNT_H
  51 #include FT_TRUETYPE_TAGS_H
  52 #include FT_MULTIPLE_MASTERS_H
  53
  54 #include "ttpload.h"
  55 #include "ttgxvar.h"
  56
  57 #include "tterrors.h"
  58
  59
  60 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
  61
  62
  63 #define FT_Stream_FTell( stream )  \
  64           (FT_ULong)( (stream)->cursor - (stream)->base )
  65 #define FT_Stream_SeekSet( stream, off ) \
  66           ( (stream)->cursor = (stream)->base + (off) )
  67
  68
  69   /*************************************************************************/
  70   /*                                                                       */
  71   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
  72   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
  73   /* messages during execution.                                            */
  74   /*                                                                       */
  75 #undef  FT_COMPONENT
  76 #define FT_COMPONENT  trace_ttgxvar
  77
  78
  79   /*************************************************************************/
  80   /*************************************************************************/
  81   /*****                                                               *****/
  82   /*****                       Internal Routines                       *****/
  83   /*****                                                               *****/
  84   /*************************************************************************/
  85   /*************************************************************************/
  86
  87
  88   /*************************************************************************/
  89   /*                                                                       */
  90   /* The macro ALL_POINTS is used in `ft_var_readpackedpoints'.  It        */
  91   /* indicates that there is a delta for every point without needing to    */
  92   /* enumerate all of them.                                                */
  93   /*                                                                       */
  94
  95   /* ensure that value `0' has the same width as a pointer */
  96 #define ALL_POINTS  (FT_UShort*)~(FT_PtrDist)0
  97
  98
  99 #define GX_PT_POINTS_ARE_WORDS      0x80
 100 #define GX_PT_POINT_RUN_COUNT_MASK  0x7F
 101
 102
 103   /*************************************************************************/
 104   /*                                                                       */
 105   /* <Function>                                                            */
 106   /*    ft_var_readpackedpoints                                            */
 107   /*                                                                       */
 108   /* <Description>                                                         */
 109   /*    Read a set of points to which the following deltas will apply.     */
 110   /*    Points are packed with a run length encoding.                      */
 111   /*                                                                       */
 112   /* <Input>                                                               */
 113   /*    stream    :: The data stream.                                      */
 114   /*                                                                       */
 115   /* <Output>                                                              */
 116   /*    point_cnt :: The number of points read.  A zero value means that   */
 117   /*                 all points in the glyph will be affected, without     */
 118   /*                 enumerating them individually.                        */
 119   /*                                                                       */
 120   /* <Return>                                                              */
 121   /*    An array of FT_UShort containing the affected points or the        */
 122   /*    special value ALL_POINTS.                                          */
 123   /*                                                                       */
 124   static FT_UShort*
 125   ft_var_readpackedpoints( FT_Stream  stream,
 126                            FT_UInt   *point_cnt )
 127   {
 128     FT_UShort *points = NULL;
 129     FT_Int     n;
 130     FT_Int     runcnt;
 131     FT_Int     i;
 132     FT_Int     j;
 133     FT_Int     first;
 134     FT_Memory  memory = stream->memory;
 135     FT_Error   error  = FT_Err_Ok;
 136
 137     FT_UNUSED( error );
 138
 139
 140     *point_cnt = n = FT_GET_BYTE();
 141     if ( n == 0 )
 142       return ALL_POINTS;
 143
 144     if ( n & GX_PT_POINTS_ARE_WORDS )
 145       n = FT_GET_BYTE() | ( ( n & GX_PT_POINT_RUN_COUNT_MASK ) << 8 );
 146
 147     if ( FT_NEW_ARRAY( points, n ) )
 148       return NULL;
 149
 150     i = 0;
 151     while ( i < n )
 152     {
 153       runcnt = FT_GET_BYTE();
 154       if ( runcnt & GX_PT_POINTS_ARE_WORDS )
 155       {
 156         runcnt = runcnt & GX_PT_POINT_RUN_COUNT_MASK;
 157         first  = points[i++] = FT_GET_USHORT();
 158
 159         if ( runcnt < 1 || i + runcnt >= n )
 160           goto Exit;
 161
 162         /* first point not included in runcount */
 163         for ( j = 0; j < runcnt; ++j )
 164           points[i++] = (FT_UShort)( first += FT_GET_USHORT() );
 165       }
 166       else
 167       {
 168         first = points[i++] = FT_GET_BYTE();
 169
 170         if ( runcnt < 1 || i + runcnt >= n )
 171           goto Exit;
 172
 173         for ( j = 0; j < runcnt; ++j )
 174           points[i++] = (FT_UShort)( first += FT_GET_BYTE() );
 175       }
 176     }
 177
 178   Exit:
 179     return points;
 180   }
 181
 182
 183   enum
 184   {
 185     GX_DT_DELTAS_ARE_ZERO      = 0x80,
 186     GX_DT_DELTAS_ARE_WORDS     = 0x40,
 187     GX_DT_DELTA_RUN_COUNT_MASK = 0x3F
 188   };
 189
 190
 191   /*************************************************************************/
 192   /*                                                                       */
 193   /* <Function>                                                            */
 194   /*    ft_var_readpackeddeltas                                            */
 195   /*                                                                       */
 196   /* <Description>                                                         */
 197   /*    Read a set of deltas.  These are packed slightly differently than  */
 198   /*    points.  In particular there is no overall count.                  */
 199   /*                                                                       */
 200   /* <Input>                                                               */
 201   /*    stream    :: The data stream.                                      */
 202   /*                                                                       */
 203   /*    delta_cnt :: The number of to be read.                             */
 204   /*                                                                       */
 205   /* <Return>                                                              */
 206   /*    An array of FT_Short containing the deltas for the affected        */
 207   /*    points.  (This only gets the deltas for one dimension.  It will    */
 208   /*    generally be called twice, once for x, once for y.  When used in   */
 209   /*    cvt table, it will only be called once.)                           */
 210   /*                                                                       */
 211   static FT_Short*
 212   ft_var_readpackeddeltas( FT_Stream  stream,
 213                            FT_Offset  delta_cnt )
 214   {
 215     FT_Short  *deltas = NULL;
 216     FT_UInt    runcnt;
 217     FT_Offset  i;
 218     FT_UInt    j;
 219     FT_Memory  memory = stream->memory;
 220     FT_Error   error  = FT_Err_Ok;
 221
 222     FT_UNUSED( error );
 223
 224
 225     if ( FT_NEW_ARRAY( deltas, delta_cnt ) )
 226       return NULL;
 227
 228     i = 0;
 229     while ( i < delta_cnt )
 230     {
 231       runcnt = FT_GET_BYTE();
 232       if ( runcnt & GX_DT_DELTAS_ARE_ZERO )
 233       {
 234         /* runcnt zeroes get added */
 235         for ( j = 0;
 236               j <= ( runcnt & GX_DT_DELTA_RUN_COUNT_MASK ) && i < delta_cnt;
 237               ++j )
 238           deltas[i++] = 0;
 239       }
 240       else if ( runcnt & GX_DT_DELTAS_ARE_WORDS )
 241       {
 242         /* runcnt shorts from the stack */
 243         for ( j = 0;
 244               j <= ( runcnt & GX_DT_DELTA_RUN_COUNT_MASK ) && i < delta_cnt;
 245               ++j )
 246           deltas[i++] = FT_GET_SHORT();
 247       }
 248       else
 249       {
 250         /* runcnt signed bytes from the stack */
 251         for ( j = 0;
 252               j <= ( runcnt & GX_DT_DELTA_RUN_COUNT_MASK ) && i < delta_cnt;
 253               ++j )
 254           deltas[i++] = FT_GET_CHAR();
 255       }
 256
 257       if ( j <= ( runcnt & GX_DT_DELTA_RUN_COUNT_MASK ) )
 258       {
 259         /* Bad format */
 260         FT_FREE( deltas );
 261         return NULL;
 262       }
 263     }
 264
 265     return deltas;
 266   }
 267
 268
 269   /*************************************************************************/
 270   /*                                                                       */
 271   /* <Function>                                                            */
 272   /*    ft_var_load_avar                                                   */
 273   /*                                                                       */
 274   /* <Description>                                                         */
 275   /*    Parse the `avar' table if present.  It need not be, so we return   */
 276   /*    nothing.                                                           */
 277   /*                                                                       */
 278   /* <InOut>                                                               */
 279   /*    face :: The font face.                                             */
 280   /*                                                                       */
 281   static void
 282   ft_var_load_avar( TT_Face  face )
 283   {
 284     FT_Stream       stream = FT_FACE_STREAM(face);
 285     FT_Memory       memory = stream->memory;
 286     GX_Blend        blend  = face->blend;
 287     GX_AVarSegment  segment;
 288     FT_Error        error = FT_Err_Ok;
 289     FT_ULong        version;
 290     FT_Long         axisCount;
 291     FT_Int          i, j;
 292     FT_ULong        table_len;
 293
 294     FT_UNUSED( error );
 295
 296
 297     blend->avar_checked = TRUE;
 298     if ( (error = face->goto_table( face, TTAG_avar, stream, &table_len )) != 0 )
 299       return;
 300
 301     if ( FT_FRAME_ENTER( table_len ) )
 302       return;
 303
 304     version   = FT_GET_LONG();
 305     axisCount = FT_GET_LONG();
 306
 307     if ( version != 0x00010000L                       ||
 308          axisCount != (FT_Long)blend->mmvar->num_axis )
 309       goto Exit;
 310
 311     if ( FT_NEW_ARRAY( blend->avar_segment, axisCount ) )
 312       goto Exit;
 313
 314     segment = &blend->avar_segment[0];
 315     for ( i = 0; i < axisCount; ++i, ++segment )
 316     {
 317       segment->pairCount = FT_GET_USHORT();
 318       if ( FT_NEW_ARRAY( segment->correspondence, segment->pairCount ) )
 319       {
 320         /* Failure.  Free everything we have done so far.  We must do */
 321         /* it right now since loading the `avar' table is optional.   */
 322
 323         for ( j = i - 1; j >= 0; --j )
 324           FT_FREE( blend->avar_segment[j].correspondence );
 325
 326         FT_FREE( blend->avar_segment );
 327         blend->avar_segment = NULL;
 328         goto Exit;
 329       }
 330
 331       for ( j = 0; j < segment->pairCount; ++j )
 332       {
 333         segment->correspondence[j].fromCoord =
 334           FT_GET_SHORT() << 2;    /* convert to Fixed */
 335         segment->correspondence[j].toCoord =
 336           FT_GET_SHORT()<<2;    /* convert to Fixed */
 337       }
 338     }
 339
 340   Exit:
 341     FT_FRAME_EXIT();
 342   }
 343
 344
 345   typedef struct  GX_GVar_Head_
 346   {
 347     FT_Long    version;
 348     FT_UShort  axisCount;
 349     FT_UShort  globalCoordCount;
 350     FT_ULong   offsetToCoord;
 351     FT_UShort  glyphCount;
 352     FT_UShort  flags;
 353     FT_ULong   offsetToData;
 354
 355   } GX_GVar_Head;
 356
 357
 358   /*************************************************************************/
 359   /*                                                                       */
 360   /* <Function>                                                            */
 361   /*    ft_var_load_gvar                                                   */
 362   /*                                                                       */
 363   /* <Description>                                                         */
 364   /*    Parses the `gvar' table if present.  If `fvar' is there, `gvar'    */
 365   /*    had better be there too.                                           */
 366   /*                                                                       */
 367   /* <InOut>                                                               */
 368   /*    face :: The font face.                                             */
 369   /*                                                                       */
 370   /* <Return>                                                              */
 371   /*    FreeType error code.  0 means success.                             */
 372   /*                                                                       */
 373   static FT_Error
 374   ft_var_load_gvar( TT_Face  face )
 375   {
 376     FT_Stream     stream = FT_FACE_STREAM(face);
 377     FT_Memory     memory = stream->memory;
 378     GX_Blend      blend  = face->blend;
 379     FT_Error      error;
 380     FT_UInt       i, j;
 381     FT_ULong      table_len;
 382     FT_ULong      gvar_start;
 383     FT_ULong      offsetToData;
 384     GX_GVar_Head  gvar_head;
 385
 386     static const FT_Frame_Field  gvar_fields[] =
 387     {
 388
 389 #undef  FT_STRUCTURE
 390 #define FT_STRUCTURE  GX_GVar_Head
 391
 392       FT_FRAME_START( 20 ),
 393         FT_FRAME_LONG  ( version ),
 394         FT_FRAME_USHORT( axisCount ),
 395         FT_FRAME_USHORT( globalCoordCount ),
 396         FT_FRAME_ULONG ( offsetToCoord ),
 397         FT_FRAME_USHORT( glyphCount ),
 398         FT_FRAME_USHORT( flags ),
 399         FT_FRAME_ULONG ( offsetToData ),
 400       FT_FRAME_END
 401     };
 402
 403     if ( (error = face->goto_table( face, TTAG_gvar, stream, &table_len )) != 0 )
 404       goto Exit;
 405
 406     gvar_start = FT_STREAM_POS( );
 407     if ( FT_STREAM_READ_FIELDS( gvar_fields, &gvar_head ) )
 408       goto Exit;
 409
 410     blend->tuplecount  = gvar_head.globalCoordCount;
 411     blend->gv_glyphcnt = gvar_head.glyphCount;
 412     offsetToData       = gvar_start + gvar_head.offsetToData;
 413
 414     if ( gvar_head.version   != (FT_Long)0x00010000L              ||
 415          gvar_head.axisCount != (FT_UShort)blend->mmvar->num_axis )
 416     {
 417       error = FT_THROW( Invalid_Table );
 418       goto Exit;
 419     }
 420
 421     if ( FT_NEW_ARRAY( blend->glyphoffsets, blend->gv_glyphcnt + 1 ) )
 422       goto Exit;
 423
 424     if ( gvar_head.flags & 1 )
 425     {
 426       /* long offsets (one more offset than glyphs, to mark size of last) */
 427       if ( FT_FRAME_ENTER( ( blend->gv_glyphcnt + 1 ) * 4L ) )
 428         goto Exit;
 429
 430       for ( i = 0; i <= blend->gv_glyphcnt; ++i )
 431         blend->glyphoffsets[i] = offsetToData + FT_GET_LONG();
 432
 433       FT_FRAME_EXIT();
 434     }
 435     else
 436     {
 437       /* short offsets (one more offset than glyphs, to mark size of last) */
 438       if ( FT_FRAME_ENTER( ( blend->gv_glyphcnt + 1 ) * 2L ) )
 439         goto Exit;
 440
 441       for ( i = 0; i <= blend->gv_glyphcnt; ++i )
 442         blend->glyphoffsets[i] = offsetToData + FT_GET_USHORT() * 2;
 443                                               /* XXX: Undocumented: `*2'! */
 444
 445       FT_FRAME_EXIT();
 446     }
 447
 448     if ( blend->tuplecount != 0 )
 449     {
 450       if ( FT_NEW_ARRAY( blend->tuplecoords,
 451                          gvar_head.axisCount * blend->tuplecount ) )
 452         goto Exit;
 453
 454       if ( FT_STREAM_SEEK( gvar_start + gvar_head.offsetToCoord )       ||
 455            FT_FRAME_ENTER( blend->tuplecount * gvar_head.axisCount * 2L )                   )
 456         goto Exit;
 457
 458       for ( i = 0; i < blend->tuplecount; ++i )
 459         for ( j = 0 ; j < (FT_UInt)gvar_head.axisCount; ++j )
 460           blend->tuplecoords[i * gvar_head.axisCount + j] =
 461             FT_GET_SHORT() << 2;                /* convert to FT_Fixed */
 462
 463       FT_FRAME_EXIT();
 464     }
 465
 466   Exit:
 467     return error;
 468   }
 469
 470
 471   /*************************************************************************/
 472   /*                                                                       */
 473   /* <Function>                                                            */
 474   /*    ft_var_apply_tuple                                                 */
 475   /*                                                                       */
 476   /* <Description>                                                         */
 477   /*    Figure out whether a given tuple (design) applies to the current   */
 478   /*    blend, and if so, what is the scaling factor.                      */
 479   /*                                                                       */
 480   /* <Input>                                                               */
 481   /*    blend           :: The current blend of the font.                  */
 482   /*                                                                       */
 483   /*    tupleIndex      :: A flag saying whether this is an intermediate   */
 484   /*                       tuple or not.                                   */
 485   /*                                                                       */
 486   /*    tuple_coords    :: The coordinates of the tuple in normalized axis */
 487   /*                       units.                                          */
 488   /*                                                                       */
 489   /*    im_start_coords :: The initial coordinates where this tuple starts */
 490   /*                       to apply (for intermediate coordinates).        */
 491   /*                                                                       */
 492   /*    im_end_coords   :: The final coordinates after which this tuple no */
 493   /*                       longer applies (for intermediate coordinates).  */
 494   /*                                                                       */
 495   /* <Return>                                                              */
 496   /*    An FT_Fixed value containing the scaling factor.                   */
 497   /*                                                                       */
 498   static FT_Fixed
 499   ft_var_apply_tuple( GX_Blend   blend,
 500                       FT_UShort  tupleIndex,
 501                       FT_Fixed*  tuple_coords,
 502                       FT_Fixed*  im_start_coords,
 503                       FT_Fixed*  im_end_coords )
 504   {
 505     FT_UInt   i;
 506     FT_Fixed  apply = 0x10000L;
 507
 508
 509     for ( i = 0; i < blend->num_axis; ++i )
 510     {
 511       if ( tuple_coords[i] == 0 )
 512         /* It's not clear why (for intermediate tuples) we don't need     */
 513         /* to check against start/end -- the documentation says we don't. */
 514         /* Similarly, it's unclear why we don't need to scale along the   */
 515         /* axis.                                                          */
 516         continue;
 517
 518       else if ( blend->normalizedcoords[i] == 0                           ||
 519                 ( blend->normalizedcoords[i] < 0 && tuple_coords[i] > 0 ) ||
 520                 ( blend->normalizedcoords[i] > 0 && tuple_coords[i] < 0 ) )
 521       {
 522         apply = 0;
 523         break;
 524       }
 525
 526       else if ( !( tupleIndex & GX_TI_INTERMEDIATE_TUPLE ) )
 527         /* not an intermediate tuple */
 528         apply = FT_MulFix( apply,
 529                            blend->normalizedcoords[i] > 0
 530                              ? blend->normalizedcoords[i]
 531                              : -blend->normalizedcoords[i] );
 532
 533       else if ( blend->normalizedcoords[i] <= im_start_coords[i] ||
 534                 blend->normalizedcoords[i] >= im_end_coords[i]   )
 535       {
 536         apply = 0;
 537         break;
 538       }
 539
 540       else if ( blend->normalizedcoords[i] < tuple_coords[i] )
 541         apply = FT_MulDiv( apply,
 542                            blend->normalizedcoords[i] - im_start_coords[i],
 543                            tuple_coords[i] - im_start_coords[i] );
 544
 545       else
 546         apply = FT_MulDiv( apply,
 547                            im_end_coords[i] - blend->normalizedcoords[i],
 548                            im_end_coords[i] - tuple_coords[i] );
 549     }
 550
 551     return apply;
 552   }
 553
 554
 555   /*************************************************************************/
 556   /*************************************************************************/
 557   /*****                                                               *****/
 558   /*****               MULTIPLE MASTERS SERVICE FUNCTIONS              *****/
 559   /*****                                                               *****/
 560   /*************************************************************************/
 561   /*************************************************************************/
 562
 563
 564   typedef struct  GX_FVar_Head_
 565   {
 566     FT_Long    version;
 567     FT_UShort  offsetToData;
 568     FT_UShort  countSizePairs;
 569     FT_UShort  axisCount;
 570     FT_UShort  axisSize;
 571     FT_UShort  instanceCount;
 572     FT_UShort  instanceSize;
 573
 574   } GX_FVar_Head;
 575
 576
 577   typedef struct  fvar_axis_
 578   {
 579     FT_ULong   axisTag;
 580     FT_ULong   minValue;
 581     FT_ULong   defaultValue;
 582     FT_ULong   maxValue;
 583     FT_UShort  flags;
 584     FT_UShort  nameID;
 585
 586   } GX_FVar_Axis;
 587
 588
 589   /*************************************************************************/
 590   /*                                                                       */
 591   /* <Function>                                                            */
 592   /*    TT_Get_MM_Var                                                      */
 593   /*                                                                       */
 594   /* <Description>                                                         */
 595   /*    Check that the font's `fvar' table is valid, parse it, and return  */
 596   /*    those data.                                                        */
 597   /*                                                                       */
 598   /* <InOut>                                                               */
 599   /*    face   :: The font face.                                           */
 600   /*              TT_Get_MM_Var initializes the blend structure.           */
 601   /*                                                                       */
 602   /* <Output>                                                              */
 603   /*    master :: The `fvar' data (must be freed by caller).               */
 604   /*                                                                       */
 605   /* <Return>                                                              */
 606   /*    FreeType error code.  0 means success.                             */
 607   /*                                                                       */
 608   FT_LOCAL_DEF( FT_Error )
 609   TT_Get_MM_Var( TT_Face      face,
 610                  FT_MM_Var*  *master )
 611   {
 612     FT_Stream            stream = face->root.stream;
 613     FT_Memory            memory = face->root.memory;
 614     FT_ULong             table_len;
 615     FT_Error             error  = FT_Err_Ok;
 616     FT_ULong             fvar_start;
 617     FT_Int               i, j;
 618     FT_MM_Var*           mmvar = NULL;
 619     FT_Fixed*            next_coords;
 620     FT_String*           next_name;
 621     FT_Var_Axis*         a;
 622     FT_Var_Named_Style*  ns;
 623     GX_FVar_Head         fvar_head;
 624
 625     static const FT_Frame_Field  fvar_fields[] =
 626     {
 627
 628 #undef  FT_STRUCTURE
 629 #define FT_STRUCTURE  GX_FVar_Head
 630
 631       FT_FRAME_START( 16 ),
 632         FT_FRAME_LONG  ( version ),
 633         FT_FRAME_USHORT( offsetToData ),
 634         FT_FRAME_USHORT( countSizePairs ),
 635         FT_FRAME_USHORT( axisCount ),
 636         FT_FRAME_USHORT( axisSize ),
 637         FT_FRAME_USHORT( instanceCount ),
 638         FT_FRAME_USHORT( instanceSize ),
 639       FT_FRAME_END
 640     };
 641
 642     static const FT_Frame_Field  fvaraxis_fields[] =
 643     {
 644
 645 #undef  FT_STRUCTURE
 646 #define FT_STRUCTURE  GX_FVar_Axis
 647
 648       FT_FRAME_START( 20 ),
 649         FT_FRAME_ULONG ( axisTag ),
 650         FT_FRAME_ULONG ( minValue ),
 651         FT_FRAME_ULONG ( defaultValue ),
 652         FT_FRAME_ULONG ( maxValue ),
 653         FT_FRAME_USHORT( flags ),
 654         FT_FRAME_USHORT( nameID ),
 655       FT_FRAME_END
 656     };
 657
 658
 659     if ( face->blend == NULL )
 660     {
 661       /* both `fvar' and `gvar' must be present */
 662       if ( (error = face->goto_table( face, TTAG_gvar,
 663                                       stream, &table_len )) != 0 )
 664         goto Exit;
 665
 666       if ( (error = face->goto_table( face, TTAG_fvar,
 667                                       stream, &table_len )) != 0 )
 668         goto Exit;
 669
 670       fvar_start = FT_STREAM_POS( );
 671
 672       if ( FT_STREAM_READ_FIELDS( fvar_fields, &fvar_head ) )
 673         goto Exit;
 674
 675       if ( fvar_head.version != (FT_Long)0x00010000L                      ||
 676            fvar_head.countSizePairs != 2                                  ||
 677            fvar_head.axisSize != 20                                       ||
 678            /* axisCount limit implied by 16-bit instanceSize */
 679            fvar_head.axisCount > 0x3FFE                                   ||
 680            fvar_head.instanceSize != 4 + 4 * fvar_head.axisCount          ||
 681            /* instanceCount limit implied by limited range of name IDs */
 682            fvar_head.instanceCount > 0x7EFF                               ||
 683            fvar_head.offsetToData + fvar_head.axisCount * 20U +
 684              fvar_head.instanceCount * fvar_head.instanceSize > table_len )
 685       {
 686         error = FT_THROW( Invalid_Table );
 687         goto Exit;
 688       }
 689
 690       if ( FT_NEW( face->blend ) )
 691         goto Exit;
 692
 693       /* cannot overflow 32-bit arithmetic because of limits above */
 694       face->blend->mmvar_len =
 695         sizeof ( FT_MM_Var ) +
 696         fvar_head.axisCount * sizeof ( FT_Var_Axis ) +
 697         fvar_head.instanceCount * sizeof ( FT_Var_Named_Style ) +
 698         fvar_head.instanceCount * fvar_head.axisCount * sizeof ( FT_Fixed ) +
 699         5 * fvar_head.axisCount;
 700
 701       if ( FT_ALLOC( mmvar, face->blend->mmvar_len ) )
 702         goto Exit;
 703       face->blend->mmvar = mmvar;
 704
 705       mmvar->num_axis =
 706         fvar_head.axisCount;
 707       mmvar->num_designs =
 708         ~0U;                   /* meaningless in this context; each glyph */
 709                                /* may have a different number of designs  */
 710                                /* (or tuples, as called by Apple)         */
 711       mmvar->num_namedstyles =
 712         fvar_head.instanceCount;
 713       mmvar->axis =
 714         (FT_Var_Axis*)&(mmvar[1]);
 715       mmvar->namedstyle =
 716         (FT_Var_Named_Style*)&(mmvar->axis[fvar_head.axisCount]);
 717
 718       next_coords =
 719         (FT_Fixed*)&(mmvar->namedstyle[fvar_head.instanceCount]);
 720       for ( i = 0; i < fvar_head.instanceCount; ++i )
 721       {
 722         mmvar->namedstyle[i].coords  = next_coords;
 723         next_coords                 += fvar_head.axisCount;
 724       }
 725
 726       next_name = (FT_String*)next_coords;
 727       for ( i = 0; i < fvar_head.axisCount; ++i )
 728       {
 729         mmvar->axis[i].name  = next_name;
 730         next_name           += 5;
 731       }
 732
 733       if ( FT_STREAM_SEEK( fvar_start + fvar_head.offsetToData ) )
 734         goto Exit;
 735
 736       a = mmvar->axis;
 737       for ( i = 0; i < fvar_head.axisCount; ++i )
 738       {
 739         GX_FVar_Axis  axis_rec;
 740
 741
 742         if ( FT_STREAM_READ_FIELDS( fvaraxis_fields, &axis_rec ) )
 743           goto Exit;
 744         a->tag     = axis_rec.axisTag;
 745         a->minimum = axis_rec.minValue;     /* A Fixed */
 746         a->def     = axis_rec.defaultValue; /* A Fixed */
 747         a->maximum = axis_rec.maxValue;     /* A Fixed */
 748         a->strid   = axis_rec.nameID;
 749
 750         a->name[0] = (FT_String)(   a->tag >> 24 );
 751         a->name[1] = (FT_String)( ( a->tag >> 16 ) & 0xFF );
 752         a->name[2] = (FT_String)( ( a->tag >>  8 ) & 0xFF );
 753         a->name[3] = (FT_String)( ( a->tag       ) & 0xFF );
 754         a->name[4] = 0;
 755
 756         ++a;
 757       }
 758
 759       ns = mmvar->namedstyle;
 760       for ( i = 0; i < fvar_head.instanceCount; ++i, ++ns )
 761       {
 762         if ( FT_FRAME_ENTER( 4L + 4L * fvar_head.axisCount ) )
 763           goto Exit;
 764
 765         ns->strid       =    FT_GET_USHORT();
 766         (void) /* flags = */ FT_GET_USHORT();
 767
 768         for ( j = 0; j < fvar_head.axisCount; ++j )
 769           ns->coords[j] = FT_GET_ULONG();     /* A Fixed */
 770
 771         FT_FRAME_EXIT();
 772       }
 773     }
 774
 775     if ( master != NULL )
 776     {
 777       FT_UInt  n;
 778
 779
 780       if ( FT_ALLOC( mmvar, face->blend->mmvar_len ) )
 781         goto Exit;
 782       FT_MEM_COPY( mmvar, face->blend->mmvar, face->blend->mmvar_len );
 783
 784       mmvar->axis =
 785         (FT_Var_Axis*)&(mmvar[1]);
 786       mmvar->namedstyle =
 787         (FT_Var_Named_Style*)&(mmvar->axis[mmvar->num_axis]);
 788       next_coords =
 789         (FT_Fixed*)&(mmvar->namedstyle[mmvar->num_namedstyles]);
 790
 791       for ( n = 0; n < mmvar->num_namedstyles; ++n )
 792       {
 793         mmvar->namedstyle[n].coords  = next_coords;
 794         next_coords                 += mmvar->num_axis;
 795       }
 796
 797       a = mmvar->axis;
 798       next_name = (FT_String*)next_coords;
 799       for ( n = 0; n < mmvar->num_axis; ++n )
 800       {
 801         a->name = next_name;
 802
 803         /* standard PostScript names for some standard apple tags */
 804         if ( a->tag == TTAG_wght )
 805           a->name = (char *)"Weight";
 806         else if ( a->tag == TTAG_wdth )
 807           a->name = (char *)"Width";
 808         else if ( a->tag == TTAG_opsz )
 809           a->name = (char *)"OpticalSize";
 810         else if ( a->tag == TTAG_slnt )
 811           a->name = (char *)"Slant";
 812
 813         next_name += 5;
 814         ++a;
 815       }
 816
 817       *master = mmvar;
 818     }
 819
 820   Exit:
 821     return error;
 822   }
 823
 824
 825   /*************************************************************************/
 826   /*                                                                       */
 827   /* <Function>                                                            */
 828   /*    TT_Set_MM_Blend                                                    */
 829   /*                                                                       */
 830   /* <Description>                                                         */
 831   /*    Set the blend (normalized) coordinates for this instance of the    */
 832   /*    font.  Check that the `gvar' table is reasonable and does some     */
 833   /*    initial preparation.                                               */
 834   /*                                                                       */
 835   /* <InOut>                                                               */
 836   /*    face       :: The font.                                            */
 837   /*                  Initialize the blend structure with `gvar' data.     */
 838   /*                                                                       */
 839   /* <Input>                                                               */
 840   /*    num_coords :: Must be the axis count of the font.                  */
 841   /*                                                                       */
 842   /*    coords     :: An array of num_coords, each between [-1,1].         */
 843   /*                                                                       */
 844   /* <Return>                                                              */
 845   /*    FreeType error code.  0 means success.                             */
 846   /*                                                                       */
 847   FT_LOCAL_DEF( FT_Error )
 848   TT_Set_MM_Blend( TT_Face    face,
 849                    FT_UInt    num_coords,
 850                    FT_Fixed*  coords )
 851   {
 852     FT_Error    error = FT_Err_Ok;
 853     GX_Blend    blend;
 854     FT_MM_Var*  mmvar;
 855     FT_UInt     i;
 856     FT_Memory   memory = face->root.memory;
 857
 858     enum
 859     {
 860       mcvt_retain,
 861       mcvt_modify,
 862       mcvt_load
 863
 864     } manageCvt;
 865
 866
 867     face->doblend = FALSE;
 868
 869     if ( face->blend == NULL )
 870     {
 871       if ( (error = TT_Get_MM_Var( face, NULL)) != 0 )
 872         goto Exit;
 873     }
 874
 875     blend = face->blend;
 876     mmvar = blend->mmvar;
 877
 878     if ( num_coords != mmvar->num_axis )
 879     {
 880       error = FT_THROW( Invalid_Argument );
 881       goto Exit;
 882     }
 883
 884     for ( i = 0; i < num_coords; ++i )
 885       if ( coords[i] < -0x00010000L || coords[i] > 0x00010000L )
 886       {
 887         error = FT_THROW( Invalid_Argument );
 888         goto Exit;
 889       }
 890
 891     if ( blend->glyphoffsets == NULL )
 892       if ( (error = ft_var_load_gvar( face )) != 0 )
 893         goto Exit;
 894
 895     if ( blend->normalizedcoords == NULL )
 896     {
 897       if ( FT_NEW_ARRAY( blend->normalizedcoords, num_coords ) )
 898         goto Exit;
 899
 900       manageCvt = mcvt_modify;
 901
 902       /* If we have not set the blend coordinates before this, then the  */
 903       /* cvt table will still be what we read from the `cvt ' table and  */
 904       /* we don't need to reload it.  We may need to change it though... */
 905     }
 906     else
 907     {
 908       manageCvt = mcvt_retain;
 909       for ( i = 0; i < num_coords; ++i )
 910       {
 911         if ( blend->normalizedcoords[i] != coords[i] )
 912         {
 913           manageCvt = mcvt_load;
 914           break;
 915         }
 916       }
 917
 918       /* If we don't change the blend coords then we don't need to do  */
 919       /* anything to the cvt table.  It will be correct.  Otherwise we */
 920       /* no longer have the original cvt (it was modified when we set  */
 921       /* the blend last time), so we must reload and then modify it.   */
 922     }
 923
 924     blend->num_axis = num_coords;
 925     FT_MEM_COPY( blend->normalizedcoords,
 926                  coords,
 927                  num_coords * sizeof ( FT_Fixed ) );
 928
 929     face->doblend = TRUE;
 930
 931     if ( face->cvt != NULL )
 932     {
 933       switch ( manageCvt )
 934       {
 935       case mcvt_load:
 936         /* The cvt table has been loaded already; every time we change the */
 937         /* blend we may need to reload and remodify the cvt table.         */
 938         FT_FREE( face->cvt );
 939         face->cvt = NULL;
 940
 941         error = tt_face_load_cvt( face, face->root.stream );
 942         break;
 943
 944       case mcvt_modify:
 945         /* The original cvt table is in memory.  All we need to do is */
 946         /* apply the `cvar' table (if any).                           */
 947         error = tt_face_vary_cvt( face, face->root.stream );
 948         break;
 949
 950       case mcvt_retain:
 951         /* The cvt table is correct for this set of coordinates. */
 952         break;
 953       }
 954     }
 955
 956   Exit:
 957     return error;
 958   }
 959
 960
 961   /*************************************************************************/
 962   /*                                                                       */
 963   /* <Function>                                                            */
 964   /*    TT_Set_Var_Design                                                  */
 965   /*                                                                       */
 966   /* <Description>                                                         */
 967   /*    Set the coordinates for the instance, measured in the user         */
 968   /*    coordinate system.  Parse the `avar' table (if present) to convert */
 969   /*    from user to normalized coordinates.                               */
 970   /*                                                                       */
 971   /* <InOut>                                                               */
 972   /*    face       :: The font face.                                       */
 973   /*                  Initialize the blend struct with `gvar' data.        */
 974   /*                                                                       */
 975   /* <Input>                                                               */
 976   /*    num_coords :: This must be the axis count of the font.             */
 977   /*                                                                       */
 978   /*    coords     :: A coordinate array with `num_coords' elements.       */
 979   /*                                                                       */
 980   /* <Return>                                                              */
 981   /*    FreeType error code.  0 means success.                             */
 982   /*                                                                       */
 983   FT_LOCAL_DEF( FT_Error )
 984   TT_Set_Var_Design( TT_Face    face,
 985                      FT_UInt    num_coords,
 986                      FT_Fixed*  coords )
 987   {
 988     FT_Error        error      = FT_Err_Ok;
 989     FT_Fixed*       normalized = NULL;
 990     GX_Blend        blend;
 991     FT_MM_Var*      mmvar;
 992     FT_UInt         i, j;
 993     FT_Var_Axis*    a;
 994     GX_AVarSegment  av;
 995     FT_Memory       memory = face->root.memory;
 996
 997
 998     if ( face->blend == NULL )
 999     {
1000       if ( (error = TT_Get_MM_Var( face, NULL )) != 0 )
1001         goto Exit;
1002     }
1003
1004     blend = face->blend;
1005     mmvar = blend->mmvar;
1006
1007     if ( num_coords != mmvar->num_axis )
1008     {
1009       error = FT_THROW( Invalid_Argument );
1010       goto Exit;
1011     }
1012
1013     /* Axis normalization is a two stage process.  First we normalize */
1014     /* based on the [min,def,max] values for the axis to be [-1,0,1]. */
1015     /* Then, if there's an `avar' table, we renormalize this range.   */
1016
1017     if ( FT_NEW_ARRAY( normalized, mmvar->num_axis ) )
1018       goto Exit;
1019
1020     a = mmvar->axis;
1021     for ( i = 0; i < mmvar->num_axis; ++i, ++a )
1022     {
1023       if ( coords[i] > a->maximum || coords[i] < a->minimum )
1024       {
1025         error = FT_THROW( Invalid_Argument );
1026         goto Exit;
1027       }
1028
1029       if ( coords[i] < a->def )
1030         normalized[i] = -FT_DivFix( coords[i] - a->def, a->minimum - a->def );
1031       else if ( a->maximum == a->def )
1032         normalized[i] = 0;
1033       else
1034         normalized[i] = FT_DivFix( coords[i] - a->def, a->maximum - a->def );
1035     }
1036
1037     if ( !blend->avar_checked )
1038       ft_var_load_avar( face );
1039
1040     if ( blend->avar_segment != NULL )
1041     {
1042       av = blend->avar_segment;
1043       for ( i = 0; i < mmvar->num_axis; ++i, ++av )
1044       {
1045         for ( j = 1; j < (FT_UInt)av->pairCount; ++j )
1046           if ( normalized[i] < av->correspondence[j].fromCoord )
1047           {
1048             normalized[i] =
1049               FT_MulDiv( normalized[i] - av->correspondence[j - 1].fromCoord,
1050                          av->correspondence[j].toCoord -
1051                            av->correspondence[j - 1].toCoord,
1052                          av->correspondence[j].fromCoord -
1053                            av->correspondence[j - 1].fromCoord ) +
1054               av->correspondence[j - 1].toCoord;
1055             break;
1056           }
1057       }
1058     }
1059
1060     error = TT_Set_MM_Blend( face, num_coords, normalized );
1061
1062   Exit:
1063     FT_FREE( normalized );
1064     return error;
1065   }
1066
1067
1068   /*************************************************************************/
1069   /*************************************************************************/
1070   /*****                                                               *****/
1071   /*****                     GX VAR PARSING ROUTINES                   *****/
1072   /*****                                                               *****/
1073   /*************************************************************************/
1074   /*************************************************************************/
1075
1076
1077   /*************************************************************************/
1078   /*                                                                       */
1079   /* <Function>                                                            */
1080   /*    tt_face_vary_cvt                                                   */
1081   /*                                                                       */
1082   /* <Description>                                                         */
1083   /*    Modify the loaded cvt table according to the `cvar' table and the  */
1084   /*    font's blend.                                                      */
1085   /*                                                                       */
1086   /* <InOut>                                                               */
1087   /*    face   :: A handle to the target face object.                      */
1088   /*                                                                       */
1089   /* <Input>                                                               */
1090   /*    stream :: A handle to the input stream.                            */
1091   /*                                                                       */
1092   /* <Return>                                                              */
1093   /*    FreeType error code.  0 means success.                             */
1094   /*                                                                       */
1095   /*    Most errors are ignored.  It is perfectly valid not to have a      */
1096   /*    `cvar' table even if there is a `gvar' and `fvar' table.           */
1097   /*                                                                       */
1098   FT_LOCAL_DEF( FT_Error )
1099   tt_face_vary_cvt( TT_Face    face,
1100                     FT_Stream  stream )
1101   {
1102     FT_Error    error;
1103     FT_Memory   memory = stream->memory;
1104     FT_ULong    table_start;
1105     FT_ULong    table_len;
1106     FT_UInt     tupleCount;
1107     FT_ULong    offsetToData;
1108     FT_ULong    here;
1109     FT_UInt     i, j;
1110     FT_Fixed*   tuple_coords    = NULL;
1111     FT_Fixed*   im_start_coords = NULL;
1112     FT_Fixed*   im_end_coords   = NULL;
1113     GX_Blend    blend           = face->blend;
1114     FT_UInt     point_count;
1115     FT_UShort*  localpoints;
1116     FT_Short*   deltas;
1117
1118
1119     FT_TRACE2(( "CVAR " ));
1120
1121     if ( blend == NULL )
1122     {
1123       FT_TRACE2(( "tt_face_vary_cvt: no blend specified\n" ));
1124
1125       error = FT_Err_Ok;
1126       goto Exit;
1127     }
1128
1129     if ( face->cvt == NULL )
1130     {
1131       FT_TRACE2(( "tt_face_vary_cvt: no `cvt ' table\n" ));
1132
1133       error = FT_Err_Ok;
1134       goto Exit;
1135     }
1136
1137     error = face->goto_table( face, TTAG_cvar, stream, &table_len );
1138     if ( error )
1139     {
1140       FT_TRACE2(( "is missing\n" ));
1141
1142       error = FT_Err_Ok;
1143       goto Exit;
1144     }
1145
1146     if ( FT_FRAME_ENTER( table_len ) )
1147     {
1148       error = FT_Err_Ok;
1149       goto Exit;
1150     }
1151
1152     table_start = FT_Stream_FTell( stream );
1153     if ( FT_GET_LONG() != 0x00010000L )
1154     {
1155       FT_TRACE2(( "bad table version\n" ));
1156
1157       error = FT_Err_Ok;
1158       goto FExit;
1159     }
1160
1161     if ( FT_NEW_ARRAY( tuple_coords, blend->num_axis )    ||
1162          FT_NEW_ARRAY( im_start_coords, blend->num_axis ) ||
1163          FT_NEW_ARRAY( im_end_coords, blend->num_axis )   )
1164       goto FExit;
1165
1166     tupleCount   = FT_GET_USHORT();
1167     offsetToData = table_start + FT_GET_USHORT();
1168
1169     /* The documentation implies there are flags packed into the        */
1170     /* tuplecount, but John Jenkins says that shared points don't apply */
1171     /* to `cvar', and no other flags are defined.                       */
1172
1173     for ( i = 0; i < ( tupleCount & 0xFFF ); ++i )
1174     {
1175       FT_UInt   tupleDataSize;
1176       FT_UInt   tupleIndex;
1177       FT_Fixed  apply;
1178
1179
1180       tupleDataSize = FT_GET_USHORT();
1181       tupleIndex    = FT_GET_USHORT();
1182
1183       /* There is no provision here for a global tuple coordinate section, */
1184       /* so John says.  There are no tuple indices, just embedded tuples.  */
1185
1186       if ( tupleIndex & GX_TI_EMBEDDED_TUPLE_COORD )
1187       {
1188         for ( j = 0; j < blend->num_axis; ++j )
1189           tuple_coords[j] = FT_GET_SHORT() << 2; /* convert from        */
1190                                                  /* short frac to fixed */
1191       }
1192       else
1193       {
1194         /* skip this tuple; it makes no sense */
1195
1196         if ( tupleIndex & GX_TI_INTERMEDIATE_TUPLE )
1197           for ( j = 0; j < 2 * blend->num_axis; ++j )
1198             (void)FT_GET_SHORT();
1199
1200         offsetToData += tupleDataSize;
1201         continue;
1202       }
1203
1204       if ( tupleIndex & GX_TI_INTERMEDIATE_TUPLE )
1205       {
1206         for ( j = 0; j < blend->num_axis; ++j )
1207           im_start_coords[j] = FT_GET_SHORT() << 2;
1208         for ( j = 0; j < blend->num_axis; ++j )
1209           im_end_coords[j] = FT_GET_SHORT() << 2;
1210       }
1211
1212       apply = ft_var_apply_tuple( blend,
1213                                   (FT_UShort)tupleIndex,
1214                                   tuple_coords,
1215                                   im_start_coords,
1216                                   im_end_coords );
1217       if ( /* tuple isn't active for our blend */
1218            apply == 0                                    ||
1219            /* global points not allowed,           */
1220            /* if they aren't local, makes no sense */
1221            !( tupleIndex & GX_TI_PRIVATE_POINT_NUMBERS ) )
1222       {
1223         offsetToData += tupleDataSize;
1224         continue;
1225       }
1226
1227       here = FT_Stream_FTell( stream );
1228
1229       FT_Stream_SeekSet( stream, offsetToData );
1230
1231       localpoints = ft_var_readpackedpoints( stream, &point_count );
1232       deltas      = ft_var_readpackeddeltas( stream,
1233                                              point_count == 0 ? face->cvt_size
1234                                                               : point_count );
1235       if ( localpoints == NULL || deltas == NULL )
1236         /* failure, ignore it */;
1237
1238       else if ( localpoints == ALL_POINTS )
1239       {
1240         /* this means that there are deltas for every entry in cvt */
1241         for ( j = 0; j < face->cvt_size; ++j )
1242           face->cvt[j] = (FT_Short)( face->cvt[j] +
1243                                      FT_MulFix( deltas[j], apply ) );
1244       }
1245
1246       else
1247       {
1248         for ( j = 0; j < point_count; ++j )
1249         {
1250           int  pindex = localpoints[j];
1251
1252           face->cvt[pindex] = (FT_Short)( face->cvt[pindex] +
1253                                           FT_MulFix( deltas[j], apply ) );
1254         }
1255       }
1256
1257       if ( localpoints != ALL_POINTS )
1258         FT_FREE( localpoints );
1259       FT_FREE( deltas );
1260
1261       offsetToData += tupleDataSize;
1262
1263       FT_Stream_SeekSet( stream, here );
1264     }
1265
1266   FExit:
1267     FT_FRAME_EXIT();
1268
1269   Exit:
1270     FT_FREE( tuple_coords );
1271     FT_FREE( im_start_coords );
1272     FT_FREE( im_end_coords );
1273
1274     return error;
1275   }
1276
1277
1278   /*************************************************************************/
1279   /*                                                                       */
1280   /* <Function>                                                            */
1281   /*    TT_Vary_Get_Glyph_Deltas                                           */
1282   /*                                                                       */
1283   /* <Description>                                                         */
1284   /*    Load the appropriate deltas for the current glyph.                 */
1285   /*                                                                       */
1286   /* <Input>                                                               */
1287   /*    face        :: A handle to the target face object.                 */
1288   /*                                                                       */
1289   /*    glyph_index :: The index of the glyph being modified.              */
1290   /*                                                                       */
1291   /*    n_points    :: The number of the points in the glyph, including    */
1292   /*                   phantom points.                                     */
1293   /*                                                                       */
1294   /* <Output>                                                              */
1295   /*    deltas      :: The array of points to change.                      */
1296   /*                                                                       */
1297   /* <Return>                                                              */
1298   /*    FreeType error code.  0 means success.                             */
1299   /*                                                                       */
1300   FT_LOCAL_DEF( FT_Error )
1301   TT_Vary_Get_Glyph_Deltas( TT_Face      face,
1302                             FT_UInt      glyph_index,
1303                             FT_Vector*  *deltas,
1304                             FT_UInt      n_points )
1305   {
1306     FT_Stream   stream = face->root.stream;
1307     FT_Memory   memory = stream->memory;
1308     GX_Blend    blend  = face->blend;
1309     FT_Vector*  delta_xy = NULL;
1310
1311     FT_Error    error;
1312     FT_ULong    glyph_start;
1313     FT_UInt     tupleCount;
1314     FT_ULong    offsetToData;
1315     FT_ULong    here;
1316     FT_UInt     i, j;
1317     FT_Fixed*   tuple_coords    = NULL;
1318     FT_Fixed*   im_start_coords = NULL;
1319     FT_Fixed*   im_end_coords   = NULL;
1320     FT_UInt     point_count, spoint_count = 0;
1321     FT_UShort*  sharedpoints = NULL;
1322     FT_UShort*  localpoints  = NULL;
1323     FT_UShort*  points;
1324     FT_Short    *deltas_x, *deltas_y;
1325
1326
1327     if ( !face->doblend || blend == NULL )
1328       return FT_THROW( Invalid_Argument );
1329
1330     /* to be freed by the caller */
1331     if ( FT_NEW_ARRAY( delta_xy, n_points ) )
1332       goto Exit;
1333     *deltas = delta_xy;
1334
1335     if ( glyph_index >= blend->gv_glyphcnt      ||
1336          blend->glyphoffsets[glyph_index] ==
1337            blend->glyphoffsets[glyph_index + 1] )
1338       return FT_Err_Ok;               /* no variation data for this glyph */
1339
1340     if ( FT_STREAM_SEEK( blend->glyphoffsets[glyph_index] )   ||
1341          FT_FRAME_ENTER( blend->glyphoffsets[glyph_index + 1] -
1342                            blend->glyphoffsets[glyph_index] ) )
1343       goto Fail1;
1344
1345     glyph_start = FT_Stream_FTell( stream );
1346
1347     /* each set of glyph variation data is formatted similarly to `cvar' */
1348     /* (except we get shared points and global tuples)                   */
1349
1350     if ( FT_NEW_ARRAY( tuple_coords, blend->num_axis )    ||
1351          FT_NEW_ARRAY( im_start_coords, blend->num_axis ) ||
1352          FT_NEW_ARRAY( im_end_coords, blend->num_axis )   )
1353       goto Fail2;
1354
1355     tupleCount   = FT_GET_USHORT();
1356     offsetToData = glyph_start + FT_GET_USHORT();
1357
1358     if ( tupleCount & GX_TC_TUPLES_SHARE_POINT_NUMBERS )
1359     {
1360       here = FT_Stream_FTell( stream );
1361
1362       FT_Stream_SeekSet( stream, offsetToData );
1363
1364       sharedpoints = ft_var_readpackedpoints( stream, &spoint_count );
1365       offsetToData = FT_Stream_FTell( stream );
1366
1367       FT_Stream_SeekSet( stream, here );
1368     }
1369
1370     for ( i = 0; i < ( tupleCount & GX_TC_TUPLE_COUNT_MASK ); ++i )
1371     {
1372       FT_UInt   tupleDataSize;
1373       FT_UInt   tupleIndex;
1374       FT_Fixed  apply;
1375
1376
1377       tupleDataSize = FT_GET_USHORT();
1378       tupleIndex    = FT_GET_USHORT();
1379
1380       if ( tupleIndex & GX_TI_EMBEDDED_TUPLE_COORD )
1381       {
1382         for ( j = 0; j < blend->num_axis; ++j )
1383           tuple_coords[j] = FT_GET_SHORT() << 2;  /* convert from        */
1384                                                   /* short frac to fixed */
1385       }
1386       else if ( ( tupleIndex & GX_TI_TUPLE_INDEX_MASK ) >= blend->tuplecount )
1387       {
1388         error = FT_THROW( Invalid_Table );
1389         goto Fail3;
1390       }
1391       else
1392       {
1393         FT_MEM_COPY(
1394           tuple_coords,
1395           &blend->tuplecoords[(tupleIndex & 0xFFF) * blend->num_axis],
1396           blend->num_axis * sizeof ( FT_Fixed ) );
1397       }
1398
1399       if ( tupleIndex & GX_TI_INTERMEDIATE_TUPLE )
1400       {
1401         for ( j = 0; j < blend->num_axis; ++j )
1402           im_start_coords[j] = FT_GET_SHORT() << 2;
1403         for ( j = 0; j < blend->num_axis; ++j )
1404           im_end_coords[j] = FT_GET_SHORT() << 2;
1405       }
1406
1407       apply = ft_var_apply_tuple( blend,
1408                                   (FT_UShort)tupleIndex,
1409                                   tuple_coords,
1410                                   im_start_coords,
1411                                   im_end_coords );
1412
1413       if ( apply == 0 )              /* tuple isn't active for our blend */
1414       {
1415         offsetToData += tupleDataSize;
1416         continue;
1417       }
1418
1419       here = FT_Stream_FTell( stream );
1420
1421       if ( tupleIndex & GX_TI_PRIVATE_POINT_NUMBERS )
1422       {
1423         FT_Stream_SeekSet( stream, offsetToData );
1424
1425         localpoints = ft_var_readpackedpoints( stream, &point_count );
1426         points      = localpoints;
1427       }
1428       else
1429       {
1430         points      = sharedpoints;
1431         point_count = spoint_count;
1432       }
1433
1434       deltas_x = ft_var_readpackeddeltas( stream,
1435                                           point_count == 0 ? n_points
1436                                                            : point_count );
1437       deltas_y = ft_var_readpackeddeltas( stream,
1438                                           point_count == 0 ? n_points
1439                                                            : point_count );
1440
1441       if ( points == NULL || deltas_y == NULL || deltas_x == NULL )
1442         ; /* failure, ignore it */
1443
1444       else if ( points == ALL_POINTS )
1445       {
1446         /* this means that there are deltas for every point in the glyph */
1447         for ( j = 0; j < n_points; ++j )
1448         {
1449           delta_xy[j].x += FT_MulFix( deltas_x[j], apply );
1450           delta_xy[j].y += FT_MulFix( deltas_y[j], apply );
1451         }
1452       }
1453
1454       else
1455       {
1456         for ( j = 0; j < point_count; ++j )
1457         {
1458           if ( localpoints[j] >= n_points )
1459             continue;
1460
1461           delta_xy[localpoints[j]].x += FT_MulFix( deltas_x[j], apply );
1462           delta_xy[localpoints[j]].y += FT_MulFix( deltas_y[j], apply );
1463         }
1464       }
1465
1466       if ( localpoints != ALL_POINTS )
1467         FT_FREE( localpoints );
1468       FT_FREE( deltas_x );
1469       FT_FREE( deltas_y );
1470
1471       offsetToData += tupleDataSize;
1472
1473       FT_Stream_SeekSet( stream, here );
1474     }
1475
1476   Fail3:
1477     FT_FREE( tuple_coords );
1478     FT_FREE( im_start_coords );
1479     FT_FREE( im_end_coords );
1480
1481   Fail2:
1482     FT_FRAME_EXIT();
1483
1484   Fail1:
1485     if ( error )
1486     {
1487       FT_FREE( delta_xy );
1488       *deltas = NULL;
1489     }
1490
1491   Exit:
1492     return error;
1493   }
1494
1495
1496   /*************************************************************************/
1497   /*                                                                       */
1498   /* <Function>                                                            */
1499   /*    tt_done_blend                                                      */
1500   /*                                                                       */
1501   /* <Description>                                                         */
1502   /*    Frees the blend internal data structure.                           */
1503   /*                                                                       */
1504   FT_LOCAL_DEF( void )
1505   tt_done_blend( FT_Memory  memory,
1506                  GX_Blend   blend )
1507   {
1508     if ( blend != NULL )
1509     {
1510       FT_UInt  i;
1511
1512
1513       FT_FREE( blend->normalizedcoords );
1514       FT_FREE( blend->mmvar );
1515
1516       if ( blend->avar_segment != NULL )
1517       {
1518         for ( i = 0; i < blend->num_axis; ++i )
1519           FT_FREE( blend->avar_segment[i].correspondence );
1520         FT_FREE( blend->avar_segment );
1521       }
1522
1523       FT_FREE( blend->tuplecoords );
1524       FT_FREE( blend->glyphoffsets );
1525       FT_FREE( blend );
1526     }
1527   }
1528
1529 #endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */
1530
1531
1532 /* END */