1 /****************************************************************************
2 *
3 * ttgxvar.c
4 *
5 * TrueType GX Font Variation loader
6 *
7 * Copyright (C) 2004-2019 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 * https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6[fgca]var.html
24 *
25 * The documentation for `gvar' is not intelligible; `cvar' refers you
26 * to `gvar' and is thus also incomprehensible.
27 *
28 * The documentation for `avar' appears correct, but Apple has no fonts
29 * with an `avar' table, so it is hard to test.
30 *
31 * Many thanks to John Jenkins (at Apple) in figuring this out.
32 *
33 *
34 * Apple's `kern' table has some references to tuple indices, but as
35 * there is no indication where these indices are defined, nor how to
36 * interpolate the kerning values (different tuples have different
37 * classes) this issue is ignored.
38 *
39 */
40
41
42 #include <ft2build.h>
43 #include FT_INTERNAL_DEBUG_H
44 #include FT_CONFIG_CONFIG_H
45 #include FT_INTERNAL_STREAM_H
46 #include FT_INTERNAL_SFNT_H
47 #include FT_TRUETYPE_TAGS_H
48 #include FT_TRUETYPE_IDS_H
49 #include FT_MULTIPLE_MASTERS_H
50 #include FT_LIST_H
51
52 #include "ttpload.h"
53 #include "ttgxvar.h"
54
55 #include "tterrors.h"
56
57
58 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
59
60
61 #define FT_Stream_FTell( stream ) \
62 (FT_ULong)( (stream)->cursor - (stream)->base )
63 #define FT_Stream_SeekSet( stream, off ) \
64 (stream)->cursor = \
65 ( (off) < (FT_ULong)( (stream)->limit - (stream)->base ) ) \
66 ? (stream)->base + (off) \
67 : (stream)->limit
68
69
70 /* some macros we need */
71 #define FT_fdot14ToFixed( x ) \
72 ( (FT_Fixed)( (FT_ULong)(x) << 2 ) )
73 #define FT_intToFixed( i ) \
74 ( (FT_Fixed)( (FT_ULong)(i) << 16 ) )
75 #define FT_fixedToInt( x ) \
76 ( (FT_Short)( ( (FT_UInt32)(x) + 0x8000U ) >> 16 ) )
77
78
79 /**************************************************************************
80 *
81 * The macro FT_COMPONENT is used in trace mode. It is an implicit
82 * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
83 * messages during execution.
84 */
85 #undef FT_COMPONENT
86 #define FT_COMPONENT ttgxvar
87
88
89 /*************************************************************************/
90 /*************************************************************************/
91 /***** *****/
92 /***** Internal Routines *****/
93 /***** *****/
94 /*************************************************************************/
95 /*************************************************************************/
96
97
98 /**************************************************************************
99 *
100 * The macro ALL_POINTS is used in `ft_var_readpackedpoints'. It
101 * indicates that there is a delta for every point without needing to
102 * enumerate all of them.
103 */
104
105 /* ensure that value `0' has the same width as a pointer */
106 #define ALL_POINTS (FT_UShort*)~(FT_PtrDist)0
107
108
109 #define GX_PT_POINTS_ARE_WORDS 0x80U
110 #define GX_PT_POINT_RUN_COUNT_MASK 0x7FU
111
112
113 /**************************************************************************
114 *
115 * @Function:
116 * ft_var_readpackedpoints
117 *
118 * @Description:
119 * Read a set of points to which the following deltas will apply.
120 * Points are packed with a run length encoding.
121 *
122 * @Input:
123 * stream ::
124 * The data stream.
125 *
126 * size ::
127 * The size of the table holding the data.
128 *
129 * @Output:
130 * point_cnt ::
131 * The number of points read. A zero value means that
132 * all points in the glyph will be affected, without
133 * enumerating them individually.
134 *
135 * @Return:
136 * An array of FT_UShort containing the affected points or the
137 * special value ALL_POINTS.
138 */
139 static FT_UShort*
140 ft_var_readpackedpoints( FT_Stream stream,
141 FT_ULong size,
142 FT_UInt *point_cnt )
143 {
144 FT_UShort *points = NULL;
145 FT_UInt n;
146 FT_UInt runcnt;
147 FT_UInt i, j;
148 FT_UShort first;
149 FT_Memory memory = stream->memory;
150 FT_Error error = FT_Err_Ok;
151
152 FT_UNUSED( error );
153
154
155 *point_cnt = 0;
156
157 n = FT_GET_BYTE();
158 if ( n == 0 )
159 return ALL_POINTS;
160
161 if ( n & GX_PT_POINTS_ARE_WORDS )
162 {
163 n &= GX_PT_POINT_RUN_COUNT_MASK;
164 n <<= 8;
165 n |= FT_GET_BYTE();
166 }
167
168 if ( n > size )
169 {
170 FT_TRACE1(( "ft_var_readpackedpoints: number of points too large\n" ));
171 return NULL;
172 }
173
174 /* in the nested loops below we increase `i' twice; */
175 /* it is faster to simply allocate one more slot */
176 /* than to add another test within the loop */
177 if ( FT_NEW_ARRAY( points, n + 1 ) )
178 return NULL;
179
180 *point_cnt = n;
181
182 first = 0;
183 i = 0;
184 while ( i < n )
185 {
186 runcnt = FT_GET_BYTE();
187 if ( runcnt & GX_PT_POINTS_ARE_WORDS )
188 {
189 runcnt &= GX_PT_POINT_RUN_COUNT_MASK;
190 first += FT_GET_USHORT();
191 points[i++] = first;
192
193 /* first point not included in run count */
194 for ( j = 0; j < runcnt; j++ )
195 {
196 first += FT_GET_USHORT();
197 points[i++] = first;
198 if ( i >= n )
199 break;
200 }
201 }
202 else
203 {
204 first += FT_GET_BYTE();
205 points[i++] = first;
206
207 for ( j = 0; j < runcnt; j++ )
208 {
209 first += FT_GET_BYTE();
210 points[i++] = first;
211 if ( i >= n )
212 break;
213 }
214 }
215 }
216
217 return points;
218 }
219
220
221 #define GX_DT_DELTAS_ARE_ZERO 0x80U
222 #define GX_DT_DELTAS_ARE_WORDS 0x40U
223 #define GX_DT_DELTA_RUN_COUNT_MASK 0x3FU
224
225
226 /**************************************************************************
227 *
228 * @Function:
229 * ft_var_readpackeddeltas
230 *
231 * @Description:
232 * Read a set of deltas. These are packed slightly differently than
233 * points. In particular there is no overall count.
234 *
235 * @Input:
236 * stream ::
237 * The data stream.
238 *
239 * size ::
240 * The size of the table holding the data.
241 *
242 * delta_cnt ::
243 * The number of deltas to be read.
244 *
245 * @Return:
246 * An array of FT_Fixed containing the deltas for the affected
247 * points. (This only gets the deltas for one dimension. It will
248 * generally be called twice, once for x, once for y. When used in
249 * cvt table, it will only be called once.)
250 *
251 * We use FT_Fixed to avoid accumulation errors while summing up all
252 * deltas (the rounding to integer values happens as the very last
253 * step).
254 */
255 static FT_Fixed*
256 ft_var_readpackeddeltas( FT_Stream stream,
257 FT_ULong size,
258 FT_UInt delta_cnt )
259 {
260 FT_Fixed *deltas = NULL;
261 FT_UInt runcnt, cnt;
262 FT_UInt i, j;
263 FT_Memory memory = stream->memory;
264 FT_Error error = FT_Err_Ok;
265
266 FT_UNUSED( error );
267
268
269 if ( delta_cnt > size )
270 {
271 FT_TRACE1(( "ft_var_readpackeddeltas: number of points too large\n" ));
272 return NULL;
273 }
274
275 if ( FT_NEW_ARRAY( deltas, delta_cnt ) )
276 return NULL;
277
278 i = 0;
279 while ( i < delta_cnt )
280 {
281 runcnt = FT_GET_BYTE();
282 cnt = runcnt & GX_DT_DELTA_RUN_COUNT_MASK;
283
284 if ( runcnt & GX_DT_DELTAS_ARE_ZERO )
285 {
286 /* `runcnt' zeroes get added */
287 for ( j = 0; j <= cnt && i < delta_cnt; j++ )
288 deltas[i++] = 0;
289 }
290 else if ( runcnt & GX_DT_DELTAS_ARE_WORDS )
291 {
292 /* `runcnt' shorts from the stack */
293 for ( j = 0; j <= cnt && i < delta_cnt; j++ )
294 deltas[i++] = FT_intToFixed( FT_GET_SHORT() );
295 }
296 else
297 {
298 /* `runcnt' signed bytes from the stack */
299 for ( j = 0; j <= cnt && i < delta_cnt; j++ )
300 deltas[i++] = FT_intToFixed( FT_GET_CHAR() );
301 }
302
303 if ( j <= cnt )
304 {
305 /* bad format */
306 FT_FREE( deltas );
307 return NULL;
308 }
309 }
310
311 return deltas;
312 }
313
314
315 /**************************************************************************
316 *
317 * @Function:
318 * ft_var_load_avar
319 *
320 * @Description:
321 * Parse the `avar' table if present. It need not be, so we return
322 * nothing.
323 *
324 * @InOut:
325 * face ::
326 * The font face.
327 */
328 static void
329 ft_var_load_avar( TT_Face face )
330 {
331 FT_Stream stream = FT_FACE_STREAM( face );
332 FT_Memory memory = stream->memory;
333 GX_Blend blend = face->blend;
334 GX_AVarSegment segment;
335 FT_Error error = FT_Err_Ok;
336 FT_Long version;
337 FT_Long axisCount;
338 FT_Int i, j;
339 FT_ULong table_len;
340
341 FT_UNUSED( error );
342
343
344 FT_TRACE2(( "AVAR " ));
345
346 blend->avar_loaded = TRUE;
347 error = face->goto_table( face, TTAG_avar, stream, &table_len );
348 if ( error )
349 {
350 FT_TRACE2(( "is missing\n" ));
351 return;
352 }
353
354 if ( FT_FRAME_ENTER( table_len ) )
355 return;
356
357 version = FT_GET_LONG();
358 axisCount = FT_GET_LONG();
359
360 if ( version != 0x00010000L )
361 {
362 FT_TRACE2(( "bad table version\n" ));
363 goto Exit;
364 }
365
366 FT_TRACE2(( "loaded\n" ));
367
368 if ( axisCount != (FT_Long)blend->mmvar->num_axis )
369 {
370 FT_TRACE2(( "ft_var_load_avar: number of axes in `avar' and `fvar'\n"
371 " table are different\n" ));
372 goto Exit;
373 }
374
375 if ( FT_NEW_ARRAY( blend->avar_segment, axisCount ) )
376 goto Exit;
377
378 segment = &blend->avar_segment[0];
379 for ( i = 0; i < axisCount; i++, segment++ )
380 {
381 FT_TRACE5(( " axis %d:\n", i ));
382
383 segment->pairCount = FT_GET_USHORT();
384 if ( (FT_ULong)segment->pairCount * 4 > table_len ||
385 FT_NEW_ARRAY( segment->correspondence, segment->pairCount ) )
386 {
387 /* Failure. Free everything we have done so far. We must do */
388 /* it right now since loading the `avar' table is optional. */
389
390 for ( j = i - 1; j >= 0; j-- )
391 FT_FREE( blend->avar_segment[j].correspondence );
392
393 FT_FREE( blend->avar_segment );
394 blend->avar_segment = NULL;
395 goto Exit;
396 }
397
398 for ( j = 0; j < segment->pairCount; j++ )
399 {
400 /* convert to Fixed */
401 segment->correspondence[j].fromCoord = FT_GET_SHORT() * 4;
402 segment->correspondence[j].toCoord = FT_GET_SHORT() * 4;
403
404 FT_TRACE5(( " mapping %.5f to %.5f\n",
405 segment->correspondence[j].fromCoord / 65536.0,
406 segment->correspondence[j].toCoord / 65536.0 ));
407 }
408
409 FT_TRACE5(( "\n" ));
410 }
411
412 Exit:
413 FT_FRAME_EXIT();
414 }
415
416
417 static FT_Error
418 ft_var_load_item_variation_store( TT_Face face,
419 FT_ULong offset,
420 GX_ItemVarStore itemStore )
421 {
422 FT_Stream stream = FT_FACE_STREAM( face );
423 FT_Memory memory = stream->memory;
424
425 FT_Error error;
426 FT_UShort format;
427 FT_ULong region_offset;
428 FT_UInt i, j, k;
429 FT_UInt shortDeltaCount;
430
431 GX_Blend blend = face->blend;
432 GX_ItemVarData varData;
433
434 FT_ULong* dataOffsetArray = NULL;
435
436
437 if ( FT_STREAM_SEEK( offset ) ||
438 FT_READ_USHORT( format ) )
439 goto Exit;
440
441 if ( format != 1 )
442 {
443 FT_TRACE2(( "ft_var_load_item_variation_store: bad store format %d\n",
444 format ));
445 error = FT_THROW( Invalid_Table );
446 goto Exit;
447 }
448
449 /* read top level fields */
450 if ( FT_READ_ULONG( region_offset ) ||
451 FT_READ_USHORT( itemStore->dataCount ) )
452 goto Exit;
453
454 /* we need at least one entry in `itemStore->varData' */
455 if ( !itemStore->dataCount )
456 {
457 FT_TRACE2(( "ft_var_load_item_variation_store: missing varData\n" ));
458 error = FT_THROW( Invalid_Table );
459 goto Exit;
460 }
461
462 /* make temporary copy of item variation data offsets; */
463 /* we will parse region list first, then come back */
464 if ( FT_NEW_ARRAY( dataOffsetArray, itemStore->dataCount ) )
465 goto Exit;
466
467 for ( i = 0; i < itemStore->dataCount; i++ )
468 {
469 if ( FT_READ_ULONG( dataOffsetArray[i] ) )
470 goto Exit;
471 }
472
473 /* parse array of region records (region list) */
474 if ( FT_STREAM_SEEK( offset + region_offset ) )
475 goto Exit;
476
477 if ( FT_READ_USHORT( itemStore->axisCount ) ||
478 FT_READ_USHORT( itemStore->regionCount ) )
479 goto Exit;
480
481 if ( itemStore->axisCount != (FT_Long)blend->mmvar->num_axis )
482 {
483 FT_TRACE2(( "ft_var_load_item_variation_store:"
484 " number of axes in item variation store\n"
485 " "
486 " and `fvar' table are different\n" ));
487 error = FT_THROW( Invalid_Table );
488 goto Exit;
489 }
490
491 if ( FT_NEW_ARRAY( itemStore->varRegionList, itemStore->regionCount ) )
492 goto Exit;
493
494 for ( i = 0; i < itemStore->regionCount; i++ )
495 {
496 GX_AxisCoords axisCoords;
497
498
499 if ( FT_NEW_ARRAY( itemStore->varRegionList[i].axisList,
500 itemStore->axisCount ) )
501 goto Exit;
502
503 axisCoords = itemStore->varRegionList[i].axisList;
504
505 for ( j = 0; j < itemStore->axisCount; j++ )
506 {
507 FT_Short start, peak, end;
508
509
510 if ( FT_READ_SHORT( start ) ||
511 FT_READ_SHORT( peak ) ||
512 FT_READ_SHORT( end ) )
513 goto Exit;
514
515 axisCoords[j].startCoord = FT_fdot14ToFixed( start );
516 axisCoords[j].peakCoord = FT_fdot14ToFixed( peak );
517 axisCoords[j].endCoord = FT_fdot14ToFixed( end );
518 }
519 }
520
521 /* end of region list parse */
522
523 /* use dataOffsetArray now to parse varData items */
524 if ( FT_NEW_ARRAY( itemStore->varData, itemStore->dataCount ) )
525 goto Exit;
526
527 for ( i = 0; i < itemStore->dataCount; i++ )
528 {
529 varData = &itemStore->varData[i];
530
531 if ( FT_STREAM_SEEK( offset + dataOffsetArray[i] ) )
532 goto Exit;
533
534 if ( FT_READ_USHORT( varData->itemCount ) ||
535 FT_READ_USHORT( shortDeltaCount ) ||
536 FT_READ_USHORT( varData->regionIdxCount ) )
537 goto Exit;
538
539 /* check some data consistency */
540 if ( shortDeltaCount > varData->regionIdxCount )
541 {
542 FT_TRACE2(( "bad short count %d or region count %d\n",
543 shortDeltaCount,
544 varData->regionIdxCount ));
545 error = FT_THROW( Invalid_Table );
546 goto Exit;
547 }
548
549 if ( varData->regionIdxCount > itemStore->regionCount )
550 {
551 FT_TRACE2(( "inconsistent regionCount %d in varData[%d]\n",
552 varData->regionIdxCount,
553 i ));
554 error = FT_THROW( Invalid_Table );
555 goto Exit;
556 }
557
558 /* parse region indices */
559 if ( FT_NEW_ARRAY( varData->regionIndices,
560 varData->regionIdxCount ) )
561 goto Exit;
562
563 for ( j = 0; j < varData->regionIdxCount; j++ )
564 {
565 if ( FT_READ_USHORT( varData->regionIndices[j] ) )
566 goto Exit;
567
568 if ( varData->regionIndices[j] >= itemStore->regionCount )
569 {
570 FT_TRACE2(( "bad region index %d\n",
571 varData->regionIndices[j] ));
572 error = FT_THROW( Invalid_Table );
573 goto Exit;
574 }
575 }
576
577 /* Parse delta set. */
578 /* */
579 /* On input, deltas are (shortDeltaCount + regionIdxCount) bytes */
580 /* each; on output, deltas are expanded to `regionIdxCount' shorts */
581 /* each. */
582 if ( FT_NEW_ARRAY( varData->deltaSet,
583 varData->regionIdxCount * varData->itemCount ) )
584 goto Exit;
585
586 /* the delta set is stored as a 2-dimensional array of shorts; */
587 /* sign-extend signed bytes to signed shorts */
588 for ( j = 0; j < varData->itemCount * varData->regionIdxCount; )
589 {
590 for ( k = 0; k < shortDeltaCount; k++, j++ )
591 {
592 /* read the short deltas */
593 FT_Short delta;
594
595
596 if ( FT_READ_SHORT( delta ) )
597 goto Exit;
598
599 varData->deltaSet[j] = delta;
600 }
601
602 for ( ; k < varData->regionIdxCount; k++, j++ )
603 {
604 /* read the (signed) byte deltas */
605 FT_Char delta;
606
607
608 if ( FT_READ_CHAR( delta ) )
609 goto Exit;
610
611 varData->deltaSet[j] = delta;
612 }
613 }
614 }
615
616 Exit:
617 FT_FREE( dataOffsetArray );
618
619 return error;
620 }
621
622
623 static FT_Error
624 ft_var_load_delta_set_index_mapping( TT_Face face,
625 FT_ULong offset,
626 GX_DeltaSetIdxMap map,
627 GX_ItemVarStore itemStore )
628 {
629 FT_Stream stream = FT_FACE_STREAM( face );
630 FT_Memory memory = stream->memory;
631
632 FT_Error error;
633
634 FT_UShort format;
635 FT_UInt entrySize;
636 FT_UInt innerBitCount;
637 FT_UInt innerIndexMask;
638 FT_UInt i, j;
639
640
641 if ( FT_STREAM_SEEK( offset ) ||
642 FT_READ_USHORT( format ) ||
643 FT_READ_USHORT( map->mapCount ) )
644 goto Exit;
645
646 if ( format & 0xFFC0 )
647 {
648 FT_TRACE2(( "bad map format %d\n", format ));
649 error = FT_THROW( Invalid_Table );
650 goto Exit;
651 }
652
653 /* bytes per entry: 1, 2, 3, or 4 */
654 entrySize = ( ( format & 0x0030 ) >> 4 ) + 1;
655 innerBitCount = ( format & 0x000F ) + 1;
656 innerIndexMask = ( 1 << innerBitCount ) - 1;
657
658 if ( FT_NEW_ARRAY( map->innerIndex, map->mapCount ) )
659 goto Exit;
660
661 if ( FT_NEW_ARRAY( map->outerIndex, map->mapCount ) )
662 goto Exit;
663
664 for ( i = 0; i < map->mapCount; i++ )
665 {
666 FT_UInt mapData = 0;
667 FT_UInt outerIndex, innerIndex;
668
669
670 /* read map data one unsigned byte at a time, big endian */
671 for ( j = 0; j < entrySize; j++ )
672 {
673 FT_Byte data;
674
675
676 if ( FT_READ_BYTE( data ) )
677 goto Exit;
678
679 mapData = ( mapData << 8 ) | data;
680 }
681
682 outerIndex = mapData >> innerBitCount;
683
684 if ( outerIndex >= itemStore->dataCount )
685 {
686 FT_TRACE2(( "outerIndex[%d] == %d out of range\n",
687 i,
688 outerIndex ));
689 error = FT_THROW( Invalid_Table );
690 goto Exit;
691 }
692
693 map->outerIndex[i] = outerIndex;
694
695 innerIndex = mapData & innerIndexMask;
696
697 if ( innerIndex >= itemStore->varData[outerIndex].itemCount )
698 {
699 FT_TRACE2(( "innerIndex[%d] == %d out of range\n",
700 i,
701 innerIndex ));
702 error = FT_THROW( Invalid_Table );
703 goto Exit;
704 }
705
706 map->innerIndex[i] = innerIndex;
707 }
708
709 Exit:
710 return error;
711 }
712
713
714 /**************************************************************************
715 *
716 * @Function:
717 * ft_var_load_hvvar
718 *
719 * @Description:
720 * If `vertical' is zero, parse the `HVAR' table and set
721 * `blend->hvar_loaded' to TRUE. On success, `blend->hvar_checked'
722 * is set to TRUE.
723 *
724 * If `vertical' is not zero, parse the `VVAR' table and set
725 * `blend->vvar_loaded' to TRUE. On success, `blend->vvar_checked'
726 * is set to TRUE.
727 *
728 * Some memory may remain allocated on error; it is always freed in
729 * `tt_done_blend', however.
730 *
731 * @InOut:
732 * face ::
733 * The font face.
734 *
735 * @Return:
736 * FreeType error code. 0 means success.
737 */
738 static FT_Error
739 ft_var_load_hvvar( TT_Face face,
740 FT_Bool vertical )
741 {
742 FT_Stream stream = FT_FACE_STREAM( face );
743 FT_Memory memory = stream->memory;
744
745 GX_Blend blend = face->blend;
746
747 GX_HVVarTable table;
748
749 FT_Error error;
750 FT_UShort majorVersion;
751 FT_ULong table_len;
752 FT_ULong table_offset;
753 FT_ULong store_offset;
754 FT_ULong widthMap_offset;
755
756
757 if ( vertical )
758 {
759 blend->vvar_loaded = TRUE;
760
761 FT_TRACE2(( "VVAR " ));
762
763 error = face->goto_table( face, TTAG_VVAR, stream, &table_len );
764 }
765 else
766 {
767 blend->hvar_loaded = TRUE;
768
769 FT_TRACE2(( "HVAR " ));
770
771 error = face->goto_table( face, TTAG_HVAR, stream, &table_len );
772 }
773
774 if ( error )
775 {
776 FT_TRACE2(( "is missing\n" ));
777 goto Exit;
778 }
779
780 table_offset = FT_STREAM_POS();
781
782 /* skip minor version */
783 if ( FT_READ_USHORT( majorVersion ) ||
784 FT_STREAM_SKIP( 2 ) )
785 goto Exit;
786
787 if ( majorVersion != 1 )
788 {
789 FT_TRACE2(( "bad table version %d\n", majorVersion ));
790 error = FT_THROW( Invalid_Table );
791 goto Exit;
792 }
793
794 if ( FT_READ_ULONG( store_offset ) ||
795 FT_READ_ULONG( widthMap_offset ) )
796 goto Exit;
797
798 if ( vertical )
799 {
800 if ( FT_NEW( blend->vvar_table ) )
801 goto Exit;
802 table = blend->vvar_table;
803 }
804 else
805 {
806 if ( FT_NEW( blend->hvar_table ) )
807 goto Exit;
808 table = blend->hvar_table;
809 }
810
811 error = ft_var_load_item_variation_store(
812 face,
813 table_offset + store_offset,
814 &table->itemStore );
815 if ( error )
816 goto Exit;
817
818 if ( widthMap_offset )
819 {
820 error = ft_var_load_delta_set_index_mapping(
821 face,
822 table_offset + widthMap_offset,
823 &table->widthMap,
824 &table->itemStore );
825 if ( error )
826 goto Exit;
827 }
828
829 FT_TRACE2(( "loaded\n" ));
830 error = FT_Err_Ok;
831
832 Exit:
833 if ( !error )
834 {
835 if ( vertical )
836 {
837 blend->vvar_checked = TRUE;
838
839 /* FreeType doesn't provide functions to quickly retrieve */
840 /* TSB, BSB, or VORG values; we thus don't have to implement */
841 /* support for those three item variation stores. */
842
843 face->variation_support |= TT_FACE_FLAG_VAR_VADVANCE;
844 }
845 else
846 {
847 blend->hvar_checked = TRUE;
848
849 /* FreeType doesn't provide functions to quickly retrieve */
850 /* LSB or RSB values; we thus don't have to implement */
851 /* support for those two item variation stores. */
852
853 face->variation_support |= TT_FACE_FLAG_VAR_HADVANCE;
854 }
855 }
856
857 return error;
858 }
859
860
861 static FT_Int
862 ft_var_get_item_delta( TT_Face face,
863 GX_ItemVarStore itemStore,
864 FT_UInt outerIndex,
865 FT_UInt innerIndex )
866 {
867 GX_ItemVarData varData;
868 FT_Short* deltaSet;
869
870 FT_UInt master, j;
871 FT_Fixed netAdjustment = 0; /* accumulated adjustment */
872 FT_Fixed scaledDelta;
873 FT_Fixed delta;
874
875
876 /* See pseudo code from `Font Variations Overview' */
877 /* in the OpenType specification. */
878
879 varData = &itemStore->varData[outerIndex];
880 deltaSet = &varData->deltaSet[varData->regionIdxCount * innerIndex];
881
882 /* outer loop steps through master designs to be blended */
883 for ( master = 0; master < varData->regionIdxCount; master++ )
884 {
885 FT_Fixed scalar = 0x10000L;
886 FT_UInt regionIndex = varData->regionIndices[master];
887
888 GX_AxisCoords axis = itemStore->varRegionList[regionIndex].axisList;
889
890
891 /* inner loop steps through axes in this region */
892 for ( j = 0; j < itemStore->axisCount; j++, axis++ )
893 {
894 /* compute the scalar contribution of this axis; */
895 /* ignore invalid ranges */
896 if ( axis->startCoord > axis->peakCoord ||
897 axis->peakCoord > axis->endCoord )
898 continue;
899
900 else if ( axis->startCoord < 0 &&
901 axis->endCoord > 0 &&
902 axis->peakCoord != 0 )
903 continue;
904
905 /* peak of 0 means ignore this axis */
906 else if ( axis->peakCoord == 0 )
907 continue;
908
909 else if ( face->blend->normalizedcoords[j] == axis->peakCoord )
910 continue;
911
912 /* ignore this region if coords are out of range */
913 else if ( face->blend->normalizedcoords[j] <= axis->startCoord ||
914 face->blend->normalizedcoords[j] >= axis->endCoord )
915 {
916 scalar = 0;
917 break;
918 }
919
920 /* cumulative product of all the axis scalars */
921 else if ( face->blend->normalizedcoords[j] < axis->peakCoord )
922 scalar =
923 FT_MulDiv( scalar,
924 face->blend->normalizedcoords[j] - axis->startCoord,
925 axis->peakCoord - axis->startCoord );
926 else
927 scalar =
928 FT_MulDiv( scalar,
929 axis->endCoord - face->blend->normalizedcoords[j],
930 axis->endCoord - axis->peakCoord );
931 } /* per-axis loop */
932
933 /* get the scaled delta for this region */
934 delta = FT_intToFixed( deltaSet[master] );
935 scaledDelta = FT_MulFix( scalar, delta );
936
937 /* accumulate the adjustments from each region */
938 netAdjustment = netAdjustment + scaledDelta;
939
940 } /* per-region loop */
941
942 return FT_fixedToInt( netAdjustment );
943 }
944
945
946 /**************************************************************************
947 *
948 * @Function:
949 * tt_hvadvance_adjust
950 *
951 * @Description:
952 * Apply `HVAR' advance width or `VVAR' advance height adjustment of
953 * a given glyph.
954 *
955 * @Input:
956 * gindex ::
957 * The glyph index.
958 *
959 * vertical ::
960 * If set, handle `VVAR' table.
961 *
962 * @InOut:
963 * face ::
964 * The font face.
965 *
966 * adelta ::
967 * Points to width or height value that gets modified.
968 */
969 static FT_Error
970 tt_hvadvance_adjust( TT_Face face,
971 FT_UInt gindex,
972 FT_Int *avalue,
973 FT_Bool vertical )
974 {
975 FT_Error error = FT_Err_Ok;
976 FT_UInt innerIndex, outerIndex;
977 FT_Int delta;
978
979 GX_HVVarTable table;
980
981
982 if ( !face->doblend || !face->blend )
983 goto Exit;
984
985 if ( vertical )
986 {
987 if ( !face->blend->vvar_loaded )
988 {
989 /* initialize vvar table */
990 face->blend->vvar_error = ft_var_load_hvvar( face, 1 );
991 }
992
993 if ( !face->blend->vvar_checked )
994 {
995 error = face->blend->vvar_error;
996 goto Exit;
997 }
998
999 table = face->blend->vvar_table;
1000 }
1001 else
1002 {
1003 if ( !face->blend->hvar_loaded )
1004 {
1005 /* initialize hvar table */
1006 face->blend->hvar_error = ft_var_load_hvvar( face, 0 );
1007 }
1008
1009 if ( !face->blend->hvar_checked )
1010 {
1011 error = face->blend->hvar_error;
1012 goto Exit;
1013 }
1014
1015 table = face->blend->hvar_table;
1016 }
1017
1018 /* advance width or height adjustments are always present in an */
1019 /* `HVAR' or `VVAR' table; no need to test for this capability */
1020
1021 if ( table->widthMap.innerIndex )
1022 {
1023 FT_UInt idx = gindex;
1024
1025
1026 if ( idx >= table->widthMap.mapCount )
1027 idx = table->widthMap.mapCount - 1;
1028
1029 /* trust that HVAR parser has checked indices */
1030 outerIndex = table->widthMap.outerIndex[idx];
1031 innerIndex = table->widthMap.innerIndex[idx];
1032 }
1033 else
1034 {
1035 GX_ItemVarData varData;
1036
1037
1038 /* no widthMap data */
1039 outerIndex = 0;
1040 innerIndex = gindex;
1041
1042 varData = &table->itemStore.varData[outerIndex];
1043 if ( gindex >= varData->itemCount )
1044 {
1045 FT_TRACE2(( "gindex %d out of range\n", gindex ));
1046 error = FT_THROW( Invalid_Argument );
1047 goto Exit;
1048 }
1049 }
1050
1051 delta = ft_var_get_item_delta( face,
1052 &table->itemStore,
1053 outerIndex,
1054 innerIndex );
1055
1056 FT_TRACE5(( "%s value %d adjusted by %d unit%s (%s)\n",
1057 vertical ? "vertical height" : "horizontal width",
1058 *avalue,
1059 delta,
1060 delta == 1 ? "" : "s",
1061 vertical ? "VVAR" : "HVAR" ));
1062
1063 *avalue += delta;
1064
1065 Exit:
1066 return error;
1067 }
1068
1069
1070 FT_LOCAL_DEF( FT_Error )
1071 tt_hadvance_adjust( TT_Face face,
1072 FT_UInt gindex,
1073 FT_Int *avalue )
1074 {
1075 return tt_hvadvance_adjust( face, gindex, avalue, 0 );
1076 }
1077
1078
1079 FT_LOCAL_DEF( FT_Error )
1080 tt_vadvance_adjust( TT_Face face,
1081 FT_UInt gindex,
1082 FT_Int *avalue )
1083 {
1084 return tt_hvadvance_adjust( face, gindex, avalue, 1 );
1085 }
1086
1087
1088 #define GX_VALUE_SIZE 8
1089
1090 /* all values are FT_Short or FT_UShort entities; */
1091 /* we treat them consistently as FT_Short */
1092 #define GX_VALUE_CASE( tag, dflt ) \
1093 case MVAR_TAG_ ## tag : \
1094 p = (FT_Short*)&face->dflt; \
1095 break
1096
1097 #define GX_GASP_CASE( idx ) \
1098 case MVAR_TAG_GASP_ ## idx : \
1099 if ( idx < face->gasp.numRanges - 1 ) \
1100 p = (FT_Short*)&face->gasp.gaspRanges[idx].maxPPEM; \
1101 else \
1102 p = NULL; \
1103 break
1104
1105
1106 static FT_Short*
1107 ft_var_get_value_pointer( TT_Face face,
1108 FT_ULong mvar_tag )
1109 {
1110 FT_Short* p;
1111
1112
1113 switch ( mvar_tag )
1114 {
1115 GX_GASP_CASE( 0 );
1116 GX_GASP_CASE( 1 );
1117 GX_GASP_CASE( 2 );
1118 GX_GASP_CASE( 3 );
1119 GX_GASP_CASE( 4 );
1120 GX_GASP_CASE( 5 );
1121 GX_GASP_CASE( 6 );
1122 GX_GASP_CASE( 7 );
1123 GX_GASP_CASE( 8 );
1124 GX_GASP_CASE( 9 );
1125
1126 GX_VALUE_CASE( CPHT, os2.sCapHeight );
1127 GX_VALUE_CASE( HASC, os2.sTypoAscender );
1128 GX_VALUE_CASE( HCLA, os2.usWinAscent );
1129 GX_VALUE_CASE( HCLD, os2.usWinDescent );
1130 GX_VALUE_CASE( HCOF, horizontal.caret_Offset );
1131 GX_VALUE_CASE( HCRN, horizontal.caret_Slope_Run );
1132 GX_VALUE_CASE( HCRS, horizontal.caret_Slope_Rise );
1133 GX_VALUE_CASE( HDSC, os2.sTypoDescender );
1134 GX_VALUE_CASE( HLGP, os2.sTypoLineGap );
1135 GX_VALUE_CASE( SBXO, os2.ySubscriptXOffset);
1136 GX_VALUE_CASE( SBXS, os2.ySubscriptXSize );
1137 GX_VALUE_CASE( SBYO, os2.ySubscriptYOffset );
1138 GX_VALUE_CASE( SBYS, os2.ySubscriptYSize );
1139 GX_VALUE_CASE( SPXO, os2.ySuperscriptXOffset );
1140 GX_VALUE_CASE( SPXS, os2.ySuperscriptXSize );
1141 GX_VALUE_CASE( SPYO, os2.ySuperscriptYOffset );
1142 GX_VALUE_CASE( SPYS, os2.ySuperscriptYSize );
1143 GX_VALUE_CASE( STRO, os2.yStrikeoutPosition );
1144 GX_VALUE_CASE( STRS, os2.yStrikeoutSize );
1145 GX_VALUE_CASE( UNDO, postscript.underlinePosition );
1146 GX_VALUE_CASE( UNDS, postscript.underlineThickness );
1147 GX_VALUE_CASE( VASC, vertical.Ascender );
1148 GX_VALUE_CASE( VCOF, vertical.caret_Offset );
1149 GX_VALUE_CASE( VCRN, vertical.caret_Slope_Run );
1150 GX_VALUE_CASE( VCRS, vertical.caret_Slope_Rise );
1151 GX_VALUE_CASE( VDSC, vertical.Descender );
1152 GX_VALUE_CASE( VLGP, vertical.Line_Gap );
1153 GX_VALUE_CASE( XHGT, os2.sxHeight );
1154
1155 default:
1156 /* ignore unknown tag */
1157 p = NULL;
1158 }
1159
1160 return p;
1161 }
1162
1163
1164 /**************************************************************************
1165 *
1166 * @Function:
1167 * ft_var_load_mvar
1168 *
1169 * @Description:
1170 * Parse the `MVAR' table.
1171 *
1172 * Some memory may remain allocated on error; it is always freed in
1173 * `tt_done_blend', however.
1174 *
1175 * @InOut:
1176 * face ::
1177 * The font face.
1178 */
1179 static void
1180 ft_var_load_mvar( TT_Face face )
1181 {
1182 FT_Stream stream = FT_FACE_STREAM( face );
1183 FT_Memory memory = stream->memory;
1184
1185 GX_Blend blend = face->blend;
1186 GX_ItemVarStore itemStore;
1187 GX_Value value, limit;
1188
1189 FT_Error error;
1190 FT_UShort majorVersion;
1191 FT_ULong table_len;
1192 FT_ULong table_offset;
1193 FT_UShort store_offset;
1194 FT_ULong records_offset;
1195
1196
1197 FT_TRACE2(( "MVAR " ));
1198
1199 error = face->goto_table( face, TTAG_MVAR, stream, &table_len );
1200 if ( error )
1201 {
1202 FT_TRACE2(( "is missing\n" ));
1203 return;
1204 }
1205
1206 table_offset = FT_STREAM_POS();
1207
1208 /* skip minor version */
1209 if ( FT_READ_USHORT( majorVersion ) ||
1210 FT_STREAM_SKIP( 2 ) )
1211 return;
1212
1213 if ( majorVersion != 1 )
1214 {
1215 FT_TRACE2(( "bad table version %d\n", majorVersion ));
1216 return;
1217 }
1218
1219 if ( FT_NEW( blend->mvar_table ) )
1220 return;
1221
1222 /* skip reserved entry and value record size */
1223 if ( FT_STREAM_SKIP( 4 ) ||
1224 FT_READ_USHORT( blend->mvar_table->valueCount ) ||
1225 FT_READ_USHORT( store_offset ) )
1226 return;
1227
1228 records_offset = FT_STREAM_POS();
1229
1230 error = ft_var_load_item_variation_store(
1231 face,
1232 table_offset + store_offset,
1233 &blend->mvar_table->itemStore );
1234 if ( error )
1235 return;
1236
1237 if ( FT_NEW_ARRAY( blend->mvar_table->values,
1238 blend->mvar_table->valueCount ) )
1239 return;
1240
1241 if ( FT_STREAM_SEEK( records_offset ) ||
1242 FT_FRAME_ENTER( blend->mvar_table->valueCount * GX_VALUE_SIZE ) )
1243 return;
1244
1245 value = blend->mvar_table->values;
1246 limit = value + blend->mvar_table->valueCount;
1247 itemStore = &blend->mvar_table->itemStore;
1248
1249 for ( ; value < limit; value++ )
1250 {
1251 value->tag = FT_GET_ULONG();
1252 value->outerIndex = FT_GET_USHORT();
1253 value->innerIndex = FT_GET_USHORT();
1254
1255 if ( value->outerIndex >= itemStore->dataCount ||
1256 value->innerIndex >= itemStore->varData[value->outerIndex]
1257 .itemCount )
1258 {
1259 error = FT_THROW( Invalid_Table );
1260 break;
1261 }
1262 }
1263
1264 FT_FRAME_EXIT();
1265
1266 if ( error )
1267 return;
1268
1269 FT_TRACE2(( "loaded\n" ));
1270
1271 value = blend->mvar_table->values;
1272 limit = value + blend->mvar_table->valueCount;
1273
1274 /* save original values of the data MVAR is going to modify */
1275 for ( ; value < limit; value++ )
1276 {
1277 FT_Short* p = ft_var_get_value_pointer( face, value->tag );
1278
1279
1280 if ( p )
1281 value->unmodified = *p;
1282 #ifdef FT_DEBUG_LEVEL_TRACE
1283 else
1284 FT_TRACE1(( "ft_var_load_mvar: Ignoring unknown tag `%c%c%c%c'\n",
1285 (FT_Char)( value->tag >> 24 ),
1286 (FT_Char)( value->tag >> 16 ),
1287 (FT_Char)( value->tag >> 8 ),
1288 (FT_Char)( value->tag ) ));
1289 #endif
1290 }
1291
1292 face->variation_support |= TT_FACE_FLAG_VAR_MVAR;
1293 }
1294
1295
1296 static FT_Error
1297 tt_size_reset_iterator( FT_ListNode node,
1298 void* user )
1299 {
1300 TT_Size size = (TT_Size)node->data;
1301
1302 FT_UNUSED( user );
1303
1304
1305 tt_size_reset( size, 1 );
1306
1307 return FT_Err_Ok;
1308 }
1309
1310
1311 /**************************************************************************
1312 *
1313 * @Function:
1314 * tt_apply_mvar
1315 *
1316 * @Description:
1317 * Apply `MVAR' table adjustments.
1318 *
1319 * @InOut:
1320 * face ::
1321 * The font face.
1322 */
1323 FT_LOCAL_DEF( void )
1324 tt_apply_mvar( TT_Face face )
1325 {
1326 GX_Blend blend = face->blend;
1327 GX_Value value, limit;
1328 FT_Short mvar_hasc_delta = 0;
1329 FT_Short mvar_hdsc_delta = 0;
1330 FT_Short mvar_hlgp_delta = 0;
1331
1332
1333 if ( !( face->variation_support & TT_FACE_FLAG_VAR_MVAR ) )
1334 return;
1335
1336 value = blend->mvar_table->values;
1337 limit = value + blend->mvar_table->valueCount;
1338
1339 for ( ; value < limit; value++ )
1340 {
1341 FT_Short* p = ft_var_get_value_pointer( face, value->tag );
1342 FT_Int delta;
1343
1344
1345 delta = ft_var_get_item_delta( face,
1346 &blend->mvar_table->itemStore,
1347 value->outerIndex,
1348 value->innerIndex );
1349
1350 if ( p )
1351 {
1352 FT_TRACE5(( "value %c%c%c%c (%d unit%s) adjusted by %d unit%s (MVAR)\n",
1353 (FT_Char)( value->tag >> 24 ),
1354 (FT_Char)( value->tag >> 16 ),
1355 (FT_Char)( value->tag >> 8 ),
1356 (FT_Char)( value->tag ),
1357 value->unmodified,
1358 value->unmodified == 1 ? "" : "s",
1359 delta,
1360 delta == 1 ? "" : "s" ));
1361
1362 /* since we handle both signed and unsigned values as FT_Short, */
1363 /* ensure proper overflow arithmetic */
1364 *p = (FT_Short)( value->unmodified + (FT_Short)delta );
1365
1366 /* Treat hasc, hdsc and hlgp specially, see below. */
1367 if ( value->tag == MVAR_TAG_HASC )
1368 mvar_hasc_delta = (FT_Short)delta;
1369 else if ( value->tag == MVAR_TAG_HDSC )
1370 mvar_hdsc_delta = (FT_Short)delta;
1371 else if ( value->tag == MVAR_TAG_HLGP )
1372 mvar_hlgp_delta = (FT_Short)delta;
1373 }
1374 }
1375
1376 /* adjust all derived values */
1377 {
1378 FT_Face root = &face->root;
1379
1380 /*
1381 * Apply the deltas of hasc, hdsc and hlgp to the FT_Face's ascender,
1382 * descender and height attributes, no matter how they were originally
1383 * computed.
1384 *
1385 * (Code that ignores those and accesses the font's metrics values
1386 * directly is already served by the delta application code above.)
1387 *
1388 * The MVAR table supports variations for both typo and win metrics.
1389 * According to Behdad Esfahbod, the thinking of the working group was
1390 * that no one uses win metrics anymore for setting line metrics (the
1391 * specification even calls these metrics "horizontal clipping
1392 * ascent/descent", probably for their role on the Windows platform in
1393 * computing clipping boxes), and new fonts should use typo metrics, so
1394 * typo deltas should be applied to whatever sfnt_load_face decided the
1395 * line metrics should be.
1396 *
1397 * Before, the following led to different line metrics between default
1398 * outline and instances, visible when e.g. the default outlines were
1399 * used as the regular face and instances for everything else:
1400 *
1401 * 1. sfnt_load_face applied the hhea metrics by default.
1402 * 2. This code later applied the typo metrics by default, regardless of
1403 * whether they were actually changed or the font had the OS/2 table's
1404 * fsSelection's bit 7 (USE_TYPO_METRICS) set.
1405 */
1406 FT_Short current_line_gap = root->height - root->ascender +
1407 root->descender;
1408
1409
1410 root->ascender = root->ascender + mvar_hasc_delta;
1411 root->descender = root->descender + mvar_hdsc_delta;
1412 root->height = root->ascender - root->descender +
1413 current_line_gap + mvar_hlgp_delta;
1414
1415 root->underline_position = face->postscript.underlinePosition -
1416 face->postscript.underlineThickness / 2;
1417 root->underline_thickness = face->postscript.underlineThickness;
1418
1419 /* iterate over all FT_Size objects and call `tt_size_reset' */
1420 /* to propagate the metrics changes */
1421 FT_List_Iterate( &root->sizes_list,
1422 tt_size_reset_iterator,
1423 NULL );
1424 }
1425 }
1426
1427
1428 typedef struct GX_GVar_Head_
1429 {
1430 FT_Long version;
1431 FT_UShort axisCount;
1432 FT_UShort globalCoordCount;
1433 FT_ULong offsetToCoord;
1434 FT_UShort glyphCount;
1435 FT_UShort flags;
1436 FT_ULong offsetToData;
1437
1438 } GX_GVar_Head;
1439
1440
1441 /**************************************************************************
1442 *
1443 * @Function:
1444 * ft_var_load_gvar
1445 *
1446 * @Description:
1447 * Parse the `gvar' table if present. If `fvar' is there, `gvar' had
1448 * better be there too.
1449 *
1450 * @InOut:
1451 * face ::
1452 * The font face.
1453 *
1454 * @Return:
1455 * FreeType error code. 0 means success.
1456 */
1457 static FT_Error
1458 ft_var_load_gvar( TT_Face face )
1459 {
1460 FT_Stream stream = FT_FACE_STREAM( face );
1461 FT_Memory memory = stream->memory;
1462 GX_Blend blend = face->blend;
1463 FT_Error error;
1464 FT_UInt i, j;
1465 FT_ULong table_len;
1466 FT_ULong gvar_start;
1467 FT_ULong offsetToData;
1468 GX_GVar_Head gvar_head;
1469
1470 static const FT_Frame_Field gvar_fields[] =
1471 {
1472
1473 #undef FT_STRUCTURE
1474 #define FT_STRUCTURE GX_GVar_Head
1475
1476 FT_FRAME_START( 20 ),
1477 FT_FRAME_LONG ( version ),
1478 FT_FRAME_USHORT( axisCount ),
1479 FT_FRAME_USHORT( globalCoordCount ),
1480 FT_FRAME_ULONG ( offsetToCoord ),
1481 FT_FRAME_USHORT( glyphCount ),
1482 FT_FRAME_USHORT( flags ),
1483 FT_FRAME_ULONG ( offsetToData ),
1484 FT_FRAME_END
1485 };
1486
1487
1488 FT_TRACE2(( "GVAR " ));
1489
1490 if ( FT_SET_ERROR( face->goto_table( face,
1491 TTAG_gvar,
1492 stream,
1493 &table_len ) ) )
1494 {
1495 FT_TRACE2(( "is missing\n" ));
1496 goto Exit;
1497 }
1498
1499 gvar_start = FT_STREAM_POS( );
1500 if ( FT_STREAM_READ_FIELDS( gvar_fields, &gvar_head ) )
1501 goto Exit;
1502
1503 if ( gvar_head.version != 0x00010000L )
1504 {
1505 FT_TRACE1(( "bad table version\n" ));
1506 error = FT_THROW( Invalid_Table );
1507 goto Exit;
1508 }
1509
1510 if ( gvar_head.axisCount != (FT_UShort)blend->mmvar->num_axis )
1511 {
1512 FT_TRACE1(( "ft_var_load_gvar: number of axes in `gvar' and `cvar'\n"
1513 " table are different\n" ));
1514 error = FT_THROW( Invalid_Table );
1515 goto Exit;
1516 }
1517
1518 /* rough sanity check, ignoring offsets */
1519 if ( (FT_ULong)gvar_head.globalCoordCount * gvar_head.axisCount >
1520 table_len / 2 )
1521 {
1522 FT_TRACE1(( "ft_var_load_gvar:"
1523 " invalid number of global coordinates\n" ));
1524 error = FT_THROW( Invalid_Table );
1525 goto Exit;
1526 }
1527
1528 /* rough sanity check: offsets can be either 2 or 4 bytes */
1529 if ( (FT_ULong)gvar_head.glyphCount *
1530 ( ( gvar_head.flags & 1 ) ? 4 : 2 ) > table_len )
1531 {
1532 FT_TRACE1(( "ft_var_load_gvar: invalid number of glyphs\n" ));
1533 error = FT_THROW( Invalid_Table );
1534 goto Exit;
1535 }
1536
1537 FT_TRACE2(( "loaded\n" ));
1538
1539 blend->gvar_size = table_len;
1540 blend->tuplecount = gvar_head.globalCoordCount;
1541 blend->gv_glyphcnt = gvar_head.glyphCount;
1542 offsetToData = gvar_start + gvar_head.offsetToData;
1543
1544 FT_TRACE5(( "gvar: there %s %d shared coordinate%s:\n",
1545 blend->tuplecount == 1 ? "is" : "are",
1546 blend->tuplecount,
1547 blend->tuplecount == 1 ? "" : "s" ));
1548
1549 if ( FT_NEW_ARRAY( blend->glyphoffsets, blend->gv_glyphcnt + 1 ) )
1550 goto Exit;
1551
1552 if ( gvar_head.flags & 1 )
1553 {
1554 FT_ULong limit = gvar_start + table_len;
1555
1556
1557 /* long offsets (one more offset than glyphs, to mark size of last) */
1558 if ( FT_FRAME_ENTER( ( blend->gv_glyphcnt + 1 ) * 4L ) )
1559 goto Exit;
1560
1561 for ( i = 0; i <= blend->gv_glyphcnt; i++ )
1562 {
1563 blend->glyphoffsets[i] = offsetToData + FT_GET_ULONG();
1564 /* use `>', not `>=' */
1565 if ( blend->glyphoffsets[i] > limit )
1566 {
1567 FT_TRACE2(( "ft_var_load_gvar:"
1568 " invalid glyph variation data offset for index %d\n",
1569 i ));
1570 error = FT_THROW( Invalid_Table );
1571 break;
1572 }
1573 }
1574 }
1575 else
1576 {
1577 FT_ULong limit = gvar_start + table_len;
1578
1579
1580 /* short offsets (one more offset than glyphs, to mark size of last) */
1581 if ( FT_FRAME_ENTER( ( blend->gv_glyphcnt + 1 ) * 2L ) )
1582 goto Exit;
1583
1584 for ( i = 0; i <= blend->gv_glyphcnt; i++ )
1585 {
1586 blend->glyphoffsets[i] = offsetToData + FT_GET_USHORT() * 2;
1587 /* use `>', not `>=' */
1588 if ( blend->glyphoffsets[i] > limit )
1589 {
1590 FT_TRACE2(( "ft_var_load_gvar:"
1591 " invalid glyph variation data offset for index %d\n",
1592 i ));
1593 error = FT_THROW( Invalid_Table );
1594 break;
1595 }
1596 }
1597 }
1598
1599 FT_FRAME_EXIT();
1600 if ( error )
1601 goto Exit;
1602
1603 if ( blend->tuplecount != 0 )
1604 {
1605 if ( FT_NEW_ARRAY( blend->tuplecoords,
1606 gvar_head.axisCount * blend->tuplecount ) )
1607 goto Exit;
1608
1609 if ( FT_STREAM_SEEK( gvar_start + gvar_head.offsetToCoord ) ||
1610 FT_FRAME_ENTER( blend->tuplecount * gvar_head.axisCount * 2L ) )
1611 goto Exit;
1612
1613 for ( i = 0; i < blend->tuplecount; i++ )
1614 {
1615 FT_TRACE5(( " [ " ));
1616 for ( j = 0; j < (FT_UInt)gvar_head.axisCount; j++ )
1617 {
1618 blend->tuplecoords[i * gvar_head.axisCount + j] =
1619 FT_GET_SHORT() * 4; /* convert to FT_Fixed */
1620 FT_TRACE5(( "%.5f ",
1621 blend->tuplecoords[i * gvar_head.axisCount + j] / 65536.0 ));
1622 }
1623 FT_TRACE5(( "]\n" ));
1624 }
1625
1626 FT_TRACE5(( "\n" ));
1627
1628 FT_FRAME_EXIT();
1629 }
1630
1631 Exit:
1632 return error;
1633 }
1634
1635
1636 /**************************************************************************
1637 *
1638 * @Function:
1639 * ft_var_apply_tuple
1640 *
1641 * @Description:
1642 * Figure out whether a given tuple (design) applies to the current
1643 * blend, and if so, what is the scaling factor.
1644 *
1645 * @Input:
1646 * blend ::
1647 * The current blend of the font.
1648 *
1649 * tupleIndex ::
1650 * A flag saying whether this is an intermediate
1651 * tuple or not.
1652 *
1653 * tuple_coords ::
1654 * The coordinates of the tuple in normalized axis
1655 * units.
1656 *
1657 * im_start_coords ::
1658 * The initial coordinates where this tuple starts
1659 * to apply (for intermediate coordinates).
1660 *
1661 * im_end_coords ::
1662 * The final coordinates after which this tuple no
1663 * longer applies (for intermediate coordinates).
1664 *
1665 * @Return:
1666 * An FT_Fixed value containing the scaling factor.
1667 */
1668 static FT_Fixed
1669 ft_var_apply_tuple( GX_Blend blend,
1670 FT_UShort tupleIndex,
1671 FT_Fixed* tuple_coords,
1672 FT_Fixed* im_start_coords,
1673 FT_Fixed* im_end_coords )
1674 {
1675 FT_UInt i;
1676 FT_Fixed apply = 0x10000L;
1677
1678
1679 for ( i = 0; i < blend->num_axis; i++ )
1680 {
1681 FT_TRACE6(( " axis %d coordinate %.5f:\n",
1682 i, blend->normalizedcoords[i] / 65536.0 ));
1683
1684 /* It's not clear why (for intermediate tuples) we don't need */
1685 /* to check against start/end -- the documentation says we don't. */
1686 /* Similarly, it's unclear why we don't need to scale along the */
1687 /* axis. */
1688
1689 if ( tuple_coords[i] == 0 )
1690 {
1691 FT_TRACE6(( " tuple coordinate is zero, ignore\n", i ));
1692 continue;
1693 }
1694
1695 if ( blend->normalizedcoords[i] == 0 )
1696 {
1697 FT_TRACE6(( " axis coordinate is zero, stop\n" ));
1698 apply = 0;
1699 break;
1700 }
1701
1702 if ( blend->normalizedcoords[i] == tuple_coords[i] )
1703 {
1704 FT_TRACE6(( " tuple coordinate %.5f fits perfectly\n",
1705 tuple_coords[i] / 65536.0 ));
1706 /* `apply' does not change */
1707 continue;
1708 }
1709
1710 if ( !( tupleIndex & GX_TI_INTERMEDIATE_TUPLE ) )
1711 {
1712 /* not an intermediate tuple */
1713
1714 if ( blend->normalizedcoords[i] < FT_MIN( 0, tuple_coords[i] ) ||
1715 blend->normalizedcoords[i] > FT_MAX( 0, tuple_coords[i] ) )
1716 {
1717 FT_TRACE6(( " tuple coordinate %.5f is exceeded, stop\n",
1718 tuple_coords[i] / 65536.0 ));
1719 apply = 0;
1720 break;
1721 }
1722
1723 FT_TRACE6(( " tuple coordinate %.5f fits\n",
1724 tuple_coords[i] / 65536.0 ));
1725 apply = FT_MulDiv( apply,
1726 blend->normalizedcoords[i],
1727 tuple_coords[i] );
1728 }
1729 else
1730 {
1731 /* intermediate tuple */
1732
1733 if ( blend->normalizedcoords[i] <= im_start_coords[i] ||
1734 blend->normalizedcoords[i] >= im_end_coords[i] )
1735 {
1736 FT_TRACE6(( " intermediate tuple range ]%.5f;%.5f[ is exceeded,"
1737 " stop\n",
1738 im_start_coords[i] / 65536.0,
1739 im_end_coords[i] / 65536.0 ));
1740 apply = 0;
1741 break;
1742 }
1743
1744 FT_TRACE6(( " intermediate tuple range ]%.5f;%.5f[ fits\n",
1745 im_start_coords[i] / 65536.0,
1746 im_end_coords[i] / 65536.0 ));
1747 if ( blend->normalizedcoords[i] < tuple_coords[i] )
1748 apply = FT_MulDiv( apply,
1749 blend->normalizedcoords[i] - im_start_coords[i],
1750 tuple_coords[i] - im_start_coords[i] );
1751 else
1752 apply = FT_MulDiv( apply,
1753 im_end_coords[i] - blend->normalizedcoords[i],
1754 im_end_coords[i] - tuple_coords[i] );
1755 }
1756 }
1757
1758 FT_TRACE6(( " apply factor is %.5f\n", apply / 65536.0 ));
1759
1760 return apply;
1761 }
1762
1763
1764 /* convert from design coordinates to normalized coordinates */
1765
1766 static void
1767 ft_var_to_normalized( TT_Face face,
1768 FT_UInt num_coords,
1769 FT_Fixed* coords,
1770 FT_Fixed* normalized )
1771 {
1772 GX_Blend blend;
1773 FT_MM_Var* mmvar;
1774 FT_UInt i, j;
1775 FT_Var_Axis* a;
1776 GX_AVarSegment av;
1777
1778
1779 blend = face->blend;
1780 mmvar = blend->mmvar;
1781
1782 if ( num_coords > mmvar->num_axis )
1783 {
1784 FT_TRACE2(( "ft_var_to_normalized:"
1785 " only using first %d of %d coordinates\n",
1786 mmvar->num_axis, num_coords ));
1787 num_coords = mmvar->num_axis;
1788 }
1789
1790 /* Axis normalization is a two-stage process. First we normalize */
1791 /* based on the [min,def,max] values for the axis to be [-1,0,1]. */
1792 /* Then, if there's an `avar' table, we renormalize this range. */
1793
1794 a = mmvar->axis;
1795 for ( i = 0; i < num_coords; i++, a++ )
1796 {
1797 FT_Fixed coord = coords[i];
1798
1799
1800 FT_TRACE5(( " %d: %.5f\n", i, coord / 65536.0 ));
1801 if ( coord > a->maximum || coord < a->minimum )
1802 {
1803 FT_TRACE1((
1804 "ft_var_to_normalized: design coordinate %.5f\n"
1805 " is out of range [%.5f;%.5f]; clamping\n",
1806 coord / 65536.0,
1807 a->minimum / 65536.0,
1808 a->maximum / 65536.0 ));
1809
1810 if ( coord > a->maximum )
1811 coord = a->maximum;
1812 else
1813 coord = a->minimum;
1814 }
1815
1816 if ( coord < a->def )
1817 normalized[i] = -FT_DivFix( SUB_LONG( coord, a->def ),
1818 SUB_LONG( a->minimum, a->def ) );
1819 else if ( coord > a->def )
1820 normalized[i] = FT_DivFix( SUB_LONG( coord, a->def ),
1821 SUB_LONG( a->maximum, a->def ) );
1822 else
1823 normalized[i] = 0;
1824 }
1825
1826 FT_TRACE5(( "\n" ));
1827
1828 for ( ; i < mmvar->num_axis; i++ )
1829 normalized[i] = 0;
1830
1831 if ( blend->avar_segment )
1832 {
1833 FT_TRACE5(( "normalized design coordinates"
1834 " before applying `avar' data:\n" ));
1835
1836 av = blend->avar_segment;
1837 for ( i = 0; i < mmvar->num_axis; i++, av++ )
1838 {
1839 for ( j = 1; j < (FT_UInt)av->pairCount; j++ )
1840 {
1841 if ( normalized[i] < av->correspondence[j].fromCoord )
1842 {
1843 FT_TRACE5(( " %.5f\n", normalized[i] / 65536.0 ));
1844
1845 normalized[i] =
1846 FT_MulDiv( normalized[i] - av->correspondence[j - 1].fromCoord,
1847 av->correspondence[j].toCoord -
1848 av->correspondence[j - 1].toCoord,
1849 av->correspondence[j].fromCoord -
1850 av->correspondence[j - 1].fromCoord ) +
1851 av->correspondence[j - 1].toCoord;
1852 break;
1853 }
1854 }
1855 }
1856 }
1857 }
1858
1859
1860 /* convert from normalized coordinates to design coordinates */
1861
1862 static void
1863 ft_var_to_design( TT_Face face,
1864 FT_UInt num_coords,
1865 FT_Fixed* coords,
1866 FT_Fixed* design )
1867 {
1868 GX_Blend blend;
1869 FT_MM_Var* mmvar;
1870 FT_Var_Axis* a;
1871
1872 FT_UInt i, j, nc;
1873
1874
1875 blend = face->blend;
1876
1877 nc = num_coords;
1878 if ( num_coords > blend->num_axis )
1879 {
1880 FT_TRACE2(( "ft_var_to_design:"
1881 " only using first %d of %d coordinates\n",
1882 blend->num_axis, num_coords ));
1883 nc = blend->num_axis;
1884 }
1885
1886 for ( i = 0; i < nc; i++ )
1887 design[i] = coords[i];
1888
1889 for ( ; i < num_coords; i++ )
1890 design[i] = 0;
1891
1892 if ( blend->avar_segment )
1893 {
1894 GX_AVarSegment av = blend->avar_segment;
1895
1896
1897 FT_TRACE5(( "design coordinates"
1898 " after removing `avar' distortion:\n" ));
1899
1900 for ( i = 0; i < nc; i++, av++ )
1901 {
1902 for ( j = 1; j < (FT_UInt)av->pairCount; j++ )
1903 {
1904 if ( design[i] < av->correspondence[j].toCoord )
1905 {
1906 design[i] =
1907 FT_MulDiv( design[i] - av->correspondence[j - 1].toCoord,
1908 av->correspondence[j].fromCoord -
1909 av->correspondence[j - 1].fromCoord,
1910 av->correspondence[j].toCoord -
1911 av->correspondence[j - 1].toCoord ) +
1912 av->correspondence[j - 1].fromCoord;
1913
1914 FT_TRACE5(( " %.5f\n", design[i] / 65536.0 ));
1915 break;
1916 }
1917 }
1918 }
1919 }
1920
1921 mmvar = blend->mmvar;
1922 a = mmvar->axis;
1923
1924 for ( i = 0; i < nc; i++, a++ )
1925 {
1926 if ( design[i] < 0 )
1927 design[i] = a->def + FT_MulFix( design[i],
1928 a->def - a->minimum );
1929 else if ( design[i] > 0 )
1930 design[i] = a->def + FT_MulFix( design[i],
1931 a->maximum - a->def );
1932 else
1933 design[i] = a->def;
1934 }
1935 }
1936
1937
1938 /*************************************************************************/
1939 /*************************************************************************/
1940 /***** *****/
1941 /***** MULTIPLE MASTERS SERVICE FUNCTIONS *****/
1942 /***** *****/
1943 /*************************************************************************/
1944 /*************************************************************************/
1945
1946
1947 typedef struct GX_FVar_Head_
1948 {
1949 FT_Long version;
1950 FT_UShort offsetToData;
1951 FT_UShort axisCount;
1952 FT_UShort axisSize;
1953 FT_UShort instanceCount;
1954 FT_UShort instanceSize;
1955
1956 } GX_FVar_Head;
1957
1958
1959 typedef struct fvar_axis_
1960 {
1961 FT_ULong axisTag;
1962 FT_Fixed minValue;
1963 FT_Fixed defaultValue;
1964 FT_Fixed maxValue;
1965 FT_UShort flags;
1966 FT_UShort nameID;
1967
1968 } GX_FVar_Axis;
1969
1970
1971 /**************************************************************************
1972 *
1973 * @Function:
1974 * TT_Get_MM_Var
1975 *
1976 * @Description:
1977 * Check that the font's `fvar' table is valid, parse it, and return
1978 * those data. It also loads (and parses) the `MVAR' table, if
1979 * possible.
1980 *
1981 * @InOut:
1982 * face ::
1983 * The font face.
1984 * TT_Get_MM_Var initializes the blend structure.
1985 *
1986 * @Output:
1987 * master ::
1988 * The `fvar' data (must be freed by caller). Can be NULL,
1989 * which makes this function simply load MM support.
1990 *
1991 * @Return:
1992 * FreeType error code. 0 means success.
1993 */
1994 FT_LOCAL_DEF( FT_Error )
1995 TT_Get_MM_Var( TT_Face face,
1996 FT_MM_Var* *master )
1997 {
1998 FT_Stream stream = face->root.stream;
1999 FT_Memory memory = face->root.memory;
2000 FT_ULong table_len;
2001 FT_Error error = FT_Err_Ok;
2002 FT_ULong fvar_start = 0;
2003 FT_UInt i, j;
2004 FT_MM_Var* mmvar = NULL;
2005 FT_Fixed* next_coords;
2006 FT_Fixed* nsc;
2007 FT_String* next_name;
2008 FT_Var_Axis* a;
2009 FT_Fixed* c;
2010 FT_Var_Named_Style* ns;
2011 GX_FVar_Head fvar_head;
2012 FT_Bool usePsName = 0;
2013 FT_UInt num_instances;
2014 FT_UInt num_axes;
2015 FT_UShort* axis_flags;
2016
2017 FT_Offset mmvar_size;
2018 FT_Offset axis_flags_size;
2019 FT_Offset axis_size;
2020 FT_Offset namedstyle_size;
2021 FT_Offset next_coords_size;
2022 FT_Offset next_name_size;
2023
2024 FT_Bool need_init;
2025
2026 static const FT_Frame_Field fvar_fields[] =
2027 {
2028
2029 #undef FT_STRUCTURE
2030 #define FT_STRUCTURE GX_FVar_Head
2031
2032 FT_FRAME_START( 16 ),
2033 FT_FRAME_LONG ( version ),
2034 FT_FRAME_USHORT ( offsetToData ),
2035 FT_FRAME_SKIP_SHORT,
2036 FT_FRAME_USHORT ( axisCount ),
2037 FT_FRAME_USHORT ( axisSize ),
2038 FT_FRAME_USHORT ( instanceCount ),
2039 FT_FRAME_USHORT ( instanceSize ),
2040 FT_FRAME_END
2041 };
2042
2043 static const FT_Frame_Field fvaraxis_fields[] =
2044 {
2045
2046 #undef FT_STRUCTURE
2047 #define FT_STRUCTURE GX_FVar_Axis
2048
2049 FT_FRAME_START( 20 ),
2050 FT_FRAME_ULONG ( axisTag ),
2051 FT_FRAME_LONG ( minValue ),
2052 FT_FRAME_LONG ( defaultValue ),
2053 FT_FRAME_LONG ( maxValue ),
2054 FT_FRAME_USHORT( flags ),
2055 FT_FRAME_USHORT( nameID ),
2056 FT_FRAME_END
2057 };
2058
2059
2060 /* read the font data and set up the internal representation */
2061 /* if not already done */
2062
2063 need_init = !face->blend;
2064
2065 if ( need_init )
2066 {
2067 FT_TRACE2(( "FVAR " ));
2068
2069 /* both `fvar' and `gvar' must be present */
2070 if ( FT_SET_ERROR( face->goto_table( face, TTAG_gvar,
2071 stream, &table_len ) ) )
2072 {
2073 /* CFF2 is an alternate to gvar here */
2074 if ( FT_SET_ERROR( face->goto_table( face, TTAG_CFF2,
2075 stream, &table_len ) ) )
2076 {
2077 FT_TRACE1(( "\n"
2078 "TT_Get_MM_Var: `gvar' or `CFF2' table is missing\n" ));
2079 goto Exit;
2080 }
2081 }
2082
2083 if ( FT_SET_ERROR( face->goto_table( face, TTAG_fvar,
2084 stream, &table_len ) ) )
2085 {
2086 FT_TRACE1(( "is missing\n" ));
2087 goto Exit;
2088 }
2089
2090 fvar_start = FT_STREAM_POS( );
2091
2092 /* the validity of the `fvar' header data was already checked */
2093 /* in function `sfnt_init_face' */
2094 if ( FT_STREAM_READ_FIELDS( fvar_fields, &fvar_head ) )
2095 goto Exit;
2096
2097 usePsName = FT_BOOL( fvar_head.instanceSize ==
2098 6 + 4 * fvar_head.axisCount );
2099
2100 FT_TRACE2(( "loaded\n" ));
2101
2102 FT_TRACE5(( "%d variation ax%s\n",
2103 fvar_head.axisCount,
2104 fvar_head.axisCount == 1 ? "is" : "es" ));
2105
2106 if ( FT_NEW( face->blend ) )
2107 goto Exit;
2108
2109 num_axes = fvar_head.axisCount;
2110 face->blend->num_axis = num_axes;
2111 }
2112 else
2113 num_axes = face->blend->num_axis;
2114
2115 /* `num_instances' holds the number of all named instances, */
2116 /* including the default instance which might be missing */
2117 /* in fvar's table of named instances */
2118 num_instances = (FT_UInt)face->root.style_flags >> 16;
2119
2120 /* prepare storage area for MM data; this cannot overflow */
2121 /* 32-bit arithmetic because of the size limits used in the */
2122 /* `fvar' table validity check in `sfnt_init_face' */
2123
2124 /* the various `*_size' variables, which we also use as */
2125 /* offsets into the `mmlen' array, must be multiples of the */
2126 /* pointer size (except the last one); without such an */
2127 /* alignment there might be runtime errors due to */
2128 /* misaligned addresses */
2129 #undef ALIGN_SIZE
2130 #define ALIGN_SIZE( n ) \
2131 ( ( (n) + sizeof (void*) - 1 ) & ~( sizeof (void*) - 1 ) )
2132
2133 mmvar_size = ALIGN_SIZE( sizeof ( FT_MM_Var ) );
2134 axis_flags_size = ALIGN_SIZE( num_axes *
2135 sizeof ( FT_UShort ) );
2136 axis_size = ALIGN_SIZE( num_axes *
2137 sizeof ( FT_Var_Axis ) );
2138 namedstyle_size = ALIGN_SIZE( num_instances *
2139 sizeof ( FT_Var_Named_Style ) );
2140 next_coords_size = ALIGN_SIZE( num_instances *
2141 num_axes *
2142 sizeof ( FT_Fixed ) );
2143 next_name_size = num_axes * 5;
2144
2145 if ( need_init )
2146 {
2147 face->blend->mmvar_len = mmvar_size +
2148 axis_flags_size +
2149 axis_size +
2150 namedstyle_size +
2151 next_coords_size +
2152 next_name_size;
2153
2154 if ( FT_ALLOC( mmvar, face->blend->mmvar_len ) )
2155 goto Exit;
2156 face->blend->mmvar = mmvar;
2157
2158 /* set up pointers and offsets into the `mmvar' array; */
2159 /* the data gets filled in later on */
2160
2161 mmvar->num_axis =
2162 num_axes;
2163 mmvar->num_designs =
2164 ~0U; /* meaningless in this context; each glyph */
2165 /* may have a different number of designs */
2166 /* (or tuples, as called by Apple) */
2167 mmvar->num_namedstyles =
2168 num_instances;
2169
2170 /* alas, no public field in `FT_Var_Axis' for axis flags */
2171 axis_flags =
2172 (FT_UShort*)( (char*)mmvar + mmvar_size );
2173 mmvar->axis =
2174 (FT_Var_Axis*)( (char*)axis_flags + axis_flags_size );
2175 mmvar->namedstyle =
2176 (FT_Var_Named_Style*)( (char*)mmvar->axis + axis_size );
2177
2178 next_coords = (FT_Fixed*)( (char*)mmvar->namedstyle +
2179 namedstyle_size );
2180 for ( i = 0; i < num_instances; i++ )
2181 {
2182 mmvar->namedstyle[i].coords = next_coords;
2183 next_coords += num_axes;
2184 }
2185
2186 next_name = (FT_String*)( (char*)mmvar->namedstyle +
2187 namedstyle_size + next_coords_size );
2188 for ( i = 0; i < num_axes; i++ )
2189 {
2190 mmvar->axis[i].name = next_name;
2191 next_name += 5;
2192 }
2193
2194 /* now fill in the data */
2195
2196 if ( FT_STREAM_SEEK( fvar_start + fvar_head.offsetToData ) )
2197 goto Exit;
2198
2199 a = mmvar->axis;
2200 for ( i = 0; i < num_axes; i++ )
2201 {
2202 GX_FVar_Axis axis_rec;
2203
2204 #ifdef FT_DEBUG_LEVEL_TRACE
2205 int invalid = 0;
2206 #endif
2207
2208
2209 if ( FT_STREAM_READ_FIELDS( fvaraxis_fields, &axis_rec ) )
2210 goto Exit;
2211 a->tag = axis_rec.axisTag;
2212 a->minimum = axis_rec.minValue;
2213 a->def = axis_rec.defaultValue;
2214 a->maximum = axis_rec.maxValue;
2215 a->strid = axis_rec.nameID;
2216
2217 a->name[0] = (FT_String)( a->tag >> 24 );
2218 a->name[1] = (FT_String)( ( a->tag >> 16 ) & 0xFF );
2219 a->name[2] = (FT_String)( ( a->tag >> 8 ) & 0xFF );
2220 a->name[3] = (FT_String)( ( a->tag ) & 0xFF );
2221 a->name[4] = '\0';
2222
2223 *axis_flags = axis_rec.flags;
2224
2225 if ( a->minimum > a->def ||
2226 a->def > a->maximum )
2227 {
2228 a->minimum = a->def;
2229 a->maximum = a->def;
2230
2231 #ifdef FT_DEBUG_LEVEL_TRACE
2232 invalid = 1;
2233 #endif
2234 }
2235
2236 #ifdef FT_DEBUG_LEVEL_TRACE
2237 if ( i == 0 )
2238 FT_TRACE5(( " idx tag "
2239 /* " XXX `XXXX'" */
2240 " minimum default maximum flags\n" ));
2241 /* " XXXX.XXXXX XXXX.XXXXX XXXX.XXXXX 0xXXXX" */
2242
2243 FT_TRACE5(( " %3d `%s'"
2244 " %10.5f %10.5f %10.5f 0x%04X%s\n",
2245 i,
2246 a->name,
2247 a->minimum / 65536.0,
2248 a->def / 65536.0,
2249 a->maximum / 65536.0,
2250 *axis_flags,
2251 invalid ? " (invalid, disabled)" : "" ));
2252 #endif
2253
2254 a++;
2255 axis_flags++;
2256 }
2257
2258 FT_TRACE5(( "\n" ));
2259
2260 /* named instance coordinates are stored as design coordinates; */
2261 /* we have to convert them to normalized coordinates also */
2262 if ( FT_NEW_ARRAY( face->blend->normalized_stylecoords,
2263 num_axes * num_instances ) )
2264 goto Exit;
2265
2266 if ( fvar_head.instanceCount && !face->blend->avar_loaded )
2267 {
2268 FT_ULong offset = FT_STREAM_POS();
2269
2270
2271 ft_var_load_avar( face );
2272
2273 if ( FT_STREAM_SEEK( offset ) )
2274 goto Exit;
2275 }
2276
2277 FT_TRACE5(( "%d instance%s\n",
2278 fvar_head.instanceCount,
2279 fvar_head.instanceCount == 1 ? "" : "s" ));
2280
2281 ns = mmvar->namedstyle;
2282 nsc = face->blend->normalized_stylecoords;
2283 for ( i = 0; i < fvar_head.instanceCount; i++, ns++ )
2284 {
2285 /* PostScript names add 2 bytes to the instance record size */
2286 if ( FT_FRAME_ENTER( ( usePsName ? 6L : 4L ) +
2287 4L * num_axes ) )
2288 goto Exit;
2289
2290 ns->strid = FT_GET_USHORT();
2291 (void) /* flags = */ FT_GET_USHORT();
2292
2293 c = ns->coords;
2294 for ( j = 0; j < num_axes; j++, c++ )
2295 *c = FT_GET_LONG();
2296
2297 /* valid psid values are 6, [256;32767], and 0xFFFF */
2298 if ( usePsName )
2299 ns->psid = FT_GET_USHORT();
2300 else
2301 ns->psid = 0xFFFF;
2302
2303 #ifdef FT_DEBUG_LEVEL_TRACE
2304 {
2305 SFNT_Service sfnt = (SFNT_Service)face->sfnt;
2306
2307 FT_String* strname = NULL;
2308 FT_String* psname = NULL;
2309
2310 FT_ULong pos;
2311
2312
2313 pos = FT_STREAM_POS();
2314
2315 if ( ns->strid != 0xFFFF )
2316 {
2317 (void)sfnt->get_name( face,
2318 (FT_UShort)ns->strid,
2319 &strname );
2320 if ( strname && !ft_strcmp( strname, ".notdef" ) )
2321 strname = NULL;
2322 }
2323
2324 if ( ns->psid != 0xFFFF )
2325 {
2326 (void)sfnt->get_name( face,
2327 (FT_UShort)ns->psid,
2328 &psname );
2329 if ( psname && !ft_strcmp( psname, ".notdef" ) )
2330 psname = NULL;
2331 }
2332
2333 (void)FT_STREAM_SEEK( pos );
2334
2335 FT_TRACE5(( " instance %d (%s%s%s, %s%s%s)\n",
2336 i,
2337 strname ? "name: `" : "",
2338 strname ? strname : "unnamed",
2339 strname ? "'" : "",
2340 psname ? "PS name: `" : "",
2341 psname ? psname : "no PS name",
2342 psname ? "'" : "" ));
2343
2344 FT_FREE( strname );
2345 FT_FREE( psname );
2346 }
2347 #endif /* FT_DEBUG_LEVEL_TRACE */
2348
2349 ft_var_to_normalized( face, num_axes, ns->coords, nsc );
2350 nsc += num_axes;
2351
2352 FT_FRAME_EXIT();
2353 }
2354
2355 if ( num_instances != fvar_head.instanceCount )
2356 {
2357 SFNT_Service sfnt = (SFNT_Service)face->sfnt;
2358
2359 FT_Int found, dummy1, dummy2;
2360 FT_UInt strid = ~0U;
2361
2362
2363 /* the default instance is missing in array the */
2364 /* of named instances; try to synthesize an entry */
2365 found = sfnt->get_name_id( face,
2366 TT_NAME_ID_TYPOGRAPHIC_SUBFAMILY,
2367 &dummy1,
2368 &dummy2 );
2369 if ( found )
2370 strid = TT_NAME_ID_TYPOGRAPHIC_SUBFAMILY;
2371 else
2372 {
2373 found = sfnt->get_name_id( face,
2374 TT_NAME_ID_FONT_SUBFAMILY,
2375 &dummy1,
2376 &dummy2 );
2377 if ( found )
2378 strid = TT_NAME_ID_FONT_SUBFAMILY;
2379 }
2380
2381 if ( found )
2382 {
2383 found = sfnt->get_name_id( face,
2384 TT_NAME_ID_PS_NAME,
2385 &dummy1,
2386 &dummy2 );
2387 if ( found )
2388 {
2389 FT_TRACE5(( "TT_Get_MM_Var:"
2390 " Adding default instance to named instances\n" ));
2391
2392 ns = &mmvar->namedstyle[fvar_head.instanceCount];
2393
2394 ns->strid = strid;
2395 ns->psid = TT_NAME_ID_PS_NAME;
2396
2397 a = mmvar->axis;
2398 c = ns->coords;
2399 for ( j = 0; j < num_axes; j++, a++, c++ )
2400 *c = a->def;
2401 }
2402 }
2403 }
2404
2405 ft_var_load_mvar( face );
2406 }
2407
2408 /* fill the output array if requested */
2409
2410 if ( master )
2411 {
2412 FT_UInt n;
2413
2414
2415 if ( FT_ALLOC( mmvar, face->blend->mmvar_len ) )
2416 goto Exit;
2417 FT_MEM_COPY( mmvar, face->blend->mmvar, face->blend->mmvar_len );
2418
2419 axis_flags =
2420 (FT_UShort*)( (char*)mmvar + mmvar_size );
2421 mmvar->axis =
2422 (FT_Var_Axis*)( (char*)axis_flags + axis_flags_size );
2423 mmvar->namedstyle =
2424 (FT_Var_Named_Style*)( (char*)mmvar->axis+ axis_size );
2425
2426 next_coords = (FT_Fixed*)( (char*)mmvar->namedstyle +
2427 namedstyle_size );
2428 for ( n = 0; n < mmvar->num_namedstyles; n++ )
2429 {
2430 mmvar->namedstyle[n].coords = next_coords;
2431 next_coords += num_axes;
2432 }
2433
2434 a = mmvar->axis;
2435 next_name = (FT_String*)( (char*)mmvar->namedstyle +
2436 namedstyle_size + next_coords_size );
2437 for ( n = 0; n < num_axes; n++ )
2438 {
2439 a->name = next_name;
2440
2441 /* standard PostScript names for some standard apple tags */
2442 if ( a->tag == TTAG_wght )
2443 a->name = (char*)"Weight";
2444 else if ( a->tag == TTAG_wdth )
2445 a->name = (char*)"Width";
2446 else if ( a->tag == TTAG_opsz )
2447 a->name = (char*)"OpticalSize";
2448 else if ( a->tag == TTAG_slnt )
2449 a->name = (char*)"Slant";
2450
2451 next_name += 5;
2452 a++;
2453 }
2454
2455 *master = mmvar;
2456 }
2457
2458 Exit:
2459 return error;
2460 }
2461
2462
2463 static FT_Error
2464 tt_set_mm_blend( TT_Face face,
2465 FT_UInt num_coords,
2466 FT_Fixed* coords,
2467 FT_Bool set_design_coords )
2468 {
2469 FT_Error error = FT_Err_Ok;
2470 GX_Blend blend;
2471 FT_MM_Var* mmvar;
2472 FT_UInt i;
2473
2474 FT_Bool all_design_coords = FALSE;
2475
2476 FT_Memory memory = face->root.memory;
2477
2478 enum
2479 {
2480 mcvt_retain,
2481 mcvt_modify,
2482 mcvt_load
2483
2484 } manageCvt;
2485
2486
2487 face->doblend = FALSE;
2488
2489 if ( !face->blend )
2490 {
2491 if ( FT_SET_ERROR( TT_Get_MM_Var( face, NULL ) ) )
2492 goto Exit;
2493 }
2494
2495 blend = face->blend;
2496 mmvar = blend->mmvar;
2497
2498 if ( num_coords > mmvar->num_axis )
2499 {
2500 FT_TRACE2(( "TT_Set_MM_Blend:"
2501 " only using first %d of %d coordinates\n",
2502 mmvar->num_axis, num_coords ));
2503 num_coords = mmvar->num_axis;
2504 }
2505
2506 FT_TRACE5(( "TT_Set_MM_Blend:\n"
2507 " normalized design coordinates:\n" ));
2508
2509 for ( i = 0; i < num_coords; i++ )
2510 {
2511 FT_TRACE5(( " %.5f\n", coords[i] / 65536.0 ));
2512 if ( coords[i] < -0x00010000L || coords[i] > 0x00010000L )
2513 {
2514 FT_TRACE1(( "TT_Set_MM_Blend: normalized design coordinate %.5f\n"
2515 " is out of range [-1;1]\n",
2516 coords[i] / 65536.0 ));
2517 error = FT_THROW( Invalid_Argument );
2518 goto Exit;
2519 }
2520 }
2521
2522 FT_TRACE5(( "\n" ));
2523
2524 if ( !face->is_cff2 && !blend->glyphoffsets )
2525 if ( FT_SET_ERROR( ft_var_load_gvar( face ) ) )
2526 goto Exit;
2527
2528 if ( !blend->coords )
2529 {
2530 if ( FT_NEW_ARRAY( blend->coords, mmvar->num_axis ) )
2531 goto Exit;
2532
2533 /* the first time we have to compute all design coordinates */
2534 all_design_coords = TRUE;
2535 }
2536
2537 if ( !blend->normalizedcoords )
2538 {
2539 if ( FT_NEW_ARRAY( blend->normalizedcoords, mmvar->num_axis ) )
2540 goto Exit;
2541
2542 manageCvt = mcvt_modify;
2543
2544 /* If we have not set the blend coordinates before this, then the */
2545 /* cvt table will still be what we read from the `cvt ' table and */
2546 /* we don't need to reload it. We may need to change it though... */
2547 }
2548 else
2549 {
2550 FT_Bool have_diff = 0;
2551 FT_UInt j;
2552 FT_Fixed* c;
2553 FT_Fixed* n;
2554
2555
2556 manageCvt = mcvt_retain;
2557
2558 for ( i = 0; i < num_coords; i++ )
2559 {
2560 if ( blend->normalizedcoords[i] != coords[i] )
2561 {
2562 manageCvt = mcvt_load;
2563 have_diff = 1;
2564 break;
2565 }
2566 }
2567
2568 if ( FT_IS_NAMED_INSTANCE( FT_FACE( face ) ) )
2569 {
2570 FT_UInt instance_index = (FT_UInt)face->root.face_index >> 16;
2571
2572
2573 c = blend->normalizedcoords + i;
2574 n = blend->normalized_stylecoords +
2575 ( instance_index - 1 ) * mmvar->num_axis +
2576 i;
2577
2578 for ( j = i; j < mmvar->num_axis; j++, n++, c++ )
2579 if ( *c != *n )
2580 have_diff = 1;
2581 }
2582 else
2583 {
2584 c = blend->normalizedcoords + i;
2585 for ( j = i; j < mmvar->num_axis; j++, c++ )
2586 if ( *c != 0 )
2587 have_diff = 1;
2588 }
2589
2590 /* return value -1 indicates `no change' */
2591 if ( !have_diff )
2592 {
2593 face->doblend = TRUE;
2594
2595 return -1;
2596 }
2597
2598 for ( ; i < mmvar->num_axis; i++ )
2599 {
2600 if ( blend->normalizedcoords[i] != 0 )
2601 {
2602 manageCvt = mcvt_load;
2603 break;
2604 }
2605 }
2606
2607 /* If we don't change the blend coords then we don't need to do */
2608 /* anything to the cvt table. It will be correct. Otherwise we */
2609 /* no longer have the original cvt (it was modified when we set */
2610 /* the blend last time), so we must reload and then modify it. */
2611 }
2612
2613 blend->num_axis = mmvar->num_axis;
2614 FT_MEM_COPY( blend->normalizedcoords,
2615 coords,
2616 num_coords * sizeof ( FT_Fixed ) );
2617
2618 if ( set_design_coords )
2619 ft_var_to_design( face,
2620 all_design_coords ? blend->num_axis : num_coords,
2621 blend->normalizedcoords,
2622 blend->coords );
2623
2624 face->doblend = TRUE;
2625
2626 if ( face->cvt )
2627 {
2628 switch ( manageCvt )
2629 {
2630 case mcvt_load:
2631 /* The cvt table has been loaded already; every time we change the */
2632 /* blend we may need to reload and remodify the cvt table. */
2633 FT_FREE( face->cvt );
2634 face->cvt = NULL;
2635
2636 error = tt_face_load_cvt( face, face->root.stream );
2637 break;
2638
2639 case mcvt_modify:
2640 /* The original cvt table is in memory. All we need to do is */
2641 /* apply the `cvar' table (if any). */
2642 error = tt_face_vary_cvt( face, face->root.stream );
2643 break;
2644
2645 case mcvt_retain:
2646 /* The cvt table is correct for this set of coordinates. */
2647 break;
2648 }
2649 }
2650
2651 /* enforce recomputation of the PostScript name; */
2652 FT_FREE( face->postscript_name );
2653 face->postscript_name = NULL;
2654
2655 Exit:
2656 return error;
2657 }
2658
2659
2660 /**************************************************************************
2661 *
2662 * @Function:
2663 * TT_Set_MM_Blend
2664 *
2665 * @Description:
2666 * Set the blend (normalized) coordinates for this instance of the
2667 * font. Check that the `gvar' table is reasonable and does some
2668 * initial preparation.
2669 *
2670 * @InOut:
2671 * face ::
2672 * The font.
2673 * Initialize the blend structure with `gvar' data.
2674 *
2675 * @Input:
2676 * num_coords ::
2677 * The number of available coordinates. If it is
2678 * larger than the number of axes, ignore the excess
2679 * values. If it is smaller than the number of axes,
2680 * use the default value (0) for the remaining axes.
2681 *
2682 * coords ::
2683 * An array of `num_coords', each between [-1,1].
2684 *
2685 * @Return:
2686 * FreeType error code. 0 means success.
2687 */
2688 FT_LOCAL_DEF( FT_Error )
2689 TT_Set_MM_Blend( TT_Face face,
2690 FT_UInt num_coords,
2691 FT_Fixed* coords )
2692 {
2693 FT_Error error;
2694
2695
2696 error = tt_set_mm_blend( face, num_coords, coords, 1 );
2697 if ( error )
2698 return error;
2699
2700 if ( num_coords )
2701 face->root.face_flags |= FT_FACE_FLAG_VARIATION;
2702 else
2703 face->root.face_flags &= ~FT_FACE_FLAG_VARIATION;
2704
2705 return FT_Err_Ok;
2706 }
2707
2708
2709 /**************************************************************************
2710 *
2711 * @Function:
2712 * TT_Get_MM_Blend
2713 *
2714 * @Description:
2715 * Get the blend (normalized) coordinates for this instance of the
2716 * font.
2717 *
2718 * @InOut:
2719 * face ::
2720 * The font.
2721 * Initialize the blend structure with `gvar' data.
2722 *
2723 * @Input:
2724 * num_coords ::
2725 * The number of available coordinates. If it is
2726 * larger than the number of axes, set the excess
2727 * values to 0.
2728 *
2729 * coords ::
2730 * An array of `num_coords', each between [-1,1].
2731 *
2732 * @Return:
2733 * FreeType error code. 0 means success.
2734 */
2735 FT_LOCAL_DEF( FT_Error )
2736 TT_Get_MM_Blend( TT_Face face,
2737 FT_UInt num_coords,
2738 FT_Fixed* coords )
2739 {
2740 FT_Error error = FT_Err_Ok;
2741 GX_Blend blend;
2742 FT_UInt i, nc;
2743
2744
2745 if ( !face->blend )
2746 {
2747 if ( FT_SET_ERROR( TT_Get_MM_Var( face, NULL ) ) )
2748 return error;
2749 }
2750
2751 blend = face->blend;
2752
2753 if ( !blend->coords )
2754 {
2755 /* select default instance coordinates */
2756 /* if no instance is selected yet */
2757 if ( FT_SET_ERROR( tt_set_mm_blend( face, 0, NULL, 1 ) ) )
2758 return error;
2759 }
2760
2761 nc = num_coords;
2762 if ( num_coords > blend->num_axis )
2763 {
2764 FT_TRACE2(( "TT_Get_MM_Blend:"
2765 " only using first %d of %d coordinates\n",
2766 blend->num_axis, num_coords ));
2767 nc = blend->num_axis;
2768 }
2769
2770 if ( face->doblend )
2771 {
2772 for ( i = 0; i < nc; i++ )
2773 coords[i] = blend->normalizedcoords[i];
2774 }
2775 else
2776 {
2777 for ( i = 0; i < nc; i++ )
2778 coords[i] = 0;
2779 }
2780
2781 for ( ; i < num_coords; i++ )
2782 coords[i] = 0;
2783
2784 return FT_Err_Ok;
2785 }
2786
2787
2788 /**************************************************************************
2789 *
2790 * @Function:
2791 * TT_Set_Var_Design
2792 *
2793 * @Description:
2794 * Set the coordinates for the instance, measured in the user
2795 * coordinate system. Parse the `avar' table (if present) to convert
2796 * from user to normalized coordinates.
2797 *
2798 * @InOut:
2799 * face ::
2800 * The font face.
2801 * Initialize the blend struct with `gvar' data.
2802 *
2803 * @Input:
2804 * num_coords ::
2805 * The number of available coordinates. If it is
2806 * larger than the number of axes, ignore the excess
2807 * values. If it is smaller than the number of axes,
2808 * use the default values for the remaining axes.
2809 *
2810 * coords ::
2811 * A coordinate array with `num_coords' elements.
2812 *
2813 * @Return:
2814 * FreeType error code. 0 means success.
2815 */
2816 FT_LOCAL_DEF( FT_Error )
2817 TT_Set_Var_Design( TT_Face face,
2818 FT_UInt num_coords,
2819 FT_Fixed* coords )
2820 {
2821 FT_Error error = FT_Err_Ok;
2822 GX_Blend blend;
2823 FT_MM_Var* mmvar;
2824 FT_UInt i;
2825 FT_Memory memory = face->root.memory;
2826
2827 FT_Fixed* c;
2828 FT_Fixed* n;
2829 FT_Fixed* normalized = NULL;
2830
2831 FT_Bool have_diff = 0;
2832
2833
2834 if ( !face->blend )
2835 {
2836 if ( FT_SET_ERROR( TT_Get_MM_Var( face, NULL ) ) )
2837 goto Exit;
2838 }
2839
2840 blend = face->blend;
2841 mmvar = blend->mmvar;
2842
2843 if ( num_coords > mmvar->num_axis )
2844 {
2845 FT_TRACE2(( "TT_Set_Var_Design:"
2846 " only using first %d of %d coordinates\n",
2847 mmvar->num_axis, num_coords ));
2848 num_coords = mmvar->num_axis;
2849 }
2850
2851 if ( !blend->coords )
2852 {
2853 if ( FT_NEW_ARRAY( blend->coords, mmvar->num_axis ) )
2854 goto Exit;
2855 }
2856
2857 c = blend->coords;
2858 n = coords;
2859 for ( i = 0; i < num_coords; i++, n++, c++ )
2860 {
2861 if ( *c != *n )
2862 {
2863 *c = *n;
2864 have_diff = 1;
2865 }
2866 }
2867
2868 if ( FT_IS_NAMED_INSTANCE( FT_FACE( face ) ) )
2869 {
2870 FT_UInt instance_index;
2871 FT_Var_Named_Style* named_style;
2872
2873
2874 instance_index = (FT_UInt)face->root.face_index >> 16;
2875 named_style = mmvar->namedstyle + instance_index - 1;
2876
2877 n = named_style->coords + num_coords;
2878 for ( ; i < mmvar->num_axis; i++, n++, c++ )
2879 {
2880 if ( *c != *n )
2881 {
2882 *c = *n;
2883 have_diff = 1;
2884 }
2885 }
2886 }
2887 else
2888 {
2889 FT_Var_Axis* a;
2890
2891
2892 a = mmvar->axis + num_coords;
2893 for ( ; i < mmvar->num_axis; i++, a++, c++ )
2894 {
2895 if ( *c != a->def )
2896 {
2897 *c = a->def;
2898 have_diff = 1;
2899 }
2900 }
2901 }
2902
2903 /* return value -1 indicates `no change'; */
2904 /* we can exit early if `normalizedcoords' is already computed */
2905 if ( blend->normalizedcoords && !have_diff )
2906 return -1;
2907
2908 if ( FT_NEW_ARRAY( normalized, mmvar->num_axis ) )
2909 goto Exit;
2910
2911 if ( !face->blend->avar_loaded )
2912 ft_var_load_avar( face );
2913
2914 FT_TRACE5(( "TT_Set_Var_Design:\n"
2915 " normalized design coordinates:\n" ));
2916 ft_var_to_normalized( face, num_coords, blend->coords, normalized );
2917
2918 error = tt_set_mm_blend( face, mmvar->num_axis, normalized, 0 );
2919 if ( error )
2920 goto Exit;
2921
2922 if ( num_coords )
2923 face->root.face_flags |= FT_FACE_FLAG_VARIATION;
2924 else
2925 face->root.face_flags &= ~FT_FACE_FLAG_VARIATION;
2926
2927 Exit:
2928 FT_FREE( normalized );
2929 return error;
2930 }
2931
2932
2933 /**************************************************************************
2934 *
2935 * @Function:
2936 * TT_Get_Var_Design
2937 *
2938 * @Description:
2939 * Get the design coordinates of the currently selected interpolated
2940 * font.
2941 *
2942 * @Input:
2943 * face ::
2944 * A handle to the source face.
2945 *
2946 * num_coords ::
2947 * The number of design coordinates to retrieve. If it
2948 * is larger than the number of axes, set the excess
2949 * values to~0.
2950 *
2951 * @Output:
2952 * coords ::
2953 * The design coordinates array.
2954 *
2955 * @Return:
2956 * FreeType error code. 0~means success.
2957 */
2958 FT_LOCAL_DEF( FT_Error )
2959 TT_Get_Var_Design( TT_Face face,
2960 FT_UInt num_coords,
2961 FT_Fixed* coords )
2962 {
2963 FT_Error error = FT_Err_Ok;
2964 GX_Blend blend;
2965 FT_UInt i, nc;
2966
2967
2968 if ( !face->blend )
2969 {
2970 if ( FT_SET_ERROR( TT_Get_MM_Var( face, NULL ) ) )
2971 return error;
2972 }
2973
2974 blend = face->blend;
2975
2976 if ( !blend->coords )
2977 {
2978 /* select default instance coordinates */
2979 /* if no instance is selected yet */
2980 if ( FT_SET_ERROR( tt_set_mm_blend( face, 0, NULL, 1 ) ) )
2981 return error;
2982 }
2983
2984 nc = num_coords;
2985 if ( num_coords > blend->num_axis )
2986 {
2987 FT_TRACE2(( "TT_Get_Var_Design:"
2988 " only using first %d of %d coordinates\n",
2989 blend->num_axis, num_coords ));
2990 nc = blend->num_axis;
2991 }
2992
2993 if ( face->doblend )
2994 {
2995 for ( i = 0; i < nc; i++ )
2996 coords[i] = blend->coords[i];
2997 }
2998 else
2999 {
3000 for ( i = 0; i < nc; i++ )
3001 coords[i] = 0;
3002 }
3003
3004 for ( ; i < num_coords; i++ )
3005 coords[i] = 0;
3006
3007 return FT_Err_Ok;
3008 }
3009
3010
3011 /**************************************************************************
3012 *
3013 * @Function:
3014 * TT_Set_Named_Instance
3015 *
3016 * @Description:
3017 * Set the given named instance, also resetting any further
3018 * variation.
3019 *
3020 * @Input:
3021 * face ::
3022 * A handle to the source face.
3023 *
3024 * instance_index ::
3025 * The instance index, starting with value 1.
3026 * Value 0 indicates to not use an instance.
3027 *
3028 * @Return:
3029 * FreeType error code. 0~means success.
3030 */
3031 FT_LOCAL_DEF( FT_Error )
3032 TT_Set_Named_Instance( TT_Face face,
3033 FT_UInt instance_index )
3034 {
3035 FT_Error error = FT_ERR( Invalid_Argument );
3036 GX_Blend blend;
3037 FT_MM_Var* mmvar;
3038
3039 FT_UInt num_instances;
3040
3041
3042 if ( !face->blend )
3043 {
3044 if ( FT_SET_ERROR( TT_Get_MM_Var( face, NULL ) ) )
3045 goto Exit;
3046 }
3047
3048 blend = face->blend;
3049 mmvar = blend->mmvar;
3050
3051 num_instances = (FT_UInt)face->root.style_flags >> 16;
3052
3053 /* `instance_index' starts with value 1, thus `>' */
3054 if ( instance_index > num_instances )
3055 goto Exit;
3056
3057 if ( instance_index > 0 && mmvar->namedstyle )
3058 {
3059 FT_Memory memory = face->root.memory;
3060 SFNT_Service sfnt = (SFNT_Service)face->sfnt;
3061
3062 FT_Var_Named_Style* named_style;
3063 FT_String* style_name;
3064
3065
3066 named_style = mmvar->namedstyle + instance_index - 1;
3067
3068 error = sfnt->get_name( face,
3069 (FT_UShort)named_style->strid,
3070 &style_name );
3071 if ( error )
3072 goto Exit;
3073
3074 /* set (or replace) style name */
3075 FT_FREE( face->root.style_name );
3076 face->root.style_name = style_name;
3077
3078 /* finally, select the named instance */
3079 error = TT_Set_Var_Design( face,
3080 mmvar->num_axis,
3081 named_style->coords );
3082 if ( error )
3083 goto Exit;
3084 }
3085 else
3086 error = TT_Set_Var_Design( face, 0, NULL );
3087
3088 face->root.face_index = ( instance_index << 16 ) |
3089 ( face->root.face_index & 0xFFFFL );
3090 face->root.face_flags &= ~FT_FACE_FLAG_VARIATION;
3091
3092 Exit:
3093 return error;
3094 }
3095
3096
3097 /*************************************************************************/
3098 /*************************************************************************/
3099 /***** *****/
3100 /***** GX VAR PARSING ROUTINES *****/
3101 /***** *****/
3102 /*************************************************************************/
3103 /*************************************************************************/
3104
3105
3106 /**************************************************************************
3107 *
3108 * @Function:
3109 * tt_face_vary_cvt
3110 *
3111 * @Description:
3112 * Modify the loaded cvt table according to the `cvar' table and the
3113 * font's blend.
3114 *
3115 * @InOut:
3116 * face ::
3117 * A handle to the target face object.
3118 *
3119 * @Input:
3120 * stream ::
3121 * A handle to the input stream.
3122 *
3123 * @Return:
3124 * FreeType error code. 0 means success.
3125 *
3126 * Most errors are ignored. It is perfectly valid not to have a
3127 * `cvar' table even if there is a `gvar' and `fvar' table.
3128 */
3129 FT_LOCAL_DEF( FT_Error )
3130 tt_face_vary_cvt( TT_Face face,
3131 FT_Stream stream )
3132 {
3133 FT_Error error;
3134 FT_Memory memory = stream->memory;
3135
3136 FT_ULong table_start;
3137 FT_ULong table_len;
3138
3139 FT_UInt tupleCount;
3140 FT_ULong offsetToData;
3141
3142 FT_ULong here;
3143 FT_UInt i, j;
3144
3145 FT_Fixed* tuple_coords = NULL;
3146 FT_Fixed* im_start_coords = NULL;
3147 FT_Fixed* im_end_coords = NULL;
3148
3149 GX_Blend blend = face->blend;
3150
3151 FT_UInt point_count;
3152 FT_UInt spoint_count = 0;
3153
3154 FT_UShort* sharedpoints = NULL;
3155 FT_UShort* localpoints = NULL;
3156 FT_UShort* points;
3157
3158 FT_Fixed* deltas = NULL;
3159 FT_Fixed* cvt_deltas = NULL;
3160
3161
3162 FT_TRACE2(( "CVAR " ));
3163
3164 if ( !blend )
3165 {
3166 FT_TRACE2(( "\n"
3167 "tt_face_vary_cvt: no blend specified\n" ));
3168 error = FT_Err_Ok;
3169 goto Exit;
3170 }
3171
3172 if ( !face->cvt )
3173 {
3174 FT_TRACE2(( "\n"
3175 "tt_face_vary_cvt: no `cvt ' table\n" ));
3176 error = FT_Err_Ok;
3177 goto Exit;
3178 }
3179
3180 error = face->goto_table( face, TTAG_cvar, stream, &table_len );
3181 if ( error )
3182 {
3183 FT_TRACE2(( "is missing\n" ));
3184
3185 error = FT_Err_Ok;
3186 goto Exit;
3187 }
3188
3189 if ( FT_FRAME_ENTER( table_len ) )
3190 {
3191 error = FT_Err_Ok;
3192 goto Exit;
3193 }
3194
3195 table_start = FT_Stream_FTell( stream );
3196 if ( FT_GET_LONG() != 0x00010000L )
3197 {
3198 FT_TRACE2(( "bad table version\n" ));
3199
3200 error = FT_Err_Ok;
3201 goto FExit;
3202 }
3203
3204 FT_TRACE2(( "loaded\n" ));
3205
3206 if ( FT_NEW_ARRAY( tuple_coords, blend->num_axis ) ||
3207 FT_NEW_ARRAY( im_start_coords, blend->num_axis ) ||
3208 FT_NEW_ARRAY( im_end_coords, blend->num_axis ) )
3209 goto FExit;
3210
3211 tupleCount = FT_GET_USHORT();
3212 offsetToData = FT_GET_USHORT();
3213
3214 /* rough sanity test */
3215 if ( offsetToData + ( tupleCount & GX_TC_TUPLE_COUNT_MASK ) * 4 >
3216 table_len )
3217 {
3218 FT_TRACE2(( "tt_face_vary_cvt:"
3219 " invalid CVT variation array header\n" ));
3220
3221 error = FT_THROW( Invalid_Table );
3222 goto FExit;
3223 }
3224
3225 offsetToData += table_start;
3226
3227 if ( tupleCount & GX_TC_TUPLES_SHARE_POINT_NUMBERS )
3228 {
3229 here = FT_Stream_FTell( stream );
3230
3231 FT_Stream_SeekSet( stream, offsetToData );
3232
3233 sharedpoints = ft_var_readpackedpoints( stream,
3234 table_len,
3235 &spoint_count );
3236 offsetToData = FT_Stream_FTell( stream );
3237
3238 FT_Stream_SeekSet( stream, here );
3239 }
3240
3241 FT_TRACE5(( "cvar: there %s %d tuple%s:\n",
3242 ( tupleCount & GX_TC_TUPLE_COUNT_MASK ) == 1 ? "is" : "are",
3243 tupleCount & GX_TC_TUPLE_COUNT_MASK,
3244 ( tupleCount & GX_TC_TUPLE_COUNT_MASK ) == 1 ? "" : "s" ));
3245
3246 if ( FT_NEW_ARRAY( cvt_deltas, face->cvt_size ) )
3247 goto FExit;
3248
3249 for ( i = 0; i < ( tupleCount & GX_TC_TUPLE_COUNT_MASK ); i++ )
3250 {
3251 FT_UInt tupleDataSize;
3252 FT_UInt tupleIndex;
3253 FT_Fixed apply;
3254
3255
3256 FT_TRACE6(( " tuple %d:\n", i ));
3257
3258 tupleDataSize = FT_GET_USHORT();
3259 tupleIndex = FT_GET_USHORT();
3260
3261 if ( tupleIndex & GX_TI_EMBEDDED_TUPLE_COORD )
3262 {
3263 for ( j = 0; j < blend->num_axis; j++ )
3264 tuple_coords[j] = FT_GET_SHORT() * 4; /* convert from */
3265 /* short frac to fixed */
3266 }
3267 else if ( ( tupleIndex & GX_TI_TUPLE_INDEX_MASK ) >= blend->tuplecount )
3268 {
3269 FT_TRACE2(( "tt_face_vary_cvt:"
3270 " invalid tuple index\n" ));
3271
3272 error = FT_THROW( Invalid_Table );
3273 goto FExit;
3274 }
3275 else
3276 {
3277 if ( !blend->tuplecoords )
3278 {
3279 FT_TRACE2(( "tt_face_vary_cvt:"
3280 " no valid tuple coordinates available\n" ));
3281
3282 error = FT_THROW( Invalid_Table );
3283 goto FExit;
3284 }
3285
3286 FT_MEM_COPY(
3287 tuple_coords,
3288 blend->tuplecoords +
3289 ( tupleIndex & GX_TI_TUPLE_INDEX_MASK ) * blend->num_axis,
3290 blend->num_axis * sizeof ( FT_Fixed ) );
3291 }
3292
3293 if ( tupleIndex & GX_TI_INTERMEDIATE_TUPLE )
3294 {
3295 for ( j = 0; j < blend->num_axis; j++ )
3296 im_start_coords[j] = FT_GET_SHORT() * 4;
3297 for ( j = 0; j < blend->num_axis; j++ )
3298 im_end_coords[j] = FT_GET_SHORT() * 4;
3299 }
3300
3301 apply = ft_var_apply_tuple( blend,
3302 (FT_UShort)tupleIndex,
3303 tuple_coords,
3304 im_start_coords,
3305 im_end_coords );
3306
3307 if ( apply == 0 ) /* tuple isn't active for our blend */
3308 {
3309 offsetToData += tupleDataSize;
3310 continue;
3311 }
3312
3313 here = FT_Stream_FTell( stream );
3314
3315 FT_Stream_SeekSet( stream, offsetToData );
3316
3317 if ( tupleIndex & GX_TI_PRIVATE_POINT_NUMBERS )
3318 {
3319 localpoints = ft_var_readpackedpoints( stream,
3320 table_len,
3321 &point_count );
3322 points = localpoints;
3323 }
3324 else
3325 {
3326 points = sharedpoints;
3327 point_count = spoint_count;
3328 }
3329
3330 deltas = ft_var_readpackeddeltas( stream,
3331 table_len,
3332 point_count == 0 ? face->cvt_size
3333 : point_count );
3334
3335 if ( !points ||
3336 !deltas ||
3337 ( localpoints == ALL_POINTS && point_count != face->cvt_size ) )
3338 ; /* failure, ignore it */
3339
3340 else if ( localpoints == ALL_POINTS )
3341 {
3342 #ifdef FT_DEBUG_LEVEL_TRACE
3343 int count = 0;
3344 #endif
3345
3346
3347 FT_TRACE7(( " CVT deltas:\n" ));
3348
3349 /* this means that there are deltas for every entry in cvt */
3350 for ( j = 0; j < face->cvt_size; j++ )
3351 {
3352 FT_Fixed old_cvt_delta;
3353
3354
3355 old_cvt_delta = cvt_deltas[j];
3356 cvt_deltas[j] = old_cvt_delta + FT_MulFix( deltas[j], apply );
3357
3358 #ifdef FT_DEBUG_LEVEL_TRACE
3359 if ( old_cvt_delta != cvt_deltas[j] )
3360 {
3361 FT_TRACE7(( " %d: %f -> %f\n",
3362 j,
3363 ( FT_intToFixed( face->cvt[j] ) +
3364 old_cvt_delta ) / 65536.0,
3365 ( FT_intToFixed( face->cvt[j] ) +
3366 cvt_deltas[j] ) / 65536.0 ));
3367 count++;
3368 }
3369 #endif
3370 }
3371
3372 #ifdef FT_DEBUG_LEVEL_TRACE
3373 if ( !count )
3374 FT_TRACE7(( " none\n" ));
3375 #endif
3376 }
3377
3378 else
3379 {
3380 #ifdef FT_DEBUG_LEVEL_TRACE
3381 int count = 0;
3382 #endif
3383
3384
3385 FT_TRACE7(( " CVT deltas:\n" ));
3386
3387 for ( j = 0; j < point_count; j++ )
3388 {
3389 int pindex;
3390 FT_Fixed old_cvt_delta;
3391
3392
3393 pindex = points[j];
3394 if ( (FT_ULong)pindex >= face->cvt_size )
3395 continue;
3396
3397 old_cvt_delta = cvt_deltas[pindex];
3398 cvt_deltas[pindex] = old_cvt_delta + FT_MulFix( deltas[j], apply );
3399
3400 #ifdef FT_DEBUG_LEVEL_TRACE
3401 if ( old_cvt_delta != cvt_deltas[pindex] )
3402 {
3403 FT_TRACE7(( " %d: %f -> %f\n",
3404 pindex,
3405 ( FT_intToFixed( face->cvt[pindex] ) +
3406 old_cvt_delta ) / 65536.0,
3407 ( FT_intToFixed( face->cvt[pindex] ) +
3408 cvt_deltas[pindex] ) / 65536.0 ));
3409 count++;
3410 }
3411 #endif
3412 }
3413
3414 #ifdef FT_DEBUG_LEVEL_TRACE
3415 if ( !count )
3416 FT_TRACE7(( " none\n" ));
3417 #endif
3418 }
3419
3420 if ( localpoints != ALL_POINTS )
3421 FT_FREE( localpoints );
3422 FT_FREE( deltas );
3423
3424 offsetToData += tupleDataSize;
3425
3426 FT_Stream_SeekSet( stream, here );
3427 }
3428
3429 FT_TRACE5(( "\n" ));
3430
3431 for ( i = 0; i < face->cvt_size; i++ )
3432 face->cvt[i] += FT_fixedToInt( cvt_deltas[i] );
3433
3434 FExit:
3435 FT_FRAME_EXIT();
3436
3437 Exit:
3438 if ( sharedpoints != ALL_POINTS )
3439 FT_FREE( sharedpoints );
3440 FT_FREE( tuple_coords );
3441 FT_FREE( im_start_coords );
3442 FT_FREE( im_end_coords );
3443 FT_FREE( cvt_deltas );
3444
3445 return error;
3446 }
3447
3448
3449 /* Shift the original coordinates of all points between indices `p1' */
3450 /* and `p2', using the same difference as given by index `ref'. */
3451
3452 /* modeled after `af_iup_shift' */
3453
3454 static void
3455 tt_delta_shift( int p1,
3456 int p2,
3457 int ref,
3458 FT_Vector* in_points,
3459 FT_Vector* out_points )
3460 {
3461 int p;
3462 FT_Vector delta;
3463
3464
3465 delta.x = out_points[ref].x - in_points[ref].x;
3466 delta.y = out_points[ref].y - in_points[ref].y;
3467
3468 if ( delta.x == 0 && delta.y == 0 )
3469 return;
3470
3471 for ( p = p1; p < ref; p++ )
3472 {
3473 out_points[p].x += delta.x;
3474 out_points[p].y += delta.y;
3475 }
3476
3477 for ( p = ref + 1; p <= p2; p++ )
3478 {
3479 out_points[p].x += delta.x;
3480 out_points[p].y += delta.y;
3481 }
3482 }
3483
3484
3485 /* Interpolate the original coordinates of all points with indices */
3486 /* between `p1' and `p2', using `ref1' and `ref2' as the reference */
3487 /* point indices. */
3488
3489 /* modeled after `af_iup_interp', `_iup_worker_interpolate', and */
3490 /* `Ins_IUP' with spec differences in handling ill-defined cases. */
3491 static void
3492 tt_delta_interpolate( int p1,
3493 int p2,
3494 int ref1,
3495 int ref2,
3496 FT_Vector* in_points,
3497 FT_Vector* out_points )
3498 {
3499 int p, i;
3500
3501 FT_Pos out, in1, in2, out1, out2, d1, d2;
3502
3503
3504 if ( p1 > p2 )
3505 return;
3506
3507 /* handle both horizontal and vertical coordinates */
3508 for ( i = 0; i <= 1; i++ )
3509 {
3510 /* shift array pointers so that we can access `foo.y' as `foo.x' */
3511 in_points = (FT_Vector*)( (FT_Pos*)in_points + i );
3512 out_points = (FT_Vector*)( (FT_Pos*)out_points + i );
3513
3514 if ( in_points[ref1].x > in_points[ref2].x )
3515 {
3516 p = ref1;
3517 ref1 = ref2;
3518 ref2 = p;
3519 }
3520
3521 in1 = in_points[ref1].x;
3522 in2 = in_points[ref2].x;
3523 out1 = out_points[ref1].x;
3524 out2 = out_points[ref2].x;
3525 d1 = out1 - in1;
3526 d2 = out2 - in2;
3527
3528 /* If the reference points have the same coordinate but different */
3529 /* delta, inferred delta is zero. Otherwise interpolate. */
3530 if ( in1 != in2 || out1 == out2 )
3531 {
3532 FT_Fixed scale = in1 != in2 ? FT_DivFix( out2 - out1, in2 - in1 )
3533 : 0;
3534
3535
3536 for ( p = p1; p <= p2; p++ )
3537 {
3538 out = in_points[p].x;
3539
3540 if ( out <= in1 )
3541 out += d1;
3542 else if ( out >= in2 )
3543 out += d2;
3544 else
3545 out = out1 + FT_MulFix( out - in1, scale );
3546
3547 out_points[p].x = out;
3548 }
3549 }
3550 }
3551 }
3552
3553
3554 /* Interpolate points without delta values, similar to */
3555 /* the `IUP' hinting instruction. */
3556
3557 /* modeled after `Ins_IUP */
3558
3559 static void
3560 tt_interpolate_deltas( FT_Outline* outline,
3561 FT_Vector* out_points,
3562 FT_Vector* in_points,
3563 FT_Bool* has_delta )
3564 {
3565 FT_Int first_point;
3566 FT_Int end_point;
3567
3568 FT_Int first_delta;
3569 FT_Int cur_delta;
3570
3571 FT_Int point;
3572 FT_Short contour;
3573
3574
3575 /* ignore empty outlines */
3576 if ( !outline->n_contours )
3577 return;
3578
3579 contour = 0;
3580 point = 0;
3581
3582 do
3583 {
3584 end_point = outline->contours[contour];
3585 first_point = point;
3586
3587 /* search first point that has a delta */
3588 while ( point <= end_point && !has_delta[point] )
3589 point++;
3590
3591 if ( point <= end_point )
3592 {
3593 first_delta = point;
3594 cur_delta = point;
3595
3596 point++;
3597
3598 while ( point <= end_point )
3599 {
3600 /* search next point that has a delta */
3601 /* and interpolate intermediate points */
3602 if ( has_delta[point] )
3603 {
3604 tt_delta_interpolate( cur_delta + 1,
3605 point - 1,
3606 cur_delta,
3607 point,
3608 in_points,
3609 out_points );
3610 cur_delta = point;
3611 }
3612
3613 point++;
3614 }
3615
3616 /* shift contour if we only have a single delta */
3617 if ( cur_delta == first_delta )
3618 tt_delta_shift( first_point,
3619 end_point,
3620 cur_delta,
3621 in_points,
3622 out_points );
3623 else
3624 {
3625 /* otherwise handle remaining points */
3626 /* at the end and beginning of the contour */
3627 tt_delta_interpolate( cur_delta + 1,
3628 end_point,
3629 cur_delta,
3630 first_delta,
3631 in_points,
3632 out_points );
3633
3634 if ( first_delta > 0 )
3635 tt_delta_interpolate( first_point,
3636 first_delta - 1,
3637 cur_delta,
3638 first_delta,
3639 in_points,
3640 out_points );
3641 }
3642 }
3643 contour++;
3644
3645 } while ( contour < outline->n_contours );
3646 }
3647
3648
3649 /**************************************************************************
3650 *
3651 * @Function:
3652 * TT_Vary_Apply_Glyph_Deltas
3653 *
3654 * @Description:
3655 * Apply the appropriate deltas to the current glyph.
3656 *
3657 * @Input:
3658 * face ::
3659 * A handle to the target face object.
3660 *
3661 * glyph_index ::
3662 * The index of the glyph being modified.
3663 *
3664 * n_points ::
3665 * The number of the points in the glyph, including
3666 * phantom points.
3667 *
3668 * @InOut:
3669 * outline ::
3670 * The outline to change.
3671 *
3672 * @Return:
3673 * FreeType error code. 0 means success.
3674 */
3675 FT_LOCAL_DEF( FT_Error )
3676 TT_Vary_Apply_Glyph_Deltas( TT_Face face,
3677 FT_UInt glyph_index,
3678 FT_Outline* outline,
3679 FT_UInt n_points )
3680 {
3681 FT_Error error;
3682 FT_Stream stream = face->root.stream;
3683 FT_Memory memory = stream->memory;
3684
3685 FT_Vector* points_org = NULL; /* coordinates in 16.16 format */
3686 FT_Vector* points_out = NULL; /* coordinates in 16.16 format */
3687 FT_Bool* has_delta = NULL;
3688
3689 FT_ULong glyph_start;
3690
3691 FT_UInt tupleCount;
3692 FT_ULong offsetToData;
3693 FT_ULong dataSize;
3694
3695 FT_ULong here;
3696 FT_UInt i, j;
3697
3698 FT_Fixed* tuple_coords = NULL;
3699 FT_Fixed* im_start_coords = NULL;
3700 FT_Fixed* im_end_coords = NULL;
3701
3702 GX_Blend blend = face->blend;
3703
3704 FT_UInt point_count;
3705 FT_UInt spoint_count = 0;
3706
3707 FT_UShort* sharedpoints = NULL;
3708 FT_UShort* localpoints = NULL;
3709 FT_UShort* points;
3710
3711 FT_Fixed* deltas_x = NULL;
3712 FT_Fixed* deltas_y = NULL;
3713 FT_Fixed* point_deltas_x = NULL;
3714 FT_Fixed* point_deltas_y = NULL;
3715
3716
3717 if ( !face->doblend || !blend )
3718 return FT_THROW( Invalid_Argument );
3719
3720 if ( glyph_index >= blend->gv_glyphcnt ||
3721 blend->glyphoffsets[glyph_index] ==
3722 blend->glyphoffsets[glyph_index + 1] )
3723 {
3724 FT_TRACE2(( "TT_Vary_Apply_Glyph_Deltas:"
3725 " no variation data for this glyph\n" ));
3726 return FT_Err_Ok;
3727 }
3728
3729 if ( FT_NEW_ARRAY( points_org, n_points ) ||
3730 FT_NEW_ARRAY( points_out, n_points ) ||
3731 FT_NEW_ARRAY( has_delta, n_points ) )
3732 goto Fail1;
3733
3734 dataSize = blend->glyphoffsets[glyph_index + 1] -
3735 blend->glyphoffsets[glyph_index];
3736
3737 if ( FT_STREAM_SEEK( blend->glyphoffsets[glyph_index] ) ||
3738 FT_FRAME_ENTER( dataSize ) )
3739 goto Fail1;
3740
3741 glyph_start = FT_Stream_FTell( stream );
3742
3743 /* each set of glyph variation data is formatted similarly to `cvar' */
3744
3745 if ( FT_NEW_ARRAY( tuple_coords, blend->num_axis ) ||
3746 FT_NEW_ARRAY( im_start_coords, blend->num_axis ) ||
3747 FT_NEW_ARRAY( im_end_coords, blend->num_axis ) )
3748 goto Fail2;
3749
3750 tupleCount = FT_GET_USHORT();
3751 offsetToData = FT_GET_USHORT();
3752
3753 /* rough sanity test */
3754 if ( offsetToData > dataSize ||
3755 ( tupleCount & GX_TC_TUPLE_COUNT_MASK ) * 4 > dataSize )
3756 {
3757 FT_TRACE2(( "TT_Vary_Apply_Glyph_Deltas:"
3758 " invalid glyph variation array header\n" ));
3759
3760 error = FT_THROW( Invalid_Table );
3761 goto Fail2;
3762 }
3763
3764 offsetToData += glyph_start;
3765
3766 if ( tupleCount & GX_TC_TUPLES_SHARE_POINT_NUMBERS )
3767 {
3768 here = FT_Stream_FTell( stream );
3769
3770 FT_Stream_SeekSet( stream, offsetToData );
3771
3772 sharedpoints = ft_var_readpackedpoints( stream,
3773 blend->gvar_size,
3774 &spoint_count );
3775 offsetToData = FT_Stream_FTell( stream );
3776
3777 FT_Stream_SeekSet( stream, here );
3778 }
3779
3780 FT_TRACE5(( "gvar: there %s %d tuple%s:\n",
3781 ( tupleCount & GX_TC_TUPLE_COUNT_MASK ) == 1 ? "is" : "are",
3782 tupleCount & GX_TC_TUPLE_COUNT_MASK,
3783 ( tupleCount & GX_TC_TUPLE_COUNT_MASK ) == 1 ? "" : "s" ));
3784
3785 if ( FT_NEW_ARRAY( point_deltas_x, n_points ) ||
3786 FT_NEW_ARRAY( point_deltas_y, n_points ) )
3787 goto Fail3;
3788
3789 for ( j = 0; j < n_points; j++ )
3790 {
3791 points_org[j].x = FT_intToFixed( outline->points[j].x );
3792 points_org[j].y = FT_intToFixed( outline->points[j].y );
3793 }
3794
3795 for ( i = 0; i < ( tupleCount & GX_TC_TUPLE_COUNT_MASK ); i++ )
3796 {
3797 FT_UInt tupleDataSize;
3798 FT_UInt tupleIndex;
3799 FT_Fixed apply;
3800
3801
3802 FT_TRACE6(( " tuple %d:\n", i ));
3803
3804 tupleDataSize = FT_GET_USHORT();
3805 tupleIndex = FT_GET_USHORT();
3806
3807 if ( tupleIndex & GX_TI_EMBEDDED_TUPLE_COORD )
3808 {
3809 for ( j = 0; j < blend->num_axis; j++ )
3810 tuple_coords[j] = FT_GET_SHORT() * 4; /* convert from */
3811 /* short frac to fixed */
3812 }
3813 else if ( ( tupleIndex & GX_TI_TUPLE_INDEX_MASK ) >= blend->tuplecount )
3814 {
3815 FT_TRACE2(( "TT_Vary_Apply_Glyph_Deltas:"
3816 " invalid tuple index\n" ));
3817
3818 error = FT_THROW( Invalid_Table );
3819 goto Fail3;
3820 }
3821 else
3822 FT_MEM_COPY(
3823 tuple_coords,
3824 blend->tuplecoords +
3825 ( tupleIndex & GX_TI_TUPLE_INDEX_MASK ) * blend->num_axis,
3826 blend->num_axis * sizeof ( FT_Fixed ) );
3827
3828 if ( tupleIndex & GX_TI_INTERMEDIATE_TUPLE )
3829 {
3830 for ( j = 0; j < blend->num_axis; j++ )
3831 im_start_coords[j] = FT_GET_SHORT() * 4;
3832 for ( j = 0; j < blend->num_axis; j++ )
3833 im_end_coords[j] = FT_GET_SHORT() * 4;
3834 }
3835
3836 apply = ft_var_apply_tuple( blend,
3837 (FT_UShort)tupleIndex,
3838 tuple_coords,
3839 im_start_coords,
3840 im_end_coords );
3841
3842 if ( apply == 0 ) /* tuple isn't active for our blend */
3843 {
3844 offsetToData += tupleDataSize;
3845 continue;
3846 }
3847
3848 here = FT_Stream_FTell( stream );
3849
3850 FT_Stream_SeekSet( stream, offsetToData );
3851
3852 if ( tupleIndex & GX_TI_PRIVATE_POINT_NUMBERS )
3853 {
3854 localpoints = ft_var_readpackedpoints( stream,
3855 blend->gvar_size,
3856 &point_count );
3857 points = localpoints;
3858 }
3859 else
3860 {
3861 points = sharedpoints;
3862 point_count = spoint_count;
3863 }
3864
3865 deltas_x = ft_var_readpackeddeltas( stream,
3866 blend->gvar_size,
3867 point_count == 0 ? n_points
3868 : point_count );
3869 deltas_y = ft_var_readpackeddeltas( stream,
3870 blend->gvar_size,
3871 point_count == 0 ? n_points
3872 : point_count );
3873
3874 if ( !points || !deltas_y || !deltas_x )
3875 ; /* failure, ignore it */
3876
3877 else if ( points == ALL_POINTS )
3878 {
3879 #ifdef FT_DEBUG_LEVEL_TRACE
3880 int count = 0;
3881 #endif
3882
3883
3884 FT_TRACE7(( " point deltas:\n" ));
3885
3886 /* this means that there are deltas for every point in the glyph */
3887 for ( j = 0; j < n_points; j++ )
3888 {
3889 FT_Fixed old_point_delta_x = point_deltas_x[j];
3890 FT_Fixed old_point_delta_y = point_deltas_y[j];
3891
3892 FT_Fixed point_delta_x = FT_MulFix( deltas_x[j], apply );
3893 FT_Fixed point_delta_y = FT_MulFix( deltas_y[j], apply );
3894
3895
3896 if ( j < n_points - 4 )
3897 {
3898 point_deltas_x[j] = old_point_delta_x + point_delta_x;
3899 point_deltas_y[j] = old_point_delta_y + point_delta_y;
3900 }
3901 else
3902 {
3903 /* To avoid double adjustment of advance width or height, */
3904 /* adjust phantom points only if there is no HVAR or VVAR */
3905 /* support, respectively. */
3906 if ( j == ( n_points - 4 ) &&
3907 !( face->variation_support &
3908 TT_FACE_FLAG_VAR_LSB ) )
3909 point_deltas_x[j] = old_point_delta_x + point_delta_x;
3910
3911 else if ( j == ( n_points - 3 ) &&
3912 !( face->variation_support &
3913 TT_FACE_FLAG_VAR_HADVANCE ) )
3914 point_deltas_x[j] = old_point_delta_x + point_delta_x;
3915
3916 else if ( j == ( n_points - 2 ) &&
3917 !( face->variation_support &
3918 TT_FACE_FLAG_VAR_TSB ) )
3919 point_deltas_y[j] = old_point_delta_y + point_delta_y;
3920
3921 else if ( j == ( n_points - 1 ) &&
3922 !( face->variation_support &
3923 TT_FACE_FLAG_VAR_VADVANCE ) )
3924 point_deltas_y[j] = old_point_delta_y + point_delta_y;
3925 }
3926
3927 #ifdef FT_DEBUG_LEVEL_TRACE
3928 if ( point_delta_x || point_delta_y )
3929 {
3930 FT_TRACE7(( " %d: (%f, %f) -> (%f, %f)\n",
3931 j,
3932 ( FT_intToFixed( outline->points[j].x ) +
3933 old_point_delta_x ) / 65536.0,
3934 ( FT_intToFixed( outline->points[j].y ) +
3935 old_point_delta_y ) / 65536.0,
3936 ( FT_intToFixed( outline->points[j].x ) +
3937 point_deltas_x[j] ) / 65536.0,
3938 ( FT_intToFixed( outline->points[j].y ) +
3939 point_deltas_y[j] ) / 65536.0 ));
3940 count++;
3941 }
3942 #endif
3943 }
3944
3945 #ifdef FT_DEBUG_LEVEL_TRACE
3946 if ( !count )
3947 FT_TRACE7(( " none\n" ));
3948 #endif
3949 }
3950
3951 else
3952 {
3953 #ifdef FT_DEBUG_LEVEL_TRACE
3954 int count = 0;
3955 #endif
3956
3957
3958 /* we have to interpolate the missing deltas similar to the */
3959 /* IUP bytecode instruction */
3960 for ( j = 0; j < n_points; j++ )
3961 {
3962 has_delta[j] = FALSE;
3963 points_out[j] = points_org[j];
3964 }
3965
3966 for ( j = 0; j < point_count; j++ )
3967 {
3968 FT_UShort idx = points[j];
3969
3970
3971 if ( idx >= n_points )
3972 continue;
3973
3974 has_delta[idx] = TRUE;
3975
3976 points_out[idx].x += FT_MulFix( deltas_x[j], apply );
3977 points_out[idx].y += FT_MulFix( deltas_y[j], apply );
3978 }
3979
3980 /* no need to handle phantom points here, */
3981 /* since solitary points can't be interpolated */
3982 tt_interpolate_deltas( outline,
3983 points_out,
3984 points_org,
3985 has_delta );
3986
3987 FT_TRACE7(( " point deltas:\n" ));
3988
3989 for ( j = 0; j < n_points; j++ )
3990 {
3991 FT_Fixed old_point_delta_x = point_deltas_x[j];
3992 FT_Fixed old_point_delta_y = point_deltas_y[j];
3993
3994 FT_Pos point_delta_x = points_out[j].x - points_org[j].x;
3995 FT_Pos point_delta_y = points_out[j].y - points_org[j].y;
3996
3997
3998 if ( j < n_points - 4 )
3999 {
4000 point_deltas_x[j] = old_point_delta_x + point_delta_x;
4001 point_deltas_y[j] = old_point_delta_y + point_delta_y;
4002 }
4003 else
4004 {
4005 /* To avoid double adjustment of advance width or height, */
4006 /* adjust phantom points only if there is no HVAR or VVAR */
4007 /* support, respectively. */
4008 if ( j == ( n_points - 4 ) &&
4009 !( face->variation_support &
4010 TT_FACE_FLAG_VAR_LSB ) )
4011 point_deltas_x[j] = old_point_delta_x + point_delta_x;
4012
4013 else if ( j == ( n_points - 3 ) &&
4014 !( face->variation_support &
4015 TT_FACE_FLAG_VAR_HADVANCE ) )
4016 point_deltas_x[j] = old_point_delta_x + point_delta_x;
4017
4018 else if ( j == ( n_points - 2 ) &&
4019 !( face->variation_support &
4020 TT_FACE_FLAG_VAR_TSB ) )
4021 point_deltas_y[j] = old_point_delta_y + point_delta_y;
4022
4023 else if ( j == ( n_points - 1 ) &&
4024 !( face->variation_support &
4025 TT_FACE_FLAG_VAR_VADVANCE ) )
4026 point_deltas_y[j] = old_point_delta_y + point_delta_y;
4027 }
4028
4029 #ifdef FT_DEBUG_LEVEL_TRACE
4030 if ( point_delta_x || point_delta_y )
4031 {
4032 FT_TRACE7(( " %d: (%f, %f) -> (%f, %f)\n",
4033 j,
4034 ( FT_intToFixed( outline->points[j].x ) +
4035 old_point_delta_x ) / 65536.0,
4036 ( FT_intToFixed( outline->points[j].y ) +
4037 old_point_delta_y ) / 65536.0,
4038 ( FT_intToFixed( outline->points[j].x ) +
4039 point_deltas_x[j] ) / 65536.0,
4040 ( FT_intToFixed( outline->points[j].y ) +
4041 point_deltas_y[j] ) / 65536.0 ));
4042 count++;
4043 }
4044 #endif
4045 }
4046
4047 #ifdef FT_DEBUG_LEVEL_TRACE
4048 if ( !count )
4049 FT_TRACE7(( " none\n" ));
4050 #endif
4051 }
4052
4053 if ( localpoints != ALL_POINTS )
4054 FT_FREE( localpoints );
4055 FT_FREE( deltas_x );
4056 FT_FREE( deltas_y );
4057
4058 offsetToData += tupleDataSize;
4059
4060 FT_Stream_SeekSet( stream, here );
4061 }
4062
4063 FT_TRACE5(( "\n" ));
4064
4065 for ( i = 0; i < n_points; i++ )
4066 {
4067 outline->points[i].x += FT_fixedToInt( point_deltas_x[i] );
4068 outline->points[i].y += FT_fixedToInt( point_deltas_y[i] );
4069 }
4070
4071 Fail3:
4072 FT_FREE( point_deltas_x );
4073 FT_FREE( point_deltas_y );
4074
4075 Fail2:
4076 if ( sharedpoints != ALL_POINTS )
4077 FT_FREE( sharedpoints );
4078 FT_FREE( tuple_coords );
4079 FT_FREE( im_start_coords );
4080 FT_FREE( im_end_coords );
4081
4082 FT_FRAME_EXIT();
4083
4084 Fail1:
4085 FT_FREE( points_org );
4086 FT_FREE( points_out );
4087 FT_FREE( has_delta );
4088
4089 return error;
4090 }
4091
4092
4093 /**************************************************************************
4094 *
4095 * @Function:
4096 * tt_get_var_blend
4097 *
4098 * @Description:
4099 * An extended internal version of `TT_Get_MM_Blend' that returns
4100 * pointers instead of copying data, without any initialization of
4101 * the MM machinery in case it isn't loaded yet.
4102 */
4103 FT_LOCAL_DEF( FT_Error )
4104 tt_get_var_blend( TT_Face face,
4105 FT_UInt *num_coords,
4106 FT_Fixed* *coords,
4107 FT_Fixed* *normalizedcoords,
4108 FT_MM_Var* *mm_var )
4109 {
4110 if ( face->blend )
4111 {
4112 if ( num_coords )
4113 *num_coords = face->blend->num_axis;
4114 if ( coords )
4115 *coords = face->blend->coords;
4116 if ( normalizedcoords )
4117 *normalizedcoords = face->blend->normalizedcoords;
4118 if ( mm_var )
4119 *mm_var = face->blend->mmvar;
4120 }
4121 else
4122 {
4123 if ( num_coords )
4124 *num_coords = 0;
4125 if ( coords )
4126 *coords = NULL;
4127 if ( mm_var )
4128 *mm_var = NULL;
4129 }
4130
4131 return FT_Err_Ok;
4132 }
4133
4134
4135 static void
4136 ft_var_done_item_variation_store( TT_Face face,
4137 GX_ItemVarStore itemStore )
4138 {
4139 FT_Memory memory = FT_FACE_MEMORY( face );
4140 FT_UInt i;
4141
4142
4143 if ( itemStore->varData )
4144 {
4145 for ( i = 0; i < itemStore->dataCount; i++ )
4146 {
4147 FT_FREE( itemStore->varData[i].regionIndices );
4148 FT_FREE( itemStore->varData[i].deltaSet );
4149 }
4150
4151 FT_FREE( itemStore->varData );
4152 }
4153
4154 if ( itemStore->varRegionList )
4155 {
4156 for ( i = 0; i < itemStore->regionCount; i++ )
4157 FT_FREE( itemStore->varRegionList[i].axisList );
4158
4159 FT_FREE( itemStore->varRegionList );
4160 }
4161 }
4162
4163
4164 /**************************************************************************
4165 *
4166 * @Function:
4167 * tt_done_blend
4168 *
4169 * @Description:
4170 * Free the blend internal data structure.
4171 */
4172 FT_LOCAL_DEF( void )
4173 tt_done_blend( TT_Face face )
4174 {
4175 FT_Memory memory = FT_FACE_MEMORY( face );
4176 GX_Blend blend = face->blend;
4177
4178
4179 if ( blend )
4180 {
4181 FT_UInt i, num_axes;
4182
4183
4184 /* blend->num_axis might not be set up yet */
4185 num_axes = blend->mmvar->num_axis;
4186
4187 FT_FREE( blend->coords );
4188 FT_FREE( blend->normalizedcoords );
4189 FT_FREE( blend->normalized_stylecoords );
4190 FT_FREE( blend->mmvar );
4191
4192 if ( blend->avar_segment )
4193 {
4194 for ( i = 0; i < num_axes; i++ )
4195 FT_FREE( blend->avar_segment[i].correspondence );
4196 FT_FREE( blend->avar_segment );
4197 }
4198
4199 if ( blend->hvar_table )
4200 {
4201 ft_var_done_item_variation_store( face,
4202 &blend->hvar_table->itemStore );
4203
4204 FT_FREE( blend->hvar_table->widthMap.innerIndex );
4205 FT_FREE( blend->hvar_table->widthMap.outerIndex );
4206 FT_FREE( blend->hvar_table );
4207 }
4208
4209 if ( blend->vvar_table )
4210 {
4211 ft_var_done_item_variation_store( face,
4212 &blend->vvar_table->itemStore );
4213
4214 FT_FREE( blend->vvar_table->widthMap.innerIndex );
4215 FT_FREE( blend->vvar_table->widthMap.outerIndex );
4216 FT_FREE( blend->vvar_table );
4217 }
4218
4219 if ( blend->mvar_table )
4220 {
4221 ft_var_done_item_variation_store( face,
4222 &blend->mvar_table->itemStore );
4223
4224 FT_FREE( blend->mvar_table->values );
4225 FT_FREE( blend->mvar_table );
4226 }
4227
4228 FT_FREE( blend->tuplecoords );
4229 FT_FREE( blend->glyphoffsets );
4230 FT_FREE( blend );
4231 }
4232 }
4233
4234 #else /* !TT_CONFIG_OPTION_GX_VAR_SUPPORT */
4235
4236 /* ANSI C doesn't like empty source files */
4237 typedef int _tt_gxvar_dummy;
4238
4239 #endif /* !TT_CONFIG_OPTION_GX_VAR_SUPPORT */
4240
4241
4242 /* END */