lz4-native-ruby 1.0.0 → 1.0.1

data/ext/lz4_native/lz4file.c

@@ -0,0 +1,362 @@
+/*
+ * LZ4 file library
+ * Copyright (c) Yann Collet and LZ4 contributors. All rights reserved.
+ *
+ * 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
+ */
+#include <stdlib.h>  /* malloc, free */
+#include <string.h>
+#include <assert.h>
+#include "lz4.h"
+#include "lz4file.h"
+
+/* =====   Error Handling   ===== */
+static LZ4F_errorCode_t returnErrorCode(LZ4F_errorCodes code)
+{
+    return (LZ4F_errorCode_t)-(ptrdiff_t)code;
+}
+
+#undef RETURN_ERROR
+#define RETURN_ERROR(e) return returnErrorCode(LZ4F_ERROR_ ## e)
+
+/* =====    Read API Implementation    ===== */
+
+struct LZ4_readFile_s {
+  LZ4F_dctx* dctxPtr;
+  FILE* fp;
+  LZ4_byte* srcBuf;
+  size_t srcBufNext;
+  size_t srcBufSize;
+  size_t srcBufMaxSize;
+};
+
+static void freeReadFileResources(LZ4_readFile_t* lz4fRead)
+{
+  if (lz4fRead==NULL) return;
+  LZ4F_freeDecompressionContext(lz4fRead->dctxPtr);
+  free(lz4fRead->srcBuf);
+  free(lz4fRead);
+}
+
+static void freeAndNullReadFile(LZ4_readFile_t** statePtr)
+{
+  assert(statePtr != NULL);
+  freeReadFileResources(*statePtr);
+  *statePtr = NULL;
+}
+
+static LZ4F_errorCode_t readAndParseHeader(LZ4_readFile_t* readFile, FILE* fp)
+{
+    char headerBuf[LZ4F_HEADER_SIZE_MAX];
+    LZ4F_frameInfo_t frameInfo;
+    size_t consumedSize;
+
+    /* Read the header from file */
+    const size_t bytesRead = fread(headerBuf, 1, sizeof(headerBuf), fp);
+    if (bytesRead < LZ4F_HEADER_SIZE_MIN + LZ4F_ENDMARK_SIZE) {
+        RETURN_ERROR(io_read);
+    }
+
+    /* Parse frame information */
+    consumedSize = bytesRead;
+    { const LZ4F_errorCode_t result = LZ4F_getFrameInfo(readFile->dctxPtr, &frameInfo, headerBuf, &consumedSize);
+      if (LZ4F_isError(result)) {
+          return result;
+    } }
+
+    /* Determine buffer size based on block size */
+    { const size_t blockSize = LZ4F_getBlockSize(frameInfo.blockSizeID);
+      if (blockSize == 0) {
+          RETURN_ERROR(maxBlockSize_invalid);
+      }
+      readFile->srcBufMaxSize = blockSize;
+    }
+
+    /* Allocate source buffer */
+    assert(readFile->srcBuf == NULL); /* Should be NULL from calloc */
+    readFile->srcBuf = (LZ4_byte*)malloc(readFile->srcBufMaxSize);
+    if (readFile->srcBuf == NULL) {
+        RETURN_ERROR(allocation_failed);
+    }
+
+    /* Store remaining header data in buffer */
+    readFile->srcBufSize = bytesRead - consumedSize;
+    if (readFile->srcBufSize > 0) {
+        memcpy(readFile->srcBuf, headerBuf + consumedSize, readFile->srcBufSize);
+    }
+    readFile->srcBufNext = 0;
+
+    return LZ4F_OK_NoError;
+}
+
+LZ4F_errorCode_t LZ4F_readOpen(LZ4_readFile_t** lz4fRead, FILE* fp)
+{
+    LZ4_readFile_t* readFile;
+
+    /* Validate parameters */
+    if (fp == NULL || lz4fRead == NULL) {
+        RETURN_ERROR(parameter_null);
+    }
+
+    /* Allocate read file structure */
+    readFile = (LZ4_readFile_t*)calloc(1, sizeof(LZ4_readFile_t));
+    if (readFile == NULL) {
+        RETURN_ERROR(allocation_failed);
+    }
+
+    readFile->fp = fp;
+
+    /* Initialize decompression context */
+    { LZ4F_errorCode_t const result = LZ4F_createDecompressionContext(&readFile->dctxPtr, LZ4F_VERSION);
+      if (LZ4F_isError(result)) {
+          freeAndNullReadFile(&readFile);
+          return result;
+    } }
+
+    /* Read and parse the header */
+    { LZ4F_errorCode_t const result = readAndParseHeader(readFile, fp);
+      if (LZ4F_isError(result)) {
+          freeAndNullReadFile(&readFile);
+          return result;
+    } }
+
+    *lz4fRead = readFile;
+    return LZ4F_OK_NoError;
+}
+
+size_t LZ4F_read(LZ4_readFile_t* lz4fRead, void* buf, size_t size)
+{
+  LZ4_byte* outPtr = (LZ4_byte*)buf;
+  size_t totalBytesRead = 0;
+
+  if (lz4fRead == NULL || buf == NULL)
+    RETURN_ERROR(parameter_null);
+
+  while (totalBytesRead < size) {
+    size_t srcBytes = lz4fRead->srcBufSize - lz4fRead->srcBufNext;
+    size_t dstBytes = size - totalBytesRead;
+
+    if (srcBytes == 0) {
+      size_t const bytesRead = fread(lz4fRead->srcBuf, 1, lz4fRead->srcBufMaxSize, lz4fRead->fp);
+      if (bytesRead == 0) {
+        if (ferror(lz4fRead->fp)) {
+          RETURN_ERROR(io_read);
+        }
+        break; /* end of input reached */
+      }
+      /* success: ret > 0*/
+      lz4fRead->srcBufSize = bytesRead;
+      srcBytes = lz4fRead->srcBufSize;
+      lz4fRead->srcBufNext = 0;
+    }
+
+    { size_t const decStatus = LZ4F_decompress(
+                          lz4fRead->dctxPtr,
+                          outPtr, &dstBytes,
+                          lz4fRead->srcBuf + lz4fRead->srcBufNext,
+                          &srcBytes,
+                          NULL);
+      if (LZ4F_isError(decStatus)) {
+          return decStatus;
+    } }
+
+    lz4fRead->srcBufNext += srcBytes;
+    totalBytesRead += dstBytes;
+    outPtr += dstBytes;
+  }
+
+  return totalBytesRead;
+}
+
+LZ4F_errorCode_t LZ4F_readClose(LZ4_readFile_t* lz4fRead)
+{
+  if (lz4fRead == NULL)
+    RETURN_ERROR(parameter_null);
+  freeReadFileResources(lz4fRead);
+  return LZ4F_OK_NoError;
+}
+
+/* =====   write API   ===== */
+
+struct LZ4_writeFile_s {
+  LZ4F_cctx* cctxPtr;
+  FILE* fp;
+  LZ4_byte* dstBuf;
+  size_t maxWriteSize;
+  size_t dstBufMaxSize;
+  LZ4F_errorCode_t errCode;
+};
+
+static void freeWriteFileResources(LZ4_writeFile_t* state)
+{
+  if (state == NULL) return;
+  LZ4F_freeCompressionContext(state->cctxPtr);
+  free(state->dstBuf);
+  free(state);
+}
+
+static void freeAndNullWriteFile(LZ4_writeFile_t** statePtr)
+{
+  assert(statePtr != NULL);
+  freeWriteFileResources(*statePtr);
+  *statePtr = NULL;
+}
+
+static LZ4F_errorCode_t writeHeader(LZ4_writeFile_t* writeFile,
+                  FILE* fp,
+            const LZ4F_preferences_t* prefsPtr)
+{
+  LZ4_byte headerBuf[LZ4F_HEADER_SIZE_MAX];
+
+  /* Generate header */
+  LZ4F_errorCode_t const headerSize = LZ4F_compressBegin(writeFile->cctxPtr,
+                                  headerBuf, LZ4F_HEADER_SIZE_MAX, prefsPtr);
+  if (LZ4F_isError(headerSize)) {
+    return headerSize;
+  }
+
+  /* Write header to file */
+  if (headerSize != fwrite(headerBuf, 1, headerSize, fp)) {
+    RETURN_ERROR(io_write);
+  }
+
+  return LZ4F_OK_NoError;
+}
+
+LZ4F_errorCode_t LZ4F_writeOpen(LZ4_writeFile_t** lz4fWrite, FILE* fp, const LZ4F_preferences_t* prefsPtr)
+{
+  LZ4_writeFile_t* writeFile;
+  size_t blockSize;
+
+  if (fp == NULL || lz4fWrite == NULL)
+      RETURN_ERROR(parameter_null);
+
+  /* Validate block size */
+  { LZ4F_blockSizeID_t const blockSizeID = prefsPtr ? prefsPtr->frameInfo.blockSizeID : LZ4F_default;
+    blockSize = LZ4F_getBlockSize(blockSizeID);
+    if (blockSize == 0) {
+        RETURN_ERROR(maxBlockSize_invalid);
+  } }
+
+  /* Allocate write file structure */
+  writeFile = (LZ4_writeFile_t*)calloc(1, sizeof(LZ4_writeFile_t));
+  if (writeFile == NULL) {
+    RETURN_ERROR(allocation_failed);
+  }
+  writeFile->fp = fp;
+  writeFile->errCode = LZ4F_OK_NoError;
+  writeFile->maxWriteSize = blockSize;
+
+  /* Calculate and allocate destination buffer */
+  writeFile->dstBufMaxSize = LZ4F_compressBound(0, prefsPtr);
+  writeFile->dstBuf = (LZ4_byte*)malloc(writeFile->dstBufMaxSize);
+  if (writeFile->dstBuf == NULL) {
+    freeAndNullWriteFile(&writeFile);
+    RETURN_ERROR(allocation_failed);
+  }
+
+  /* Initialize compression context */
+  { LZ4F_errorCode_t const status = LZ4F_createCompressionContext(&writeFile->cctxPtr, LZ4F_VERSION);
+    if (LZ4F_isError(status)) {
+        freeAndNullWriteFile(lz4fWrite);
+        return status;
+  } }
+
+    /* Write header to file */
+  { LZ4F_errorCode_t const writeStatus = writeHeader(writeFile, fp, prefsPtr);
+    if (LZ4F_isError(writeStatus)) {
+        freeAndNullWriteFile(&writeFile);
+        return writeStatus;
+  } }
+
+  *lz4fWrite = writeFile;
+  return LZ4F_OK_NoError;
+}
+
+size_t LZ4F_write(LZ4_writeFile_t* lz4fWrite, const void* buf, size_t size)
+{
+  const LZ4_byte* p = (const LZ4_byte*)buf;
+  size_t remainingBytes = size;
+
+  /* Validate parameters */
+  if (lz4fWrite == NULL || buf == NULL)
+    RETURN_ERROR(parameter_null);
+
+  while (remainingBytes) {
+    size_t const chunkSize = (remainingBytes > lz4fWrite->maxWriteSize) ? lz4fWrite->maxWriteSize : remainingBytes;
+
+    /* Compress and write chunk */
+    size_t cSize = LZ4F_compressUpdate(lz4fWrite->cctxPtr,
+                              lz4fWrite->dstBuf, lz4fWrite->dstBufMaxSize,
+                              p, chunkSize,
+                              NULL);
+    if (LZ4F_isError(cSize)) {
+      lz4fWrite->errCode = cSize;
+      return cSize;
+    }
+
+    if (cSize != fwrite(lz4fWrite->dstBuf, 1, cSize, lz4fWrite->fp)) {
+      lz4fWrite->errCode = returnErrorCode(LZ4F_ERROR_io_write);
+      RETURN_ERROR(io_write);
+    }
+
+    /* Update positions */
+    p += chunkSize;
+    remainingBytes -= chunkSize;
+  }
+
+  return size;
+}
+
+LZ4F_errorCode_t LZ4F_writeClose(LZ4_writeFile_t* lz4fWrite)
+{
+  LZ4F_errorCode_t ret = LZ4F_OK_NoError;
+
+  if (lz4fWrite == NULL) {
+    RETURN_ERROR(parameter_null);
+  }
+
+  if (lz4fWrite->errCode == LZ4F_OK_NoError) {
+    ret =  LZ4F_compressEnd(lz4fWrite->cctxPtr,
+                            lz4fWrite->dstBuf, lz4fWrite->dstBufMaxSize,
+                            NULL);
+    if (LZ4F_isError(ret)) {
+      goto cleanup;
+    }
+
+    if (ret != fwrite(lz4fWrite->dstBuf, 1, ret, lz4fWrite->fp)) {
+      ret = returnErrorCode(LZ4F_ERROR_io_write);
+    }
+  }
+
+cleanup:
+  freeWriteFileResources(lz4fWrite);
+  return ret;
+}

