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 */ 98typedef 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; 106typedef 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 */ 114typedef 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; 131typedef 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 */ 142typedef struct { 143 const uint8_t *externalDict; 144 size_t extDictSize; 145 const uint8_t *prefixEnd; 146 size_t prefixSize; 147} LZ4_streamDecode_t_internal; 148typedef 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 */ 170static 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 */ 197int 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 */ 221int 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 */ 245int 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 */ 271int 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 */ 292int 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 */ 320int 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 */ 346int 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 */ 361void 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 */ 376int 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 */ 415int 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 */ 434int 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 */ 450void 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 */ 465int 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 */ 484int 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 */ 507int 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 */ 521int 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 */ 560int 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 */ 599int 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 */ 622int 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 */ 645int LZ4_decompress_fast_usingDict(const char *source, char *dest, 646 int originalSize, const char *dictStart, int dictSize); 647 648#endif 649