contrib/subversion/subversion/libsvn_subr/lz4/lz4internal.h

   1 #include "svn_private_config.h"
   2 #if SVN_INTERNAL_LZ4
   3 /*
   4  *  LZ4 - Fast LZ compression algorithm
   5  *  Header File
   6  *  Copyright (C) 2011-2016, Yann Collet.
   7
   8    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
   9
  10    Redistribution and use in source and binary forms, with or without
  11    modification, are permitted provided that the following conditions are
  12    met:
  13
  14        * Redistributions of source code must retain the above copyright
  15    notice, this list of conditions and the following disclaimer.
  16        * Redistributions in binary form must reproduce the above
  17    copyright notice, this list of conditions and the following disclaimer
  18    in the documentation and/or other materials provided with the
  19    distribution.
  20
  21    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32
  33    You can contact the author at :
  34     - LZ4 homepage : http://www.lz4.org
  35     - LZ4 source repository : https://github.com/lz4/lz4
  36 */
  37 #ifndef LZ4_H_2983827168210
  38 #define LZ4_H_2983827168210
  39
  40 #if defined (__cplusplus)
  41 extern "C" {
  42 #endif
  43
  44 /* --- Dependency --- */
  45 #include <stddef.h>   /* size_t */
  46
  47
  48 /**
  49   Introduction
  50
  51   LZ4 is lossless compression algorithm, providing compression speed at 400 MB/s per core,
  52   scalable with multi-cores CPU. It features an extremely fast decoder, with speed in
  53   multiple GB/s per core, typically reaching RAM speed limits on multi-core systems.
  54
  55   The LZ4 compression library provides in-memory compression and decompression functions.
  56   Compression can be done in:
  57     - a single step (described as Simple Functions)
  58     - a single step, reusing a context (described in Advanced Functions)
  59     - unbounded multiple steps (described as Streaming compression)
  60
  61   lz4.h provides block compression functions. It gives full buffer control to user.
  62   Decompressing an lz4-compressed block also requires metadata (such as compressed size).
  63   Each application is free to encode such metadata in whichever way it wants.
  64
  65   An additional format, called LZ4 frame specification (doc/lz4_Frame_format.md),
  66   take care of encoding standard metadata alongside LZ4-compressed blocks.
  67   If your application requires interoperability, it's recommended to use it.
  68   A library is provided to take care of it, see lz4frame.h.
  69 */
  70
  71 /*^***************************************************************
  72 *  Export parameters
  73 *****************************************************************/
  74 /*
  75 *  LZ4_DLL_EXPORT :
  76 *  Enable exporting of functions when building a Windows DLL
  77 */
  78 #if defined(LZ4_DLL_EXPORT) && (LZ4_DLL_EXPORT==1)
  79 #  define LZ4LIB_API __declspec(dllexport)
  80 #elif defined(LZ4_DLL_IMPORT) && (LZ4_DLL_IMPORT==1)
  81 #  define LZ4LIB_API __declspec(dllimport) /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
  82 #else
  83 #  define LZ4LIB_API
  84 #endif
  85
  86
  87 /*========== Version =========== */
  88 #define LZ4_VERSION_MAJOR    1    /* for breaking interface changes  */
  89 #define LZ4_VERSION_MINOR    7    /* for new (non-breaking) interface capabilities */
  90 #define LZ4_VERSION_RELEASE  5    /* for tweaks, bug-fixes, or development */
  91
  92 #define LZ4_VERSION_NUMBER (LZ4_VERSION_MAJOR *100*100 + LZ4_VERSION_MINOR *100 + LZ4_VERSION_RELEASE)
  93
  94 #define LZ4_LIB_VERSION LZ4_VERSION_MAJOR.LZ4_VERSION_MINOR.LZ4_VERSION_RELEASE
  95 #define LZ4_QUOTE(str) #str
  96 #define LZ4_EXPAND_AND_QUOTE(str) LZ4_QUOTE(str)
  97 #define LZ4_VERSION_STRING LZ4_EXPAND_AND_QUOTE(LZ4_LIB_VERSION)
  98
  99 LZ4LIB_API int LZ4_versionNumber (void);
 100 LZ4LIB_API const char* LZ4_versionString (void);
 101
 102
 103 /*-************************************
 104 *  Tuning parameter
 105 **************************************/
 106 /*!
 107  * LZ4_MEMORY_USAGE :
 108  * Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
 109  * Increasing memory usage improves compression ratio
 110  * Reduced memory usage can improve speed, due to cache effect
 111  * Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache
 112  */
 113 #define LZ4_MEMORY_USAGE 14
 114
 115
 116 /*-************************************
 117 *  Simple Functions
 118 **************************************/
 119 /*! LZ4_compress_default() :
 120     Compresses 'sourceSize' bytes from buffer 'source'
 121     into already allocated 'dest' buffer of size 'maxDestSize'.
 122     Compression is guaranteed to succeed if 'maxDestSize' >= LZ4_compressBound(sourceSize).
 123     It also runs faster, so it's a recommended setting.
 124     If the function cannot compress 'source' into a more limited 'dest' budget,
 125     compression stops *immediately*, and the function result is zero.
 126     As a consequence, 'dest' content is not valid.
 127     This function never writes outside 'dest' buffer, nor read outside 'source' buffer.
 128         sourceSize  : Max supported value is LZ4_MAX_INPUT_VALUE
 129         maxDestSize : full or partial size of buffer 'dest' (which must be already allocated)
 130         return : the number of bytes written into buffer 'dest' (necessarily <= maxOutputSize)
 131               or 0 if compression fails */
 132 LZ4LIB_API int LZ4_compress_default(const char* source, char* dest, int sourceSize, int maxDestSize);
 133
 134 /*! LZ4_decompress_safe() :
 135     compressedSize : is the precise full size of the compressed block.
 136     maxDecompressedSize : is the size of destination buffer, which must be already allocated.
 137     return : the number of bytes decompressed into destination buffer (necessarily <= maxDecompressedSize)
 138              If destination buffer is not large enough, decoding will stop and output an error code (<0).
 139              If the source stream is detected malformed, the function will stop decoding and return a negative result.
 140              This function is protected against buffer overflow exploits, including malicious data packets.
 141              It never writes outside output buffer, nor reads outside input buffer.
 142 */
 143 LZ4LIB_API int LZ4_decompress_safe (const char* source, char* dest, int compressedSize, int maxDecompressedSize);
 144
 145
 146 /*-************************************
 147 *  Advanced Functions
 148 **************************************/
 149 #define LZ4_MAX_INPUT_SIZE        0x7E000000   /* 2 113 929 216 bytes */
 150 #define LZ4_COMPRESSBOUND(isize)  ((unsigned)(isize) > (unsigned)LZ4_MAX_INPUT_SIZE ? 0 : (isize) + ((isize)/255) + 16)
 151
 152 /*!
 153 LZ4_compressBound() :
 154     Provides the maximum size that LZ4 compression may output in a "worst case" scenario (input data not compressible)
 155     This function is primarily useful for memory allocation purposes (destination buffer size).
 156     Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example).
 157     Note that LZ4_compress_default() compress faster when dest buffer size is >= LZ4_compressBound(srcSize)
 158         inputSize  : max supported value is LZ4_MAX_INPUT_SIZE
 159         return : maximum output size in a "worst case" scenario
 160               or 0, if input size is too large ( > LZ4_MAX_INPUT_SIZE)
 161 */
 162 LZ4LIB_API int LZ4_compressBound(int inputSize);
 163
 164 /*!
 165 LZ4_compress_fast() :
 166     Same as LZ4_compress_default(), but allows to select an "acceleration" factor.
 167     The larger the acceleration value, the faster the algorithm, but also the lesser the compression.
 168     It's a trade-off. It can be fine tuned, with each successive value providing roughly +~3% to speed.
 169     An acceleration value of "1" is the same as regular LZ4_compress_default()
 170     Values <= 0 will be replaced by ACCELERATION_DEFAULT (see lz4.c), which is 1.
 171 */
 172 LZ4LIB_API int LZ4_compress_fast (const char* source, char* dest, int sourceSize, int maxDestSize, int acceleration);
 173
 174
 175 /*!
 176 LZ4_compress_fast_extState() :
 177     Same compression function, just using an externally allocated memory space to store compression state.
 178     Use LZ4_sizeofState() to know how much memory must be allocated,
 179     and allocate it on 8-bytes boundaries (using malloc() typically).
 180     Then, provide it as 'void* state' to compression function.
 181 */
 182 LZ4LIB_API int LZ4_sizeofState(void);
 183 LZ4LIB_API int LZ4_compress_fast_extState (void* state, const char* source, char* dest, int inputSize, int maxDestSize, int acceleration);
 184
 185
 186 /*!
 187 LZ4_compress_destSize() :
 188     Reverse the logic, by compressing as much data as possible from 'source' buffer
 189     into already allocated buffer 'dest' of size 'targetDestSize'.
 190     This function either compresses the entire 'source' content into 'dest' if it's large enough,
 191     or fill 'dest' buffer completely with as much data as possible from 'source'.
 192         *sourceSizePtr : will be modified to indicate how many bytes where read from 'source' to fill 'dest'.
 193                          New value is necessarily <= old value.
 194         return : Nb bytes written into 'dest' (necessarily <= targetDestSize)
 195               or 0 if compression fails
 196 */
 197 LZ4LIB_API int LZ4_compress_destSize (const char* source, char* dest, int* sourceSizePtr, int targetDestSize);
 198
 199
 200 /*!
 201 LZ4_decompress_fast() :
 202     originalSize : is the original and therefore uncompressed size
 203     return : the number of bytes read from the source buffer (in other words, the compressed size)
 204              If the source stream is detected malformed, the function will stop decoding and return a negative result.
 205              Destination buffer must be already allocated. Its size must be a minimum of 'originalSize' bytes.
 206     note : This function fully respect memory boundaries for properly formed compressed data.
 207            It is a bit faster than LZ4_decompress_safe().
 208            However, it does not provide any protection against intentionally modified data stream (malicious input).
 209            Use this function in trusted environment only (data to decode comes from a trusted source).
 210 */
 211 LZ4LIB_API int LZ4_decompress_fast (const char* source, char* dest, int originalSize);
 212
 213 /*!
 214 LZ4_decompress_safe_partial() :
 215     This function decompress a compressed block of size 'compressedSize' at position 'source'
 216     into destination buffer 'dest' of size 'maxDecompressedSize'.
 217     The function tries to stop decompressing operation as soon as 'targetOutputSize' has been reached,
 218     reducing decompression time.
 219     return : the number of bytes decoded in the destination buffer (necessarily <= maxDecompressedSize)
 220        Note : this number can be < 'targetOutputSize' should the compressed block to decode be smaller.
 221              Always control how many bytes were decoded.
 222              If the source stream is detected malformed, the function will stop decoding and return a negative result.
 223              This function never writes outside of output buffer, and never reads outside of input buffer. It is therefore protected against malicious data packets
 224 */
 225 LZ4LIB_API int LZ4_decompress_safe_partial (const char* source, char* dest, int compressedSize, int targetOutputSize, int maxDecompressedSize);
 226
 227
 228 /*-*********************************************
 229 *  Streaming Compression Functions
 230 ***********************************************/
 231 typedef union LZ4_stream_u LZ4_stream_t;   /* incomplete type (defined later) */
 232
 233 /*! LZ4_createStream() and LZ4_freeStream() :
 234  *  LZ4_createStream() will allocate and initialize an `LZ4_stream_t` structure.
 235  *  LZ4_freeStream() releases its memory.
 236  */
 237 LZ4LIB_API LZ4_stream_t* LZ4_createStream(void);
 238 LZ4LIB_API int           LZ4_freeStream (LZ4_stream_t* streamPtr);
 239
 240 /*! LZ4_resetStream() :
 241  *  An LZ4_stream_t structure can be allocated once and re-used multiple times.
 242  *  Use this function to init an allocated `LZ4_stream_t` structure and start a new compression.
 243  */
 244 LZ4LIB_API void LZ4_resetStream (LZ4_stream_t* streamPtr);
 245
 246 /*! LZ4_loadDict() :
 247  *  Use this function to load a static dictionary into LZ4_stream.
 248  *  Any previous data will be forgotten, only 'dictionary' will remain in memory.
 249  *  Loading a size of 0 is allowed.
 250  *  Return : dictionary size, in bytes (necessarily <= 64 KB)
 251  */
 252 LZ4LIB_API int LZ4_loadDict (LZ4_stream_t* streamPtr, const char* dictionary, int dictSize);
 253
 254 /*! LZ4_compress_fast_continue() :
 255  *  Compress buffer content 'src', using data from previously compressed blocks as dictionary to improve compression ratio.
 256  *  Important : Previous data blocks are assumed to still be present and unmodified !
 257  *  'dst' buffer must be already allocated.
 258  *  If maxDstSize >= LZ4_compressBound(srcSize), compression is guaranteed to succeed, and runs faster.
 259  *  If not, and if compressed data cannot fit into 'dst' buffer size, compression stops, and function returns a zero.
 260  */
 261 LZ4LIB_API int LZ4_compress_fast_continue (LZ4_stream_t* streamPtr, const char* src, char* dst, int srcSize, int maxDstSize, int acceleration);
 262
 263 /*! LZ4_saveDict() :
 264  *  If previously compressed data block is not guaranteed to remain available at its memory location,
 265  *  save it into a safer place (char* safeBuffer).
 266  *  Note : you don't need to call LZ4_loadDict() afterwards,
 267  *         dictionary is immediately usable, you can therefore call LZ4_compress_fast_continue().
 268  *  Return : saved dictionary size in bytes (necessarily <= dictSize), or 0 if error.
 269  */
 270 LZ4LIB_API int LZ4_saveDict (LZ4_stream_t* streamPtr, char* safeBuffer, int dictSize);
 271
 272
 273 /*-**********************************************
 274 *  Streaming Decompression Functions
 275 *  Bufferless synchronous API
 276 ************************************************/
 277 typedef union LZ4_streamDecode_u LZ4_streamDecode_t;   /* incomplete type (defined later) */
 278
 279 /* creation / destruction of streaming decompression tracking structure */
 280 LZ4LIB_API LZ4_streamDecode_t* LZ4_createStreamDecode(void);
 281 LZ4LIB_API int                 LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream);
 282
 283 /*! LZ4_setStreamDecode() :
 284  *  Use this function to instruct where to find the dictionary.
 285  *  Setting a size of 0 is allowed (same effect as reset).
 286  *  @return : 1 if OK, 0 if error
 287  */
 288 LZ4LIB_API int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize);
 289
 290 /*!
 291 LZ4_decompress_*_continue() :
 292     These decoding functions allow decompression of multiple blocks in "streaming" mode.
 293     Previously decoded blocks *must* remain available at the memory position where they were decoded (up to 64 KB)
 294     In the case of a ring buffers, decoding buffer must be either :
 295     - Exactly same size as encoding buffer, with same update rule (block boundaries at same positions)
 296       In which case, the decoding & encoding ring buffer can have any size, including very small ones ( < 64 KB).
 297     - Larger than encoding buffer, by a minimum of maxBlockSize more bytes.
 298       maxBlockSize is implementation dependent. It's the maximum size you intend to compress into a single block.
 299       In which case, encoding and decoding buffers do not need to be synchronized,
 300       and encoding ring buffer can have any size, including small ones ( < 64 KB).
 301     - _At least_ 64 KB + 8 bytes + maxBlockSize.
 302       In which case, encoding and decoding buffers do not need to be synchronized,
 303       and encoding ring buffer can have any size, including larger than decoding buffer.
 304     Whenever these conditions are not possible, save the last 64KB of decoded data into a safe buffer,
 305     and indicate where it is saved using LZ4_setStreamDecode()
 306 */
 307 LZ4LIB_API int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int compressedSize, int maxDecompressedSize);
 308 LZ4LIB_API int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int originalSize);
 309
 310
 311 /*! LZ4_decompress_*_usingDict() :
 312  *  These decoding functions work the same as
 313  *  a combination of LZ4_setStreamDecode() followed by LZ4_decompress_*_continue()
 314  *  They are stand-alone, and don't need an LZ4_streamDecode_t structure.
 315  */
 316 LZ4LIB_API int LZ4_decompress_safe_usingDict (const char* source, char* dest, int compressedSize, int maxDecompressedSize, const char* dictStart, int dictSize);
 317 LZ4LIB_API int LZ4_decompress_fast_usingDict (const char* source, char* dest, int originalSize, const char* dictStart, int dictSize);
 318
 319
 320 /*^**********************************************
 321  * !!!!!!   STATIC LINKING ONLY   !!!!!!
 322  ***********************************************/
 323 /*-************************************
 324  *  Private definitions
 325  **************************************
 326  * Do not use these definitions.
 327  * They are exposed to allow static allocation of `LZ4_stream_t` and `LZ4_streamDecode_t`.
 328  * Using these definitions will expose code to API and/or ABI break in future versions of the library.
 329  **************************************/
 330 #define LZ4_HASHLOG   (LZ4_MEMORY_USAGE-2)
 331 #define LZ4_HASHTABLESIZE (1 << LZ4_MEMORY_USAGE)
 332 #define LZ4_HASH_SIZE_U32 (1 << LZ4_HASHLOG)       /* required as macro for static allocation */
 333
 334 #if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
 335 #include <stdint.h>
 336
 337 typedef struct {
 338     uint32_t hashTable[LZ4_HASH_SIZE_U32];
 339     uint32_t currentOffset;
 340     uint32_t initCheck;
 341     const uint8_t* dictionary;
 342     uint8_t* bufferStart;   /* obsolete, used for slideInputBuffer */
 343     uint32_t dictSize;
 344 } LZ4_stream_t_internal;
 345
 346 typedef struct {
 347     const uint8_t* externalDict;
 348     size_t extDictSize;
 349     const uint8_t* prefixEnd;
 350     size_t prefixSize;
 351 } LZ4_streamDecode_t_internal;
 352
 353 #else
 354
 355 typedef struct {
 356     unsigned int hashTable[LZ4_HASH_SIZE_U32];
 357     unsigned int currentOffset;
 358     unsigned int initCheck;
 359     const unsigned char* dictionary;
 360     unsigned char* bufferStart;   /* obsolete, used for slideInputBuffer */
 361     unsigned int dictSize;
 362 } LZ4_stream_t_internal;
 363
 364 typedef struct {
 365     const unsigned char* externalDict;
 366     size_t extDictSize;
 367     const unsigned char* prefixEnd;
 368     size_t prefixSize;
 369 } LZ4_streamDecode_t_internal;
 370
 371 #endif
 372
 373 /*!
 374  * LZ4_stream_t :
 375  * information structure to track an LZ4 stream.
 376  * init this structure before first use.
 377  * note : only use in association with static linking !
 378  *        this definition is not API/ABI safe,
 379  *        and may change in a future version !
 380  */
 381 #define LZ4_STREAMSIZE_U64 ((1 << (LZ4_MEMORY_USAGE-3)) + 4)
 382 #define LZ4_STREAMSIZE     (LZ4_STREAMSIZE_U64 * sizeof(unsigned long long))
 383 union LZ4_stream_u {
 384     unsigned long long table[LZ4_STREAMSIZE_U64];
 385     LZ4_stream_t_internal internal_donotuse;
 386 } ;  /* previously typedef'd to LZ4_stream_t */
 387
 388
 389 /*!
 390  * LZ4_streamDecode_t :
 391  * information structure to track an LZ4 stream during decompression.
 392  * init this structure  using LZ4_setStreamDecode (or memset()) before first use
 393  * note : only use in association with static linking !
 394  *        this definition is not API/ABI safe,
 395  *        and may change in a future version !
 396  */
 397 #define LZ4_STREAMDECODESIZE_U64  4
 398 #define LZ4_STREAMDECODESIZE     (LZ4_STREAMDECODESIZE_U64 * sizeof(unsigned long long))
 399 union LZ4_streamDecode_u {
 400     unsigned long long table[LZ4_STREAMDECODESIZE_U64];
 401     LZ4_streamDecode_t_internal internal_donotuse;
 402 } ;   /* previously typedef'd to LZ4_streamDecode_t */
 403
 404
 405 /*=************************************
 406 *  Obsolete Functions
 407 **************************************/
 408 /* Deprecation warnings */
 409 /* Should these warnings be a problem,
 410    it is generally possible to disable them,
 411    typically with -Wno-deprecated-declarations for gcc
 412    or _CRT_SECURE_NO_WARNINGS in Visual.
 413    Otherwise, it's also possible to define LZ4_DISABLE_DEPRECATE_WARNINGS */
 414 #ifdef LZ4_DISABLE_DEPRECATE_WARNINGS
 415 #  define LZ4_DEPRECATED(message)   /* disable deprecation warnings */
 416 #else
 417 #  define LZ4_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
 418 #  if defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */
 419 #    define LZ4_DEPRECATED(message) [[deprecated(message)]]
 420 #  elif (LZ4_GCC_VERSION >= 405) || defined(__clang__)
 421 #    define LZ4_DEPRECATED(message) __attribute__((deprecated(message)))
 422 #  elif (LZ4_GCC_VERSION >= 301)
 423 #    define LZ4_DEPRECATED(message) __attribute__((deprecated))
 424 #  elif defined(_MSC_VER)
 425 #    define LZ4_DEPRECATED(message) __declspec(deprecated(message))
 426 #  else
 427 #    pragma message("WARNING: You need to implement LZ4_DEPRECATED for this compiler")
 428 #    define LZ4_DEPRECATED(message)
 429 #  endif
 430 #endif /* LZ4_DISABLE_DEPRECATE_WARNINGS */
 431
 432 /* Obsolete compression functions */
 433 LZ4_DEPRECATED("use LZ4_compress_default() instead") int LZ4_compress               (const char* source, char* dest, int sourceSize);
 434 LZ4_DEPRECATED("use LZ4_compress_default() instead") int LZ4_compress_limitedOutput (const char* source, char* dest, int sourceSize, int maxOutputSize);
 435 LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") int LZ4_compress_withState               (void* state, const char* source, char* dest, int inputSize);
 436 LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") int LZ4_compress_limitedOutput_withState (void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
 437 LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") int LZ4_compress_continue                (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize);
 438 LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") int LZ4_compress_limitedOutput_continue  (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize, int maxOutputSize);
 439
 440 /* Obsolete decompression functions */
 441 /* These function names are completely deprecated and must no longer be used.
 442    They are only provided in lz4.c for compatibility with older programs.
 443     - LZ4_uncompress is the same as LZ4_decompress_fast
 444     - LZ4_uncompress_unknownOutputSize is the same as LZ4_decompress_safe
 445    These function prototypes are now disabled; uncomment them only if you really need them.
 446    It is highly recommended to stop using these prototypes and migrate to maintained ones */
 447 /* int LZ4_uncompress (const char* source, char* dest, int outputSize); */
 448 /* int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize); */
 449
 450 /* Obsolete streaming functions; use new streaming interface whenever possible */
 451 LZ4_DEPRECATED("use LZ4_createStream() instead") void* LZ4_create (char* inputBuffer);
 452 LZ4_DEPRECATED("use LZ4_createStream() instead") int   LZ4_sizeofStreamState(void);
 453 LZ4_DEPRECATED("use LZ4_resetStream() instead")  int   LZ4_resetStreamState(void* state, char* inputBuffer);
 454 LZ4_DEPRECATED("use LZ4_saveDict() instead")     char* LZ4_slideInputBuffer (void* state);
 455
 456 /* Obsolete streaming decoding functions */
 457 LZ4_DEPRECATED("use LZ4_decompress_safe_usingDict() instead") int LZ4_decompress_safe_withPrefix64k (const char* src, char* dst, int compressedSize, int maxDstSize);
 458 LZ4_DEPRECATED("use LZ4_decompress_fast_usingDict() instead") int LZ4_decompress_fast_withPrefix64k (const char* src, char* dst, int originalSize);
 459
 460
 461 #if defined (__cplusplus)
 462 }
 463 #endif
 464
 465 #endif /* LZ4_H_2983827168210 */
 466 #endif /* SVN_INTERNAL_LZ4 */