[mirror_ubuntu-artful-kernel.git] / drivers / char / ftape / compressor / lzrw3.h

#ifndef _LZRW3_H
#define _LZRW3_H
/*
 * $Source: /homes/cvs/ftape-stacked/ftape/compressor/lzrw3.h,v $
 * $Revision: 1.1 $
 * $Date: 1997/10/05 19:12:30 $
 *
 *  include files for lzrw3. Only slighty modified from the original
 *  version. Assembles the three include files compress.h, port.h and
 *  fastcopy.h from the original lzrw3 package.
 *
 */

#include <linux/types.h>
#include <linux/string.h>

/******************************************************************************/
/*                                                                            */
/*                                 COMPRESS.H                                 */
/*                                                                            */
/******************************************************************************/
/*                                                                            */
/* Author : Ross Williams.                                                    */
/* Date   : December 1989.                                                    */
/*                                                                            */
/* This header file defines the interface to a set of functions called        */
/* 'compress', each member of which implements a particular data compression  */
/* algorithm.                                                                 */
/*                                                                            */
/* Normally in C programming, for each .H file, there is a corresponding .C   */
/* file that implements the functions promised in the .H file.                */
/* Here, there are many .C files corresponding to this header file.           */
/* Each comforming implementation file contains a single function             */
/* called 'compress' that implements a single data compression                */
/* algorithm that conforms with the interface specified in this header file.  */
/* Only one algorithm can be linked in at a time in this organization.        */
/*                                                                            */
/******************************************************************************/
/*                                                                            */
/*                    DEFINITION OF FUNCTION COMPRESS                         */
/*                    ===============================                         */
/*                                                                            */
/* Summary of Function Compress                                               */
/* ----------------------------                                               */
/* The action that 'compress' takes depends on its first argument called      */
/* 'action'.  The function provides three actions:                            */
/*                                                                            */
/*    - Return information about the algorithm.                               */
/*    - Compress   a block of memory.                                         */
/*    - Decompress a block of memory.                                         */
/*                                                                            */
/* Parameters                                                                 */
/* ----------                                                                 */
/* See the formal C definition later for a description of the parameters.     */
/*                                                                            */
/* Constants                                                                  */
/* ---------                                                                  */
/* COMPRESS_OVERRUN: The constant COMPRESS_OVERRUN defines by how many bytes  */
/* an algorithm is allowed to expand a block during a compression operation.  */
/*                                                                            */
/* Although compression algorithms usually compress data, there will always   */
/* be data that a given compressor will expand (this can be proven).          */
/* Fortunately, the degree of expansion can be limited to a single bit, by    */
/* copying over the input data if the data gets bigger during compression.    */
/* To allow for this possibility, the first bit of a compressed               */
/* representation can be used as a flag indicating whether the                */
/* input data was copied over, or truly compressed. In practice, the first    */
/* byte would be used to store this bit so as to maintain byte alignment.     */
/*                                                                            */
/* Unfortunately, in general, the only way to tell if an algorithm will       */
/* expand a particular block of data is to run the algorithm on the data.     */
/* If the algorithm does not continuously monitor how many output bytes it    */
/* has written, it might write an output block far larger than the input      */
/* block before realizing that it has done so.                                */
/* On the other hand, continuous checks on output length are inefficient.     */
/*                                                                            */
/* To cater for all these problems, this interface definition:                */
/* > Allows a compression algorithm to return an output block that is up to   */
/*   COMPRESS_OVERRUN bytes longer than the input block.                      */
/* > Allows a compression algorithm to write up to COMPRESS_OVERRUN bytes     */
/*   more than the length of the input block to the memory of the output      */
/*   block regardless of the length of the output block eventually returned.  */
/*   This allows an algorithm to overrun the length of the input block in the */
/*   output block by up to COMPRESS_OVERRUN bytes between expansion checks.   */
/*                                                                            */
/* The problem does not arise for decompression.                              */
/*                                                                            */
/* Identity Action                                                            */
/* ---------------                                                            */
/* > action must be COMPRESS_ACTION_IDENTITY.                                 */
/* > p_dst_len must point to a longword to receive a longword address.        */
/* > The value of the other parameters does not matter.                       */
/* > After execution, the longword that p_dst_len points to will be a pointer */
/*   to a structure of type compress_identity.                                */
/*   Thus, for example, after the call, (*p_dst_len)->memory will return the  */
/*   number of bytes of working memory that the algorithm requires to run.    */
/* > The values of the identity structure returned are fixed constant         */
/*   attributes of the algorithm and must not vary from call to call.         */
/*                                                                            */
/* Common Requirements for Compression and Decompression Actions              */
/* -------------------------------------------------------------              */
/* > wrk_mem must point to an unused block of memory of a length specified in */
/*   the algorithm's identity block. The identity block can be obtained by    */
/*   making a separate call to compress, specifying the identity action.      */
/* > The INPUT BLOCK is defined to be Memory[src_addr,src_addr+src_len-1].    */
/* > dst_len will be used to denote *p_dst_len.                               */
/* > dst_len is not read by compress, only written.                           */
/* > The value of dst_len is defined only upon termination.                   */
/* > The OUTPUT BLOCK is defined to be Memory[dst_addr,dst_addr+dst_len-1].   */
/*                                                                            */
/* Compression Action                                                         */
/* ------------------                                                         */
/* > action must be COMPRESS_ACTION_COMPRESS.                                 */
/* > src_len must be in the range [0,COMPRESS_MAX_ORG].                       */
/* > The OUTPUT ZONE is defined to be                                         */
/*      Memory[dst_addr,dst_addr+src_len-1+COMPRESS_OVERRUN].                 */
/* > The function can modify any part of the output zone regardless of the    */
/*   final length of the output block.                                        */
/* > The input block and the output zone must not overlap.                    */
/* > dst_len will be in the range [0,src_len+COMPRESS_OVERRUN].               */
/* > dst_len will be in the range [0,COMPRESS_MAX_COM] (from prev fact).      */
/* > The output block will consist of a representation of the input block.    */
/*                                                                            */
/* Decompression Action                                                       */
/* --------------------                                                       */
/* > action must be COMPRESS_ACTION_DECOMPRESS.                               */
/* > The input block must be the result of an earlier compression operation.  */
/* > If the previous fact is true, the following facts must also be true:     */
/*   > src_len will be in the range [0,COMPRESS_MAX_COM].                     */
/*   > dst_len will be in the range [0,COMPRESS_MAX_ORG].                     */
/* > The input and output blocks must not overlap.                            */
/* > Only the output block is modified.                                       */
/* > Upon termination, the output block will consist of the bytes contained   */
/*   in the input block passed to the earlier compression operation.          */
/*                                                                            */
/******************************************************************************/

/******************************************************************************/
/*                                                                            */
/*                                    PORT.H                                  */
/*                                                                            */
/******************************************************************************/
/*                                                                            */
/* This module contains macro definitions and types that are likely to        */
/* change between computers.                                                  */
/*                                                                            */
/******************************************************************************/

#ifndef DONE_PORT       /* Only do this if not previously done.               */

   #ifdef THINK_C
      #define UBYTE unsigned char      /* Unsigned byte                       */
      #define UWORD unsigned int       /* Unsigned word (2 bytes)             */
      #define ULONG unsigned long      /* Unsigned word (4 bytes)             */
      #define BOOL  unsigned char      /* Boolean                             */
      #define FOPEN_BINARY_READ  "rb"  /* Mode string for binary reading.     */
      #define FOPEN_BINARY_WRITE "wb"  /* Mode string for binary writing.     */
      #define FOPEN_TEXT_APPEND  "a"   /* Mode string for text appending.     */
      #define REAL double              /* USed for floating point stuff.      */
   #endif
   #if defined(LINUX) || defined(linux)
      #define UBYTE __u8               /* Unsigned byte                       */
      #define UWORD __u16              /* Unsigned word (2 bytes)             */
      #define ULONG __u32              /* Unsigned word (4 bytes)             */
      #define LONG  __s32              /* Signed   word (4 bytes)             */
      #define BOOL  is not used here   /* Boolean                             */
      #define FOPEN_BINARY_READ  not used  /* Mode string for binary reading. */
      #define FOPEN_BINARY_WRITE not used  /* Mode string for binary writing. */
      #define FOPEN_TEXT_APPEND  not used  /* Mode string for text appending. */
      #define REAL not used                /* USed for floating point stuff.  */
      #ifndef TRUE
      #define TRUE 1
      #endif
   #endif

   #define DONE_PORT                   /* Don't do all this again.            */
   #define MALLOC_FAIL NULL            /* Failure status from malloc()        */
   #define LOCAL static                /* For non-exported routines.          */
   #define EXPORT                      /* Signals exported function.          */
   #define then                        /* Useful for aligning ifs.            */

