[PR] Add support for native memory compression and decompression

install-jar.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+
+# Define the directory and file pattern
+TARGET_DIR="./target"
+FILE_PATTERN="zstd-jni-*.jar"
+
+# Find the jar file matching the pattern
+JAR_FILE=$(find "$TARGET_DIR" -name "$FILE_PATTERN" -print -quit)
+
+# Check if the jar file exists
+if [[ -z "$JAR_FILE" ]]; then
+  echo "Error: No jar file matching the pattern '$FILE_PATTERN' found in '$TARGET_DIR'."
+  exit 1
+fi
+
+# Extract the version from the jar file name
+VERSION=$(basename "$JAR_FILE" | sed -n 's/^zstd-jni-\(.*\)\.jar$/\1/p')
+
+# Check if version was extracted successfully
+if [[ -z "$VERSION" ]]; then
+  echo "Error: Unable to extract version from jar file name '$JAR_FILE'."
+  exit 1
+fi
+
+# Run the Maven install command with the extracted version
+echo "Installing zstd-jni library to the local maven repository"
+mvn install:install-file -Dfile="$JAR_FILE" -DgroupId=com.carrotdata -DartifactId=zstd-jni -Dversion="$VERSION" -Dpackaging=jar

src/main/java/com/github/luben/zstd/ZstdCompressCtx.java

@@ -577,8 +577,98 @@ public int compressByteArray(byte[] dstBuff, int dstOffset, int dstSize, byte[]
         }
     }
 
+
+    /**
+     * Compress native memory - to native memory, reusing this ZstdCompressCtx.
+     * @param dstBuff destination memory buffer address
+     * @param dstSize destination memory buffer size
+     * @param srcBuff source memory buffer address
+     * @param srcSize source memory buffer size
+     * @return  the number of bytes written into buffer 'dstBuff'.
+     */
+    public int compressNativeNative(long dstBuff, int dstSize, long srcBuff, int srcSize) {
+      ensureOpen();
+      acquireSharedLock();
+
+      try {
+          long size = compressUnsafeNativeNative0(nativePtr, dstBuff, dstSize, srcBuff, srcSize);
+          if (Zstd.isError(size)) {
+              throw new ZstdException(size);
+          }
+          if (size > Integer.MAX_VALUE) {
+              throw new ZstdException(Zstd.errGeneric(), "Output size is greater than MAX_INT");
+          }
+          return (int) size;
+      } finally {
+          releaseSharedLock();
+      }
+   }
+
+   /**
+    * Compress native memory - to byte array, reusing this ZstdCompressCtx.
+    * @param dstBuff destination buffer
+    * @param dstOffset offset in the destination buffer
+    * @param dstSize destination buffer size
+    * @param srcBuff source memory buffer address
+    * @param srcSize source memory buffer size
+    * @return  the number of bytes written into buffer 'dstBuff'.
+    */
+    public int compressNativeByteArray(byte[] dstBuff, int dstOffset, int dstSize, long srcBuff, int srcSize) {
+      ensureOpen();
+      acquireSharedLock();
+
+      try {
+          long size = compressUnsafeNativeByteArray0(nativePtr, dstBuff, dstOffset, dstSize, srcBuff, srcSize);
+          if (Zstd.isError(size)) {
+              throw new ZstdException(size);
+          }
+          if (size > Integer.MAX_VALUE) {
+              throw new ZstdException(Zstd.errGeneric(), "Output size is greater than MAX_INT");
+          }
+          return (int) size;
+      } finally {
+          releaseSharedLock();
+      }
+    }
+
+    /**
+     * Compress byte array - to native memory, reusing this ZstdCompressCtx.
+     * @param dstBuff destination memory buffer address
+     * @param dstSize destination memory buffer size
+     * @param srcBuff source buffer
+     * @param srcOffset source buffer offset 
+     * @param srcSize source buffer size
+     * @return  the number of bytes written into buffer 'dstBuff'.
+     */
+    public int compressByteArrayNative(long dstBuff, int dstSize, byte[] srcBuff, int srcOffset,
+        int srcSize) {
+      ensureOpen();
+      acquireSharedLock();
+
+      try {
+        long size = compressUnsafeByteArrayNative0(nativePtr, dstBuff, dstSize, srcBuff, srcOffset,
+          srcSize);
+        if (Zstd.isError(size)) {
+          throw new ZstdException(size);
+        }
+        if (size > Integer.MAX_VALUE) {
+          throw new ZstdException(Zstd.errGeneric(), "Output size is greater than MAX_INT");
+        }
+        return (int) size;
+      } finally {
+        releaseSharedLock();
+      }
+    }
+
     private static native long compressByteArray0(long ptr, byte[] dst, int dstOffset, int dstSize, byte[] src, int srcOffset, int srcSize);
 
