Quelle  lz4hc_compress.c   Sprache: C

/*
 * 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 <4sschmid@informatik.uni-hamburg.de>
 */

/*-************************************
 * Dependencies
 **************************************/
#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;
}
EXPORT_SYMBOL(LZ4_resetStreamHC);

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");