WebSVN – Kolibri OS – Blame – /programs/develop/libraries/freetype/include/freetype/internal/ftstream.h

Rev	Author	Line No.	Line
3918	Serge	1	/***************************************************************************/
		2	/* */
		3	/* ftstream.h */
		4	/* */
		5	/* Stream handling (specification). */
		6	/* */
		7	/* Copyright 1996-2002, 2004-2006, 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	#ifndef __FTSTREAM_H__
		20	#define __FTSTREAM_H__
		21
		22
		23	#include
		24	#include FT_SYSTEM_H
		25	#include FT_INTERNAL_OBJECTS_H
		26
		27
		28	FT_BEGIN_HEADER
		29
		30
		31	/* format of an 8-bit frame_op value: */
		32	/* */
		33	/* bit 76543210 */
		34	/* xxxxxxes */
		35	/* */
		36	/* s is set to 1 if the value is signed. */
		37	/* e is set to 1 if the value is little-endian. */
		38	/* xxx is a command. */
		39
		40	#define FT_FRAME_OP_SHIFT 2
		41	#define FT_FRAME_OP_SIGNED 1
		42	#define FT_FRAME_OP_LITTLE 2
		43	#define FT_FRAME_OP_COMMAND( x ) ( x >> FT_FRAME_OP_SHIFT )
		44
		45	#define FT_MAKE_FRAME_OP( command, little, sign ) \
		46	( ( command << FT_FRAME_OP_SHIFT ) \| ( little << 1 ) \| sign )
		47
		48	#define FT_FRAME_OP_END 0
		49	#define FT_FRAME_OP_START 1 /* start a new frame */
		50	#define FT_FRAME_OP_BYTE 2 /* read 1-byte value */
		51	#define FT_FRAME_OP_SHORT 3 /* read 2-byte value */
		52	#define FT_FRAME_OP_LONG 4 /* read 4-byte value */
		53	#define FT_FRAME_OP_OFF3 5 /* read 3-byte value */
		54	#define FT_FRAME_OP_BYTES 6 /* read a bytes sequence */
		55
		56
		57	typedef enum FT_Frame_Op_
		58	{
		59	ft_frame_end = 0,
		60	ft_frame_start = FT_MAKE_FRAME_OP( FT_FRAME_OP_START, 0, 0 ),
		61
		62	ft_frame_byte = FT_MAKE_FRAME_OP( FT_FRAME_OP_BYTE, 0, 0 ),
		63	ft_frame_schar = FT_MAKE_FRAME_OP( FT_FRAME_OP_BYTE, 0, 1 ),
		64
		65	ft_frame_ushort_be = FT_MAKE_FRAME_OP( FT_FRAME_OP_SHORT, 0, 0 ),
		66	ft_frame_short_be = FT_MAKE_FRAME_OP( FT_FRAME_OP_SHORT, 0, 1 ),
		67	ft_frame_ushort_le = FT_MAKE_FRAME_OP( FT_FRAME_OP_SHORT, 1, 0 ),
		68	ft_frame_short_le = FT_MAKE_FRAME_OP( FT_FRAME_OP_SHORT, 1, 1 ),
		69
		70	ft_frame_ulong_be = FT_MAKE_FRAME_OP( FT_FRAME_OP_LONG, 0, 0 ),
		71	ft_frame_long_be = FT_MAKE_FRAME_OP( FT_FRAME_OP_LONG, 0, 1 ),
		72	ft_frame_ulong_le = FT_MAKE_FRAME_OP( FT_FRAME_OP_LONG, 1, 0 ),
		73	ft_frame_long_le = FT_MAKE_FRAME_OP( FT_FRAME_OP_LONG, 1, 1 ),
		74
		75	ft_frame_uoff3_be = FT_MAKE_FRAME_OP( FT_FRAME_OP_OFF3, 0, 0 ),
		76	ft_frame_off3_be = FT_MAKE_FRAME_OP( FT_FRAME_OP_OFF3, 0, 1 ),
		77	ft_frame_uoff3_le = FT_MAKE_FRAME_OP( FT_FRAME_OP_OFF3, 1, 0 ),
		78	ft_frame_off3_le = FT_MAKE_FRAME_OP( FT_FRAME_OP_OFF3, 1, 1 ),
		79
		80	ft_frame_bytes = FT_MAKE_FRAME_OP( FT_FRAME_OP_BYTES, 0, 0 ),
		81	ft_frame_skip = FT_MAKE_FRAME_OP( FT_FRAME_OP_BYTES, 0, 1 )
		82
		83	} FT_Frame_Op;
		84
		85
		86	typedef struct FT_Frame_Field_
		87	{
		88	FT_Byte value;
		89	FT_Byte size;
		90	FT_UShort offset;
		91
		92	} FT_Frame_Field;
		93
		94
		95	/* Construct an FT_Frame_Field out of a structure type and a field name. */
		96	/* The structure type must be set in the FT_STRUCTURE macro before */
		97	/* calling the FT_FRAME_START() macro. */
		98	/* */
		99	#define FT_FIELD_SIZE( f ) \
		100	(FT_Byte)sizeof ( ((FT_STRUCTURE*)0)->f )
		101
		102	#define FT_FIELD_SIZE_DELTA( f ) \
		103	(FT_Byte)sizeof ( ((FT_STRUCTURE*)0)->f[0] )
		104
		105	#define FT_FIELD_OFFSET( f ) \
		106	(FT_UShort)( offsetof( FT_STRUCTURE, f ) )
		107
		108	#define FT_FRAME_FIELD( frame_op, field ) \
		109	{ \
		110	frame_op, \
		111	FT_FIELD_SIZE( field ), \
		112	FT_FIELD_OFFSET( field ) \
		113	}
		114
		115	#define FT_MAKE_EMPTY_FIELD( frame_op ) { frame_op, 0, 0 }
		116
		117	#define FT_FRAME_START( size ) { ft_frame_start, 0, size }
		118	#define FT_FRAME_END { ft_frame_end, 0, 0 }
		119
		120	#define FT_FRAME_LONG( f ) FT_FRAME_FIELD( ft_frame_long_be, f )
		121	#define FT_FRAME_ULONG( f ) FT_FRAME_FIELD( ft_frame_ulong_be, f )
		122	#define FT_FRAME_SHORT( f ) FT_FRAME_FIELD( ft_frame_short_be, f )
		123	#define FT_FRAME_USHORT( f ) FT_FRAME_FIELD( ft_frame_ushort_be, f )
		124	#define FT_FRAME_OFF3( f ) FT_FRAME_FIELD( ft_frame_off3_be, f )
		125	#define FT_FRAME_UOFF3( f ) FT_FRAME_FIELD( ft_frame_uoff3_be, f )
		126	#define FT_FRAME_BYTE( f ) FT_FRAME_FIELD( ft_frame_byte, f )
		127	#define FT_FRAME_CHAR( f ) FT_FRAME_FIELD( ft_frame_schar, f )
		128
		129	#define FT_FRAME_LONG_LE( f ) FT_FRAME_FIELD( ft_frame_long_le, f )
		130	#define FT_FRAME_ULONG_LE( f ) FT_FRAME_FIELD( ft_frame_ulong_le, f )
		131	#define FT_FRAME_SHORT_LE( f ) FT_FRAME_FIELD( ft_frame_short_le, f )
		132	#define FT_FRAME_USHORT_LE( f ) FT_FRAME_FIELD( ft_frame_ushort_le, f )
		133	#define FT_FRAME_OFF3_LE( f ) FT_FRAME_FIELD( ft_frame_off3_le, f )
		134	#define FT_FRAME_UOFF3_LE( f ) FT_FRAME_FIELD( ft_frame_uoff3_le, f )
		135
		136	#define FT_FRAME_SKIP_LONG { ft_frame_long_be, 0, 0 }
		137	#define FT_FRAME_SKIP_SHORT { ft_frame_short_be, 0, 0 }
		138	#define FT_FRAME_SKIP_BYTE { ft_frame_byte, 0, 0 }
		139
		140	#define FT_FRAME_BYTES( field, count ) \
		141	{ \
		142	ft_frame_bytes, \
		143	count, \
		144	FT_FIELD_OFFSET( field ) \
		145	}
		146
		147	#define FT_FRAME_SKIP_BYTES( count ) { ft_frame_skip, count, 0 }
		148
		149
		150	/*************************************************************************/
		151	/* */
		152	/* Integer extraction macros -- the `buffer' parameter must ALWAYS be of */
		153	/* type `char' or equivalent (1-byte elements). /
		154	/* */
		155
		156	#define FT_BYTE_( p, i ) ( ((const FT_Byte*)(p))[(i)] )
		157
		158	#define FT_INT16( x ) ( (FT_Int16)(x) )
		159	#define FT_UINT16( x ) ( (FT_UInt16)(x) )
		160	#define FT_INT32( x ) ( (FT_Int32)(x) )
		161	#define FT_UINT32( x ) ( (FT_UInt32)(x) )
		162
		163
		164	#define FT_BYTE_U16( p, i, s ) ( FT_UINT16( FT_BYTE_( p, i ) ) << (s) )
		165	#define FT_BYTE_U32( p, i, s ) ( FT_UINT32( FT_BYTE_( p, i ) ) << (s) )
		166
		167
		168	#define FT_PEEK_SHORT( p ) FT_INT16( FT_BYTE_U16( p, 0, 8) \| \
		169	FT_BYTE_U16( p, 1, 0) )
		170
		171	#define FT_PEEK_USHORT( p ) FT_UINT16( FT_BYTE_U16( p, 0, 8 ) \| \
		172	FT_BYTE_U16( p, 1, 0 ) )
		173
		174	#define FT_PEEK_LONG( p ) FT_INT32( FT_BYTE_U32( p, 0, 24 ) \| \
		175	FT_BYTE_U32( p, 1, 16 ) \| \
		176	FT_BYTE_U32( p, 2, 8 ) \| \
		177	FT_BYTE_U32( p, 3, 0 ) )
		178
		179	#define FT_PEEK_ULONG( p ) FT_UINT32( FT_BYTE_U32( p, 0, 24 ) \| \
		180	FT_BYTE_U32( p, 1, 16 ) \| \
		181	FT_BYTE_U32( p, 2, 8 ) \| \
		182	FT_BYTE_U32( p, 3, 0 ) )
		183
		184	#define FT_PEEK_OFF3( p ) FT_INT32( FT_BYTE_U32( p, 0, 16 ) \| \
		185	FT_BYTE_U32( p, 1, 8 ) \| \
		186	FT_BYTE_U32( p, 2, 0 ) )
		187
		188	#define FT_PEEK_UOFF3( p ) FT_UINT32( FT_BYTE_U32( p, 0, 16 ) \| \
		189	FT_BYTE_U32( p, 1, 8 ) \| \
		190	FT_BYTE_U32( p, 2, 0 ) )
		191
		192	#define FT_PEEK_SHORT_LE( p ) FT_INT16( FT_BYTE_U16( p, 1, 8 ) \| \
		193	FT_BYTE_U16( p, 0, 0 ) )
		194
		195	#define FT_PEEK_USHORT_LE( p ) FT_UINT16( FT_BYTE_U16( p, 1, 8 ) \| \
		196	FT_BYTE_U16( p, 0, 0 ) )
		197
		198	#define FT_PEEK_LONG_LE( p ) FT_INT32( FT_BYTE_U32( p, 3, 24 ) \| \
		199	FT_BYTE_U32( p, 2, 16 ) \| \
		200	FT_BYTE_U32( p, 1, 8 ) \| \
		201	FT_BYTE_U32( p, 0, 0 ) )
		202
		203	#define FT_PEEK_ULONG_LE( p ) FT_UINT32( FT_BYTE_U32( p, 3, 24 ) \| \
		204	FT_BYTE_U32( p, 2, 16 ) \| \
		205	FT_BYTE_U32( p, 1, 8 ) \| \
		206	FT_BYTE_U32( p, 0, 0 ) )
		207
		208	#define FT_PEEK_OFF3_LE( p ) FT_INT32( FT_BYTE_U32( p, 2, 16 ) \| \
		209	FT_BYTE_U32( p, 1, 8 ) \| \
		210	FT_BYTE_U32( p, 0, 0 ) )
		211
		212	#define FT_PEEK_UOFF3_LE( p ) FT_UINT32( FT_BYTE_U32( p, 2, 16 ) \| \
		213	FT_BYTE_U32( p, 1, 8 ) \| \
		214	FT_BYTE_U32( p, 0, 0 ) )
		215
		216
		217	#define FT_NEXT_CHAR( buffer ) \
		218	( (signed char)*buffer++ )
		219
		220	#define FT_NEXT_BYTE( buffer ) \
		221	( (unsigned char)*buffer++ )
		222
		223	#define FT_NEXT_SHORT( buffer ) \
		224	( (short)( buffer += 2, FT_PEEK_SHORT( buffer - 2 ) ) )
		225
		226	#define FT_NEXT_USHORT( buffer ) \
		227	( (unsigned short)( buffer += 2, FT_PEEK_USHORT( buffer - 2 ) ) )
		228
		229	#define FT_NEXT_OFF3( buffer ) \
		230	( (long)( buffer += 3, FT_PEEK_OFF3( buffer - 3 ) ) )
		231
		232	#define FT_NEXT_UOFF3( buffer ) \
		233	( (unsigned long)( buffer += 3, FT_PEEK_UOFF3( buffer - 3 ) ) )
		234
		235	#define FT_NEXT_LONG( buffer ) \
		236	( (long)( buffer += 4, FT_PEEK_LONG( buffer - 4 ) ) )
		237
		238	#define FT_NEXT_ULONG( buffer ) \
		239	( (unsigned long)( buffer += 4, FT_PEEK_ULONG( buffer - 4 ) ) )
		240
		241
		242	#define FT_NEXT_SHORT_LE( buffer ) \
		243	( (short)( buffer += 2, FT_PEEK_SHORT_LE( buffer - 2 ) ) )
		244
		245	#define FT_NEXT_USHORT_LE( buffer ) \
		246	( (unsigned short)( buffer += 2, FT_PEEK_USHORT_LE( buffer - 2 ) ) )
		247
		248	#define FT_NEXT_OFF3_LE( buffer ) \
		249	( (long)( buffer += 3, FT_PEEK_OFF3_LE( buffer - 3 ) ) )
		250
		251	#define FT_NEXT_UOFF3_LE( buffer ) \
		252	( (unsigned long)( buffer += 3, FT_PEEK_UOFF3_LE( buffer - 3 ) ) )
		253
		254	#define FT_NEXT_LONG_LE( buffer ) \
		255	( (long)( buffer += 4, FT_PEEK_LONG_LE( buffer - 4 ) ) )
		256
		257	#define FT_NEXT_ULONG_LE( buffer ) \
		258	( (unsigned long)( buffer += 4, FT_PEEK_ULONG_LE( buffer - 4 ) ) )
		259
		260
		261	/*************************************************************************/
		262	/* */
		263	/* Each GET_xxxx() macro uses an implicit `stream' variable. */
		264	/* */
		265	#if 0
		266	#define FT_GET_MACRO( type ) FT_NEXT_ ## type ( stream->cursor )
		267
		268	#define FT_GET_CHAR() FT_GET_MACRO( CHAR )
		269	#define FT_GET_BYTE() FT_GET_MACRO( BYTE )
		270	#define FT_GET_SHORT() FT_GET_MACRO( SHORT )
		271	#define FT_GET_USHORT() FT_GET_MACRO( USHORT )
		272	#define FT_GET_OFF3() FT_GET_MACRO( OFF3 )
		273	#define FT_GET_UOFF3() FT_GET_MACRO( UOFF3 )
		274	#define FT_GET_LONG() FT_GET_MACRO( LONG )
		275	#define FT_GET_ULONG() FT_GET_MACRO( ULONG )
		276	#define FT_GET_TAG4() FT_GET_MACRO( ULONG )
		277
		278	#define FT_GET_SHORT_LE() FT_GET_MACRO( SHORT_LE )
		279	#define FT_GET_USHORT_LE() FT_GET_MACRO( USHORT_LE )
		280	#define FT_GET_LONG_LE() FT_GET_MACRO( LONG_LE )
		281	#define FT_GET_ULONG_LE() FT_GET_MACRO( ULONG_LE )
		282
		283	#else
		284	#define FT_GET_MACRO( func, type ) ( (type)func( stream ) )
		285
		286	#define FT_GET_CHAR() FT_GET_MACRO( FT_Stream_GetChar, FT_Char )
		287	#define FT_GET_BYTE() FT_GET_MACRO( FT_Stream_GetChar, FT_Byte )
		288	#define FT_GET_SHORT() FT_GET_MACRO( FT_Stream_GetUShort, FT_Short )
		289	#define FT_GET_USHORT() FT_GET_MACRO( FT_Stream_GetUShort, FT_UShort )
		290	#define FT_GET_OFF3() FT_GET_MACRO( FT_Stream_GetUOffset, FT_Long )
		291	#define FT_GET_UOFF3() FT_GET_MACRO( FT_Stream_GetUOffset, FT_ULong )
		292	#define FT_GET_LONG() FT_GET_MACRO( FT_Stream_GetULong, FT_Long )
		293	#define FT_GET_ULONG() FT_GET_MACRO( FT_Stream_GetULong, FT_ULong )
		294	#define FT_GET_TAG4() FT_GET_MACRO( FT_Stream_GetULong, FT_ULong )
		295
		296	#define FT_GET_SHORT_LE() FT_GET_MACRO( FT_Stream_GetUShortLE, FT_Short )
		297	#define FT_GET_USHORT_LE() FT_GET_MACRO( FT_Stream_GetUShortLE, FT_UShort )
		298	#define FT_GET_LONG_LE() FT_GET_MACRO( FT_Stream_GetULongLE, FT_Long )
		299	#define FT_GET_ULONG_LE() FT_GET_MACRO( FT_Stream_GetULongLE, FT_ULong )
		300	#endif
		301
		302	#define FT_READ_MACRO( func, type, var ) \
		303	( var = (type)func( stream, &error ), \
		304	error != FT_Err_Ok )
		305
		306	#define FT_READ_BYTE( var ) FT_READ_MACRO( FT_Stream_ReadChar, FT_Byte, var )
		307	#define FT_READ_CHAR( var ) FT_READ_MACRO( FT_Stream_ReadChar, FT_Char, var )
		308	#define FT_READ_SHORT( var ) FT_READ_MACRO( FT_Stream_ReadUShort, FT_Short, var )
		309	#define FT_READ_USHORT( var ) FT_READ_MACRO( FT_Stream_ReadUShort, FT_UShort, var )
		310	#define FT_READ_OFF3( var ) FT_READ_MACRO( FT_Stream_ReadUOffset, FT_Long, var )
		311	#define FT_READ_UOFF3( var ) FT_READ_MACRO( FT_Stream_ReadUOffset, FT_ULong, var )
		312	#define FT_READ_LONG( var ) FT_READ_MACRO( FT_Stream_ReadULong, FT_Long, var )
		313	#define FT_READ_ULONG( var ) FT_READ_MACRO( FT_Stream_ReadULong, FT_ULong, var )
		314
		315	#define FT_READ_SHORT_LE( var ) FT_READ_MACRO( FT_Stream_ReadUShortLE, FT_Short, var )
		316	#define FT_READ_USHORT_LE( var ) FT_READ_MACRO( FT_Stream_ReadUShortLE, FT_UShort, var )
		317	#define FT_READ_LONG_LE( var ) FT_READ_MACRO( FT_Stream_ReadULongLE, FT_Long, var )
		318	#define FT_READ_ULONG_LE( var ) FT_READ_MACRO( FT_Stream_ReadULongLE, FT_ULong, var )
		319
		320
		321	#ifndef FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM
		322
		323	/* initialize a stream for reading a regular system stream */
		324	FT_BASE( FT_Error )
		325	FT_Stream_Open( FT_Stream stream,
		326	const char* filepathname );
		327
		328	#endif /* FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM */
		329
		330
		331	/* create a new (input) stream from an FT_Open_Args structure */
		332	FT_BASE( FT_Error )
		333	FT_Stream_New( FT_Library library,
		334	const FT_Open_Args* args,
		335	FT_Stream *astream );
		336
		337	/* free a stream */
		338	FT_BASE( void )
		339	FT_Stream_Free( FT_Stream stream,
		340	FT_Int external );
		341
		342	/* initialize a stream for reading in-memory data */
		343	FT_BASE( void )
		344	FT_Stream_OpenMemory( FT_Stream stream,
		345	const FT_Byte* base,
		346	FT_ULong size );
		347
		348	/* close a stream (does not destroy the stream structure) */
		349	FT_BASE( void )
		350	FT_Stream_Close( FT_Stream stream );
		351
		352
		353	/* seek within a stream. position is relative to start of stream */
		354	FT_BASE( FT_Error )
		355	FT_Stream_Seek( FT_Stream stream,
		356	FT_ULong pos );
		357
		358	/* skip bytes in a stream */
		359	FT_BASE( FT_Error )
		360	FT_Stream_Skip( FT_Stream stream,
		361	FT_Long distance );
		362
		363	/* return current stream position */
		364	FT_BASE( FT_Long )
		365	FT_Stream_Pos( FT_Stream stream );
		366
		367	/* read bytes from a stream into a user-allocated buffer, returns an */
		368	/* error if not all bytes could be read. */
		369	FT_BASE( FT_Error )
		370	FT_Stream_Read( FT_Stream stream,
		371	FT_Byte* buffer,
		372	FT_ULong count );
		373
		374	/* read bytes from a stream at a given position */
		375	FT_BASE( FT_Error )
		376	FT_Stream_ReadAt( FT_Stream stream,
		377	FT_ULong pos,
		378	FT_Byte* buffer,
		379	FT_ULong count );
		380
		381	/* try to read bytes at the end of a stream; return number of bytes */
		382	/* really available */
		383	FT_BASE( FT_ULong )
		384	FT_Stream_TryRead( FT_Stream stream,
		385	FT_Byte* buffer,
		386	FT_ULong count );
		387
		388	/* Enter a frame of `count' consecutive bytes in a stream. Returns an */
		389	/* error if the frame could not be read/accessed. The caller can use */
		390	/* the FT_Stream_Get_XXX functions to retrieve frame data without */
		391	/* error checks. */
		392	/* */
		393	/* You must _always_ call FT_Stream_ExitFrame() once you have entered */
		394	/* a stream frame! */
		395	/* */
		396	FT_BASE( FT_Error )
		397	FT_Stream_EnterFrame( FT_Stream stream,
		398	FT_ULong count );
		399
		400	/* exit a stream frame */
		401	FT_BASE( void )
		402	FT_Stream_ExitFrame( FT_Stream stream );
		403
		404	/* Extract a stream frame. If the stream is disk-based, a heap block */
		405	/* is allocated and the frame bytes are read into it. If the stream */
		406	/* is memory-based, this function simply set a pointer to the data. */
		407	/* */
		408	/* Useful to optimize access to memory-based streams transparently. */
		409	/* */
		410	/* All extracted frames must be `freed' with a call to the function */
		411	/* FT_Stream_ReleaseFrame(). */
		412	/* */
		413	FT_BASE( FT_Error )
		414	FT_Stream_ExtractFrame( FT_Stream stream,
		415	FT_ULong count,
		416	FT_Byte** pbytes );
		417
		418	/* release an extract frame (see FT_Stream_ExtractFrame) */
		419	FT_BASE( void )
		420	FT_Stream_ReleaseFrame( FT_Stream stream,
		421	FT_Byte** pbytes );
		422
		423	/* read a byte from an entered frame */
		424	FT_BASE( FT_Char )
		425	FT_Stream_GetChar( FT_Stream stream );
		426
		427	/* read a 16-bit big-endian unsigned integer from an entered frame */
		428	FT_BASE( FT_UShort )
		429	FT_Stream_GetUShort( FT_Stream stream );
		430
		431	/* read a 24-bit big-endian unsigned integer from an entered frame */
		432	FT_BASE( FT_ULong )
		433	FT_Stream_GetUOffset( FT_Stream stream );
		434
		435	/* read a 32-bit big-endian unsigned integer from an entered frame */
		436	FT_BASE( FT_ULong )
		437	FT_Stream_GetULong( FT_Stream stream );
		438
		439	/* read a 16-bit little-endian unsigned integer from an entered frame */
		440	FT_BASE( FT_UShort )
		441	FT_Stream_GetUShortLE( FT_Stream stream );
		442
		443	/* read a 32-bit little-endian unsigned integer from an entered frame */
		444	FT_BASE( FT_ULong )
		445	FT_Stream_GetULongLE( FT_Stream stream );
		446
		447
		448	/* read a byte from a stream */
		449	FT_BASE( FT_Char )
		450	FT_Stream_ReadChar( FT_Stream stream,
		451	FT_Error* error );
		452
		453	/* read a 16-bit big-endian unsigned integer from a stream */
		454	FT_BASE( FT_UShort )
		455	FT_Stream_ReadUShort( FT_Stream stream,
		456	FT_Error* error );
		457
		458	/* read a 24-bit big-endian unsigned integer from a stream */
		459	FT_BASE( FT_ULong )
		460	FT_Stream_ReadUOffset( FT_Stream stream,
		461	FT_Error* error );
		462
		463	/* read a 32-bit big-endian integer from a stream */
		464	FT_BASE( FT_ULong )
		465	FT_Stream_ReadULong( FT_Stream stream,
		466	FT_Error* error );
		467
		468	/* read a 16-bit little-endian unsigned integer from a stream */
		469	FT_BASE( FT_UShort )
		470	FT_Stream_ReadUShortLE( FT_Stream stream,
		471	FT_Error* error );
		472
		473	/* read a 32-bit little-endian unsigned integer from a stream */
		474	FT_BASE( FT_ULong )
		475	FT_Stream_ReadULongLE( FT_Stream stream,
		476	FT_Error* error );
		477
		478	/* Read a structure from a stream. The structure must be described */
		479	/* by an array of FT_Frame_Field records. */
		480	FT_BASE( FT_Error )
		481	FT_Stream_ReadFields( FT_Stream stream,
		482	const FT_Frame_Field* fields,
		483	void* structure );
		484
		485
		486	#define FT_STREAM_POS() \
		487	FT_Stream_Pos( stream )
		488
		489	#define FT_STREAM_SEEK( position ) \
		490	FT_SET_ERROR( FT_Stream_Seek( stream, \
		491	(FT_ULong)(position) ) )
		492
		493	#define FT_STREAM_SKIP( distance ) \
		494	FT_SET_ERROR( FT_Stream_Skip( stream, \
		495	(FT_Long)(distance) ) )
		496
		497	#define FT_STREAM_READ( buffer, count ) \
		498	FT_SET_ERROR( FT_Stream_Read( stream, \
		499	(FT_Byte*)(buffer), \
		500	(FT_ULong)(count) ) )
		501
		502	#define FT_STREAM_READ_AT( position, buffer, count ) \
		503	FT_SET_ERROR( FT_Stream_ReadAt( stream, \
		504	(FT_ULong)(position), \
		505	(FT_Byte*)buffer, \
		506	(FT_ULong)(count) ) )
		507
		508	#define FT_STREAM_READ_FIELDS( fields, object ) \
		509	FT_SET_ERROR( FT_Stream_ReadFields( stream, fields, object ) )
		510
		511
		512	#define FT_FRAME_ENTER( size ) \
		513	FT_SET_ERROR( \
		514	FT_DEBUG_INNER( FT_Stream_EnterFrame( stream, \
		515	(FT_ULong)(size) ) ) )
		516
		517	#define FT_FRAME_EXIT() \
		518	FT_DEBUG_INNER( FT_Stream_ExitFrame( stream ) )
		519
		520	#define FT_FRAME_EXTRACT( size, bytes ) \
		521	FT_SET_ERROR( \
		522	FT_DEBUG_INNER( FT_Stream_ExtractFrame( stream, \
		523	(FT_ULong)(size), \
		524	(FT_Byte**)&(bytes) ) ) )
		525
		526	#define FT_FRAME_RELEASE( bytes ) \
		527	FT_DEBUG_INNER( FT_Stream_ReleaseFrame( stream, \
		528	(FT_Byte**)&(bytes) ) )
		529
		530
		531	FT_END_HEADER
		532
		533	#endif /* __FTSTREAM_H__ */
		534
		535
		536	/* END */

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/freetype/include/freetype/internal/ftstream.h – Rev 3918