data/{vendor/lz4/lib → ext/lz4_native}/lz4file.h

@@ -1,7 +1,8 @@
 /*
    LZ4 file library
    Header File
-   Copyright (C) 2022, Xiaomi Inc.
+   Copyright (c) Yann Collet and LZ4 contributors. All rights reserved.
+
    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
 
    Redistribution and use in source and binary forms, with or without
@@ -44,10 +45,21 @@ extern "C" {
 typedef struct LZ4_readFile_s LZ4_readFile_t;
 typedef struct LZ4_writeFile_s LZ4_writeFile_t;
 
-/*! LZ4F_readOpen() :
- * Set read lz4file handle.
- * `lz4f` will set a lz4file handle.
- * `fp` must be the return value of the lz4 file opened by fopen.
+/** LZ4 File Decompression **/
+
+/**
+ * Opens an LZ4 file for reading.
+ * Note that the FILE* handle @p fp must be opened in binary mode.
+ *
+ * @param lz4fRead  Pointer to receive the read file handle.
+ *                  It is an OUT parameter, so its initial value is ignored and will be overwritten.
+ *                  Its value on exit is only valid if the function returns LZ4F_OK_NoError.
+ * @param fp        FILE* positioned at start of LZ4 file (binary mode).
+ *
+ * @return LZ4F_OK_NoError on success, or error code on failure.
+ *         Can be tested with LZ4F_isError().
+ *
+ * @note Must be closed with LZ4F_readClose() when done.
  */
 LZ4FLIB_STATIC_API LZ4F_errorCode_t LZ4F_readOpen(LZ4_readFile_t** lz4fRead, FILE* fp);
 
