Context Navigation

source: trunk/poppler/freetype2/src/pfr/pfrobjs.c @ 262

Last change on this file since 262 was 262, checked in by Eugene Romanenko, 12 years ago
PDF plugin: freetype library updated to version 2.3.8
File size: 17.6 KB

Line
1	/***************************************************************************/
2	/* */
3	/* pfrobjs.c */
4	/* */
5	/* FreeType PFR object methods (body). */
6	/* */
7	/* Copyright 2002, 2003, 2004, 2005, 2006, 2007, 2008 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 "pfrobjs.h"
20	#include "pfrload.h"
21	#include "pfrgload.h"
22	#include "pfrcmap.h"
23	#include "pfrsbit.h"
24	#include FT_OUTLINE_H
25	#include FT_INTERNAL_DEBUG_H
26
27	#include "pfrerror.h"
28
29	#undef FT_COMPONENT
30	#define FT_COMPONENT trace_pfr
31
32
33	/*************************************************************************/
34	/*************************************************************************/
35	/*** ***/
36	/*** FACE OBJECT METHODS ***/
37	/*** ***/
38	/*************************************************************************/
39	/*************************************************************************/
40
41	FT_LOCAL_DEF( void )
42	pfr_face_done( FT_Face pfrface ) /* PFR_Face */
43	{
44	PFR_Face face = (PFR_Face)pfrface;
45	FT_Memory memory;
46
47
48	if ( !face )
49	return;
50
51	memory = pfrface->driver->root.memory;
52
53	/* we don't want dangling pointers */
54	pfrface->family_name = NULL;
55	pfrface->style_name = NULL;
56
57	/* finalize the physical font record */
58	pfr_phy_font_done( &face->phy_font, FT_FACE_MEMORY( face ) );
59
60	/* no need to finalize the logical font or the header */
61	FT_FREE( pfrface->available_sizes );
62	}
63
64
65	FT_LOCAL_DEF( FT_Error )
66	pfr_face_init( FT_Stream stream,
67	FT_Face pfrface,
68	FT_Int face_index,
69	FT_Int num_params,
70	FT_Parameter* params )
71	{
72	PFR_Face face = (PFR_Face)pfrface;
73	FT_Error error;
74
75	FT_UNUSED( num_params );
76	FT_UNUSED( params );
77
78
79	/* load the header and check it */
80	error = pfr_header_load( &face->header, stream );
81	if ( error )
82	goto Exit;
83
84	if ( !pfr_header_check( &face->header ) )
85	{
86	FT_TRACE4(( "pfr_face_init: not a valid PFR font\n" ));
87	error = PFR_Err_Unknown_File_Format;
88	goto Exit;
89	}
90
91	/* check face index */
92	{
93	FT_UInt num_faces;
94
95
96	error = pfr_log_font_count( stream,
97	face->header.log_dir_offset,
98	&num_faces );
99	if ( error )
100	goto Exit;
101
102	pfrface->num_faces = num_faces;
103	}
104
105	if ( face_index < 0 )
106	goto Exit;
107
108	if ( face_index >= pfrface->num_faces )
109	{
110	FT_ERROR(( "pfr_face_init: invalid face index\n" ));
111	error = PFR_Err_Invalid_Argument;
112	goto Exit;
113	}
114
115	/* load the face */
116	error = pfr_log_font_load(
117	&face->log_font, stream, face_index,
118	face->header.log_dir_offset,
119	FT_BOOL( face->header.phy_font_max_size_high != 0 ) );
120	if ( error )
121	goto Exit;
122
123	/* now load the physical font descriptor */
124	error = pfr_phy_font_load( &face->phy_font, stream,
125	face->log_font.phys_offset,
126	face->log_font.phys_size );
127	if ( error )
128	goto Exit;
129
130	/* now set up all root face fields */
131	{
132	PFR_PhyFont phy_font = &face->phy_font;
133
134
135	pfrface->face_index = face_index;
136	pfrface->num_glyphs = phy_font->num_chars + 1;
137	pfrface->face_flags = FT_FACE_FLAG_SCALABLE;
138
139	/* if all characters point to the same gps_offset 0, we */
140	/* assume that the font only contains bitmaps */
141	{
142	FT_UInt nn;
143
144
145	for ( nn = 0; nn < phy_font->num_chars; nn++ )
146	if ( phy_font->chars[nn].gps_offset != 0 )
147	break;
148
149	if ( nn == phy_font->num_chars )
150	pfrface->face_flags = 0; /* not scalable */
151	}
152
153	if ( (phy_font->flags & PFR_PHY_PROPORTIONAL) == 0 )
154	pfrface->face_flags \|= FT_FACE_FLAG_FIXED_WIDTH;
155
156	if ( phy_font->flags & PFR_PHY_VERTICAL )
157	pfrface->face_flags \|= FT_FACE_FLAG_VERTICAL;
158	else
159	pfrface->face_flags \|= FT_FACE_FLAG_HORIZONTAL;
160
161	if ( phy_font->num_strikes > 0 )
162	pfrface->face_flags \|= FT_FACE_FLAG_FIXED_SIZES;
163
164	if ( phy_font->num_kern_pairs > 0 )
165	pfrface->face_flags \|= FT_FACE_FLAG_KERNING;
166
167	/* If no family name was found in the "undocumented" auxiliary
168	* data, use the font ID instead. This sucks but is better than
169	* nothing.
170	*/
171	pfrface->family_name = phy_font->family_name;
172	if ( pfrface->family_name == NULL )
173	pfrface->family_name = phy_font->font_id;
174
175	/* note that the style name can be NULL in certain PFR fonts,
176	* probably meaning "Regular"
177	*/
178	pfrface->style_name = phy_font->style_name;
179
180	pfrface->num_fixed_sizes = 0;
181	pfrface->available_sizes = 0;
182
183	pfrface->bbox = phy_font->bbox;
184	pfrface->units_per_EM = (FT_UShort)phy_font->outline_resolution;
185	pfrface->ascender = (FT_Short) phy_font->bbox.yMax;
186	pfrface->descender = (FT_Short) phy_font->bbox.yMin;
187
188	pfrface->height = (FT_Short)( ( pfrface->units_per_EM * 12 ) / 10 );
189	if ( pfrface->height < pfrface->ascender - pfrface->descender )
190	pfrface->height = (FT_Short)(pfrface->ascender - pfrface->descender);
191
192	if ( phy_font->num_strikes > 0 )
193	{
194	FT_UInt n, count = phy_font->num_strikes;
195	FT_Bitmap_Size* size;
196	PFR_Strike strike;
197	FT_Memory memory = pfrface->stream->memory;
198
199
200	if ( FT_NEW_ARRAY( pfrface->available_sizes, count ) )
201	goto Exit;
202
203	size = pfrface->available_sizes;
204	strike = phy_font->strikes;
205	for ( n = 0; n < count; n++, size++, strike++ )
206	{
207	size->height = (FT_UShort)strike->y_ppm;
208	size->width = (FT_UShort)strike->x_ppm;
209	size->size = strike->y_ppm << 6;
210	size->x_ppem = strike->x_ppm << 6;
211	size->y_ppem = strike->y_ppm << 6;
212	}
213	pfrface->num_fixed_sizes = count;
214	}
215
216	/* now compute maximum advance width */
217	if ( ( phy_font->flags & PFR_PHY_PROPORTIONAL ) == 0 )
218	pfrface->max_advance_width = (FT_Short)phy_font->standard_advance;
219	else
220	{
221	FT_Int max = 0;
222	FT_UInt count = phy_font->num_chars;
223	PFR_Char gchar = phy_font->chars;
224
225
226	for ( ; count > 0; count--, gchar++ )
227	{
228	if ( max < gchar->advance )
229	max = gchar->advance;
230	}
231
232	pfrface->max_advance_width = (FT_Short)max;
233	}
234
235	pfrface->max_advance_height = pfrface->height;
236
237	pfrface->underline_position = (FT_Short)( -pfrface->units_per_EM / 10 );
238	pfrface->underline_thickness = (FT_Short)( pfrface->units_per_EM / 30 );
239
240	/* create charmap */
241	{
242	FT_CharMapRec charmap;
243
244
245	charmap.face = pfrface;
246	charmap.platform_id = 3;
247	charmap.encoding_id = 1;
248	charmap.encoding = FT_ENCODING_UNICODE;
249
250	FT_CMap_New( &pfr_cmap_class_rec, NULL, &charmap, NULL );
251
252	#if 0
253	/* Select default charmap */
254	if ( pfrface->num_charmaps )
255	pfrface->charmap = pfrface->charmaps[0];
256	#endif
257	}
258
259	/* check whether we've loaded any kerning pairs */
260	if ( phy_font->num_kern_pairs )
261	pfrface->face_flags \|= FT_FACE_FLAG_KERNING;
262	}
263
264	Exit:
265	return error;
266	}
267
268
269	/*************************************************************************/
270	/*************************************************************************/
271	/*** ***/
272	/*** SLOT OBJECT METHOD ***/
273	/*** ***/
274	/*************************************************************************/
275	/*************************************************************************/
276
277	FT_LOCAL_DEF( FT_Error )
278	pfr_slot_init( FT_GlyphSlot pfrslot ) /* PFR_Slot */
279	{
280	PFR_Slot slot = (PFR_Slot)pfrslot;
281	FT_GlyphLoader loader = pfrslot->internal->loader;
282
283
284	pfr_glyph_init( &slot->glyph, loader );
285
286	return 0;
287	}
288
289
290	FT_LOCAL_DEF( void )
291	pfr_slot_done( FT_GlyphSlot pfrslot ) /* PFR_Slot */
292	{
293	PFR_Slot slot = (PFR_Slot)pfrslot;
294
295
296	pfr_glyph_done( &slot->glyph );
297	}
298
299
300	FT_LOCAL_DEF( FT_Error )
301	pfr_slot_load( FT_GlyphSlot pfrslot, /* PFR_Slot */
302	FT_Size pfrsize, /* PFR_Size */
303	FT_UInt gindex,
304	FT_Int32 load_flags )
305	{
306	PFR_Slot slot = (PFR_Slot)pfrslot;
307	PFR_Size size = (PFR_Size)pfrsize;
308	FT_Error error;
309	PFR_Face face = (PFR_Face)pfrslot->face;
310	PFR_Char gchar;
311	FT_Outline* outline = &pfrslot->outline;
312	FT_ULong gps_offset;
313
314
315	if ( gindex > 0 )
316	gindex--;
317
318	if ( !face \|\| gindex >= face->phy_font.num_chars )
319	{
320	error = PFR_Err_Invalid_Argument;
321	goto Exit;
322	}
323
324	/* try to load an embedded bitmap */
325	if ( ( load_flags & ( FT_LOAD_NO_SCALE \| FT_LOAD_NO_BITMAP ) ) == 0 )
326	{
327	error = pfr_slot_load_bitmap( slot, size, gindex );
328	if ( error == 0 )
329	goto Exit;
330	}
331
332	if ( load_flags & FT_LOAD_SBITS_ONLY )
333	{
334	error = PFR_Err_Invalid_Argument;
335	goto Exit;
336	}
337
338	gchar = face->phy_font.chars + gindex;
339	pfrslot->format = FT_GLYPH_FORMAT_OUTLINE;
340	outline->n_points = 0;
341	outline->n_contours = 0;
342	gps_offset = face->header.gps_section_offset;
343
344	/* load the glyph outline (FT_LOAD_NO_RECURSE isn't supported) */
345	error = pfr_glyph_load( &slot->glyph, face->root.stream,
346	gps_offset, gchar->gps_offset, gchar->gps_size );
347
348	if ( !error )
349	{
350	FT_BBox cbox;
351	FT_Glyph_Metrics* metrics = &pfrslot->metrics;
352	FT_Pos advance;
353	FT_Int em_metrics, em_outline;
354	FT_Bool scaling;
355
356
357	scaling = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE ) == 0 );
358
359	/* copy outline data */
360	*outline = slot->glyph.loader->base.outline;
361
362	outline->flags &= ~FT_OUTLINE_OWNER;
363	outline->flags \|= FT_OUTLINE_REVERSE_FILL;
364
365	if ( size && pfrsize->metrics.y_ppem < 24 )
366	outline->flags \|= FT_OUTLINE_HIGH_PRECISION;
367
368	/* compute the advance vector */
369	metrics->horiAdvance = 0;
370	metrics->vertAdvance = 0;
371
372	advance = gchar->advance;
373	em_metrics = face->phy_font.metrics_resolution;
374	em_outline = face->phy_font.outline_resolution;
375
376	if ( em_metrics != em_outline )
377	advance = FT_MulDiv( advance, em_outline, em_metrics );
378
379	if ( face->phy_font.flags & PFR_PHY_VERTICAL )
380	metrics->vertAdvance = advance;
381	else
382	metrics->horiAdvance = advance;
383
384	pfrslot->linearHoriAdvance = metrics->horiAdvance;
385	pfrslot->linearVertAdvance = metrics->vertAdvance;
386
387	/* make-up vertical metrics(?) */
388	metrics->vertBearingX = 0;
389	metrics->vertBearingY = 0;
390
391	#if 0 /* some fonts seem to be broken here! */
392
393	/* Apply the font matrix, if any. */
394	/* TODO: Test existing fonts with unusual matrix */
395	/* whether we have to adjust Units per EM. */
396	{
397	FT_Matrix font_matrix;
398
399
400	font_matrix.xx = face->log_font.matrix[0] << 8;
401	font_matrix.yx = face->log_font.matrix[1] << 8;
402	font_matrix.xy = face->log_font.matrix[2] << 8;
403	font_matrix.yy = face->log_font.matrix[3] << 8;
404
405	FT_Outline_Transform( outline, &font_matrix );
406	}
407	#endif
408
409	/* scale when needed */
410	if ( scaling )
411	{
412	FT_Int n;
413	FT_Fixed x_scale = pfrsize->metrics.x_scale;
414	FT_Fixed y_scale = pfrsize->metrics.y_scale;
415	FT_Vector* vec = outline->points;
416
417
418	/* scale outline points */
419	for ( n = 0; n < outline->n_points; n++, vec++ )
420	{
421	vec->x = FT_MulFix( vec->x, x_scale );
422	vec->y = FT_MulFix( vec->y, y_scale );
423	}
424
425	/* scale the advance */
426	metrics->horiAdvance = FT_MulFix( metrics->horiAdvance, x_scale );
427	metrics->vertAdvance = FT_MulFix( metrics->vertAdvance, y_scale );
428	}
429
430	/* compute the rest of the metrics */
431	FT_Outline_Get_CBox( outline, &cbox );
432
433	metrics->width = cbox.xMax - cbox.xMin;
434	metrics->height = cbox.yMax - cbox.yMin;
435	metrics->horiBearingX = cbox.xMin;
436	metrics->horiBearingY = cbox.yMax - metrics->height;
437	}
438
439	Exit:
440	return error;
441	}
442
443
444	/*************************************************************************/
445	/*************************************************************************/
446	/*** ***/
447	/*** KERNING METHOD ***/
448	/*** ***/
449	/*************************************************************************/
450	/*************************************************************************/
451
452	FT_LOCAL_DEF( FT_Error )
453	pfr_face_get_kerning( FT_Face pfrface, /* PFR_Face */
454	FT_UInt glyph1,
455	FT_UInt glyph2,
456	FT_Vector* kerning )
457	{
458	PFR_Face face = (PFR_Face)pfrface;
459	FT_Error error = PFR_Err_Ok;
460	PFR_PhyFont phy_font = &face->phy_font;
461	FT_UInt32 code1, code2, pair;
462
463
464	kerning->x = 0;
465	kerning->y = 0;
466
467	if ( glyph1 > 0 )
468	glyph1--;
469
470	if ( glyph2 > 0 )
471	glyph2--;
472
473	/* convert glyph indices to character codes */
474	if ( glyph1 > phy_font->num_chars \|\|
475	glyph2 > phy_font->num_chars )
476	goto Exit;
477
478	code1 = phy_font->chars[glyph1].char_code;
479	code2 = phy_font->chars[glyph2].char_code;
480	pair = PFR_KERN_INDEX( code1, code2 );
481
482	/* now search the list of kerning items */
483	{
484	PFR_KernItem item = phy_font->kern_items;
485	FT_Stream stream = pfrface->stream;
486
487
488	for ( ; item; item = item->next )
489	{
490	if ( pair >= item->pair1 && pair <= item->pair2 )
491	goto FoundPair;
492	}
493	goto Exit;
494
495	FoundPair: /* we found an item, now parse it and find the value if any */
496	if ( FT_STREAM_SEEK( item->offset ) \|\|
497	FT_FRAME_ENTER( item->pair_count * item->pair_size ) )
498	goto Exit;
499
500	{
501	FT_UInt count = item->pair_count;
502	FT_UInt size = item->pair_size;
503	FT_UInt power = (FT_UInt)ft_highpow2( (FT_UInt32)count );
504	FT_UInt probe = power * size;
505	FT_UInt extra = count - power;
506	FT_Byte* base = stream->cursor;
507	FT_Bool twobytes = FT_BOOL( item->flags & 1 );
508	FT_Bool twobyte_adj = FT_BOOL( item->flags & 2 );
509	FT_Byte* p;
510	FT_UInt32 cpair;
511
512
513	if ( extra > 0 )
514	{
515	p = base + extra * size;
516
517	if ( twobytes )
518	cpair = FT_NEXT_ULONG( p );
519	else
520	cpair = PFR_NEXT_KPAIR( p );
521
522	if ( cpair == pair )
523	goto Found;
524
525	if ( cpair < pair )
526	{
527	if ( twobyte_adj )
528	p += 2;
529	else
530	p++;
531	base = p;
532	}
533	}
534
535	while ( probe > size )
536	{
537	probe >>= 1;
538	p = base + probe;
539
540	if ( twobytes )
541	cpair = FT_NEXT_ULONG( p );
542	else
543	cpair = PFR_NEXT_KPAIR( p );
544
545	if ( cpair == pair )
546	goto Found;
547
548	if ( cpair < pair )
549	base += probe;
550	}
551
552	p = base;
553
554	if ( twobytes )
555	cpair = FT_NEXT_ULONG( p );
556	else
557	cpair = PFR_NEXT_KPAIR( p );
558
559	if ( cpair == pair )
560	{
561	FT_Int value;
562
563
564	Found:
565	if ( twobyte_adj )
566	value = FT_PEEK_SHORT( p );
567	else
568	value = p[0];
569
570	kerning->x = item->base_adj + value;
571	}
572	}
573
574	FT_FRAME_EXIT();
575	}
576
577	Exit:
578	return error;
579	}
580
581	/* END */

Note: See TracBrowser for help on using the repository browser.

Download in other formats: