开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
lzrw3.h
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：16k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

lzrw3.h：源码内容
  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.  */
  14. #include <linux/types.h>
  15. #include <linux/string.h>
  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. /******************************************************************************/
  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. /******************************************************************************/
  149. #ifndef DONE_PORT       /* Only do this if not previously done.               */
  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
  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.            */
  182. #endif
  184. /******************************************************************************/
  185. /*                              End of PORT.H                                 */
  186. /******************************************************************************/
  188. #define COMPRESS_ACTION_IDENTITY   0
  189. #define COMPRESS_ACTION_COMPRESS   1
  190. #define COMPRESS_ACTION_DECOMPRESS 2
  192. #define COMPRESS_OVERRUN 1024
  193. #define COMPRESS_MAX_COM 0x70000000
  194. #define COMPRESS_MAX_ORG (COMPRESS_MAX_COM-COMPRESS_OVERRUN)
  196. #define COMPRESS_MAX_STRLEN 255
  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. */
  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.                          */
  214.    char  *author;      /* Author of algorithm.                        */
  215.    char  *affiliation; /* Affiliation of author.                      */
  216.    char  *vendor;      /* Where the algorithm can be obtained.        */
  217.   };
  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. );
  231. /******************************************************************************/
  232. /*                             End of COMPRESS.H                              */
  233. /******************************************************************************/
  236. /******************************************************************************/
  237. /*                                  fast_copy.h                               */
  238. /******************************************************************************/
  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.          */
  247. #define fast_copy(src,dst,len) memcpy(dst,src,len)
  249. /******************************************************************************/
  250. /*                               End of fast_copy.h                           */
  251. /******************************************************************************/
  253. #endif