include/linux/lz4.h

   1 /* LZ4 Kernel Interface
   2  *
   3  * Copyright (C) 2013, LG Electronics, Kyungsik Lee <kyungsik.lee@lge.com>
   4  * Copyright (C) 2016, Sven Schmidt <4sschmid@informatik.uni-hamburg.de>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  * This file is based on the original header file
  11  * for LZ4 - Fast LZ compression algorithm.
  12  *
  13  * LZ4 - Fast LZ compression algorithm
  14  * Copyright (C) 2011-2016, Yann Collet.
  15  * BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
  16  * Redistribution and use in source and binary forms, with or without
  17  * modification, are permitted provided that the following conditions are
  18  * met:
  19  *      * Redistributions of source code must retain the above copyright
  20  *        notice, this list of conditions and the following disclaimer.
  21  *      * Redistributions in binary form must reproduce the above
  22  * copyright notice, this list of conditions and the following disclaimer
  23  * in the documentation and/or other materials provided with the
  24  * distribution.
  25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  26  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  27  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  28  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  29  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  30  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  31  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  32  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  33  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  34  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  35  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  * You can contact the author at :
  37  *      - LZ4 homepage : http://www.lz4.org
  38  *      - LZ4 source repository : https://github.com/lz4/lz4
  39  */
  40
  41 #ifndef __LZ4_H__
  42 #define __LZ4_H__
  43
  44 #include <linux/types.h>
  45 #include <linux/string.h>        /* memset, memcpy */
  46
  47 /*-************************************************************************
  48  *      CONSTANTS
  49  **************************************************************************/
  50 /*
  51  * LZ4_MEMORY_USAGE :
  52  * Memory usage formula : N->2^N Bytes
  53  * (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
  54  * Increasing memory usage improves compression ratio
  55  * Reduced memory usage can improve speed, due to cache effect
  56  * Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache
  57  */
  58 #define LZ4_MEMORY_USAGE 14
  59
  60 #define LZ4_MAX_INPUT_SIZE      0x7E000000 /* 2 113 929 216 bytes */
  61 #define LZ4_COMPRESSBOUND(isize)        (\
  62         (unsigned int)(isize) > (unsigned int)LZ4_MAX_INPUT_SIZE \
  63         ? 0 \
  64         : (isize) + ((isize)/255) + 16)
  65
  66 #define LZ4_ACCELERATION_DEFAULT 1
  67 #define LZ4_HASHLOG      (LZ4_MEMORY_USAGE-2)
  68 #define LZ4_HASHTABLESIZE (1 << LZ4_MEMORY_USAGE)
  69 #define LZ4_HASH_SIZE_U32 (1 << LZ4_HASHLOG)
  70
  71 #define LZ4HC_MIN_CLEVEL                        3
  72 #define LZ4HC_DEFAULT_CLEVEL                    9
  73 #define LZ4HC_MAX_CLEVEL                        16
  74
  75 #define LZ4HC_DICTIONARY_LOGSIZE 16
  76 #define LZ4HC_MAXD (1<<LZ4HC_DICTIONARY_LOGSIZE)
  77 #define LZ4HC_MAXD_MASK (LZ4HC_MAXD - 1)
  78 #define LZ4HC_HASH_LOG (LZ4HC_DICTIONARY_LOGSIZE - 1)
  79 #define LZ4HC_HASHTABLESIZE (1 << LZ4HC_HASH_LOG)
  80 #define LZ4HC_HASH_MASK (LZ4HC_HASHTABLESIZE - 1)
  81
  82 /*-************************************************************************
  83  *      STREAMING CONSTANTS AND STRUCTURES
  84  **************************************************************************/
  85 #define LZ4_STREAMSIZE_U64 ((1 << (LZ4_MEMORY_USAGE - 3)) + 4)
  86 #define LZ4_STREAMSIZE  (LZ4_STREAMSIZE_U64 * sizeof(unsigned long long))
  87
  88 #define LZ4_STREAMHCSIZE        262192
  89 #define LZ4_STREAMHCSIZE_SIZET (262192 / sizeof(size_t))
  90
  91 #define LZ4_STREAMDECODESIZE_U64        4
  92 #define LZ4_STREAMDECODESIZE             (LZ4_STREAMDECODESIZE_U64 * \
  93         sizeof(unsigned long long))
  94
  95 /*
  96  * LZ4_stream_t - information structure to track an LZ4 stream.
  97  */
  98 typedef struct {
  99         uint32_t hashTable[LZ4_HASH_SIZE_U32];
 100         uint32_t currentOffset;
 101         uint32_t initCheck;
 102         const uint8_t *dictionary;
 103         uint8_t *bufferStart;
 104         uint32_t dictSize;
 105 } LZ4_stream_t_internal;
 106 typedef union {
 107         unsigned long long table[LZ4_STREAMSIZE_U64];
 108         LZ4_stream_t_internal internal_donotuse;
 109 } LZ4_stream_t;
 110
 111 /*
 112  * LZ4_streamHC_t - information structure to track an LZ4HC stream.
 113  */
 114 typedef struct {
 115         unsigned int     hashTable[LZ4HC_HASHTABLESIZE];
 116         unsigned short   chainTable[LZ4HC_MAXD];
 117         /* next block to continue on current prefix */
 118         const unsigned char *end;
 119         /* All index relative to this position */
 120         const unsigned char *base;
 121         /* alternate base for extDict */
 122         const unsigned char *dictBase;
 123         /* below that point, need extDict */
 124         unsigned int     dictLimit;
 125         /* below that point, no more dict */
 126         unsigned int     lowLimit;
 127         /* index from which to continue dict update */
 128         unsigned int     nextToUpdate;
 129         unsigned int     compressionLevel;
 130 } LZ4HC_CCtx_internal;
 131 typedef union {
 132         size_t table[LZ4_STREAMHCSIZE_SIZET];
 133         LZ4HC_CCtx_internal internal_donotuse;
 134 } LZ4_streamHC_t;
 135
 136 /*
 137  * LZ4_streamDecode_t - information structure to track an
 138  *      LZ4 stream during decompression.
 139  *
 140  * init this structure using LZ4_setStreamDecode (or memset()) before first use
 141  */
 142 typedef struct {
 143         const uint8_t *externalDict;
 144         size_t extDictSize;
 145         const uint8_t *prefixEnd;
 146         size_t prefixSize;
 147 } LZ4_streamDecode_t_internal;
 148 typedef union {
 149         unsigned long long table[LZ4_STREAMDECODESIZE_U64];
 150         LZ4_streamDecode_t_internal internal_donotuse;
 151 } LZ4_streamDecode_t;
 152
 153 /*-************************************************************************
 154  *      SIZE OF STATE
 155  **************************************************************************/
 156 #define LZ4_MEM_COMPRESS        LZ4_STREAMSIZE
 157 #define LZ4HC_MEM_COMPRESS      LZ4_STREAMHCSIZE
 158
 159 /*-************************************************************************
 160  *      Compression Functions
 161  **************************************************************************/
 162
 163 /**
 164  * LZ4_compressBound() - Max. output size in worst case szenarios
 165  * @isize: Size of the input data
 166  *
 167  * Return: Max. size LZ4 may output in a "worst case" szenario
 168  * (data not compressible)
 169  */
 170 static inline int LZ4_compressBound(size_t isize)
 171 {
 172         return LZ4_COMPRESSBOUND(isize);
 173 }
 174
 175 /**
 176  * LZ4_compress_default() - Compress data from source to dest
 177  * @source: source address of the original data
 178  * @dest: output buffer address of the compressed data
 179  * @inputSize: size of the input data. Max supported value is LZ4_MAX_INPUT_SIZE
 180  * @maxOutputSize: full or partial size of buffer 'dest'
 181  *      which must be already allocated
 182  * @wrkmem: address of the working memory.
 183  *      This requires 'workmem' of LZ4_MEM_COMPRESS.
 184  *
 185  * Compresses 'sourceSize' bytes from buffer 'source'
 186  * into already allocated 'dest' buffer of size 'maxOutputSize'.
 187  * Compression is guaranteed to succeed if
 188  * 'maxOutputSize' >= LZ4_compressBound(inputSize).
 189  * It also runs faster, so it's a recommended setting.
 190  * If the function cannot compress 'source' into a more limited 'dest' budget,
 191  * compression stops *immediately*, and the function result is zero.
 192  * As a consequence, 'dest' content is not valid.
 193  *
 194  * Return: Number of bytes written into buffer 'dest'
 195  *      (necessarily <= maxOutputSize) or 0 if compression fails
 196  */
 197 int LZ4_compress_default(const char *source, char *dest, int inputSize,
 198         int maxOutputSize, void *wrkmem);
 199
 200 /**
 201  * LZ4_compress_fast() - As LZ4_compress_default providing an acceleration param
 202  * @source: source address of the original data
 203  * @dest: output buffer address of the compressed data
 204  * @inputSize: size of the input data. Max supported value is LZ4_MAX_INPUT_SIZE
 205  * @maxOutputSize: full or partial size of buffer 'dest'
 206  *      which must be already allocated
 207  * @acceleration: acceleration factor
 208  * @wrkmem: address of the working memory.
 209  *      This requires 'workmem' of LZ4_MEM_COMPRESS.
 210  *
 211  * Same as LZ4_compress_default(), but allows to select an "acceleration"
 212  * factor. The larger the acceleration value, the faster the algorithm,
 213  * but also the lesser the compression. It's a trade-off. It can be fine tuned,
 214  * with each successive value providing roughly +~3% to speed.
 215  * An acceleration value of "1" is the same as regular LZ4_compress_default()
 216  * Values <= 0 will be replaced by LZ4_ACCELERATION_DEFAULT, which is 1.
 217  *
 218  * Return: Number of bytes written into buffer 'dest'
 219  *      (necessarily <= maxOutputSize) or 0 if compression fails
 220  */
 221 int LZ4_compress_fast(const char *source, char *dest, int inputSize,
 222         int maxOutputSize, int acceleration, void *wrkmem);
 223
 224 /**
 225  * LZ4_compress_destSize() - Compress as much data as possible
 226  *      from source to dest
 227  * @source: source address of the original data
 228  * @dest: output buffer address of the compressed data
 229  * @sourceSizePtr: will be modified to indicate how many bytes where read
 230  *      from 'source' to fill 'dest'. New value is necessarily <= old value.
 231  * @targetDestSize: Size of buffer 'dest' which must be already allocated
 232  * @wrkmem: address of the working memory.
 233  *      This requires 'workmem' of LZ4_MEM_COMPRESS.
 234  *
 235  * Reverse the logic, by compressing as much data as possible
 236  * from 'source' buffer into already allocated buffer 'dest'
 237  * of size 'targetDestSize'.
 238  * This function either compresses the entire 'source' content into 'dest'
 239  * if it's large enough, or fill 'dest' buffer completely with as much data as
 240  * possible from 'source'.
 241  *
 242  * Return: Number of bytes written into 'dest' (necessarily <= targetDestSize)
 243  *      or 0 if compression fails
 244  */
 245 int LZ4_compress_destSize(const char *source, char *dest, int *sourceSizePtr,
 246         int targetDestSize, void *wrkmem);
 247
 248 /*-************************************************************************
 249  *      Decompression Functions
 250  **************************************************************************/
 251
 252 /**
 253  * LZ4_decompress_fast() - Decompresses data from 'source' into 'dest'
 254  * @source: source address of the compressed data
 255  * @dest: output buffer address of the uncompressed data
 256  *      which must be already allocated with 'originalSize' bytes
 257  * @originalSize: is the original and therefore uncompressed size
 258  *
 259  * Decompresses data from 'source' into 'dest'.
 260  * This function fully respect memory boundaries for properly formed
 261  * compressed data.
 262  * It is a bit faster than LZ4_decompress_safe().
 263  * However, it does not provide any protection against intentionally
 264  * modified data stream (malicious input).
 265  * Use this function in trusted environment only
 266  * (data to decode comes from a trusted source).
 267  *
 268  * Return: number of bytes read from the source buffer
 269  *      or a negative result if decompression fails.
 270  */
 271 int LZ4_decompress_fast(const char *source, char *dest, int originalSize);
 272
 273 /**
 274  * LZ4_decompress_safe() - Decompression protected against buffer overflow
 275  * @source: source address of the compressed data
 276  * @dest: output buffer address of the uncompressed data
 277  *      which must be already allocated
 278  * @compressedSize: is the precise full size of the compressed block
 279  * @maxDecompressedSize: is the size of 'dest' buffer
 280  *
 281  * Decompresses data from 'source' into 'dest'.
 282  * If the source stream is detected malformed, the function will
 283  * stop decoding and return a negative result.
 284  * This function is protected against buffer overflow exploits,
 285  * including malicious data packets. It never writes outside output buffer,
 286  * nor reads outside input buffer.
 287  *
 288  * Return: number of bytes decompressed into destination buffer
 289  *      (necessarily <= maxDecompressedSize)
 290  *      or a negative result in case of error
 291  */
 292 int LZ4_decompress_safe(const char *source, char *dest, int compressedSize,
 293         int maxDecompressedSize);
 294
 295 /**
 296  * LZ4_decompress_safe_partial() - Decompress a block of size 'compressedSize'
 297  *      at position 'source' into buffer 'dest'
 298  * @source: source address of the compressed data
 299  * @dest: output buffer address of the decompressed data which must be
 300  *      already allocated
 301  * @compressedSize: is the precise full size of the compressed block.
 302  * @targetOutputSize: the decompression operation will try
 303  *      to stop as soon as 'targetOutputSize' has been reached
 304  * @maxDecompressedSize: is the size of destination buffer
 305  *
 306  * This function decompresses a compressed block of size 'compressedSize'
 307  * at position 'source' into destination buffer 'dest'
 308  * of size 'maxDecompressedSize'.
 309  * The function tries to stop decompressing operation as soon as
 310  * 'targetOutputSize' has been reached, reducing decompression time.
 311  * This function never writes outside of output buffer,
 312  * and never reads outside of input buffer.
 313  * It is therefore protected against malicious data packets.
 314  *
 315  * Return: the number of bytes decoded in the destination buffer
 316  *      (necessarily <= maxDecompressedSize)
 317  *      or a negative result in case of error
 318  *
 319  */
 320 int LZ4_decompress_safe_partial(const char *source, char *dest,
 321         int compressedSize, int targetOutputSize, int maxDecompressedSize);
 322
 323 /*-************************************************************************
 324  *      LZ4 HC Compression
 325  **************************************************************************/
 326
 327 /**
 328  * LZ4_compress_HC() - Compress data from `src` into `dst`, using HC algorithm
 329  * @src: source address of the original data
 330  * @dst: output buffer address of the compressed data
 331  * @srcSize: size of the input data. Max supported value is LZ4_MAX_INPUT_SIZE
 332  * @dstCapacity: full or partial size of buffer 'dst',
 333  *      which must be already allocated
 334  * @compressionLevel: Recommended values are between 4 and 9, although any
 335  *      value between 1 and LZ4HC_MAX_CLEVEL will work.
 336  *      Values >LZ4HC_MAX_CLEVEL behave the same as 16.
 337  * @wrkmem: address of the working memory.
 338  *      This requires 'wrkmem' of size LZ4HC_MEM_COMPRESS.
 339  *
 340  * Compress data from 'src' into 'dst', using the more powerful
 341  * but slower "HC" algorithm. Compression is guaranteed to succeed if
 342  * `dstCapacity >= LZ4_compressBound(srcSize)
 343  *
 344  * Return : the number of bytes written into 'dst' or 0 if compression fails.
 345  */
 346 int LZ4_compress_HC(const char *src, char *dst, int srcSize, int dstCapacity,
 347         int compressionLevel, void *wrkmem);
 348
 349 /**
 350  * LZ4_resetStreamHC() - Init an allocated 'LZ4_streamHC_t' structure
 351  * @streamHCPtr: pointer to the 'LZ4_streamHC_t' structure
 352  * @compressionLevel: Recommended values are between 4 and 9, although any
 353  *      value between 1 and LZ4HC_MAX_CLEVEL will work.
 354  *      Values >LZ4HC_MAX_CLEVEL behave the same as 16.
 355  *
 356  * An LZ4_streamHC_t structure can be allocated once
 357  * and re-used multiple times.
 358  * Use this function to init an allocated `LZ4_streamHC_t` structure
 359  * and start a new compression.
 360  */
 361 void LZ4_resetStreamHC(LZ4_streamHC_t *streamHCPtr, int compressionLevel);
 362
 363 /**
 364  * LZ4_loadDictHC() - Load a static dictionary into LZ4_streamHC
 365  * @streamHCPtr: pointer to the LZ4HC_stream_t
 366  * @dictionary: dictionary to load
 367  * @dictSize: size of dictionary
 368  *
 369  * Use this function to load a static dictionary into LZ4HC_stream.
 370  * Any previous data will be forgotten, only 'dictionary'
 371  * will remain in memory.
 372  * Loading a size of 0 is allowed.
 373  *
 374  * Return : dictionary size, in bytes (necessarily <= 64 KB)
 375  */
 376 int     LZ4_loadDictHC(LZ4_streamHC_t *streamHCPtr, const char *dictionary,
 377         int dictSize);
 378
 379 /**
 380  * LZ4_compress_HC_continue() - Compress 'src' using data from previously
 381  *      compressed blocks as a dictionary using the HC algorithm
 382  * @streamHCPtr: Pointer to the previous 'LZ4_streamHC_t' structure
 383  * @src: source address of the original data
 384  * @dst: output buffer address of the compressed data,
 385  *      which must be already allocated
 386  * @srcSize: size of the input data. Max supported value is LZ4_MAX_INPUT_SIZE
 387  * @maxDstSize: full or partial size of buffer 'dest'
 388  *      which must be already allocated
 389  *
 390  * These functions compress data in successive blocks of any size, using
 391  * previous blocks as dictionary. One key assumption is that previous
 392  * blocks (up to 64 KB) remain read-accessible while
 393  * compressing next blocks. There is an exception for ring buffers,
 394  * which can be smaller than 64 KB.
 395  * Ring buffers scenario is automatically detected and handled by
 396  * LZ4_compress_HC_continue().
 397  * Before starting compression, state must be properly initialized,
 398  * using LZ4_resetStreamHC().
 399  * A first "fictional block" can then be designated as
 400  * initial dictionary, using LZ4_loadDictHC() (Optional).
 401  * Then, use LZ4_compress_HC_continue()
 402  * to compress each successive block. Previous memory blocks
 403  * (including initial dictionary when present) must remain accessible
 404  * and unmodified during compression.
 405  * 'dst' buffer should be sized to handle worst case scenarios, using
 406  *  LZ4_compressBound(), to ensure operation success.
 407  *  If, for any reason, previous data blocks can't be preserved unmodified
 408  *  in memory during next compression block,
 409  *  you must save it to a safer memory space, using LZ4_saveDictHC().
 410  * Return value of LZ4_saveDictHC() is the size of dictionary
 411  * effectively saved into 'safeBuffer'.
 412  *
 413  * Return: Number of bytes written into buffer 'dst'  or 0 if compression fails
 414  */
 415 int LZ4_compress_HC_continue(LZ4_streamHC_t *streamHCPtr, const char *src,
 416         char *dst, int srcSize, int maxDstSize);
 417
 418 /**
 419  * LZ4_saveDictHC() - Save static dictionary from LZ4HC_stream
 420  * @streamHCPtr: pointer to the 'LZ4HC_stream_t' structure
 421  * @safeBuffer: buffer to save dictionary to, must be already allocated
 422  * @maxDictSize: size of 'safeBuffer'
 423  *
 424  * If previously compressed data block is not guaranteed
 425  * to remain available at its memory location,
 426  * save it into a safer place (char *safeBuffer).
 427  * Note : you don't need to call LZ4_loadDictHC() afterwards,
 428  * dictionary is immediately usable, you can therefore call
 429  * LZ4_compress_HC_continue().
 430  *
 431  * Return : saved dictionary size in bytes (necessarily <= maxDictSize),
 432  *      or 0 if error.
 433  */
 434 int LZ4_saveDictHC(LZ4_streamHC_t *streamHCPtr, char *safeBuffer,
 435         int maxDictSize);
 436
 437 /*-*********************************************
 438  *      Streaming Compression Functions
 439  ***********************************************/
 440
 441 /**
 442  * LZ4_resetStream() - Init an allocated 'LZ4_stream_t' structure
 443  * @LZ4_stream: pointer to the 'LZ4_stream_t' structure
 444  *
 445  * An LZ4_stream_t structure can be allocated once
 446  * and re-used multiple times.
 447  * Use this function to init an allocated `LZ4_stream_t` structure
 448  * and start a new compression.
 449  */
 450 void LZ4_resetStream(LZ4_stream_t *LZ4_stream);
 451
 452 /**
 453  * LZ4_loadDict() - Load a static dictionary into LZ4_stream
 454  * @streamPtr: pointer to the LZ4_stream_t
 455  * @dictionary: dictionary to load
 456  * @dictSize: size of dictionary
 457  *
 458  * Use this function to load a static dictionary into LZ4_stream.
 459  * Any previous data will be forgotten, only 'dictionary'
 460  * will remain in memory.
 461  * Loading a size of 0 is allowed.
 462  *
 463  * Return : dictionary size, in bytes (necessarily <= 64 KB)
 464  */
 465 int LZ4_loadDict(LZ4_stream_t *streamPtr, const char *dictionary,
 466         int dictSize);
 467
 468 /**
 469  * LZ4_saveDict() - Save static dictionary from LZ4_stream
 470  * @streamPtr: pointer to the 'LZ4_stream_t' structure
 471  * @safeBuffer: buffer to save dictionary to, must be already allocated
 472  * @dictSize: size of 'safeBuffer'
 473  *
 474  * If previously compressed data block is not guaranteed
 475  * to remain available at its memory location,
 476  * save it into a safer place (char *safeBuffer).
 477  * Note : you don't need to call LZ4_loadDict() afterwards,
 478  * dictionary is immediately usable, you can therefore call
 479  * LZ4_compress_fast_continue().
 480  *
 481  * Return : saved dictionary size in bytes (necessarily <= dictSize),
 482  *      or 0 if error.
 483  */
 484 int LZ4_saveDict(LZ4_stream_t *streamPtr, char *safeBuffer, int dictSize);
 485
 486 /**
 487  * LZ4_compress_fast_continue() - Compress 'src' using data from previously
 488  *      compressed blocks as a dictionary
 489  * @streamPtr: Pointer to the previous 'LZ4_stream_t' structure
 490  * @src: source address of the original data
 491  * @dst: output buffer address of the compressed data,
 492  *      which must be already allocated
 493  * @srcSize: size of the input data. Max supported value is LZ4_MAX_INPUT_SIZE
 494  * @maxDstSize: full or partial size of buffer 'dest'
 495  *      which must be already allocated
 496  * @acceleration: acceleration factor
 497  *
 498  * Compress buffer content 'src', using data from previously compressed blocks
 499  * as dictionary to improve compression ratio.
 500  * Important : Previous data blocks are assumed to still
 501  * be present and unmodified !
 502  * If maxDstSize >= LZ4_compressBound(srcSize),
 503  * compression is guaranteed to succeed, and runs faster.
 504  *
 505  * Return: Number of bytes written into buffer 'dst'  or 0 if compression fails
 506  */
 507 int LZ4_compress_fast_continue(LZ4_stream_t *streamPtr, const char *src,
 508         char *dst, int srcSize, int maxDstSize, int acceleration);
 509
 510 /**
 511  * LZ4_setStreamDecode() - Instruct where to find dictionary
 512  * @LZ4_streamDecode: the 'LZ4_streamDecode_t' structure
 513  * @dictionary: dictionary to use
 514  * @dictSize: size of dictionary
 515  *
 516  * Use this function to instruct where to find the dictionary.
 517  *      Setting a size of 0 is allowed (same effect as reset).
 518  *
 519  * Return: 1 if OK, 0 if error
 520  */
 521 int LZ4_setStreamDecode(LZ4_streamDecode_t *LZ4_streamDecode,
 522         const char *dictionary, int dictSize);
 523
 524 /**
 525  * LZ4_decompress_safe_continue() - Decompress blocks in streaming mode
 526  * @LZ4_streamDecode: the 'LZ4_streamDecode_t' structure
 527  * @source: source address of the compressed data
 528  * @dest: output buffer address of the uncompressed data
 529  *      which must be already allocated
 530  * @compressedSize: is the precise full size of the compressed block
 531  * @maxDecompressedSize: is the size of 'dest' buffer
 532  *
 533  * This decoding function allows decompression of multiple blocks
 534  * in "streaming" mode.
 535  * Previously decoded blocks *must* remain available at the memory position
 536  * where they were decoded (up to 64 KB)
 537  * In the case of a ring buffers, decoding buffer must be either :
 538  *    - Exactly same size as encoding buffer, with same update rule
 539  *      (block boundaries at same positions) In which case,
 540  *      the decoding & encoding ring buffer can have any size,
 541  *      including very small ones ( < 64 KB).
 542  *    - Larger than encoding buffer, by a minimum of maxBlockSize more bytes.
 543  *      maxBlockSize is implementation dependent.
 544  *      It's the maximum size you intend to compress into a single block.
 545  *      In which case, encoding and decoding buffers do not need
 546  *      to be synchronized, and encoding ring buffer can have any size,
 547  *      including small ones ( < 64 KB).
 548  *    - _At least_ 64 KB + 8 bytes + maxBlockSize.
 549  *      In which case, encoding and decoding buffers do not need to be
 550  *      synchronized, and encoding ring buffer can have any size,
 551  *      including larger than decoding buffer. W
 552  * Whenever these conditions are not possible, save the last 64KB of decoded
 553  * data into a safe buffer, and indicate where it is saved
 554  * using LZ4_setStreamDecode()
 555  *
 556  * Return: number of bytes decompressed into destination buffer
 557  *      (necessarily <= maxDecompressedSize)
 558  *      or a negative result in case of error
 559  */
 560 int LZ4_decompress_safe_continue(LZ4_streamDecode_t *LZ4_streamDecode,
 561         const char *source, char *dest, int compressedSize,
 562         int maxDecompressedSize);
 563
 564 /**
 565  * LZ4_decompress_fast_continue() - Decompress blocks in streaming mode
 566  * @LZ4_streamDecode: the 'LZ4_streamDecode_t' structure
 567  * @source: source address of the compressed data
 568  * @dest: output buffer address of the uncompressed data
 569  *      which must be already allocated with 'originalSize' bytes
 570  * @originalSize: is the original and therefore uncompressed size
 571  *
 572  * This decoding function allows decompression of multiple blocks
 573  * in "streaming" mode.
 574  * Previously decoded blocks *must* remain available at the memory position
 575  * where they were decoded (up to 64 KB)
 576  * In the case of a ring buffers, decoding buffer must be either :
 577  *    - Exactly same size as encoding buffer, with same update rule
 578  *      (block boundaries at same positions) In which case,
 579  *      the decoding & encoding ring buffer can have any size,
 580  *      including very small ones ( < 64 KB).
 581  *    - Larger than encoding buffer, by a minimum of maxBlockSize more bytes.
 582  *      maxBlockSize is implementation dependent.
 583  *      It's the maximum size you intend to compress into a single block.
 584  *      In which case, encoding and decoding buffers do not need
 585  *      to be synchronized, and encoding ring buffer can have any size,
 586  *      including small ones ( < 64 KB).
 587  *    - _At least_ 64 KB + 8 bytes + maxBlockSize.
 588  *      In which case, encoding and decoding buffers do not need to be
 589  *      synchronized, and encoding ring buffer can have any size,
 590  *      including larger than decoding buffer. W
 591  * Whenever these conditions are not possible, save the last 64KB of decoded
 592  * data into a safe buffer, and indicate where it is saved
 593  * using LZ4_setStreamDecode()
 594  *
 595  * Return: number of bytes decompressed into destination buffer
 596  *      (necessarily <= maxDecompressedSize)
 597  *      or a negative result in case of error
 598  */
 599 int LZ4_decompress_fast_continue(LZ4_streamDecode_t *LZ4_streamDecode,
 600         const char *source, char *dest, int originalSize);
 601
 602 /**
 603  * LZ4_decompress_safe_usingDict() - Same as LZ4_setStreamDecode()
 604  *      followed by LZ4_decompress_safe_continue()
 605  * @source: source address of the compressed data
 606  * @dest: output buffer address of the uncompressed data
 607  *      which must be already allocated
 608  * @compressedSize: is the precise full size of the compressed block
 609  * @maxDecompressedSize: is the size of 'dest' buffer
 610  * @dictStart: pointer to the start of the dictionary in memory
 611  * @dictSize: size of dictionary
 612  *
 613  * This decoding function works the same as
 614  * a combination of LZ4_setStreamDecode() followed by
 615  * LZ4_decompress_safe_continue()
 616  * It is stand-alone, and doesn't need an LZ4_streamDecode_t structure.
 617  *
 618  * Return: number of bytes decompressed into destination buffer
 619  *      (necessarily <= maxDecompressedSize)
 620  *      or a negative result in case of error
 621  */
 622 int LZ4_decompress_safe_usingDict(const char *source, char *dest,
 623         int compressedSize, int maxDecompressedSize, const char *dictStart,
 624         int dictSize);
 625
 626 /**
 627  * LZ4_decompress_fast_usingDict() - Same as LZ4_setStreamDecode()
 628  *      followed by LZ4_decompress_fast_continue()
 629  * @source: source address of the compressed data
 630  * @dest: output buffer address of the uncompressed data
 631  *      which must be already allocated with 'originalSize' bytes
 632  * @originalSize: is the original and therefore uncompressed size
 633  * @dictStart: pointer to the start of the dictionary in memory
 634  * @dictSize: size of dictionary
 635  *
 636  * This decoding function works the same as
 637  * a combination of LZ4_setStreamDecode() followed by
 638  * LZ4_decompress_fast_continue()
 639  * It is stand-alone, and doesn't need an LZ4_streamDecode_t structure.
 640  *
 641  * Return: number of bytes decompressed into destination buffer
 642  *      (necessarily <= maxDecompressedSize)
 643  *      or a negative result in case of error
 644  */
 645 int LZ4_decompress_fast_usingDict(const char *source, char *dest,
 646         int originalSize, const char *dictStart, int dictSize);
 647
 648 #endif