Visualization Library 2.0.0-b5

A lightweight C++ OpenGL middleware for 2D/3D graphics

VL     Star     Watch     Fork     Issue

[Download] [Tutorials] [All Classes] [Grouped Classes]
pfrload.c
Go to the documentation of this file.
1 /***************************************************************************/
2 /* */
3 /* pfrload.c */
4 /* */
5 /* FreeType PFR loader (body). */
6 /* */
7 /* Copyright 2002-2005, 2007, 2009, 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 "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 
40  FT_Byte* limit )
41  {
42  return pfr_extra_items_parse( pp, limit, NULL, NULL );
43  }
44 
45 
48  FT_Byte* limit,
49  PFR_ExtraItem item_list,
50  FT_Pointer item_data )
51  {
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 = FT_THROW( 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 ),
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 ),
149  };
150 
151 
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 
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 
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 
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;
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 FT_THROW( 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 
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 
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 = FT_THROW( 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 */
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;
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 = FT_THROW( 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  */
449  FT_Byte* limit,
450  PFR_PhyFont phy_font )
451  {
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 */
475  FT_Byte* limit,
476  PFR_PhyFont phy_font )
477  {
478  FT_UInt count, num_vert, num_horz;
479  FT_Int* snaps = NULL;
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 = FT_THROW( 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 */
520  FT_Byte* limit,
521  PFR_PhyFont phy_font )
522  {
523  PFR_KernItem item = NULL;
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 = FT_THROW( 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  {
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  {
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 )
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 
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  {
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  {
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;
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 
884  Size += 1;
885 
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 
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
913  ? PFR_NEXT_USHORT( p )
914  : PFR_NEXT_BYTE( p );
915 
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 = FT_THROW( Invalid_Table );
936  FT_ERROR(( "pfr_phy_font_load: invalid physical font table\n" ));
937  goto Fail;
938  }
939 
940 
941 /* END */
GLenum GLuint GLenum GLsizei length
#define FT_ALLOC(ptr, size)
Definition: ftmemory.h:260
FT_BEGIN_HEADER struct PFR_HeaderRec_ * PFR_Header
pfr_header_load(PFR_Header header, FT_Stream stream)
Definition: pfrload.c:153
int FT_Error
Definition: fttypes.h:296
GLuint GLuint stream
ft_ptrdiff_t FT_PtrDist
Definition: fttypes.h:333
pfr_extra_item_load_stem_snaps(FT_Byte *p, FT_Byte *limit, PFR_PhyFont phy_font)
Definition: pfrload.c:474
unsigned long FT_ULong
Definition: fttypes.h:249
#define FT_FRAME_UOFF3(f)
Definition: ftstream.h:125
#define PFR_CHECK(x)
Definition: pfrload.h:31
GLfloat GLfloat p
#define PFR_NEXT_LONG(p)
Definition: pfrload.h:42
#define NULL
Definition: ftobjs.h:61
FT_Byte pair_count
Definition: pfrtypes.h:199
signed int FT_Int
Definition: fttypes.h:216
GLdouble GLdouble GLdouble GLdouble q
FT_UInt pair_size
Definition: pfrtypes.h:202
return FT_THROW(Missing_Property)
FT_Short base_adj
Definition: pfrtypes.h:201
pfr_header_check(PFR_Header header)
Definition: pfrload.c:173
unsigned int FT_UInt32
Definition: ftconfig.h:133
FT_UInt32 gps_offset
Definition: pfrtypes.h:177
#define FT_READ_UOFF3(var)
Definition: ftstream.h:311
return FT_Err_Ok
Definition: ftbbox.c:645
#define FT_READ_USHORT(var)
Definition: ftstream.h:309
PFR_KernItem next
Definition: pfrtypes.h:198
FT_UInt32 pair2
Definition: pfrtypes.h:205
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:104
FT_UInt char_code
Definition: pfrtypes.h:174
FT_UInt flags
Definition: pfrtypes.h:155
FT_UInt type
Definition: pfrload.h:55
pfr_log_font_count(FT_Stream stream, FT_UInt32 section_offset, FT_UInt *acount)
Definition: pfrload.c:200
#define FT_ERROR(varformat)
Definition: ftdebug.h:181
#define FT_PAD_CEIL(x, n)
Definition: ftobjs.h:78
unsigned char FT_Byte
Definition: fttypes.h:150
pfr_extra_items_skip(FT_Byte **pp, FT_Byte *limit)
Definition: pfrload.c:39
#define FT_STREAM_READ_FIELDS(fields, object)
Definition: ftstream.h:506
#define FT_FREE(ptr)
Definition: ftmemory.h:286
#define FT_FRAME_END
Definition: ftstream.h:118
#define FT_STREAM_SKIP(distance)
Definition: ftstream.h:492
FT_UInt gps_size
Definition: pfrtypes.h:176
#define FT_FRAME_USHORT(f)
Definition: ftstream.h:123
FT_UInt y_ppm
Definition: pfrtypes.h:154
GLenum GLsizei len
FT_UInt idx
Definition: cffcmap.c:127
pfr_phy_font_load(PFR_PhyFont phy_font, FT_Stream stream, FT_UInt32 offset, FT_UInt32 size)
Definition: pfrload.c:712
FT_Error error
Definition: cffdrivr.c:411
pfr_extra_item_load_bitmap_info(FT_Byte *p, FT_Byte *limit, PFR_PhyFont phy_font)
Definition: pfrload.c:348
char FT_String
Definition: fttypes.h:183
void * FT_Pointer
Definition: fttypes.h:307
GLbitfield flags
PFR_ExtraItem_ParseFunc parser
Definition: pfrload.h:56
FT_Error(* PFR_ExtraItem_ParseFunc)(FT_Byte *p, FT_Byte *limit, FT_Pointer data)
Definition: pfrload.h:49
GLdouble n
#define FT_TRACE2(varformat)
Definition: ftdebug.h:159
int const char * version
Definition: zlib.h:813
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
#define FT_CALLBACK_DEF(x)
Definition: ftconfig.h:323
#define FT_RENEW_ARRAY(ptr, curcnt, newcnt)
Definition: ftmemory.h:293
GLintptr offset
pfr_extra_items_parse(FT_Byte **pp, FT_Byte *limit, PFR_ExtraItem item_list, FT_Pointer item_data)
Definition: pfrload.c:47
FT_UInt num_bitmaps
Definition: pfrtypes.h:164
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
#define FT_FRAME_EXIT()
Definition: ftstream.h:514
#define FT_NEW_ARRAY(ptr, count)
Definition: ftmemory.h:290
#define FT_STREAM_SEEK(position)
Definition: ftstream.h:489
FT_UInt x_ppm
Definition: pfrtypes.h:153
FT_Byte flags
Definition: pfrtypes.h:200
GLenum type
#define local
Definition: zutil.h:30
#define FT_STREAM_POS()
Definition: ftstream.h:486
pfr_extra_item_load_kerning_pairs(FT_Byte *p, FT_Byte *limit, PFR_PhyFont phy_font)
Definition: pfrload.c:519
#define FT_FRAME_ULONG(f)
Definition: ftstream.h:121
GLuint64EXT * result
unsigned int FT_UInt
Definition: fttypes.h:227
#define PFR_KERN_INDEX(g1, g2)
Definition: pfrtypes.h:210
#define FT_FRAME_BYTE(f)
Definition: ftstream.h:126
FT_Int advance
Definition: pfrtypes.h:175
FT_UInt32 bct_offset
Definition: pfrtypes.h:161
FT_UInt32 pair1
Definition: pfrtypes.h:204
#define PFR_NEXT_BYTE(p)
Definition: pfrload.h:38
FT_Offset offset
Definition: pfrtypes.h:203
pfr_extra_item_load_font_id(FT_Byte *p, FT_Byte *limit, PFR_PhyFont phy_font)
Definition: pfrload.c:448
GLuint GLuint GLsizei count
#define FT_FRAME_ENTER(size)
Definition: ftstream.h:510
#define FT_NEW(ptr)
Definition: ftmemory.h:288
FT_UInt32 bct_size
Definition: pfrtypes.h:160
#define PFR_NEXT_USHORT(p)
Definition: pfrload.h:41
#define FT_MEM_COPY(dest, source, count)
Definition: ftmemory.h:203
#define PFR_NEXT_ULONG(p)
Definition: pfrload.h:43
#define FT_NEXT_SHORT(buffer)
Definition: ftstream.h:223
pfr_phy_font_done(PFR_PhyFont phy_font, FT_Memory memory)
Definition: pfrload.c:668
GLsizeiptr size
#define FT_FRAME_START(size)
Definition: ftstream.h:117
GLint limit
#define PFR_NEXT_SHORT(p)
Definition: pfrload.h:40
#define FT_LOCAL_DEF(x)
Definition: ftconfig.h:236