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]
pfrgload.c
Go to the documentation of this file.
1 /***************************************************************************/
2 /* */
3 /* pfrgload.c */
4 /* */
5 /* FreeType PFR glyph loader (body). */
6 /* */
7 /* Copyright 2002, 2003, 2005, 2007, 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 "pfrgload.h"
20 #include "pfrsbit.h"
21 #include "pfrload.h" /* for macro definitions */
22 #include FT_INTERNAL_DEBUG_H
23 
24 #include "pfrerror.h"
25 
26 #undef FT_COMPONENT
27 #define FT_COMPONENT trace_pfr
28 
29 
30  /*************************************************************************/
31  /*************************************************************************/
32  /***** *****/
33  /***** PFR GLYPH BUILDER *****/
34  /***** *****/
35  /*************************************************************************/
36  /*************************************************************************/
37 
38 
39  FT_LOCAL_DEF( void )
41  FT_GlyphLoader loader )
42  {
43  FT_ZERO( glyph );
44 
45  glyph->loader = loader;
46  glyph->path_begun = 0;
47 
48  FT_GlyphLoader_Rewind( loader );
49  }
50 
51 
52  FT_LOCAL_DEF( void )
54  {
55  FT_Memory memory = glyph->loader->memory;
56 
57 
58  FT_FREE( glyph->x_control );
59  glyph->y_control = NULL;
60 
61  glyph->max_xy_control = 0;
62 #if 0
63  glyph->num_x_control = 0;
64  glyph->num_y_control = 0;
65 #endif
66 
67  FT_FREE( glyph->subs );
68 
69  glyph->max_subs = 0;
70  glyph->num_subs = 0;
71 
72  glyph->loader = NULL;
73  glyph->path_begun = 0;
74  }
75 
76 
77  /* close current contour, if any */
78  static void
79  pfr_glyph_close_contour( PFR_Glyph glyph )
80  {
81  FT_GlyphLoader loader = glyph->loader;
82  FT_Outline* outline = &loader->current.outline;
83  FT_Int last, first;
84 
85 
86  if ( !glyph->path_begun )
87  return;
88 
89  /* compute first and last point indices in current glyph outline */
90  last = outline->n_points - 1;
91  first = 0;
92  if ( outline->n_contours > 0 )
93  first = outline->contours[outline->n_contours - 1];
94 
95  /* if the last point falls on the same location than the first one */
96  /* we need to delete it */
97  if ( last > first )
98  {
99  FT_Vector* p1 = outline->points + first;
100  FT_Vector* p2 = outline->points + last;
101 
102 
103  if ( p1->x == p2->x && p1->y == p2->y )
104  {
105  outline->n_points--;
106  last--;
107  }
108  }
109 
110  /* don't add empty contours */
111  if ( last >= first )
112  outline->contours[outline->n_contours++] = (short)last;
113 
114  glyph->path_begun = 0;
115  }
116 
117 
118  /* reset glyph to start the loading of a new glyph */
119  static void
120  pfr_glyph_start( PFR_Glyph glyph )
121  {
122  glyph->path_begun = 0;
123  }
124 
125 
126  static FT_Error
127  pfr_glyph_line_to( PFR_Glyph glyph,
128  FT_Vector* to )
129  {
130  FT_GlyphLoader loader = glyph->loader;
131  FT_Outline* outline = &loader->current.outline;
132  FT_Error error;
133 
134 
135  /* check that we have begun a new path */
136  if ( !glyph->path_begun )
137  {
138  error = FT_THROW( Invalid_Table );
139  FT_ERROR(( "pfr_glyph_line_to: invalid glyph data\n" ));
140  goto Exit;
141  }
142 
143  error = FT_GLYPHLOADER_CHECK_POINTS( loader, 1, 0 );
144  if ( !error )
145  {
146  FT_UInt n = outline->n_points;
147 
148 
149  outline->points[n] = *to;
150  outline->tags [n] = FT_CURVE_TAG_ON;
151 
152  outline->n_points++;
153  }
154 
155  Exit:
156  return error;
157  }
158 
159 
160  static FT_Error
161  pfr_glyph_curve_to( PFR_Glyph glyph,
162  FT_Vector* control1,
163  FT_Vector* control2,
164  FT_Vector* to )
165  {
166  FT_GlyphLoader loader = glyph->loader;
167  FT_Outline* outline = &loader->current.outline;
168  FT_Error error;
169 
170 
171  /* check that we have begun a new path */
172  if ( !glyph->path_begun )
173  {
174  error = FT_THROW( Invalid_Table );
175  FT_ERROR(( "pfr_glyph_line_to: invalid glyph data\n" ));
176  goto Exit;
177  }
178 
179  error = FT_GLYPHLOADER_CHECK_POINTS( loader, 3, 0 );
180  if ( !error )
181  {
182  FT_Vector* vec = outline->points + outline->n_points;
183  FT_Byte* tag = (FT_Byte*)outline->tags + outline->n_points;
184 
185 
186  vec[0] = *control1;
187  vec[1] = *control2;
188  vec[2] = *to;
189  tag[0] = FT_CURVE_TAG_CUBIC;
190  tag[1] = FT_CURVE_TAG_CUBIC;
191  tag[2] = FT_CURVE_TAG_ON;
192 
193  outline->n_points = (FT_Short)( outline->n_points + 3 );
194  }
195 
196  Exit:
197  return error;
198  }
199 
200 
201  static FT_Error
202  pfr_glyph_move_to( PFR_Glyph glyph,
203  FT_Vector* to )
204  {
205  FT_GlyphLoader loader = glyph->loader;
206  FT_Error error;
207 
208 
209  /* close current contour if any */
210  pfr_glyph_close_contour( glyph );
211 
212  /* indicate that a new contour has started */
213  glyph->path_begun = 1;
214 
215  /* check that there is space for a new contour and a new point */
216  error = FT_GLYPHLOADER_CHECK_POINTS( loader, 1, 1 );
217  if ( !error )
218  /* add new start point */
219  error = pfr_glyph_line_to( glyph, to );
220 
221  return error;
222  }
223 
224 
225  static void
226  pfr_glyph_end( PFR_Glyph glyph )
227  {
228  /* close current contour if any */
229  pfr_glyph_close_contour( glyph );
230 
231  /* merge the current glyph into the stack */
232  FT_GlyphLoader_Add( glyph->loader );
233  }
234 
235 
236  /*************************************************************************/
237  /*************************************************************************/
238  /***** *****/
239  /***** PFR GLYPH LOADER *****/
240  /***** *****/
241  /*************************************************************************/
242  /*************************************************************************/
243 
244 
245  /* load a simple glyph */
246  static FT_Error
247  pfr_glyph_load_simple( PFR_Glyph glyph,
248  FT_Byte* p,
249  FT_Byte* limit )
250  {
252  FT_Memory memory = glyph->loader->memory;
253  FT_UInt flags, x_count, y_count, i, count, mask;
254  FT_Int x;
255 
256 
257  PFR_CHECK( 1 );
258  flags = PFR_NEXT_BYTE( p );
259 
260  /* test for composite glyphs */
261  if ( flags & PFR_GLYPH_IS_COMPOUND )
262  goto Failure;
263 
264  x_count = 0;
265  y_count = 0;
266 
267  if ( flags & PFR_GLYPH_1BYTE_XYCOUNT )
268  {
269  PFR_CHECK( 1 );
270  count = PFR_NEXT_BYTE( p );
271  x_count = count & 15;
272  y_count = count >> 4;
273  }
274  else
275  {
276  if ( flags & PFR_GLYPH_XCOUNT )
277  {
278  PFR_CHECK( 1 );
279  x_count = PFR_NEXT_BYTE( p );
280  }
281 
282  if ( flags & PFR_GLYPH_YCOUNT )
283  {
284  PFR_CHECK( 1 );
285  y_count = PFR_NEXT_BYTE( p );
286  }
287  }
288 
289  count = x_count + y_count;
290 
291  /* re-allocate array when necessary */
292  if ( count > glyph->max_xy_control )
293  {
294  FT_UInt new_max = FT_PAD_CEIL( count, 8 );
295 
296 
297  if ( FT_RENEW_ARRAY( glyph->x_control,
298  glyph->max_xy_control,
299  new_max ) )
300  goto Exit;
301 
302  glyph->max_xy_control = new_max;
303  }
304 
305  glyph->y_control = glyph->x_control + x_count;
306 
307  mask = 0;
308  x = 0;
309 
310  for ( i = 0; i < count; i++ )
311  {
312  if ( ( i & 7 ) == 0 )
313  {
314  PFR_CHECK( 1 );
315  mask = PFR_NEXT_BYTE( p );
316  }
317 
318  if ( mask & 1 )
319  {
320  PFR_CHECK( 2 );
321  x = PFR_NEXT_SHORT( p );
322  }
323  else
324  {
325  PFR_CHECK( 1 );
326  x += PFR_NEXT_BYTE( p );
327  }
328 
329  glyph->x_control[i] = x;
330 
331  mask >>= 1;
332  }
333 
334  /* XXX: for now we ignore the secondary stroke and edge definitions */
335  /* since we don't want to support native PFR hinting */
336  /* */
337  if ( flags & PFR_GLYPH_EXTRA_ITEMS )
338  {
339  error = pfr_extra_items_skip( &p, limit );
340  if ( error )
341  goto Exit;
342  }
343 
344  pfr_glyph_start( glyph );
345 
346  /* now load a simple glyph */
347  {
348  FT_Vector pos[4];
349  FT_Vector* cur;
350 
351 
352  pos[0].x = pos[0].y = 0;
353  pos[3] = pos[0];
354 
355  for (;;)
356  {
357  FT_UInt format, format_low, args_format = 0, args_count, n;
358 
359 
360  /***************************************************************/
361  /* read instruction */
362  /* */
363  PFR_CHECK( 1 );
364  format = PFR_NEXT_BYTE( p );
365  format_low = format & 15;
366 
367  switch ( format >> 4 )
368  {
369  case 0: /* end glyph */
370  FT_TRACE6(( "- end glyph" ));
371  args_count = 0;
372  break;
373 
374  case 1: /* general line operation */
375  FT_TRACE6(( "- general line" ));
376  goto Line1;
377 
378  case 4: /* move to inside contour */
379  FT_TRACE6(( "- move to inside" ));
380  goto Line1;
381 
382  case 5: /* move to outside contour */
383  FT_TRACE6(( "- move to outside" ));
384  Line1:
385  args_format = format_low;
386  args_count = 1;
387  break;
388 
389  case 2: /* horizontal line to */
390  FT_TRACE6(( "- horizontal line to cx.%d", format_low ));
391  if ( format_low >= x_count )
392  goto Failure;
393  pos[0].x = glyph->x_control[format_low];
394  pos[0].y = pos[3].y;
395  pos[3] = pos[0];
396  args_count = 0;
397  break;
398 
399  case 3: /* vertical line to */
400  FT_TRACE6(( "- vertical line to cy.%d", format_low ));
401  if ( format_low >= y_count )
402  goto Failure;
403  pos[0].x = pos[3].x;
404  pos[0].y = glyph->y_control[format_low];
405  pos[3] = pos[0];
406  args_count = 0;
407  break;
408 
409  case 6: /* horizontal to vertical curve */
410  FT_TRACE6(( "- hv curve " ));
411  args_format = 0xB8E;
412  args_count = 3;
413  break;
414 
415  case 7: /* vertical to horizontal curve */
416  FT_TRACE6(( "- vh curve" ));
417  args_format = 0xE2B;
418  args_count = 3;
419  break;
420 
421  default: /* general curve to */
422  FT_TRACE6(( "- general curve" ));
423  args_count = 4;
424  args_format = format_low;
425  }
426 
427  /***********************************************************/
428  /* now read arguments */
429  /* */
430  cur = pos;
431  for ( n = 0; n < args_count; n++ )
432  {
433  FT_UInt idx;
434  FT_Int delta;
435 
436 
437  /* read the X argument */
438  switch ( args_format & 3 )
439  {
440  case 0: /* 8-bit index */
441  PFR_CHECK( 1 );
442  idx = PFR_NEXT_BYTE( p );
443  if ( idx >= x_count )
444  goto Failure;
445  cur->x = glyph->x_control[idx];
446  FT_TRACE7(( " cx#%d", idx ));
447  break;
448 
449  case 1: /* 16-bit value */
450  PFR_CHECK( 2 );
451  cur->x = PFR_NEXT_SHORT( p );
452  FT_TRACE7(( " x.%d", cur->x ));
453  break;
454 
455  case 2: /* 8-bit delta */
456  PFR_CHECK( 1 );
457  delta = PFR_NEXT_INT8( p );
458  cur->x = pos[3].x + delta;
459  FT_TRACE7(( " dx.%d", delta ));
460  break;
461 
462  default:
463  FT_TRACE7(( " |" ));
464  cur->x = pos[3].x;
465  }
466 
467  /* read the Y argument */
468  switch ( ( args_format >> 2 ) & 3 )
469  {
470  case 0: /* 8-bit index */
471  PFR_CHECK( 1 );
472  idx = PFR_NEXT_BYTE( p );
473  if ( idx >= y_count )
474  goto Failure;
475  cur->y = glyph->y_control[idx];
476  FT_TRACE7(( " cy#%d", idx ));
477  break;
478 
479  case 1: /* 16-bit absolute value */
480  PFR_CHECK( 2 );
481  cur->y = PFR_NEXT_SHORT( p );
482  FT_TRACE7(( " y.%d", cur->y ));
483  break;
484 
485  case 2: /* 8-bit delta */
486  PFR_CHECK( 1 );
487  delta = PFR_NEXT_INT8( p );
488  cur->y = pos[3].y + delta;
489  FT_TRACE7(( " dy.%d", delta ));
490  break;
491 
492  default:
493  FT_TRACE7(( " -" ));
494  cur->y = pos[3].y;
495  }
496 
497  /* read the additional format flag for the general curve */
498  if ( n == 0 && args_count == 4 )
499  {
500  PFR_CHECK( 1 );
501  args_format = PFR_NEXT_BYTE( p );
502  args_count--;
503  }
504  else
505  args_format >>= 4;
506 
507  /* save the previous point */
508  pos[3] = cur[0];
509  cur++;
510  }
511 
512  FT_TRACE7(( "\n" ));
513 
514  /***********************************************************/
515  /* finally, execute instruction */
516  /* */
517  switch ( format >> 4 )
518  {
519  case 0: /* end glyph => EXIT */
520  pfr_glyph_end( glyph );
521  goto Exit;
522 
523  case 1: /* line operations */
524  case 2:
525  case 3:
526  error = pfr_glyph_line_to( glyph, pos );
527  goto Test_Error;
528 
529  case 4: /* move to inside contour */
530  case 5: /* move to outside contour */
531  error = pfr_glyph_move_to( glyph, pos );
532  goto Test_Error;
533 
534  default: /* curve operations */
535  error = pfr_glyph_curve_to( glyph, pos, pos + 1, pos + 2 );
536 
537  Test_Error: /* test error condition */
538  if ( error )
539  goto Exit;
540  }
541  } /* for (;;) */
542  }
543 
544  Exit:
545  return error;
546 
547  Failure:
548  Too_Short:
549  error = FT_THROW( Invalid_Table );
550  FT_ERROR(( "pfr_glyph_load_simple: invalid glyph data\n" ));
551  goto Exit;
552  }
553 
554 
555  /* load a composite/compound glyph */
556  static FT_Error
557  pfr_glyph_load_compound( PFR_Glyph glyph,
558  FT_Byte* p,
559  FT_Byte* limit )
560  {
562  FT_GlyphLoader loader = glyph->loader;
563  FT_Memory memory = loader->memory;
564  PFR_SubGlyph subglyph;
565  FT_UInt flags, i, count, org_count;
566  FT_Int x_pos, y_pos;
567 
568 
569  PFR_CHECK( 1 );
570  flags = PFR_NEXT_BYTE( p );
571 
572  /* test for composite glyphs */
573  if ( !( flags & PFR_GLYPH_IS_COMPOUND ) )
574  goto Failure;
575 
576  count = flags & 0x3F;
577 
578  /* ignore extra items when present */
579  /* */
580  if ( flags & PFR_GLYPH_EXTRA_ITEMS )
581  {
582  error = pfr_extra_items_skip( &p, limit );
583  if (error) goto Exit;
584  }
585 
586  /* we can't rely on the FT_GlyphLoader to load sub-glyphs, because */
587  /* the PFR format is dumb, using direct file offsets to point to the */
588  /* sub-glyphs (instead of glyph indices). Sigh. */
589  /* */
590  /* For now, we load the list of sub-glyphs into a different array */
591  /* but this will prevent us from using the auto-hinter at its best */
592  /* quality. */
593  /* */
594  org_count = glyph->num_subs;
595 
596  if ( org_count + count > glyph->max_subs )
597  {
598  FT_UInt new_max = ( org_count + count + 3 ) & (FT_UInt)-4;
599 
600 
601  /* we arbitrarily limit the number of subglyphs */
602  /* to avoid endless recursion */
603  if ( new_max > 64 )
604  {
605  error = FT_THROW( Invalid_Table );
606  FT_ERROR(( "pfr_glyph_load_compound:"
607  " too many compound glyphs components\n" ));
608  goto Exit;
609  }
610 
611  if ( FT_RENEW_ARRAY( glyph->subs, glyph->max_subs, new_max ) )
612  goto Exit;
613 
614  glyph->max_subs = new_max;
615  }
616 
617  subglyph = glyph->subs + org_count;
618 
619  for ( i = 0; i < count; i++, subglyph++ )
620  {
621  FT_UInt format;
622 
623 
624  x_pos = 0;
625  y_pos = 0;
626 
627  PFR_CHECK( 1 );
628  format = PFR_NEXT_BYTE( p );
629 
630  /* read scale when available */
631  subglyph->x_scale = 0x10000L;
632  if ( format & PFR_SUBGLYPH_XSCALE )
633  {
634  PFR_CHECK( 2 );
635  subglyph->x_scale = PFR_NEXT_SHORT( p ) << 4;
636  }
637 
638  subglyph->y_scale = 0x10000L;
639  if ( format & PFR_SUBGLYPH_YSCALE )
640  {
641  PFR_CHECK( 2 );
642  subglyph->y_scale = PFR_NEXT_SHORT( p ) << 4;
643  }
644 
645  /* read offset */
646  switch ( format & 3 )
647  {
648  case 1:
649  PFR_CHECK( 2 );
650  x_pos = PFR_NEXT_SHORT( p );
651  break;
652 
653  case 2:
654  PFR_CHECK( 1 );
655  x_pos += PFR_NEXT_INT8( p );
656  break;
657 
658  default:
659  ;
660  }
661 
662  switch ( ( format >> 2 ) & 3 )
663  {
664  case 1:
665  PFR_CHECK( 2 );
666  y_pos = PFR_NEXT_SHORT( p );
667  break;
668 
669  case 2:
670  PFR_CHECK( 1 );
671  y_pos += PFR_NEXT_INT8( p );
672  break;
673 
674  default:
675  ;
676  }
677 
678  subglyph->x_delta = x_pos;
679  subglyph->y_delta = y_pos;
680 
681  /* read glyph position and size now */
682  if ( format & PFR_SUBGLYPH_2BYTE_SIZE )
683  {
684  PFR_CHECK( 2 );
685  subglyph->gps_size = PFR_NEXT_USHORT( p );
686  }
687  else
688  {
689  PFR_CHECK( 1 );
690  subglyph->gps_size = PFR_NEXT_BYTE( p );
691  }
692 
693  if ( format & PFR_SUBGLYPH_3BYTE_OFFSET )
694  {
695  PFR_CHECK( 3 );
696  subglyph->gps_offset = PFR_NEXT_LONG( p );
697  }
698  else
699  {
700  PFR_CHECK( 2 );
701  subglyph->gps_offset = PFR_NEXT_USHORT( p );
702  }
703 
704  glyph->num_subs++;
705  }
706 
707  Exit:
708  return error;
709 
710  Failure:
711  Too_Short:
712  error = FT_THROW( Invalid_Table );
713  FT_ERROR(( "pfr_glyph_load_compound: invalid glyph data\n" ));
714  goto Exit;
715  }
716 
717 
718  static FT_Error
719  pfr_glyph_load_rec( PFR_Glyph glyph,
721  FT_ULong gps_offset,
723  FT_ULong size )
724  {
725  FT_Error error;
726  FT_Byte* p;
727  FT_Byte* limit;
728 
729 
730  if ( FT_STREAM_SEEK( gps_offset + offset ) ||
731  FT_FRAME_ENTER( size ) )
732  goto Exit;
733 
734  p = (FT_Byte*)stream->cursor;
735  limit = p + size;
736 
737  if ( size > 0 && *p & PFR_GLYPH_IS_COMPOUND )
738  {
739  FT_Int n, old_count, count;
740  FT_GlyphLoader loader = glyph->loader;
741  FT_Outline* base = &loader->base.outline;
742 
743 
744  old_count = glyph->num_subs;
745 
746  /* this is a compound glyph - load it */
747  error = pfr_glyph_load_compound( glyph, p, limit );
748 
749  FT_FRAME_EXIT();
750 
751  if ( error )
752  goto Exit;
753 
754  count = glyph->num_subs - old_count;
755 
756  FT_TRACE4(( "compound glyph with %d elements (offset %lu):\n",
757  count, offset ));
758 
759  /* now, load each individual glyph */
760  for ( n = 0; n < count; n++ )
761  {
762  FT_Int i, old_points, num_points;
763  PFR_SubGlyph subglyph;
764 
765 
766  FT_TRACE4(( "subglyph %d:\n", n ));
767 
768  subglyph = glyph->subs + old_count + n;
769  old_points = base->n_points;
770 
771  error = pfr_glyph_load_rec( glyph, stream, gps_offset,
772  subglyph->gps_offset,
773  subglyph->gps_size );
774  if ( error )
775  break;
776 
777  /* note that `glyph->subs' might have been re-allocated */
778  subglyph = glyph->subs + old_count + n;
779  num_points = base->n_points - old_points;
780 
781  /* translate and eventually scale the new glyph points */
782  if ( subglyph->x_scale != 0x10000L || subglyph->y_scale != 0x10000L )
783  {
784  FT_Vector* vec = base->points + old_points;
785 
786 
787  for ( i = 0; i < num_points; i++, vec++ )
788  {
789  vec->x = FT_MulFix( vec->x, subglyph->x_scale ) +
790  subglyph->x_delta;
791  vec->y = FT_MulFix( vec->y, subglyph->y_scale ) +
792  subglyph->y_delta;
793  }
794  }
795  else
796  {
797  FT_Vector* vec = loader->base.outline.points + old_points;
798 
799 
800  for ( i = 0; i < num_points; i++, vec++ )
801  {
802  vec->x += subglyph->x_delta;
803  vec->y += subglyph->y_delta;
804  }
805  }
806 
807  /* proceed to next sub-glyph */
808  }
809 
810  FT_TRACE4(( "end compound glyph with %d elements\n", count ));
811  }
812  else
813  {
814  FT_TRACE4(( "simple glyph (offset %lu)\n", offset ));
815 
816  /* load a simple glyph */
817  error = pfr_glyph_load_simple( glyph, p, limit );
818 
819  FT_FRAME_EXIT();
820  }
821 
822  Exit:
823  return error;
824  }
825 
826 
829  FT_Stream stream,
830  FT_ULong gps_offset,
832  FT_ULong size )
833  {
834  /* initialize glyph loader */
835  FT_GlyphLoader_Rewind( glyph->loader );
836 
837  glyph->num_subs = 0;
838 
839  /* load the glyph, recursively when needed */
840  return pfr_glyph_load_rec( glyph, stream, gps_offset, offset, size );
841  }
842 
843 
844 /* END */
int FT_Error
Definition: fttypes.h:296
GLuint GLuint stream
unsigned long FT_ULong
Definition: fttypes.h:249
#define PFR_CHECK(x)
Definition: pfrload.h:31
GLfloat GLfloat p
#define PFR_NEXT_LONG(p)
Definition: pfrload.h:42
#define FT_CURVE_TAG_CUBIC
Definition: ftimage.h:518
#define NULL
Definition: ftobjs.h:61
signed int FT_Int
Definition: fttypes.h:216
short n_contours
Definition: ftimage.h:385
FT_UInt max_xy_control
Definition: pfrtypes.h:342
FT_Int x_delta
Definition: pfrtypes.h:316
unsigned char * cursor
Definition: ftsystem.h:333
return FT_THROW(Missing_Property)
short * contours
Definition: ftimage.h:390
char * tags
Definition: ftimage.h:389
GLint GLint GLint GLint GLint x
return FT_Err_Ok
Definition: ftbbox.c:645
png_uint_32 i
Definition: png.h:2640
FT_UInt num_subs
Definition: pfrtypes.h:347
FT_Fixed x_scale
Definition: pfrtypes.h:314
typedefFT_BEGIN_HEADER struct FT_GlyphLoaderRec_ * FT_GlyphLoader
Definition: ftgloadr.h:43
#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
#define FT_TRACE4(varformat)
Definition: ftdebug.h:161
PFR_SubGlyphRec * subs
Definition: pfrtypes.h:349
pfr_glyph_done(PFR_Glyph glyph)
Definition: pfrgload.c:53
FT_GlyphLoader_Add(FT_GlyphLoader loader)
Definition: ftgloadr.c:324
pfr_extra_items_skip(FT_Byte **pp, FT_Byte *limit)
Definition: pfrload.c:39
#define FT_FREE(ptr)
Definition: ftmemory.h:286
GLenum GLint GLuint mask
FT_UInt idx
Definition: cffcmap.c:127
FT_Bool path_begun
Definition: pfrtypes.h:352
FT_GlyphLoader loader
Definition: pfrtypes.h:351
FT_Error error
Definition: cffdrivr.c:411
FT_Pos x
Definition: ftimage.h:77
#define FT_ZERO(p)
Definition: ftmemory.h:210
GLbitfield flags
FT_UInt32 gps_offset
Definition: pfrtypes.h:318
FT_Pos y
Definition: ftimage.h:78
GLdouble n
#define FT_TRACE7(varformat)
Definition: ftdebug.h:164
#define FT_RENEW_ARRAY(ptr, curcnt, newcnt)
Definition: ftmemory.h:293
const GLint * first
FT_Vector * vec
Definition: ftbbox.c:566
GLintptr offset
short n_points
Definition: ftimage.h:386
signed short FT_Short
Definition: fttypes.h:194
pfr_glyph_init(PFR_Glyph glyph, FT_GlyphLoader loader)
Definition: pfrgload.c:40
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
#define FT_FRAME_EXIT()
Definition: ftstream.h:514
FT_UInt gps_size
Definition: pfrtypes.h:319
#define FT_STREAM_SEEK(position)
Definition: ftstream.h:489
FT_MulFix(FT_Long a, FT_Long b)
Definition: ftcalc.c:485
if(!abbox) return FT_THROW(Invalid_Argument)
#define FT_TRACE6(varformat)
Definition: ftdebug.h:163
unsigned int FT_UInt
Definition: fttypes.h:227
pfr_glyph_load(PFR_Glyph glyph, FT_Stream stream, FT_ULong gps_offset, FT_ULong offset, FT_ULong size)
Definition: pfrgload.c:828
FT_GlyphLoader_Rewind(FT_GlyphLoader loader)
Definition: ftgloadr.c:88
#define PFR_NEXT_INT8(p)
Definition: pfrload.h:39
FT_Fixed y_scale
Definition: pfrtypes.h:315
#define PFR_NEXT_BYTE(p)
Definition: pfrload.h:38
FT_Int y_delta
Definition: pfrtypes.h:317
GLuint GLuint GLsizei count
#define FT_CURVE_TAG_ON
Definition: ftimage.h:516
#define FT_FRAME_ENTER(size)
Definition: ftstream.h:510
FT_UInt max_subs
Definition: pfrtypes.h:348
#define PFR_NEXT_USHORT(p)
Definition: pfrload.h:41
FT_Pos * x_control
Definition: pfrtypes.h:343
FT_Pos * y_control
Definition: pfrtypes.h:344
#define FT_GLYPHLOADER_CHECK_POINTS(_loader, _points, _contours)
Definition: ftgloadr.h:134
GLsizeiptr size
FT_Vector * points
Definition: ftimage.h:388
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
GLint limit
#define PFR_NEXT_SHORT(p)
Definition: pfrload.h:40
#define FT_LOCAL_DEF(x)
Definition: ftconfig.h:236