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 |
649 | |