projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge to trunk head (r46631)
[reactos.git] / lib / 3rdparty / freetype / src / pfr / pfrload.c
1 /***************************************************************************/
2 /* */
3 /* pfrload.c */
4 /* */
5 /* FreeType PFR loader (body). */
6 /* */
7 /* Copyright 2002, 2003, 2004, 2005, 2007 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 = 0;
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 = 0;
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: invalid bitmap info table\n" ));
432 goto Exit;
433 }
434
435
436 /* Load font ID. This is a so-called "unique" name that is rather
437 * long and descriptive (like "Tiresias ScreenFont v7.51").
438 *
439 * Note that a PFR font's family name is contained in an *undocumented*
440 * string of the "auxiliary data" portion of a physical font record. This
441 * may also contain the "real" style name!
442 *
443 * If no family name is present, the font ID is used instead for the
444 * family.
445 */
446 FT_CALLBACK_DEF( FT_Error )
447 pfr_extra_item_load_font_id( FT_Byte* p,
448 FT_Byte* limit,
449 PFR_PhyFont phy_font )
450 {
451 FT_Error error = 0;
452 FT_Memory memory = phy_font->memory;
453 FT_PtrDist len = limit - p;
454
455
456 if ( phy_font->font_id != NULL )
457 goto Exit;
458
459 if ( FT_ALLOC( phy_font->font_id, len + 1 ) )
460 goto Exit;
461
462 /* copy font ID name, and terminate it for safety */
463 FT_MEM_COPY( phy_font->font_id, p, len );
464 phy_font->font_id[len] = 0;
465
466 Exit:
467 return error;
468 }
469
470
471 /* load stem snap tables */
472 FT_CALLBACK_DEF( FT_Error )
473 pfr_extra_item_load_stem_snaps( FT_Byte* p,
474 FT_Byte* limit,
475 PFR_PhyFont phy_font )
476 {
477 FT_UInt count, num_vert, num_horz;
478 FT_Int* snaps;
479 FT_Error error = 0;
480 FT_Memory memory = phy_font->memory;
481
482
483 if ( phy_font->vertical.stem_snaps != NULL )
484 goto Exit;
485
486 PFR_CHECK( 1 );
487 count = PFR_NEXT_BYTE( p );
488
489 num_vert = count & 15;
490 num_horz = count >> 4;
491 count = num_vert + num_horz;
492
493 PFR_CHECK( count * 2 );
494
495 if ( FT_NEW_ARRAY( snaps, count ) )
496 goto Exit;
497
498 phy_font->vertical.stem_snaps = snaps;
499 phy_font->horizontal.stem_snaps = snaps + num_vert;
500
501 for ( ; count > 0; count--, snaps++ )
502 *snaps = FT_NEXT_SHORT( p );
503
504 Exit:
505 return error;
506
507 Too_Short:
508 error = PFR_Err_Invalid_Table;
509 FT_ERROR(( "pfr_exta_item_load_stem_snaps: invalid stem snaps table\n" ));
510 goto Exit;
511 }
512
513
514
515 /* load kerning pair data */
516 FT_CALLBACK_DEF( FT_Error )
517 pfr_extra_item_load_kerning_pairs( FT_Byte* p,
518 FT_Byte* limit,
519 PFR_PhyFont phy_font )
520 {
521 PFR_KernItem item;
522 FT_Error error = 0;
523 FT_Memory memory = phy_font->memory;
524
525
526 FT_TRACE2(( "pfr_extra_item_load_kerning_pairs()\n" ));
527
528 if ( FT_NEW( item ) )
529 goto Exit;
530
531 PFR_CHECK( 4 );
532
533 item->pair_count = PFR_NEXT_BYTE( p );
534 item->base_adj = PFR_NEXT_SHORT( p );
535 item->flags = PFR_NEXT_BYTE( p );
536 item->offset = phy_font->offset + ( p - phy_font->cursor );
537
538 #ifndef PFR_CONFIG_NO_CHECKS
539 item->pair_size = 3;
540
541 if ( item->flags & PFR_KERN_2BYTE_CHAR )
542 item->pair_size += 2;
543
544 if ( item->flags & PFR_KERN_2BYTE_ADJ )
545 item->pair_size += 1;
546
547 PFR_CHECK( item->pair_count * item->pair_size );
548 #endif
549
550 /* load first and last pairs into the item to speed up */
551 /* lookup later... */
552 if ( item->pair_count > 0 )
553 {
554 FT_UInt char1, char2;
555 FT_Byte* q;
556
557
558 if ( item->flags & PFR_KERN_2BYTE_CHAR )
559 {
560 q = p;
561 char1 = PFR_NEXT_USHORT( q );
562 char2 = PFR_NEXT_USHORT( q );
563
564 item->pair1 = PFR_KERN_INDEX( char1, char2 );
565
566 q = p + item->pair_size * ( item->pair_count - 1 );
567 char1 = PFR_NEXT_USHORT( q );
568 char2 = PFR_NEXT_USHORT( q );
569
570 item->pair2 = PFR_KERN_INDEX( char1, char2 );
571 }
572 else
573 {
574 q = p;
575 char1 = PFR_NEXT_BYTE( q );
576 char2 = PFR_NEXT_BYTE( q );
577
578 item->pair1 = PFR_KERN_INDEX( char1, char2 );
579
580 q = p + item->pair_size * ( item->pair_count - 1 );
581 char1 = PFR_NEXT_BYTE( q );
582 char2 = PFR_NEXT_BYTE( q );
583
584 item->pair2 = PFR_KERN_INDEX( char1, char2 );
585 }
586
587 /* add new item to the current list */
588 item->next = NULL;
589 *phy_font->kern_items_tail = item;
590 phy_font->kern_items_tail = &item->next;
591 phy_font->num_kern_pairs += item->pair_count;
592 }
593 else
594 {
595 /* empty item! */
596 FT_FREE( item );
597 }
598
599 Exit:
600 return error;
601
602 Too_Short:
603 FT_FREE( item );
604
605 error = PFR_Err_Invalid_Table;
606 FT_ERROR(( "pfr_extra_item_load_kerning_pairs: "
607 "invalid kerning pairs table\n" ));
608 goto Exit;
609 }
610
611
612
613 static const PFR_ExtraItemRec pfr_phy_font_extra_items[] =
614 {
615 { 1, (PFR_ExtraItem_ParseFunc)pfr_extra_item_load_bitmap_info },
616 { 2, (PFR_ExtraItem_ParseFunc)pfr_extra_item_load_font_id },
617 { 3, (PFR_ExtraItem_ParseFunc)pfr_extra_item_load_stem_snaps },
618 { 4, (PFR_ExtraItem_ParseFunc)pfr_extra_item_load_kerning_pairs },
619 { 0, NULL }
620 };
621
622
623 /* Loads a name from the auxiliary data. Since this extracts undocumented
624 * strings from the font file, we need to be careful here.
625 */
626 static FT_Error
627 pfr_aux_name_load( FT_Byte* p,
628 FT_UInt len,
629 FT_Memory memory,
630 FT_String* *astring )
631 {
632 FT_Error error = 0;
633 FT_String* result = NULL;
634 FT_UInt n, ok;
635
636
637 if ( len > 0 && p[len - 1] == 0 )
638 len--;
639
640 /* check that each character is ASCII for making sure not to
641 load garbage
642 */
643 ok = ( len > 0 );
644 for ( n = 0; n < len; n++ )
645 if ( p[n] < 32 || p[n] > 127 )
646 {
647 ok = 0;
648 break;
649 }
650
651 if ( ok )
652 {
653 if ( FT_ALLOC( result, len + 1 ) )
654 goto Exit;
655
656 FT_MEM_COPY( result, p, len );
657 result[len] = 0;
658 }
659 Exit:
660 *astring = result;
661 return error;
662 }
663
664
665 FT_LOCAL_DEF( void )
666 pfr_phy_font_done( PFR_PhyFont phy_font,
667 FT_Memory memory )
668 {
669 FT_FREE( phy_font->font_id );
670 FT_FREE( phy_font->family_name );
671 FT_FREE( phy_font->style_name );
672
673 FT_FREE( phy_font->vertical.stem_snaps );
674 phy_font->vertical.num_stem_snaps = 0;
675
676 phy_font->horizontal.stem_snaps = NULL;
677 phy_font->horizontal.num_stem_snaps = 0;
678
679 FT_FREE( phy_font->strikes );
680 phy_font->num_strikes = 0;
681 phy_font->max_strikes = 0;
682
683 FT_FREE( phy_font->chars );
684 phy_font->num_chars = 0;
685 phy_font->chars_offset = 0;
686
687 FT_FREE( phy_font->blue_values );
688 phy_font->num_blue_values = 0;
689
690 {
691 PFR_KernItem item, next;
692
693
694 item = phy_font->kern_items;
695 while ( item )
696 {
697 next = item->next;
698 FT_FREE( item );
699 item = next;
700 }
701 phy_font->kern_items = NULL;
702 phy_font->kern_items_tail = NULL;
703 }
704
705 phy_font->num_kern_pairs = 0;
706 }
707
708
709 FT_LOCAL_DEF( FT_Error )
710 pfr_phy_font_load( PFR_PhyFont phy_font,
711 FT_Stream stream,
712 FT_UInt32 offset,
713 FT_UInt32 size )
714 {
715 FT_Error error;
716 FT_Memory memory = stream->memory;
717 FT_UInt flags, num_aux;
718 FT_Byte* p;
719 FT_Byte* limit;
720
721
722 phy_font->memory = memory;
723 phy_font->offset = offset;
724
725 phy_font->kern_items = NULL;
726 phy_font->kern_items_tail = &phy_font->kern_items;
727
728 if ( FT_STREAM_SEEK( offset ) || FT_FRAME_ENTER( size ) )
729 goto Exit;
730
731 phy_font->cursor = stream->cursor;
732
733 p = stream->cursor;
734 limit = p + size;
735
736 PFR_CHECK( 15 );
737 phy_font->font_ref_number = PFR_NEXT_USHORT( p );
738 phy_font->outline_resolution = PFR_NEXT_USHORT( p );
739 phy_font->metrics_resolution = PFR_NEXT_USHORT( p );
740 phy_font->bbox.xMin = PFR_NEXT_SHORT( p );
741 phy_font->bbox.yMin = PFR_NEXT_SHORT( p );
742 phy_font->bbox.xMax = PFR_NEXT_SHORT( p );
743 phy_font->bbox.yMax = PFR_NEXT_SHORT( p );
744 phy_font->flags = flags = PFR_NEXT_BYTE( p );
745
746 /* get the standard advance for non-proportional fonts */
747 if ( !(flags & PFR_PHY_PROPORTIONAL) )
748 {
749 PFR_CHECK( 2 );
750 phy_font->standard_advance = PFR_NEXT_SHORT( p );
751 }
752
753 /* load the extra items when present */
754 if ( flags & PFR_PHY_EXTRA_ITEMS )
755 {
756 error = pfr_extra_items_parse( &p, limit,
757 pfr_phy_font_extra_items, phy_font );
758
759 if ( error )
760 goto Fail;
761 }
762
763 /* In certain fonts, the auxiliary bytes contain interesting */
764 /* information. These are not in the specification but can be */
765 /* guessed by looking at the content of a few PFR0 fonts. */
766 PFR_CHECK( 3 );
767 num_aux = PFR_NEXT_ULONG( p );
768
769 if ( num_aux > 0 )
770 {
771 FT_Byte* q = p;
772 FT_Byte* q2;
773
774
775 PFR_CHECK( num_aux );
776 p += num_aux;
777
778 while ( num_aux > 0 )
779 {
780 FT_UInt length, type;
781
782
783 if ( q + 4 > p )
784 break;
785
786 length = PFR_NEXT_USHORT( q );
787 if ( length < 4 || length > num_aux )
788 break;
789
790 q2 = q + length - 2;
791 type = PFR_NEXT_USHORT( q );
792
793 switch ( type )
794 {
795 case 1:
796 /* this seems to correspond to the font's family name,
797 * padded to 16-bits with one zero when necessary
798 */
799 error = pfr_aux_name_load( q, length - 4U, memory,
800 &phy_font->family_name );
801 if ( error )
802 goto Exit;
803 break;
804
805 case 2:
806 if ( q + 32 > q2 )
807 break;
808
809 q += 10;
810 phy_font->ascent = PFR_NEXT_SHORT( q );
811 phy_font->descent = PFR_NEXT_SHORT( q );
812 phy_font->leading = PFR_NEXT_SHORT( q );
813 q += 16;
814 break;
815
816 case 3:
817 /* this seems to correspond to the font's style name,
818 * padded to 16-bits with one zero when necessary
819 */
820 error = pfr_aux_name_load( q, length - 4U, memory,
821 &phy_font->style_name );
822 if ( error )
823 goto Exit;
824 break;
825
826 default:
827 ;
828 }
829
830 q = q2;
831 num_aux -= length;
832 }
833 }
834
835 /* read the blue values */
836 {
837 FT_UInt n, count;
838
839
840 PFR_CHECK( 1 );
841 phy_font->num_blue_values = count = PFR_NEXT_BYTE( p );
842
843 PFR_CHECK( count * 2 );
844
845 if ( FT_NEW_ARRAY( phy_font->blue_values, count ) )
846 goto Fail;
847
848 for ( n = 0; n < count; n++ )
849 phy_font->blue_values[n] = PFR_NEXT_SHORT( p );
850 }
851
852 PFR_CHECK( 8 );
853 phy_font->blue_fuzz = PFR_NEXT_BYTE( p );
854 phy_font->blue_scale = PFR_NEXT_BYTE( p );
855
856 phy_font->vertical.standard = PFR_NEXT_USHORT( p );
857 phy_font->horizontal.standard = PFR_NEXT_USHORT( p );
858
859 /* read the character descriptors */
860 {
861 FT_UInt n, count, Size;
862
863
864 phy_font->num_chars = count = PFR_NEXT_USHORT( p );
865 phy_font->chars_offset = offset + ( p - stream->cursor );
866
867 if ( FT_NEW_ARRAY( phy_font->chars, count ) )
868 goto Fail;
869
870 Size = 1 + 1 + 2;
871 if ( flags & PFR_PHY_2BYTE_CHARCODE )
872 Size += 1;
873
874 if ( flags & PFR_PHY_PROPORTIONAL )
875 Size += 2;
876
877 if ( flags & PFR_PHY_ASCII_CODE )
878 Size += 1;
879
880 if ( flags & PFR_PHY_2BYTE_GPS_SIZE )
881 Size += 1;
882
883 if ( flags & PFR_PHY_3BYTE_GPS_OFFSET )
884 Size += 1;
885
886 PFR_CHECK( count * Size );
887
888 for ( n = 0; n < count; n++ )
889 {
890 PFR_Char cur = &phy_font->chars[n];
891
892
893 cur->char_code = ( flags & PFR_PHY_2BYTE_CHARCODE )
894 ? PFR_NEXT_USHORT( p )
895 : PFR_NEXT_BYTE( p );
896
897 cur->advance = ( flags & PFR_PHY_PROPORTIONAL )
898 ? PFR_NEXT_SHORT( p )
899 : (FT_Int) phy_font->standard_advance;
900
901 #if 0
902 cur->ascii = ( flags & PFR_PHY_ASCII_CODE )
903 ? PFR_NEXT_BYTE( p )
904 : 0;
905 #else
906 if ( flags & PFR_PHY_ASCII_CODE )
907 p += 1;
908 #endif
909 cur->gps_size = ( flags & PFR_PHY_2BYTE_GPS_SIZE )
910 ? PFR_NEXT_USHORT( p )
911 : PFR_NEXT_BYTE( p );
912
913 cur->gps_offset = ( flags & PFR_PHY_3BYTE_GPS_OFFSET )
914 ? PFR_NEXT_ULONG( p )
915 : PFR_NEXT_USHORT( p );
916 }
917 }
918
919 /* that's it! */
920
921 Fail:
922 FT_FRAME_EXIT();
923
924 /* save position of bitmap info */
925 phy_font->bct_offset = FT_STREAM_POS();
926 phy_font->cursor = NULL;
927
928 Exit:
929 return error;
930
931 Too_Short:
932 error = PFR_Err_Invalid_Table;
933 FT_ERROR(( "pfr_phy_font_load: invalid physical font table\n" ));
934 goto Fail;
935 }
936
937
938 /* END */
A free Windows-compatible Operating System