]>
Commit | Line | Data |
---|---|---|
4e1a33b1 | 1 | /* LZ4 Kernel Interface |
cffb78b0 KL |
2 | * |
3 | * Copyright (C) 2013, LG Electronics, Kyungsik Lee <kyungsik.lee@lge.com> | |
4e1a33b1 | 4 | * Copyright (C) 2016, Sven Schmidt <4sschmid@informatik.uni-hamburg.de> |
cffb78b0 KL |
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. | |
4e1a33b1 SS |
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 | |
cffb78b0 KL |
39 | */ |
40 | ||
4e1a33b1 SS |
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 | **************************************************************************/ | |
cffb78b0 | 50 | /* |
4e1a33b1 SS |
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 | |
cffb78b0 | 57 | */ |
4e1a33b1 SS |
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) | |
cffb78b0 | 171 | { |
4e1a33b1 | 172 | return LZ4_COMPRESSBOUND(isize); |
cffb78b0 KL |
173 | } |
174 | ||
4e1a33b1 SS |
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); | |
c72ac7a1 | 247 | |
4e1a33b1 SS |
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 | * | |
97a0efea | 281 | * Decompresses data from 'source' into 'dest'. |
4e1a33b1 SS |
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); | |
cffb78b0 | 322 | |
4e1a33b1 SS |
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 | ||
4e1a33b1 SS |
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 | /** | |
97a0efea | 525 | * LZ4_decompress_safe_continue() - Decompress blocks in streaming mode |
4e1a33b1 SS |
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 | * | |
97a0efea | 533 | * This decoding function allows decompression of multiple blocks |
4e1a33b1 SS |
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 | * | |
97a0efea | 572 | * This decoding function allows decompression of multiple blocks |
4e1a33b1 SS |
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 | * | |
97a0efea | 613 | * This decoding function works the same as |
4e1a33b1 SS |
614 | * a combination of LZ4_setStreamDecode() followed by |
615 | * LZ4_decompress_safe_continue() | |
97a0efea | 616 | * It is stand-alone, and doesn't need an LZ4_streamDecode_t structure. |
4e1a33b1 SS |
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 | * | |
97a0efea | 636 | * This decoding function works the same as |
4e1a33b1 | 637 | * a combination of LZ4_setStreamDecode() followed by |
97a0efea TL |
638 | * LZ4_decompress_fast_continue() |
639 | * It is stand-alone, and doesn't need an LZ4_streamDecode_t structure. | |
4e1a33b1 SS |
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 | ||
cffb78b0 | 648 | #endif |