@@ -65,10 +77,21 @@ LZ4FLIB_STATIC_API size_t LZ4F_read(LZ4_readFile_t* lz4fRead, void* buf, size_t
  */
 LZ4FLIB_STATIC_API LZ4F_errorCode_t LZ4F_readClose(LZ4_readFile_t* lz4fRead);
 
-/*! LZ4F_writeOpen() :
- * Set write lz4file handle.
- * `lz4f` will set a lz4file handle.
- * `fp` must be the return value of the lz4 file opened by fopen.
+/** LZ4 File Decompression **/
+
+/**
+ * Opens an LZ4 file for writing.
+ * Note that the FILE* handle @p fp must be opened in write binary mode.
+ *
+ * @param lz4fWrite Pointer to receive the write file handle.
+ *                  It is an OUT parameter, so its initial value is ignored and will be overwritten.
+ *                  Its value on exit is only valid if the function returns LZ4F_OK_NoError.
+ * @param fp        FILE* positioned at start of LZ4 file (binary mode).
+ *
+ * @return LZ4F_OK_NoError on success, or error code on failure.
+ *         Can be tested with LZ4F_isError().
+ *
+ * @note Must be closed with LZ4F_writeClose() when done.
  */
 LZ4FLIB_STATIC_API LZ4F_errorCode_t LZ4F_writeOpen(LZ4_writeFile_t** lz4fWrite, FILE* fp, const LZ4F_preferences_t* prefsPtr);
 

data/{vendor/lz4/lib → ext/lz4_native}/lz4frame.c

@@ -1,6 +1,6 @@
 /*
  * LZ4 auto-framing library
- * Copyright (C) 2011-2016, Yann Collet.
+ * Copyright (c) Yann Collet. All rights reserved.
  *
  * BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
  *
@@ -155,7 +155,7 @@ static void LZ4F_free(void* p, LZ4F_CustomMem cmem)
 static int g_debuglog_enable = 1;
 #  define DEBUGLOG(l, ...) {                                  \
                 if ((g_debuglog_enable) && (l<=LZ4_DEBUG)) {  \
-                    fprintf(stderr, __FILE__ " (%i): ", __LINE__ );  \
+                    fprintf(stderr, __FILE__ " %i: ", __LINE__ );  \
                     fprintf(stderr, __VA_ARGS__);             \
                     fprintf(stderr, " \n");                   \
             }   }
@@ -539,9 +539,16 @@ LZ4F_CDict*
 LZ4F_createCDict_advanced(LZ4F_CustomMem cmem, const void* dictBuffer, size_t dictSize)
 {
     const char* dictStart = (const char*)dictBuffer;
-    LZ4F_CDict* const cdict = (LZ4F_CDict*)LZ4F_malloc(sizeof(*cdict), cmem);
+    LZ4F_CDict* cdict = NULL;
+
     DEBUGLOG(4, "LZ4F_createCDict_advanced");
-    if (!cdict) return NULL;
+
+    if (!dictStart)
+        return NULL;
+    cdict = (LZ4F_CDict*)LZ4F_malloc(sizeof(*cdict), cmem);
+    if (!cdict)
+        return NULL;
+
     cdict->cmem = cmem;
     if (dictSize > 64 KB) {
         dictStart += dictSize - 64 KB;
@@ -684,6 +691,13 @@ static int ctxTypeID_to_size(int ctxTypeID) {
     }
 }
 
+size_t LZ4F_cctx_size(const LZ4F_cctx* cctx) {
+    if (cctx == NULL) {
+        return 0;
+    }
+    return sizeof(*cctx) + cctx->maxBufferSize + ctxTypeID_to_size(cctx->lz4CtxAlloc);
+}
+
 /* LZ4F_compressBegin_internal()
  * Note: only accepts @cdict _or_ @dictBuffer as non NULL.
  */
@@ -700,6 +714,7 @@ size_t LZ4F_compressBegin_internal(LZ4F_cctx* cctx,
     RETURN_ERROR_IF(dstCapacity < maxFHSize, dstMaxSize_tooSmall);
     if (preferencesPtr == NULL) preferencesPtr = &prefNull;
     cctx->prefs = *preferencesPtr;
+    DEBUGLOG(5, "LZ4F_compressBegin_internal: Independent_blocks=%u", cctx->prefs.frameInfo.blockMode);
 
     /* cctx Management */
     {   U16 const ctxTypeID = (cctx->prefs.compressionLevel < LZ4HC_CLEVEL_MIN) ? 1 : 2;
@@ -887,10 +902,11 @@ static size_t LZ4F_makeBlock(void* dst,
                              LZ4F_blockChecksum_t crcFlag)
 {
     BYTE* const cSizePtr = (BYTE*)dst;
+    int dstCapacity = (srcSize > 1) ? (int)srcSize - 1 : 1;
     U32 cSize;
     assert(compress != NULL);
     cSize = (U32)compress(lz4ctx, (const char*)src, (char*)(cSizePtr+BHSize),
-                          (int)(srcSize), (int)(srcSize-1),
+                          (int)srcSize, dstCapacity,
                           level, cdict);
 
     if (cSize == 0 || cSize >= srcSize) {
@@ -961,12 +977,13 @@ static compressFunc_t LZ4F_selectCompression(LZ4F_blockMode_t blockMode, int lev
     return LZ4F_compressBlockHC_continue;
 }
 
-/* Save history (up to 64KB) into @tmpBuff */
-static int LZ4F_localSaveDict(LZ4F_cctx_t* cctxPtr)
+/* Save or shorten history (up to 64KB) into @tmpBuff */
+static void LZ4F_localSaveDict(LZ4F_cctx_t* cctxPtr)
 {
-    if (cctxPtr->prefs.compressionLevel < LZ4HC_CLEVEL_MIN)
-        return LZ4_saveDict ((LZ4_stream_t*)(cctxPtr->lz4CtxPtr), (char*)(cctxPtr->tmpBuff), 64 KB);
-    return LZ4_saveDictHC ((LZ4_streamHC_t*)(cctxPtr->lz4CtxPtr), (char*)(cctxPtr->tmpBuff), 64 KB);
+    int const dictSize = (cctxPtr->prefs.compressionLevel < LZ4HC_CLEVEL_MIN) ?
+                    LZ4_saveDict ((LZ4_stream_t*)(cctxPtr->lz4CtxPtr), (char*)(cctxPtr->tmpBuff), 64 KB) :
+                    LZ4_saveDictHC ((LZ4_streamHC_t*)(cctxPtr->lz4CtxPtr), (char*)(cctxPtr->tmpBuff), 64 KB);
+    cctxPtr->tmpIn = cctxPtr->tmpBuff + dictSize;
 }
 
 typedef enum { notDone, fromTmpBuffer, fromSrcBuffer } LZ4F_lastBlockStatus;
@@ -974,7 +991,7 @@ typedef enum { notDone, fromTmpBuffer, fromSrcBuffer } LZ4F_lastBlockStatus;
 static const LZ4F_compressOptions_t k_cOptionsNull = { 0, { 0, 0, 0 } };
 
 
- /*! LZ4F_compressUpdateImpl() :
+/*! LZ4F_compressUpdateImpl() :
  *  LZ4F_compressUpdate() can be called repetitively to compress as much data as necessary.
  *  When successful, the function always entirely consumes @srcBuffer.
  *  src data is either buffered or compressed into @dstBuffer.
@@ -994,7 +1011,7 @@ static size_t LZ4F_compressUpdateImpl(LZ4F_cctx* cctxPtr,
   {
     size_t const blockSize = cctxPtr->maxBlockSize;
     const BYTE* srcPtr = (const BYTE*)srcBuffer;
-    const BYTE* const srcEnd = srcPtr + srcSize;
+    const BYTE* const srcEnd = srcSize ? (assert(srcPtr!=NULL), srcPtr + srcSize) : srcPtr;
     BYTE* const dstStart = (BYTE*)dstBuffer;
     BYTE* dstPtr = dstStart;
     LZ4F_lastBlockStatus lastBlockCompressed = notDone;
@@ -1072,9 +1089,7 @@ static size_t LZ4F_compressUpdateImpl(LZ4F_cctx* cctxPtr,
         if (compressOptionsPtr->stableSrc) {
             cctxPtr->tmpIn = cctxPtr->tmpBuff;  /* src is stable : dictionary remains in src across invocations */
         } else {
-            int const realDictSize = LZ4F_localSaveDict(cctxPtr);
-            assert(0 <= realDictSize && realDictSize <= 64 KB);
-            cctxPtr->tmpIn = cctxPtr->tmpBuff + realDictSize;
+            LZ4F_localSaveDict(cctxPtr);
         }
     }
 
@@ -1084,8 +1099,7 @@ static size_t LZ4F_compressUpdateImpl(LZ4F_cctx* cctxPtr,
     {
         /* only preserve 64KB within internal buffer. Ensures there is enough room for next block.
          * note: this situation necessarily implies lastBlockCompressed==fromTmpBuffer */
-        int const realDictSize = LZ4F_localSaveDict(cctxPtr);
-        cctxPtr->tmpIn = cctxPtr->tmpBuff + realDictSize;
+        LZ4F_localSaveDict(cctxPtr);
         assert((cctxPtr->tmpIn + blockSize) <= (cctxPtr->tmpBuff + cctxPtr->maxBufferSize));
     }
 
@@ -1150,7 +1164,7 @@ size_t LZ4F_uncompressedUpdate(LZ4F_cctx* cctxPtr,
 
 /*! LZ4F_flush() :
  *  When compressed data must be sent immediately, without waiting for a block to be filled,
- *  invoke LZ4_flush(), which will immediately compress any remaining data stored within LZ4F_cctx.
+ *  invoke LZ4F_flush(), which will immediately compress any remaining data stored within LZ4F_cctx.
  *  The result of the function is the number of bytes written into dstBuffer.
  *  It can be zero, this means there was no data left within LZ4F_cctx.
  *  The function outputs an error code if it fails (can be tested using LZ4F_isError())
@@ -1164,6 +1178,8 @@ size_t LZ4F_flush(LZ4F_cctx* cctxPtr,
     BYTE* dstPtr = dstStart;
     compressFunc_t compress;
 
+    DEBUGLOG(5, "LZ4F_flush: %zu buffered bytes (saved dict size = %i) (dstCapacity=%u)",
+            cctxPtr->tmpInSize, (int)(cctxPtr->tmpIn - cctxPtr->tmpBuff), (unsigned)dstCapacity);
     if (cctxPtr->tmpInSize == 0) return 0;   /* nothing to flush */
     RETURN_ERROR_IF(cctxPtr->cStage != 1, compressionState_uninitialized);
     RETURN_ERROR_IF(dstCapacity < (cctxPtr->tmpInSize + BHSize + BFSize), dstMaxSize_tooSmall);
@@ -1185,9 +1201,9 @@ size_t LZ4F_flush(LZ4F_cctx* cctxPtr,
     cctxPtr->tmpInSize = 0;
 
     /* keep tmpIn within limits */
-    if ((cctxPtr->tmpIn + cctxPtr->maxBlockSize) > (cctxPtr->tmpBuff + cctxPtr->maxBufferSize)) {  /* necessarily LZ4F_blockLinked */
-        int const realDictSize = LZ4F_localSaveDict(cctxPtr);
-        cctxPtr->tmpIn = cctxPtr->tmpBuff + realDictSize;
+    if ((cctxPtr->tmpIn + cctxPtr->maxBlockSize) > (cctxPtr->tmpBuff + cctxPtr->maxBufferSize)) {
+        assert(cctxPtr->prefs.frameInfo.blockMode == LZ4F_blockLinked);
+        LZ4F_localSaveDict(cctxPtr);
     }
 
     return (size_t)(dstPtr - dstStart);
@@ -1322,6 +1338,15 @@ LZ4F_errorCode_t LZ4F_freeDecompressionContext(LZ4F_dctx* dctx)
     return result;
 }
 
+size_t LZ4F_dctx_size(const LZ4F_dctx* dctx) {
+    if (dctx == NULL) {
+        return 0;
+    }
+    return sizeof(*dctx)
+         + (dctx->tmpIn != NULL ? dctx->maxBlockSize + BFSize : 0)
+         + (dctx->tmpOutBuffer != NULL ? dctx->maxBufferSize : 0);
+}
+
 
 /*==---   Streaming Decompression operations   ---==*/
 void LZ4F_resetDecompressionContext(LZ4F_dctx* dctx)
@@ -1486,6 +1511,10 @@ LZ4F_errorCode_t LZ4F_getFrameInfo(LZ4F_dctx* dctx,
                                    LZ4F_frameInfo_t* frameInfoPtr,
                              const void* srcBuffer, size_t* srcSizePtr)
 {
+    assert(dctx != NULL);
+    RETURN_ERROR_IF(frameInfoPtr == NULL, parameter_null);
+    RETURN_ERROR_IF(srcSizePtr == NULL, parameter_null);
+
     LZ4F_STATIC_ASSERT(dstage_getFrameHeader < dstage_storeFrameHeader);
     if (dctx->dStage > dstage_storeFrameHeader) {
         /* frameInfo already decoded */