#endif

/******************************************************************************/
/*                              End of PORT.H                                 */
/******************************************************************************/

#define COMPRESS_ACTION_IDENTITY   0
#define COMPRESS_ACTION_COMPRESS   1
#define COMPRESS_ACTION_DECOMPRESS 2

#define COMPRESS_OVERRUN 1024
#define COMPRESS_MAX_COM 0x70000000
#define COMPRESS_MAX_ORG (COMPRESS_MAX_COM-COMPRESS_OVERRUN)

#define COMPRESS_MAX_STRLEN 255

/* The following structure provides information about the algorithm.         */
/* > The top bit of id must be zero. The remaining bits must be chosen by    */
/*   the author of the algorithm by tossing a coin 31 times.                 */
/* > The amount of memory requested by the algorithm is specified in bytes   */
/*   and must be in the range [0,0x70000000].                                */
/* > All strings s must be such that strlen(s)<=COMPRESS_MAX_STRLEN.         */
struct compress_identity
  {
   ULONG id;           /* Identifying number of algorithm.            */
   ULONG memory;       /* Number of bytes of working memory required. */

   char  *name;        /* Name of algorithm.                          */
   char  *version;     /* Version number.                             */
   char  *date;        /* Date of release of this version.            */
   char  *copyright;   /* Copyright message.                          */

   char  *author;      /* Author of algorithm.                        */
   char  *affiliation; /* Affiliation of author.                      */
   char  *vendor;      /* Where the algorithm can be obtained.        */
  };

void  lzrw3_compress(        /* Single function interface to compression algorithm. */
UWORD     action,      /* Action to be performed.                             */
UBYTE   *wrk_mem,      /* Working memory temporarily given to routine to use. */
UBYTE   *src_adr,      /* Address of input  data.                             */
LONG     src_len,      /* Length  of input  data.                             */
UBYTE   *dst_adr,      /* Address of output data.                             */
void  *p_dst_len       /* Pointer to a longword where routine will write:     */
                       /*    If action=..IDENTITY   => Adr of id structure.   */
                       /*    If action=..COMPRESS   => Length of output data. */
                       /*    If action=..DECOMPRESS => Length of output data. */
);

/******************************************************************************/
/*                             End of COMPRESS.H                              */
/******************************************************************************/


/******************************************************************************/
/*                                  fast_copy.h                               */
/******************************************************************************/

/* This function copies a block of memory very quickly.                       */
/* The exact speed depends on the relative alignment of the blocks of memory. */
/* PRE  : 0<=src_len<=(2^32)-1 .                                              */
/* PRE  : Source and destination blocks must not overlap.                     */
/* POST : MEM[dst_adr,dst_adr+src_len-1]=MEM[src_adr,src_adr+src_len-1].      */
/* POST : MEM[dst_adr,dst_adr+src_len-1] is the only memory changed.          */

#define fast_copy(src,dst,len) memcpy(dst,src,len)

/******************************************************************************/
/*                               End of fast_copy.h                           */
/******************************************************************************/

