ttgxvar.c source code [engine/third_party/freetype2/src/truetype/ttgxvar.c]

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

Browse the source code of engine/third_party/freetype2/src/truetype/ttgxvar.c