ttgxvar.c source code [Godot/thirdparty/freetype/src/truetype/ttgxvar.c]

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

Browse the source code of Godot/thirdparty/freetype/src/truetype/ttgxvar.c