#endif
Commit	Line	Data
1da177e4 LT	1	#ifndef _LZRW3_H
	2	#define _LZRW3_H
	3	/*
	4	* $Source: /homes/cvs/ftape-stacked/ftape/compressor/lzrw3.h,v $
	5	* $Revision: 1.1 $
	6	* $Date: 1997/10/05 19:12:30 $
	7	*
	8	* include files for lzrw3. Only slighty modified from the original
	9	* version. Assembles the three include files compress.h, port.h and
	10	* fastcopy.h from the original lzrw3 package.
	11	*
	12	*/
	13
	14	#include <linux/types.h>
	15	#include <linux/string.h>
	16
	17	/******************************************************************************/
	18	/* */
	19	/* COMPRESS.H */
	20	/* */
	21	/******************************************************************************/
	22	/* */
	23	/* Author : Ross Williams. */
	24	/* Date : December 1989. */
	25	/* */
	26	/* This header file defines the interface to a set of functions called */
	27	/* 'compress', each member of which implements a particular data compression */
	28	/* algorithm. */
	29	/* */
	30	/* Normally in C programming, for each .H file, there is a corresponding .C */
	31	/* file that implements the functions promised in the .H file. */
	32	/* Here, there are many .C files corresponding to this header file. */
	33	/* Each comforming implementation file contains a single function */
	34	/* called 'compress' that implements a single data compression */
	35	/* algorithm that conforms with the interface specified in this header file. */
	36	/* Only one algorithm can be linked in at a time in this organization. */
	37	/* */
	38	/******************************************************************************/
	39	/* */
	40	/* DEFINITION OF FUNCTION COMPRESS */
	41	/* =============================== */
	42	/* */
	43	/* Summary of Function Compress */
	44	/* ---------------------------- */
	45	/* The action that 'compress' takes depends on its first argument called */
	46	/* 'action'. The function provides three actions: */
	47	/* */
	48	/* - Return information about the algorithm. */
	49	/* - Compress a block of memory. */
	50	/* - Decompress a block of memory. */
	51	/* */
	52	/* Parameters */
	53	/* ---------- */
	54	/* See the formal C definition later for a description of the parameters. */
	55	/* */
	56	/* Constants */
	57	/* --------- */
	58	/* COMPRESS_OVERRUN: The constant COMPRESS_OVERRUN defines by how many bytes */
	59	/* an algorithm is allowed to expand a block during a compression operation. */
	60	/* */
	61	/* Although compression algorithms usually compress data, there will always */
	62	/* be data that a given compressor will expand (this can be proven). */
	63	/* Fortunately, the degree of expansion can be limited to a single bit, by */
	64	/* copying over the input data if the data gets bigger during compression. */
