| // Copyright 2005 and onwards Google Inc. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| // 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 int kBlockSize = 1 << kBlockLog; |
| |
| static const int kMaxHashTableBits = 14; |
| static const int kMaxHashTableSize = 1 << kMaxHashTableBits; |
| |
| } // end namespace snappy |
| |
| |
| #endif // UTIL_SNAPPY_SNAPPY_H__ |