WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/freetype/src/truetype/ttgload.c

Rev	Author	Line No.	Line
4349	Serge	1	/***************************************************************************/
		2	/* */
		3	/* ttgload.c */
		4	/* */
		5	/* TrueType Glyph Loader (body). */
		6	/* */
		7	/* Copyright 1996-2013 */
		8	/* David Turner, Robert Wilhelm, and Werner Lemberg. */
		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	#include
		20	#include FT_INTERNAL_DEBUG_H
		21	#include FT_INTERNAL_CALC_H
		22	#include FT_INTERNAL_STREAM_H
		23	#include FT_INTERNAL_SFNT_H
		24	#include FT_TRUETYPE_TAGS_H
		25	#include FT_OUTLINE_H
		26	#include FT_TRUETYPE_DRIVER_H
		27
		28	#include "ttgload.h"
		29	#include "ttpload.h"
		30
		31	#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
		32	#include "ttgxvar.h"
		33	#endif
		34
		35	#include "tterrors.h"
		36	#include "ttsubpix.h"
		37
		38
		39	/*************************************************************************/
		40	/* */
		41	/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
		42	/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
		43	/* messages during execution. */
		44	/* */
		45	#undef FT_COMPONENT
		46	#define FT_COMPONENT trace_ttgload
		47
		48
		49	/*************************************************************************/
		50	/* */
		51	/* Composite glyph flags. */
		52	/* */
		53	#define ARGS_ARE_WORDS 0x0001
		54	#define ARGS_ARE_XY_VALUES 0x0002
		55	#define ROUND_XY_TO_GRID 0x0004
		56	#define WE_HAVE_A_SCALE 0x0008
		57	/* reserved 0x0010 */
		58	#define MORE_COMPONENTS 0x0020
		59	#define WE_HAVE_AN_XY_SCALE 0x0040
		60	#define WE_HAVE_A_2X2 0x0080
		61	#define WE_HAVE_INSTR 0x0100
		62	#define USE_MY_METRICS 0x0200
		63	#define OVERLAP_COMPOUND 0x0400
		64	#define SCALED_COMPONENT_OFFSET 0x0800
		65	#define UNSCALED_COMPONENT_OFFSET 0x1000
		66
		67
		68	/*************************************************************************/
		69	/* */
		70	/* Return the horizontal metrics in font units for a given glyph. */
		71	/* */
		72	FT_LOCAL_DEF( void )
		73	TT_Get_HMetrics( TT_Face face,
		74	FT_UInt idx,
		75	FT_Short* lsb,
		76	FT_UShort* aw )
		77	{
		78	( (SFNT_Service)face->sfnt )->get_metrics( face, 0, idx, lsb, aw );
		79
		80	FT_TRACE5(( " advance width (font units): %d\n", *aw ));
		81	FT_TRACE5(( " left side bearing (font units): %d\n", *lsb ));
		82	}
		83
		84
		85	/*************************************************************************/
		86	/* */
		87	/* Return the vertical metrics in font units for a given glyph. */
		88	/* Greg Hitchcock from Microsoft told us that if there were no `vmtx' */
		89	/* table, typoAscender/Descender from the `OS/2' table would be used */
		90	/* instead, and if there were no `OS/2' table, use ascender/descender */
		91	/* from the `hhea' table. But that is not what Microsoft's rasterizer */
		92	/* apparently does: It uses the ppem value as the advance height, and */
		93	/* sets the top side bearing to be zero. */
		94	/* */
		95	FT_LOCAL_DEF( void )
		96	TT_Get_VMetrics( TT_Face face,
		97	FT_UInt idx,
		98	FT_Short* tsb,
		99	FT_UShort* ah )
		100	{
		101	if ( face->vertical_info )
		102	( (SFNT_Service)face->sfnt )->get_metrics( face, 1, idx, tsb, ah );
		103
		104	#if 1 /* Empirically determined, at variance with what MS said */
		105
		106	else
		107	{
		108	*tsb = 0;
		109	*ah = face->root.units_per_EM;
		110	}
		111
		112	#else /* This is what MS said to do. It isn't what they do, however. */
		113
		114	else if ( face->os2.version != 0xFFFFU )
		115	{
		116	*tsb = face->os2.sTypoAscender;
		117	*ah = face->os2.sTypoAscender - face->os2.sTypoDescender;
		118	}
		119	else
		120	{
		121	*tsb = face->horizontal.Ascender;
		122	*ah = face->horizontal.Ascender - face->horizontal.Descender;
		123	}
		124
		125	#endif
		126
		127	FT_TRACE5(( " advance height (font units): %d\n", *ah ));
		128	FT_TRACE5(( " top side bearing (font units): %d\n", *tsb ));
		129	}
		130
		131
		132	static void
		133	tt_get_metrics( TT_Loader loader,
		134	FT_UInt glyph_index )
		135	{
		136	TT_Face face = (TT_Face)loader->face;
		137	#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
		138	TT_Driver driver = (TT_Driver)FT_FACE_DRIVER( face );
		139	#endif
		140
		141	FT_Short left_bearing = 0, top_bearing = 0;
		142	FT_UShort advance_width = 0, advance_height = 0;
		143
		144
		145	TT_Get_HMetrics( face, glyph_index,
		146	&left_bearing,
		147	&advance_width );
		148	TT_Get_VMetrics( face, glyph_index,
		149	&top_bearing,
		150	&advance_height );
		151
		152	loader->left_bearing = left_bearing;
		153	loader->advance = advance_width;
		154	loader->top_bearing = top_bearing;
		155	loader->vadvance = advance_height;
		156
		157	#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
		158	if ( driver->interpreter_version == TT_INTERPRETER_VERSION_38 )
		159	{
		160	if ( loader->exec )
		161	loader->exec->sph_tweak_flags = 0;
		162
		163	/* this may not be the right place for this, but it works */
		164	if ( loader->exec && loader->exec->ignore_x_mode )
		165	sph_set_tweaks( loader, glyph_index );
		166	}
		167	#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
		168
		169	if ( !loader->linear_def )
		170	{
		171	loader->linear_def = 1;
		172	loader->linear = advance_width;
		173	}
		174	}
		175
		176
		177	#ifdef FT_CONFIG_OPTION_INCREMENTAL
		178
		179	static void
		180	tt_get_metrics_incr_overrides( TT_Loader loader,
		181	FT_UInt glyph_index )
		182	{
		183	TT_Face face = (TT_Face)loader->face;
		184
		185	FT_Short left_bearing = 0, top_bearing = 0;
		186	FT_UShort advance_width = 0, advance_height = 0;
		187
		188
		189	/* If this is an incrementally loaded font check whether there are */
		190	/* overriding metrics for this glyph. */
		191	if ( face->root.internal->incremental_interface &&
		192	face->root.internal->incremental_interface->funcs->get_glyph_metrics )
		193	{
		194	FT_Incremental_MetricsRec metrics;
		195	FT_Error error;
		196
		197
		198	metrics.bearing_x = loader->left_bearing;
		199	metrics.bearing_y = 0;
		200	metrics.advance = loader->advance;
		201	metrics.advance_v = 0;
		202
		203	error = face->root.internal->incremental_interface->funcs->get_glyph_metrics(
		204	face->root.internal->incremental_interface->object,
		205	glyph_index, FALSE, &metrics );
		206	if ( error )
		207	goto Exit;
		208
		209	left_bearing = (FT_Short)metrics.bearing_x;
		210	advance_width = (FT_UShort)metrics.advance;
		211
		212	#if 0
		213
		214	/* GWW: Do I do the same for vertical metrics? */
		215	metrics.bearing_x = 0;
		216	metrics.bearing_y = loader->top_bearing;
		217	metrics.advance = loader->vadvance;
		218
		219	error = face->root.internal->incremental_interface->funcs->get_glyph_metrics(
		220	face->root.internal->incremental_interface->object,
		221	glyph_index, TRUE, &metrics );
		222	if ( error )
		223	goto Exit;
		224
		225	top_bearing = (FT_Short)metrics.bearing_y;
		226	advance_height = (FT_UShort)metrics.advance;
		227
		228	#endif /* 0 */
		229
		230	loader->left_bearing = left_bearing;
		231	loader->advance = advance_width;
		232	loader->top_bearing = top_bearing;
		233	loader->vadvance = advance_height;
		234
		235	if ( !loader->linear_def )
		236	{
		237	loader->linear_def = 1;
		238	loader->linear = advance_width;
		239	}
		240	}
		241
		242	Exit:
		243	return;
		244	}
		245
		246	#endif /* FT_CONFIG_OPTION_INCREMENTAL */
		247
		248
		249	/*************************************************************************/
		250	/* */
		251	/* Translates an array of coordinates. */
		252	/* */
		253	static void
		254	translate_array( FT_UInt n,
		255	FT_Vector* coords,
		256	FT_Pos delta_x,
		257	FT_Pos delta_y )
		258	{
		259	FT_UInt k;
		260
		261
		262	if ( delta_x )
		263	for ( k = 0; k < n; k++ )
		264	coords[k].x += delta_x;
		265
		266	if ( delta_y )
		267	for ( k = 0; k < n; k++ )
		268	coords[k].y += delta_y;
		269	}
		270
		271
		272	/*************************************************************************/
		273	/* */
		274	/* The following functions are used by default with TrueType fonts. */
		275	/* However, they can be replaced by alternatives if we need to support */
		276	/* TrueType-compressed formats (like MicroType) in the future. */
		277	/* */
		278	/*************************************************************************/
		279
		280	FT_CALLBACK_DEF( FT_Error )
		281	TT_Access_Glyph_Frame( TT_Loader loader,
		282	FT_UInt glyph_index,
		283	FT_ULong offset,
		284	FT_UInt byte_count )
		285	{
		286	FT_Error error;
		287	FT_Stream stream = loader->stream;
		288
		289	/* for non-debug mode */
		290	FT_UNUSED( glyph_index );
		291
		292
		293	FT_TRACE4(( "Glyph %ld\n", glyph_index ));
		294
		295	/* the following line sets the `error' variable through macros! */
		296	if ( FT_STREAM_SEEK( offset ) \|\| FT_FRAME_ENTER( byte_count ) )
		297	return error;
		298
		299	loader->cursor = stream->cursor;
		300	loader->limit = stream->limit;
		301
		302	return FT_Err_Ok;
		303	}
		304
		305
		306	FT_CALLBACK_DEF( void )
		307	TT_Forget_Glyph_Frame( TT_Loader loader )
		308	{
		309	FT_Stream stream = loader->stream;
		310
		311
		312	FT_FRAME_EXIT();
		313	}
		314
		315
		316	FT_CALLBACK_DEF( FT_Error )
		317	TT_Load_Glyph_Header( TT_Loader loader )
		318	{
		319	FT_Byte* p = loader->cursor;
		320	FT_Byte* limit = loader->limit;
		321
		322
		323	if ( p + 10 > limit )
		324	return FT_THROW( Invalid_Outline );
		325
		326	loader->n_contours = FT_NEXT_SHORT( p );
		327
		328	loader->bbox.xMin = FT_NEXT_SHORT( p );
		329	loader->bbox.yMin = FT_NEXT_SHORT( p );
		330	loader->bbox.xMax = FT_NEXT_SHORT( p );
		331	loader->bbox.yMax = FT_NEXT_SHORT( p );
		332
		333	FT_TRACE5(( " # of contours: %d\n", loader->n_contours ));
		334	FT_TRACE5(( " xMin: %4d xMax: %4d\n", loader->bbox.xMin,
		335	loader->bbox.xMax ));
		336	FT_TRACE5(( " yMin: %4d yMax: %4d\n", loader->bbox.yMin,
		337	loader->bbox.yMax ));
		338	loader->cursor = p;
		339
		340	return FT_Err_Ok;
		341	}
		342
		343
		344	FT_CALLBACK_DEF( FT_Error )
		345	TT_Load_Simple_Glyph( TT_Loader load )
		346	{
		347	FT_Error error;
		348	FT_Byte* p = load->cursor;
		349	FT_Byte* limit = load->limit;
		350	FT_GlyphLoader gloader = load->gloader;
		351	FT_Int n_contours = load->n_contours;
		352	FT_Outline* outline;
		353	TT_Face face = (TT_Face)load->face;
		354	FT_UShort n_ins;
		355	FT_Int n_points;
		356
		357	FT_Byte flag, flag_limit;
		358	FT_Byte c, count;
		359	FT_Vector vec, vec_limit;
		360	FT_Pos x;
		361	FT_Short cont, cont_limit, prev_cont;
		362	FT_Int xy_size = 0;
		363
		364
		365	/* check that we can add the contours to the glyph */
		366	error = FT_GLYPHLOADER_CHECK_POINTS( gloader, 0, n_contours );
		367	if ( error )
		368	goto Fail;
		369
		370	/* reading the contours' endpoints & number of points */
		371	cont = gloader->current.outline.contours;
		372	cont_limit = cont + n_contours;
		373
		374	/* check space for contours array + instructions count */
		375	if ( n_contours >= 0xFFF \|\| p + ( n_contours + 1 ) * 2 > limit )
		376	goto Invalid_Outline;
		377
		378	prev_cont = FT_NEXT_SHORT( p );
		379
		380	if ( n_contours > 0 )
		381	cont[0] = prev_cont;
		382
		383	if ( prev_cont < 0 )
		384	goto Invalid_Outline;
		385
		386	for ( cont++; cont < cont_limit; cont++ )
		387	{
		388	cont[0] = FT_NEXT_SHORT( p );
		389	if ( cont[0] <= prev_cont )
		390	{
		391	/* unordered contours: this is invalid */
		392	goto Invalid_Outline;
		393	}
		394	prev_cont = cont[0];
		395	}
		396
		397	n_points = 0;
		398	if ( n_contours > 0 )
		399	{
		400	n_points = cont[-1] + 1;
		401	if ( n_points < 0 )
		402	goto Invalid_Outline;
		403	}
		404
		405	/* note that we will add four phantom points later */
		406	error = FT_GLYPHLOADER_CHECK_POINTS( gloader, n_points + 4, 0 );
		407	if ( error )
		408	goto Fail;
		409
		410	/* reading the bytecode instructions */
		411	load->glyph->control_len = 0;
		412	load->glyph->control_data = 0;
		413
		414	if ( p + 2 > limit )
		415	goto Invalid_Outline;
		416
		417	n_ins = FT_NEXT_USHORT( p );
		418
		419	FT_TRACE5(( " Instructions size: %u\n", n_ins ));
		420
		421	if ( n_ins > face->max_profile.maxSizeOfInstructions )
		422	{
		423	FT_TRACE0(( "TT_Load_Simple_Glyph: too many instructions (%d)\n",
		424	n_ins ));
		425	error = FT_THROW( Too_Many_Hints );
		426	goto Fail;
		427	}
		428
		429	if ( ( limit - p ) < n_ins )
		430	{
		431	FT_TRACE0(( "TT_Load_Simple_Glyph: instruction count mismatch\n" ));
		432	error = FT_THROW( Too_Many_Hints );
		433	goto Fail;
		434	}
		435
		436	#ifdef TT_USE_BYTECODE_INTERPRETER
		437
		438	if ( IS_HINTED( load->load_flags ) )
		439	{
		440	load->glyph->control_len = n_ins;
		441	load->glyph->control_data = load->exec->glyphIns;
		442
		443	FT_MEM_COPY( load->exec->glyphIns, p, (FT_Long)n_ins );
		444	}
		445
		446	#endif /* TT_USE_BYTECODE_INTERPRETER */
		447
		448	p += n_ins;
		449
		450	outline = &gloader->current.outline;
		451
		452	/* reading the point tags */
		453	flag = (FT_Byte*)outline->tags;
		454	flag_limit = flag + n_points;
		455
		456	FT_ASSERT( flag != NULL );
		457
		458	while ( flag < flag_limit )
		459	{
		460	if ( p + 1 > limit )
		461	goto Invalid_Outline;
		462
		463	*flag++ = c = FT_NEXT_BYTE( p );
		464	if ( c & 8 )
		465	{
		466	if ( p + 1 > limit )
		467	goto Invalid_Outline;
		468
		469	count = FT_NEXT_BYTE( p );
		470	if ( flag + (FT_Int)count > flag_limit )
		471	goto Invalid_Outline;
		472
		473	for ( ; count > 0; count-- )
		474	*flag++ = c;
		475	}
		476	}
		477
		478	/* reading the X coordinates */
		479
		480	vec = outline->points;
		481	vec_limit = vec + n_points;
		482	flag = (FT_Byte*)outline->tags;
		483	x = 0;
		484
		485	if ( p + xy_size > limit )
		486	goto Invalid_Outline;
		487
		488	for ( ; vec < vec_limit; vec++, flag++ )
		489	{
		490	FT_Pos y = 0;
		491	FT_Byte f = *flag;
		492
		493
		494	if ( f & 2 )
		495	{
		496	if ( p + 1 > limit )
		497	goto Invalid_Outline;
		498
		499	y = (FT_Pos)FT_NEXT_BYTE( p );
		500	if ( ( f & 16 ) == 0 )
		501	y = -y;
		502	}
		503	else if ( ( f & 16 ) == 0 )
		504	{
		505	if ( p + 2 > limit )
		506	goto Invalid_Outline;
		507
		508	y = (FT_Pos)FT_NEXT_SHORT( p );
		509	}
		510
		511	x += y;
		512	vec->x = x;
		513	/* the cast is for stupid compilers */
		514	*flag = (FT_Byte)( f & ~( 2 \| 16 ) );
		515	}
		516
		517	/* reading the Y coordinates */
		518
		519	vec = gloader->current.outline.points;
		520	vec_limit = vec + n_points;
		521	flag = (FT_Byte*)outline->tags;
		522	x = 0;
		523
		524	for ( ; vec < vec_limit; vec++, flag++ )
		525	{
		526	FT_Pos y = 0;
		527	FT_Byte f = *flag;
		528
		529
		530	if ( f & 4 )
		531	{
		532	if ( p + 1 > limit )
		533	goto Invalid_Outline;
		534
		535	y = (FT_Pos)FT_NEXT_BYTE( p );
		536	if ( ( f & 32 ) == 0 )
		537	y = -y;
		538	}
		539	else if ( ( f & 32 ) == 0 )
		540	{
		541	if ( p + 2 > limit )
		542	goto Invalid_Outline;
		543
		544	y = (FT_Pos)FT_NEXT_SHORT( p );
		545	}
		546
		547	x += y;
		548	vec->y = x;
		549	/* the cast is for stupid compilers */
		550	*flag = (FT_Byte)( f & FT_CURVE_TAG_ON );
		551	}
		552
		553	outline->n_points = (FT_UShort)n_points;
		554	outline->n_contours = (FT_Short) n_contours;
		555
		556	load->cursor = p;
		557
		558	Fail:
		559	return error;
		560
		561	Invalid_Outline:
		562	error = FT_THROW( Invalid_Outline );
		563	goto Fail;
		564	}
		565
		566
		567	FT_CALLBACK_DEF( FT_Error )
		568	TT_Load_Composite_Glyph( TT_Loader loader )
		569	{
		570	FT_Error error;
		571	FT_Byte* p = loader->cursor;
		572	FT_Byte* limit = loader->limit;
		573	FT_GlyphLoader gloader = loader->gloader;
		574	FT_SubGlyph subglyph;
		575	FT_UInt num_subglyphs;
		576
		577
		578	num_subglyphs = 0;
		579
		580	do
		581	{
		582	FT_Fixed xx, xy, yy, yx;
		583	FT_UInt count;
		584
		585
		586	/* check that we can load a new subglyph */
		587	error = FT_GlyphLoader_CheckSubGlyphs( gloader, num_subglyphs + 1 );
		588	if ( error )
		589	goto Fail;
		590
		591	/* check space */
		592	if ( p + 4 > limit )
		593	goto Invalid_Composite;
		594
		595	subglyph = gloader->current.subglyphs + num_subglyphs;
		596
		597	subglyph->arg1 = subglyph->arg2 = 0;
		598
		599	subglyph->flags = FT_NEXT_USHORT( p );
		600	subglyph->index = FT_NEXT_USHORT( p );
		601
		602	/* check space */
		603	count = 2;
		604	if ( subglyph->flags & ARGS_ARE_WORDS )
		605	count += 2;
		606	if ( subglyph->flags & WE_HAVE_A_SCALE )
		607	count += 2;
		608	else if ( subglyph->flags & WE_HAVE_AN_XY_SCALE )
		609	count += 4;
		610	else if ( subglyph->flags & WE_HAVE_A_2X2 )
		611	count += 8;
		612
		613	if ( p + count > limit )
		614	goto Invalid_Composite;
		615
		616	/* read arguments */
		617	if ( subglyph->flags & ARGS_ARE_WORDS )
		618	{
		619	subglyph->arg1 = FT_NEXT_SHORT( p );
		620	subglyph->arg2 = FT_NEXT_SHORT( p );
		621	}
		622	else
		623	{
		624	subglyph->arg1 = FT_NEXT_CHAR( p );
		625	subglyph->arg2 = FT_NEXT_CHAR( p );
		626	}
		627
		628	/* read transform */
		629	xx = yy = 0x10000L;
		630	xy = yx = 0;
		631
		632	if ( subglyph->flags & WE_HAVE_A_SCALE )
		633	{
		634	xx = (FT_Fixed)FT_NEXT_SHORT( p ) << 2;
		635	yy = xx;
		636	}
		637	else if ( subglyph->flags & WE_HAVE_AN_XY_SCALE )
		638	{
		639	xx = (FT_Fixed)FT_NEXT_SHORT( p ) << 2;
		640	yy = (FT_Fixed)FT_NEXT_SHORT( p ) << 2;
		641	}
		642	else if ( subglyph->flags & WE_HAVE_A_2X2 )
		643	{
		644	xx = (FT_Fixed)FT_NEXT_SHORT( p ) << 2;
		645	yx = (FT_Fixed)FT_NEXT_SHORT( p ) << 2;
		646	xy = (FT_Fixed)FT_NEXT_SHORT( p ) << 2;
		647	yy = (FT_Fixed)FT_NEXT_SHORT( p ) << 2;
		648	}
		649
		650	subglyph->transform.xx = xx;
		651	subglyph->transform.xy = xy;
		652	subglyph->transform.yx = yx;
		653	subglyph->transform.yy = yy;
		654
		655	num_subglyphs++;
		656
		657	} while ( subglyph->flags & MORE_COMPONENTS );
		658
		659	gloader->current.num_subglyphs = num_subglyphs;
		660
		661	#ifdef TT_USE_BYTECODE_INTERPRETER
		662
		663	{
		664	FT_Stream stream = loader->stream;
		665
		666
		667	/* we must undo the FT_FRAME_ENTER in order to point */
		668	/* to the composite instructions, if we find some. */
		669	/* We will process them later. */
		670	/* */
		671	loader->ins_pos = (FT_ULong)( FT_STREAM_POS() +
		672	p - limit );
		673	}
		674
		675	#endif
		676
		677	loader->cursor = p;
		678
		679	Fail:
		680	return error;
		681
		682	Invalid_Composite:
		683	error = FT_THROW( Invalid_Composite );
		684	goto Fail;
		685	}
		686
		687
		688	FT_LOCAL_DEF( void )
		689	TT_Init_Glyph_Loading( TT_Face face )
		690	{
		691	face->access_glyph_frame = TT_Access_Glyph_Frame;
		692	face->read_glyph_header = TT_Load_Glyph_Header;
		693	face->read_simple_glyph = TT_Load_Simple_Glyph;
		694	face->read_composite_glyph = TT_Load_Composite_Glyph;
		695	face->forget_glyph_frame = TT_Forget_Glyph_Frame;
		696	}
		697
		698
		699	static void
		700	tt_prepare_zone( TT_GlyphZone zone,
		701	FT_GlyphLoad load,
		702	FT_UInt start_point,
		703	FT_UInt start_contour )
		704	{
		705	zone->n_points = (FT_UShort)( load->outline.n_points - start_point );
		706	zone->n_contours = (FT_Short) ( load->outline.n_contours -
		707	start_contour );
		708	zone->org = load->extra_points + start_point;
		709	zone->cur = load->outline.points + start_point;
		710	zone->orus = load->extra_points2 + start_point;
		711	zone->tags = (FT_Byte*)load->outline.tags + start_point;
		712	zone->contours = (FT_UShort*)load->outline.contours + start_contour;
		713	zone->first_point = (FT_UShort)start_point;
		714	}
		715
		716
		717	/*************************************************************************/
		718	/* */
		719	/* */
		720	/* TT_Hint_Glyph */
		721	/* */
		722	/* */
		723	/* Hint the glyph using the zone prepared by the caller. Note that */
		724	/* the zone is supposed to include four phantom points. */
		725	/* */
		726	static FT_Error
		727	TT_Hint_Glyph( TT_Loader loader,
		728	FT_Bool is_composite )
		729	{
		730	#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
		731	TT_Face face = (TT_Face)loader->face;
		732	TT_Driver driver = (TT_Driver)FT_FACE_DRIVER( face );
		733	#endif
		734
		735	TT_GlyphZone zone = &loader->zone;
		736	FT_Pos origin;
		737
		738	#ifdef TT_USE_BYTECODE_INTERPRETER
		739	FT_UInt n_ins;
		740	#else
		741	FT_UNUSED( is_composite );
		742	#endif
		743
		744
		745	#ifdef TT_USE_BYTECODE_INTERPRETER
		746	if ( loader->glyph->control_len > 0xFFFFL )
		747	{
		748	FT_TRACE1(( "TT_Hint_Glyph: too long instructions " ));
		749	FT_TRACE1(( "(0x%lx byte) is truncated\n",
		750	loader->glyph->control_len ));
		751	}
		752	n_ins = (FT_UInt)( loader->glyph->control_len );
		753	#endif
		754
		755	origin = zone->cur[zone->n_points - 4].x;
		756	origin = FT_PIX_ROUND( origin ) - origin;
		757	if ( origin )
		758	translate_array( zone->n_points, zone->cur, origin, 0 );
		759
		760	#ifdef TT_USE_BYTECODE_INTERPRETER
		761	/* save original point position in org */
		762	if ( n_ins > 0 )
		763	FT_ARRAY_COPY( zone->org, zone->cur, zone->n_points );
		764
		765	/* Reset graphics state. */
		766	loader->exec->GS = ((TT_Size)loader->size)->GS;
		767
		768	/* XXX: UNDOCUMENTED! Hinting instructions of a composite glyph */
		769	/* completely refer to the (already) hinted subglyphs. */
		770	if ( is_composite )
		771	{
		772	loader->exec->metrics.x_scale = 1 << 16;
		773	loader->exec->metrics.y_scale = 1 << 16;
		774
		775	FT_ARRAY_COPY( zone->orus, zone->cur, zone->n_points );
		776	}
		777	else
		778	{
		779	loader->exec->metrics.x_scale =
		780	((TT_Size)loader->size)->metrics.x_scale;
		781	loader->exec->metrics.y_scale =
		782	((TT_Size)loader->size)->metrics.y_scale;
		783	}
		784	#endif
		785
		786	/* round pp2 and pp4 */
		787	zone->cur[zone->n_points - 3].x =
		788	FT_PIX_ROUND( zone->cur[zone->n_points - 3].x );
		789	zone->cur[zone->n_points - 1].y =
		790	FT_PIX_ROUND( zone->cur[zone->n_points - 1].y );
		791
		792	#ifdef TT_USE_BYTECODE_INTERPRETER
		793
		794	if ( n_ins > 0 )
		795	{
		796	FT_Bool debug;
		797	FT_Error error;
		798
		799	FT_GlyphLoader gloader = loader->gloader;
		800	FT_Outline current_outline = gloader->current.outline;
		801
		802
		803	error = TT_Set_CodeRange( loader->exec, tt_coderange_glyph,
		804	loader->exec->glyphIns, n_ins );
		805	if ( error )
		806	return error;
		807
		808	loader->exec->is_composite = is_composite;
		809	loader->exec->pts = *zone;
		810
		811	debug = FT_BOOL( !( loader->load_flags & FT_LOAD_NO_SCALE ) &&
		812	((TT_Size)loader->size)->debug );
		813
		814	error = TT_Run_Context( loader->exec, debug );
		815	if ( error && loader->exec->pedantic_hinting )
		816	return error;
		817
		818	/* store drop-out mode in bits 5-7; set bit 2 also as a marker */
		819	current_outline.tags[0] \|=
		820	( loader->exec->GS.scan_type << 5 ) \| FT_CURVE_TAG_HAS_SCANMODE;
		821	}
		822
		823	#endif
		824
		825	/* save glyph phantom points */
		826	if ( !loader->preserve_pps )
		827	{
		828	loader->pp1 = zone->cur[zone->n_points - 4];
		829	loader->pp2 = zone->cur[zone->n_points - 3];
		830	loader->pp3 = zone->cur[zone->n_points - 2];
		831	loader->pp4 = zone->cur[zone->n_points - 1];
		832	}
		833
		834	#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
		835	if ( driver->interpreter_version == TT_INTERPRETER_VERSION_38 )
		836	{
		837	if ( loader->exec->sph_tweak_flags & SPH_TWEAK_DEEMBOLDEN )
		838	FT_Outline_EmboldenXY( &loader->gloader->current.outline, -24, 0 );
		839
		840	else if ( loader->exec->sph_tweak_flags & SPH_TWEAK_EMBOLDEN )
		841	FT_Outline_EmboldenXY( &loader->gloader->current.outline, 24, 0 );
		842	}
		843	#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
		844
		845	return FT_Err_Ok;
		846	}
		847
		848
		849	/*************************************************************************/
		850	/* */
		851	/* */
		852	/* TT_Process_Simple_Glyph */
		853	/* */
		854	/* */
		855	/* Once a simple glyph has been loaded, it needs to be processed. */
		856	/* Usually, this means scaling and hinting through bytecode */
		857	/* interpretation. */
		858	/* */
		859	static FT_Error
		860	TT_Process_Simple_Glyph( TT_Loader loader )
		861	{
		862	FT_GlyphLoader gloader = loader->gloader;
		863	FT_Error error = FT_Err_Ok;
		864	FT_Outline* outline;
		865	FT_Int n_points;
		866
		867
		868	outline = &gloader->current.outline;
		869	n_points = outline->n_points;
		870
		871	/* set phantom points */
		872
		873	outline->points[n_points ] = loader->pp1;
		874	outline->points[n_points + 1] = loader->pp2;
		875	outline->points[n_points + 2] = loader->pp3;
		876	outline->points[n_points + 3] = loader->pp4;
		877
		878	outline->tags[n_points ] = 0;
		879	outline->tags[n_points + 1] = 0;
		880	outline->tags[n_points + 2] = 0;
		881	outline->tags[n_points + 3] = 0;
		882
		883	n_points += 4;
		884
		885	#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
		886
		887	if ( ((TT_Face)loader->face)->doblend )
		888	{
		889	/* Deltas apply to the unscaled data. */
		890	FT_Vector* deltas;
		891	FT_Memory memory = loader->face->memory;
		892	FT_Int i;
		893
		894
		895	error = TT_Vary_Get_Glyph_Deltas( (TT_Face)(loader->face),
		896	loader->glyph_index,
		897	&deltas,
		898	n_points );
		899	if ( error )
		900	return error;
		901
		902	for ( i = 0; i < n_points; ++i )
		903	{
		904	outline->points[i].x += deltas[i].x;
		905	outline->points[i].y += deltas[i].y;
		906	}
		907
		908	FT_FREE( deltas );
		909	}
		910
		911	#endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */
		912
		913	if ( IS_HINTED( loader->load_flags ) )
		914	{
		915	tt_prepare_zone( &loader->zone, &gloader->current, 0, 0 );
		916
		917	FT_ARRAY_COPY( loader->zone.orus, loader->zone.cur,
		918	loader->zone.n_points + 4 );
		919	}
		920
		921	{
		922	#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
		923	TT_Face face = (TT_Face)loader->face;
		924	TT_Driver driver = (TT_Driver)FT_FACE_DRIVER( face );
		925
		926	FT_String* family = face->root.family_name;
		927	FT_Int ppem = loader->size->metrics.x_ppem;
		928	FT_String* style = face->root.style_name;
		929	FT_Int x_scale_factor = 1000;
		930	#endif
		931
		932	FT_Vector* vec = outline->points;
		933	FT_Vector* limit = outline->points + n_points;
		934
		935	FT_Fixed x_scale = 0; /* pacify compiler */
		936	FT_Fixed y_scale = 0;
		937
		938	FT_Bool do_scale = FALSE;
		939
		940
		941	#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
		942
		943	if ( driver->interpreter_version == TT_INTERPRETER_VERSION_38 )
		944	{
		945	/* scale, but only if enabled and only if TT hinting is being used */
		946	if ( IS_HINTED( loader->load_flags ) )
		947	x_scale_factor = sph_test_tweak_x_scaling( face,
		948	family,
		949	ppem,
		950	style,
		951	loader->glyph_index );
		952	/* scale the glyph */
		953	if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 \|\|
		954	x_scale_factor != 1000 )
		955	{
		956	x_scale = FT_MulDiv( ((TT_Size)loader->size)->metrics.x_scale,
		957	x_scale_factor, 1000 );
		958	y_scale = ((TT_Size)loader->size)->metrics.y_scale;
		959
		960	/* compensate for any scaling by de/emboldening; */
		961	/* the amount was determined via experimentation */
		962	if ( x_scale_factor != 1000 && ppem > 11 )
		963	FT_Outline_EmboldenXY( outline,
		964	FT_MulFix( 1280 * ppem,
		965	1000 - x_scale_factor ),
		966
		967	do_scale = TRUE;
		968	}
		969	}
		970	else
		971
		972	#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
		973
		974	{
		975	/* scale the glyph */
		976	if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 )
		977	{
		978	x_scale = ((TT_Size)loader->size)->metrics.x_scale;
		979	y_scale = ((TT_Size)loader->size)->metrics.y_scale;
		980
		981	do_scale = TRUE;
		982	}
		983	}
		984
		985	if ( do_scale )
		986	{
		987	for ( ; vec < limit; vec++ )
		988	{
		989	vec->x = FT_MulFix( vec->x, x_scale );
		990	vec->y = FT_MulFix( vec->y, y_scale );
		991	}
		992
		993	loader->pp1 = outline->points[n_points - 4];
		994	loader->pp2 = outline->points[n_points - 3];
		995	loader->pp3 = outline->points[n_points - 2];
		996	loader->pp4 = outline->points[n_points - 1];
		997	}
		998	}
		999
		1000	if ( IS_HINTED( loader->load_flags ) )
		1001	{
		1002	loader->zone.n_points += 4;
		1003
		1004	error = TT_Hint_Glyph( loader, 0 );
		1005	}
		1006
		1007	return error;
		1008	}
		1009
		1010
		1011	/*************************************************************************/
		1012	/* */
		1013	/* */
		1014	/* TT_Process_Composite_Component */
		1015	/* */
		1016	/* */
		1017	/* Once a composite component has been loaded, it needs to be */
		1018	/* processed. Usually, this means transforming and translating. */
		1019	/* */
		1020	static FT_Error
		1021	TT_Process_Composite_Component( TT_Loader loader,
		1022	FT_SubGlyph subglyph,
		1023	FT_UInt start_point,
		1024	FT_UInt num_base_points )
		1025	{
		1026	FT_GlyphLoader gloader = loader->gloader;
		1027	FT_Vector* base_vec = gloader->base.outline.points;
		1028	FT_UInt num_points = gloader->base.outline.n_points;
		1029	FT_Bool have_scale;
		1030	FT_Pos x, y;
		1031
		1032
		1033	have_scale = FT_BOOL( subglyph->flags & ( WE_HAVE_A_SCALE \|
		1034	WE_HAVE_AN_XY_SCALE \|
		1035	WE_HAVE_A_2X2 ) );
		1036
		1037	/* perform the transform required for this subglyph */
		1038	if ( have_scale )
		1039	{
		1040	FT_UInt i;
		1041
		1042
		1043	for ( i = num_base_points; i < num_points; i++ )
		1044	FT_Vector_Transform( base_vec + i, &subglyph->transform );
		1045	}
		1046
		1047	/* get offset */
		1048	if ( !( subglyph->flags & ARGS_ARE_XY_VALUES ) )
		1049	{
		1050	FT_UInt k = subglyph->arg1;
		1051	FT_UInt l = subglyph->arg2;
		1052	FT_Vector* p1;
		1053	FT_Vector* p2;
		1054
		1055
		1056	/* match l-th point of the newly loaded component to the k-th point */
		1057	/* of the previously loaded components. */
		1058
		1059	/* change to the point numbers used by our outline */
		1060	k += start_point;
		1061	l += num_base_points;
		1062	if ( k >= num_base_points \|\|
		1063	l >= num_points )
		1064	return FT_THROW( Invalid_Composite );
		1065
		1066	p1 = gloader->base.outline.points + k;
		1067	p2 = gloader->base.outline.points + l;
		1068
		1069	x = p1->x - p2->x;
		1070	y = p1->y - p2->y;
		1071	}
		1072	else
		1073	{
		1074	x = subglyph->arg1;
		1075	y = subglyph->arg2;
		1076
		1077	if ( !x && !y )
		1078	return FT_Err_Ok;
		1079
		1080	/* Use a default value dependent on */
		1081	/* TT_CONFIG_OPTION_COMPONENT_OFFSET_SCALED. This is useful for old TT */
		1082	/* fonts which don't set the xxx_COMPONENT_OFFSET bit. */
		1083
		1084	if ( have_scale &&
		1085	#ifdef TT_CONFIG_OPTION_COMPONENT_OFFSET_SCALED
		1086	!( subglyph->flags & UNSCALED_COMPONENT_OFFSET ) )
		1087	#else
		1088	( subglyph->flags & SCALED_COMPONENT_OFFSET ) )
		1089	#endif
		1090	{
		1091
		1092	#if 0
		1093
		1094	/*************************************************************************/
		1095	/* */
		1096	/* This algorithm is what Apple documents. But it doesn't work. */
		1097	/* */
		1098	int a = subglyph->transform.xx > 0 ? subglyph->transform.xx
		1099	: -subglyph->transform.xx;
		1100	int b = subglyph->transform.yx > 0 ? subglyph->transform.yx
		1101	: -subglyph->transform.yx;
		1102	int c = subglyph->transform.xy > 0 ? subglyph->transform.xy
		1103	: -subglyph->transform.xy;
		1104	int d = subglyph->transform.yy > 0 ? subglyph->transform.yy
		1105	: -subglyph->transform.yy;
		1106	int m = a > b ? a : b;
		1107	int n = c > d ? c : d;
		1108
		1109
		1110	if ( a - b <= 33 && a - b >= -33 )
		1111	m *= 2;
		1112	if ( c - d <= 33 && c - d >= -33 )
		1113	n *= 2;
		1114	x = FT_MulFix( x, m );
		1115	y = FT_MulFix( y, n );
		1116
		1117	#else /* 0 */
		1118
		1119	/*************************************************************************/
		1120	/* */
		1121	/* This algorithm is a guess and works much better than the above. */
		1122	/* */
		1123	FT_Fixed mac_xscale = FT_Hypot( subglyph->transform.xx,
		1124	subglyph->transform.xy );
		1125	FT_Fixed mac_yscale = FT_Hypot( subglyph->transform.yy,
		1126	subglyph->transform.yx );
		1127
		1128
		1129	x = FT_MulFix( x, mac_xscale );
		1130	y = FT_MulFix( y, mac_yscale );
		1131
		1132	#endif /* 0 */
		1133
		1134	}
		1135
		1136	if ( !( loader->load_flags & FT_LOAD_NO_SCALE ) )
		1137	{
		1138	FT_Fixed x_scale = ((TT_Size)loader->size)->metrics.x_scale;
		1139	FT_Fixed y_scale = ((TT_Size)loader->size)->metrics.y_scale;
		1140
		1141
		1142	x = FT_MulFix( x, x_scale );
		1143	y = FT_MulFix( y, y_scale );
		1144
		1145	if ( subglyph->flags & ROUND_XY_TO_GRID )
		1146	{
		1147	x = FT_PIX_ROUND( x );
		1148	y = FT_PIX_ROUND( y );
		1149	}
		1150	}
		1151	}
		1152
		1153	if ( x \|\| y )
		1154	translate_array( num_points - num_base_points,
		1155	base_vec + num_base_points,
		1156	x, y );
		1157
		1158	return FT_Err_Ok;
		1159	}
		1160
		1161
		1162	/*************************************************************************/
		1163	/* */
		1164	/* */
		1165	/* TT_Process_Composite_Glyph */
		1166	/* */
		1167	/* */
		1168	/* This is slightly different from TT_Process_Simple_Glyph, in that */
		1169	/* its sole purpose is to hint the glyph. Thus this function is */
		1170	/* only available when bytecode interpreter is enabled. */
		1171	/* */
		1172	static FT_Error
		1173	TT_Process_Composite_Glyph( TT_Loader loader,
		1174	FT_UInt start_point,
		1175	FT_UInt start_contour )
		1176	{
		1177	FT_Error error;
		1178	FT_Outline* outline;
		1179	FT_UInt i;
		1180
		1181
		1182	outline = &loader->gloader->base.outline;
		1183
		1184	/* make room for phantom points */
		1185	error = FT_GLYPHLOADER_CHECK_POINTS( loader->gloader,
		1186	outline->n_points + 4,
		1187
		1188	if ( error )
		1189	return error;
		1190
		1191	outline->points[outline->n_points ] = loader->pp1;
		1192	outline->points[outline->n_points + 1] = loader->pp2;
		1193	outline->points[outline->n_points + 2] = loader->pp3;
		1194	outline->points[outline->n_points + 3] = loader->pp4;
		1195
		1196	outline->tags[outline->n_points ] = 0;
		1197	outline->tags[outline->n_points + 1] = 0;
		1198	outline->tags[outline->n_points + 2] = 0;
		1199	outline->tags[outline->n_points + 3] = 0;
		1200
		1201	#ifdef TT_USE_BYTECODE_INTERPRETER
		1202
		1203	{
		1204	FT_Stream stream = loader->stream;
		1205	FT_UShort n_ins, max_ins;
		1206	FT_ULong tmp;
		1207
		1208
		1209	/* TT_Load_Composite_Glyph only gives us the offset of instructions */
		1210	/* so we read them here */
		1211	if ( FT_STREAM_SEEK( loader->ins_pos ) \|\|
		1212	FT_READ_USHORT( n_ins ) )
		1213	return error;
		1214
		1215	FT_TRACE5(( " Instructions size = %d\n", n_ins ));
		1216
		1217	/* check it */
		1218	max_ins = ((TT_Face)loader->face)->max_profile.maxSizeOfInstructions;
		1219	if ( n_ins > max_ins )
		1220	{
		1221	/* acroread ignores this field, so we only do a rough safety check */
		1222	if ( (FT_Int)n_ins > loader->byte_len )
		1223	{
		1224	FT_TRACE1(( "TT_Process_Composite_Glyph: "
		1225	"too many instructions (%d) for glyph with length %d\n",
		1226	n_ins, loader->byte_len ));
		1227	return FT_THROW( Too_Many_Hints );
		1228	}
		1229
		1230	tmp = loader->exec->glyphSize;
		1231	error = Update_Max( loader->exec->memory,
		1232	&tmp,
		1233	sizeof ( FT_Byte ),
		1234	(void*)&loader->exec->glyphIns,
		1235	n_ins );
		1236	loader->exec->glyphSize = (FT_UShort)tmp;
		1237	if ( error )
		1238	return error;
		1239	}
		1240	else if ( n_ins == 0 )
		1241	return FT_Err_Ok;
		1242
		1243	if ( FT_STREAM_READ( loader->exec->glyphIns, n_ins ) )
		1244	return error;
		1245
		1246	loader->glyph->control_data = loader->exec->glyphIns;
		1247	loader->glyph->control_len = n_ins;
		1248	}
		1249
		1250	#endif
		1251
		1252	tt_prepare_zone( &loader->zone, &loader->gloader->base,
		1253	start_point, start_contour );
		1254
		1255	/* Some points are likely touched during execution of */
		1256	/* instructions on components. So let's untouch them. */
		1257	for ( i = start_point; i < loader->zone.n_points; i++ )
		1258	loader->zone.tags[i] &= ~FT_CURVE_TAG_TOUCH_BOTH;
		1259
		1260	loader->zone.n_points += 4;
		1261
		1262	return TT_Hint_Glyph( loader, 1 );
		1263	}
		1264
		1265
		1266	/* Calculate the four phantom points. */
		1267	/* The first two stand for horizontal origin and advance. */
		1268	/* The last two stand for vertical origin and advance. */
		1269	#define TT_LOADER_SET_PP( loader ) \
		1270	do { \
		1271	(loader)->pp1.x = (loader)->bbox.xMin - (loader)->left_bearing; \
		1272	(loader)->pp1.y = 0; \
		1273	(loader)->pp2.x = (loader)->pp1.x + (loader)->advance; \
		1274	(loader)->pp2.y = 0; \
		1275	(loader)->pp3.x = 0; \
		1276	(loader)->pp3.y = (loader)->top_bearing + (loader)->bbox.yMax; \
		1277	(loader)->pp4.x = 0; \
		1278	(loader)->pp4.y = (loader)->pp3.y - (loader)->vadvance; \
		1279	} while ( 0 )
		1280
		1281
		1282	/*************************************************************************/
		1283	/* */
		1284	/* */
		1285	/* load_truetype_glyph */
		1286	/* */
		1287	/* */
		1288	/* Loads a given truetype glyph. Handles composites and uses a */
		1289	/* TT_Loader object. */
		1290	/* */
		1291	static FT_Error
		1292	load_truetype_glyph( TT_Loader loader,
		1293	FT_UInt glyph_index,
		1294	FT_UInt recurse_count,
		1295	FT_Bool header_only )
		1296	{
		1297	FT_Error error = FT_Err_Ok;
		1298	FT_Fixed x_scale, y_scale;
		1299	FT_ULong offset;
		1300	TT_Face face = (TT_Face)loader->face;
		1301	FT_GlyphLoader gloader = loader->gloader;
		1302	FT_Bool opened_frame = 0;
		1303
		1304	#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
		1305	FT_Vector* deltas = NULL;
		1306	#endif
		1307
		1308	#ifdef FT_CONFIG_OPTION_INCREMENTAL
		1309	FT_StreamRec inc_stream;
		1310	FT_Data glyph_data;
		1311	FT_Bool glyph_data_loaded = 0;
		1312	#endif
		1313
		1314
		1315	/* some fonts have an incorrect value of `maxComponentDepth', */
		1316	/* thus we allow depth 1 to catch the majority of them */
		1317	if ( recurse_count > 1 &&
		1318	recurse_count > face->max_profile.maxComponentDepth )
		1319	{
		1320	error = FT_THROW( Invalid_Composite );
		1321	goto Exit;
		1322	}
		1323
		1324	/* check glyph index */
		1325	if ( glyph_index >= (FT_UInt)face->root.num_glyphs )
		1326	{
		1327	error = FT_THROW( Invalid_Glyph_Index );
		1328	goto Exit;
		1329	}
		1330
		1331	loader->glyph_index = glyph_index;
		1332
		1333	if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 )
		1334	{
		1335	x_scale = ((TT_Size)loader->size)->metrics.x_scale;
		1336	y_scale = ((TT_Size)loader->size)->metrics.y_scale;
		1337	}
		1338	else
		1339	{
		1340	x_scale = 0x10000L;
		1341	y_scale = 0x10000L;
		1342	}
		1343
		1344	tt_get_metrics( loader, glyph_index );
		1345
		1346	/* Set `offset' to the start of the glyph relative to the start of */
		1347	/* the `glyf' table, and `byte_len' to the length of the glyph in */
		1348	/* bytes. */
		1349
		1350	#ifdef FT_CONFIG_OPTION_INCREMENTAL
		1351
		1352	/* If we are loading glyph data via the incremental interface, set */
		1353	/* the loader stream to a memory stream reading the data returned */
		1354	/* by the interface. */
		1355	if ( face->root.internal->incremental_interface )
		1356	{
		1357	error = face->root.internal->incremental_interface->funcs->get_glyph_data(
		1358	face->root.internal->incremental_interface->object,
		1359	glyph_index, &glyph_data );
		1360	if ( error )
		1361	goto Exit;
		1362
		1363	glyph_data_loaded = 1;
		1364	offset = 0;
		1365	loader->byte_len = glyph_data.length;
		1366
		1367	FT_MEM_ZERO( &inc_stream, sizeof ( inc_stream ) );
		1368	FT_Stream_OpenMemory( &inc_stream,
		1369	glyph_data.pointer, glyph_data.length );
		1370
		1371	loader->stream = &inc_stream;
		1372	}
		1373	else
		1374
		1375	#endif /* FT_CONFIG_OPTION_INCREMENTAL */
		1376
		1377	offset = tt_face_get_location( face, glyph_index,
		1378	(FT_UInt*)&loader->byte_len );
		1379
		1380	if ( loader->byte_len > 0 )
		1381	{
		1382	#ifdef FT_CONFIG_OPTION_INCREMENTAL
		1383	/* for the incremental interface, `glyf_offset' is always zero */
		1384	if ( !loader->glyf_offset &&
		1385	!face->root.internal->incremental_interface )
		1386	#else
		1387	if ( !loader->glyf_offset )
		1388	#endif /* FT_CONFIG_OPTION_INCREMENTAL */
		1389	{
		1390	FT_TRACE2(( "no `glyf' table but non-zero `loca' entry\n" ));
		1391	error = FT_THROW( Invalid_Table );
		1392	goto Exit;
		1393	}
		1394
		1395	error = face->access_glyph_frame( loader, glyph_index,
		1396	loader->glyf_offset + offset,
		1397	loader->byte_len );
		1398	if ( error )
		1399	goto Exit;
		1400
		1401	opened_frame = 1;
		1402
		1403	/* read glyph header first */
		1404	error = face->read_glyph_header( loader );
		1405	if ( error \|\| header_only )
		1406	goto Exit;
		1407	}
		1408
		1409	if ( loader->byte_len == 0 \|\| loader->n_contours == 0 )
		1410	{
		1411	loader->bbox.xMin = 0;
		1412	loader->bbox.xMax = 0;
		1413	loader->bbox.yMin = 0;
		1414	loader->bbox.yMax = 0;
		1415
		1416	if ( header_only )
		1417	goto Exit;
		1418
		1419	/* must initialize points before (possibly) overriding */
		1420	/* glyph metrics from the incremental interface */
		1421	TT_LOADER_SET_PP( loader );
		1422
		1423	#ifdef FT_CONFIG_OPTION_INCREMENTAL
		1424	tt_get_metrics_incr_overrides( loader, glyph_index );
		1425	#endif
		1426
		1427	#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
		1428
		1429	if ( ((TT_Face)(loader->face))->doblend )
		1430	{
		1431	/* this must be done before scaling */
		1432	FT_Memory memory = loader->face->memory;
		1433
		1434
		1435	error = TT_Vary_Get_Glyph_Deltas( (TT_Face)(loader->face),
		1436	glyph_index, &deltas, 4 );
		1437	if ( error )
		1438	goto Exit;
		1439
		1440	loader->pp1.x += deltas[0].x; loader->pp1.y += deltas[0].y;
		1441	loader->pp2.x += deltas[1].x; loader->pp2.y += deltas[1].y;
		1442	loader->pp3.x += deltas[2].x; loader->pp3.y += deltas[2].y;
		1443	loader->pp4.x += deltas[3].x; loader->pp4.y += deltas[3].y;
		1444
		1445	FT_FREE( deltas );
		1446	}
		1447
		1448	#endif
		1449
		1450	if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 )
		1451	{
		1452	loader->pp1.x = FT_MulFix( loader->pp1.x, x_scale );
		1453	loader->pp2.x = FT_MulFix( loader->pp2.x, x_scale );
		1454	loader->pp3.y = FT_MulFix( loader->pp3.y, y_scale );
		1455	loader->pp4.y = FT_MulFix( loader->pp4.y, y_scale );
		1456	}
		1457
		1458	error = FT_Err_Ok;
		1459	goto Exit;
		1460	}
		1461
		1462	/* must initialize points before (possibly) overriding */
		1463	/* glyph metrics from the incremental interface */
		1464	TT_LOADER_SET_PP( loader );
		1465
		1466	#ifdef FT_CONFIG_OPTION_INCREMENTAL
		1467	tt_get_metrics_incr_overrides( loader, glyph_index );
		1468	#endif
		1469
		1470	/***********************************************************************/
		1471	/***********************************************************************/
		1472	/***********************************************************************/
		1473
		1474	/* if it is a simple glyph, load it */
		1475
		1476	if ( loader->n_contours > 0 )
		1477	{
		1478	error = face->read_simple_glyph( loader );
		1479	if ( error )
		1480	goto Exit;
		1481
		1482	/* all data have been read */
		1483	face->forget_glyph_frame( loader );
		1484	opened_frame = 0;
		1485
		1486	error = TT_Process_Simple_Glyph( loader );
		1487	if ( error )
		1488	goto Exit;
		1489
		1490	FT_GlyphLoader_Add( gloader );
		1491	}
		1492
		1493	/***********************************************************************/
		1494	/***********************************************************************/
		1495	/***********************************************************************/
		1496
		1497	/* otherwise, load a composite! */
		1498	else if ( loader->n_contours == -1 )
		1499	{
		1500	FT_UInt start_point;
		1501	FT_UInt start_contour;
		1502	FT_ULong ins_pos; /* position of composite instructions, if any */
		1503
		1504
		1505	start_point = gloader->base.outline.n_points;
		1506	start_contour = gloader->base.outline.n_contours;
		1507
		1508	/* for each subglyph, read composite header */
		1509	error = face->read_composite_glyph( loader );
		1510	if ( error )
		1511	goto Exit;
		1512
		1513	/* store the offset of instructions */
		1514	ins_pos = loader->ins_pos;
		1515
		1516	/* all data we need are read */
		1517	face->forget_glyph_frame( loader );
		1518	opened_frame = 0;
		1519
		1520	#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
		1521
		1522	if ( face->doblend )
		1523	{
		1524	FT_Int i, limit;
		1525	FT_SubGlyph subglyph;
		1526	FT_Memory memory = face->root.memory;
		1527
		1528
		1529	/* this provides additional offsets */
		1530	/* for each component's translation */
		1531
		1532	if ( ( error = TT_Vary_Get_Glyph_Deltas(
		1533	face,
		1534	glyph_index,
		1535	&deltas,
		1536	gloader->current.num_subglyphs + 4 )) != 0 )
		1537	goto Exit;
		1538
		1539	subglyph = gloader->current.subglyphs + gloader->base.num_subglyphs;
		1540	limit = gloader->current.num_subglyphs;
		1541
		1542	for ( i = 0; i < limit; ++i, ++subglyph )
		1543	{
		1544	if ( subglyph->flags & ARGS_ARE_XY_VALUES )
		1545	{
		1546	/* XXX: overflow check for subglyph->{arg1,arg2}. */
		1547	/* deltas[i].{x,y} must be within signed 16-bit, */
		1548	/* but the restriction of summed delta is not clear */
		1549	subglyph->arg1 += (FT_Int16)deltas[i].x;
		1550	subglyph->arg2 += (FT_Int16)deltas[i].y;
		1551	}
		1552	}
		1553
		1554	loader->pp1.x += deltas[i + 0].x; loader->pp1.y += deltas[i + 0].y;
		1555	loader->pp2.x += deltas[i + 1].x; loader->pp2.y += deltas[i + 1].y;
		1556	loader->pp3.x += deltas[i + 2].x; loader->pp3.y += deltas[i + 2].y;
		1557	loader->pp4.x += deltas[i + 3].x; loader->pp4.y += deltas[i + 3].y;
		1558
		1559	FT_FREE( deltas );
		1560	}
		1561
		1562	#endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */
		1563
		1564	if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 )
		1565	{
		1566	loader->pp1.x = FT_MulFix( loader->pp1.x, x_scale );
		1567	loader->pp2.x = FT_MulFix( loader->pp2.x, x_scale );
		1568	loader->pp3.y = FT_MulFix( loader->pp3.y, y_scale );
		1569	loader->pp4.y = FT_MulFix( loader->pp4.y, y_scale );
		1570	}
		1571
		1572	/* if the flag FT_LOAD_NO_RECURSE is set, we return the subglyph */
		1573	/* `as is' in the glyph slot (the client application will be */
		1574	/* responsible for interpreting these data)... */
		1575	if ( loader->load_flags & FT_LOAD_NO_RECURSE )
		1576	{
		1577	FT_GlyphLoader_Add( gloader );
		1578	loader->glyph->format = FT_GLYPH_FORMAT_COMPOSITE;
		1579
		1580	goto Exit;
		1581	}
		1582
		1583	/*********************************************************************/
		1584	/*********************************************************************/
		1585	/*********************************************************************/
		1586
		1587	{
		1588	FT_UInt n, num_base_points;
		1589	FT_SubGlyph subglyph = 0;
		1590
		1591	FT_UInt num_points = start_point;
		1592	FT_UInt num_subglyphs = gloader->current.num_subglyphs;
		1593	FT_UInt num_base_subgs = gloader->base.num_subglyphs;
		1594
		1595	FT_Stream old_stream = loader->stream;
		1596	FT_Int old_byte_len = loader->byte_len;
		1597
		1598
		1599	FT_GlyphLoader_Add( gloader );
		1600
		1601	/* read each subglyph independently */
		1602	for ( n = 0; n < num_subglyphs; n++ )
		1603	{
		1604	FT_Vector pp[4];
		1605
		1606
		1607	/* Each time we call load_truetype_glyph in this loop, the */
		1608	/* value of `gloader.base.subglyphs' can change due to table */
		1609	/* reallocations. We thus need to recompute the subglyph */
		1610	/* pointer on each iteration. */
		1611	subglyph = gloader->base.subglyphs + num_base_subgs + n;
		1612
		1613	pp[0] = loader->pp1;
		1614	pp[1] = loader->pp2;
		1615	pp[2] = loader->pp3;
		1616	pp[3] = loader->pp4;
		1617
		1618	num_base_points = gloader->base.outline.n_points;
		1619
		1620	error = load_truetype_glyph( loader, subglyph->index,
		1621	recurse_count + 1, FALSE );
		1622	if ( error )
		1623	goto Exit;
		1624
		1625	/* restore subglyph pointer */
		1626	subglyph = gloader->base.subglyphs + num_base_subgs + n;
		1627
		1628	if ( !( subglyph->flags & USE_MY_METRICS ) )
		1629	{
		1630	loader->pp1 = pp[0];
		1631	loader->pp2 = pp[1];
		1632	loader->pp3 = pp[2];
		1633	loader->pp4 = pp[3];
		1634	}
		1635
		1636	num_points = gloader->base.outline.n_points;
		1637
		1638	if ( num_points == num_base_points )
		1639	continue;
		1640
		1641	/* gloader->base.outline consists of three parts: */
		1642	/* 0 -(1)-> start_point -(2)-> num_base_points -(3)-> n_points. */
		1643	/* */
		1644	/* (1): exists from the beginning */
		1645	/* (2): components that have been loaded so far */
		1646	/* (3): the newly loaded component */
		1647	TT_Process_Composite_Component( loader, subglyph, start_point,
		1648	num_base_points );
		1649	}
		1650
		1651	loader->stream = old_stream;
		1652	loader->byte_len = old_byte_len;
		1653
		1654	/* process the glyph */
		1655	loader->ins_pos = ins_pos;
		1656	if ( IS_HINTED( loader->load_flags ) &&
		1657
		1658	#ifdef TT_USE_BYTECODE_INTERPRETER
		1659
		1660	subglyph->flags & WE_HAVE_INSTR &&
		1661
		1662	#endif
		1663
		1664	num_points > start_point )
		1665	TT_Process_Composite_Glyph( loader, start_point, start_contour );
		1666
		1667	}
		1668	}
		1669	else
		1670	{
		1671	/* invalid composite count (negative but not -1) */
		1672	error = FT_THROW( Invalid_Outline );
		1673	goto Exit;
		1674	}
		1675
		1676	/***********************************************************************/
		1677	/***********************************************************************/
		1678	/***********************************************************************/
		1679
		1680	Exit:
		1681
		1682	if ( opened_frame )
		1683	face->forget_glyph_frame( loader );
		1684
		1685	#ifdef FT_CONFIG_OPTION_INCREMENTAL
		1686
		1687	if ( glyph_data_loaded )
		1688	face->root.internal->incremental_interface->funcs->free_glyph_data(
		1689	face->root.internal->incremental_interface->object,
		1690	&glyph_data );
		1691
		1692	#endif
		1693
		1694	return error;
		1695	}
		1696
		1697
		1698	static FT_Error
		1699	compute_glyph_metrics( TT_Loader loader,
		1700	FT_UInt glyph_index )
		1701	{
		1702	TT_Face face = (TT_Face)loader->face;
		1703	#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
		1704	TT_Driver driver = (TT_Driver)FT_FACE_DRIVER( face );
		1705	#endif
		1706
		1707	FT_BBox bbox;
		1708	FT_Fixed y_scale;
		1709	TT_GlyphSlot glyph = loader->glyph;
		1710	TT_Size size = (TT_Size)loader->size;
		1711
		1712
		1713	y_scale = 0x10000L;
		1714	if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 )
		1715	y_scale = size->root.metrics.y_scale;
		1716
		1717	if ( glyph->format != FT_GLYPH_FORMAT_COMPOSITE )
		1718	FT_Outline_Get_CBox( &glyph->outline, &bbox );
		1719	else
		1720	bbox = loader->bbox;
		1721
		1722	/* get the device-independent horizontal advance; it is scaled later */
		1723	/* by the base layer. */
		1724	glyph->linearHoriAdvance = loader->linear;
		1725
		1726	glyph->metrics.horiBearingX = bbox.xMin;
		1727	glyph->metrics.horiBearingY = bbox.yMax;
		1728	glyph->metrics.horiAdvance = loader->pp2.x - loader->pp1.x;
		1729
		1730	/* adjust advance width to the value contained in the hdmx table */
		1731	if ( !face->postscript.isFixedPitch &&
		1732	IS_HINTED( loader->load_flags ) )
		1733	{
		1734	FT_Byte* widthp;
		1735
		1736
		1737	widthp = tt_face_get_device_metrics( face,
		1738	size->root.metrics.x_ppem,
		1739	glyph_index );
		1740
		1741	#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
		1742
		1743	if ( driver->interpreter_version == TT_INTERPRETER_VERSION_38 )
		1744	{
		1745	FT_Bool ignore_x_mode;
		1746
		1747
		1748	ignore_x_mode = FT_BOOL( FT_LOAD_TARGET_MODE( loader->load_flags ) !=
		1749	FT_RENDER_MODE_MONO );
		1750
		1751	if ( widthp &&
		1752	( ( ignore_x_mode && loader->exec->compatible_widths ) \|\|
		1753	!ignore_x_mode \|\|
		1754	SPH_OPTION_BITMAP_WIDTHS ) )
		1755	glyph->metrics.horiAdvance = *widthp << 6;
		1756	}
		1757	else
		1758
		1759	#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
		1760
		1761	{
		1762	if ( widthp )
		1763	glyph->metrics.horiAdvance = *widthp << 6;
		1764	}
		1765	}
		1766
		1767	/* set glyph dimensions */
		1768	glyph->metrics.width = bbox.xMax - bbox.xMin;
		1769	glyph->metrics.height = bbox.yMax - bbox.yMin;
		1770
		1771	/* Now take care of vertical metrics. In the case where there is */
		1772	/* no vertical information within the font (relatively common), */
		1773	/* create some metrics manually */
		1774	{
		1775	FT_Pos top; /* scaled vertical top side bearing */
		1776	FT_Pos advance; /* scaled vertical advance height */
		1777
		1778
		1779	/* Get the unscaled top bearing and advance height. */
		1780	if ( face->vertical_info &&
		1781	face->vertical.number_Of_VMetrics > 0 )
		1782	{
		1783	top = (FT_Short)FT_DivFix( loader->pp3.y - bbox.yMax,
		1784	y_scale );
		1785
		1786	if ( loader->pp3.y <= loader->pp4.y )
		1787	advance = 0;
		1788	else
		1789	advance = (FT_UShort)FT_DivFix( loader->pp3.y - loader->pp4.y,
		1790	y_scale );
		1791	}
		1792	else
		1793	{
		1794	FT_Pos height;
		1795
		1796
		1797	/* XXX Compute top side bearing and advance height in */
		1798	/* Get_VMetrics instead of here. */
		1799
		1800	/* NOTE: The OS/2 values are the only `portable' ones, */
		1801	/* which is why we use them, if there is an OS/2 */
		1802	/* table in the font. Otherwise, we use the */
		1803	/* values defined in the horizontal header. */
		1804
		1805	height = (FT_Short)FT_DivFix( bbox.yMax - bbox.yMin,
		1806	y_scale );
		1807	if ( face->os2.version != 0xFFFFU )
		1808	advance = (FT_Pos)( face->os2.sTypoAscender -
		1809	face->os2.sTypoDescender );
		1810	else
		1811	advance = (FT_Pos)( face->horizontal.Ascender -
		1812	face->horizontal.Descender );
		1813
		1814	top = ( advance - height ) / 2;
		1815	}
		1816
		1817	#ifdef FT_CONFIG_OPTION_INCREMENTAL
		1818	{
		1819	FT_Incremental_InterfaceRec* incr;
		1820	FT_Incremental_MetricsRec metrics;
		1821	FT_Error error;
		1822
		1823
		1824	incr = face->root.internal->incremental_interface;
		1825
		1826	/* If this is an incrementally loaded font see if there are */
		1827	/* overriding metrics for this glyph. */
		1828	if ( incr && incr->funcs->get_glyph_metrics )
		1829	{
		1830	metrics.bearing_x = 0;
		1831	metrics.bearing_y = top;
		1832	metrics.advance = advance;
		1833
		1834	error = incr->funcs->get_glyph_metrics( incr->object,
		1835	glyph_index,
		1836	TRUE,
		1837	&metrics );
		1838	if ( error )
		1839	return error;
		1840
		1841	top = metrics.bearing_y;
		1842	advance = metrics.advance;
		1843	}
		1844	}
		1845
		1846	/* GWW: Do vertical metrics get loaded incrementally too? */
		1847
		1848	#endif /* FT_CONFIG_OPTION_INCREMENTAL */
		1849
		1850	glyph->linearVertAdvance = advance;
		1851
		1852	/* scale the metrics */
		1853	if ( !( loader->load_flags & FT_LOAD_NO_SCALE ) )
		1854	{
		1855	top = FT_MulFix( top, y_scale );
		1856	advance = FT_MulFix( advance, y_scale );
		1857	}
		1858
		1859	/* XXX: for now, we have no better algorithm for the lsb, but it */
		1860	/* should work fine. */
		1861	/* */
		1862	glyph->metrics.vertBearingX = glyph->metrics.horiBearingX -
		1863	glyph->metrics.horiAdvance / 2;
		1864	glyph->metrics.vertBearingY = top;
		1865	glyph->metrics.vertAdvance = advance;
		1866	}
		1867
		1868	return 0;
		1869	}
		1870
		1871
		1872	#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
		1873
		1874	static FT_Error
		1875	load_sbit_image( TT_Size size,
		1876	TT_GlyphSlot glyph,
		1877	FT_UInt glyph_index,
		1878	FT_Int32 load_flags )
		1879	{
		1880	TT_Face face;
		1881	SFNT_Service sfnt;
		1882	FT_Stream stream;
		1883	FT_Error error;
		1884	TT_SBit_MetricsRec metrics;
		1885
		1886
		1887	face = (TT_Face)glyph->face;
		1888	sfnt = (SFNT_Service)face->sfnt;
		1889	stream = face->root.stream;
		1890
		1891	error = sfnt->load_sbit_image( face,
		1892	size->strike_index,
		1893	glyph_index,
		1894	(FT_Int)load_flags,
		1895	stream,
		1896	&glyph->bitmap,
		1897	&metrics );
		1898	if ( !error )
		1899	{
		1900	glyph->outline.n_points = 0;
		1901	glyph->outline.n_contours = 0;
		1902
		1903	glyph->metrics.width = (FT_Pos)metrics.width << 6;
		1904	glyph->metrics.height = (FT_Pos)metrics.height << 6;
		1905
		1906	glyph->metrics.horiBearingX = (FT_Pos)metrics.horiBearingX << 6;
		1907	glyph->metrics.horiBearingY = (FT_Pos)metrics.horiBearingY << 6;
		1908	glyph->metrics.horiAdvance = (FT_Pos)metrics.horiAdvance << 6;
		1909
		1910	glyph->metrics.vertBearingX = (FT_Pos)metrics.vertBearingX << 6;
		1911	glyph->metrics.vertBearingY = (FT_Pos)metrics.vertBearingY << 6;
		1912	glyph->metrics.vertAdvance = (FT_Pos)metrics.vertAdvance << 6;
		1913
		1914	glyph->format = FT_GLYPH_FORMAT_BITMAP;
		1915
		1916	if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )
		1917	{
		1918	glyph->bitmap_left = metrics.vertBearingX;
		1919	glyph->bitmap_top = metrics.vertBearingY;
		1920	}
		1921	else
		1922	{
		1923	glyph->bitmap_left = metrics.horiBearingX;
		1924	glyph->bitmap_top = metrics.horiBearingY;
		1925	}
		1926	}
		1927
		1928	return error;
		1929	}
		1930
		1931	#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
		1932
		1933
		1934	static FT_Error
		1935	tt_loader_init( TT_Loader loader,
		1936	TT_Size size,
		1937	TT_GlyphSlot glyph,
		1938	FT_Int32 load_flags,
		1939	FT_Bool glyf_table_only )
		1940	{
		1941	TT_Face face;
		1942	FT_Stream stream;
		1943	#ifdef TT_USE_BYTECODE_INTERPRETER
		1944	FT_Bool pedantic = FT_BOOL( load_flags & FT_LOAD_PEDANTIC );
		1945	#endif
		1946
		1947
		1948	face = (TT_Face)glyph->face;
		1949	stream = face->root.stream;
		1950
		1951	FT_MEM_ZERO( loader, sizeof ( TT_LoaderRec ) );
		1952
		1953	#ifdef TT_USE_BYTECODE_INTERPRETER
		1954
		1955	/* load execution context */
		1956	if ( IS_HINTED( load_flags ) && !glyf_table_only )
		1957	{
		1958	TT_ExecContext exec;
		1959	FT_Bool grayscale;
		1960
		1961	#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
		1962	TT_Driver driver = (TT_Driver)FT_FACE_DRIVER( face );
		1963
		1964	FT_Bool subpixel_hinting = FALSE;
		1965	FT_Bool grayscale_hinting = TRUE;
		1966
		1967	#if 0
		1968	/* not used yet */
		1969	FT_Bool compatible_widths;
		1970	FT_Bool symmetrical_smoothing;
		1971	FT_Bool bgr;
		1972	FT_Bool subpixel_positioned;
		1973	#endif
		1974	#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
		1975
		1976	FT_Bool reexecute = FALSE;
		1977
		1978
		1979	if ( !size->cvt_ready )
		1980	{
		1981	FT_Error error = tt_size_ready_bytecode( size, pedantic );
		1982
		1983
		1984	if ( error )
		1985	return error;
		1986	}
		1987
		1988	/* query new execution context */
		1989	exec = size->debug ? size->context
		1990	: ( (TT_Driver)FT_FACE_DRIVER( face ) )->context;
		1991	if ( !exec )
		1992	return FT_THROW( Could_Not_Find_Context );
		1993
		1994	#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
		1995
		1996	if ( driver->interpreter_version == TT_INTERPRETER_VERSION_38 )
		1997	{
		1998	subpixel_hinting = FT_BOOL( ( FT_LOAD_TARGET_MODE( load_flags )
		1999	!= FT_RENDER_MODE_MONO ) &&
		2000	SPH_OPTION_SET_SUBPIXEL );
		2001
		2002	if ( subpixel_hinting )
		2003	grayscale = grayscale_hinting = FALSE;
		2004	else if ( SPH_OPTION_SET_GRAYSCALE )
		2005	{
		2006	grayscale = grayscale_hinting = TRUE;
		2007	subpixel_hinting = FALSE;
		2008	}
		2009	else
		2010	grayscale = grayscale_hinting = FALSE;
		2011
		2012	if ( FT_IS_TRICKY( glyph->face ) )
		2013	subpixel_hinting = grayscale_hinting = FALSE;
		2014
		2015	exec->ignore_x_mode = subpixel_hinting \|\| grayscale_hinting;
		2016	exec->rasterizer_version = SPH_OPTION_SET_RASTERIZER_VERSION;
		2017	if ( exec->sph_tweak_flags & SPH_TWEAK_RASTERIZER_35 )
		2018	exec->rasterizer_version = TT_INTERPRETER_VERSION_35;
		2019
		2020	#if 1
		2021	exec->compatible_widths = SPH_OPTION_SET_COMPATIBLE_WIDTHS;
		2022	exec->symmetrical_smoothing = FALSE;
		2023	exec->bgr = FALSE;
		2024	exec->subpixel_positioned = TRUE;
		2025	#else /* 0 */
		2026	exec->compatible_widths =
		2027	FT_BOOL( FT_LOAD_TARGET_MODE( load_flags ) !=
		2028	TT_LOAD_COMPATIBLE_WIDTHS );
		2029	exec->symmetrical_smoothing =
		2030	FT_BOOL( FT_LOAD_TARGET_MODE( load_flags ) !=
		2031	TT_LOAD_SYMMETRICAL_SMOOTHING );
		2032	exec->bgr =
		2033	FT_BOOL( FT_LOAD_TARGET_MODE( load_flags ) !=
		2034	TT_LOAD_BGR );
		2035	exec->subpixel_positioned =
		2036	FT_BOOL( FT_LOAD_TARGET_MODE( load_flags ) !=
		2037	TT_LOAD_SUBPIXEL_POSITIONED );
		2038	#endif /* 0 */
		2039
		2040	}
		2041	else
		2042
		2043	#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
		2044
		2045	{
		2046	grayscale = FT_BOOL( FT_LOAD_TARGET_MODE( load_flags ) !=
		2047	FT_RENDER_MODE_MONO );
		2048	}
		2049
		2050	TT_Load_Context( exec, face, size );
		2051
		2052	#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
		2053
		2054	if ( driver->interpreter_version == TT_INTERPRETER_VERSION_38 )
		2055	{
		2056	/* a change from mono to subpixel rendering (and vice versa) */
		2057	/* requires a re-execution of the CVT program */
		2058	if ( subpixel_hinting != exec->subpixel_hinting )
		2059	{
		2060	FT_TRACE4(( "tt_loader_init: subpixel hinting change,"
		2061	" re-executing `prep' table\n" ));
		2062
		2063	exec->subpixel_hinting = subpixel_hinting;
		2064	reexecute = TRUE;
		2065	}
		2066
		2067	/* a change from mono to grayscale rendering (and vice versa) */
		2068	/* requires a re-execution of the CVT program */
		2069	if ( grayscale != exec->grayscale_hinting )
		2070	{
		2071	FT_TRACE4(( "tt_loader_init: grayscale hinting change,"
		2072	" re-executing `prep' table\n" ));
		2073
		2074	exec->grayscale_hinting = grayscale_hinting;
		2075	reexecute = TRUE;
		2076	}
		2077	}
		2078	else
		2079
		2080	#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
		2081
		2082	{
		2083	/* a change from mono to grayscale rendering (and vice versa) */
		2084	/* requires a re-execution of the CVT program */
		2085	if ( grayscale != exec->grayscale )
		2086	{
		2087	FT_TRACE4(( "tt_loader_init: grayscale change,"
		2088	" re-executing `prep' table\n" ));
		2089
		2090	exec->grayscale = grayscale;
		2091	reexecute = TRUE;
		2092	}
		2093	}
		2094
		2095	if ( reexecute )
		2096	{
		2097	FT_UInt i;
		2098
		2099
		2100	for ( i = 0; i < size->cvt_size; i++ )
		2101	size->cvt[i] = FT_MulFix( face->cvt[i], size->ttmetrics.scale );
		2102	tt_size_run_prep( size, pedantic );
		2103	}
		2104
		2105	/* see whether the cvt program has disabled hinting */
		2106	if ( exec->GS.instruct_control & 1 )
		2107	load_flags \|= FT_LOAD_NO_HINTING;
		2108
		2109	/* load default graphics state -- if needed */
		2110	if ( exec->GS.instruct_control & 2 )
		2111	exec->GS = tt_default_graphics_state;
		2112
		2113	exec->pedantic_hinting = FT_BOOL( load_flags & FT_LOAD_PEDANTIC );
		2114	loader->exec = exec;
		2115	loader->instructions = exec->glyphIns;
		2116	}
		2117
		2118	#endif /* TT_USE_BYTECODE_INTERPRETER */
		2119
		2120	/* seek to the beginning of the glyph table -- for Type 42 fonts */
		2121	/* the table might be accessed from a Postscript stream or something */
		2122	/* else... */
		2123
		2124	#ifdef FT_CONFIG_OPTION_INCREMENTAL
		2125
		2126	if ( face->root.internal->incremental_interface )
		2127	loader->glyf_offset = 0;
		2128	else
		2129
		2130	#endif
		2131
		2132	{
		2133	FT_Error error = face->goto_table( face, TTAG_glyf, stream, 0 );
		2134
		2135
		2136	if ( FT_ERR_EQ( error, Table_Missing ) )
		2137	loader->glyf_offset = 0;
		2138	else if ( error )
		2139	{
		2140	FT_ERROR(( "tt_loader_init: could not access glyph table\n" ));
		2141	return error;
		2142	}
		2143	else
		2144	loader->glyf_offset = FT_STREAM_POS();
		2145	}
		2146
		2147	/* get face's glyph loader */
		2148	if ( !glyf_table_only )
		2149	{
		2150	FT_GlyphLoader gloader = glyph->internal->loader;
		2151
		2152
		2153	FT_GlyphLoader_Rewind( gloader );
		2154	loader->gloader = gloader;
		2155	}
		2156
		2157	loader->load_flags = load_flags;
		2158
		2159	loader->face = (FT_Face)face;
		2160	loader->size = (FT_Size)size;
		2161	loader->glyph = (FT_GlyphSlot)glyph;
		2162	loader->stream = stream;
		2163
		2164	return FT_Err_Ok;
		2165	}
		2166
		2167
		2168	/*************************************************************************/
		2169	/* */
		2170	/* */
		2171	/* TT_Load_Glyph */
		2172	/* */
		2173	/* */
		2174	/* A function used to load a single glyph within a given glyph slot, */
		2175	/* for a given size. */
		2176	/* */
		2177	/* */
		2178	/* glyph :: A handle to a target slot object where the glyph */
		2179	/* will be loaded. */
		2180	/* */
		2181	/* size :: A handle to the source face size at which the glyph */
		2182	/* must be scaled/loaded. */
		2183	/* */
		2184	/* glyph_index :: The index of the glyph in the font file. */
		2185	/* */
		2186	/* load_flags :: A flag indicating what to load for this glyph. The */
		2187	/* FT_LOAD_XXX constants can be used to control the */
		2188	/* glyph loading process (e.g., whether the outline */
		2189	/* should be scaled, whether to load bitmaps or not, */
		2190	/* whether to hint the outline, etc). */
		2191	/* */
		2192	/* */
		2193	/* FreeType error code. 0 means success. */
		2194	/* */
		2195	FT_LOCAL_DEF( FT_Error )
		2196	TT_Load_Glyph( TT_Size size,
		2197	TT_GlyphSlot glyph,
		2198	FT_UInt glyph_index,
		2199	FT_Int32 load_flags )
		2200	{
		2201	FT_Error error;
		2202	TT_LoaderRec loader;
		2203
		2204
		2205	error = FT_Err_Ok;
		2206
		2207	#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
		2208
		2209	/* try to load embedded bitmap if any */
		2210	/* */
		2211	/* XXX: The convention should be emphasized in */
		2212	/* the documents because it can be confusing. */
		2213	if ( size->strike_index != 0xFFFFFFFFUL &&
		2214	( load_flags & FT_LOAD_NO_BITMAP ) == 0 )
		2215	{
		2216	error = load_sbit_image( size, glyph, glyph_index, load_flags );
		2217	if ( !error )
		2218	{
		2219	if ( FT_IS_SCALABLE( glyph->face ) )
		2220	{
		2221	/* for the bbox we need the header only */
		2222	(void)tt_loader_init( &loader, size, glyph, load_flags, TRUE );
		2223	(void)load_truetype_glyph( &loader, glyph_index, 0, TRUE );
		2224	glyph->linearHoriAdvance = loader.linear;
		2225	glyph->linearVertAdvance = loader.top_bearing + loader.bbox.yMax -
		2226	loader.vadvance;
		2227
		2228	/* sanity check: if `horiAdvance' in the sbit metric */
		2229	/* structure isn't set, use `linearHoriAdvance' */
		2230	if ( !glyph->metrics.horiAdvance && glyph->linearHoriAdvance )
		2231	glyph->metrics.horiAdvance =
		2232	FT_MulFix( glyph->linearHoriAdvance,
		2233	size->root.metrics.x_scale );
		2234	}
		2235
		2236	return FT_Err_Ok;
		2237	}
		2238	}
		2239
		2240	#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
		2241
		2242	/* if FT_LOAD_NO_SCALE is not set, `ttmetrics' must be valid */
		2243	if ( !( load_flags & FT_LOAD_NO_SCALE ) && !size->ttmetrics.valid )
		2244	return FT_THROW( Invalid_Size_Handle );
		2245
		2246	if ( load_flags & FT_LOAD_SBITS_ONLY )
		2247	return FT_THROW( Invalid_Argument );
		2248
		2249	error = tt_loader_init( &loader, size, glyph, load_flags, FALSE );
		2250	if ( error )
		2251	return error;
		2252
		2253	glyph->format = FT_GLYPH_FORMAT_OUTLINE;
		2254	glyph->num_subglyphs = 0;
		2255	glyph->outline.flags = 0;
		2256
		2257	/* main loading loop */
		2258	error = load_truetype_glyph( &loader, glyph_index, 0, FALSE );
		2259	if ( !error )
		2260	{
		2261	if ( glyph->format == FT_GLYPH_FORMAT_COMPOSITE )
		2262	{
		2263	glyph->num_subglyphs = loader.gloader->base.num_subglyphs;
		2264	glyph->subglyphs = loader.gloader->base.subglyphs;
		2265	}
		2266	else
		2267	{
		2268	glyph->outline = loader.gloader->base.outline;
		2269	glyph->outline.flags &= ~FT_OUTLINE_SINGLE_PASS;
		2270
		2271	/* Translate array so that (0,0) is the glyph's origin. Note */
		2272	/* that this behaviour is independent on the value of bit 1 of */
		2273	/* the `flags' field in the `head' table -- at least major */
		2274	/* applications like Acroread indicate that. */
		2275	if ( loader.pp1.x )
		2276	FT_Outline_Translate( &glyph->outline, -loader.pp1.x, 0 );
		2277	}
		2278
		2279	#ifdef TT_USE_BYTECODE_INTERPRETER
		2280
		2281	if ( IS_HINTED( load_flags ) )
		2282	{
		2283	if ( loader.exec->GS.scan_control )
		2284	{
		2285	/* convert scan conversion mode to FT_OUTLINE_XXX flags */
		2286	switch ( loader.exec->GS.scan_type )
		2287	{
		2288	case 0: /* simple drop-outs including stubs */
		2289	glyph->outline.flags \|= FT_OUTLINE_INCLUDE_STUBS;
		2290	break;
		2291	case 1: /* simple drop-outs excluding stubs */
		2292	/* nothing; it's the default rendering mode */
		2293	break;
		2294	case 4: /* smart drop-outs including stubs */
		2295	glyph->outline.flags \|= FT_OUTLINE_SMART_DROPOUTS \|
		2296	FT_OUTLINE_INCLUDE_STUBS;
		2297	break;
		2298	case 5: /* smart drop-outs excluding stubs */
		2299	glyph->outline.flags \|= FT_OUTLINE_SMART_DROPOUTS;
		2300	break;
		2301
		2302	default: /* no drop-out control */
		2303	glyph->outline.flags \|= FT_OUTLINE_IGNORE_DROPOUTS;
		2304	break;
		2305	}
		2306	}
		2307	else
		2308	glyph->outline.flags \|= FT_OUTLINE_IGNORE_DROPOUTS;
		2309	}
		2310
		2311	#endif /* TT_USE_BYTECODE_INTERPRETER */
		2312
		2313	compute_glyph_metrics( &loader, glyph_index );
		2314	}
		2315
		2316	/* Set the `high precision' bit flag. */
		2317	/* This is _critical_ to get correct output for monochrome */
		2318	/* TrueType glyphs at all sizes using the bytecode interpreter. */
		2319	/* */
		2320	if ( !( load_flags & FT_LOAD_NO_SCALE ) &&
		2321	size->root.metrics.y_ppem < 24 )
		2322	glyph->outline.flags \|= FT_OUTLINE_HIGH_PRECISION;
		2323
		2324	return error;
		2325	}
		2326
		2327
		2328	/* END */

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/freetype/src/truetype/ttgload.c – Rev 8031