65	/* To allow for this possibility, the first bit of a compressed */
66	/* representation can be used as a flag indicating whether the */
67	/* input data was copied over, or truly compressed. In practice, the first */
68	/* byte would be used to store this bit so as to maintain byte alignment. */
69	/* */
70	/* Unfortunately, in general, the only way to tell if an algorithm will */
71	/* expand a particular block of data is to run the algorithm on the data. */
72	/* If the algorithm does not continuously monitor how many output bytes it */
73	/* has written, it might write an output block far larger than the input */
74	/* block before realizing that it has done so. */
75	/* On the other hand, continuous checks on output length are inefficient. */
76	/* */
77	/* To cater for all these problems, this interface definition: */
78	/* > Allows a compression algorithm to return an output block that is up to */
79	/* COMPRESS_OVERRUN bytes longer than the input block. */
80	/* > Allows a compression algorithm to write up to COMPRESS_OVERRUN bytes */
81	/* more than the length of the input block to the memory of the output */
82	/* block regardless of the length of the output block eventually returned. */
83	/* This allows an algorithm to overrun the length of the input block in the */
84	/* output block by up to COMPRESS_OVERRUN bytes between expansion checks. */
85	/* */
86	/* The problem does not arise for decompression. */
87	/* */
88	/* Identity Action */
89	/* --------------- */
90	/* > action must be COMPRESS_ACTION_IDENTITY. */
91	/* > p_dst_len must point to a longword to receive a longword address. */
92	/* > The value of the other parameters does not matter. */
93	/* > After execution, the longword that p_dst_len points to will be a pointer */
94	/* to a structure of type compress_identity. */
95	/* Thus, for example, after the call, (p_dst_len)->memory will return the /
96	/* number of bytes of working memory that the algorithm requires to run. */
97	/* > The values of the identity structure returned are fixed constant */
98	/* attributes of the algorithm and must not vary from call to call. */
99	/* */
100	/* Common Requirements for Compression and Decompression Actions */
101	/* ------------------------------------------------------------- */
102	/* > wrk_mem must point to an unused block of memory of a length specified in */
103	/* the algorithm's identity block. The identity block can be obtained by */
104	/* making a separate call to compress, specifying the identity action. */
105	/* > The INPUT BLOCK is defined to be Memory[src_addr,src_addr+src_len-1]. */
106	/* > dst_len will be used to denote p_dst_len. /
107	/* > dst_len is not read by compress, only written. */
108	/* > The value of dst_len is defined only upon termination. */
109	/* > The OUTPUT BLOCK is defined to be Memory[dst_addr,dst_addr+dst_len-1]. */
110	/* */
111	/* Compression Action */
112	/* ------------------ */
113	/* > action must be COMPRESS_ACTION_COMPRESS. */
114	/* > src_len must be in the range [0,COMPRESS_MAX_ORG]. */
115	/* > The OUTPUT ZONE is defined to be */
116	/* Memory[dst_addr,dst_addr+src_len-1+COMPRESS_OVERRUN]. */
117	/* > The function can modify any part of the output zone regardless of the */
118	/* final length of the output block. */
119	/* > The input block and the output zone must not overlap. */
120	/* > dst_len will be in the range [0,src_len+COMPRESS_OVERRUN]. */
121	/* > dst_len will be in the range [0,COMPRESS_MAX_COM] (from prev fact). */
122	/* > The output block will consist of a representation of the input block. */
123	/* */
124	/* Decompression Action */
125	/* -------------------- */
126	/* > action must be COMPRESS_ACTION_DECOMPRESS. */
127	/* > The input block must be the result of an earlier compression operation. */
128	/* > If the previous fact is true, the following facts must also be true: */
129	/* > src_len will be in the range [0,COMPRESS_MAX_COM]. */
130	/* > dst_len will be in the range [0,COMPRESS_MAX_ORG]. */
131	/* > The input and output blocks must not overlap. */
132	/* > Only the output block is modified. */
133	/* > Upon termination, the output block will consist of the bytes contained */
134	/* in the input block passed to the earlier compression operation. */
135	/* */
136	/******************************************************************************/
137
138	/******************************************************************************/
139	/* */
140	/* PORT.H */
141	/* */
142	/******************************************************************************/
143	/* */
144	/* This module contains macro definitions and types that are likely to */
145	/* change between computers. */
146	/* */
147	/******************************************************************************/
148
149	#ifndef DONE_PORT /* Only do this if not previously done. */
150
151	#ifdef THINK_C
152	#define UBYTE unsigned char /* Unsigned byte */
153	#define UWORD unsigned int /* Unsigned word (2 bytes) */
154	#define ULONG unsigned long /* Unsigned word (4 bytes) */
155	#define BOOL unsigned char /* Boolean */
156	#define FOPEN_BINARY_READ "rb" /* Mode string for binary reading. */
157	#define FOPEN_BINARY_WRITE "wb" /* Mode string for binary writing. */
158	#define FOPEN_TEXT_APPEND "a" /* Mode string for text appending. */
159	#define REAL double /* USed for floating point stuff. */
160	#endif
161	#if defined(LINUX) \|\| defined(linux)
162	#define UBYTE __u8 /* Unsigned byte */
163	#define UWORD __u16 /* Unsigned word (2 bytes) */
164	#define ULONG __u32 /* Unsigned word (4 bytes) */
165	#define LONG __s32 /* Signed word (4 bytes) */
166	#define BOOL is not used here /* Boolean */
167	#define FOPEN_BINARY_READ not used /* Mode string for binary reading. */
168	#define FOPEN_BINARY_WRITE not used /* Mode string for binary writing. */
169	#define FOPEN_TEXT_APPEND not used /* Mode string for text appending. */
170	#define REAL not used /* USed for floating point stuff. */
171	#ifndef TRUE
172	#define TRUE 1
173	#endif
174	#endif
175
176	#define DONE_PORT /* Don't do all this again. */
177	#define MALLOC_FAIL NULL /* Failure status from malloc() */
178	#define LOCAL static /* For non-exported routines. */
179	#define EXPORT /* Signals exported function. */
180	#define then /* Useful for aligning ifs. */
181
182	#endif
183
184	/******************************************************************************/
185	/* End of PORT.H */
186	/******************************************************************************/
187
188	#define COMPRESS_ACTION_IDENTITY 0
189	#define COMPRESS_ACTION_COMPRESS 1
190	#define COMPRESS_ACTION_DECOMPRESS 2
191
192	#define COMPRESS_OVERRUN 1024
193	#define COMPRESS_MAX_COM 0x70000000
194	#define COMPRESS_MAX_ORG (COMPRESS_MAX_COM-COMPRESS_OVERRUN)
195
196	#define COMPRESS_MAX_STRLEN 255
197
198	/* The following structure provides information about the algorithm. */
199	/* > The top bit of id must be zero. The remaining bits must be chosen by */
200	/* the author of the algorithm by tossing a coin 31 times. */
201	/* > The amount of memory requested by the algorithm is specified in bytes */
202	/* and must be in the range [0,0x70000000]. */
203	/* > All strings s must be such that strlen(s)<=COMPRESS_MAX_STRLEN. */
204	struct compress_identity
205	{
206	ULONG id; /* Identifying number of algorithm. */
207	ULONG memory; /* Number of bytes of working memory required. */
208
209	char name; / Name of algorithm. */
210	char version; / Version number. */
211	char date; / Date of release of this version. */
212	char copyright; / Copyright message. */
213
214	char author; / Author of algorithm. */
215	char affiliation; / Affiliation of author. */
216	char vendor; / Where the algorithm can be obtained. */
217	};
218
219	void lzrw3_compress( /* Single function interface to compression algorithm. */
220	UWORD action, /* Action to be performed. */
221	UBYTE wrk_mem, / Working memory temporarily given to routine to use. */
222	UBYTE src_adr, / Address of input data. */
223	LONG src_len, /* Length of input data. */
224	UBYTE dst_adr, / Address of output data. */
225	void p_dst_len / Pointer to a longword where routine will write: */
226	/* If action=..IDENTITY => Adr of id structure. */
227	/* If action=..COMPRESS => Length of output data. */
228	/* If action=..DECOMPRESS => Length of output data. */
229	);
230
231	/******************************************************************************/
232	/* End of COMPRESS.H */
233	/******************************************************************************/
234
235
236	/******************************************************************************/
237	/* fast_copy.h */
238	/******************************************************************************/
239
240	/* This function copies a block of memory very quickly. */
241	/* The exact speed depends on the relative alignment of the blocks of memory. */
242	/* PRE : 0<=src_len<=(2^32)-1 . */
243	/* PRE : Source and destination blocks must not overlap. */
244	/* POST : MEM[dst_adr,dst_adr+src_len-1]=MEM[src_adr,src_adr+src_len-1]. */
245	/* POST : MEM[dst_adr,dst_adr+src_len-1] is the only memory changed. */
246
247	#define fast_copy(src,dst,len) memcpy(dst,src,len)
248
249	/******************************************************************************/
250	/* End of fast_copy.h */
251	/******************************************************************************/
252
253	#endif