Commit | Line | Data |
---|---|---|
cffb78b0 | 1 | /* |
cffb78b0 | 2 | * LZ4 - Fast LZ compression algorithm |
4e1a33b1 SS |
3 | * Copyright (C) 2011 - 2016, Yann Collet. |
4 | * BSD 2 - Clause License (http://www.opensource.org/licenses/bsd - license.php) | |
cffb78b0 KL |
5 | * Redistribution and use in source and binary forms, with or without |
6 | * modification, are permitted provided that the following conditions are | |
7 | * met: | |
4e1a33b1 SS |
8 | * * Redistributions of source code must retain the above copyright |
9 | * notice, this list of conditions and the following disclaimer. | |
10 | * * Redistributions in binary form must reproduce the above | |
cffb78b0 KL |
11 | * copyright notice, this list of conditions and the following disclaimer |
12 | * in the documentation and/or other materials provided with the | |
13 | * distribution. | |
cffb78b0 KL |
14 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
15 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
16 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
17 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
18 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
19 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
20 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
21 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
22 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
23 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
24 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
4e1a33b1 SS |
25 | * You can contact the author at : |
26 | * - LZ4 homepage : http://www.lz4.org | |
27 | * - LZ4 source repository : https://github.com/lz4/lz4 | |
cffb78b0 | 28 | * |
4e1a33b1 SS |
29 | * Changed for kernel usage by: |
30 | * Sven Schmidt <4sschmid@informatik.uni-hamburg.de> | |
cffb78b0 KL |
31 | */ |
32 | ||
4e1a33b1 SS |
33 | /*-************************************ |
34 | * Dependencies | |
35 | **************************************/ | |
36 | #include <linux/lz4.h> | |
37 | #include "lz4defs.h" | |
38 | #include <linux/init.h> | |
cffb78b0 KL |
39 | #include <linux/module.h> |
40 | #include <linux/kernel.h> | |
cffb78b0 KL |
41 | #include <asm/unaligned.h> |
42 | ||
4e1a33b1 SS |
43 | /*-***************************** |
44 | * Decompression functions | |
45 | *******************************/ | |
2209fda3 GX |
46 | |
47 | #define DEBUGLOG(l, ...) {} /* disabled */ | |
48 | ||
49 | #ifndef assert | |
50 | #define assert(condition) ((void)0) | |
51 | #endif | |
52 | ||
53 | /* | |
54 | * LZ4_decompress_generic() : | |
55 | * This generic decompression function covers all use cases. | |
56 | * It shall be instantiated several times, using different sets of directives. | |
57 | * Note that it is important for performance that this function really get inlined, | |
4e1a33b1 SS |
58 | * in order to remove useless branches during compilation optimization. |
59 | */ | |
60 | static FORCE_INLINE int LZ4_decompress_generic( | |
2209fda3 GX |
61 | const char * const src, |
62 | char * const dst, | |
63 | int srcSize, | |
4e1a33b1 SS |
64 | /* |
65 | * If endOnInput == endOnInputSize, | |
2209fda3 | 66 | * this value is `dstCapacity` |
4e1a33b1 SS |
67 | */ |
68 | int outputSize, | |
69 | /* endOnOutputSize, endOnInputSize */ | |
2209fda3 | 70 | endCondition_directive endOnInput, |
4e1a33b1 | 71 | /* full, partial */ |
2209fda3 | 72 | earlyEnd_directive partialDecoding, |
4e1a33b1 | 73 | /* noDict, withPrefix64k, usingExtDict */ |
2209fda3 GX |
74 | dict_directive dict, |
75 | /* always <= dst, == dst when no prefix */ | |
4e1a33b1 SS |
76 | const BYTE * const lowPrefix, |
77 | /* only if dict == usingExtDict */ | |
78 | const BYTE * const dictStart, | |
79 | /* note : = 0 if noDict */ | |
80 | const size_t dictSize | |
81 | ) | |
cffb78b0 | 82 | { |
2209fda3 GX |
83 | const BYTE *ip = (const BYTE *) src; |
84 | const BYTE * const iend = ip + srcSize; | |
4e1a33b1 | 85 | |
2209fda3 | 86 | BYTE *op = (BYTE *) dst; |
4e1a33b1 | 87 | BYTE * const oend = op + outputSize; |
cffb78b0 | 88 | BYTE *cpy; |
4e1a33b1 SS |
89 | |
90 | const BYTE * const dictEnd = (const BYTE *)dictStart + dictSize; | |
2209fda3 GX |
91 | static const unsigned int inc32table[8] = {0, 1, 2, 1, 0, 4, 4, 4}; |
92 | static const int dec64table[8] = {0, 0, 0, -1, -4, 1, 2, 3}; | |
cffb78b0 | 93 | |
4e1a33b1 SS |
94 | const int safeDecode = (endOnInput == endOnInputSize); |
95 | const int checkOffset = ((safeDecode) && (dictSize < (int)(64 * KB))); | |
96 | ||
2209fda3 GX |
97 | /* Set up the "end" pointers for the shortcut. */ |
98 | const BYTE *const shortiend = iend - | |
99 | (endOnInput ? 14 : 8) /*maxLL*/ - 2 /*offset*/; | |
100 | const BYTE *const shortoend = oend - | |
101 | (endOnInput ? 14 : 8) /*maxLL*/ - 18 /*maxML*/; | |
102 | ||
103 | DEBUGLOG(5, "%s (srcSize:%i, dstSize:%i)", __func__, | |
104 | srcSize, outputSize); | |
105 | ||
4e1a33b1 | 106 | /* Special cases */ |
2209fda3 GX |
107 | assert(lowPrefix <= op); |
108 | assert(src != NULL); | |
4e1a33b1 SS |
109 | |
110 | /* Empty output buffer */ | |
111 | if ((endOnInput) && (unlikely(outputSize == 0))) | |
2209fda3 | 112 | return ((srcSize == 1) && (*ip == 0)) ? 0 : -1; |
4e1a33b1 SS |
113 | |
114 | if ((!endOnInput) && (unlikely(outputSize == 0))) | |
115 | return (*ip == 0 ? 1 : -1); | |
116 | ||
2209fda3 GX |
117 | if ((endOnInput) && unlikely(srcSize == 0)) |
118 | return -1; | |
119 | ||
4e1a33b1 | 120 | /* Main Loop : decode sequences */ |
cffb78b0 | 121 | while (1) { |
4e1a33b1 SS |
122 | size_t length; |
123 | const BYTE *match; | |
124 | size_t offset; | |
125 | ||
126 | /* get literal length */ | |
127 | unsigned int const token = *ip++; | |
4e1a33b1 | 128 | length = token>>ML_BITS; |
cffb78b0 | 129 | |
2209fda3 GX |
130 | /* ip < iend before the increment */ |
131 | assert(!endOnInput || ip <= iend); | |
132 | ||
133 | /* | |
134 | * A two-stage shortcut for the most common case: | |
135 | * 1) If the literal length is 0..14, and there is enough | |
136 | * space, enter the shortcut and copy 16 bytes on behalf | |
137 | * of the literals (in the fast mode, only 8 bytes can be | |
138 | * safely copied this way). | |
139 | * 2) Further if the match length is 4..18, copy 18 bytes | |
140 | * in a similar manner; but we ensure that there's enough | |
141 | * space in the output for those 18 bytes earlier, upon | |
142 | * entering the shortcut (in other words, there is a | |
143 | * combined check for both stages). | |
144 | */ | |
145 | if ((endOnInput ? length != RUN_MASK : length <= 8) | |
146 | /* | |
147 | * strictly "less than" on input, to re-enter | |
148 | * the loop with at least one byte | |
149 | */ | |
150 | && likely((endOnInput ? ip < shortiend : 1) & | |
151 | (op <= shortoend))) { | |
152 | /* Copy the literals */ | |
153 | memcpy(op, ip, endOnInput ? 16 : 8); | |
154 | op += length; ip += length; | |
155 | ||
156 | /* | |
157 | * The second stage: | |
158 | * prepare for match copying, decode full info. | |
159 | * If it doesn't work out, the info won't be wasted. | |
160 | */ | |
161 | length = token & ML_MASK; /* match length */ | |
162 | offset = LZ4_readLE16(ip); | |
163 | ip += 2; | |
164 | match = op - offset; | |
165 | assert(match <= op); /* check overflow */ | |
166 | ||
167 | /* Do not deal with overlapping matches. */ | |
168 | if ((length != ML_MASK) && | |
169 | (offset >= 8) && | |
170 | (dict == withPrefix64k || match >= lowPrefix)) { | |
171 | /* Copy the match. */ | |
172 | memcpy(op + 0, match + 0, 8); | |
173 | memcpy(op + 8, match + 8, 8); | |
174 | memcpy(op + 16, match + 16, 2); | |
175 | op += length + MINMATCH; | |
176 | /* Both stages worked, load the next token. */ | |
177 | continue; | |
178 | } | |
179 | ||
180 | /* | |
181 | * The second stage didn't work out, but the info | |
182 | * is ready. Propel it right to the point of match | |
183 | * copying. | |
184 | */ | |
185 | goto _copy_match; | |
186 | } | |
187 | ||
188 | /* decode literal length */ | |
cffb78b0 | 189 | if (length == RUN_MASK) { |
4e1a33b1 | 190 | unsigned int s; |
cffb78b0 | 191 | |
2209fda3 GX |
192 | if (unlikely(endOnInput ? ip >= iend - RUN_MASK : 0)) { |
193 | /* overflow detection */ | |
194 | goto _output_error; | |
195 | } | |
4e1a33b1 SS |
196 | do { |
197 | s = *ip++; | |
198 | length += s; | |
199 | } while (likely(endOnInput | |
200 | ? ip < iend - RUN_MASK | |
201 | : 1) & (s == 255)); | |
202 | ||
203 | if ((safeDecode) | |
2209fda3 GX |
204 | && unlikely((uptrval)(op) + |
205 | length < (uptrval)(op))) { | |
4e1a33b1 | 206 | /* overflow detection */ |
206204a1 | 207 | goto _output_error; |
4e1a33b1 SS |
208 | } |
209 | if ((safeDecode) | |
2209fda3 GX |
210 | && unlikely((uptrval)(ip) + |
211 | length < (uptrval)(ip))) { | |
4e1a33b1 SS |
212 | /* overflow detection */ |
213 | goto _output_error; | |
214 | } | |
cffb78b0 KL |
215 | } |
216 | ||
217 | /* copy literals */ | |
218 | cpy = op + length; | |
2209fda3 GX |
219 | LZ4_STATIC_ASSERT(MFLIMIT >= WILDCOPYLENGTH); |
220 | ||
221 | if (((endOnInput) && ((cpy > oend - MFLIMIT) | |
4e1a33b1 SS |
222 | || (ip + length > iend - (2 + 1 + LASTLITERALS)))) |
223 | || ((!endOnInput) && (cpy > oend - WILDCOPYLENGTH))) { | |
224 | if (partialDecoding) { | |
225 | if (cpy > oend) { | |
226 | /* | |
2209fda3 GX |
227 | * Partial decoding : |
228 | * stop in the middle of literal segment | |
4e1a33b1 | 229 | */ |
2209fda3 GX |
230 | cpy = oend; |
231 | length = oend - op; | |
4e1a33b1 SS |
232 | } |
233 | if ((endOnInput) | |
234 | && (ip + length > iend)) { | |
235 | /* | |
236 | * Error : | |
237 | * read attempt beyond | |
238 | * end of input buffer | |
239 | */ | |
240 | goto _output_error; | |
241 | } | |
242 | } else { | |
243 | if ((!endOnInput) | |
244 | && (cpy != oend)) { | |
245 | /* | |
246 | * Error : | |
247 | * block decoding must | |
248 | * stop exactly there | |
249 | */ | |
250 | goto _output_error; | |
251 | } | |
252 | if ((endOnInput) | |
253 | && ((ip + length != iend) | |
254 | || (cpy > oend))) { | |
255 | /* | |
256 | * Error : | |
257 | * input must be consumed | |
258 | */ | |
259 | goto _output_error; | |
260 | } | |
261 | } | |
cffb78b0 KL |
262 | |
263 | memcpy(op, ip, length); | |
264 | ip += length; | |
4e1a33b1 | 265 | op += length; |
2209fda3 | 266 | |
4e1a33b1 | 267 | /* Necessarily EOF, due to parsing restrictions */ |
2209fda3 GX |
268 | if (!partialDecoding || (cpy == oend)) |
269 | break; | |
270 | } else { | |
271 | /* may overwrite up to WILDCOPYLENGTH beyond cpy */ | |
272 | LZ4_wildCopy(op, ip, cpy); | |
273 | ip += length; | |
274 | op = cpy; | |
cffb78b0 | 275 | } |
4e1a33b1 | 276 | |
cffb78b0 | 277 | /* get offset */ |
4e1a33b1 | 278 | offset = LZ4_readLE16(ip); |
cffb78b0 | 279 | ip += 2; |
4e1a33b1 | 280 | match = op - offset; |
cffb78b0 | 281 | |
2209fda3 GX |
282 | /* get matchlength */ |
283 | length = token & ML_MASK; | |
284 | ||
285 | _copy_match: | |
286 | if ((checkOffset) && (unlikely(match + dictSize < lowPrefix))) { | |
4e1a33b1 | 287 | /* Error : offset outside buffers */ |
cffb78b0 | 288 | goto _output_error; |
4e1a33b1 SS |
289 | } |
290 | ||
291 | /* costs ~1%; silence an msan warning when offset == 0 */ | |
2209fda3 GX |
292 | /* |
293 | * note : when partialDecoding, there is no guarantee that | |
294 | * at least 4 bytes remain available in output buffer | |
295 | */ | |
296 | if (!partialDecoding) { | |
297 | assert(oend > op); | |
298 | assert(oend - op >= 4); | |
299 | ||
300 | LZ4_write32(op, (U32)offset); | |
301 | } | |
cffb78b0 | 302 | |
cffb78b0 | 303 | if (length == ML_MASK) { |
4e1a33b1 SS |
304 | unsigned int s; |
305 | ||
306 | do { | |
307 | s = *ip++; | |
308 | ||
309 | if ((endOnInput) && (ip > iend - LASTLITERALS)) | |
310 | goto _output_error; | |
311 | ||
312 | length += s; | |
313 | } while (s == 255); | |
314 | ||
315 | if ((safeDecode) | |
316 | && unlikely( | |
2209fda3 | 317 | (uptrval)(op) + length < (uptrval)op)) { |
4e1a33b1 | 318 | /* overflow detection */ |
4148c1f6 | 319 | goto _output_error; |
4e1a33b1 | 320 | } |
cffb78b0 KL |
321 | } |
322 | ||
4e1a33b1 SS |
323 | length += MINMATCH; |
324 | ||
2209fda3 | 325 | /* match starting within external dictionary */ |
4e1a33b1 SS |
326 | if ((dict == usingExtDict) && (match < lowPrefix)) { |
327 | if (unlikely(op + length > oend - LASTLITERALS)) { | |
328 | /* doesn't respect parsing restriction */ | |
2209fda3 GX |
329 | if (!partialDecoding) |
330 | goto _output_error; | |
331 | length = min(length, (size_t)(oend - op)); | |
4e1a33b1 SS |
332 | } |
333 | ||
334 | if (length <= (size_t)(lowPrefix - match)) { | |
335 | /* | |
2209fda3 GX |
336 | * match fits entirely within external |
337 | * dictionary : just copy | |
4e1a33b1 SS |
338 | */ |
339 | memmove(op, dictEnd - (lowPrefix - match), | |
340 | length); | |
341 | op += length; | |
342 | } else { | |
343 | /* | |
2209fda3 | 344 | * match stretches into both external |
4e1a33b1 SS |
345 | * dictionary and current block |
346 | */ | |
347 | size_t const copySize = (size_t)(lowPrefix - match); | |
348 | size_t const restSize = length - copySize; | |
349 | ||
350 | memcpy(op, dictEnd - copySize, copySize); | |
351 | op += copySize; | |
4e1a33b1 SS |
352 | if (restSize > (size_t)(op - lowPrefix)) { |
353 | /* overlap copy */ | |
354 | BYTE * const endOfMatch = op + restSize; | |
355 | const BYTE *copyFrom = lowPrefix; | |
356 | ||
357 | while (op < endOfMatch) | |
358 | *op++ = *copyFrom++; | |
359 | } else { | |
360 | memcpy(op, lowPrefix, restSize); | |
361 | op += restSize; | |
362 | } | |
363 | } | |
4e1a33b1 SS |
364 | continue; |
365 | } | |
366 | ||
367 | /* copy match within block */ | |
368 | cpy = op + length; | |
369 | ||
2209fda3 GX |
370 | /* |
371 | * partialDecoding : | |
372 | * may not respect endBlock parsing restrictions | |
373 | */ | |
374 | assert(op <= oend); | |
375 | if (partialDecoding && | |
376 | (cpy > oend - MATCH_SAFEGUARD_DISTANCE)) { | |
377 | size_t const mlen = min(length, (size_t)(oend - op)); | |
378 | const BYTE * const matchEnd = match + mlen; | |
379 | BYTE * const copyEnd = op + mlen; | |
380 | ||
381 | if (matchEnd > op) { | |
382 | /* overlap copy */ | |
383 | while (op < copyEnd) | |
384 | *op++ = *match++; | |
385 | } else { | |
386 | memcpy(op, match, mlen); | |
387 | } | |
388 | op = copyEnd; | |
389 | if (op == oend) | |
390 | break; | |
391 | continue; | |
392 | } | |
4e1a33b1 | 393 | |
2209fda3 | 394 | if (unlikely(offset < 8)) { |
4e1a33b1 SS |
395 | op[0] = match[0]; |
396 | op[1] = match[1]; | |
397 | op[2] = match[2]; | |
398 | op[3] = match[3]; | |
2209fda3 | 399 | match += inc32table[offset]; |
4e1a33b1 | 400 | memcpy(op + 4, match, 4); |
2209fda3 | 401 | match -= dec64table[offset]; |
cffb78b0 | 402 | } else { |
4e1a33b1 SS |
403 | LZ4_copy8(op, match); |
404 | match += 8; | |
cffb78b0 | 405 | } |
cffb78b0 | 406 | |
4e1a33b1 SS |
407 | op += 8; |
408 | ||
2209fda3 | 409 | if (unlikely(cpy > oend - MATCH_SAFEGUARD_DISTANCE)) { |
4e1a33b1 SS |
410 | BYTE * const oCopyLimit = oend - (WILDCOPYLENGTH - 1); |
411 | ||
412 | if (cpy > oend - LASTLITERALS) { | |
413 | /* | |
414 | * Error : last LASTLITERALS bytes | |
415 | * must be literals (uncompressed) | |
416 | */ | |
d5e7cafd | 417 | goto _output_error; |
4e1a33b1 SS |
418 | } |
419 | ||
420 | if (op < oCopyLimit) { | |
421 | LZ4_wildCopy(op, match, oCopyLimit); | |
422 | match += oCopyLimit - op; | |
423 | op = oCopyLimit; | |
424 | } | |
cffb78b0 | 425 | while (op < cpy) |
4e1a33b1 SS |
426 | *op++ = *match++; |
427 | } else { | |
428 | LZ4_copy8(op, match); | |
4e1a33b1 SS |
429 | if (length > 16) |
430 | LZ4_wildCopy(op + 8, match + 8, cpy); | |
cffb78b0 | 431 | } |
2209fda3 | 432 | op = cpy; /* wildcopy correction */ |
cffb78b0 | 433 | } |
4e1a33b1 | 434 | |
cffb78b0 | 435 | /* end of decoding */ |
4e1a33b1 SS |
436 | if (endOnInput) { |
437 | /* Nb of output bytes decoded */ | |
2209fda3 | 438 | return (int) (((char *)op) - dst); |
4e1a33b1 SS |
439 | } else { |
440 | /* Nb of input bytes read */ | |
2209fda3 | 441 | return (int) (((const char *)ip) - src); |
4e1a33b1 | 442 | } |
cffb78b0 | 443 | |
4e1a33b1 | 444 | /* Overflow error detected */ |
cffb78b0 | 445 | _output_error: |
2209fda3 | 446 | return (int) (-(((const char *)ip) - src)) - 1; |
cffb78b0 KL |
447 | } |
448 | ||
4e1a33b1 SS |
449 | int LZ4_decompress_safe(const char *source, char *dest, |
450 | int compressedSize, int maxDecompressedSize) | |
cffb78b0 | 451 | { |
2209fda3 GX |
452 | return LZ4_decompress_generic(source, dest, |
453 | compressedSize, maxDecompressedSize, | |
454 | endOnInputSize, decode_full_block, | |
455 | noDict, (BYTE *)dest, NULL, 0); | |
4e1a33b1 | 456 | } |
cffb78b0 | 457 | |
2209fda3 GX |
458 | int LZ4_decompress_safe_partial(const char *src, char *dst, |
459 | int compressedSize, int targetOutputSize, int dstCapacity) | |
4e1a33b1 | 460 | { |
2209fda3 GX |
461 | dstCapacity = min(targetOutputSize, dstCapacity); |
462 | return LZ4_decompress_generic(src, dst, compressedSize, dstCapacity, | |
463 | endOnInputSize, partial_decode, | |
464 | noDict, (BYTE *)dst, NULL, 0); | |
4e1a33b1 | 465 | } |
cffb78b0 | 466 | |
4e1a33b1 SS |
467 | int LZ4_decompress_fast(const char *source, char *dest, int originalSize) |
468 | { | |
469 | return LZ4_decompress_generic(source, dest, 0, originalSize, | |
2209fda3 GX |
470 | endOnOutputSize, decode_full_block, |
471 | withPrefix64k, | |
472 | (BYTE *)dest - 64 * KB, NULL, 0); | |
473 | } | |
474 | ||
475 | /* ===== Instantiate a few more decoding cases, used more than once. ===== */ | |
476 | ||
477 | int LZ4_decompress_safe_withPrefix64k(const char *source, char *dest, | |
478 | int compressedSize, int maxOutputSize) | |
479 | { | |
480 | return LZ4_decompress_generic(source, dest, | |
481 | compressedSize, maxOutputSize, | |
482 | endOnInputSize, decode_full_block, | |
483 | withPrefix64k, | |
484 | (BYTE *)dest - 64 * KB, NULL, 0); | |
485 | } | |
486 | ||
487 | static int LZ4_decompress_safe_withSmallPrefix(const char *source, char *dest, | |
488 | int compressedSize, | |
489 | int maxOutputSize, | |
490 | size_t prefixSize) | |
491 | { | |
492 | return LZ4_decompress_generic(source, dest, | |
493 | compressedSize, maxOutputSize, | |
494 | endOnInputSize, decode_full_block, | |
495 | noDict, | |
496 | (BYTE *)dest - prefixSize, NULL, 0); | |
497 | } | |
498 | ||
499 | int LZ4_decompress_safe_forceExtDict(const char *source, char *dest, | |
500 | int compressedSize, int maxOutputSize, | |
501 | const void *dictStart, size_t dictSize) | |
502 | { | |
503 | return LZ4_decompress_generic(source, dest, | |
504 | compressedSize, maxOutputSize, | |
505 | endOnInputSize, decode_full_block, | |
506 | usingExtDict, (BYTE *)dest, | |
507 | (const BYTE *)dictStart, dictSize); | |
4e1a33b1 | 508 | } |
cffb78b0 | 509 | |
2209fda3 GX |
510 | static int LZ4_decompress_fast_extDict(const char *source, char *dest, |
511 | int originalSize, | |
512 | const void *dictStart, size_t dictSize) | |
513 | { | |
514 | return LZ4_decompress_generic(source, dest, | |
515 | 0, originalSize, | |
516 | endOnOutputSize, decode_full_block, | |
517 | usingExtDict, (BYTE *)dest, | |
518 | (const BYTE *)dictStart, dictSize); | |
519 | } | |
520 | ||
521 | /* | |
522 | * The "double dictionary" mode, for use with e.g. ring buffers: the first part | |
523 | * of the dictionary is passed as prefix, and the second via dictStart + dictSize. | |
524 | * These routines are used only once, in LZ4_decompress_*_continue(). | |
525 | */ | |
526 | static FORCE_INLINE | |
527 | int LZ4_decompress_safe_doubleDict(const char *source, char *dest, | |
528 | int compressedSize, int maxOutputSize, | |
529 | size_t prefixSize, | |
530 | const void *dictStart, size_t dictSize) | |
531 | { | |
532 | return LZ4_decompress_generic(source, dest, | |
533 | compressedSize, maxOutputSize, | |
534 | endOnInputSize, decode_full_block, | |
535 | usingExtDict, (BYTE *)dest - prefixSize, | |
536 | (const BYTE *)dictStart, dictSize); | |
537 | } | |
538 | ||
539 | static FORCE_INLINE | |
540 | int LZ4_decompress_fast_doubleDict(const char *source, char *dest, | |
541 | int originalSize, size_t prefixSize, | |
542 | const void *dictStart, size_t dictSize) | |
543 | { | |
544 | return LZ4_decompress_generic(source, dest, | |
545 | 0, originalSize, | |
546 | endOnOutputSize, decode_full_block, | |
547 | usingExtDict, (BYTE *)dest - prefixSize, | |
548 | (const BYTE *)dictStart, dictSize); | |
549 | } | |
550 | ||
551 | /* ===== streaming decompression functions ===== */ | |
552 | ||
4e1a33b1 SS |
553 | int LZ4_setStreamDecode(LZ4_streamDecode_t *LZ4_streamDecode, |
554 | const char *dictionary, int dictSize) | |
555 | { | |
2209fda3 GX |
556 | LZ4_streamDecode_t_internal *lz4sd = |
557 | &LZ4_streamDecode->internal_donotuse; | |
cffb78b0 | 558 | |
4e1a33b1 SS |
559 | lz4sd->prefixSize = (size_t) dictSize; |
560 | lz4sd->prefixEnd = (const BYTE *) dictionary + dictSize; | |
561 | lz4sd->externalDict = NULL; | |
562 | lz4sd->extDictSize = 0; | |
563 | return 1; | |
564 | } | |
cffb78b0 | 565 | |
4e1a33b1 SS |
566 | /* |
567 | * *_continue() : | |
568 | * These decoding functions allow decompression of multiple blocks | |
569 | * in "streaming" mode. | |
570 | * Previously decoded blocks must still be available at the memory | |
571 | * position where they were decoded. | |
572 | * If it's not possible, save the relevant part of | |
573 | * decoded data into a safe buffer, | |
574 | * and indicate where it stands using LZ4_setStreamDecode() | |
575 | */ | |
576 | int LZ4_decompress_safe_continue(LZ4_streamDecode_t *LZ4_streamDecode, | |
577 | const char *source, char *dest, int compressedSize, int maxOutputSize) | |
578 | { | |
2209fda3 GX |
579 | LZ4_streamDecode_t_internal *lz4sd = |
580 | &LZ4_streamDecode->internal_donotuse; | |
4e1a33b1 SS |
581 | int result; |
582 | ||
2209fda3 GX |
583 | if (lz4sd->prefixSize == 0) { |
584 | /* The first call, no dictionary yet. */ | |
585 | assert(lz4sd->extDictSize == 0); | |
586 | result = LZ4_decompress_safe(source, dest, | |
587 | compressedSize, maxOutputSize); | |
588 | if (result <= 0) | |
589 | return result; | |
590 | lz4sd->prefixSize = result; | |
591 | lz4sd->prefixEnd = (BYTE *)dest + result; | |
592 | } else if (lz4sd->prefixEnd == (BYTE *)dest) { | |
593 | /* They're rolling the current segment. */ | |
594 | if (lz4sd->prefixSize >= 64 * KB - 1) | |
595 | result = LZ4_decompress_safe_withPrefix64k(source, dest, | |
596 | compressedSize, maxOutputSize); | |
597 | else if (lz4sd->extDictSize == 0) | |
598 | result = LZ4_decompress_safe_withSmallPrefix(source, | |
599 | dest, compressedSize, maxOutputSize, | |
600 | lz4sd->prefixSize); | |
601 | else | |
602 | result = LZ4_decompress_safe_doubleDict(source, dest, | |
603 | compressedSize, maxOutputSize, | |
604 | lz4sd->prefixSize, | |
605 | lz4sd->externalDict, lz4sd->extDictSize); | |
4e1a33b1 SS |
606 | if (result <= 0) |
607 | return result; | |
4e1a33b1 | 608 | lz4sd->prefixSize += result; |
2209fda3 | 609 | lz4sd->prefixEnd += result; |
4e1a33b1 | 610 | } else { |
2209fda3 GX |
611 | /* |
612 | * The buffer wraps around, or they're | |
613 | * switching to another buffer. | |
614 | */ | |
4e1a33b1 SS |
615 | lz4sd->extDictSize = lz4sd->prefixSize; |
616 | lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize; | |
2209fda3 | 617 | result = LZ4_decompress_safe_forceExtDict(source, dest, |
4e1a33b1 | 618 | compressedSize, maxOutputSize, |
4e1a33b1 SS |
619 | lz4sd->externalDict, lz4sd->extDictSize); |
620 | if (result <= 0) | |
621 | return result; | |
622 | lz4sd->prefixSize = result; | |
2209fda3 | 623 | lz4sd->prefixEnd = (BYTE *)dest + result; |
4e1a33b1 | 624 | } |
cffb78b0 | 625 | |
4e1a33b1 SS |
626 | return result; |
627 | } | |
cffb78b0 | 628 | |
4e1a33b1 SS |
629 | int LZ4_decompress_fast_continue(LZ4_streamDecode_t *LZ4_streamDecode, |
630 | const char *source, char *dest, int originalSize) | |
631 | { | |
632 | LZ4_streamDecode_t_internal *lz4sd = &LZ4_streamDecode->internal_donotuse; | |
633 | int result; | |
634 | ||
2209fda3 GX |
635 | if (lz4sd->prefixSize == 0) { |
636 | assert(lz4sd->extDictSize == 0); | |
637 | result = LZ4_decompress_fast(source, dest, originalSize); | |
638 | if (result <= 0) | |
639 | return result; | |
640 | lz4sd->prefixSize = originalSize; | |
641 | lz4sd->prefixEnd = (BYTE *)dest + originalSize; | |
642 | } else if (lz4sd->prefixEnd == (BYTE *)dest) { | |
643 | if (lz4sd->prefixSize >= 64 * KB - 1 || | |
644 | lz4sd->extDictSize == 0) | |
645 | result = LZ4_decompress_fast(source, dest, | |
646 | originalSize); | |
647 | else | |
648 | result = LZ4_decompress_fast_doubleDict(source, dest, | |
649 | originalSize, lz4sd->prefixSize, | |
650 | lz4sd->externalDict, lz4sd->extDictSize); | |
4e1a33b1 SS |
651 | if (result <= 0) |
652 | return result; | |
4e1a33b1 | 653 | lz4sd->prefixSize += originalSize; |
2209fda3 | 654 | lz4sd->prefixEnd += originalSize; |
4e1a33b1 SS |
655 | } else { |
656 | lz4sd->extDictSize = lz4sd->prefixSize; | |
657 | lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize; | |
2209fda3 GX |
658 | result = LZ4_decompress_fast_extDict(source, dest, |
659 | originalSize, lz4sd->externalDict, lz4sd->extDictSize); | |
4e1a33b1 SS |
660 | if (result <= 0) |
661 | return result; | |
662 | lz4sd->prefixSize = originalSize; | |
2209fda3 | 663 | lz4sd->prefixEnd = (BYTE *)dest + originalSize; |
cffb78b0 | 664 | } |
4e1a33b1 | 665 | return result; |
cffb78b0 KL |
666 | } |
667 | ||
2209fda3 GX |
668 | int LZ4_decompress_safe_usingDict(const char *source, char *dest, |
669 | int compressedSize, int maxOutputSize, | |
670 | const char *dictStart, int dictSize) | |
cffb78b0 | 671 | { |
4e1a33b1 | 672 | if (dictSize == 0) |
2209fda3 GX |
673 | return LZ4_decompress_safe(source, dest, |
674 | compressedSize, maxOutputSize); | |
675 | if (dictStart+dictSize == dest) { | |
676 | if (dictSize >= 64 * KB - 1) | |
677 | return LZ4_decompress_safe_withPrefix64k(source, dest, | |
678 | compressedSize, maxOutputSize); | |
679 | return LZ4_decompress_safe_withSmallPrefix(source, dest, | |
680 | compressedSize, maxOutputSize, dictSize); | |
4e1a33b1 | 681 | } |
2209fda3 GX |
682 | return LZ4_decompress_safe_forceExtDict(source, dest, |
683 | compressedSize, maxOutputSize, dictStart, dictSize); | |
cffb78b0 | 684 | } |
cffb78b0 | 685 | |
4e1a33b1 | 686 | int LZ4_decompress_fast_usingDict(const char *source, char *dest, |
2209fda3 GX |
687 | int originalSize, |
688 | const char *dictStart, int dictSize) | |
cffb78b0 | 689 | { |
2209fda3 GX |
690 | if (dictSize == 0 || dictStart + dictSize == dest) |
691 | return LZ4_decompress_fast(source, dest, originalSize); | |
692 | ||
693 | return LZ4_decompress_fast_extDict(source, dest, originalSize, | |
694 | dictStart, dictSize); | |
cffb78b0 | 695 | } |
4e1a33b1 | 696 | |
cffb78b0 | 697 | #ifndef STATIC |
4e1a33b1 SS |
698 | EXPORT_SYMBOL(LZ4_decompress_safe); |
699 | EXPORT_SYMBOL(LZ4_decompress_safe_partial); | |
700 | EXPORT_SYMBOL(LZ4_decompress_fast); | |
701 | EXPORT_SYMBOL(LZ4_setStreamDecode); | |
702 | EXPORT_SYMBOL(LZ4_decompress_safe_continue); | |
703 | EXPORT_SYMBOL(LZ4_decompress_fast_continue); | |
704 | EXPORT_SYMBOL(LZ4_decompress_safe_usingDict); | |
705 | EXPORT_SYMBOL(LZ4_decompress_fast_usingDict); | |
cffb78b0 | 706 | |
ee8a99bd | 707 | MODULE_LICENSE("Dual BSD/GPL"); |
4e1a33b1 | 708 | MODULE_DESCRIPTION("LZ4 decompressor"); |
cffb78b0 | 709 | #endif |