forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
768 lines
19 KiB
768 lines
19 KiB
/* |
|
* LZ4 HC - High Compression Mode of LZ4 |
|
* Copyright (C) 2011-2015, Yann Collet. |
|
* |
|
* BSD 2 - Clause License (http://www.opensource.org/licenses/bsd - license.php) |
|
* Redistribution and use in source and binary forms, with or without |
|
* modification, are permitted provided that the following conditions are |
|
* met: |
|
* * Redistributions of source code must retain the above copyright |
|
* notice, this list of conditions and the following disclaimer. |
|
* * Redistributions in binary form must reproduce the above |
|
* copyright notice, this list of conditions and the following disclaimer |
|
* in the documentation and/or other materials provided with the |
|
* distribution. |
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
* You can contact the author at : |
|
* - LZ4 homepage : http://www.lz4.org |
|
* - LZ4 source repository : https://github.com/lz4/lz4 |
|
* |
|
* Changed for kernel usage by: |
|
* Sven Schmidt <[email protected]> |
|
*/ |
|
|
|
/*-************************************ |
|
* Dependencies |
|
**************************************/ |
|
#include <linux/lz4.h> |
|
#include "lz4defs.h" |
|
#include <linux/module.h> |
|
#include <linux/kernel.h> |
|
#include <linux/string.h> /* memset */ |
|
|
|
/* ************************************* |
|
* Local Constants and types |
|
***************************************/ |
|
|
|
#define OPTIMAL_ML (int)((ML_MASK - 1) + MINMATCH) |
|
|
|
#define HASH_FUNCTION(i) (((i) * 2654435761U) \ |
|
>> ((MINMATCH*8) - LZ4HC_HASH_LOG)) |
|
#define DELTANEXTU16(p) chainTable[(U16)(p)] /* faster */ |
|
|
|
static U32 LZ4HC_hashPtr(const void *ptr) |
|
{ |
|
return HASH_FUNCTION(LZ4_read32(ptr)); |
|
} |
|
|
|
/************************************** |
|
* HC Compression |
|
**************************************/ |
|
static void LZ4HC_init(LZ4HC_CCtx_internal *hc4, const BYTE *start) |
|
{ |
|
memset((void *)hc4->hashTable, 0, sizeof(hc4->hashTable)); |
|
memset(hc4->chainTable, 0xFF, sizeof(hc4->chainTable)); |
|
hc4->nextToUpdate = 64 * KB; |
|
hc4->base = start - 64 * KB; |
|
hc4->end = start; |
|
hc4->dictBase = start - 64 * KB; |
|
hc4->dictLimit = 64 * KB; |
|
hc4->lowLimit = 64 * KB; |
|
} |
|
|
|
/* Update chains up to ip (excluded) */ |
|
static FORCE_INLINE void LZ4HC_Insert(LZ4HC_CCtx_internal *hc4, |
|
const BYTE *ip) |
|
{ |
|
U16 * const chainTable = hc4->chainTable; |
|
U32 * const hashTable = hc4->hashTable; |
|
const BYTE * const base = hc4->base; |
|
U32 const target = (U32)(ip - base); |
|
U32 idx = hc4->nextToUpdate; |
|
|
|
while (idx < target) { |
|
U32 const h = LZ4HC_hashPtr(base + idx); |
|
size_t delta = idx - hashTable[h]; |
|
|
|
if (delta > MAX_DISTANCE) |
|
delta = MAX_DISTANCE; |
|
|
|
DELTANEXTU16(idx) = (U16)delta; |
|
|
|
hashTable[h] = idx; |
|
idx++; |
|
} |
|
|
|
hc4->nextToUpdate = target; |
|
} |
|
|
|
static FORCE_INLINE int LZ4HC_InsertAndFindBestMatch( |
|
LZ4HC_CCtx_internal *hc4, /* Index table will be updated */ |
|
const BYTE *ip, |
|
const BYTE * const iLimit, |
|
const BYTE **matchpos, |
|
const int maxNbAttempts) |
|
{ |
|
U16 * const chainTable = hc4->chainTable; |
|
U32 * const HashTable = hc4->hashTable; |
|
const BYTE * const base = hc4->base; |
|
const BYTE * const dictBase = hc4->dictBase; |
|
const U32 dictLimit = hc4->dictLimit; |
|
const U32 lowLimit = (hc4->lowLimit + 64 * KB > (U32)(ip - base)) |
|
? hc4->lowLimit |
|
: (U32)(ip - base) - (64 * KB - 1); |
|
U32 matchIndex; |
|
int nbAttempts = maxNbAttempts; |
|
size_t ml = 0; |
|
|
|
/* HC4 match finder */ |
|
LZ4HC_Insert(hc4, ip); |
|
matchIndex = HashTable[LZ4HC_hashPtr(ip)]; |
|
|
|
while ((matchIndex >= lowLimit) |
|
&& (nbAttempts)) { |
|
nbAttempts--; |
|
if (matchIndex >= dictLimit) { |
|
const BYTE * const match = base + matchIndex; |
|
|
|
if (*(match + ml) == *(ip + ml) |
|
&& (LZ4_read32(match) == LZ4_read32(ip))) { |
|
size_t const mlt = LZ4_count(ip + MINMATCH, |
|
match + MINMATCH, iLimit) + MINMATCH; |
|
|
|
if (mlt > ml) { |
|
ml = mlt; |
|
*matchpos = match; |
|
} |
|
} |
|
} else { |
|
const BYTE * const match = dictBase + matchIndex; |
|
|
|
if (LZ4_read32(match) == LZ4_read32(ip)) { |
|
size_t mlt; |
|
const BYTE *vLimit = ip |
|
+ (dictLimit - matchIndex); |
|
|
|
if (vLimit > iLimit) |
|
vLimit = iLimit; |
|
mlt = LZ4_count(ip + MINMATCH, |
|
match + MINMATCH, vLimit) + MINMATCH; |
|
if ((ip + mlt == vLimit) |
|
&& (vLimit < iLimit)) |
|
mlt += LZ4_count(ip + mlt, |
|
base + dictLimit, |
|
iLimit); |
|
if (mlt > ml) { |
|
/* virtual matchpos */ |
|
ml = mlt; |
|
*matchpos = base + matchIndex; |
|
} |
|
} |
|
} |
|
matchIndex -= DELTANEXTU16(matchIndex); |
|
} |
|
|
|
return (int)ml; |
|
} |
|
|
|
static FORCE_INLINE int LZ4HC_InsertAndGetWiderMatch( |
|
LZ4HC_CCtx_internal *hc4, |
|
const BYTE * const ip, |
|
const BYTE * const iLowLimit, |
|
const BYTE * const iHighLimit, |
|
int longest, |
|
const BYTE **matchpos, |
|
const BYTE **startpos, |
|
const int maxNbAttempts) |
|
{ |
|
U16 * const chainTable = hc4->chainTable; |
|
U32 * const HashTable = hc4->hashTable; |
|
const BYTE * const base = hc4->base; |
|
const U32 dictLimit = hc4->dictLimit; |
|
const BYTE * const lowPrefixPtr = base + dictLimit; |
|
const U32 lowLimit = (hc4->lowLimit + 64 * KB > (U32)(ip - base)) |
|
? hc4->lowLimit |
|
: (U32)(ip - base) - (64 * KB - 1); |
|
const BYTE * const dictBase = hc4->dictBase; |
|
U32 matchIndex; |
|
int nbAttempts = maxNbAttempts; |
|
int delta = (int)(ip - iLowLimit); |
|
|
|
/* First Match */ |
|
LZ4HC_Insert(hc4, ip); |
|
matchIndex = HashTable[LZ4HC_hashPtr(ip)]; |
|
|
|
while ((matchIndex >= lowLimit) |
|
&& (nbAttempts)) { |
|
nbAttempts--; |
|
if (matchIndex >= dictLimit) { |
|
const BYTE *matchPtr = base + matchIndex; |
|
|
|
if (*(iLowLimit + longest) |
|
== *(matchPtr - delta + longest)) { |
|
if (LZ4_read32(matchPtr) == LZ4_read32(ip)) { |
|
int mlt = MINMATCH + LZ4_count( |
|
ip + MINMATCH, |
|
matchPtr + MINMATCH, |
|
iHighLimit); |
|
int back = 0; |
|
|
|
while ((ip + back > iLowLimit) |
|
&& (matchPtr + back > lowPrefixPtr) |
|
&& (ip[back - 1] == matchPtr[back - 1])) |
|
back--; |
|
|
|
mlt -= back; |
|
|
|
if (mlt > longest) { |
|
longest = (int)mlt; |
|
*matchpos = matchPtr + back; |
|
*startpos = ip + back; |
|
} |
|
} |
|
} |
|
} else { |
|
const BYTE * const matchPtr = dictBase + matchIndex; |
|
|
|
if (LZ4_read32(matchPtr) == LZ4_read32(ip)) { |
|
size_t mlt; |
|
int back = 0; |
|
const BYTE *vLimit = ip + (dictLimit - matchIndex); |
|
|
|
if (vLimit > iHighLimit) |
|
vLimit = iHighLimit; |
|
|
|
mlt = LZ4_count(ip + MINMATCH, |
|
matchPtr + MINMATCH, vLimit) + MINMATCH; |
|
|
|
if ((ip + mlt == vLimit) && (vLimit < iHighLimit)) |
|
mlt += LZ4_count(ip + mlt, base + dictLimit, |
|
iHighLimit); |
|
while ((ip + back > iLowLimit) |
|
&& (matchIndex + back > lowLimit) |
|
&& (ip[back - 1] == matchPtr[back - 1])) |
|
back--; |
|
|
|
mlt -= back; |
|
|
|
if ((int)mlt > longest) { |
|
longest = (int)mlt; |
|
*matchpos = base + matchIndex + back; |
|
*startpos = ip + back; |
|
} |
|
} |
|
} |
|
|
|
matchIndex -= DELTANEXTU16(matchIndex); |
|
} |
|
|
|
return longest; |
|
} |
|
|
|
static FORCE_INLINE int LZ4HC_encodeSequence( |
|
const BYTE **ip, |
|
BYTE **op, |
|
const BYTE **anchor, |
|
int matchLength, |
|
const BYTE * const match, |
|
limitedOutput_directive limitedOutputBuffer, |
|
BYTE *oend) |
|
{ |
|
int length; |
|
BYTE *token; |
|
|
|
/* Encode Literal length */ |
|
length = (int)(*ip - *anchor); |
|
token = (*op)++; |
|
|
|
if ((limitedOutputBuffer) |
|
&& ((*op + (length>>8) |
|
+ length + (2 + 1 + LASTLITERALS)) > oend)) { |
|
/* Check output limit */ |
|
return 1; |
|
} |
|
if (length >= (int)RUN_MASK) { |
|
int len; |
|
|
|
*token = (RUN_MASK<<ML_BITS); |
|
len = length - RUN_MASK; |
|
for (; len > 254 ; len -= 255) |
|
*(*op)++ = 255; |
|
*(*op)++ = (BYTE)len; |
|
} else |
|
*token = (BYTE)(length<<ML_BITS); |
|
|
|
/* Copy Literals */ |
|
LZ4_wildCopy(*op, *anchor, (*op) + length); |
|
*op += length; |
|
|
|
/* Encode Offset */ |
|
LZ4_writeLE16(*op, (U16)(*ip - match)); |
|
*op += 2; |
|
|
|
/* Encode MatchLength */ |
|
length = (int)(matchLength - MINMATCH); |
|
|
|
if ((limitedOutputBuffer) |
|
&& (*op + (length>>8) |
|
+ (1 + LASTLITERALS) > oend)) { |
|
/* Check output limit */ |
|
return 1; |
|
} |
|
|
|
if (length >= (int)ML_MASK) { |
|
*token += ML_MASK; |
|
length -= ML_MASK; |
|
|
|
for (; length > 509 ; length -= 510) { |
|
*(*op)++ = 255; |
|
*(*op)++ = 255; |
|
} |
|
|
|
if (length > 254) { |
|
length -= 255; |
|
*(*op)++ = 255; |
|
} |
|
|
|
*(*op)++ = (BYTE)length; |
|
} else |
|
*token += (BYTE)(length); |
|
|
|
/* Prepare next loop */ |
|
*ip += matchLength; |
|
*anchor = *ip; |
|
|
|
return 0; |
|
} |
|
|
|
static int LZ4HC_compress_generic( |
|
LZ4HC_CCtx_internal *const ctx, |
|
const char * const source, |
|
char * const dest, |
|
int const inputSize, |
|
int const maxOutputSize, |
|
int compressionLevel, |
|
limitedOutput_directive limit |
|
) |
|
{ |
|
const BYTE *ip = (const BYTE *) source; |
|
const BYTE *anchor = ip; |
|
const BYTE * const iend = ip + inputSize; |
|
const BYTE * const mflimit = iend - MFLIMIT; |
|
const BYTE * const matchlimit = (iend - LASTLITERALS); |
|
|
|
BYTE *op = (BYTE *) dest; |
|
BYTE * const oend = op + maxOutputSize; |
|
|
|
unsigned int maxNbAttempts; |
|
int ml, ml2, ml3, ml0; |
|
const BYTE *ref = NULL; |
|
const BYTE *start2 = NULL; |
|
const BYTE *ref2 = NULL; |
|
const BYTE *start3 = NULL; |
|
const BYTE *ref3 = NULL; |
|
const BYTE *start0; |
|
const BYTE *ref0; |
|
|
|
/* init */ |
|
if (compressionLevel > LZ4HC_MAX_CLEVEL) |
|
compressionLevel = LZ4HC_MAX_CLEVEL; |
|
if (compressionLevel < 1) |
|
compressionLevel = LZ4HC_DEFAULT_CLEVEL; |
|
maxNbAttempts = 1 << (compressionLevel - 1); |
|
ctx->end += inputSize; |
|
|
|
ip++; |
|
|
|
/* Main Loop */ |
|
while (ip < mflimit) { |
|
ml = LZ4HC_InsertAndFindBestMatch(ctx, ip, |
|
matchlimit, (&ref), maxNbAttempts); |
|
if (!ml) { |
|
ip++; |
|
continue; |
|
} |
|
|
|
/* saved, in case we would skip too much */ |
|
start0 = ip; |
|
ref0 = ref; |
|
ml0 = ml; |
|
|
|
_Search2: |
|
if (ip + ml < mflimit) |
|
ml2 = LZ4HC_InsertAndGetWiderMatch(ctx, |
|
ip + ml - 2, ip + 0, |
|
matchlimit, ml, &ref2, |
|
&start2, maxNbAttempts); |
|
else |
|
ml2 = ml; |
|
|
|
if (ml2 == ml) { |
|
/* No better match */ |
|
if (LZ4HC_encodeSequence(&ip, &op, |
|
&anchor, ml, ref, limit, oend)) |
|
return 0; |
|
continue; |
|
} |
|
|
|
if (start0 < ip) { |
|
if (start2 < ip + ml0) { |
|
/* empirical */ |
|
ip = start0; |
|
ref = ref0; |
|
ml = ml0; |
|
} |
|
} |
|
|
|
/* Here, start0 == ip */ |
|
if ((start2 - ip) < 3) { |
|
/* First Match too small : removed */ |
|
ml = ml2; |
|
ip = start2; |
|
ref = ref2; |
|
goto _Search2; |
|
} |
|
|
|
_Search3: |
|
/* |
|
* Currently we have : |
|
* ml2 > ml1, and |
|
* ip1 + 3 <= ip2 (usually < ip1 + ml1) |
|
*/ |
|
if ((start2 - ip) < OPTIMAL_ML) { |
|
int correction; |
|
int new_ml = ml; |
|
|
|
if (new_ml > OPTIMAL_ML) |
|
new_ml = OPTIMAL_ML; |
|
if (ip + new_ml > start2 + ml2 - MINMATCH) |
|
new_ml = (int)(start2 - ip) + ml2 - MINMATCH; |
|
|
|
correction = new_ml - (int)(start2 - ip); |
|
|
|
if (correction > 0) { |
|
start2 += correction; |
|
ref2 += correction; |
|
ml2 -= correction; |
|
} |
|
} |
|
/* |
|
* Now, we have start2 = ip + new_ml, |
|
* with new_ml = min(ml, OPTIMAL_ML = 18) |
|
*/ |
|
|
|
if (start2 + ml2 < mflimit) |
|
ml3 = LZ4HC_InsertAndGetWiderMatch(ctx, |
|
start2 + ml2 - 3, start2, |
|
matchlimit, ml2, &ref3, &start3, |
|
maxNbAttempts); |
|
else |
|
ml3 = ml2; |
|
|
|
if (ml3 == ml2) { |
|
/* No better match : 2 sequences to encode */ |
|
/* ip & ref are known; Now for ml */ |
|
if (start2 < ip + ml) |
|
ml = (int)(start2 - ip); |
|
/* Now, encode 2 sequences */ |
|
if (LZ4HC_encodeSequence(&ip, &op, &anchor, |
|
ml, ref, limit, oend)) |
|
return 0; |
|
ip = start2; |
|
if (LZ4HC_encodeSequence(&ip, &op, &anchor, |
|
ml2, ref2, limit, oend)) |
|
return 0; |
|
continue; |
|
} |
|
|
|
if (start3 < ip + ml + 3) { |
|
/* Not enough space for match 2 : remove it */ |
|
if (start3 >= (ip + ml)) { |
|
/* can write Seq1 immediately |
|
* ==> Seq2 is removed, |
|
* so Seq3 becomes Seq1 |
|
*/ |
|
if (start2 < ip + ml) { |
|
int correction = (int)(ip + ml - start2); |
|
|
|
start2 += correction; |
|
ref2 += correction; |
|
ml2 -= correction; |
|
if (ml2 < MINMATCH) { |
|
start2 = start3; |
|
ref2 = ref3; |
|
ml2 = ml3; |
|
} |
|
} |
|
|
|
if (LZ4HC_encodeSequence(&ip, &op, &anchor, |
|
ml, ref, limit, oend)) |
|
return 0; |
|
ip = start3; |
|
ref = ref3; |
|
ml = ml3; |
|
|
|
start0 = start2; |
|
ref0 = ref2; |
|
ml0 = ml2; |
|
goto _Search2; |
|
} |
|
|
|
start2 = start3; |
|
ref2 = ref3; |
|
ml2 = ml3; |
|
goto _Search3; |
|
} |
|
|
|
/* |
|
* OK, now we have 3 ascending matches; |
|
* let's write at least the first one |
|
* ip & ref are known; Now for ml |
|
*/ |
|
if (start2 < ip + ml) { |
|
if ((start2 - ip) < (int)ML_MASK) { |
|
int correction; |
|
|
|
if (ml > OPTIMAL_ML) |
|
ml = OPTIMAL_ML; |
|
if (ip + ml > start2 + ml2 - MINMATCH) |
|
ml = (int)(start2 - ip) + ml2 - MINMATCH; |
|
correction = ml - (int)(start2 - ip); |
|
if (correction > 0) { |
|
start2 += correction; |
|
ref2 += correction; |
|
ml2 -= correction; |
|
} |
|
} else |
|
ml = (int)(start2 - ip); |
|
} |
|
if (LZ4HC_encodeSequence(&ip, &op, &anchor, ml, |
|
ref, limit, oend)) |
|
return 0; |
|
|
|
ip = start2; |
|
ref = ref2; |
|
ml = ml2; |
|
|
|
start2 = start3; |
|
ref2 = ref3; |
|
ml2 = ml3; |
|
|
|
goto _Search3; |
|
} |
|
|
|
/* Encode Last Literals */ |
|
{ |
|
int lastRun = (int)(iend - anchor); |
|
|
|
if ((limit) |
|
&& (((char *)op - dest) + lastRun + 1 |
|
+ ((lastRun + 255 - RUN_MASK)/255) |
|
> (U32)maxOutputSize)) { |
|
/* Check output limit */ |
|
return 0; |
|
} |
|
if (lastRun >= (int)RUN_MASK) { |
|
*op++ = (RUN_MASK<<ML_BITS); |
|
lastRun -= RUN_MASK; |
|
for (; lastRun > 254 ; lastRun -= 255) |
|
*op++ = 255; |
|
*op++ = (BYTE) lastRun; |
|
} else |
|
*op++ = (BYTE)(lastRun<<ML_BITS); |
|
LZ4_memcpy(op, anchor, iend - anchor); |
|
op += iend - anchor; |
|
} |
|
|
|
/* End */ |
|
return (int) (((char *)op) - dest); |
|
} |
|
|
|
static int LZ4_compress_HC_extStateHC( |
|
void *state, |
|
const char *src, |
|
char *dst, |
|
int srcSize, |
|
int maxDstSize, |
|
int compressionLevel) |
|
{ |
|
LZ4HC_CCtx_internal *ctx = &((LZ4_streamHC_t *)state)->internal_donotuse; |
|
|
|
if (((size_t)(state)&(sizeof(void *) - 1)) != 0) { |
|
/* Error : state is not aligned |
|
* for pointers (32 or 64 bits) |
|
*/ |
|
return 0; |
|
} |
|
|
|
LZ4HC_init(ctx, (const BYTE *)src); |
|
|
|
if (maxDstSize < LZ4_compressBound(srcSize)) |
|
return LZ4HC_compress_generic(ctx, src, dst, |
|
srcSize, maxDstSize, compressionLevel, limitedOutput); |
|
else |
|
return LZ4HC_compress_generic(ctx, src, dst, |
|
srcSize, maxDstSize, compressionLevel, noLimit); |
|
} |
|
|
|
int LZ4_compress_HC(const char *src, char *dst, int srcSize, |
|
int maxDstSize, int compressionLevel, void *wrkmem) |
|
{ |
|
return LZ4_compress_HC_extStateHC(wrkmem, src, dst, |
|
srcSize, maxDstSize, compressionLevel); |
|
} |
|
EXPORT_SYMBOL(LZ4_compress_HC); |
|
|
|
/************************************** |
|
* Streaming Functions |
|
**************************************/ |
|
void LZ4_resetStreamHC(LZ4_streamHC_t *LZ4_streamHCPtr, int compressionLevel) |
|
{ |
|
LZ4_streamHCPtr->internal_donotuse.base = NULL; |
|
LZ4_streamHCPtr->internal_donotuse.compressionLevel = (unsigned int)compressionLevel; |
|
} |
|
|
|
int LZ4_loadDictHC(LZ4_streamHC_t *LZ4_streamHCPtr, |
|
const char *dictionary, |
|
int dictSize) |
|
{ |
|
LZ4HC_CCtx_internal *ctxPtr = &LZ4_streamHCPtr->internal_donotuse; |
|
|
|
if (dictSize > 64 * KB) { |
|
dictionary += dictSize - 64 * KB; |
|
dictSize = 64 * KB; |
|
} |
|
LZ4HC_init(ctxPtr, (const BYTE *)dictionary); |
|
if (dictSize >= 4) |
|
LZ4HC_Insert(ctxPtr, (const BYTE *)dictionary + (dictSize - 3)); |
|
ctxPtr->end = (const BYTE *)dictionary + dictSize; |
|
return dictSize; |
|
} |
|
EXPORT_SYMBOL(LZ4_loadDictHC); |
|
|
|
/* compression */ |
|
|
|
static void LZ4HC_setExternalDict( |
|
LZ4HC_CCtx_internal *ctxPtr, |
|
const BYTE *newBlock) |
|
{ |
|
if (ctxPtr->end >= ctxPtr->base + 4) { |
|
/* Referencing remaining dictionary content */ |
|
LZ4HC_Insert(ctxPtr, ctxPtr->end - 3); |
|
} |
|
|
|
/* |
|
* Only one memory segment for extDict, |
|
* so any previous extDict is lost at this stage |
|
*/ |
|
ctxPtr->lowLimit = ctxPtr->dictLimit; |
|
ctxPtr->dictLimit = (U32)(ctxPtr->end - ctxPtr->base); |
|
ctxPtr->dictBase = ctxPtr->base; |
|
ctxPtr->base = newBlock - ctxPtr->dictLimit; |
|
ctxPtr->end = newBlock; |
|
/* match referencing will resume from there */ |
|
ctxPtr->nextToUpdate = ctxPtr->dictLimit; |
|
} |
|
|
|
static int LZ4_compressHC_continue_generic( |
|
LZ4_streamHC_t *LZ4_streamHCPtr, |
|
const char *source, |
|
char *dest, |
|
int inputSize, |
|
int maxOutputSize, |
|
limitedOutput_directive limit) |
|
{ |
|
LZ4HC_CCtx_internal *ctxPtr = &LZ4_streamHCPtr->internal_donotuse; |
|
|
|
/* auto - init if forgotten */ |
|
if (ctxPtr->base == NULL) |
|
LZ4HC_init(ctxPtr, (const BYTE *) source); |
|
|
|
/* Check overflow */ |
|
if ((size_t)(ctxPtr->end - ctxPtr->base) > 2 * GB) { |
|
size_t dictSize = (size_t)(ctxPtr->end - ctxPtr->base) |
|
- ctxPtr->dictLimit; |
|
if (dictSize > 64 * KB) |
|
dictSize = 64 * KB; |
|
LZ4_loadDictHC(LZ4_streamHCPtr, |
|
(const char *)(ctxPtr->end) - dictSize, (int)dictSize); |
|
} |
|
|
|
/* Check if blocks follow each other */ |
|
if ((const BYTE *)source != ctxPtr->end) |
|
LZ4HC_setExternalDict(ctxPtr, (const BYTE *)source); |
|
|
|
/* Check overlapping input/dictionary space */ |
|
{ |
|
const BYTE *sourceEnd = (const BYTE *) source + inputSize; |
|
const BYTE * const dictBegin = ctxPtr->dictBase + ctxPtr->lowLimit; |
|
const BYTE * const dictEnd = ctxPtr->dictBase + ctxPtr->dictLimit; |
|
|
|
if ((sourceEnd > dictBegin) |
|
&& ((const BYTE *)source < dictEnd)) { |
|
if (sourceEnd > dictEnd) |
|
sourceEnd = dictEnd; |
|
ctxPtr->lowLimit = (U32)(sourceEnd - ctxPtr->dictBase); |
|
|
|
if (ctxPtr->dictLimit - ctxPtr->lowLimit < 4) |
|
ctxPtr->lowLimit = ctxPtr->dictLimit; |
|
} |
|
} |
|
|
|
return LZ4HC_compress_generic(ctxPtr, source, dest, |
|
inputSize, maxOutputSize, ctxPtr->compressionLevel, limit); |
|
} |
|
|
|
int LZ4_compress_HC_continue( |
|
LZ4_streamHC_t *LZ4_streamHCPtr, |
|
const char *source, |
|
char *dest, |
|
int inputSize, |
|
int maxOutputSize) |
|
{ |
|
if (maxOutputSize < LZ4_compressBound(inputSize)) |
|
return LZ4_compressHC_continue_generic(LZ4_streamHCPtr, |
|
source, dest, inputSize, maxOutputSize, limitedOutput); |
|
else |
|
return LZ4_compressHC_continue_generic(LZ4_streamHCPtr, |
|
source, dest, inputSize, maxOutputSize, noLimit); |
|
} |
|
EXPORT_SYMBOL(LZ4_compress_HC_continue); |
|
|
|
/* dictionary saving */ |
|
|
|
int LZ4_saveDictHC( |
|
LZ4_streamHC_t *LZ4_streamHCPtr, |
|
char *safeBuffer, |
|
int dictSize) |
|
{ |
|
LZ4HC_CCtx_internal *const streamPtr = &LZ4_streamHCPtr->internal_donotuse; |
|
int const prefixSize = (int)(streamPtr->end |
|
- (streamPtr->base + streamPtr->dictLimit)); |
|
|
|
if (dictSize > 64 * KB) |
|
dictSize = 64 * KB; |
|
if (dictSize < 4) |
|
dictSize = 0; |
|
if (dictSize > prefixSize) |
|
dictSize = prefixSize; |
|
|
|
memmove(safeBuffer, streamPtr->end - dictSize, dictSize); |
|
|
|
{ |
|
U32 const endIndex = (U32)(streamPtr->end - streamPtr->base); |
|
|
|
streamPtr->end = (const BYTE *)safeBuffer + dictSize; |
|
streamPtr->base = streamPtr->end - endIndex; |
|
streamPtr->dictLimit = endIndex - dictSize; |
|
streamPtr->lowLimit = endIndex - dictSize; |
|
|
|
if (streamPtr->nextToUpdate < streamPtr->dictLimit) |
|
streamPtr->nextToUpdate = streamPtr->dictLimit; |
|
} |
|
return dictSize; |
|
} |
|
EXPORT_SYMBOL(LZ4_saveDictHC); |
|
|
|
MODULE_LICENSE("Dual BSD/GPL"); |
|
MODULE_DESCRIPTION("LZ4 HC compressor");
|
|
|