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