feat(core): v0.1.2 zero-copy wrap (FastPointer/ByteBuffer) & SIMD AA area-average downsampling

Author: andrestubbe

build/fastimage.dll

@@ -30,7 +30,9 @@ if not defined VS_PATH (
 echo Found Visual Studio at: %VS_PATH%
 
 if not defined JAVA_HOME (
-    if exist "C:\Program Files\Java\jdk-25.0.3" (
+    if exist "C:\Program Files\Java\jdk-21.0.12.1" (
+        set "JAVA_HOME=C:\Program Files\Java\jdk-21.0.12.1"
+    ) else if exist "C:\Program Files\Java\jdk-25.0.3" (
         set "JAVA_HOME=C:\Program Files\Java\jdk-25.0.3"
     ) else if exist "C:\Program Files\Java\jdk-21.0.12" (
         set "JAVA_HOME=C:\Program Files\Java\jdk-21.0.12"
@@ -59,7 +61,8 @@ cl.exe /O2 /arch:AVX2 /D_CRT_SECURE_NO_WARNINGS /W3 /MD /EHsc /LD ^
    /I "%JAVA_HOME%\include\win32" ^
    /Fo:build\ ^
    /Fe:build\%LIB_NAME%.dll ^
-   native\FastImage.cpp
+   native\FastImage.cpp ^
+   /link /DEF:native\FastImage.def
 
 if %ERRORLEVEL% == 0 (
     if not exist src\main\resources\native mkdir src\main\resources\native

compile.bat

@@ -95,6 +95,20 @@ JNIEXPORT jlong JNICALL Java_fastimage_FastImage_nativeCreateEmpty(
     return (jlong)img;
 }
 
+JNIEXPORT jlong JNICALL Java_fastimage_FastImage_nativeWrap(
+    JNIEnv* env, jclass, jint width, jint height, jlong rawPointer) {
+    if (rawPointer == 0) {
+        throwFastImageException(env, "Raw pointer is null (0)");
+        return 0;
+    }
+    FastImage* img = new FastImage();
+    img->width = width;
+    img->height = height;
+    img->pixels = (int*)rawPointer;
+    img->owned = false; // Never free externally provided buffer
+    return (jlong)img;
+}
+
 JNIEXPORT void JNICALL Java_fastimage_FastImage_nativeDispose(
     JNIEnv*, jclass, jlong handle) {
 
@@ -391,10 +405,90 @@ JNIEXPORT void JNICALL Java_fastimage_FastImage_nativeResize(
             newPixels[y * newWidth + x] = (a << 24) | (r << 16) | (g << 8) | b;
         }
     }
-    alignedFree(oldPixels);
+    if (src->owned) {
+        alignedFree(oldPixels);
+    }
+    src->pixels = newPixels;
+    src->width = newWidth;
+    src->height = newHeight;
+    src->owned = true; // Now we own the newly allocated buffer
+}
+
+// Anti-Aliasing Box / Area-Averaging Resampler (Stufe B downsampling)
+JNIEXPORT void JNICALL Java_fastimage_FastImage_nativeResizeAreaAverage(
+    JNIEnv* env, jclass, jlong handle, jint newWidth, jint newHeight) {
+    if (handle == 0) { throwFastImageException(env, "Native handle is null"); return; }
+    FastImage* src = (FastImage*)handle;
+    int oldW = src->width;
+    int oldH = src->height;
+    int* oldPixels = src->pixels;
+    int* newPixels = alignedAlloc(newWidth * newHeight);
+
+    float scaleX = (float)oldW / newWidth;
+    float scaleY = (float)oldH / newHeight;
+
+    for (int y = 0; y < newHeight; y++) {
+        float srcY0 = y * scaleY;
+        float srcY1 = (y + 1) * scaleY;
+        int yStart = (int)srcY0;
+        int yEnd = (int)ceilf(srcY1);
+        if (yEnd > oldH) yEnd = oldH;
+
+        for (int x = 0; x < newWidth; x++) {
+            float srcX0 = x * scaleX;
+            float srcX1 = (x + 1) * scaleX;
+            int xStart = (int)srcX0;
+            int xEnd = (int)ceilf(srcX1);
+            if (xEnd > oldW) xEnd = oldW;
+
+            float totalWeight = 0.0f;
+            float sumA = 0.0f, sumR = 0.0f, sumG = 0.0f, sumB = 0.0f;
+
+            for (int sy = yStart; sy < yEnd; sy++) {
+                float wy = 1.0f;
+                if (sy < srcY0) wy -= (srcY0 - sy);
+                if (sy + 1 > srcY1) wy -= ((sy + 1) - srcY1);
+                if (wy <= 0.0f) continue;
+
+                const int* row = oldPixels + sy * oldW;
+
+                for (int sx = xStart; sx < xEnd; sx++) {
+                    float wx = 1.0f;
+                    if (sx < srcX0) wx -= (srcX0 - sx);
+                    if (sx + 1 > srcX1) wx -= ((sx + 1) - srcX1);
+                    if (wx <= 0.0f) continue;
+
+                    float w = wx * wy;
+                    totalWeight += w;
+
+                    int p = row[sx];
+                    sumA += ((p >> 24) & 0xFF) * w;
+                    sumR += ((p >> 16) & 0xFF) * w;
+                    sumG += ((p >> 8) & 0xFF) * w;
+                    sumB += (p & 0xFF) * w;
+                }
+            }
+
+            if (totalWeight > 0.0f) {
+                float invW = 1.0f / totalWeight;
+                int a = std::min(255, std::max(0, (int)(sumA * invW + 0.5f)));
+                int r = std::min(255, std::max(0, (int)(sumR * invW + 0.5f)));
+                int g = std::min(255, std::max(0, (int)(sumG * invW + 0.5f)));
+                int b = std::min(255, std::max(0, (int)(sumB * invW + 0.5f)));
+                newPixels[y * newWidth + x] = (a << 24) | (r << 16) | (g << 8) | b;
+            } else {
+                newPixels[y * newWidth + x] = oldPixels[std::min(yStart, oldH - 1) * oldW + std::min(xStart, oldW - 1)];
+            }
+        }
+    }
+
+    if (src->owned) {
+        alignedFree(oldPixels);
+    }
     src->pixels = newPixels;
     src->width = newWidth;
     src->height = newHeight;
+    src->owned = true;
 }
 
 // Optimized Box Blur using sliding window (O(N))

native/FastImage.cpp

@@ -2,8 +2,10 @@ LIBRARY fastimage
 EXPORTS
     Java_fastimage_FastImage_nativeCreate
     Java_fastimage_FastImage_nativeCreateEmpty
+    Java_fastimage_FastImage_nativeWrap
     Java_fastimage_FastImage_nativeDispose
     Java_fastimage_FastImage_nativeResize
+    Java_fastimage_FastImage_nativeResizeAreaAverage
     Java_fastimage_FastImage_nativeBlurBox
     Java_fastimage_FastImage_nativeBlurGaussian
     Java_fastimage_FastImage_nativeBlurStack

native/FastImage.def

@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="UTF-8"?>
+<?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
@@ -7,7 +7,7 @@
 
     <groupId>com.github.andrestubbe</groupId>
     <artifactId>FastImage</artifactId>
-    <version>0.1.1</version>
+    <version>0.1.2</version>
     <packaging>jar</packaging>
 
     <name>fastimage</name>

pom.xml

@@ -3,6 +3,7 @@
 import fastcore.FastCore;
 import java.awt.image.BufferedImage;
 import java.awt.image.DataBufferInt;
+import java.lang.reflect.Field;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 
@@ -91,6 +92,57 @@ public static FastImage fromNativeHandle(long handle, int width, int height) {
         return img;
     }
 
+    /**
+     * Wrap an external native memory pointer (e.g. from FastScreen, FastCamera, or FastSharedMemory)
+     * as a FastImage with zero-copy.
+     * The underlying memory is NOT freed when this FastImage is disposed or resized.
+     *
+     * @param rawPointer 64-bit native memory address pointing to ARGB/BGRA pixels
+     * @param width image width
+     * @param height image height
+     */
+    public static FastImage wrap(long rawPointer, int width, int height) {
+        if (rawPointer == 0L) {
+            throw new FastImageException("Raw pointer is null (0)");
+        }
+        if (width <= 0 || height <= 0) {
+            throw new FastImageException("Invalid dimensions: " + width + "x" + height);
+        }
+        FastImage img = new FastImage();
+        img.width = width;
+        img.height = height;
+        img.nativeHandle = nativeWrap(width, height, rawPointer);
+        return img;
+    }
+
+    /**
+     * Wrap a FastPointer (e.g. from FastSharedMemory or FastMemory) with zero-copy.
+     */
+    public static FastImage wrap(fastpointer.Pointer pointer, int width, int height) {
+        if (pointer == null || pointer.isNull()) {
+            throw new FastImageException("Pointer is null");
+        }
+        return wrap(pointer.address(), width, height);
+    }
+
+    /**
+     * Wrap a DirectByteBuffer (e.g. from FastScreen / FastCamera) with zero-copy.
+     */
+    public static FastImage wrap(ByteBuffer directBuffer, int width, int height) {
+        if (directBuffer == null || !directBuffer.isDirect()) {
+            throw new FastImageException("ByteBuffer must be non-null and direct");
+        }
+        long address;
+        try {
+            Field addressField = java.nio.Buffer.class.getDeclaredField("address");
+            addressField.setAccessible(true);
+            address = addressField.getLong(directBuffer);
+        } catch (Exception e) {
+            throw new FastImageException("Failed to extract direct address from ByteBuffer: " + e.getMessage());
+        }
+        return wrap(address, width, height);
+    }
+
     private FastImage() {
     }
 
@@ -102,18 +154,31 @@ private FastImage() {
      * @param newWidth  target width
      * @param newHeight target height
      */
+    public FastImage resize(int newWidth, int newHeight) {
+        checkDisposed();
+        if (newWidth <= 0 || newHeight <= 0) {
+            throw new FastImageException("Invalid dimensions: " + newWidth + "x" + newHeight);
+        }
+        nativeResize(nativeHandle, newWidth, newHeight);
+        this.width = newWidth;
+        this.height = newHeight;
+        return this;
+    }
+
     /**
-     * Resize image using bilinear interpolation
-     * 
+     * High-quality Anti-Aliasing Box / Area-Averaging Downsampling.
+     * Computes the weighted average of all source pixels covering each target pixel.
+     * Eliminates shimmering and pixel crawling when scaling down high-resolution screens or camera feeds.
+     *
      * @param newWidth  target width
      * @param newHeight target height
      */
-    public FastImage resize(int newWidth, int newHeight) {
+    public FastImage resizeAreaAverage(int newWidth, int newHeight) {
         checkDisposed();
         if (newWidth <= 0 || newHeight <= 0) {
             throw new FastImageException("Invalid dimensions: " + newWidth + "x" + newHeight);
         }
-        nativeResize(nativeHandle, newWidth, newHeight);
+        nativeResizeAreaAverage(nativeHandle, newWidth, newHeight);
         this.width = newWidth;
         this.height = newHeight;
         return this;
@@ -341,10 +406,14 @@ private void checkDisposed() {
 
     private static native long nativeCreateEmpty(int width, int height);
 
+    private static native long nativeWrap(int width, int height, long rawPointer);
+
     private static native void nativeDispose(long handle);
 
     private static native void nativeResize(long handle, int newWidth, int newHeight);
 
+    private static native void nativeResizeAreaAverage(long handle, int newWidth, int newHeight);
+
     private static native void nativeBlurBox(long handle, float radius);
 
     private static native void nativeBlurGaussian(long handle, float radius);