Snappy压缩库安装和使用之一

ゞ浴缸里的玫瑰 2022-08-27 05:55 541阅读 0赞

近日需要在毕业设计中引入一个压缩库，要求压缩与解压缩速度快，但是压缩率可以不那么苛刻。查找资料发现Google的snappy库比较合适，而且该库开源，由C++写成。所以就拿来使用一下，下面权作记录。下面引出的任何涉及Google公司的源代码，版权归Google公司所有，我权作学习交流。文章安排如下，首先简要介绍Snappy，之后安装之，然后以实际例子介绍如何使用，接着bzip2和gzip做了性能比较，最后提出一些使用上面的疑问。

（一）简要介绍

去官网下载之[http://code.google.com/p/snappy/][http_code.google.com_p_snappy]。在Project Home处有这么一段英文，我想许多地方都引用和翻译了这段。我也尝试翻译一下。

Snappy is a compression/decompression library.

It does not aim for maximum compression,

or compatibility with any other compression library;

instead, it aims for veryhigh speeds and reasonable compression.

For instance, compared to the fastest mode of zlib,

Snappy is an order of magnitude faster for most inputs,

but the resulting compressed files are anywhere from 20% to 100% bigger.

On a single core of a Core i7 processor in 64-bit mode,

Snappy compresses at about 250 MB/sec or more and

decompresses at about 500 MB/sec or more.

Snappy is widely used inside Google, in everything from BigTable

and MapReduce to our internal RPC systems.

译文：Snappy是一个压缩/解压缩库。它不是以最大压缩率，或者与其他压缩库兼容为目标；它旨在获得高速的压缩和合理的压缩率。例如，Snappy对大多数的输入比zlib的最快模式要快几个数量级，但是其压缩过后的文件通常会比zlib大20%到100%。在Core i7的单核64位模式下，Snappy压缩速度大概可以达到250MB/s或者更快，解压缩可以达到大约500MB/s或更快。

Snappy在Google内部广泛使用，从BigTable，MapReduce到公司内部的RPC系统。

（二）安装过程

下面描述安装过程：

下载snappy-1.0.5.tar.gz，snappy的安装过程与传统的安装过程一样。解压后的INSTALL文件有详细的安装说明。

gunzip snappy-1.0.5.tar.gz

tar xf snappy-1.0.5.tar

cd snappy-1.0.5

./configure

make

make install

安装完成后，生成的动态库和静态库位于/usr/local/lib处，编程需要用到的头文件位于/usr/local/include处。注意需要将这些库文件cp至/usr/lib处，不然就算在链接的时候加上-L/usr/local/lib，在运行时也会报错。./main: error while loading shared libraries: libsnappy.so.1:

cannot open shared object file: No such file or directory

当然这是我的LD\_LIBRARY\_PATH环境变量的设置问题。

（三）使用snappy

解压出来的README文件介绍了一简单的使用方式。snappy是各种库标示符所在的命名空间。C++使用需要包含\#include <snappy.h>头文件，C语言使用需要包含\#include<snapyy-c.h>头文件。Snappy使用较为简单，我指的是跟bzip2的库比起来。所有的函数接口都暴露在上述两个头文件中，头文件中有详细的使用说明，并有简单的示例，而且英文通俗易懂。摘抄如下（Google公司版权所有）：

snappy.h

**\[cpp\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  // Copyright 2005 and onwards Google Inc.
2.  //
3.  // Redistribution and use in source and binary forms, with or without
4.  // modification, are permitted provided that the following conditions are
5.  // met:
6.  //
7.  // \* Redistributions of source code must retain the above copyright
8.  // notice, this list of conditions and the following disclaimer.
9.  // \* Redistributions in binary form must reproduce the above
10. // copyright notice, this list of conditions and the following disclaimer
11. // in the documentation and/or other materials provided with the
12. // distribution.
13. // \* Neither the name of Google Inc. nor the names of its
14. // contributors may be used to endorse or promote products derived from
15. // this software without specific prior written permission.
16. //
17. // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18. // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19. // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20. // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21. // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22. // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23. // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24. // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25. // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26. // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28. //
29. // A light-weight compression algorithm. It is designed for speed of
30. // compression and decompression, rather than for the utmost in space
31. // savings.
32. //
33. // For getting better compression ratios when you are compressing data
34. // with long repeated sequences or compressing data that is similar to
35. // other data, while still compressing fast, you might look at first
36. // using BMDiff and then compressing the output of BMDiff with
37. // Snappy.
38. 
39. \#ifndef UTIL\_SNAPPY\_SNAPPY\_H\_\_
40. \#define UTIL\_SNAPPY\_SNAPPY\_H\_\_
41. 
42. \#include <stddef.h>
43. \#include <string>
44. 
45. \#include "snappy-stubs-public.h"
46. 
47. namespace snappy \{
48. class Source;
49. class Sink;
50. 
51. // ------------------------------------------------------------------------
52. // Generic compression/decompression routines.
53. // ------------------------------------------------------------------------
54. 
55. // Compress the bytes read from "\*source" and append to "\*sink". Return the
56. // number of bytes written.
57. size\_t Compress(Source\* source, Sink\* sink);
58. 
59. bool GetUncompressedLength(Source\* source, uint32\* result);
60. 
61. // ------------------------------------------------------------------------
62. // Higher-level string based routines (should be sufficient for most users)
63. // ------------------------------------------------------------------------
64. 
65. // Sets "\*output" to the compressed version of "input\[0,input\_length-1\]".
66. // Original contents of \*output are lost.
67. //
68. // REQUIRES: "input\[\]" is not an alias of "\*output".
69. size\_t Compress(const char\* input, size\_t input\_length, string\* output);
70. 
71. // Decompresses "compressed\[0,compressed\_length-1\]" to "\*uncompressed".
72. // Original contents of "\*uncompressed" are lost.
73. //
74. // REQUIRES: "compressed\[\]" is not an alias of "\*uncompressed".
75. //
76. // returns false if the message is corrupted and could not be decompressed
77. bool Uncompress(const char\* compressed, size\_t compressed\_length,
78. string\* uncompressed);
79. 
80. 
81. // ------------------------------------------------------------------------
82. // Lower-level character array based routines. May be useful for
83. // efficiency reasons in certain circumstances.
84. // ------------------------------------------------------------------------
85. 
86. // REQUIRES: "compressed" must point to an area of memory that is at
87. // least "MaxCompressedLength(input\_length)" bytes in length.
88. //
89. // Takes the data stored in "input\[0..input\_length\]" and stores
90. // it in the array pointed to by "compressed".
91. //
92. // "\*compressed\_length" is set to the length of the compressed output.
93. //
94. // Example:
95. // char\* output = new char\[snappy::MaxCompressedLength(input\_length)\];
96. // size\_t output\_length;
97. // RawCompress(input, input\_length, output, &output\_length);
98. // ... Process(output, output\_length) ...
99. // delete \[\] output;
100. void RawCompress(const char\* input,
101. size\_t input\_length,
102. char\* compressed,
103. size\_t\* compressed\_length);
104. 
105. // Given data in "compressed\[0..compressed\_length-1\]" generated by
106. // calling the Snappy::Compress routine, this routine
107. // stores the uncompressed data to
108. // uncompressed\[0..GetUncompressedLength(compressed)-1\]
109. // returns false if the message is corrupted and could not be decrypted
110. bool RawUncompress(const char\* compressed, size\_t compressed\_length,
111. char\* uncompressed);
112. 
113. // Given data from the byte source 'compressed' generated by calling
114. // the Snappy::Compress routine, this routine stores the uncompressed
115. // data to
116. // uncompressed\[0..GetUncompressedLength(compressed,compressed\_length)-1\]
117. // returns false if the message is corrupted and could not be decrypted
118. bool RawUncompress(Source\* compressed, char\* uncompressed);
119. 
120. // Returns the maximal size of the compressed representation of
121. // input data that is "source\_bytes" bytes in length;
122. size\_t MaxCompressedLength(size\_t source\_bytes);
123. 
124. // REQUIRES: "compressed\[\]" was produced by RawCompress() or Compress()
125. // Returns true and stores the length of the uncompressed data in
126. // \*result normally. Returns false on parsing error.
127. // This operation takes O(1) time.
128. bool GetUncompressedLength(const char\* compressed, size\_t compressed\_length,
129. size\_t\* result);
130. 
131. // Returns true iff the contents of "compressed\[\]" can be uncompressed
132. // successfully. Does not return the uncompressed data. Takes
133. // time proportional to compressed\_length, but is usually at least
134. // a factor of four faster than actual decompression.
135. bool IsValidCompressedBuffer(const char\* compressed,
136. size\_t compressed\_length);
137. 
138. // \*\*\* DO NOT CHANGE THE VALUE OF kBlockSize \*\*\*
139. //
140. // New Compression code chops up the input into blocks of at most
141. // the following size. This ensures that back-references in the
142. // output never cross kBlockSize block boundaries. This can be
143. // helpful in implementing blocked decompression. However the
144. // decompression code should not rely on this guarantee since older
145. // compression code may not obey it.
146. static const int kBlockLog = 15;
147. static const size\_t kBlockSize = 1 << kBlockLog;
148. 
149. static const int kMaxHashTableBits = 14;
150. static const size\_t kMaxHashTableSize = 1 << kMaxHashTableBits;
151. 
152. \} // end namespace snappy
153. 
154. 
155. \#endif // UTIL\_SNAPPY\_SNAPPY\_H\_\_

// Copyright 2005 and onwards Google Inc.
    //
    // Redistribution and use in source and binary forms, with or without
    // modification, are permitted provided that the following conditions are
    // met:
    //
    //     * Redistributions of source code must retain the above copyright
    // notice, this list of conditions and the following disclaimer.
    //     * Redistributions in binary form must reproduce the above
    // copyright notice, this list of conditions and the following disclaimer
    // in the documentation and/or other materials provided with the
    // distribution.
    //     * Neither the name of Google Inc. nor the names of its
    // contributors may be used to endorse or promote products derived from
    // this software without specific prior written permission.
    //
    // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    //
    // A light-weight compression algorithm.  It is designed for speed of
    // compression and decompression, rather than for the utmost in space
    // savings.
    //
    // For getting better compression ratios when you are compressing data
    // with long repeated sequences or compressing data that is similar to
    // other data, while still compressing fast, you might look at first
    // using BMDiff and then compressing the output of BMDiff with
    // Snappy.
    
    #ifndef UTIL_SNAPPY_SNAPPY_H__
    #define UTIL_SNAPPY_SNAPPY_H__
    
    #include <stddef.h>
    #include <string>
    
    #include "snappy-stubs-public.h"
    
    namespace snappy {
      class Source;
      class Sink;
    
      // ------------------------------------------------------------------------
      // Generic compression/decompression routines.
      // ------------------------------------------------------------------------
    
      // Compress the bytes read from "*source" and append to "*sink". Return the
      // number of bytes written.
      size_t Compress(Source* source, Sink* sink);
    
      bool GetUncompressedLength(Source* source, uint32* result);
    
      // ------------------------------------------------------------------------
      // Higher-level string based routines (should be sufficient for most users)
      // ------------------------------------------------------------------------
    
      // Sets "*output" to the compressed version of "input[0,input_length-1]".
      // Original contents of *output are lost.
      //
      // REQUIRES: "input[]" is not an alias of "*output".
      size_t Compress(const char* input, size_t input_length, string* output);
    
      // Decompresses "compressed[0,compressed_length-1]" to "*uncompressed".
      // Original contents of "*uncompressed" are lost.
      //
      // REQUIRES: "compressed[]" is not an alias of "*uncompressed".
      //
      // returns false if the message is corrupted and could not be decompressed
      bool Uncompress(const char* compressed, size_t compressed_length,
                      string* uncompressed);
    
    
      // ------------------------------------------------------------------------
      // Lower-level character array based routines.  May be useful for
      // efficiency reasons in certain circumstances.
      // ------------------------------------------------------------------------
    
      // REQUIRES: "compressed" must point to an area of memory that is at
      // least "MaxCompressedLength(input_length)" bytes in length.
      //
      // Takes the data stored in "input[0..input_length]" and stores
      // it in the array pointed to by "compressed".
      //
      // "*compressed_length" is set to the length of the compressed output.
      //
      // Example:
      //    char* output = new char[snappy::MaxCompressedLength(input_length)];
      //    size_t output_length;
      //    RawCompress(input, input_length, output, &output_length);
      //    ... Process(output, output_length) ...
      //    delete [] output;
      void RawCompress(const char* input,
                       size_t input_length,
                       char* compressed,
                       size_t* compressed_length);
    
      // Given data in "compressed[0..compressed_length-1]" generated by
      // calling the Snappy::Compress routine, this routine
      // stores the uncompressed data to
      //    uncompressed[0..GetUncompressedLength(compressed)-1]
      // returns false if the message is corrupted and could not be decrypted
      bool RawUncompress(const char* compressed, size_t compressed_length,
                         char* uncompressed);
    
      // Given data from the byte source 'compressed' generated by calling
      // the Snappy::Compress routine, this routine stores the uncompressed
      // data to
      //    uncompressed[0..GetUncompressedLength(compressed,compressed_length)-1]
      // returns false if the message is corrupted and could not be decrypted
      bool RawUncompress(Source* compressed, char* uncompressed);
    
      // Returns the maximal size of the compressed representation of
      // input data that is "source_bytes" bytes in length;
      size_t MaxCompressedLength(size_t source_bytes);
    
      // REQUIRES: "compressed[]" was produced by RawCompress() or Compress()
      // Returns true and stores the length of the uncompressed data in
      // *result normally.  Returns false on parsing error.
      // This operation takes O(1) time.
      bool GetUncompressedLength(const char* compressed, size_t compressed_length,
                                 size_t* result);
    
      // Returns true iff the contents of "compressed[]" can be uncompressed
      // successfully.  Does not return the uncompressed data.  Takes
      // time proportional to compressed_length, but is usually at least
      // a factor of four faster than actual decompression.
      bool IsValidCompressedBuffer(const char* compressed,
                                   size_t compressed_length);
    
      // *** DO NOT CHANGE THE VALUE OF kBlockSize ***
      //
      // New Compression code chops up the input into blocks of at most
      // the following size.  This ensures that back-references in the
      // output never cross kBlockSize block boundaries.  This can be
      // helpful in implementing blocked decompression.  However the
      // decompression code should not rely on this guarantee since older
      // compression code may not obey it.
      static const int kBlockLog = 15;
      static const size_t kBlockSize = 1 << kBlockLog;
    
      static const int kMaxHashTableBits = 14;
      static const size_t kMaxHashTableSize = 1 << kMaxHashTableBits;
    
    }  // end namespace snappy
    
    
    #endif  // UTIL_SNAPPY_SNAPPY_H__

snapp-c.h

**\[cpp\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  /\*
2.   \* Copyright 2011 Martin Gieseking <martin.gieseking@uos.de>.
3.   \*
4.   \* Redistribution and use in source and binary forms, with or without
5.   \* modification, are permitted provided that the following conditions are
6.   \* met:
7.   \*
8.   \* \* Redistributions of source code must retain the above copyright
9.   \* notice, this list of conditions and the following disclaimer.
10.  \* \* Redistributions in binary form must reproduce the above
11.  \* copyright notice, this list of conditions and the following disclaimer
12.  \* in the documentation and/or other materials provided with the
13.  \* distribution.
14.  \* \* Neither the name of Google Inc. nor the names of its
15.  \* contributors may be used to endorse or promote products derived from
16.  \* this software without specific prior written permission.
17.  \*
18.  \* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19.  \* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20.  \* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21.  \* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22.  \* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23.  \* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24.  \* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25.  \* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26.  \* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27.  \* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28.  \* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29.  \*
30.  \* Plain C interface (a wrapper around the C++ implementation).
31.  \*/
32. 
33. \#ifndef UTIL\_SNAPPY\_OPENSOURCE\_SNAPPY\_C\_H\_
34. \#define UTIL\_SNAPPY\_OPENSOURCE\_SNAPPY\_C\_H\_
35. 
36. \#ifdef \_\_cplusplus
37. extern "C" \{
38. \#endif
39. 
40. \#include <stddef.h>
41. 
42. /\*
43.  \* Return values; see the documentation for each function to know
44.  \* what each can return.
45.  \*/
46. typedef enum \{
47. SNAPPY\_OK = 0,
48. SNAPPY\_INVALID\_INPUT = 1,
49. SNAPPY\_BUFFER\_TOO\_SMALL = 2,
50. \} snappy\_status;
51. 
52. /\*
53.  \* Takes the data stored in "input\[0..input\_length-1\]" and stores
54.  \* it in the array pointed to by "compressed".
55.  \*
56.  \* <compressed\_length> signals the space available in "compressed".
57.  \* If it is not at least equal to "snappy\_max\_compressed\_length(input\_length)",
58.  \* SNAPPY\_BUFFER\_TOO\_SMALL is returned. After successful compression,
59.  \* <compressed\_length> contains the true length of the compressed output,
60.  \* and SNAPPY\_OK is returned.
61.  \*
62.  \* Example:
63.  \* size\_t output\_length = snappy\_max\_compressed\_length(input\_length);
64.  \* char\* output = (char\*)malloc(output\_length);
65.  \* if (snappy\_compress(input, input\_length, output, &output\_length)
66.  \* == SNAPPY\_OK) \{ 
67.  \* ... Process(output, output\_length) ...
68.  \* \}
69.  \* free(output);
70.  \*/
71. snappy\_status snappy\_compress(const char\* input,
72. size\_t input\_length,
73. char\* compressed,
74. size\_t\* compressed\_length);
75. 
76. /\*
77.  \* Given data in "compressed\[0..compressed\_length-1\]" generated by
78.  \* calling the snappy\_compress routine, this routine stores
79.  \* the uncompressed data to
80.  \* uncompressed\[0..uncompressed\_length-1\].
81.  \* Returns failure (a value not equal to SNAPPY\_OK) if the message
82.  \* is corrupted and could not be decrypted.
83.  \*
84.  \* <uncompressed\_length> signals the space available in "uncompressed".
85.  \* If it is not at least equal to the value returned by
86.  \* snappy\_uncompressed\_length for this stream, SNAPPY\_BUFFER\_TOO\_SMALL
87.  \* is returned. After successful decompression, <uncompressed\_length>
88.  \* contains the true length of the decompressed output.
89.  \*
90.  \* Example:
91.  \* size\_t output\_length;
92.  \* if (snappy\_uncompressed\_length(input, input\_length, &output\_length)
93.  \* != SNAPPY\_OK) \{ 
94.  \* ... fail ...
95.  \* \}
96.  \* char\* output = (char\*)malloc(output\_length);
97.  \* if (snappy\_uncompress(input, input\_length, output, &output\_length)
98.  \* == SNAPPY\_OK) \{ 
99.  \* ... Process(output, output\_length) ...
100.  \* \}
101.  \* free(output);
102.  \*/
103. snappy\_status snappy\_uncompress(const char\* compressed,
104. size\_t compressed\_length,
105. char\* uncompressed,
106. size\_t\* uncompressed\_length);
107. 
108. /\*
109.  \* Returns the maximal size of the compressed representation of
110.  \* input data that is "source\_length" bytes in length.
111.  \*/
112. size\_t snappy\_max\_compressed\_length(size\_t source\_length);
113. 
114. /\*
115.  \* REQUIRES: "compressed\[\]" was produced by snappy\_compress()
116.  \* Returns SNAPPY\_OK and stores the length of the uncompressed data in
117.  \* \*result normally. Returns SNAPPY\_INVALID\_INPUT on parsing error.
118.  \* This operation takes O(1) time.
119.  \*/
120. snappy\_status snappy\_uncompressed\_length(const char\* compressed,
121. size\_t compressed\_length,
122. size\_t\* result);
123. 
124. /\*
125.  \* Check if the contents of "compressed\[\]" can be uncompressed successfully.
126.  \* Does not return the uncompressed data; if so, returns SNAPPY\_OK,
127.  \* or if not, returns SNAPPY\_INVALID\_INPUT.
128.  \* Takes time proportional to compressed\_length, but is usually at least a
129.  \* factor of four faster than actual decompression.
130.  \*/
131. snappy\_status snappy\_validate\_compressed\_buffer(const char\* compressed,
132. size\_t compressed\_length);
133. 
134. \#ifdef \_\_cplusplus
135. \} // extern "C"
136. \#endif
137. 
138. \#endif /\* UTIL\_SNAPPY\_OPENSOURCE\_SNAPPY\_C\_H\_ \*/

/*
     * Copyright 2011 Martin Gieseking <martin.gieseking@uos.de>.
     *
     * Redistribution and use in source and binary forms, with or without
     * modification, are permitted provided that the following conditions are
     * met:
     *
     *     * Redistributions of source code must retain the above copyright
     * notice, this list of conditions and the following disclaimer.
     *     * Redistributions in binary form must reproduce the above
     * copyright notice, this list of conditions and the following disclaimer
     * in the documentation and/or other materials provided with the
     * distribution.
     *     * Neither the name of Google Inc. nor the names of its
     * contributors may be used to endorse or promote products derived from
     * this software without specific prior written permission.
     *
     * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     *
     * Plain C interface (a wrapper around the C++ implementation).
     */
    
    #ifndef UTIL_SNAPPY_OPENSOURCE_SNAPPY_C_H_
    #define UTIL_SNAPPY_OPENSOURCE_SNAPPY_C_H_
    
    #ifdef __cplusplus
    extern "C" {
    #endif
    
    #include <stddef.h>
    
    /*
     * Return values; see the documentation for each function to know
     * what each can return.
     */
    typedef enum {
      SNAPPY_OK = 0,
      SNAPPY_INVALID_INPUT = 1,
      SNAPPY_BUFFER_TOO_SMALL = 2,
    } snappy_status;
    
    /*
     * Takes the data stored in "input[0..input_length-1]" and stores
     * it in the array pointed to by "compressed".
     *
     * <compressed_length> signals the space available in "compressed".
     * If it is not at least equal to "snappy_max_compressed_length(input_length)",
     * SNAPPY_BUFFER_TOO_SMALL is returned. After successful compression,
     * <compressed_length> contains the true length of the compressed output,
     * and SNAPPY_OK is returned.
     *
     * Example:
     *   size_t output_length = snappy_max_compressed_length(input_length);
     *   char* output = (char*)malloc(output_length);
     *   if (snappy_compress(input, input_length, output, &output_length)
     *       == SNAPPY_OK) {
     *     ... Process(output, output_length) ...
     *   }
     *   free(output);
     */
    snappy_status snappy_compress(const char* input,
                                  size_t input_length,
                                  char* compressed,
                                  size_t* compressed_length);
    
    /*
     * Given data in "compressed[0..compressed_length-1]" generated by
     * calling the snappy_compress routine, this routine stores
     * the uncompressed data to
     *   uncompressed[0..uncompressed_length-1].
     * Returns failure (a value not equal to SNAPPY_OK) if the message
     * is corrupted and could not be decrypted.
     *
     * <uncompressed_length> signals the space available in "uncompressed".
     * If it is not at least equal to the value returned by
     * snappy_uncompressed_length for this stream, SNAPPY_BUFFER_TOO_SMALL
     * is returned. After successful decompression, <uncompressed_length>
     * contains the true length of the decompressed output.
     *
     * Example:
     *   size_t output_length;
     *   if (snappy_uncompressed_length(input, input_length, &output_length)
     *       != SNAPPY_OK) {
     *     ... fail ...
     *   }
     *   char* output = (char*)malloc(output_length);
     *   if (snappy_uncompress(input, input_length, output, &output_length)
     *       == SNAPPY_OK) {
     *     ... Process(output, output_length) ...
     *   }
     *   free(output);
     */
    snappy_status snappy_uncompress(const char* compressed,
                                    size_t compressed_length,
                                    char* uncompressed,
                                    size_t* uncompressed_length);
    
    /*
     * Returns the maximal size of the compressed representation of
     * input data that is "source_length" bytes in length.
     */
    size_t snappy_max_compressed_length(size_t source_length);
    
    /*
     * REQUIRES: "compressed[]" was produced by snappy_compress()
     * Returns SNAPPY_OK and stores the length of the uncompressed data in
     * *result normally. Returns SNAPPY_INVALID_INPUT on parsing error.
     * This operation takes O(1) time.
     */
    snappy_status snappy_uncompressed_length(const char* compressed,
                                             size_t compressed_length,
                                             size_t* result);
    
    /*
     * Check if the contents of "compressed[]" can be uncompressed successfully.
     * Does not return the uncompressed data; if so, returns SNAPPY_OK,
     * or if not, returns SNAPPY_INVALID_INPUT.
     * Takes time proportional to compressed_length, but is usually at least a
     * factor of four faster than actual decompression.
     */
    snappy_status snappy_validate_compressed_buffer(const char* compressed,
                                                    size_t compressed_length);
    
    #ifdef __cplusplus
    }  // extern "C"
    #endif
    
    #endif  /* UTIL_SNAPPY_OPENSOURCE_SNAPPY_C_H_ */

[http_code.google.com_p_snappy]: http://code.google.com/p/snappy/
[view plain]: http://blog.csdn.net/luo6620378xu/article/details/8521223#