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]
ftstream.c
Go to the documentation of this file.
1 /***************************************************************************/
2 /* */
3 /* ftstream.c */
4 /* */
5 /* I/O stream support (body). */
6 /* */
7 /* Copyright 2000-2002, 2004-2006, 2008-2011, 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 <ft2build.h>
20 #include FT_INTERNAL_STREAM_H
21 #include FT_INTERNAL_DEBUG_H
22 
23 
24  /*************************************************************************/
25  /* */
26  /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
27  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
28  /* messages during execution. */
29  /* */
30 #undef FT_COMPONENT
31 #define FT_COMPONENT trace_stream
32 
33 
34  FT_BASE_DEF( void )
36  const FT_Byte* base,
37  FT_ULong size )
38  {
39  stream->base = (FT_Byte*) base;
40  stream->size = size;
41  stream->pos = 0;
42  stream->cursor = 0;
43  stream->read = 0;
44  stream->close = 0;
45  }
46 
47 
48  FT_BASE_DEF( void )
50  {
51  if ( stream && stream->close )
52  stream->close( stream );
53  }
54 
55 
58  FT_ULong pos )
59  {
61 
62 
63  if ( stream->read )
64  {
65  if ( stream->read( stream, pos, 0, 0 ) )
66  {
67  FT_ERROR(( "FT_Stream_Seek:"
68  " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
69  pos, stream->size ));
70 
71  error = FT_THROW( Invalid_Stream_Operation );
72  }
73  }
74  /* note that seeking to the first position after the file is valid */
75  else if ( pos > stream->size )
76  {
77  FT_ERROR(( "FT_Stream_Seek:"
78  " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
79  pos, stream->size ));
80 
81  error = FT_THROW( Invalid_Stream_Operation );
82  }
83 
84  if ( !error )
85  stream->pos = pos;
86 
87  return error;
88  }
89 
90 
94  {
95  if ( distance < 0 )
96  return FT_THROW( Invalid_Stream_Operation );
97 
98  return FT_Stream_Seek( stream, (FT_ULong)( stream->pos + distance ) );
99  }
100 
101 
104  {
105  return stream->pos;
106  }
107 
108 
111  FT_Byte* buffer,
112  FT_ULong count )
113  {
114  return FT_Stream_ReadAt( stream, stream->pos, buffer, count );
115  }
116 
117 
120  FT_ULong pos,
121  FT_Byte* buffer,
122  FT_ULong count )
123  {
125  FT_ULong read_bytes;
126 
127 
128  if ( pos >= stream->size )
129  {
130  FT_ERROR(( "FT_Stream_ReadAt:"
131  " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
132  pos, stream->size ));
133 
134  return FT_THROW( Invalid_Stream_Operation );
135  }
136 
137  if ( stream->read )
138  read_bytes = stream->read( stream, pos, buffer, count );
139  else
140  {
141  read_bytes = stream->size - pos;
142  if ( read_bytes > count )
143  read_bytes = count;
144 
145  FT_MEM_COPY( buffer, stream->base + pos, read_bytes );
146  }
147 
148  stream->pos = pos + read_bytes;
149 
150  if ( read_bytes < count )
151  {
152  FT_ERROR(( "FT_Stream_ReadAt:"
153  " invalid read; expected %lu bytes, got %lu\n",
154  count, read_bytes ));
155 
156  error = FT_THROW( Invalid_Stream_Operation );
157  }
158 
159  return error;
160  }
161 
162 
165  FT_Byte* buffer,
166  FT_ULong count )
167  {
168  FT_ULong read_bytes = 0;
169 
170 
171  if ( stream->pos >= stream->size )
172  goto Exit;
173 
174  if ( stream->read )
175  read_bytes = stream->read( stream, stream->pos, buffer, count );
176  else
177  {
178  read_bytes = stream->size - stream->pos;
179  if ( read_bytes > count )
180  read_bytes = count;
181 
182  FT_MEM_COPY( buffer, stream->base + stream->pos, read_bytes );
183  }
184 
185  stream->pos += read_bytes;
186 
187  Exit:
188  return read_bytes;
189  }
190 
191 
194  FT_ULong count,
195  FT_Byte** pbytes )
196  {
197  FT_Error error;
198 
199 
201  if ( !error )
202  {
203  *pbytes = (FT_Byte*)stream->cursor;
204 
205  /* equivalent to FT_Stream_ExitFrame(), with no memory block release */
206  stream->cursor = 0;
207  stream->limit = 0;
208  }
209 
210  return error;
211  }
212 
213 
214  FT_BASE_DEF( void )
216  FT_Byte** pbytes )
217  {
218  if ( stream && stream->read )
219  {
220  FT_Memory memory = stream->memory;
221 
222 #ifdef FT_DEBUG_MEMORY
223  ft_mem_free( memory, *pbytes );
224  *pbytes = NULL;
225 #else
226  FT_FREE( *pbytes );
227 #endif
228  }
229  *pbytes = 0;
230  }
231 
232 
235  FT_ULong count )
236  {
238  FT_ULong read_bytes;
239 
240 
241  /* check for nested frame access */
242  FT_ASSERT( stream && stream->cursor == 0 );
243 
244  if ( stream->read )
245  {
246  /* allocate the frame in memory */
247  FT_Memory memory = stream->memory;
248 
249 
250  /* simple sanity check */
251  if ( count > stream->size )
252  {
253  FT_ERROR(( "FT_Stream_EnterFrame:"
254  " frame size (%lu) larger than stream size (%lu)\n",
255  count, stream->size ));
256 
257  error = FT_THROW( Invalid_Stream_Operation );
258  goto Exit;
259  }
260 
261 #ifdef FT_DEBUG_MEMORY
262  /* assume _ft_debug_file and _ft_debug_lineno are already set */
263  stream->base = (unsigned char*)ft_mem_qalloc( memory, count, &error );
264  if ( error )
265  goto Exit;
266 #else
267  if ( FT_QALLOC( stream->base, count ) )
268  goto Exit;
269 #endif
270  /* read it */
271  read_bytes = stream->read( stream, stream->pos,
272  stream->base, count );
273  if ( read_bytes < count )
274  {
275  FT_ERROR(( "FT_Stream_EnterFrame:"
276  " invalid read; expected %lu bytes, got %lu\n",
277  count, read_bytes ));
278 
279  FT_FREE( stream->base );
280  error = FT_THROW( Invalid_Stream_Operation );
281  }
282  stream->cursor = stream->base;
283  stream->limit = stream->cursor + count;
284  stream->pos += read_bytes;
285  }
286  else
287  {
288  /* check current and new position */
289  if ( stream->pos >= stream->size ||
290  stream->size - stream->pos < count )
291  {
292  FT_ERROR(( "FT_Stream_EnterFrame:"
293  " invalid i/o; pos = 0x%lx, count = %lu, size = 0x%lx\n",
294  stream->pos, count, stream->size ));
295 
296  error = FT_THROW( Invalid_Stream_Operation );
297  goto Exit;
298  }
299 
300  /* set cursor */
301  stream->cursor = stream->base + stream->pos;
302  stream->limit = stream->cursor + count;
303  stream->pos += count;
304  }
305 
306  Exit:
307  return error;
308  }
309 
310 
311  FT_BASE_DEF( void )
313  {
314  /* IMPORTANT: The assertion stream->cursor != 0 was removed, given */
315  /* that it is possible to access a frame of length 0 in */
316  /* some weird fonts (usually, when accessing an array of */
317  /* 0 records, like in some strange kern tables). */
318  /* */
319  /* In this case, the loader code handles the 0-length table */
320  /* gracefully; however, stream.cursor is really set to 0 by the */
321  /* FT_Stream_EnterFrame() call, and this is not an error. */
322  /* */
323  FT_ASSERT( stream );
324 
325  if ( stream->read )
326  {
327  FT_Memory memory = stream->memory;
328 
329 #ifdef FT_DEBUG_MEMORY
330  ft_mem_free( memory, stream->base );
331  stream->base = NULL;
332 #else
333  FT_FREE( stream->base );
334 #endif
335  }
336  stream->cursor = 0;
337  stream->limit = 0;
338  }
339 
340 
343  {
344  FT_Char result;
345 
346 
347  FT_ASSERT( stream && stream->cursor );
348 
349  result = 0;
350  if ( stream->cursor < stream->limit )
351  result = *stream->cursor++;
352 
353  return result;
354  }
355 
356 
359  {
360  FT_Byte* p;
362 
363 
364  FT_ASSERT( stream && stream->cursor );
365 
366  result = 0;
367  p = stream->cursor;
368  if ( p + 1 < stream->limit )
369  result = FT_NEXT_USHORT( p );
370  stream->cursor = p;
371 
372  return result;
373  }
374 
375 
378  {
379  FT_Byte* p;
381 
382 
383  FT_ASSERT( stream && stream->cursor );
384 
385  result = 0;
386  p = stream->cursor;
387  if ( p + 1 < stream->limit )
389  stream->cursor = p;
390 
391  return result;
392  }
393 
394 
397  {
398  FT_Byte* p;
399  FT_Long result;
400 
401 
402  FT_ASSERT( stream && stream->cursor );
403 
404  result = 0;
405  p = stream->cursor;
406  if ( p + 2 < stream->limit )
407  result = FT_NEXT_UOFF3( p );
408  stream->cursor = p;
409  return result;
410  }
411 
412 
415  {
416  FT_Byte* p;
417  FT_Long result;
418 
419 
420  FT_ASSERT( stream && stream->cursor );
421 
422  result = 0;
423  p = stream->cursor;
424  if ( p + 3 < stream->limit )
425  result = FT_NEXT_ULONG( p );
426  stream->cursor = p;
427  return result;
428  }
429 
430 
433  {
434  FT_Byte* p;
435  FT_Long result;
436 
437 
438  FT_ASSERT( stream && stream->cursor );
439 
440  result = 0;
441  p = stream->cursor;
442  if ( p + 3 < stream->limit )
444  stream->cursor = p;
445  return result;
446  }
447 
448 
451  FT_Error* error )
452  {
453  FT_Byte result = 0;
454 
455 
456  FT_ASSERT( stream );
457 
458  *error = FT_Err_Ok;
459 
460  if ( stream->read )
461  {
462  if ( stream->read( stream, stream->pos, &result, 1L ) != 1L )
463  goto Fail;
464  }
465  else
466  {
467  if ( stream->pos < stream->size )
468  result = stream->base[stream->pos];
469  else
470  goto Fail;
471  }
472  stream->pos++;
473 
474  return result;
475 
476  Fail:
477  *error = FT_THROW( Invalid_Stream_Operation );
478  FT_ERROR(( "FT_Stream_ReadChar:"
479  " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
480  stream->pos, stream->size ));
481 
482  return 0;
483  }
484 
485 
488  FT_Error* error )
489  {
490  FT_Byte reads[2];
491  FT_Byte* p = 0;
492  FT_Short result = 0;
493 
494 
495  FT_ASSERT( stream );
496 
497  *error = FT_Err_Ok;
498 
499  if ( stream->pos + 1 < stream->size )
500  {
501  if ( stream->read )
502  {
503  if ( stream->read( stream, stream->pos, reads, 2L ) != 2L )
504  goto Fail;
505 
506  p = reads;
507  }
508  else
509  {
510  p = stream->base + stream->pos;
511  }
512 
513  if ( p )
514  result = FT_NEXT_USHORT( p );
515  }
516  else
517  goto Fail;
518 
519  stream->pos += 2;
520 
521  return result;
522 
523  Fail:
524  *error = FT_THROW( Invalid_Stream_Operation );
525  FT_ERROR(( "FT_Stream_ReadUShort:"
526  " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
527  stream->pos, stream->size ));
528 
529  return 0;
530  }
531 
532 
535  FT_Error* error )
536  {
537  FT_Byte reads[2];
538  FT_Byte* p = 0;
539  FT_Short result = 0;
540 
541 
542  FT_ASSERT( stream );
543 
544  *error = FT_Err_Ok;
545 
546  if ( stream->pos + 1 < stream->size )
547  {
548  if ( stream->read )
549  {
550  if ( stream->read( stream, stream->pos, reads, 2L ) != 2L )
551  goto Fail;
552 
553  p = reads;
554  }
555  else
556  {
557  p = stream->base + stream->pos;
558  }
559 
560  if ( p )
562  }
563  else
564  goto Fail;
565 
566  stream->pos += 2;
567 
568  return result;
569 
570  Fail:
571  *error = FT_THROW( Invalid_Stream_Operation );
572  FT_ERROR(( "FT_Stream_ReadUShortLE:"
573  " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
574  stream->pos, stream->size ));
575 
576  return 0;
577  }
578 
579 
582  FT_Error* error )
583  {
584  FT_Byte reads[3];
585  FT_Byte* p = 0;
586  FT_Long result = 0;
587 
588 
589  FT_ASSERT( stream );
590 
591  *error = FT_Err_Ok;
592 
593  if ( stream->pos + 2 < stream->size )
594  {
595  if ( stream->read )
596  {
597  if (stream->read( stream, stream->pos, reads, 3L ) != 3L )
598  goto Fail;
599 
600  p = reads;
601  }
602  else
603  {
604  p = stream->base + stream->pos;
605  }
606 
607  if ( p )
608  result = FT_NEXT_UOFF3( p );
609  }
610  else
611  goto Fail;
612 
613  stream->pos += 3;
614 
615  return result;
616 
617  Fail:
618  *error = FT_THROW( Invalid_Stream_Operation );
619  FT_ERROR(( "FT_Stream_ReadUOffset:"
620  " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
621  stream->pos, stream->size ));
622 
623  return 0;
624  }
625 
626 
629  FT_Error* error )
630  {
631  FT_Byte reads[4];
632  FT_Byte* p = 0;
633  FT_Long result = 0;
634 
635 
636  FT_ASSERT( stream );
637 
638  *error = FT_Err_Ok;
639 
640  if ( stream->pos + 3 < stream->size )
641  {
642  if ( stream->read )
643  {
644  if ( stream->read( stream, stream->pos, reads, 4L ) != 4L )
645  goto Fail;
646 
647  p = reads;
648  }
649  else
650  {
651  p = stream->base + stream->pos;
652  }
653 
654  if ( p )
655  result = FT_NEXT_ULONG( p );
656  }
657  else
658  goto Fail;
659 
660  stream->pos += 4;
661 
662  return result;
663 
664  Fail:
665  *error = FT_THROW( Invalid_Stream_Operation );
666  FT_ERROR(( "FT_Stream_ReadULong:"
667  " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
668  stream->pos, stream->size ));
669 
670  return 0;
671  }
672 
673 
676  FT_Error* error )
677  {
678  FT_Byte reads[4];
679  FT_Byte* p = 0;
680  FT_Long result = 0;
681 
682 
683  FT_ASSERT( stream );
684 
685  *error = FT_Err_Ok;
686 
687  if ( stream->pos + 3 < stream->size )
688  {
689  if ( stream->read )
690  {
691  if ( stream->read( stream, stream->pos, reads, 4L ) != 4L )
692  goto Fail;
693 
694  p = reads;
695  }
696  else
697  {
698  p = stream->base + stream->pos;
699  }
700 
701  if ( p )
703  }
704  else
705  goto Fail;
706 
707  stream->pos += 4;
708 
709  return result;
710 
711  Fail:
712  *error = FT_THROW( Invalid_Stream_Operation );
713  FT_ERROR(( "FT_Stream_ReadULongLE:"
714  " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
715  stream->pos, stream->size ));
716 
717  return 0;
718  }
719 
720 
723  const FT_Frame_Field* fields,
724  void* structure )
725  {
726  FT_Error error;
727  FT_Bool frame_accessed = 0;
728  FT_Byte* cursor;
729 
730 
731  if ( !fields || !stream )
732  return FT_THROW( Invalid_Argument );
733 
734  cursor = stream->cursor;
735 
736  error = FT_Err_Ok;
737  do
738  {
739  FT_ULong value;
740  FT_Int sign_shift;
741  FT_Byte* p;
742 
743 
744  switch ( fields->value )
745  {
746  case ft_frame_start: /* access a new frame */
747  error = FT_Stream_EnterFrame( stream, fields->offset );
748  if ( error )
749  goto Exit;
750 
751  frame_accessed = 1;
752  cursor = stream->cursor;
753  fields++;
754  continue; /* loop! */
755 
756  case ft_frame_bytes: /* read a byte sequence */
757  case ft_frame_skip: /* skip some bytes */
758  {
759  FT_UInt len = fields->size;
760 
761 
762  if ( cursor + len > stream->limit )
763  {
764  error = FT_THROW( Invalid_Stream_Operation );
765  goto Exit;
766  }
767 
768  if ( fields->value == ft_frame_bytes )
769  {
770  p = (FT_Byte*)structure + fields->offset;
771  FT_MEM_COPY( p, cursor, len );
772  }
773  cursor += len;
774  fields++;
775  continue;
776  }
777 
778  case ft_frame_byte:
779  case ft_frame_schar: /* read a single byte */
780  value = FT_NEXT_BYTE( cursor );
781  sign_shift = 24;
782  break;
783 
784  case ft_frame_short_be:
785  case ft_frame_ushort_be: /* read a 2-byte big-endian short */
786  value = FT_NEXT_USHORT( cursor) ;
787  sign_shift = 16;
788  break;
789 
790  case ft_frame_short_le:
791  case ft_frame_ushort_le: /* read a 2-byte little-endian short */
792  value = FT_NEXT_USHORT_LE( cursor );
793  sign_shift = 16;
794  break;
795 
796  case ft_frame_long_be:
797  case ft_frame_ulong_be: /* read a 4-byte big-endian long */
798  value = FT_NEXT_ULONG( cursor );
799  sign_shift = 0;
800  break;
801 
802  case ft_frame_long_le:
803  case ft_frame_ulong_le: /* read a 4-byte little-endian long */
804  value = FT_NEXT_ULONG_LE( cursor );
805  sign_shift = 0;
806  break;
807 
808  case ft_frame_off3_be:
809  case ft_frame_uoff3_be: /* read a 3-byte big-endian long */
810  value = FT_NEXT_UOFF3( cursor );
811  sign_shift = 8;
812  break;
813 
814  case ft_frame_off3_le:
815  case ft_frame_uoff3_le: /* read a 3-byte little-endian long */
816  value = FT_NEXT_UOFF3_LE( cursor );
817  sign_shift = 8;
818  break;
819 
820  default:
821  /* otherwise, exit the loop */
822  stream->cursor = cursor;
823  goto Exit;
824  }
825 
826  /* now, compute the signed value is necessary */
827  if ( fields->value & FT_FRAME_OP_SIGNED )
828  value = (FT_ULong)( (FT_Int32)( value << sign_shift ) >> sign_shift );
829 
830  /* finally, store the value in the object */
831 
832  p = (FT_Byte*)structure + fields->offset;
833  switch ( fields->size )
834  {
835  case ( 8 / FT_CHAR_BIT ):
836  *(FT_Byte*)p = (FT_Byte)value;
837  break;
838 
839  case ( 16 / FT_CHAR_BIT ):
840  *(FT_UShort*)p = (FT_UShort)value;
841  break;
842 
843  case ( 32 / FT_CHAR_BIT ):
844  *(FT_UInt32*)p = (FT_UInt32)value;
845  break;
846 
847  default: /* for 64-bit systems */
848  *(FT_ULong*)p = (FT_ULong)value;
849  }
850 
851  /* go to next field */
852  fields++;
853  }
854  while ( 1 );
855 
856  Exit:
857  /* close the frame if it was opened by this read */
858  if ( frame_accessed )
860 
861  return error;
862  }
863 
864 
865 /* END */
FT_Stream_Skip(FT_Stream stream, FT_Long distance)
Definition: ftstream.c:92
FT_Stream_TryRead(FT_Stream stream, FT_Byte *buffer, FT_ULong count)
Definition: ftstream.c:164
FT_Stream_ReadAt(FT_Stream stream, FT_ULong pos, FT_Byte *buffer, FT_ULong count)
Definition: ftstream.c:119
int FT_Error
Definition: fttypes.h:296
FT_Stream_GetUOffset(FT_Stream stream)
Definition: ftstream.c:396
GLuint GLuint stream
signed long FT_Long
Definition: fttypes.h:238
unsigned long FT_ULong
Definition: fttypes.h:249
GLfloat GLfloat p
ft_mem_free(FT_Memory memory, const void *P)
Definition: ftutil.c:168
FT_Stream_Seek(FT_Stream stream, FT_ULong pos)
Definition: ftstream.c:57
FT_Stream_ReleaseFrame(FT_Stream stream, FT_Byte **pbytes)
Definition: ftstream.c:215
#define FT_NEXT_ULONG_LE(buffer)
Definition: ftstream.h:257
#define NULL
Definition: ftobjs.h:61
signed int FT_Int
Definition: fttypes.h:216
FT_Stream_Close(FT_Stream stream)
Definition: ftstream.c:49
return FT_THROW(Missing_Property)
#define FT_NEXT_BYTE(buffer)
Definition: ftstream.h:220
ft_mem_qalloc(FT_Memory memory, FT_Long size, FT_Error *p_error)
Definition: ftutil.c:66
signed char FT_Char
Definition: fttypes.h:139
unsigned int FT_UInt32
Definition: ftconfig.h:133
#define FT_QALLOC(ptr, size)
Definition: ftmemory.h:273
FT_Stream_GetChar(FT_Stream stream)
Definition: ftstream.c:342
FT_Stream_ExtractFrame(FT_Stream stream, FT_ULong count, FT_Byte **pbytes)
Definition: ftstream.c:193
return FT_Err_Ok
Definition: ftbbox.c:645
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:104
FT_Stream_Read(FT_Stream stream, FT_Byte *buffer, FT_ULong count)
Definition: ftstream.c:110
#define const
Definition: zconf.h:91
#define FT_ERROR(varformat)
Definition: ftdebug.h:181
#define FT_BASE_DEF(x)
Definition: ftconfig.h:258
unsigned char FT_Byte
Definition: fttypes.h:150
#define FT_ASSERT(condition)
Definition: ftdebug.h:211
FT_Stream_GetUShort(FT_Stream stream)
Definition: ftstream.c:358
FT_Stream_ExitFrame(FT_Stream stream)
Definition: ftstream.c:312
FT_Stream_GetULongLE(FT_Stream stream)
Definition: ftstream.c:432
#define FT_FREE(ptr)
Definition: ftmemory.h:286
FT_Stream_ReadUShortLE(FT_Stream stream, FT_Error *error)
Definition: ftstream.c:534
GLenum GLsizei len
FT_Stream_GetULong(FT_Stream stream)
Definition: ftstream.c:414
FT_Error error
Definition: cffdrivr.c:411
FT_Stream_ReadUOffset(FT_Stream stream, FT_Error *error)
Definition: ftstream.c:581
GLuint buffer
FT_Stream_ReadUShort(FT_Stream stream, FT_Error *error)
Definition: ftstream.c:487
signed int FT_Int32
Definition: ftconfig.h:132
FT_Stream_EnterFrame(FT_Stream stream, FT_ULong count)
Definition: ftstream.c:234
GLsizei GLsizei GLfloat distance
GLsizei const GLfloat * value
#define FT_NEXT_UOFF3(buffer)
Definition: ftstream.h:232
signed short FT_Short
Definition: fttypes.h:194
#define FT_NEXT_USHORT_LE(buffer)
Definition: ftstream.h:245
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
#define FT_NEXT_USHORT(buffer)
Definition: ftstream.h:226
#define FT_FRAME_OP_SIGNED
Definition: ftstream.h:41
GLuint64EXT * result
unsigned int FT_UInt
Definition: fttypes.h:227
FT_Stream_ReadFields(FT_Stream stream, const FT_Frame_Field *fields, void *structure)
Definition: ftstream.c:722
#define FT_NEXT_UOFF3_LE(buffer)
Definition: ftstream.h:251
#define FT_NEXT_ULONG(buffer)
Definition: ftstream.h:238
FT_Stream_Pos(FT_Stream stream)
Definition: ftstream.c:103
FT_Stream_ReadChar(FT_Stream stream, FT_Error *error)
Definition: ftstream.c:450
GLuint GLuint GLsizei count
FT_Stream_GetUShortLE(FT_Stream stream)
Definition: ftstream.c:377
#define FT_MEM_COPY(dest, source, count)
Definition: ftmemory.h:203
unsigned short FT_UShort
Definition: fttypes.h:205
FT_Stream_ReadULongLE(FT_Stream stream, FT_Error *error)
Definition: ftstream.c:675
FT_Stream_ReadULong(FT_Stream stream, FT_Error *error)
Definition: ftstream.c:628
GLsizeiptr size
FT_Stream_OpenMemory(FT_Stream stream, const FT_Byte *base, FT_ULong size)
Definition: ftstream.c:35
#define FT_CHAR_BIT
Definition: ftconfig.h:70