ref: 758d55e522eb426dad2f15adc1d945f7896d7b29
dir: /src/truetype/ttgxvar.c/
/***************************************************************************/ /* */ /* ttgxvar.c */ /* */ /* TrueType GX Font Variation loader */ /* */ /* Copyright 2004-2015 by */ /* David Turner, Robert Wilhelm, Werner Lemberg, and George Williams. */ /* */ /* This file is part of the FreeType project, and may only be used, */ /* modified, and distributed under the terms of the FreeType project */ /* license, LICENSE.TXT. By continuing to use, modify, or distribute */ /* this file you indicate that you have read the license and */ /* understand and accept it fully. */ /* */ /***************************************************************************/ /*************************************************************************/ /* */ /* Apple documents the `fvar', `gvar', `cvar', and `avar' tables at */ /* */ /* https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6[fgca]var.html */ /* */ /* The documentation for `fvar' is inconsistent. At one point it says */ /* that `countSizePairs' should be 3, at another point 2. It should */ /* be 2. */ /* */ /* The documentation for `gvar' is not intelligible; `cvar' refers you */ /* to `gvar' and is thus also incomprehensible. */ /* */ /* The documentation for `avar' appears correct, but Apple has no fonts */ /* with an `avar' table, so it is hard to test. */ /* */ /* Many thanks to John Jenkins (at Apple) in figuring this out. */ /* */ /* */ /* Apple's `kern' table has some references to tuple indices, but as */ /* there is no indication where these indices are defined, nor how to */ /* interpolate the kerning values (different tuples have different */ /* classes) this issue is ignored. */ /* */ /*************************************************************************/ #include <ft2build.h> #include FT_INTERNAL_DEBUG_H #include FT_CONFIG_CONFIG_H #include FT_INTERNAL_STREAM_H #include FT_INTERNAL_SFNT_H #include FT_TRUETYPE_TAGS_H #include FT_MULTIPLE_MASTERS_H #include "ttpload.h" #include "ttgxvar.h" #include "tterrors.h" #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT #define FT_Stream_FTell( stream ) \ (FT_ULong)( (stream)->cursor - (stream)->base ) #define FT_Stream_SeekSet( stream, off ) \ ( (stream)->cursor = (stream)->base + (off) ) /*************************************************************************/ /* */ /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ /* messages during execution. */ /* */ #undef FT_COMPONENT #define FT_COMPONENT trace_ttgxvar /*************************************************************************/ /*************************************************************************/ /***** *****/ /***** Internal Routines *****/ /***** *****/ /*************************************************************************/ /*************************************************************************/ /*************************************************************************/ /* */ /* The macro ALL_POINTS is used in `ft_var_readpackedpoints'. It */ /* indicates that there is a delta for every point without needing to */ /* enumerate all of them. */ /* */ /* ensure that value `0' has the same width as a pointer */ #define ALL_POINTS (FT_UShort*)~(FT_PtrDist)0 #define GX_PT_POINTS_ARE_WORDS 0x80U #define GX_PT_POINT_RUN_COUNT_MASK 0x7FU /*************************************************************************/ /* */ /* <Function> */ /* ft_var_readpackedpoints */ /* */ /* <Description> */ /* Read a set of points to which the following deltas will apply. */ /* Points are packed with a run length encoding. */ /* */ /* <Input> */ /* stream :: The data stream. */ /* */ /* size :: The size of the table holding the data. */ /* */ /* <Output> */ /* point_cnt :: The number of points read. A zero value means that */ /* all points in the glyph will be affected, without */ /* enumerating them individually. */ /* */ /* <Return> */ /* An array of FT_UShort containing the affected points or the */ /* special value ALL_POINTS. */ /* */ static FT_UShort* ft_var_readpackedpoints( FT_Stream stream, FT_ULong size, FT_UInt *point_cnt ) { FT_UShort *points = NULL; FT_UInt n; FT_UInt runcnt; FT_UInt i, j; FT_UShort first; FT_Memory memory = stream->memory; FT_Error error = FT_Err_Ok; FT_UNUSED( error ); *point_cnt = 0; n = FT_GET_BYTE(); if ( n == 0 ) return ALL_POINTS; if ( n & GX_PT_POINTS_ARE_WORDS ) { n &= GX_PT_POINT_RUN_COUNT_MASK; n <<= 8; n |= FT_GET_BYTE(); } if ( n > size ) { FT_TRACE1(( "ft_var_readpackedpoints: number of points too large\n" )); return NULL; } if ( FT_NEW_ARRAY( points, n ) ) return NULL; *point_cnt = n; i = 0; while ( i < n ) { runcnt = FT_GET_BYTE(); if ( runcnt & GX_PT_POINTS_ARE_WORDS ) { runcnt &= GX_PT_POINT_RUN_COUNT_MASK; first = FT_GET_USHORT(); points[i++] = first; if ( runcnt < 1 || i + runcnt > n ) goto Exit; /* first point not included in run count */ for ( j = 0; j < runcnt; j++ ) { first += FT_GET_USHORT(); points[i++] = first; } } else { first = FT_GET_BYTE(); points[i++] = first; if ( runcnt < 1 || i + runcnt > n ) goto Exit; for ( j = 0; j < runcnt; j++ ) { first += FT_GET_BYTE(); points[i++] = first; } } } Exit: return points; } #define GX_DT_DELTAS_ARE_ZERO 0x80U #define GX_DT_DELTAS_ARE_WORDS 0x40U #define GX_DT_DELTA_RUN_COUNT_MASK 0x3FU /*************************************************************************/ /* */ /* <Function> */ /* ft_var_readpackeddeltas */ /* */ /* <Description> */ /* Read a set of deltas. These are packed slightly differently than */ /* points. In particular there is no overall count. */ /* */ /* <Input> */ /* stream :: The data stream. */ /* */ /* size :: The size of the table holding the data. */ /* */ /* delta_cnt :: The number of deltas to be read. */ /* */ /* <Return> */ /* An array of FT_Short containing the deltas for the affected */ /* points. (This only gets the deltas for one dimension. It will */ /* generally be called twice, once for x, once for y. When used in */ /* cvt table, it will only be called once.) */ /* */ static FT_Short* ft_var_readpackeddeltas( FT_Stream stream, FT_ULong size, FT_UInt delta_cnt ) { FT_Short *deltas = NULL; FT_UInt runcnt, cnt; FT_UInt i, j; FT_Memory memory = stream->memory; FT_Error error = FT_Err_Ok; FT_UNUSED( error ); if ( delta_cnt > size ) { FT_TRACE1(( "ft_var_readpackeddeltas: number of points too large\n" )); return NULL; } if ( FT_NEW_ARRAY( deltas, delta_cnt ) ) return NULL; i = 0; while ( i < delta_cnt ) { runcnt = FT_GET_BYTE(); cnt = runcnt & GX_DT_DELTA_RUN_COUNT_MASK; if ( runcnt & GX_DT_DELTAS_ARE_ZERO ) { /* `runcnt' zeroes get added */ for ( j = 0; j <= cnt && i < delta_cnt; j++ ) deltas[i++] = 0; } else if ( runcnt & GX_DT_DELTAS_ARE_WORDS ) { /* `runcnt' shorts from the stack */ for ( j = 0; j <= cnt && i < delta_cnt; j++ ) deltas[i++] = FT_GET_SHORT(); } else { /* `runcnt' signed bytes from the stack */ for ( j = 0; j <= cnt && i < delta_cnt; j++ ) deltas[i++] = FT_GET_CHAR(); } if ( j <= cnt ) { /* bad format */ FT_FREE( deltas ); return NULL; } } return deltas; } /*************************************************************************/ /* */ /* <Function> */ /* ft_var_load_avar */ /* */ /* <Description> */ /* Parse the `avar' table if present. It need not be, so we return */ /* nothing. */ /* */ /* <InOut> */ /* face :: The font face. */ /* */ static void ft_var_load_avar( TT_Face face ) { FT_Stream stream = FT_FACE_STREAM( face ); FT_Memory memory = stream->memory; GX_Blend blend = face->blend; GX_AVarSegment segment; FT_Error error = FT_Err_Ok; FT_Long version; FT_Long axisCount; FT_Int i, j; FT_ULong table_len; FT_UNUSED( error ); FT_TRACE2(( "AVAR " )); blend->avar_checked = TRUE; error = face->goto_table( face, TTAG_avar, stream, &table_len ); if ( error ) { FT_TRACE2(( "is missing\n" )); return; } if ( FT_FRAME_ENTER( table_len ) ) return; version = FT_GET_LONG(); axisCount = FT_GET_LONG(); if ( version != 0x00010000L ) { FT_TRACE2(( "bad table version\n" )); goto Exit; } FT_TRACE2(( "loaded\n" )); if ( axisCount != (FT_Long)blend->mmvar->num_axis ) { FT_TRACE2(( "ft_var_load_avar: number of axes in `avar' and `cvar'\n" " table are different\n" )); goto Exit; } if ( FT_NEW_ARRAY( blend->avar_segment, axisCount ) ) goto Exit; segment = &blend->avar_segment[0]; for ( i = 0; i < axisCount; i++, segment++ ) { FT_TRACE5(( " axis %d:\n", i )); segment->pairCount = FT_GET_USHORT(); if ( (FT_ULong)segment->pairCount * 4 > table_len || FT_NEW_ARRAY( segment->correspondence, segment->pairCount ) ) { /* Failure. Free everything we have done so far. We must do */ /* it right now since loading the `avar' table is optional. */ for ( j = i - 1; j >= 0; j-- ) FT_FREE( blend->avar_segment[j].correspondence ); FT_FREE( blend->avar_segment ); blend->avar_segment = NULL; goto Exit; } for ( j = 0; j < segment->pairCount; j++ ) { /* convert to Fixed */ segment->correspondence[j].fromCoord = FT_GET_SHORT() * 4; segment->correspondence[j].toCoord = FT_GET_SHORT() * 4; FT_TRACE5(( " mapping %.4f to %.4f\n", segment->correspondence[j].fromCoord / 65536.0, segment->correspondence[j].toCoord / 65536.0 )); } FT_TRACE5(( "\n" )); } Exit: FT_FRAME_EXIT(); } typedef struct GX_GVar_Head_ { FT_Long version; FT_UShort axisCount; FT_UShort globalCoordCount; FT_ULong offsetToCoord; FT_UShort glyphCount; FT_UShort flags; FT_ULong offsetToData; } GX_GVar_Head; /*************************************************************************/ /* */ /* <Function> */ /* ft_var_load_gvar */ /* */ /* <Description> */ /* Parse the `gvar' table if present. If `fvar' is there, `gvar' had */ /* better be there too. */ /* */ /* <InOut> */ /* face :: The font face. */ /* */ /* <Return> */ /* FreeType error code. 0 means success. */ /* */ static FT_Error ft_var_load_gvar( TT_Face face ) { FT_Stream stream = FT_FACE_STREAM( face ); FT_Memory memory = stream->memory; GX_Blend blend = face->blend; FT_Error error; FT_UInt i, j; FT_ULong table_len; FT_ULong gvar_start; FT_ULong offsetToData; GX_GVar_Head gvar_head; static const FT_Frame_Field gvar_fields[] = { #undef FT_STRUCTURE #define FT_STRUCTURE GX_GVar_Head FT_FRAME_START( 20 ), FT_FRAME_LONG ( version ), FT_FRAME_USHORT( axisCount ), FT_FRAME_USHORT( globalCoordCount ), FT_FRAME_ULONG ( offsetToCoord ), FT_FRAME_USHORT( glyphCount ), FT_FRAME_USHORT( flags ), FT_FRAME_ULONG ( offsetToData ), FT_FRAME_END }; FT_TRACE2(( "GVAR " )); if ( ( error = face->goto_table( face, TTAG_gvar, stream, &table_len ) ) != 0 ) { FT_TRACE2(( "is missing\n" )); goto Exit; } gvar_start = FT_STREAM_POS( ); if ( FT_STREAM_READ_FIELDS( gvar_fields, &gvar_head ) ) goto Exit; if ( gvar_head.version != 0x00010000L ) { FT_TRACE1(( "bad table version\n" )); error = FT_THROW( Invalid_Table ); goto Exit; } if ( gvar_head.axisCount != (FT_UShort)blend->mmvar->num_axis ) { FT_TRACE1(( "ft_var_load_gvar: number of axes in `gvar' and `cvar'\n" " table are different\n" )); error = FT_THROW( Invalid_Table ); goto Exit; } /* rough sanity check, ignoring offsets */ if ( (FT_ULong)gvar_head.globalCoordCount * gvar_head.axisCount > table_len / 2 ) { FT_TRACE1(( "ft_var_load_gvar:" " invalid number of global coordinates\n" )); error = FT_THROW( Invalid_Table ); goto Exit; } /* rough sanity check: offsets can be either 2 or 4 bytes, */ /* and a single variation needs at least 4 bytes per glyph */ if ( (FT_ULong)gvar_head.glyphCount * ( ( gvar_head.flags & 1 ) ? 8 : 6 ) > table_len ) { FT_TRACE1(( "ft_var_load_gvar: invalid number of glyphs\n" )); error = FT_THROW( Invalid_Table ); goto Exit; } FT_TRACE2(( "loaded\n" )); blend->gvar_size = table_len; blend->tuplecount = gvar_head.globalCoordCount; blend->gv_glyphcnt = gvar_head.glyphCount; offsetToData = gvar_start + gvar_head.offsetToData; FT_TRACE5(( "gvar: there are %d shared coordinates:\n", blend->tuplecount )); if ( FT_NEW_ARRAY( blend->glyphoffsets, blend->gv_glyphcnt + 1 ) ) goto Exit; if ( gvar_head.flags & 1 ) { /* long offsets (one more offset than glyphs, to mark size of last) */ if ( FT_FRAME_ENTER( ( blend->gv_glyphcnt + 1 ) * 4L ) ) goto Exit; for ( i = 0; i <= blend->gv_glyphcnt; i++ ) blend->glyphoffsets[i] = offsetToData + FT_GET_ULONG(); FT_FRAME_EXIT(); } else { /* short offsets (one more offset than glyphs, to mark size of last) */ if ( FT_FRAME_ENTER( ( blend->gv_glyphcnt + 1 ) * 2L ) ) goto Exit; for ( i = 0; i <= blend->gv_glyphcnt; i++ ) blend->glyphoffsets[i] = offsetToData + FT_GET_USHORT() * 2; /* XXX: Undocumented: `*2'! */ FT_FRAME_EXIT(); } if ( blend->tuplecount != 0 ) { if ( FT_NEW_ARRAY( blend->tuplecoords, gvar_head.axisCount * blend->tuplecount ) ) goto Exit; if ( FT_STREAM_SEEK( gvar_start + gvar_head.offsetToCoord ) || FT_FRAME_ENTER( blend->tuplecount * gvar_head.axisCount * 2L ) ) goto Exit; for ( i = 0; i < blend->tuplecount; i++ ) { FT_TRACE5(( " [ " )); for ( j = 0 ; j < (FT_UInt)gvar_head.axisCount; j++ ) { blend->tuplecoords[i * gvar_head.axisCount + j] = FT_GET_SHORT() * 4; /* convert to FT_Fixed */ FT_TRACE5(( "%.4f ", blend->tuplecoords[i * gvar_head.axisCount + j] / 65536.0 )); } FT_TRACE5(( "]\n" )); } FT_TRACE5(( "\n" )); FT_FRAME_EXIT(); } Exit: return error; } /*************************************************************************/ /* */ /* <Function> */ /* ft_var_apply_tuple */ /* */ /* <Description> */ /* Figure out whether a given tuple (design) applies to the current */ /* blend, and if so, what is the scaling factor. */ /* */ /* <Input> */ /* blend :: The current blend of the font. */ /* */ /* tupleIndex :: A flag saying whether this is an intermediate */ /* tuple or not. */ /* */ /* tuple_coords :: The coordinates of the tuple in normalized axis */ /* units. */ /* */ /* im_start_coords :: The initial coordinates where this tuple starts */ /* to apply (for intermediate coordinates). */ /* */ /* im_end_coords :: The final coordinates after which this tuple no */ /* longer applies (for intermediate coordinates). */ /* */ /* <Return> */ /* An FT_Fixed value containing the scaling factor. */ /* */ static FT_Fixed ft_var_apply_tuple( GX_Blend blend, FT_UShort tupleIndex, FT_Fixed* tuple_coords, FT_Fixed* im_start_coords, FT_Fixed* im_end_coords ) { FT_UInt i; FT_Fixed apply = 0x10000L; for ( i = 0; i < blend->num_axis; i++ ) { FT_TRACE6(( " axis coordinate %d (%.4f):\n", i, blend->normalizedcoords[i] / 65536.0 )); /* It's not clear why (for intermediate tuples) we don't need */ /* to check against start/end -- the documentation says we don't. */ /* Similarly, it's unclear why we don't need to scale along the */ /* axis. */ if ( tuple_coords[i] == 0 ) { FT_TRACE6(( " tuple coordinate is zero, ignored\n", i )); continue; } else if ( blend->normalizedcoords[i] == 0 ) { FT_TRACE6(( " axis coordinate is zero, stop\n" )); apply = 0; break; } else if ( ( blend->normalizedcoords[i] < 0 && tuple_coords[i] > 0 ) || ( blend->normalizedcoords[i] > 0 && tuple_coords[i] < 0 ) ) { FT_TRACE6(( " tuple coordinate value %.4f is exceeded, stop\n", tuple_coords[i] / 65536.0 )); apply = 0; break; } else if ( !( tupleIndex & GX_TI_INTERMEDIATE_TUPLE ) ) { FT_TRACE6(( " tuple coordinate value %.4f fits\n", tuple_coords[i] / 65536.0 )); /* not an intermediate tuple */ apply = FT_MulFix( apply, blend->normalizedcoords[i] > 0 ? blend->normalizedcoords[i] : -blend->normalizedcoords[i] ); } else if ( blend->normalizedcoords[i] < im_start_coords[i] || blend->normalizedcoords[i] > im_end_coords[i] ) { FT_TRACE6(( " intermediate tuple range [%.4f;%.4f] is exceeded," " stop\n", im_start_coords[i] / 65536.0, im_end_coords[i] / 65536.0 )); apply = 0; break; } else if ( blend->normalizedcoords[i] < tuple_coords[i] ) { FT_TRACE6(( " intermediate tuple range [%.4f;%.4f] fits\n", im_start_coords[i] / 65536.0, im_end_coords[i] / 65536.0 )); apply = FT_MulDiv( apply, blend->normalizedcoords[i] - im_start_coords[i], tuple_coords[i] - im_start_coords[i] ); } else { FT_TRACE6(( " intermediate tuple range [%.4f;%.4f] fits\n", im_start_coords[i] / 65536.0, im_end_coords[i] / 65536.0 )); apply = FT_MulDiv( apply, im_end_coords[i] - blend->normalizedcoords[i], im_end_coords[i] - tuple_coords[i] ); } } FT_TRACE6(( " apply factor is %.4f\n", apply / 65536.0 )); return apply; } /*************************************************************************/ /*************************************************************************/ /***** *****/ /***** MULTIPLE MASTERS SERVICE FUNCTIONS *****/ /***** *****/ /*************************************************************************/ /*************************************************************************/ typedef struct GX_FVar_Head_ { FT_Long version; FT_UShort offsetToData; FT_UShort countSizePairs; FT_UShort axisCount; FT_UShort axisSize; FT_UShort instanceCount; FT_UShort instanceSize; } GX_FVar_Head; typedef struct fvar_axis_ { FT_ULong axisTag; FT_Fixed minValue; FT_Fixed defaultValue; FT_Fixed maxValue; FT_UShort flags; FT_UShort nameID; } GX_FVar_Axis; /*************************************************************************/ /* */ /* <Function> */ /* TT_Get_MM_Var */ /* */ /* <Description> */ /* Check that the font's `fvar' table is valid, parse it, and return */ /* those data. */ /* */ /* <InOut> */ /* face :: The font face. */ /* TT_Get_MM_Var initializes the blend structure. */ /* */ /* <Output> */ /* master :: The `fvar' data (must be freed by caller). Can be NULL, */ /* which makes this function simply load MM support. */ /* */ /* <Return> */ /* FreeType error code. 0 means success. */ /* */ FT_LOCAL_DEF( FT_Error ) TT_Get_MM_Var( TT_Face face, FT_MM_Var* *master ) { FT_Stream stream = face->root.stream; FT_Memory memory = face->root.memory; FT_ULong table_len; FT_Error error = FT_Err_Ok; FT_ULong fvar_start; FT_Int i, j; FT_MM_Var* mmvar = NULL; FT_Fixed* next_coords; FT_String* next_name; FT_Var_Axis* a; FT_Var_Named_Style* ns; GX_FVar_Head fvar_head; static const FT_Frame_Field fvar_fields[] = { #undef FT_STRUCTURE #define FT_STRUCTURE GX_FVar_Head FT_FRAME_START( 16 ), FT_FRAME_LONG ( version ), FT_FRAME_USHORT( offsetToData ), FT_FRAME_USHORT( countSizePairs ), FT_FRAME_USHORT( axisCount ), FT_FRAME_USHORT( axisSize ), FT_FRAME_USHORT( instanceCount ), FT_FRAME_USHORT( instanceSize ), FT_FRAME_END }; static const FT_Frame_Field fvaraxis_fields[] = { #undef FT_STRUCTURE #define FT_STRUCTURE GX_FVar_Axis FT_FRAME_START( 20 ), FT_FRAME_ULONG ( axisTag ), FT_FRAME_LONG ( minValue ), FT_FRAME_LONG ( defaultValue ), FT_FRAME_LONG ( maxValue ), FT_FRAME_USHORT( flags ), FT_FRAME_USHORT( nameID ), FT_FRAME_END }; /* read the font data and set up the internal representation */ /* if not already done */ if ( face->blend == NULL ) { FT_TRACE2(( "FVAR " )); /* both `fvar' and `gvar' must be present */ if ( ( error = face->goto_table( face, TTAG_gvar, stream, &table_len ) ) != 0 ) { FT_TRACE1(( "\n" "TT_Get_MM_Var: `gvar' table is missing\n" )); goto Exit; } if ( ( error = face->goto_table( face, TTAG_fvar, stream, &table_len ) ) != 0 ) { FT_TRACE1(( "is missing\n" )); goto Exit; } fvar_start = FT_STREAM_POS( ); if ( FT_STREAM_READ_FIELDS( fvar_fields, &fvar_head ) ) goto Exit; if ( fvar_head.version != (FT_Long)0x00010000L || #if 0 /* fonts like `JamRegular.ttf' have an incorrect value for */ /* `countSizePairs'; since value 2 is hard-coded in `fvar' */ /* version 1.0, we simply ignore it */ fvar_head.countSizePairs != 2 || #endif fvar_head.axisSize != 20 || /* axisCount limit implied by 16-bit instanceSize */ fvar_head.axisCount > 0x3FFE || fvar_head.instanceSize != 4 + 4 * fvar_head.axisCount || /* instanceCount limit implied by limited range of name IDs */ fvar_head.instanceCount > 0x7EFF || fvar_head.offsetToData + fvar_head.axisCount * 20U + fvar_head.instanceCount * fvar_head.instanceSize > table_len ) { FT_TRACE1(( "\n" "TT_Get_MM_Var: invalid `fvar' header\n" )); error = FT_THROW( Invalid_Table ); goto Exit; } FT_TRACE2(( "loaded\n" )); FT_TRACE5(( "number of GX style axes: %d\n", fvar_head.axisCount )); if ( FT_NEW( face->blend ) ) goto Exit; /* cannot overflow 32-bit arithmetic because of limits above */ face->blend->mmvar_len = sizeof ( FT_MM_Var ) + fvar_head.axisCount * sizeof ( FT_Var_Axis ) + fvar_head.instanceCount * sizeof ( FT_Var_Named_Style ) + fvar_head.instanceCount * fvar_head.axisCount * sizeof ( FT_Fixed ) + 5 * fvar_head.axisCount; if ( FT_ALLOC( mmvar, face->blend->mmvar_len ) ) goto Exit; face->blend->mmvar = mmvar; /* set up pointers and offsets into the `mmvar' array; */ /* the data gets filled in later on */ mmvar->num_axis = fvar_head.axisCount; mmvar->num_designs = ~0U; /* meaningless in this context; each glyph */ /* may have a different number of designs */ /* (or tuples, as called by Apple) */ mmvar->num_namedstyles = fvar_head.instanceCount; mmvar->axis = (FT_Var_Axis*)&( mmvar[1] ); mmvar->namedstyle = (FT_Var_Named_Style*)&( mmvar->axis[fvar_head.axisCount] ); next_coords = (FT_Fixed*)&( mmvar->namedstyle[fvar_head.instanceCount] ); for ( i = 0; i < fvar_head.instanceCount; i++ ) { mmvar->namedstyle[i].coords = next_coords; next_coords += fvar_head.axisCount; } next_name = (FT_String*)next_coords; for ( i = 0; i < fvar_head.axisCount; i++ ) { mmvar->axis[i].name = next_name; next_name += 5; } /* now fill in the data */ if ( FT_STREAM_SEEK( fvar_start + fvar_head.offsetToData ) ) goto Exit; a = mmvar->axis; for ( i = 0; i < fvar_head.axisCount; i++ ) { GX_FVar_Axis axis_rec; if ( FT_STREAM_READ_FIELDS( fvaraxis_fields, &axis_rec ) ) goto Exit; a->tag = axis_rec.axisTag; a->minimum = axis_rec.minValue; a->def = axis_rec.defaultValue; a->maximum = axis_rec.maxValue; a->strid = axis_rec.nameID; a->name[0] = (FT_String)( a->tag >> 24 ); a->name[1] = (FT_String)( ( a->tag >> 16 ) & 0xFF ); a->name[2] = (FT_String)( ( a->tag >> 8 ) & 0xFF ); a->name[3] = (FT_String)( ( a->tag ) & 0xFF ); a->name[4] = '\0'; FT_TRACE5(( " \"%s\": minimum=%.4f, default=%.4f, maximum=%.4f\n", a->name, a->minimum / 65536.0, a->def / 65536.0, a->maximum / 65536.0 )); a++; } FT_TRACE5(( "\n" )); ns = mmvar->namedstyle; for ( i = 0; i < fvar_head.instanceCount; i++, ns++ ) { if ( FT_FRAME_ENTER( 4L + 4L * fvar_head.axisCount ) ) goto Exit; ns->strid = FT_GET_USHORT(); (void) /* flags = */ FT_GET_USHORT(); for ( j = 0; j < fvar_head.axisCount; j++ ) ns->coords[j] = FT_GET_LONG(); FT_FRAME_EXIT(); } } /* fill the output array if requested */ if ( master != NULL ) { FT_UInt n; if ( FT_ALLOC( mmvar, face->blend->mmvar_len ) ) goto Exit; FT_MEM_COPY( mmvar, face->blend->mmvar, face->blend->mmvar_len ); mmvar->axis = (FT_Var_Axis*)&( mmvar[1] ); mmvar->namedstyle = (FT_Var_Named_Style*)&( mmvar->axis[mmvar->num_axis] ); next_coords = (FT_Fixed*)&( mmvar->namedstyle[mmvar->num_namedstyles] ); for ( n = 0; n < mmvar->num_namedstyles; n++ ) { mmvar->namedstyle[n].coords = next_coords; next_coords += mmvar->num_axis; } a = mmvar->axis; next_name = (FT_String*)next_coords; for ( n = 0; n < mmvar->num_axis; n++ ) { a->name = next_name; /* standard PostScript names for some standard apple tags */ if ( a->tag == TTAG_wght ) a->name = (char*)"Weight"; else if ( a->tag == TTAG_wdth ) a->name = (char*)"Width"; else if ( a->tag == TTAG_opsz ) a->name = (char*)"OpticalSize"; else if ( a->tag == TTAG_slnt ) a->name = (char*)"Slant"; next_name += 5; a++; } *master = mmvar; } Exit: return error; } /*************************************************************************/ /* */ /* <Function> */ /* TT_Set_MM_Blend */ /* */ /* <Description> */ /* Set the blend (normalized) coordinates for this instance of the */ /* font. Check that the `gvar' table is reasonable and does some */ /* initial preparation. */ /* */ /* <InOut> */ /* face :: The font. */ /* Initialize the blend structure with `gvar' data. */ /* */ /* <Input> */ /* num_coords :: The number of available coordinates. If it is */ /* larger than the number of axes, ignore the excess */ /* values. If it is smaller than the number of axes, */ /* use the default value (0) for the remaining axes. */ /* */ /* coords :: An array of `num_coords', each between [-1,1]. */ /* */ /* <Return> */ /* FreeType error code. 0 means success. */ /* */ FT_LOCAL_DEF( FT_Error ) TT_Set_MM_Blend( TT_Face face, FT_UInt num_coords, FT_Fixed* coords ) { FT_Error error = FT_Err_Ok; GX_Blend blend; FT_MM_Var* mmvar; FT_UInt i; FT_Memory memory = face->root.memory; enum { mcvt_retain, mcvt_modify, mcvt_load } manageCvt; face->doblend = FALSE; if ( face->blend == NULL ) { if ( ( error = TT_Get_MM_Var( face, NULL ) ) != 0 ) goto Exit; } blend = face->blend; mmvar = blend->mmvar; if ( num_coords > mmvar->num_axis ) { FT_TRACE2(( "TT_Set_MM_Blend: only using first %d of %d coordinates\n", mmvar->num_axis, num_coords )); num_coords = mmvar->num_axis; } FT_TRACE5(( "normalized design coordinates:\n" )); for ( i = 0; i < num_coords; i++ ) { FT_TRACE5(( " %.4f\n", coords[i] / 65536.0 )); if ( coords[i] < -0x00010000L || coords[i] > 0x00010000L ) { FT_TRACE1(( "TT_Set_MM_Blend: normalized design coordinate %.4f\n" " is out of range [-1;1]\n", coords[i] / 65536.0 )); error = FT_THROW( Invalid_Argument ); goto Exit; } } FT_TRACE5(( "\n" )); if ( blend->glyphoffsets == NULL ) if ( ( error = ft_var_load_gvar( face ) ) != 0 ) goto Exit; if ( blend->normalizedcoords == NULL ) { if ( FT_NEW_ARRAY( blend->normalizedcoords, mmvar->num_axis ) ) goto Exit; manageCvt = mcvt_modify; /* If we have not set the blend coordinates before this, then the */ /* cvt table will still be what we read from the `cvt ' table and */ /* we don't need to reload it. We may need to change it though... */ } else { manageCvt = mcvt_retain; for ( i = 0; i < num_coords; i++ ) { if ( blend->normalizedcoords[i] != coords[i] ) { manageCvt = mcvt_load; break; } } for ( ; i < mmvar->num_axis; i++ ) { if ( blend->normalizedcoords[i] != 0 ) { manageCvt = mcvt_load; break; } } /* If we don't change the blend coords then we don't need to do */ /* anything to the cvt table. It will be correct. Otherwise we */ /* no longer have the original cvt (it was modified when we set */ /* the blend last time), so we must reload and then modify it. */ } blend->num_axis = mmvar->num_axis; FT_MEM_COPY( blend->normalizedcoords, coords, num_coords * sizeof ( FT_Fixed ) ); face->doblend = TRUE; if ( face->cvt != NULL ) { switch ( manageCvt ) { case mcvt_load: /* The cvt table has been loaded already; every time we change the */ /* blend we may need to reload and remodify the cvt table. */ FT_FREE( face->cvt ); face->cvt = NULL; error = tt_face_load_cvt( face, face->root.stream ); break; case mcvt_modify: /* The original cvt table is in memory. All we need to do is */ /* apply the `cvar' table (if any). */ error = tt_face_vary_cvt( face, face->root.stream ); break; case mcvt_retain: /* The cvt table is correct for this set of coordinates. */ break; } } Exit: return error; } /*************************************************************************/ /* */ /* <Function> */ /* TT_Set_Var_Design */ /* */ /* <Description> */ /* Set the coordinates for the instance, measured in the user */ /* coordinate system. Parse the `avar' table (if present) to convert */ /* from user to normalized coordinates. */ /* */ /* <InOut> */ /* face :: The font face. */ /* Initialize the blend struct with `gvar' data. */ /* */ /* <Input> */ /* num_coords :: The number of available coordinates. If it is */ /* larger than the number of axes, ignore the excess */ /* values. If it is smaller than the number of axes, */ /* use the default values for the remaining axes. */ /* */ /* coords :: A coordinate array with `num_coords' elements. */ /* */ /* <Return> */ /* FreeType error code. 0 means success. */ /* */ FT_LOCAL_DEF( FT_Error ) TT_Set_Var_Design( TT_Face face, FT_UInt num_coords, FT_Fixed* coords ) { FT_Error error = FT_Err_Ok; FT_Fixed* normalized = NULL; GX_Blend blend; FT_MM_Var* mmvar; FT_UInt i, j; FT_Var_Axis* a; GX_AVarSegment av; FT_Memory memory = face->root.memory; if ( face->blend == NULL ) { if ( ( error = TT_Get_MM_Var( face, NULL ) ) != 0 ) goto Exit; } blend = face->blend; mmvar = blend->mmvar; if ( num_coords > mmvar->num_axis ) { FT_TRACE2(( "TT_Set_Var_Design:" " only using first %d of %d coordinates\n", mmvar->num_axis, num_coords )); num_coords = mmvar->num_axis; } /* Axis normalization is a two stage process. First we normalize */ /* based on the [min,def,max] values for the axis to be [-1,0,1]. */ /* Then, if there's an `avar' table, we renormalize this range. */ if ( FT_NEW_ARRAY( normalized, mmvar->num_axis ) ) goto Exit; FT_TRACE5(( "design coordinates:\n" )); a = mmvar->axis; for ( i = 0; i < num_coords; i++, a++ ) { FT_TRACE5(( " %.4f\n", coords[i] / 65536.0 )); if ( coords[i] > a->maximum || coords[i] < a->minimum ) { FT_TRACE1(( "TT_Set_Var_Design: normalized design coordinate %.4f\n" " is out of range [%.4f;%.4f]\n", coords[i] / 65536.0, a->minimum / 65536.0, a->maximum / 65536.0 )); error = FT_THROW( Invalid_Argument ); goto Exit; } if ( coords[i] < a->def ) normalized[i] = -FT_DivFix( coords[i] - a->def, a->minimum - a->def ); else if ( a->maximum == a->def ) normalized[i] = 0; else normalized[i] = FT_DivFix( coords[i] - a->def, a->maximum - a->def ); } FT_TRACE5(( "\n" )); for ( ; i < mmvar->num_axis; i++ ) normalized[i] = 0; if ( !blend->avar_checked ) ft_var_load_avar( face ); if ( blend->avar_segment != NULL ) { FT_TRACE5(( "normalized design coordinates" " before applying `avar' data:\n" )); av = blend->avar_segment; for ( i = 0; i < mmvar->num_axis; i++, av++ ) { for ( j = 1; j < (FT_UInt)av->pairCount; j++ ) { FT_TRACE5(( " %.4f\n", normalized[i] / 65536.0 )); if ( normalized[i] < av->correspondence[j].fromCoord ) { normalized[i] = FT_MulDiv( normalized[i] - av->correspondence[j - 1].fromCoord, av->correspondence[j].toCoord - av->correspondence[j - 1].toCoord, av->correspondence[j].fromCoord - av->correspondence[j - 1].fromCoord ) + av->correspondence[j - 1].toCoord; break; } } } } error = TT_Set_MM_Blend( face, mmvar->num_axis, normalized ); Exit: FT_FREE( normalized ); return error; } /*************************************************************************/ /*************************************************************************/ /***** *****/ /***** GX VAR PARSING ROUTINES *****/ /***** *****/ /*************************************************************************/ /*************************************************************************/ /*************************************************************************/ /* */ /* <Function> */ /* tt_face_vary_cvt */ /* */ /* <Description> */ /* Modify the loaded cvt table according to the `cvar' table and the */ /* font's blend. */ /* */ /* <InOut> */ /* face :: A handle to the target face object. */ /* */ /* <Input> */ /* stream :: A handle to the input stream. */ /* */ /* <Return> */ /* FreeType error code. 0 means success. */ /* */ /* Most errors are ignored. It is perfectly valid not to have a */ /* `cvar' table even if there is a `gvar' and `fvar' table. */ /* */ FT_LOCAL_DEF( FT_Error ) tt_face_vary_cvt( TT_Face face, FT_Stream stream ) { FT_Error error; FT_Memory memory = stream->memory; FT_ULong table_start; FT_ULong table_len; FT_UInt tupleCount; FT_ULong offsetToData; FT_ULong here; FT_UInt i, j; FT_Fixed* tuple_coords = NULL; FT_Fixed* im_start_coords = NULL; FT_Fixed* im_end_coords = NULL; GX_Blend blend = face->blend; FT_UInt point_count; FT_UShort* localpoints; FT_Short* deltas; FT_TRACE2(( "CVAR " )); if ( blend == NULL ) { FT_TRACE2(( "\n" "tt_face_vary_cvt: no blend specified\n" )); error = FT_Err_Ok; goto Exit; } if ( face->cvt == NULL ) { FT_TRACE2(( "\n" "tt_face_vary_cvt: no `cvt ' table\n" )); error = FT_Err_Ok; goto Exit; } error = face->goto_table( face, TTAG_cvar, stream, &table_len ); if ( error ) { FT_TRACE2(( "is missing\n" )); error = FT_Err_Ok; goto Exit; } if ( FT_FRAME_ENTER( table_len ) ) { error = FT_Err_Ok; goto Exit; } table_start = FT_Stream_FTell( stream ); if ( FT_GET_LONG() != 0x00010000L ) { FT_TRACE2(( "bad table version\n" )); error = FT_Err_Ok; goto FExit; } FT_TRACE2(( "loaded\n" )); if ( FT_NEW_ARRAY( tuple_coords, blend->num_axis ) || FT_NEW_ARRAY( im_start_coords, blend->num_axis ) || FT_NEW_ARRAY( im_end_coords, blend->num_axis ) ) goto FExit; tupleCount = FT_GET_USHORT(); offsetToData = FT_GET_USHORT(); /* rough sanity test */ if ( offsetToData + tupleCount * 4 > table_len ) { FT_TRACE2(( "tt_face_vary_cvt:" " invalid CVT variation array header\n" )); error = FT_THROW( Invalid_Table ); goto FExit; } offsetToData += table_start; /* The documentation implies there are flags packed into */ /* `tupleCount', but John Jenkins says that shared points don't apply */ /* to `cvar', and no other flags are defined. */ FT_TRACE5(( "cvar: there are %d tuples:\n", tupleCount & 0xFFF )); for ( i = 0; i < ( tupleCount & 0xFFF ); i++ ) { FT_UInt tupleDataSize; FT_UInt tupleIndex; FT_Fixed apply; FT_TRACE6(( " tuple %d:\n", i )); tupleDataSize = FT_GET_USHORT(); tupleIndex = FT_GET_USHORT(); /* There is no provision here for a global tuple coordinate section, */ /* so John says. There are no tuple indices, just embedded tuples. */ if ( tupleIndex & GX_TI_EMBEDDED_TUPLE_COORD ) { for ( j = 0; j < blend->num_axis; j++ ) tuple_coords[j] = FT_GET_SHORT() * 4; /* convert from */ /* short frac to fixed */ } else { /* skip this tuple; it makes no sense */ if ( tupleIndex & GX_TI_INTERMEDIATE_TUPLE ) for ( j = 0; j < 2 * blend->num_axis; j++ ) (void)FT_GET_SHORT(); offsetToData += tupleDataSize; continue; } if ( tupleIndex & GX_TI_INTERMEDIATE_TUPLE ) { for ( j = 0; j < blend->num_axis; j++ ) im_start_coords[j] = FT_GET_SHORT() * 4; for ( j = 0; j < blend->num_axis; j++ ) im_end_coords[j] = FT_GET_SHORT() * 4; } apply = ft_var_apply_tuple( blend, (FT_UShort)tupleIndex, tuple_coords, im_start_coords, im_end_coords ); if ( /* tuple isn't active for our blend */ apply == 0 || /* global points not allowed, */ /* if they aren't local, makes no sense */ !( tupleIndex & GX_TI_PRIVATE_POINT_NUMBERS ) ) { offsetToData += tupleDataSize; continue; } here = FT_Stream_FTell( stream ); FT_Stream_SeekSet( stream, offsetToData ); localpoints = ft_var_readpackedpoints( stream, table_len, &point_count ); deltas = ft_var_readpackeddeltas( stream, table_len, point_count == 0 ? face->cvt_size : point_count ); if ( localpoints == NULL || deltas == NULL ) ; /* failure, ignore it */ else if ( localpoints == ALL_POINTS ) { #ifdef FT_DEBUG_LEVEL_TRACE int count = 0; #endif FT_TRACE7(( " CVT deltas:\n" )); /* this means that there are deltas for every entry in cvt */ for ( j = 0; j < face->cvt_size; j++ ) { FT_Long orig_cvt = face->cvt[j]; face->cvt[j] = (FT_Short)( orig_cvt + FT_MulFix( deltas[j], apply ) ); #ifdef FT_DEBUG_LEVEL_TRACE if ( orig_cvt != face->cvt[j] ) { FT_TRACE7(( " %d: %d -> %d\n", j, orig_cvt, face->cvt[j] )); count++; } #endif } #ifdef FT_DEBUG_LEVEL_TRACE if ( !count ) FT_TRACE7(( " none\n" )); #endif } else { #ifdef FT_DEBUG_LEVEL_TRACE int count = 0; #endif FT_TRACE7(( " CVT deltas:\n" )); for ( j = 0; j < point_count; j++ ) { int pindex = localpoints[j]; FT_Long orig_cvt = face->cvt[pindex]; face->cvt[pindex] = (FT_Short)( orig_cvt + FT_MulFix( deltas[j], apply ) ); #ifdef FT_DEBUG_LEVEL_TRACE if ( orig_cvt != face->cvt[pindex] ) { FT_TRACE7(( " %d: %d -> %d\n", pindex, orig_cvt, face->cvt[pindex] )); count++; } #endif } #ifdef FT_DEBUG_LEVEL_TRACE if ( !count ) FT_TRACE7(( " none\n" )); #endif } if ( localpoints != ALL_POINTS ) FT_FREE( localpoints ); FT_FREE( deltas ); offsetToData += tupleDataSize; FT_Stream_SeekSet( stream, here ); } FT_TRACE5(( "\n" )); FExit: FT_FRAME_EXIT(); Exit: FT_FREE( tuple_coords ); FT_FREE( im_start_coords ); FT_FREE( im_end_coords ); return error; } /* Shift the original coordinates of all points between indices `p1' */ /* and `p2', using the same difference as given by index `ref'. */ /* modeled after `af_iup_shift' */ static void tt_delta_shift( int p1, int p2, int ref, FT_Vector* in_points, FT_Vector* out_points ) { int p; FT_Vector delta; delta.x = out_points[ref].x - in_points[ref].x; delta.y = out_points[ref].y - in_points[ref].y; if ( delta.x == 0 && delta.y == 0 ) return; for ( p = p1; p < ref; p++ ) { out_points[p].x += delta.x; out_points[p].y += delta.y; } for ( p = ref + 1; p <= p2; p++ ) { out_points[p].x += delta.x; out_points[p].y += delta.y; } } /* Interpolate the original coordinates of all points with indices */ /* between `p1' and `p2', using `ref1' and `ref2' as the reference */ /* point indices. */ /* modeled after `af_iup_interp', `_iup_worker_interpolate', and */ /* `Ins_IUP' */ static void tt_delta_interpolate( int p1, int p2, int ref1, int ref2, FT_Vector* in_points, FT_Vector* out_points ) { int p, i; FT_Pos out, in1, in2, out1, out2, d1, d2; if ( p1 > p2 ) return; /* handle both horizontal and vertical coordinates */ for ( i = 0; i <= 1; i++ ) { /* shift array pointers so that we can access `foo.y' as `foo.x' */ in_points = (FT_Vector*)( (FT_Pos*)in_points + i ); out_points = (FT_Vector*)( (FT_Pos*)out_points + i ); if ( in_points[ref1].x > in_points[ref2].x ) { p = ref1; ref1 = ref2; ref2 = p; } in1 = in_points[ref1].x; in2 = in_points[ref2].x; out1 = out_points[ref1].x; out2 = out_points[ref2].x; d1 = out1 - in1; d2 = out2 - in2; if ( out1 == out2 || in1 == in2 ) { for ( p = p1; p <= p2; p++ ) { out = in_points[p].x; if ( out <= in1 ) out += d1; else if ( out >= in2 ) out += d2; else out = out1; out_points[p].x = out; } } else { FT_Fixed scale = FT_DivFix( out2 - out1, in2 - in1 ); for ( p = p1; p <= p2; p++ ) { out = in_points[p].x; if ( out <= in1 ) out += d1; else if ( out >= in2 ) out += d2; else out = out1 + FT_MulFix( out - in1, scale ); out_points[p].x = out; } } } } /* Interpolate points without delta values, similar to */ /* the `IUP' hinting instruction. */ /* modeled after `Ins_IUP */ static void tt_handle_deltas( FT_Outline* outline, FT_Vector* in_points, FT_Bool* has_delta ) { FT_Vector* out_points; FT_Int first_point; FT_Int end_point; FT_Int first_delta; FT_Int cur_delta; FT_Int point; FT_Short contour; /* ignore empty outlines */ if ( !outline->n_contours ) return; out_points = outline->points; contour = 0; point = 0; do { end_point = outline->contours[contour]; first_point = point; /* search first point that has a delta */ while ( point <= end_point && !has_delta[point] ) point++; if ( point <= end_point ) { first_delta = point; cur_delta = point; point++; while ( point <= end_point ) { /* search next point that has a delta */ /* and interpolate intermediate points */ if ( has_delta[point] ) { tt_delta_interpolate( cur_delta + 1, point - 1, cur_delta, point, in_points, out_points ); cur_delta = point; } point++; } /* shift contour if we only have a single delta */ if ( cur_delta == first_delta ) tt_delta_shift( first_point, end_point, cur_delta, in_points, out_points ); else { /* otherwise handle remaining points */ /* at the end and beginning of the contour */ tt_delta_interpolate( cur_delta + 1, end_point, cur_delta, first_delta, in_points, out_points ); if ( first_delta > 0 ) tt_delta_interpolate( first_point, first_delta - 1, cur_delta, first_delta, in_points, out_points ); } } contour++; } while ( contour < outline->n_contours ); } /*************************************************************************/ /* */ /* <Function> */ /* TT_Vary_Apply_Glyph_Deltas */ /* */ /* <Description> */ /* Apply the appropriate deltas to the current glyph. */ /* */ /* <Input> */ /* face :: A handle to the target face object. */ /* */ /* glyph_index :: The index of the glyph being modified. */ /* */ /* n_points :: The number of the points in the glyph, including */ /* phantom points. */ /* */ /* <InOut> */ /* outline :: The outline to change. */ /* */ /* <Return> */ /* FreeType error code. 0 means success. */ /* */ FT_LOCAL_DEF( FT_Error ) TT_Vary_Apply_Glyph_Deltas( TT_Face face, FT_UInt glyph_index, FT_Outline* outline, FT_UInt n_points ) { FT_Stream stream = face->root.stream; FT_Memory memory = stream->memory; GX_Blend blend = face->blend; FT_Vector* points_org = NULL; FT_Bool* has_delta = NULL; FT_Error error; FT_ULong glyph_start; FT_UInt tupleCount; FT_ULong offsetToData; FT_ULong here; FT_UInt i, j; FT_Fixed* tuple_coords = NULL; FT_Fixed* im_start_coords = NULL; FT_Fixed* im_end_coords = NULL; FT_UInt point_count, spoint_count = 0; FT_UShort* sharedpoints = NULL; FT_UShort* localpoints = NULL; FT_UShort* points; FT_Short *deltas_x, *deltas_y; if ( !face->doblend || blend == NULL ) return FT_THROW( Invalid_Argument ); if ( glyph_index >= blend->gv_glyphcnt || blend->glyphoffsets[glyph_index] == blend->glyphoffsets[glyph_index + 1] ) { FT_TRACE2(( "TT_Vary_Apply_Glyph_Deltas:" " no variation data for this glyph\n" )); return FT_Err_Ok; } if ( FT_NEW_ARRAY( points_org, n_points ) || FT_NEW_ARRAY( has_delta, n_points ) ) goto Fail1; if ( FT_STREAM_SEEK( blend->glyphoffsets[glyph_index] ) || FT_FRAME_ENTER( blend->glyphoffsets[glyph_index + 1] - blend->glyphoffsets[glyph_index] ) ) goto Fail1; glyph_start = FT_Stream_FTell( stream ); /* each set of glyph variation data is formatted similarly to `cvar' */ /* (except we get shared points and global tuples) */ if ( FT_NEW_ARRAY( tuple_coords, blend->num_axis ) || FT_NEW_ARRAY( im_start_coords, blend->num_axis ) || FT_NEW_ARRAY( im_end_coords, blend->num_axis ) ) goto Fail2; tupleCount = FT_GET_USHORT(); offsetToData = FT_GET_USHORT(); /* rough sanity test */ if ( offsetToData + tupleCount * 4 > blend->gvar_size ) { FT_TRACE2(( "TT_Vary_Apply_Glyph_Deltas:" " invalid glyph variation array header\n" )); error = FT_THROW( Invalid_Table ); goto Fail2; } offsetToData += glyph_start; if ( tupleCount & GX_TC_TUPLES_SHARE_POINT_NUMBERS ) { here = FT_Stream_FTell( stream ); FT_Stream_SeekSet( stream, offsetToData ); sharedpoints = ft_var_readpackedpoints( stream, blend->gvar_size, &spoint_count ); offsetToData = FT_Stream_FTell( stream ); FT_Stream_SeekSet( stream, here ); } FT_TRACE5(( "gvar: there are %d tuples:\n", tupleCount & GX_TC_TUPLE_COUNT_MASK )); for ( i = 0; i < ( tupleCount & GX_TC_TUPLE_COUNT_MASK ); i++ ) { FT_UInt tupleDataSize; FT_UInt tupleIndex; FT_Fixed apply; FT_TRACE6(( " tuple %d:\n", i )); tupleDataSize = FT_GET_USHORT(); tupleIndex = FT_GET_USHORT(); if ( tupleIndex & GX_TI_EMBEDDED_TUPLE_COORD ) { for ( j = 0; j < blend->num_axis; j++ ) tuple_coords[j] = FT_GET_SHORT() * 4; /* convert from */ /* short frac to fixed */ } else if ( ( tupleIndex & GX_TI_TUPLE_INDEX_MASK ) >= blend->tuplecount ) { FT_TRACE2(( "TT_Vary_Apply_Glyph_Deltas:" " invalid tuple index\n" )); error = FT_THROW( Invalid_Table ); goto Fail2; } else FT_MEM_COPY( tuple_coords, &blend->tuplecoords[( tupleIndex & 0xFFF ) * blend->num_axis], blend->num_axis * sizeof ( FT_Fixed ) ); if ( tupleIndex & GX_TI_INTERMEDIATE_TUPLE ) { for ( j = 0; j < blend->num_axis; j++ ) im_start_coords[j] = FT_GET_SHORT() * 4; for ( j = 0; j < blend->num_axis; j++ ) im_end_coords[j] = FT_GET_SHORT() * 4; } apply = ft_var_apply_tuple( blend, (FT_UShort)tupleIndex, tuple_coords, im_start_coords, im_end_coords ); if ( apply == 0 ) /* tuple isn't active for our blend */ { offsetToData += tupleDataSize; continue; } here = FT_Stream_FTell( stream ); if ( tupleIndex & GX_TI_PRIVATE_POINT_NUMBERS ) { FT_Stream_SeekSet( stream, offsetToData ); localpoints = ft_var_readpackedpoints( stream, blend->gvar_size, &point_count ); points = localpoints; } else { points = sharedpoints; point_count = spoint_count; } deltas_x = ft_var_readpackeddeltas( stream, blend->gvar_size, point_count == 0 ? n_points : point_count ); deltas_y = ft_var_readpackeddeltas( stream, blend->gvar_size, point_count == 0 ? n_points : point_count ); if ( points == NULL || deltas_y == NULL || deltas_x == NULL ) ; /* failure, ignore it */ else if ( points == ALL_POINTS ) { #ifdef FT_DEBUG_LEVEL_TRACE int count = 0; #endif FT_TRACE7(( " point deltas:\n" )); /* this means that there are deltas for every point in the glyph */ for ( j = 0; j < n_points; j++ ) { #ifdef FT_DEBUG_LEVEL_TRACE FT_Vector point_org = outline->points[j]; #endif outline->points[j].x += FT_MulFix( deltas_x[j], apply ); outline->points[j].y += FT_MulFix( deltas_y[j], apply ); #ifdef FT_DEBUG_LEVEL_TRACE if ( ( point_org.x != outline->points[j].x ) || ( point_org.y != outline->points[j].y ) ) { FT_TRACE7(( " %d: (%d, %d) -> (%d, %d)\n", j, point_org.x, point_org.y, outline->points[j].x, outline->points[j].y )); count++; } #endif } #ifdef FT_DEBUG_LEVEL_TRACE if ( !count ) FT_TRACE7(( " none\n" )); #endif } else if ( localpoints == NULL ) ; /* failure, ignore it */ else { #ifdef FT_DEBUG_LEVEL_TRACE int count = 0; #endif /* we have to interpolate the missing deltas similar to the */ /* IUP bytecode instruction */ for ( j = 0; j < n_points; j++ ) { points_org[j] = outline->points[j]; has_delta[j] = FALSE; } for ( j = 0; j < point_count; j++ ) { FT_UShort idx = localpoints[j]; if ( idx >= n_points ) continue; has_delta[idx] = TRUE; outline->points[idx].x += FT_MulFix( deltas_x[j], apply ); outline->points[idx].y += FT_MulFix( deltas_y[j], apply ); } /* no need to handle phantom points here, */ /* since solitary points can't be interpolated */ tt_handle_deltas( outline, points_org, has_delta ); #ifdef FT_DEBUG_LEVEL_TRACE FT_TRACE7(( " point deltas:\n" )); for ( j = 0; j < n_points; j++) { if ( ( points_org[j].x != outline->points[j].x ) || ( points_org[j].y != outline->points[j].y ) ) { FT_TRACE7(( " %d: (%d, %d) -> (%d, %d)\n", j, points_org[j].x, points_org[j].y, outline->points[j].x, outline->points[j].y )); count++; } } if ( !count ) FT_TRACE7(( " none\n" )); #endif } if ( localpoints != ALL_POINTS ) FT_FREE( localpoints ); FT_FREE( deltas_x ); FT_FREE( deltas_y ); offsetToData += tupleDataSize; FT_Stream_SeekSet( stream, here ); } FT_TRACE5(( "\n" )); Fail2: if ( sharedpoints != ALL_POINTS ) FT_FREE( sharedpoints ); FT_FREE( tuple_coords ); FT_FREE( im_start_coords ); FT_FREE( im_end_coords ); FT_FRAME_EXIT(); Fail1: FT_FREE( points_org ); FT_FREE( has_delta ); return error; } /*************************************************************************/ /* */ /* <Function> */ /* tt_done_blend */ /* */ /* <Description> */ /* Free the blend internal data structure. */ /* */ FT_LOCAL_DEF( void ) tt_done_blend( FT_Memory memory, GX_Blend blend ) { if ( blend != NULL ) { FT_UInt i; FT_FREE( blend->normalizedcoords ); FT_FREE( blend->mmvar ); if ( blend->avar_segment != NULL ) { for ( i = 0; i < blend->num_axis; i++ ) FT_FREE( blend->avar_segment[i].correspondence ); FT_FREE( blend->avar_segment ); } FT_FREE( blend->tuplecoords ); FT_FREE( blend->glyphoffsets ); FT_FREE( blend ); } } #endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */ /* END */