WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/freetype/src/lzw/ftzopen.h

Rev	Author	Line No.	Line
4349	Serge	1	/***************************************************************************/
		2	/* */
		3	/* ftzopen.h */
		4	/* */
		5	/* FreeType support for .Z compressed files. */
		6	/* */
		7	/* This optional component relies on NetBSD's zopen(). It should mainly */
		8	/* be used to parse compressed PCF fonts, as found with many X11 server */
		9	/* distributions. */
		10	/* */
		11	/* Copyright 2005, 2006, 2007, 2008 by David Turner. */
		12	/* */
		13	/* This file is part of the FreeType project, and may only be used, */
		14	/* modified, and distributed under the terms of the FreeType project */
		15	/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
		16	/* this file you indicate that you have read the license and */
		17	/* understand and accept it fully. */
		18	/* */
		19	/***************************************************************************/
		20
		21	#ifndef __FT_ZOPEN_H__
		22	#define __FT_ZOPEN_H__
		23
		24	#include
		25	#include FT_FREETYPE_H
		26
		27
		28	/*
		29	* This is a complete re-implementation of the LZW file reader,
		30	* since the old one was incredibly badly written, using
		31	* 400 KByte of heap memory before decompressing anything.
		32	*
		33	*/
		34
		35	#define FT_LZW_IN_BUFF_SIZE 64
		36	#define FT_LZW_DEFAULT_STACK_SIZE 64
		37
		38	#define LZW_INIT_BITS 9
		39	#define LZW_MAX_BITS 16
		40
		41	#define LZW_CLEAR 256
		42	#define LZW_FIRST 257
		43
		44	#define LZW_BIT_MASK 0x1f
		45	#define LZW_BLOCK_MASK 0x80
		46	#define LZW_MASK( n ) ( ( 1U << (n) ) - 1U )
		47
		48
		49	typedef enum FT_LzwPhase_
		50	{
		51	FT_LZW_PHASE_START = 0,
		52	FT_LZW_PHASE_CODE,
		53	FT_LZW_PHASE_STACK,
		54	FT_LZW_PHASE_EOF
		55
		56	} FT_LzwPhase;
		57
		58
		59	/*
		60	* state of LZW decompressor
		61	*
		62	* small technical note
		63	* --------------------
		64	*
		65	* We use a few tricks in this implementation that are explained here to
		66	* ease debugging and maintenance.
		67	*
		68	* - First of all, the `prefix' and `suffix' arrays contain the suffix
		69	* and prefix for codes over 256; this means that
		70	*
		71	* prefix_of(code) == state->prefix[code-256]
		72	* suffix_of(code) == state->suffix[code-256]
		73	*
		74	* Each prefix is a 16-bit code, and each suffix an 8-bit byte.
		75	*
		76	* Both arrays are stored in a single memory block, pointed to by
		77	* `state->prefix'. This means that the following equality is always
		78	* true:
		79	*
		80	* state->suffix == (FT_Byte*)(state->prefix + state->prefix_size)
		81	*
		82	* Of course, state->prefix_size is the number of prefix/suffix slots
		83	* in the arrays, corresponding to codes 256..255+prefix_size.
		84	*
		85	* - `free_ent' is the index of the next free entry in the `prefix'
		86	* and `suffix' arrays. This means that the corresponding `next free
		87	* code' is really `256+free_ent'.
		88	*
		89	* Moreover, `max_free' is the maximum value that `free_ent' can reach.
		90	*
		91	* `max_free' corresponds to `(1 << max_bits) - 256'. Note that this
		92	* value is always <= 0xFF00, which means that both `free_ent' and
		93	* `max_free' can be stored in an FT_UInt variable, even on 16-bit
		94	* machines.
		95	*
		96	* If `free_ent == max_free', you cannot add new codes to the
		97	* prefix/suffix table.
		98	*
		99	* - `num_bits' is the current number of code bits, starting at 9 and
		100	* growing each time `free_ent' reaches the value of `free_bits'. The
		101	* latter is computed as follows
		102	*
		103	* if num_bits < max_bits:
		104	* free_bits = (1 << num_bits)-256
		105	* else:
		106	* free_bits = max_free + 1
		107	*
		108	* Since the value of `max_free + 1' can never be reached by
		109	* `free_ent', `num_bits' cannot grow larger than `max_bits'.
		110	*/
		111
		112	typedef struct FT_LzwStateRec_
		113	{
		114	FT_LzwPhase phase;
		115	FT_Int in_eof;
		116
		117	FT_Byte buf_tab[16];
		118	FT_Int buf_offset;
		119	FT_Int buf_size;
		120	FT_Bool buf_clear;
		121	FT_Offset buf_total;
		122
		123	FT_UInt max_bits; /* max code bits, from file header */
		124	FT_Int block_mode; /* block mode flag, from file header */
		125	FT_UInt max_free; /* (1 << max_bits) - 256 */
		126
		127	FT_UInt num_bits; /* current code bit number */
		128	FT_UInt free_ent; /* index of next free entry */
		129	FT_UInt free_bits; /* if reached by free_ent, increment num_bits */
		130	FT_UInt old_code;
		131	FT_UInt old_char;
		132	FT_UInt in_code;
		133
		134	FT_UShort* prefix; /* always dynamically allocated / reallocated */
		135	FT_Byte* suffix; /* suffix = (FT_Byte)(prefix + prefix_size) /
		136	FT_UInt prefix_size; /* number of slots in `prefix' or `suffix' */
		137
		138	FT_Byte* stack; /* character stack */
		139	FT_UInt stack_top;
		140	FT_Offset stack_size;
		141	FT_Byte stack_0[FT_LZW_DEFAULT_STACK_SIZE]; /* minimize heap alloc */
		142
		143	FT_Stream source; /* source stream */
		144	FT_Memory memory;
		145
		146	} FT_LzwStateRec, *FT_LzwState;
		147
		148
		149	FT_LOCAL( void )
		150	ft_lzwstate_init( FT_LzwState state,
		151	FT_Stream source );
		152
		153	FT_LOCAL( void )
		154	ft_lzwstate_done( FT_LzwState state );
		155
		156
		157	FT_LOCAL( void )
		158	ft_lzwstate_reset( FT_LzwState state );
		159
		160
		161	FT_LOCAL( FT_ULong )
		162	ft_lzwstate_io( FT_LzwState state,
		163	FT_Byte* buffer,
		164	FT_ULong out_size );
		165
		166	/* */
		167
		168	#endif /* __FT_ZOPEN_H__ */
		169
		170
		171	/* END */

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/freetype/src/lzw/ftzopen.h – Rev 4349