zenilib: zenilib/jni/external/freetype2/src/pfr/pfrload.c Source File

zenilib 0.5.3.0

- Main Page
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
pfrload.c
Go to the documentation of this file.
1 /***************************************************************************/
2 /* */
3 /* pfrload.c */
4 /* */
5 /* FreeType PFR loader (body). */
6 /* */
7 /* Copyright 2002, 2003, 2004, 2005, 2007, 2009, 2010 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 "pfrload.h"
20 #include FT_INTERNAL_DEBUG_H
21 #include FT_INTERNAL_STREAM_H
22
23 #include "pfrerror.h"
24
25 #undef FT_COMPONENT
26 #define FT_COMPONENT trace_pfr
27
28
29 /*************************************************************************/
30 /*************************************************************************/
31 /***** *****/
32 /***** EXTRA ITEMS *****/
33 /***** *****/
34 /*************************************************************************/
35 /*************************************************************************/
36
37
38 FT_LOCAL_DEF( FT_Error )
39 pfr_extra_items_skip( FT_Byte* *pp,
40 FT_Byte* limit )
41 {
42 return pfr_extra_items_parse( pp, limit, NULL, NULL );
43 }
44
45
46 FT_LOCAL_DEF( FT_Error )
47 pfr_extra_items_parse( FT_Byte* *pp,
48 FT_Byte* limit,
49 PFR_ExtraItem item_list,
50 FT_Pointer item_data )
51 {
52 FT_Error error = PFR_Err_Ok;
53 FT_Byte* p = *pp;
54 FT_UInt num_items, item_type, item_size;
55
56
57 PFR_CHECK( 1 );
58 num_items = PFR_NEXT_BYTE( p );
59
60 for ( ; num_items > 0; num_items-- )
61 {
62 PFR_CHECK( 2 );
63 item_size = PFR_NEXT_BYTE( p );
64 item_type = PFR_NEXT_BYTE( p );
65
66 PFR_CHECK( item_size );
67
68 if ( item_list )
69 {
70 PFR_ExtraItem extra = item_list;
71
72
73 for ( extra = item_list; extra->parser != NULL; extra++ )
74 {
75 if ( extra->type == item_type )
76 {
77 error = extra->parser( p, p + item_size, item_data );
78 if ( error ) goto Exit;
79
80 break;
81 }
82 }
83 }
84
85 p += item_size;
86 }
87
88 Exit:
89 *pp = p;
90 return error;
91
92 Too_Short:
93 FT_ERROR(( "pfr_extra_items_parse: invalid extra items table\n" ));
94 error = PFR_Err_Invalid_Table;
95 goto Exit;
96 }
97
98
99 /*************************************************************************/
100 /*************************************************************************/
101 /***** *****/
102 /***** PFR HEADER *****/
103 /***** *****/
104 /*************************************************************************/
105 /*************************************************************************/
106
107 static const FT_Frame_Field pfr_header_fields[] =
108 {
109 #undef FT_STRUCTURE
110 #define FT_STRUCTURE PFR_HeaderRec
111
112 FT_FRAME_START( 58 ),
113 FT_FRAME_ULONG ( signature ),
114 FT_FRAME_USHORT( version ),
115 FT_FRAME_USHORT( signature2 ),
116 FT_FRAME_USHORT( header_size ),
117
118 FT_FRAME_USHORT( log_dir_size ),
119 FT_FRAME_USHORT( log_dir_offset ),
120
121 FT_FRAME_USHORT( log_font_max_size ),
122 FT_FRAME_UOFF3 ( log_font_section_size ),
123 FT_FRAME_UOFF3 ( log_font_section_offset ),
124
125 FT_FRAME_USHORT( phy_font_max_size ),
126 FT_FRAME_UOFF3 ( phy_font_section_size ),
127 FT_FRAME_UOFF3 ( phy_font_section_offset ),
128
129 FT_FRAME_USHORT( gps_max_size ),
130 FT_FRAME_UOFF3 ( gps_section_size ),
131 FT_FRAME_UOFF3 ( gps_section_offset ),
132
133 FT_FRAME_BYTE ( max_blue_values ),
134 FT_FRAME_BYTE ( max_x_orus ),
135 FT_FRAME_BYTE ( max_y_orus ),
136
137 FT_FRAME_BYTE ( phy_font_max_size_high ),
138 FT_FRAME_BYTE ( color_flags ),
139
140 FT_FRAME_UOFF3 ( bct_max_size ),
141 FT_FRAME_UOFF3 ( bct_set_max_size ),
142 FT_FRAME_UOFF3 ( phy_bct_set_max_size ),
143
144 FT_FRAME_USHORT( num_phy_fonts ),
145 FT_FRAME_BYTE ( max_vert_stem_snap ),
146 FT_FRAME_BYTE ( max_horz_stem_snap ),
147 FT_FRAME_USHORT( max_chars ),
148 FT_FRAME_END
149 };
150
151
152 FT_LOCAL_DEF( FT_Error )
153 pfr_header_load( PFR_Header header,
154 FT_Stream stream )
155 {
156 FT_Error error;
157
158
159 /* read header directly */
160 if ( !FT_STREAM_SEEK( 0 ) &&
161 !FT_STREAM_READ_FIELDS( pfr_header_fields, header ) )
162 {
163 /* make a few adjustments to the header */
164 header->phy_font_max_size +=
165 (FT_UInt32)header->phy_font_max_size_high << 16;
166 }
167
168 return error;
169 }
170
171
172 FT_LOCAL_DEF( FT_Bool )
173 pfr_header_check( PFR_Header header )
174 {
175 FT_Bool result = 1;
176
177
178 /* check signature and header size */
179 if ( header->signature != 0x50465230L || /* "PFR0" */
180 header->version > 4 ||
181 header->header_size < 58 ||
182 header->signature2 != 0x0d0a ) /* CR/LF */
183 {
184 result = 0;
185 }
186 return result;
187 }
188
189
190 /***********************************************************************/
191 /***********************************************************************/
192 /***** *****/
193 /***** PFR LOGICAL FONTS *****/
194 /***** *****/
195 /***********************************************************************/
196 /***********************************************************************/
197
198
199 FT_LOCAL_DEF( FT_Error )
200 pfr_log_font_count( FT_Stream stream,
201 FT_UInt32 section_offset,
202 FT_UInt *acount )
203 {
204 FT_Error error;
205 FT_UInt count;
206 FT_UInt result = 0;
207
208
209 if ( FT_STREAM_SEEK( section_offset ) || FT_READ_USHORT( count ) )
210 goto Exit;
211
212 result = count;
213
214 Exit:
215 *acount = result;
216 return error;
217 }
218
219
220 FT_LOCAL_DEF( FT_Error )
221 pfr_log_font_load( PFR_LogFont log_font,
222 FT_Stream stream,
223 FT_UInt idx,
224 FT_UInt32 section_offset,
225 FT_Bool size_increment )
226 {
227 FT_UInt num_log_fonts;
228 FT_UInt flags;
229 FT_UInt32 offset;
230 FT_UInt32 size;
231 FT_Error error;
232
233
234 if ( FT_STREAM_SEEK( section_offset ) ||
235 FT_READ_USHORT( num_log_fonts ) )
236 goto Exit;
237
238 if ( idx >= num_log_fonts )
239 return PFR_Err_Invalid_Argument;
240
241 if ( FT_STREAM_SKIP( idx * 5 ) ||
242 FT_READ_USHORT( size ) ||
243 FT_READ_UOFF3 ( offset ) )
244 goto Exit;
245
246 /* save logical font size and offset */
247 log_font->size = size;
248 log_font->offset = offset;
249
250 /* now, check the rest of the table before loading it */
251 {
252 FT_Byte* p;
253 FT_Byte* limit;
254 FT_UInt local;
255
256
257 if ( FT_STREAM_SEEK( offset ) || FT_FRAME_ENTER( size ) )
258 goto Exit;
259
260 p = stream->cursor;
261 limit = p + size;
262
263 PFR_CHECK(13);
264
265 log_font->matrix[0] = PFR_NEXT_LONG( p );
266 log_font->matrix[1] = PFR_NEXT_LONG( p );
267 log_font->matrix[2] = PFR_NEXT_LONG( p );
268 log_font->matrix[3] = PFR_NEXT_LONG( p );
269
270 flags = PFR_NEXT_BYTE( p );
271
272 local = 0;
273 if ( flags & PFR_LOG_STROKE )
274 {
275 local++;
276 if ( flags & PFR_LOG_2BYTE_STROKE )
277 local++;
278
279 if ( (flags & PFR_LINE_JOIN_MASK) == PFR_LINE_JOIN_MITER )
280 local += 3;
281 }
282 if ( flags & PFR_LOG_BOLD )
283 {
284 local++;
285 if ( flags & PFR_LOG_2BYTE_BOLD )
286 local++;
287 }
288
289 PFR_CHECK( local );
290
291 if ( flags & PFR_LOG_STROKE )
292 {
293 log_font->stroke_thickness = ( flags & PFR_LOG_2BYTE_STROKE )
294 ? PFR_NEXT_SHORT( p )
295 : PFR_NEXT_BYTE( p );
296
297 if ( ( flags & PFR_LINE_JOIN_MASK ) == PFR_LINE_JOIN_MITER )
298 log_font->miter_limit = PFR_NEXT_LONG( p );
299 }
300
301 if ( flags & PFR_LOG_BOLD )
302 {
303 log_font->bold_thickness = ( flags & PFR_LOG_2BYTE_BOLD )
304 ? PFR_NEXT_SHORT( p )
305 : PFR_NEXT_BYTE( p );
306 }
307
308 if ( flags & PFR_LOG_EXTRA_ITEMS )
309 {
310 error = pfr_extra_items_skip( &p, limit );
311 if (error) goto Fail;
312 }
313
314 PFR_CHECK(5);
315 log_font->phys_size = PFR_NEXT_USHORT( p );
316 log_font->phys_offset = PFR_NEXT_ULONG( p );
317 if ( size_increment )
318 {
319 PFR_CHECK( 1 );
320 log_font->phys_size += (FT_UInt32)PFR_NEXT_BYTE( p ) << 16;
321 }
322 }
323
324 Fail:
325 FT_FRAME_EXIT();
326
327 Exit:
328 return error;
329
330 Too_Short:
331 FT_ERROR(( "pfr_log_font_load: invalid logical font table\n" ));
332 error = PFR_Err_Invalid_Table;
333 goto Fail;
334 }
335
336
337 /***********************************************************************/
338 /***********************************************************************/
339 /***** *****/
340 /***** PFR PHYSICAL FONTS *****/
341 /***** *****/
342 /***********************************************************************/
343 /***********************************************************************/
344
345
346 /* load bitmap strikes lists */
347 FT_CALLBACK_DEF( FT_Error )
348 pfr_extra_item_load_bitmap_info( FT_Byte* p,
349 FT_Byte* limit,
350 PFR_PhyFont phy_font )
351 {
352 FT_Memory memory = phy_font->memory;
353 PFR_Strike strike;
354 FT_UInt flags0;
355 FT_UInt n, count, size1;
356 FT_Error error = PFR_Err_Ok;
357
358
359 PFR_CHECK( 5 );
360
361 p += 3; /* skip bctSize */
362 flags0 = PFR_NEXT_BYTE( p );
363 count = PFR_NEXT_BYTE( p );
364
365 /* re-allocate when needed */
366 if ( phy_font->num_strikes + count > phy_font->max_strikes )
367 {
368 FT_UInt new_max = FT_PAD_CEIL( phy_font->num_strikes + count, 4 );
369
370
371 if ( FT_RENEW_ARRAY( phy_font->strikes,
372 phy_font->num_strikes,
373 new_max ) )
374 goto Exit;
375
376 phy_font->max_strikes = new_max;
377 }
378
379 size1 = 1 + 1 + 1 + 2 + 2 + 1;
380 if ( flags0 & PFR_STRIKE_2BYTE_XPPM )
381 size1++;
382
383 if ( flags0 & PFR_STRIKE_2BYTE_YPPM )
384 size1++;
385
386 if ( flags0 & PFR_STRIKE_3BYTE_SIZE )
387 size1++;
388
389 if ( flags0 & PFR_STRIKE_3BYTE_OFFSET )
390 size1++;
391
392 if ( flags0 & PFR_STRIKE_2BYTE_COUNT )
393 size1++;
394
395 strike = phy_font->strikes + phy_font->num_strikes;
396
397 PFR_CHECK( count * size1 );
398
399 for ( n = 0; n < count; n++, strike++ )
400 {
401 strike->x_ppm = ( flags0 & PFR_STRIKE_2BYTE_XPPM )
402 ? PFR_NEXT_USHORT( p )
403 : PFR_NEXT_BYTE( p );
404
405 strike->y_ppm = ( flags0 & PFR_STRIKE_2BYTE_YPPM )
406 ? PFR_NEXT_USHORT( p )
407 : PFR_NEXT_BYTE( p );
408
409 strike->flags = PFR_NEXT_BYTE( p );
410
411 strike->bct_size = ( flags0 & PFR_STRIKE_3BYTE_SIZE )
412 ? PFR_NEXT_ULONG( p )
413 : PFR_NEXT_USHORT( p );
414
415 strike->bct_offset = ( flags0 & PFR_STRIKE_3BYTE_OFFSET )
416 ? PFR_NEXT_ULONG( p )
417 : PFR_NEXT_USHORT( p );
418
419 strike->num_bitmaps = ( flags0 & PFR_STRIKE_2BYTE_COUNT )
420 ? PFR_NEXT_USHORT( p )
421 : PFR_NEXT_BYTE( p );
422 }
423
424 phy_font->num_strikes += count;
425
426 Exit:
427 return error;
428
429 Too_Short:
430 error = PFR_Err_Invalid_Table;
431 FT_ERROR(( "pfr_extra_item_load_bitmap_info:"
432 " invalid bitmap info table\n" ));
433 goto Exit;
434 }
435
436
437 /* Load font ID. This is a so-called "unique" name that is rather
438 * long and descriptive (like "Tiresias ScreenFont v7.51").
439 *
440 * Note that a PFR font's family name is contained in an *undocumented*
441 * string of the "auxiliary data" portion of a physical font record. This
442 * may also contain the "real" style name!
443 *
444 * If no family name is present, the font ID is used instead for the
445 * family.
446 */
447 FT_CALLBACK_DEF( FT_Error )
448 pfr_extra_item_load_font_id( FT_Byte* p,
449 FT_Byte* limit,
450 PFR_PhyFont phy_font )
451 {
452 FT_Error error = PFR_Err_Ok;
453 FT_Memory memory = phy_font->memory;
454 FT_PtrDist len = limit - p;
455
456
457 if ( phy_font->font_id != NULL )
458 goto Exit;
459
460 if ( FT_ALLOC( phy_font->font_id, len + 1 ) )
461 goto Exit;
462
463 /* copy font ID name, and terminate it for safety */
464 FT_MEM_COPY( phy_font->font_id, p, len );
465 phy_font->font_id[len] = 0;
466
467 Exit:
468 return error;
469 }
470
471
472 /* load stem snap tables */
473 FT_CALLBACK_DEF( FT_Error )
474 pfr_extra_item_load_stem_snaps( FT_Byte* p,
475 FT_Byte* limit,
476 PFR_PhyFont phy_font )
477 {
478 FT_UInt count, num_vert, num_horz;
479 FT_Int* snaps = NULL;
480 FT_Error error = PFR_Err_Ok;
481 FT_Memory memory = phy_font->memory;
482
483
484 if ( phy_font->vertical.stem_snaps != NULL )
485 goto Exit;
486
487 PFR_CHECK( 1 );
488 count = PFR_NEXT_BYTE( p );
489
490 num_vert = count & 15;
491 num_horz = count >> 4;
492 count = num_vert + num_horz;
493
494 PFR_CHECK( count * 2 );
495
496 if ( FT_NEW_ARRAY( snaps, count ) )
497 goto Exit;
498
499 phy_font->vertical.stem_snaps = snaps;
500 phy_font->horizontal.stem_snaps = snaps + num_vert;
501
502 for ( ; count > 0; count--, snaps++ )
503 *snaps = FT_NEXT_SHORT( p );
504
505 Exit:
506 return error;
507
508 Too_Short:
509 error = PFR_Err_Invalid_Table;
510 FT_ERROR(( "pfr_exta_item_load_stem_snaps:"
511 " invalid stem snaps table\n" ));
512 goto Exit;
513 }
514
515
516
517 /* load kerning pair data */
518 FT_CALLBACK_DEF( FT_Error )
519 pfr_extra_item_load_kerning_pairs( FT_Byte* p,
520 FT_Byte* limit,
521 PFR_PhyFont phy_font )
522 {
523 PFR_KernItem item = NULL;
524 FT_Error error = PFR_Err_Ok;
525 FT_Memory memory = phy_font->memory;
526
527
528 FT_TRACE2(( "pfr_extra_item_load_kerning_pairs()\n" ));
529
530 if ( FT_NEW( item ) )
531 goto Exit;
532
533 PFR_CHECK( 4 );
534
535 item->pair_count = PFR_NEXT_BYTE( p );
536 item->base_adj = PFR_NEXT_SHORT( p );
537 item->flags = PFR_NEXT_BYTE( p );
538 item->offset = phy_font->offset + ( p - phy_font->cursor );
539
540 #ifndef PFR_CONFIG_NO_CHECKS
541 item->pair_size = 3;
542
543 if ( item->flags & PFR_KERN_2BYTE_CHAR )
544 item->pair_size += 2;
545
546 if ( item->flags & PFR_KERN_2BYTE_ADJ )
547 item->pair_size += 1;
548
549 PFR_CHECK( item->pair_count * item->pair_size );
550 #endif
551
552 /* load first and last pairs into the item to speed up */
553 /* lookup later... */
554 if ( item->pair_count > 0 )
555 {
556 FT_UInt char1, char2;
557 FT_Byte* q;
558
559
560 if ( item->flags & PFR_KERN_2BYTE_CHAR )
561 {
562 q = p;
563 char1 = PFR_NEXT_USHORT( q );
564 char2 = PFR_NEXT_USHORT( q );
565
566 item->pair1 = PFR_KERN_INDEX( char1, char2 );
567
568 q = p + item->pair_size * ( item->pair_count - 1 );
569 char1 = PFR_NEXT_USHORT( q );
570 char2 = PFR_NEXT_USHORT( q );
571
572 item->pair2 = PFR_KERN_INDEX( char1, char2 );
573 }
574 else
575 {
576 q = p;
577 char1 = PFR_NEXT_BYTE( q );
578 char2 = PFR_NEXT_BYTE( q );
579
580 item->pair1 = PFR_KERN_INDEX( char1, char2 );
581
582 q = p + item->pair_size * ( item->pair_count - 1 );
583 char1 = PFR_NEXT_BYTE( q );
584 char2 = PFR_NEXT_BYTE( q );
585
586 item->pair2 = PFR_KERN_INDEX( char1, char2 );
587 }
588
589 /* add new item to the current list */
590 item->next = NULL;
591 *phy_font->kern_items_tail = item;
592 phy_font->kern_items_tail = &item->next;
593 phy_font->num_kern_pairs += item->pair_count;
594 }
595 else
596 {
597 /* empty item! */
598 FT_FREE( item );
599 }
600
601 Exit:
602 return error;
603
604 Too_Short:
605 FT_FREE( item );
606
607 error = PFR_Err_Invalid_Table;
608 FT_ERROR(( "pfr_extra_item_load_kerning_pairs:"
609 " invalid kerning pairs table\n" ));
610 goto Exit;
611 }
612
613
614
615 static const PFR_ExtraItemRec pfr_phy_font_extra_items[] =
616 {
617 { 1, (PFR_ExtraItem_ParseFunc)pfr_extra_item_load_bitmap_info },
618 { 2, (PFR_ExtraItem_ParseFunc)pfr_extra_item_load_font_id },
619 { 3, (PFR_ExtraItem_ParseFunc)pfr_extra_item_load_stem_snaps },
620 { 4, (PFR_ExtraItem_ParseFunc)pfr_extra_item_load_kerning_pairs },
621 { 0, NULL }
622 };
623
624
625 /* Loads a name from the auxiliary data. Since this extracts undocumented
626 * strings from the font file, we need to be careful here.
627 */
628 static FT_Error
629 pfr_aux_name_load( FT_Byte* p,
630 FT_UInt len,
631 FT_Memory memory,
632 FT_String* *astring )
633 {
634 FT_Error error = PFR_Err_Ok;
635 FT_String* result = NULL;
636 FT_UInt n, ok;
637
638
639 if ( len > 0 && p[len - 1] == 0 )
640 len--;
641
642 /* check that each character is ASCII for making sure not to
643 load garbage
644 */
645 ok = ( len > 0 );
646 for ( n = 0; n < len; n++ )
647 if ( p[n] < 32 || p[n] > 127 )
648 {
649 ok = 0;
650 break;
651 }
652
653 if ( ok )
654 {
655 if ( FT_ALLOC( result, len + 1 ) )
656 goto Exit;
657
658 FT_MEM_COPY( result, p, len );
659 result[len] = 0;
660 }
661 Exit:
662 *astring = result;
663 return error;
664 }
665
666
667 FT_LOCAL_DEF( void )
668 pfr_phy_font_done( PFR_PhyFont phy_font,
669 FT_Memory memory )
670 {
671 FT_FREE( phy_font->font_id );
672 FT_FREE( phy_font->family_name );
673 FT_FREE( phy_font->style_name );
674
675 FT_FREE( phy_font->vertical.stem_snaps );
676 phy_font->vertical.num_stem_snaps = 0;
677
678 phy_font->horizontal.stem_snaps = NULL;
679 phy_font->horizontal.num_stem_snaps = 0;
680
681 FT_FREE( phy_font->strikes );
682 phy_font->num_strikes = 0;
683 phy_font->max_strikes = 0;
684
685 FT_FREE( phy_font->chars );
686 phy_font->num_chars = 0;
687 phy_font->chars_offset = 0;
688
689 FT_FREE( phy_font->blue_values );
690 phy_font->num_blue_values = 0;
691
692 {
693 PFR_KernItem item, next;
694
695
696 item = phy_font->kern_items;
697 while ( item )
698 {
699 next = item->next;
700 FT_FREE( item );
701 item = next;
702 }
703 phy_font->kern_items = NULL;
704 phy_font->kern_items_tail = NULL;
705 }
706
707 phy_font->num_kern_pairs = 0;
708 }
709
710
711 FT_LOCAL_DEF( FT_Error )
712 pfr_phy_font_load( PFR_PhyFont phy_font,
713 FT_Stream stream,
714 FT_UInt32 offset,
715 FT_UInt32 size )
716 {
717 FT_Error error;
718 FT_Memory memory = stream->memory;
719 FT_UInt flags;
720 FT_ULong num_aux;
721 FT_Byte* p;
722 FT_Byte* limit;
723
724
725 phy_font->memory = memory;
726 phy_font->offset = offset;
727
728 phy_font->kern_items = NULL;
729 phy_font->kern_items_tail = &phy_font->kern_items;
730
731 if ( FT_STREAM_SEEK( offset ) || FT_FRAME_ENTER( size ) )
732 goto Exit;
733
734 phy_font->cursor = stream->cursor;
735
736 p = stream->cursor;
737 limit = p + size;
738
739 PFR_CHECK( 15 );
740 phy_font->font_ref_number = PFR_NEXT_USHORT( p );
741 phy_font->outline_resolution = PFR_NEXT_USHORT( p );
742 phy_font->metrics_resolution = PFR_NEXT_USHORT( p );
743 phy_font->bbox.xMin = PFR_NEXT_SHORT( p );
744 phy_font->bbox.yMin = PFR_NEXT_SHORT( p );
745 phy_font->bbox.xMax = PFR_NEXT_SHORT( p );
746 phy_font->bbox.yMax = PFR_NEXT_SHORT( p );
747 phy_font->flags = flags = PFR_NEXT_BYTE( p );
748
749 /* get the standard advance for non-proportional fonts */
750 if ( !(flags & PFR_PHY_PROPORTIONAL) )
751 {
752 PFR_CHECK( 2 );
753 phy_font->standard_advance = PFR_NEXT_SHORT( p );
754 }
755
756 /* load the extra items when present */
757 if ( flags & PFR_PHY_EXTRA_ITEMS )
758 {
759 error = pfr_extra_items_parse( &p, limit,
760 pfr_phy_font_extra_items, phy_font );
761
762 if ( error )
763 goto Fail;
764 }
765
766 /* In certain fonts, the auxiliary bytes contain interesting */
767 /* information. These are not in the specification but can be */
768 /* guessed by looking at the content of a few PFR0 fonts. */
769 PFR_CHECK( 3 );
770 num_aux = PFR_NEXT_ULONG( p );
771
772 if ( num_aux > 0 )
773 {
774 FT_Byte* q = p;
775 FT_Byte* q2;
776
777
778 PFR_CHECK( num_aux );
779 p += num_aux;
780
781 while ( num_aux > 0 )
782 {
783 FT_UInt length, type;
784
785
786 if ( q + 4 > p )
787 break;
788
789 length = PFR_NEXT_USHORT( q );
790 if ( length < 4 || length > num_aux )
791 break;
792
793 q2 = q + length - 2;
794 type = PFR_NEXT_USHORT( q );
795
796 switch ( type )
797 {
798 case 1:
799 /* this seems to correspond to the font's family name,
800 * padded to 16-bits with one zero when necessary
801 */
802 error = pfr_aux_name_load( q, length - 4U, memory,
803 &phy_font->family_name );
804 if ( error )
805 goto Exit;
806 break;
807
808 case 2:
809 if ( q + 32 > q2 )
810 break;
811
812 q += 10;
813 phy_font->ascent = PFR_NEXT_SHORT( q );
814 phy_font->descent = PFR_NEXT_SHORT( q );
815 phy_font->leading = PFR_NEXT_SHORT( q );
816 q += 16;
817 break;
818
819 case 3:
820 /* this seems to correspond to the font's style name,
821 * padded to 16-bits with one zero when necessary
822 */
823 error = pfr_aux_name_load( q, length - 4U, memory,
824 &phy_font->style_name );
825 if ( error )
826 goto Exit;
827 break;
828
829 default:
830 ;
831 }
832
833 q = q2;
834 num_aux -= length;
835 }
836 }
837
838 /* read the blue values */
839 {
840 FT_UInt n, count;
841
842
843 PFR_CHECK( 1 );
844 phy_font->num_blue_values = count = PFR_NEXT_BYTE( p );
845
846 PFR_CHECK( count * 2 );
847
848 if ( FT_NEW_ARRAY( phy_font->blue_values, count ) )
849 goto Fail;
850
851 for ( n = 0; n < count; n++ )
852 phy_font->blue_values[n] = PFR_NEXT_SHORT( p );
853 }
854
855 PFR_CHECK( 8 );
856 phy_font->blue_fuzz = PFR_NEXT_BYTE( p );
857 phy_font->blue_scale = PFR_NEXT_BYTE( p );
858
859 phy_font->vertical.standard = PFR_NEXT_USHORT( p );
860 phy_font->horizontal.standard = PFR_NEXT_USHORT( p );
861
862 /* read the character descriptors */
863 {
864 FT_UInt n, count, Size;
865
866
867 phy_font->num_chars = count = PFR_NEXT_USHORT( p );
868 phy_font->chars_offset = offset + ( p - stream->cursor );
869
870 if ( FT_NEW_ARRAY( phy_font->chars, count ) )
871 goto Fail;
872
873 Size = 1 + 1 + 2;
874 if ( flags & PFR_PHY_2BYTE_CHARCODE )
875 Size += 1;
876
877 if ( flags & PFR_PHY_PROPORTIONAL )
878 Size += 2;
879
880 if ( flags & PFR_PHY_ASCII_CODE )
881 Size += 1;
882
883 if ( flags & PFR_PHY_2BYTE_GPS_SIZE )
884 Size += 1;
885
886 if ( flags & PFR_PHY_3BYTE_GPS_OFFSET )
887 Size += 1;
888
889 PFR_CHECK( count * Size );
890
891 for ( n = 0; n < count; n++ )
892 {
893 PFR_Char cur = &phy_font->chars[n];
894
895
896 cur->char_code = ( flags & PFR_PHY_2BYTE_CHARCODE )
897 ? PFR_NEXT_USHORT( p )
898 : PFR_NEXT_BYTE( p );
899
900 cur->advance = ( flags & PFR_PHY_PROPORTIONAL )
901 ? PFR_NEXT_SHORT( p )
902 : (FT_Int) phy_font->standard_advance;
903
904 #if 0
905 cur->ascii = ( flags & PFR_PHY_ASCII_CODE )
906 ? PFR_NEXT_BYTE( p )
907 : 0;
908 #else
909 if ( flags & PFR_PHY_ASCII_CODE )
910 p += 1;
911 #endif
912 cur->gps_size = ( flags & PFR_PHY_2BYTE_GPS_SIZE )
913 ? PFR_NEXT_USHORT( p )
914 : PFR_NEXT_BYTE( p );
915
916 cur->gps_offset = ( flags & PFR_PHY_3BYTE_GPS_OFFSET )
917 ? PFR_NEXT_ULONG( p )
918 : PFR_NEXT_USHORT( p );
919 }
920 }
921
922 /* that's it! */
923
924 Fail:
925 FT_FRAME_EXIT();
926
927 /* save position of bitmap info */
928 phy_font->bct_offset = FT_STREAM_POS();
929 phy_font->cursor = NULL;
930
931 Exit:
932 return error;
933
934 Too_Short:
935 error = PFR_Err_Invalid_Table;
936 FT_ERROR(( "pfr_phy_font_load: invalid physical font table\n" ));
937 goto Fail;
938 }
939
940
941 /* END */
FT_ALLOC
#define FT_ALLOC(ptr, size)
Definition: ftmemory.h:260
PFR_Header
FT_BEGIN_HEADER struct PFR_HeaderRec_ * PFR_Header
pfr_header_load
pfr_header_load(PFR_Header header, FT_Stream stream)
Definition: pfrload.c:153
FT_Error
int FT_Error
Definition: fttypes.h:296
FT_PtrDist
ft_ptrdiff_t FT_PtrDist
Definition: fttypes.h:333
PFR_PhyFontRec_
Definition: pfrtypes.h:222
pfr_extra_item_load_stem_snaps
pfr_extra_item_load_stem_snaps(FT_Byte *p, FT_Byte *limit, PFR_PhyFont phy_font)
Definition: pfrload.c:474
header
cannot open resource broken file module version is too low unimplemented feature broken offset within table missing module invalid character code cannot render this glyph format invalid composite glyph invalid pixel size invalid library handle invalid face handle invalid glyph slot handle invalid cache manager handle too many modules out of memory cannot open stream invalid stream skip invalid stream operation nested frame access raster uninitialized raster overflow too many registered caches too few arguments code overflow division by zero found debug opcode nested DEFS execution context too long too many instruction definitions horizontal header(hhea) table missing" ) FT_ERRORDEF_( Locations_Missing
FT_ULong
unsigned long FT_ULong
Definition: fttypes.h:249
FT_FRAME_UOFF3
#define FT_FRAME_UOFF3(f)
Definition: ftstream.h:125
PFR_CHECK
#define PFR_CHECK(x)
Definition: pfrload.h:31
type
GLint GLenum GLsizei GLsizei GLsizei GLint GLenum GLenum type
Definition: gl2ext.h:845
PFR_NEXT_LONG
#define PFR_NEXT_LONG(p)
Definition: pfrload.h:42
pfr_phy_font_extra_items
static const PFR_ExtraItemRec pfr_phy_font_extra_items[]
Definition: pfrload.c:615
NULL
#define NULL
Definition: ftobjs.h:61
PFR_KernItemRec_::pair_count
FT_Byte pair_count
Definition: pfrtypes.h:199
FT_Int
signed int FT_Int
Definition: fttypes.h:216
FT_Frame_Field_
Definition: ftstream.h:86
PFR_KernItemRec_::pair_size
FT_UInt pair_size
Definition: pfrtypes.h:202
stream
GLuint GLuint stream
Definition: glew.h:6573
n
GLclampd n
Definition: glew.h:7287
local
#define local
Definition: zutil.h:30
PFR_KernItemRec_::base_adj
FT_Short base_adj
Definition: pfrtypes.h:201
pfr_header_check
pfr_header_check(PFR_Header header)
Definition: pfrload.c:173
pp
png_sPLT_entryp pp
Definition: pngrutil.c:1375
PFR_STRIKE_2BYTE_YPPM
Definition: pfrtypes.h:145
PFR_PHY_ASCII_CODE
Definition: pfrtypes.h:274
version
int const char * version
Definition: zlib.h:813
PFR_CharRec_::gps_offset
FT_UInt32 gps_offset
Definition: pfrtypes.h:177
FT_READ_UOFF3
#define FT_READ_UOFF3(var)
Definition: ftstream.h:318
FT_READ_USHORT
#define FT_READ_USHORT(var)
Definition: ftstream.h:316
len
GLenum GLsizei len
Definition: glew.h:7035
PFR_KernItemRec_::next
PFR_KernItem next
Definition: pfrtypes.h:198
PFR_KernItemRec_::pair2
FT_UInt32 pair2
Definition: pfrtypes.h:205
FT_Bool
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:104
pfrerror.h
PFR_LOG_STROKE
Definition: pfrtypes.h:105
PFR_CharRec_::char_code
FT_UInt char_code
Definition: pfrtypes.h:174
PFR_StrikeRec_::flags
FT_UInt flags
Definition: pfrtypes.h:155
PFR_ExtraItemRec_::type
FT_UInt type
Definition: pfrload.h:55
pfr_log_font_count
pfr_log_font_count(FT_Stream stream, FT_UInt32 section_offset, FT_UInt *acount)
Definition: pfrload.c:200
pfr_aux_name_load
static FT_Error pfr_aux_name_load(FT_Byte *p, FT_UInt len, FT_Memory memory, FT_String **astring)
Definition: pfrload.c:629
FT_ERROR
#define FT_ERROR(varformat)
Definition: ftdebug.h:181
FT_PAD_CEIL
#define FT_PAD_CEIL(x, n)
Definition: ftobjs.h:78
PFR_PHY_2BYTE_CHARCODE
Definition: pfrtypes.h:276
FT_Byte
unsigned char FT_Byte
Definition: fttypes.h:150
pfr_header_fields
static const FT_Frame_Field pfr_header_fields[]
Definition: pfrload.c:107
PFR_LogFontRec_
Definition: pfrtypes.h:82
pfr_extra_items_skip
pfr_extra_items_skip(FT_Byte **pp, FT_Byte *limit)
Definition: pfrload.c:39
FT_STREAM_READ_FIELDS
#define FT_STREAM_READ_FIELDS(fields, object)
Definition: ftstream.h:513
PFR_LINE_JOIN_MASK
Definition: pfrtypes.h:106
PFR_ExtraItem_ParseFunc
FT_Error(* PFR_ExtraItem_ParseFunc)(FT_Byte *p, FT_Byte *limit, FT_Pointer data)
Definition: pfrload.h:49
FT_FREE
#define FT_FREE(ptr)
Definition: ftmemory.h:286
FT_FRAME_END
#define FT_FRAME_END
Definition: ftstream.h:118
FT_STREAM_SKIP
#define FT_STREAM_SKIP(distance)
Definition: ftstream.h:499
PFR_CharRec_::gps_size
FT_UInt gps_size
Definition: pfrtypes.h:176
result
GLuint64EXT * result
Definition: glew.h:12708
PFR_STRIKE_3BYTE_SIZE
Definition: pfrtypes.h:144
FT_FRAME_USHORT
#define FT_FRAME_USHORT(f)
Definition: ftstream.h:123
FT_LOCAL_DEF
#define FT_LOCAL_DEF(x)
Definition: ftconfig.h:467
PFR_StrikeRec_::y_ppm
FT_UInt y_ppm
Definition: pfrtypes.h:154
idx
FT_UInt idx
Definition: cffcmap.c:125
pfr_phy_font_load
pfr_phy_font_load(PFR_PhyFont phy_font, FT_Stream stream, FT_UInt32 offset, FT_UInt32 size)
Definition: pfrload.c:712
length
GLsizei GLsizei * length
Definition: gl2ext.h:792
error
FT_Error error
Definition: cffdrivr.c:407
pfr_extra_item_load_bitmap_info
pfr_extra_item_load_bitmap_info(FT_Byte *p, FT_Byte *limit, PFR_PhyFont phy_font)
Definition: pfrload.c:348
PFR_LOG_BOLD
Definition: pfrtypes.h:103
FT_String
char FT_String
Definition: fttypes.h:183
FT_Pointer
void * FT_Pointer
Definition: fttypes.h:307
count
GLint GLsizei count
Definition: gl2ext.h:1011
PFR_ExtraItemRec_::parser
PFR_ExtraItem_ParseFunc parser
Definition: pfrload.h:56
PFR_LOG_2BYTE_BOLD
Definition: pfrtypes.h:102
p
GLfloat GLfloat p
Definition: glew.h:14938
PFR_STRIKE_2BYTE_COUNT
Definition: pfrtypes.h:142
FT_TRACE2
#define FT_TRACE2(varformat)
Definition: ftdebug.h:159
limit
GLint limit
Definition: glew.h:11829
pfr_log_font_load
pfr_log_font_load(PFR_LogFont log_font, FT_Stream stream, FT_UInt idx, FT_UInt32 section_offset, FT_Bool size_increment)
Definition: pfrload.c:221
FT_RENEW_ARRAY
#define FT_RENEW_ARRAY(ptr, curcnt, newcnt)
Definition: ftmemory.h:293
PFR_PHY_PROPORTIONAL
Definition: pfrtypes.h:275
PFR_STRIKE_3BYTE_OFFSET
Definition: pfrtypes.h:143
FT_CALLBACK_DEF
#define FT_CALLBACK_DEF(x)
Definition: ftconfig.h:554
pfr_extra_items_parse
pfr_extra_items_parse(FT_Byte **pp, FT_Byte *limit, PFR_ExtraItem item_list, FT_Pointer item_data)
Definition: pfrload.c:47
pfrload.h
PFR_StrikeRec_
Definition: pfrtypes.h:151
PFR_StrikeRec_::num_bitmaps
FT_UInt num_bitmaps
Definition: pfrtypes.h:164
FT_Memory
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
PFR_KernItemRec_
Definition: pfrtypes.h:196
FT_FRAME_EXIT
#define FT_FRAME_EXIT()
Definition: ftstream.h:521
FT_NEW_ARRAY
#define FT_NEW_ARRAY(ptr, count)
Definition: ftmemory.h:290
FT_STREAM_SEEK
#define FT_STREAM_SEEK(position)
Definition: ftstream.h:496
PFR_StrikeRec_::x_ppm
FT_UInt x_ppm
Definition: pfrtypes.h:153
PFR_KernItemRec_::flags
FT_Byte flags
Definition: pfrtypes.h:200
FT_STREAM_POS
#define FT_STREAM_POS()
Definition: ftstream.h:493
PFR_PHY_2BYTE_GPS_SIZE
Definition: pfrtypes.h:273
pfr_extra_item_load_kerning_pairs
pfr_extra_item_load_kerning_pairs(FT_Byte *p, FT_Byte *limit, PFR_PhyFont phy_font)
Definition: pfrload.c:519
offset
GLintptr offset
Definition: glew.h:1668
FT_FRAME_ULONG
#define FT_FRAME_ULONG(f)
Definition: ftstream.h:121
flags
GLenum GLsizei GLsizei GLsizei GLsizei GLbitfield flags
Definition: glew.h:2767
FT_UInt
unsigned int FT_UInt
Definition: fttypes.h:227
q
GLdouble GLdouble GLdouble GLdouble q
Definition: glew.h:1400
PFR_KERN_INDEX
#define PFR_KERN_INDEX(g1, g2)
Definition: pfrtypes.h:210
FT_FRAME_BYTE
#define FT_FRAME_BYTE(f)
Definition: ftstream.h:126
PFR_CharRec_::advance
FT_Int advance
Definition: pfrtypes.h:175
PFR_LINE_JOIN_MITER
Definition: pfrtypes.h:113
PFR_StrikeRec_::bct_offset
FT_UInt32 bct_offset
Definition: pfrtypes.h:161
PFR_KernItemRec_::pair1
FT_UInt32 pair1
Definition: pfrtypes.h:204
PFR_ExtraItemRec_
Definition: pfrload.h:53
PFR_NEXT_BYTE
#define PFR_NEXT_BYTE(p)
Definition: pfrload.h:38
PFR_KernItemRec_::offset
FT_Offset offset
Definition: pfrtypes.h:203
pfr_extra_item_load_font_id
pfr_extra_item_load_font_id(FT_Byte *p, FT_Byte *limit, PFR_PhyFont phy_font)
Definition: pfrload.c:448
FT_FRAME_ENTER
#define FT_FRAME_ENTER(size)
Definition: ftstream.h:517
PFR_PHY_EXTRA_ITEMS
Definition: pfrtypes.h:271
PFR_KERN_2BYTE_CHAR
Definition: pfrtypes.h:284
PFR_PHY_3BYTE_GPS_OFFSET
Definition: pfrtypes.h:272
PFR_STRIKE_2BYTE_XPPM
Definition: pfrtypes.h:146
FT_NEW
#define FT_NEW(ptr)
Definition: ftmemory.h:288
PFR_StrikeRec_::bct_size
FT_UInt32 bct_size
Definition: pfrtypes.h:160
PFR_NEXT_USHORT
#define PFR_NEXT_USHORT(p)
Definition: pfrload.h:41
PFR_KERN_2BYTE_ADJ
Definition: pfrtypes.h:285
FT_MEM_COPY
#define FT_MEM_COPY(dest, source, count)
Definition: ftmemory.h:203
PFR_NEXT_ULONG
#define PFR_NEXT_ULONG(p)
Definition: pfrload.h:43
FT_NEXT_SHORT
#define FT_NEXT_SHORT(buffer)
Definition: ftstream.h:230
pfr_phy_font_done
pfr_phy_font_done(PFR_PhyFont phy_font, FT_Memory memory)
Definition: pfrload.c:668
FT_StreamRec_
Definition: ftsystem.h:321
PFR_CharRec_
Definition: pfrtypes.h:172
PFR_LOG_2BYTE_STROKE
Definition: pfrtypes.h:104
PFR_LOG_EXTRA_ITEMS
Definition: pfrtypes.h:101
FT_FRAME_START
#define FT_FRAME_START(size)
Definition: ftstream.h:117
PFR_NEXT_SHORT
#define PFR_NEXT_SHORT(p)
Definition: pfrload.h:40
size
GLsizei size
Definition: gl2ext.h:1467