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
