WebSVN – Kolibri OS – Blame – /programs/develop/libraries/freetype/src/sfnt/sfobjs.c

Rev	Author	Line No.	Line
3918	Serge	1	/***************************************************************************/
		2	/* */
		3	/* sfobjs.c */
		4	/* */
		5	/* SFNT object management (base). */
		6	/* */
		7	/* Copyright 1996-2008, 2010-2013 by */
		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 "sfobjs.h"
		21	#include "ttload.h"
		22	#include "ttcmap.h"
		23	#include "ttkern.h"
		24	#include FT_INTERNAL_SFNT_H
		25	#include FT_INTERNAL_DEBUG_H
		26	#include FT_TRUETYPE_IDS_H
		27	#include FT_TRUETYPE_TAGS_H
		28	#include FT_SERVICE_POSTSCRIPT_CMAPS_H
		29	#include FT_SFNT_NAMES_H
		30	#include "sferrors.h"
		31
		32	#ifdef TT_CONFIG_OPTION_BDF
		33	#include "ttbdf.h"
		34	#endif
		35
		36
		37	/*************************************************************************/
		38	/* */
		39	/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
		40	/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
		41	/* messages during execution. */
		42	/* */
		43	#undef FT_COMPONENT
		44	#define FT_COMPONENT trace_sfobjs
		45
		46
		47
		48	/* convert a UTF-16 name entry to ASCII */
		49	static FT_String*
		50	tt_name_entry_ascii_from_utf16( TT_NameEntry entry,
		51	FT_Memory memory )
		52	{
		53	FT_String* string = NULL;
		54	FT_UInt len, code, n;
		55	FT_Byte* read = (FT_Byte*)entry->string;
		56	FT_Error error;
		57
		58
		59	len = (FT_UInt)entry->stringLength / 2;
		60
		61	if ( FT_NEW_ARRAY( string, len + 1 ) )
		62	return NULL;
		63
		64	for ( n = 0; n < len; n++ )
		65	{
		66	code = FT_NEXT_USHORT( read );
		67
		68	if ( code == 0 )
		69	break;
		70
		71	if ( code < 32 \|\| code > 127 )
		72	code = '?';
		73
		74	string[n] = (char)code;
		75	}
		76
		77	string[n] = 0;
		78
		79	return string;
		80	}
		81
		82
		83	/* convert an Apple Roman or symbol name entry to ASCII */
		84	static FT_String*
		85	tt_name_entry_ascii_from_other( TT_NameEntry entry,
		86	FT_Memory memory )
		87	{
		88	FT_String* string = NULL;
		89	FT_UInt len, code, n;
		90	FT_Byte* read = (FT_Byte*)entry->string;
		91	FT_Error error;
		92
		93
		94	len = (FT_UInt)entry->stringLength;
		95
		96	if ( FT_NEW_ARRAY( string, len + 1 ) )
		97	return NULL;
		98
		99	for ( n = 0; n < len; n++ )
		100	{
		101	code = *read++;
		102
		103	if ( code == 0 )
		104	break;
		105
		106	if ( code < 32 \|\| code > 127 )
		107	code = '?';
		108
		109	string[n] = (char)code;
		110	}
		111
		112	string[n] = 0;
		113
		114	return string;
		115	}
		116
		117
		118	typedef FT_String* (*TT_NameEntry_ConvertFunc)( TT_NameEntry entry,
		119	FT_Memory memory );
		120
		121
		122	/*************************************************************************/
		123	/* */
		124	/* */
		125	/* tt_face_get_name */
		126	/* */
		127	/* */
		128	/* Returns a given ENGLISH name record in ASCII. */
		129	/* */
		130	/* */
		131	/* face :: A handle to the source face object. */
		132	/* */
		133	/* nameid :: The name id of the name record to return. */
		134	/* */
		135	/* */
		136	/* name :: The address of a string pointer. NULL if no name is */
		137	/* present. */
		138	/* */
		139	/* */
		140	/* FreeType error code. 0 means success. */
		141	/* */
		142	static FT_Error
		143	tt_face_get_name( TT_Face face,
		144	FT_UShort nameid,
		145	FT_String** name )
		146	{
		147	FT_Memory memory = face->root.memory;
		148	FT_Error error = FT_Err_Ok;
		149	FT_String* result = NULL;
		150	FT_UShort n;
		151	TT_NameEntryRec* rec;
		152	FT_Int found_apple = -1;
		153	FT_Int found_apple_roman = -1;
		154	FT_Int found_apple_english = -1;
		155	FT_Int found_win = -1;
		156	FT_Int found_unicode = -1;
		157
		158	FT_Bool is_english = 0;
		159
		160	TT_NameEntry_ConvertFunc convert;
		161
		162
		163	FT_ASSERT( name );
		164
		165	rec = face->name_table.names;
		166	for ( n = 0; n < face->num_names; n++, rec++ )
		167	{
		168	/* According to the OpenType 1.3 specification, only Microsoft or */
		169	/* Apple platform IDs might be used in the `name' table. The */
		170	/* `Unicode' platform is reserved for the `cmap' table, and the */
		171	/* `ISO' one is deprecated. */
		172	/* */
		173	/* However, the Apple TrueType specification doesn't say the same */
		174	/* thing and goes to suggest that all Unicode `name' table entries */
		175	/* should be coded in UTF-16 (in big-endian format I suppose). */
		176	/* */
		177	if ( rec->nameID == nameid && rec->stringLength > 0 )
		178	{
		179	switch ( rec->platformID )
		180	{
		181	case TT_PLATFORM_APPLE_UNICODE:
		182	case TT_PLATFORM_ISO:
		183	/* there is `languageID' to check there. We should use this */
		184	/* field only as a last solution when nothing else is */
		185	/* available. */
		186	/* */
		187	found_unicode = n;
		188	break;
		189
		190	case TT_PLATFORM_MACINTOSH:
		191	/* This is a bit special because some fonts will use either */
		192	/* an English language id, or a Roman encoding id, to indicate */
		193	/* the English version of its font name. */
		194	/* */
		195	if ( rec->languageID == TT_MAC_LANGID_ENGLISH )
		196	found_apple_english = n;
		197	else if ( rec->encodingID == TT_MAC_ID_ROMAN )
		198	found_apple_roman = n;
		199	break;
		200
		201	case TT_PLATFORM_MICROSOFT:
		202	/* we only take a non-English name when there is nothing */
		203	/* else available in the font */
		204	/* */
		205	if ( found_win == -1 \|\| ( rec->languageID & 0x3FF ) == 0x009 )
		206	{
		207	switch ( rec->encodingID )
		208	{
		209	case TT_MS_ID_SYMBOL_CS:
		210	case TT_MS_ID_UNICODE_CS:
		211	case TT_MS_ID_UCS_4:
		212	is_english = FT_BOOL( ( rec->languageID & 0x3FF ) == 0x009 );
		213	found_win = n;
		214	break;
		215
		216	default:
		217	;
		218	}
		219	}
		220	break;
		221
		222	default:
		223	;
		224	}
		225	}
		226	}
		227
		228	found_apple = found_apple_roman;
		229	if ( found_apple_english >= 0 )
		230	found_apple = found_apple_english;
		231
		232	/* some fonts contain invalid Unicode or Macintosh formatted entries; */
		233	/* we will thus favor names encoded in Windows formats if available */
		234	/* (provided it is an English name) */
		235	/* */
		236	convert = NULL;
		237	if ( found_win >= 0 && !( found_apple >= 0 && !is_english ) )
		238	{
		239	rec = face->name_table.names + found_win;
		240	switch ( rec->encodingID )
		241	{
		242	/* all Unicode strings are encoded using UTF-16BE */
		243	case TT_MS_ID_UNICODE_CS:
		244	case TT_MS_ID_SYMBOL_CS:
		245	convert = tt_name_entry_ascii_from_utf16;
		246	break;
		247
		248	case TT_MS_ID_UCS_4:
		249	/* Apparently, if this value is found in a name table entry, it is */
		250	/* documented as `full Unicode repertoire'. Experience with the */
		251	/* MsGothic font shipped with Windows Vista shows that this really */
		252	/* means UTF-16 encoded names (UCS-4 values are only used within */
		253	/* charmaps). */
		254	convert = tt_name_entry_ascii_from_utf16;
		255	break;
		256
		257	default:
		258	;
		259	}
		260	}
		261	else if ( found_apple >= 0 )
		262	{
		263	rec = face->name_table.names + found_apple;
		264	convert = tt_name_entry_ascii_from_other;
		265	}
		266	else if ( found_unicode >= 0 )
		267	{
		268	rec = face->name_table.names + found_unicode;
		269	convert = tt_name_entry_ascii_from_utf16;
		270	}
		271
		272	if ( rec && convert )
		273	{
		274	if ( rec->string == NULL )
		275	{
		276	FT_Stream stream = face->name_table.stream;
		277
		278
		279	if ( FT_QNEW_ARRAY ( rec->string, rec->stringLength ) \|\|
		280	FT_STREAM_SEEK( rec->stringOffset ) \|\|
		281	FT_STREAM_READ( rec->string, rec->stringLength ) )
		282	{
		283	FT_FREE( rec->string );
		284	rec->stringLength = 0;
		285	result = NULL;
		286	goto Exit;
		287	}
		288	}
		289
		290	result = convert( rec, memory );
		291	}
		292
		293	Exit:
		294	*name = result;
		295	return error;
		296	}
		297
		298
		299	static FT_Encoding
		300	sfnt_find_encoding( int platform_id,
		301	int encoding_id )
		302	{
		303	typedef struct TEncoding_
		304	{
		305	int platform_id;
		306	int encoding_id;
		307	FT_Encoding encoding;
		308
		309	} TEncoding;
		310
		311	static
		312	const TEncoding tt_encodings[] =
		313	{
		314	{ TT_PLATFORM_ISO, -1, FT_ENCODING_UNICODE },
		315
		316	{ TT_PLATFORM_APPLE_UNICODE, -1, FT_ENCODING_UNICODE },
		317
		318	{ TT_PLATFORM_MACINTOSH, TT_MAC_ID_ROMAN, FT_ENCODING_APPLE_ROMAN },
		319
		320	{ TT_PLATFORM_MICROSOFT, TT_MS_ID_SYMBOL_CS, FT_ENCODING_MS_SYMBOL },
		321	{ TT_PLATFORM_MICROSOFT, TT_MS_ID_UCS_4, FT_ENCODING_UNICODE },
		322	{ TT_PLATFORM_MICROSOFT, TT_MS_ID_UNICODE_CS, FT_ENCODING_UNICODE },
		323	{ TT_PLATFORM_MICROSOFT, TT_MS_ID_SJIS, FT_ENCODING_SJIS },
		324	{ TT_PLATFORM_MICROSOFT, TT_MS_ID_GB2312, FT_ENCODING_GB2312 },
		325	{ TT_PLATFORM_MICROSOFT, TT_MS_ID_BIG_5, FT_ENCODING_BIG5 },
		326	{ TT_PLATFORM_MICROSOFT, TT_MS_ID_WANSUNG, FT_ENCODING_WANSUNG },
		327	{ TT_PLATFORM_MICROSOFT, TT_MS_ID_JOHAB, FT_ENCODING_JOHAB }
		328	};
		329
		330	const TEncoding cur, limit;
		331
		332
		333	cur = tt_encodings;
		334	limit = cur + sizeof ( tt_encodings ) / sizeof ( tt_encodings[0] );
		335
		336	for ( ; cur < limit; cur++ )
		337	{
		338	if ( cur->platform_id == platform_id )
		339	{
		340	if ( cur->encoding_id == encoding_id \|\|
		341	cur->encoding_id == -1 )
		342	return cur->encoding;
		343	}
		344	}
		345
		346	return FT_ENCODING_NONE;
		347	}
		348
		349
		350	/* Fill in face->ttc_header. If the font is not a TTC, it is */
		351	/* synthesized into a TTC with one offset table. */
		352	static FT_Error
		353	sfnt_open_font( FT_Stream stream,
		354	TT_Face face )
		355	{
		356	FT_Memory memory = stream->memory;
		357	FT_Error error;
		358	FT_ULong tag, offset;
		359
		360	static const FT_Frame_Field ttc_header_fields[] =
		361	{
		362	#undef FT_STRUCTURE
		363	#define FT_STRUCTURE TTC_HeaderRec
		364
		365	FT_FRAME_START( 8 ),
		366	FT_FRAME_LONG( version ),
		367	FT_FRAME_LONG( count ), /* this is ULong in the specs */
		368	FT_FRAME_END
		369	};
		370
		371
		372	face->ttc_header.tag = 0;
		373	face->ttc_header.version = 0;
		374	face->ttc_header.count = 0;
		375
		376	offset = FT_STREAM_POS();
		377
		378	if ( FT_READ_ULONG( tag ) )
		379	return error;
		380
		381	if ( tag != 0x00010000UL &&
		382	tag != TTAG_ttcf &&
		383	tag != TTAG_OTTO &&
		384	tag != TTAG_true &&
		385	tag != TTAG_typ1 &&
		386	tag != 0x00020000UL )
		387	{
		388	FT_TRACE2(( " not a font using the SFNT container format\n" ));
		389	return FT_THROW( Unknown_File_Format );
		390	}
		391
		392	face->ttc_header.tag = TTAG_ttcf;
		393
		394	if ( tag == TTAG_ttcf )
		395	{
		396	FT_Int n;
		397
		398
		399	FT_TRACE3(( "sfnt_open_font: file is a collection\n" ));
		400
		401	if ( FT_STREAM_READ_FIELDS( ttc_header_fields, &face->ttc_header ) )
		402	return error;
		403
		404	if ( face->ttc_header.count == 0 )
		405	return FT_THROW( Invalid_Table );
		406
		407	/* a rough size estimate: let's conservatively assume that there */
		408	/* is just a single table info in each subfont header (12 + 161 = /
		409	/* 28 bytes), thus we have (at least) `12 + 4count' bytes for the /
		410	/* size of the TTC header plus `28count' bytes for all subfont /
		411	/* headers */
		412	if ( (FT_ULong)face->ttc_header.count > stream->size / ( 28 + 4 ) )
		413	return FT_THROW( Array_Too_Large );
		414
		415	/* now read the offsets of each font in the file */
		416	if ( FT_NEW_ARRAY( face->ttc_header.offsets, face->ttc_header.count ) )
		417	return error;
		418
		419	if ( FT_FRAME_ENTER( face->ttc_header.count * 4L ) )
		420	return error;
		421
		422	for ( n = 0; n < face->ttc_header.count; n++ )
		423	face->ttc_header.offsets[n] = FT_GET_ULONG();
		424
		425	FT_FRAME_EXIT();
		426	}
		427	else
		428	{
		429	FT_TRACE3(( "sfnt_open_font: synthesize TTC\n" ));
		430
		431	face->ttc_header.version = 1 << 16;
		432	face->ttc_header.count = 1;
		433
		434	if ( FT_NEW( face->ttc_header.offsets ) )
		435	return error;
		436
		437	face->ttc_header.offsets[0] = offset;
		438	}
		439
		440	return error;
		441	}
		442
		443
		444	FT_LOCAL_DEF( FT_Error )
		445	sfnt_init_face( FT_Stream stream,
		446	TT_Face face,
		447	FT_Int face_index,
		448	FT_Int num_params,
		449	FT_Parameter* params )
		450	{
		451	FT_Error error;
		452	FT_Library library = face->root.driver->root.library;
		453	SFNT_Service sfnt;
		454
		455
		456	/* for now, parameters are unused */
		457	FT_UNUSED( num_params );
		458	FT_UNUSED( params );
		459
		460
		461	sfnt = (SFNT_Service)face->sfnt;
		462	if ( !sfnt )
		463	{
		464	sfnt = (SFNT_Service)FT_Get_Module_Interface( library, "sfnt" );
		465	if ( !sfnt )
		466	{
		467	FT_ERROR(( "sfnt_init_face: cannot access `sfnt' module\n" ));
		468	return FT_THROW( Missing_Module );
		469	}
		470
		471	face->sfnt = sfnt;
		472	face->goto_table = sfnt->goto_table;
		473	}
		474
		475	FT_FACE_FIND_GLOBAL_SERVICE( face, face->psnames, POSTSCRIPT_CMAPS );
		476
		477	FT_TRACE2(( "SFNT driver\n" ));
		478
		479	error = sfnt_open_font( stream, face );
		480	if ( error )
		481	return error;
		482
		483	FT_TRACE2(( "sfnt_init_face: %08p, %ld\n", face, face_index ));
		484
		485	if ( face_index < 0 )
		486	face_index = 0;
		487
		488	if ( face_index >= face->ttc_header.count )
		489	return FT_THROW( Invalid_Argument );
		490
		491	if ( FT_STREAM_SEEK( face->ttc_header.offsets[face_index] ) )
		492	return error;
		493
		494	/* check that we have a valid TrueType file */
		495	error = sfnt->load_font_dir( face, stream );
		496	if ( error )
		497	return error;
		498
		499	face->root.num_faces = face->ttc_header.count;
		500	face->root.face_index = face_index;
		501
		502	return error;
		503	}
		504
		505
		506	#define LOAD_( x ) \
		507	do { \
		508	FT_TRACE2(( "`" #x "' " )); \
		509	FT_TRACE3(( "-->\n" )); \
		510	\
		511	error = sfnt->load_ ## x( face, stream ); \
		512	\
		513	FT_TRACE2(( "%s\n", ( !error ) \
		514	? "loaded" \
		515	: FT_ERR_EQ( error, Table_Missing ) \
		516	? "missing" \
		517	: "failed to load" )); \
		518	FT_TRACE3(( "\n" )); \
		519	} while ( 0 )
		520
		521	#define LOADM_( x, vertical ) \
		522	do { \
		523	FT_TRACE2(( "`%s" #x "' ", \
		524	vertical ? "vertical " : "" )); \
		525	FT_TRACE3(( "-->\n" )); \
		526	\
		527	error = sfnt->load_ ## x( face, stream, vertical ); \
		528	\
		529	FT_TRACE2(( "%s\n", ( !error ) \
		530	? "loaded" \
		531	: FT_ERR_EQ( error, Table_Missing ) \
		532	? "missing" \
		533	: "failed to load" )); \
		534	FT_TRACE3(( "\n" )); \
		535	} while ( 0 )
		536
		537	#define GET_NAME( id, field ) \
		538	do { \
		539	error = tt_face_get_name( face, TT_NAME_ID_ ## id, field ); \
		540	if ( error ) \
		541	goto Exit; \
		542	} while ( 0 )
		543
		544
		545	FT_LOCAL_DEF( FT_Error )
		546	sfnt_load_face( FT_Stream stream,
		547	TT_Face face,
		548	FT_Int face_index,
		549	FT_Int num_params,
		550	FT_Parameter* params )
		551	{
		552	FT_Error error;
		553	#ifdef TT_CONFIG_OPTION_POSTSCRIPT_NAMES
		554	FT_Error psnames_error;
		555	#endif
		556	FT_Bool has_outline;
		557	FT_Bool is_apple_sbit;
		558	FT_Bool ignore_preferred_family = FALSE;
		559	FT_Bool ignore_preferred_subfamily = FALSE;
		560
		561	SFNT_Service sfnt = (SFNT_Service)face->sfnt;
		562
		563	FT_UNUSED( face_index );
		564
		565
		566	/* Check parameters */
		567
		568	{
		569	FT_Int i;
		570
		571
		572	for ( i = 0; i < num_params; i++ )
		573	{
		574	if ( params[i].tag == FT_PARAM_TAG_IGNORE_PREFERRED_FAMILY )
		575	ignore_preferred_family = TRUE;
		576	else if ( params[i].tag == FT_PARAM_TAG_IGNORE_PREFERRED_SUBFAMILY )
		577	ignore_preferred_subfamily = TRUE;
		578	}
		579	}
		580
		581	/* Load tables */
		582
		583	/* We now support two SFNT-based bitmapped font formats. They */
		584	/* are recognized easily as they do not include a `glyf' */
		585	/* table. */
		586	/* */
		587	/* The first format comes from Apple, and uses a table named */
		588	/* `bhed' instead of `head' to store the font header (using */
		589	/* the same format). It also doesn't include horizontal and */
		590	/* vertical metrics tables (i.e. `hhea' and `vhea' tables are */
		591	/* missing). */
		592	/* */
		593	/* The other format comes from Microsoft, and is used with */
		594	/* WinCE/PocketPC. It looks like a standard TTF, except that */
		595	/* it doesn't contain outlines. */
		596	/* */
		597
		598	FT_TRACE2(( "sfnt_load_face: %08p\n\n", face ));
		599
		600	/* do we have outlines in there? */
		601	#ifdef FT_CONFIG_OPTION_INCREMENTAL
		602	has_outline = FT_BOOL( face->root.internal->incremental_interface != 0 \|\|
		603	tt_face_lookup_table( face, TTAG_glyf ) != 0 \|\|
		604	tt_face_lookup_table( face, TTAG_CFF ) != 0 );
		605	#else
		606	has_outline = FT_BOOL( tt_face_lookup_table( face, TTAG_glyf ) != 0 \|\|
		607	tt_face_lookup_table( face, TTAG_CFF ) != 0 );
		608	#endif
		609
		610	is_apple_sbit = 0;
		611
		612	/* if this font doesn't contain outlines, we try to load */
		613	/* a `bhed' table */
		614	if ( !has_outline && sfnt->load_bhed )
		615	{
		616	LOAD_( bhed );
		617	is_apple_sbit = FT_BOOL( !error );
		618	}
		619
		620	/* load the font header (`head' table) if this isn't an Apple */
		621	/* sbit font file */
		622	if ( !is_apple_sbit )
		623	{
		624	LOAD_( head );
		625	if ( error )
		626	goto Exit;
		627	}
		628
		629	if ( face->header.Units_Per_EM == 0 )
		630	{
		631	error = FT_THROW( Invalid_Table );
		632
		633	goto Exit;
		634	}
		635
		636	/* the following tables are often not present in embedded TrueType */
		637	/* fonts within PDF documents, so don't check for them. */
		638	LOAD_( maxp );
		639	LOAD_( cmap );
		640
		641	/* the following tables are optional in PCL fonts -- */
		642	/* don't check for errors */
		643	LOAD_( name );
		644	LOAD_( post );
		645
		646	#ifdef TT_CONFIG_OPTION_POSTSCRIPT_NAMES
		647	psnames_error = error;
		648	#endif
		649
		650	/* do not load the metrics headers and tables if this is an Apple */
		651	/* sbit font file */
		652	if ( !is_apple_sbit )
		653	{
		654	/* load the `hhea' and `hmtx' tables */
		655	LOADM_( hhea, 0 );
		656	if ( !error )
		657	{
		658	LOADM_( hmtx, 0 );
		659	if ( FT_ERR_EQ( error, Table_Missing ) )
		660	{
		661	error = FT_THROW( Hmtx_Table_Missing );
		662
		663	#ifdef FT_CONFIG_OPTION_INCREMENTAL
		664	/* If this is an incrementally loaded font and there are */
		665	/* overriding metrics, tolerate a missing `hmtx' table. */
		666	if ( face->root.internal->incremental_interface &&
		667	face->root.internal->incremental_interface->funcs->
		668	get_glyph_metrics )
		669	{
		670	face->horizontal.number_Of_HMetrics = 0;
		671	error = FT_Err_Ok;
		672	}
		673	#endif
		674	}
		675	}
		676	else if ( FT_ERR_EQ( error, Table_Missing ) )
		677	{
		678	/* No `hhea' table necessary for SFNT Mac fonts. */
		679	if ( face->format_tag == TTAG_true )
		680	{
		681	FT_TRACE2(( "This is an SFNT Mac font.\n" ));
		682
		683	has_outline = 0;
		684	error = FT_Err_Ok;
		685	}
		686	else
		687	{
		688	error = FT_THROW( Horiz_Header_Missing );
		689
		690	#ifdef FT_CONFIG_OPTION_INCREMENTAL
		691	/* If this is an incrementally loaded font and there are */
		692	/* overriding metrics, tolerate a missing `hhea' table. */
		693	if ( face->root.internal->incremental_interface &&
		694	face->root.internal->incremental_interface->funcs->
		695	get_glyph_metrics )
		696	{
		697	face->horizontal.number_Of_HMetrics = 0;
		698	error = FT_Err_Ok;
		699	}
		700	#endif
		701
		702	}
		703	}
		704
		705	if ( error )
		706	goto Exit;
		707
		708	/* try to load the `vhea' and `vmtx' tables */
		709	LOADM_( hhea, 1 );
		710	if ( !error )
		711	{
		712	LOADM_( hmtx, 1 );
		713	if ( !error )
		714	face->vertical_info = 1;
		715	}
		716
		717	if ( error && FT_ERR_NEQ( error, Table_Missing ) )
		718	goto Exit;
		719
		720	LOAD_( os2 );
		721	if ( error )
		722	{
		723	/* we treat the table as missing if there are any errors */
		724	face->os2.version = 0xFFFFU;
		725	}
		726	}
		727
		728	/* the optional tables */
		729
		730	/* embedded bitmap support */
		731	if ( sfnt->load_eblc )
		732	{
		733	LOAD_( eblc );
		734	if ( error )
		735	{
		736	/* a font which contains neither bitmaps nor outlines is */
		737	/* still valid (although rather useless in most cases); */
		738	/* however, you can find such stripped fonts in PDFs */
		739	if ( FT_ERR_EQ( error, Table_Missing ) )
		740	error = FT_Err_Ok;
		741	else
		742	goto Exit;
		743	}
		744	}
		745
		746	LOAD_( pclt );
		747	if ( error )
		748	{
		749	if ( FT_ERR_NEQ( error, Table_Missing ) )
		750	goto Exit;
		751
		752	face->pclt.Version = 0;
		753	}
		754
		755	/* consider the kerning and gasp tables as optional */
		756	LOAD_( gasp );
		757	LOAD_( kern );
		758
		759	face->root.num_glyphs = face->max_profile.numGlyphs;
		760
		761	/* Bit 8 of the `fsSelection' field in the `OS/2' table denotes */
		762	/* a WWS-only font face. `WWS' stands for `weight', width', and */
		763	/* `slope', a term used by Microsoft's Windows Presentation */
		764	/* Foundation (WPF). This flag has been introduced in version */
		765	/* 1.5 of the OpenType specification (May 2008). */
		766
		767	face->root.family_name = NULL;
		768	face->root.style_name = NULL;
		769	if ( face->os2.version != 0xFFFFU && face->os2.fsSelection & 256 )
		770	{
		771	if ( !ignore_preferred_family )
		772	GET_NAME( PREFERRED_FAMILY, &face->root.family_name );
		773	if ( !face->root.family_name )
		774	GET_NAME( FONT_FAMILY, &face->root.family_name );
		775
		776	if ( !ignore_preferred_subfamily )
		777	GET_NAME( PREFERRED_SUBFAMILY, &face->root.style_name );
		778	if ( !face->root.style_name )
		779	GET_NAME( FONT_SUBFAMILY, &face->root.style_name );
		780	}
		781	else
		782	{
		783	GET_NAME( WWS_FAMILY, &face->root.family_name );
		784	if ( !face->root.family_name && !ignore_preferred_family )
		785	GET_NAME( PREFERRED_FAMILY, &face->root.family_name );
		786	if ( !face->root.family_name )
		787	GET_NAME( FONT_FAMILY, &face->root.family_name );
		788
		789	GET_NAME( WWS_SUBFAMILY, &face->root.style_name );
		790	if ( !face->root.style_name && !ignore_preferred_subfamily )
		791	GET_NAME( PREFERRED_SUBFAMILY, &face->root.style_name );
		792	if ( !face->root.style_name )
		793	GET_NAME( FONT_SUBFAMILY, &face->root.style_name );
		794	}
		795
		796	/* now set up root fields */
		797	{
		798	FT_Face root = &face->root;
		799	FT_Long flags = root->face_flags;
		800
		801
		802	/*********************************************************************/
		803	/* */
		804	/* Compute face flags. */
		805	/* */
		806	if ( has_outline == TRUE )
		807	flags \|= FT_FACE_FLAG_SCALABLE; /* scalable outlines */
		808
		809	/* The sfnt driver only supports bitmap fonts natively, thus we */
		810	/* don't set FT_FACE_FLAG_HINTER. */
		811	flags \|= FT_FACE_FLAG_SFNT \| /* SFNT file format */
		812	FT_FACE_FLAG_HORIZONTAL; /* horizontal data */
		813
		814	#ifdef TT_CONFIG_OPTION_POSTSCRIPT_NAMES
		815	if ( !psnames_error &&
		816	face->postscript.FormatType != 0x00030000L )
		817	flags \|= FT_FACE_FLAG_GLYPH_NAMES;
		818	#endif
		819
		820	/* fixed width font? */
		821	if ( face->postscript.isFixedPitch )
		822	flags \|= FT_FACE_FLAG_FIXED_WIDTH;
		823
		824	/* vertical information? */
		825	if ( face->vertical_info )
		826	flags \|= FT_FACE_FLAG_VERTICAL;
		827
		828	/* kerning available ? */
		829	if ( TT_FACE_HAS_KERNING( face ) )
		830	flags \|= FT_FACE_FLAG_KERNING;
		831
		832	#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
		833	/* Don't bother to load the tables unless somebody asks for them. */
		834	/* No need to do work which will (probably) not be used. */
		835	if ( tt_face_lookup_table( face, TTAG_glyf ) != 0 &&
		836	tt_face_lookup_table( face, TTAG_fvar ) != 0 &&
		837	tt_face_lookup_table( face, TTAG_gvar ) != 0 )
		838	flags \|= FT_FACE_FLAG_MULTIPLE_MASTERS;
		839	#endif
		840
		841	root->face_flags = flags;
		842
		843	/*********************************************************************/
		844	/* */
		845	/* Compute style flags. */
		846	/* */
		847
		848	flags = 0;
		849	if ( has_outline == TRUE && face->os2.version != 0xFFFFU )
		850	{
		851	/* We have an OS/2 table; use the `fsSelection' field. Bit 9 */
		852	/* indicates an oblique font face. This flag has been */
		853	/* introduced in version 1.5 of the OpenType specification. */
		854
		855	if ( face->os2.fsSelection & 512 ) /* bit 9 */
		856	flags \|= FT_STYLE_FLAG_ITALIC;
		857	else if ( face->os2.fsSelection & 1 ) /* bit 0 */
		858	flags \|= FT_STYLE_FLAG_ITALIC;
		859
		860	if ( face->os2.fsSelection & 32 ) /* bit 5 */
		861	flags \|= FT_STYLE_FLAG_BOLD;
		862	}
		863	else
		864	{
		865	/* this is an old Mac font, use the header field */
		866
		867	if ( face->header.Mac_Style & 1 )
		868	flags \|= FT_STYLE_FLAG_BOLD;
		869
		870	if ( face->header.Mac_Style & 2 )
		871	flags \|= FT_STYLE_FLAG_ITALIC;
		872	}
		873
		874	root->style_flags = flags;
		875
		876	/*********************************************************************/
		877	/* */
		878	/* Polish the charmaps. */
		879	/* */
		880	/* Try to set the charmap encoding according to the platform & */
		881	/* encoding ID of each charmap. */
		882	/* */
		883
		884	tt_face_build_cmaps( face ); /* ignore errors */
		885
		886
		887	/* set the encoding fields */
		888	{
		889	FT_Int m;
		890
		891
		892	for ( m = 0; m < root->num_charmaps; m++ )
		893	{
		894	FT_CharMap charmap = root->charmaps[m];
		895
		896
		897	charmap->encoding = sfnt_find_encoding( charmap->platform_id,
		898	charmap->encoding_id );
		899
		900	#if 0
		901	if ( root->charmap == NULL &&
		902	charmap->encoding == FT_ENCODING_UNICODE )
		903	{
		904	/* set 'root->charmap' to the first Unicode encoding we find */
		905	root->charmap = charmap;
		906	}
		907	#endif
		908	}
		909	}
		910
		911	#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
		912
		913	/*
		914	* Now allocate the root array of FT_Bitmap_Size records and
		915	* populate them. Unfortunately, it isn't possible to indicate bit
		916	* depths in the FT_Bitmap_Size record. This is a design error.
		917	*/
		918	{
		919	FT_UInt i, count;
		920
		921
		922	count = face->sbit_num_strikes;
		923
		924	if ( count > 0 )
		925	{
		926	FT_Memory memory = face->root.stream->memory;
		927	FT_UShort em_size = face->header.Units_Per_EM;
		928	FT_Short avgwidth = face->os2.xAvgCharWidth;
		929	FT_Size_Metrics metrics;
		930
		931
		932	if ( em_size == 0 \|\| face->os2.version == 0xFFFFU )
		933	{
		934	avgwidth = 0;
		935	em_size = 1;
		936	}
		937
		938	if ( FT_NEW_ARRAY( root->available_sizes, count ) )
		939	goto Exit;
		940
		941	for ( i = 0; i < count; i++ )
		942	{
		943	FT_Bitmap_Size* bsize = root->available_sizes + i;
		944
		945
		946	error = sfnt->load_strike_metrics( face, i, &metrics );
		947	if ( error )
		948	goto Exit;
		949
		950	bsize->height = (FT_Short)( metrics.height >> 6 );
		951	bsize->width = (FT_Short)(
		952	( avgwidth * metrics.x_ppem + em_size / 2 ) / em_size );
		953
		954	bsize->x_ppem = metrics.x_ppem << 6;
		955	bsize->y_ppem = metrics.y_ppem << 6;
		956
		957	/* assume 72dpi */
		958	bsize->size = metrics.y_ppem << 6;
		959	}
		960
		961	root->face_flags \|= FT_FACE_FLAG_FIXED_SIZES;
		962	root->num_fixed_sizes = (FT_Int)count;
		963	}
		964	}
		965
		966	#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
		967
		968	/* a font with no bitmaps and no outlines is scalable; */
		969	/* it has only empty glyphs then */
		970	if ( !FT_HAS_FIXED_SIZES( root ) && !FT_IS_SCALABLE( root ) )
		971	root->face_flags \|= FT_FACE_FLAG_SCALABLE;
		972
		973
		974	/*********************************************************************/
		975	/* */
		976	/* Set up metrics. */
		977	/* */
		978	if ( FT_IS_SCALABLE( root ) )
		979	{
		980	/* XXX What about if outline header is missing */
		981	/* (e.g. sfnt wrapped bitmap)? */
		982	root->bbox.xMin = face->header.xMin;
		983	root->bbox.yMin = face->header.yMin;
		984	root->bbox.xMax = face->header.xMax;
		985	root->bbox.yMax = face->header.yMax;
		986	root->units_per_EM = face->header.Units_Per_EM;
		987
		988
		989	/* XXX: Computing the ascender/descender/height is very different */
		990	/* from what the specification tells you. Apparently, we */
		991	/* must be careful because */
		992	/* */
		993	/* - not all fonts have an OS/2 table; in this case, we take */
		994	/* the values in the horizontal header. However, these */
		995	/* values very often are not reliable. */
		996	/* */
		997	/* - otherwise, the correct typographic values are in the */
		998	/* sTypoAscender, sTypoDescender & sTypoLineGap fields. */
		999	/* */
		1000	/* However, certain fonts have these fields set to 0. */
		1001	/* Rather, they have usWinAscent & usWinDescent correctly */
		1002	/* set (but with different values). */
		1003	/* */
		1004	/* As an example, Arial Narrow is implemented through four */
		1005	/* files ARIALN.TTF, ARIALNI.TTF, ARIALNB.TTF & ARIALNBI.TTF */
		1006	/* */
		1007	/* Strangely, all fonts have the same values in their */
		1008	/* sTypoXXX fields, except ARIALNB which sets them to 0. */
		1009	/* */
		1010	/* On the other hand, they all have different */
		1011	/* usWinAscent/Descent values -- as a conclusion, the OS/2 */
		1012	/* table cannot be used to compute the text height reliably! */
		1013	/* */
		1014
		1015	/* The ascender and descender are taken from the `hhea' table. */
		1016	/* If zero, they are taken from the `OS/2' table. */
		1017
		1018	root->ascender = face->horizontal.Ascender;
		1019	root->descender = face->horizontal.Descender;
		1020
		1021	root->height = (FT_Short)( root->ascender - root->descender +
		1022	face->horizontal.Line_Gap );
		1023
		1024	if ( !( root->ascender \|\| root->descender ) )
		1025	{
		1026	if ( face->os2.version != 0xFFFFU )
		1027	{
		1028	if ( face->os2.sTypoAscender \|\| face->os2.sTypoDescender )
		1029	{
		1030	root->ascender = face->os2.sTypoAscender;
		1031	root->descender = face->os2.sTypoDescender;
		1032
		1033	root->height = (FT_Short)( root->ascender - root->descender +
		1034	face->os2.sTypoLineGap );
		1035	}
		1036	else
		1037	{
		1038	root->ascender = (FT_Short)face->os2.usWinAscent;
		1039	root->descender = -(FT_Short)face->os2.usWinDescent;
		1040
		1041	root->height = (FT_UShort)( root->ascender - root->descender );
		1042	}
		1043	}
		1044	}
		1045
		1046	root->max_advance_width = face->horizontal.advance_Width_Max;
		1047	root->max_advance_height = (FT_Short)( face->vertical_info
		1048	? face->vertical.advance_Height_Max
		1049	: root->height );
		1050
		1051	/* See http://www.microsoft.com/OpenType/OTSpec/post.htm -- */
		1052	/* Adjust underline position from top edge to centre of */
		1053	/* stroke to convert TrueType meaning to FreeType meaning. */
		1054	root->underline_position = face->postscript.underlinePosition -
		1055	face->postscript.underlineThickness / 2;
		1056	root->underline_thickness = face->postscript.underlineThickness;
		1057	}
		1058
		1059	}
		1060
		1061	Exit:
		1062	FT_TRACE2(( "sfnt_load_face: done\n" ));
		1063
		1064	return error;
		1065	}
		1066
		1067
		1068	#undef LOAD_
		1069	#undef LOADM_
		1070	#undef GET_NAME
		1071
		1072
		1073	FT_LOCAL_DEF( void )
		1074	sfnt_done_face( TT_Face face )
		1075	{
		1076	FT_Memory memory;
		1077	SFNT_Service sfnt;
		1078
		1079
		1080	if ( !face )
		1081	return;
		1082
		1083	memory = face->root.memory;
		1084	sfnt = (SFNT_Service)face->sfnt;
		1085
		1086	if ( sfnt )
		1087	{
		1088	/* destroy the postscript names table if it is loaded */
		1089	if ( sfnt->free_psnames )
		1090	sfnt->free_psnames( face );
		1091
		1092	/* destroy the embedded bitmaps table if it is loaded */
		1093	if ( sfnt->free_eblc )
		1094	sfnt->free_eblc( face );
		1095	}
		1096
		1097	#ifdef TT_CONFIG_OPTION_BDF
		1098	/* freeing the embedded BDF properties */
		1099	tt_face_free_bdf_props( face );
		1100	#endif
		1101
		1102	/* freeing the kerning table */
		1103	tt_face_done_kern( face );
		1104
		1105	/* freeing the collection table */
		1106	FT_FREE( face->ttc_header.offsets );
		1107	face->ttc_header.count = 0;
		1108
		1109	/* freeing table directory */
		1110	FT_FREE( face->dir_tables );
		1111	face->num_tables = 0;
		1112
		1113	{
		1114	FT_Stream stream = FT_FACE_STREAM( face );
		1115
		1116
		1117	/* simply release the 'cmap' table frame */
		1118	FT_FRAME_RELEASE( face->cmap_table );
		1119	face->cmap_size = 0;
		1120	}
		1121
		1122	/* freeing the horizontal metrics */
		1123	{
		1124	FT_Stream stream = FT_FACE_STREAM( face );
		1125
		1126
		1127	FT_FRAME_RELEASE( face->horz_metrics );
		1128	FT_FRAME_RELEASE( face->vert_metrics );
		1129	face->horz_metrics_size = 0;
		1130	face->vert_metrics_size = 0;
		1131	}
		1132
		1133	/* freeing the vertical ones, if any */
		1134	if ( face->vertical_info )
		1135	{
		1136	FT_FREE( face->vertical.long_metrics );
		1137	FT_FREE( face->vertical.short_metrics );
		1138	face->vertical_info = 0;
		1139	}
		1140
		1141	/* freeing the gasp table */
		1142	FT_FREE( face->gasp.gaspRanges );
		1143	face->gasp.numRanges = 0;
		1144
		1145	/* freeing the name table */
		1146	if ( sfnt )
		1147	sfnt->free_name( face );
		1148
		1149	/* freeing family and style name */
		1150	FT_FREE( face->root.family_name );
		1151	FT_FREE( face->root.style_name );
		1152
		1153	/* freeing sbit size table */
		1154	FT_FREE( face->root.available_sizes );
		1155	face->root.num_fixed_sizes = 0;
		1156
		1157	FT_FREE( face->postscript_name );
		1158
		1159	face->sfnt = 0;
		1160	}
		1161
		1162
		1163	/* END */

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/freetype/src/sfnt/sfobjs.c – Rev 3918