+    private static native long compressUnsafeNativeNative0(long ptr, long dst, int dstSize, long src, int srcSize);
+
+    private static native long compressUnsafeNativeByteArray0(long ptr, byte[] dst, int dstOffset, int dstSize, long src, int srcSize);
+
+    private static native long compressUnsafeByteArrayNative0(long ptr, long dst, int dstSize, byte[] src, int srcOffset, int srcSize);
+
+
     /* Convenience methods */
 
     /**

src/main/java/com/github/luben/zstd/ZstdDecompressCtx.java

@@ -215,6 +215,102 @@ public int decompressByteArray(byte[] dstBuff, int dstOffset, int dstSize, byte[
 
     private static native long decompressByteArray0(long nativePtr, byte[] dst, int dstOffset, int dstSize, byte[] src, int srcOffset, int srcSize);
 
+
+    /**
+     * Decompresses memory buffer 'srcBuff' into memory buffer 'dstBuff' using this ZstdDecompressCtx.
+     *
+     * Destination buffer should be sized to be larger of equal to the originalSize.
+     *
+     * @param dstBuff the destination memory buffer address
+     * @param dstSize the size of destination memory buffer
+     * @param srcBuff the source memory buffer address
+     * @param srcSize the size of source memory buffer
+     * @return the number of bytes decompressed into destination buffer (originalSize)
+     */ 
+    public int decompressNativeNative(long dstBuff, int dstSize, long srcBuff, int srcSize) {
+      ensureOpen();
+      acquireSharedLock();
+
+      try {
+          long size = decompressUnsafeNativeNative0(nativePtr, dstBuff, dstSize, srcBuff, srcSize);
+          if (Zstd.isError(size)) {
+              throw new ZstdException(size);
+          }
+          if (size > Integer.MAX_VALUE) {
+              throw new ZstdException(Zstd.errGeneric(), "Output size is greater than MAX_INT");
+          }
+          return (int) size;
+      } finally {
+          releaseSharedLock();
+      }
+    }
+
+    /**
+     * Decompresses memory buffer 'srcBuff' into byte array 'dstBuff' using this ZstdDecompressCtx.
+     *
+     * Destination buffer should be sized to be larger of equal to the originalSize.
+     *
+     * @param dstBuff the destination byte array
+     * @param dstOffset offset in the destination byte array
+     * @param dstSize the size of destination byte array buffer
+     * @param srcBuff the source memory buffer address
+     * @param srcSize the size of source memory buffer
+     * @return the number of bytes decompressed into destination buffer (originalSize)
+     */ 
+    public int decompressNativeByteArray(byte[] dstBuff, int dstOffset, int dstSize, long srcBuff, int srcSize) {
+      ensureOpen();
+      acquireSharedLock();
+
+      try {
+          long size = decompressUnsafeNativeByteArray0(nativePtr, dstBuff, dstOffset, dstSize, srcBuff, srcSize);
+          if (Zstd.isError(size)) {
+              throw new ZstdException(size);
+          }
+          if (size > Integer.MAX_VALUE) {
+              throw new ZstdException(Zstd.errGeneric(), "Output size is greater than MAX_INT");
+          }
+          return (int) size;
+      } finally {
+          releaseSharedLock();
+      }
+    }
+
+    /**
+     * Decompresses byte array 'srcBuff' into memory 'dstBuff' using this ZstdDecompressCtx.
+     *
+     * Destination buffer should be sized to be larger of equal to the originalSize.
+     *
+     * @param dstBuff the destination memory buffer
+     * @param dstSize the size of destination memory buffer
+     * @param srcBuff the source byte array
+     * @param srcOffset offset in the source byte array
+     * @param srcSize the size of source byte array 
+     * @return the number of bytes decompressed into destination buffer (originalSize)
+     */ 
+    public int decompressByteArrayNative(long dstBuff, int dstSize, byte[] srcBuff, int srcOffset, int srcSize) {
+      ensureOpen();
+      acquireSharedLock();
+
+      try {
+          long size = decompressUnsafeByteArrayNative0(nativePtr, dstBuff, dstSize, srcBuff, srcOffset, srcSize);
+          if (Zstd.isError(size)) {
+              throw new ZstdException(size);
+          }
+          if (size > Integer.MAX_VALUE) {
+              throw new ZstdException(Zstd.errGeneric(), "Output size is greater than MAX_INT");
+          }
+          return (int) size;
+      } finally {
+          releaseSharedLock();
+      }
+    }
+
+    private static native long decompressUnsafeNativeNative0(long ptr, long dst, int dstSize, long src, int srcSize);
+
+    private static native long decompressUnsafeNativeByteArray0(long ptr, byte[] dst, int dstOffset, int dstSize, long src, int srcSize);
+
+    private static native long decompressUnsafeByteArrayNative0(long ptr, long dst, int dstSize, byte[] src, int srcOffset, int srcSize);
+
     /* Covenience methods */
 
     /**