Coverage Report

Created: 2024-05-04 12:45

/proc/self/cwd/external/snappy/snappy.h
Line
Count
Source (jump to first uncovered line)
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 THIRD_PARTY_SNAPPY_SNAPPY_H__
40
#define THIRD_PARTY_SNAPPY_SNAPPY_H__
41
42
#include <stddef.h>
43
#include <stdint.h>
44
45
#include <string>
46
47
#include "snappy-stubs-public.h"
48
49
namespace snappy {
50
  class Source;
51
  class Sink;
52
53
  struct CompressionOptions {
54
    // Compression level.
55
    // Level 1 is the fastest
56
    // Level 2 is a little slower but provides better compression. Level 2 is
57
    // **EXPERIMENTAL** for the time being. It might happen that we decide to
58
    // fall back to level 1 in the future.
59
    // Levels 3+ are currently not supported. We plan to support levels up to
60
    // 9 in the future.
61
    // If you played with other compression algorithms, level 1 is equivalent to
62
    // fast mode (level 1) of LZ4, level 2 is equivalent to LZ4's level 2 mode
63
    // and compresses somewhere around zstd:-3 and zstd:-2 but generally with
64
    // faster decompression speeds than snappy:1 and zstd:-3.
65
    int level = DefaultCompressionLevel();
66
67
0
    constexpr CompressionOptions() = default;
68
    constexpr CompressionOptions(int compression_level)
69
0
        : level(compression_level) {}
70
0
    static constexpr int MinCompressionLevel() { return 1; }
71
0
    static constexpr int MaxCompressionLevel() { return 2; }
72
0
    static constexpr int DefaultCompressionLevel() { return 1; }
73
  };
74
75
  // ------------------------------------------------------------------------
76
  // Generic compression/decompression routines.
77
  // ------------------------------------------------------------------------
78
79
  // Compress the bytes read from "*reader" and append to "*writer". Return the
80
  // number of bytes written.
81
  size_t Compress(Source* reader, Sink* writer,
82
                  CompressionOptions options = {});
83
84
  // Find the uncompressed length of the given stream, as given by the header.
85
  // Note that the true length could deviate from this; the stream could e.g.
86
  // be truncated.
87
  //
88
  // Also note that this leaves "*source" in a state that is unsuitable for
89
  // further operations, such as RawUncompress(). You will need to rewind
90
  // or recreate the source yourself before attempting any further calls.
91
  bool GetUncompressedLength(Source* source, uint32_t* result);
92
93
  // ------------------------------------------------------------------------
94
  // Higher-level string based routines (should be sufficient for most users)
95
  // ------------------------------------------------------------------------
96
97
  // Sets "*compressed" to the compressed version of "input[0..input_length-1]".
98
  // Original contents of *compressed are lost.
99
  //
100
  // REQUIRES: "input[]" is not an alias of "*compressed".
101
  size_t Compress(const char* input, size_t input_length,
102
                  std::string* compressed, CompressionOptions options = {});
103
104
  // Same as `Compress` above but taking an `iovec` array as input. Note that
105
  // this function preprocesses the inputs to compute the sum of
106
  // `iov[0..iov_cnt-1].iov_len` before reading. To avoid this, use
107
  // `RawCompressFromIOVec` below.
108
  size_t CompressFromIOVec(const struct iovec* iov, size_t iov_cnt,
109
                           std::string* compressed,
110
                           CompressionOptions options = {});
111
112
  // Decompresses "compressed[0..compressed_length-1]" to "*uncompressed".
113
  // Original contents of "*uncompressed" are lost.
114
  //
115
  // REQUIRES: "compressed[]" is not an alias of "*uncompressed".
116
  //
117
  // returns false if the message is corrupted and could not be decompressed
118
  bool Uncompress(const char* compressed, size_t compressed_length,
119
                  std::string* uncompressed);
120
121
  // Decompresses "compressed" to "*uncompressed".
122
  //
123
  // returns false if the message is corrupted and could not be decompressed
124
  bool Uncompress(Source* compressed, Sink* uncompressed);
125
126
  // This routine uncompresses as much of the "compressed" as possible
127
  // into sink.  It returns the number of valid bytes added to sink
128
  // (extra invalid bytes may have been added due to errors; the caller
129
  // should ignore those). The emitted data typically has length
130
  // GetUncompressedLength(), but may be shorter if an error is
131
  // encountered.
132
  size_t UncompressAsMuchAsPossible(Source* compressed, Sink* uncompressed);
133
134
  // ------------------------------------------------------------------------
135
  // Lower-level character array based routines.  May be useful for
136
  // efficiency reasons in certain circumstances.
137
  // ------------------------------------------------------------------------
138
139
  // REQUIRES: "compressed" must point to an area of memory that is at
140
  // least "MaxCompressedLength(input_length)" bytes in length.
141
  //
142
  // Takes the data stored in "input[0..input_length]" and stores
143
  // it in the array pointed to by "compressed".
144
  //
145
  // "*compressed_length" is set to the length of the compressed output.
146
  //
147
  // Example:
148
  //    char* output = new char[snappy::MaxCompressedLength(input_length)];
149
  //    size_t output_length;
150
  //    RawCompress(input, input_length, output, &output_length);
151
  //    ... Process(output, output_length) ...
152
  //    delete [] output;
153
  void RawCompress(const char* input, size_t input_length, char* compressed,
154
                   size_t* compressed_length, CompressionOptions options = {});
155
156
  // Same as `RawCompress` above but taking an `iovec` array as input. Note that
157
  // `uncompressed_length` is the total number of bytes to be read from the
158
  // elements of `iov` (_not_ the number of elements in `iov`).
159
  void RawCompressFromIOVec(const struct iovec* iov, size_t uncompressed_length,
160
                            char* compressed, size_t* compressed_length,
161
                            CompressionOptions options = {});
162
163
  // Given data in "compressed[0..compressed_length-1]" generated by
164
  // calling the Snappy::Compress routine, this routine
165
  // stores the uncompressed data to
166
  //    uncompressed[0..GetUncompressedLength(compressed)-1]
167
  // returns false if the message is corrupted and could not be decrypted
168
  bool RawUncompress(const char* compressed, size_t compressed_length,
169
                     char* uncompressed);
170
171
  // Given data from the byte source 'compressed' generated by calling
172
  // the Snappy::Compress routine, this routine stores the uncompressed
173
  // data to
174
  //    uncompressed[0..GetUncompressedLength(compressed,compressed_length)-1]
175
  // returns false if the message is corrupted and could not be decrypted
176
  bool RawUncompress(Source* compressed, char* uncompressed);
177
178
  // Given data in "compressed[0..compressed_length-1]" generated by
179
  // calling the Snappy::Compress routine, this routine
180
  // stores the uncompressed data to the iovec "iov". The number of physical
181
  // buffers in "iov" is given by iov_cnt and their cumulative size
182
  // must be at least GetUncompressedLength(compressed). The individual buffers
183
  // in "iov" must not overlap with each other.
184
  //
185
  // returns false if the message is corrupted and could not be decrypted
186
  bool RawUncompressToIOVec(const char* compressed, size_t compressed_length,
187
                            const struct iovec* iov, size_t iov_cnt);
188
189
  // Given data from the byte source 'compressed' generated by calling
190
  // the Snappy::Compress routine, this routine stores the uncompressed
191
  // data to the iovec "iov". The number of physical
192
  // buffers in "iov" is given by iov_cnt and their cumulative size
193
  // must be at least GetUncompressedLength(compressed). The individual buffers
194
  // in "iov" must not overlap with each other.
195
  //
196
  // returns false if the message is corrupted and could not be decrypted
197
  bool RawUncompressToIOVec(Source* compressed, const struct iovec* iov,
198
                            size_t iov_cnt);
199
200
  // Returns the maximal size of the compressed representation of
201
  // input data that is "source_bytes" bytes in length;
202
  size_t MaxCompressedLength(size_t source_bytes);
203
204
  // REQUIRES: "compressed[]" was produced by RawCompress() or Compress()
205
  // Returns true and stores the length of the uncompressed data in
206
  // *result normally.  Returns false on parsing error.
207
  // This operation takes O(1) time.
208
  bool GetUncompressedLength(const char* compressed, size_t compressed_length,
209
                             size_t* result);
210
211
  // Returns true iff the contents of "compressed[]" can be uncompressed
212
  // successfully.  Does not return the uncompressed data.  Takes
213
  // time proportional to compressed_length, but is usually at least
214
  // a factor of four faster than actual decompression.
215
  bool IsValidCompressedBuffer(const char* compressed,
216
                               size_t compressed_length);
217
218
  // Returns true iff the contents of "compressed" can be uncompressed
219
  // successfully.  Does not return the uncompressed data.  Takes
220
  // time proportional to *compressed length, but is usually at least
221
  // a factor of four faster than actual decompression.
222
  // On success, consumes all of *compressed.  On failure, consumes an
223
  // unspecified prefix of *compressed.
224
  bool IsValidCompressed(Source* compressed);
225
226
  // The size of a compression block. Note that many parts of the compression
227
  // code assumes that kBlockSize <= 65536; in particular, the hash table
228
  // can only store 16-bit offsets, and EmitCopy() also assumes the offset
229
  // is 65535 bytes or less. Note also that if you change this, it will
230
  // affect the framing format (see framing_format.txt).
231
  //
232
  // Note that there might be older data around that is compressed with larger
233
  // block sizes, so the decompression code should not rely on the
234
  // non-existence of long backreferences.
235
  static constexpr int kBlockLog = 16;
236
  static constexpr size_t kBlockSize = 1 << kBlockLog;
237
238
  static constexpr int kMinHashTableBits = 8;
239
  static constexpr size_t kMinHashTableSize = 1 << kMinHashTableBits;
240
241
  static constexpr int kMaxHashTableBits = 15;
242
  static constexpr size_t kMaxHashTableSize = 1 << kMaxHashTableBits;
243
}  // end namespace snappy
244
245
#endif  // THIRD_PARTY_SNAPPY_SNAPPY_H__