pack SamplingMode into IntArray with 2 Int values. (#316)

* pack SamplingMode into IntArray with 2 Int values.

Use IntArray instead of Long to pass SamplingMode through interop border.

* use 2 Ints instead of IntArray to pass SamplingMode through interop
Co-authored-by: Oleksandr Karpovich <oleksandr.karpovich@jetbrains.com>

skiko/src/commonMain/kotlin/org/jetbrains/skia/Bitmap.kt

@@ -1021,7 +1021,8 @@ class Bitmap internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerH
                         _ptr,
                         tmx.ordinal,
                         tmy.ordinal,
-                        sampling._pack(),
+                        sampling._packedInt1(),
+                        sampling._packedInt2(),
                         toInterop(localMatrix?.mat)
                     )
                 }
@@ -1196,4 +1197,4 @@ private external fun _nExtractAlpha(ptr: NativePointer, dstPtr: NativePointer, p
 private external fun _nPeekPixels(ptr: NativePointer): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_Bitmap__1nMakeShader")
-private external fun _nMakeShader(ptr: NativePointer, tmx: Int, tmy: Int, samplingMode: Long, localMatrix: InteropPointer): NativePointer
+private external fun _nMakeShader(ptr: NativePointer, tmx: Int, tmy: Int, samplingModeValue1: Int, samplingModeValue2: Int, localMatrix: InteropPointer): NativePointer

skiko/src/commonMain/kotlin/org/jetbrains/skia/Canvas.kt

@@ -428,7 +428,8 @@ open class Canvas internal constructor(ptr: NativePointer, managed: Boolean, int
             dst.top,
             dst.right,
             dst.bottom,
-            samplingMode._pack(),
+            samplingMode._packedInt1(),
+            samplingMode._packedInt2(),
             getPtr(paint),
             strict
         )
@@ -1550,7 +1551,8 @@ private external fun _nDrawImageRect(
     dt: Float,
     dr: Float,
     db: Float,
-    samplingMode: Long,
+    samplingModeVal1: Int,
+    samplingModeVal2: Int,
     paintPtr: NativePointer,
     strict: Boolean
 )

skiko/src/commonMain/kotlin/org/jetbrains/skia/CubicResampler.kt

@@ -25,6 +25,9 @@ class CubicResampler(val b: Float, val c: Float) : SamplingMode {
 
     override fun _pack(): Long = (0x8L shl 60) or ((b.toBits().toULong() shl 32) or c.toBits().toULong()).toLong()
 
+    override fun _packedInt1(): Int = b.toBits() or (0x8 shl 28)
+    override fun _packedInt2(): Int = c.toBits()
+
     override fun equals(other: Any?): Boolean {
         if (other === this) return true
         if (other !is CubicResampler) return false

skiko/src/commonMain/kotlin/org/jetbrains/skia/FilterMipmap.kt

@@ -7,6 +7,9 @@ class FilterMipmap constructor(
 
     override fun _pack() = filterMode.ordinal.toLong() shl 32 or mipmapMode.ordinal.toLong()
 
+    override fun _packedInt1(): Int = filterMode.ordinal
+    override fun _packedInt2(): Int = mipmapMode.ordinal
+
     override fun equals(other: Any?): Boolean {
         if (other === this) return true
         if (other !is FilterMipmap) return false

skiko/src/commonMain/kotlin/org/jetbrains/skia/Image.kt

@@ -235,7 +235,8 @@ class Image internal constructor(ptr: NativePointer) : RefCnt(ptr), IHasImageInf
                         _ptr,
                         tmx.ordinal,
                         tmy.ordinal,
-                        sampling._pack(),
+                        sampling._packedInt1(),
+                        sampling._packedInt2(),
                         toInterop(localMatrix?.mat)
                     )
                 }
@@ -361,7 +362,8 @@ class Image internal constructor(ptr: NativePointer) : RefCnt(ptr), IHasImageInf
             _nScalePixels(
                 _ptr,
                 getPtr(dst),
-                samplingMode._pack(),
+                samplingMode._packedInt1(),
+                samplingMode._packedInt2(),
                 cache
             )
         } finally {
@@ -375,7 +377,7 @@ class Image internal constructor(ptr: NativePointer) : RefCnt(ptr), IHasImageInf
 private external fun Image_nGetImageInfo(ptr: NativePointer, imageInfo: InteropPointer, colorSpacePtrs: InteropPointer)
 
 @ExternalSymbolName("org_jetbrains_skia_Image__1nMakeShader")
-private external fun Image_nMakeShader(ptr: NativePointer, tmx: Int, tmy: Int, samplingMode: Long, localMatrix: InteropPointer): NativePointer
+private external fun Image_nMakeShader(ptr: NativePointer, tmx: Int, tmy: Int, samplingModeVal1: Int, samplingModeVal2: Int, localMatrix: InteropPointer): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_Image__1nPeekPixels")
 private external fun Image_nPeekPixels(ptr: NativePointer): NativePointer
@@ -420,7 +422,7 @@ private external fun _nEncodeToData(ptr: NativePointer, format: Int, quality: In
 private external fun _nPeekPixelsToPixmap(ptr: NativePointer, pixmapPtr: NativePointer): Boolean
 
 @ExternalSymbolName("org_jetbrains_skia_Image__1nScalePixels")
-private external fun _nScalePixels(ptr: NativePointer, pixmapPtr: NativePointer, samplingOptions: Long, cache: Boolean): Boolean
+private external fun _nScalePixels(ptr: NativePointer, pixmapPtr: NativePointer, samplingOptionsVal1: Int, samplingOptionsVal2: Int, cache: Boolean): Boolean
 
 @ExternalSymbolName("org_jetbrains_skia_Image__1nReadPixelsBitmap")
 private external fun _nReadPixelsBitmap(

skiko/src/commonMain/kotlin/org/jetbrains/skia/ImageFilter.kt

@@ -219,9 +219,7 @@ class ImageFilter internal constructor(ptr: NativePointer) : RefCnt(ptr) {
                 Stats.onNativeCall()
                 ImageFilter(
                     _nMakeImage(
-                        getPtr(
-                            image
-                        ),
+                        getPtr(image),
                         src.left,
                         src.top,
                         src.right,
@@ -230,7 +228,8 @@ class ImageFilter internal constructor(ptr: NativePointer) : RefCnt(ptr) {
                         dst.top,
                         dst.right,
                         dst.bottom,
-                        mode._pack()
+                        mode._packedInt1(),
+                        mode._packedInt2()
                     )
                 )
             } finally {
@@ -301,7 +300,8 @@ class ImageFilter internal constructor(ptr: NativePointer) : RefCnt(ptr) {
                     interopScope {
                         _nMakeMatrixTransform(
                             toInterop(matrix.mat),
-                            mode._pack(),
+                            mode._packedInt1(),
+                            mode._packedInt2(),
                             getPtr(input)
                         )
                     }
@@ -686,7 +686,8 @@ private external fun _nMakeImage(
     t1: Float,
     r1: Float,
     b1: Float,
-    samplingMode: Long
+    samplingModeVal1: Int,
+    samplingModeVal2: Int,
 ): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_ImageFilter__1nMakeMagnifier")
@@ -716,7 +717,7 @@ private external fun _nMakeMatrixConvolution(
 ): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_ImageFilter__1nMakeMatrixTransform")
-private external fun _nMakeMatrixTransform(matrix: InteropPointer, samplingMode: Long, input: NativePointer): NativePointer
+private external fun _nMakeMatrixTransform(matrix: InteropPointer, samplingModeVal1: Int, samplingModeVal2: Int, input: NativePointer): NativePointer
 @ExternalSymbolName("org_jetbrains_skia_ImageFilter__1nMakeMerge")
 private external fun _nMakeMerge(filters: InteropPointer, crop: IRect?): NativePointer
 @ExternalSymbolName("org_jetbrains_skia_ImageFilter__1nMakeOffset")

skiko/src/commonMain/kotlin/org/jetbrains/skia/Pixmap.kt

@@ -216,7 +216,8 @@ class Pixmap internal constructor(ptr: NativePointer, managed: Boolean) :
             _nScalePixels(
                 _ptr,
                 getPtr(dstPixmap),
-                samplingMode._pack()
+                samplingMode._packedInt1(),
+                samplingMode._packedInt2()
             )
         } finally {
             reachabilityBarrier(this)
@@ -392,7 +393,7 @@ private external fun _nReadPixelsToPixmap(ptr: NativePointer, dstPixmapPtr: Nati
 private external fun _nReadPixelsToPixmapFromPoint(ptr: NativePointer, dstPixmapPtr: NativePointer, srcX: Int, srcY: Int): Boolean
 
 @ExternalSymbolName("org_jetbrains_skia_Pixmap__1nScalePixels")
-private external fun _nScalePixels(ptr: NativePointer, dstPixmapPtr: NativePointer, samplingOptions: Long): Boolean
+private external fun _nScalePixels(ptr: NativePointer, dstPixmapPtr: NativePointer, samplingOptionsVal1: Int, samplingOptionsVal2: Int): Boolean
 
 @ExternalSymbolName("org_jetbrains_skia_Pixmap__1nErase")
 private external fun _nErase(ptr: NativePointer, color: Int): Boolean

skiko/src/commonMain/kotlin/org/jetbrains/skia/SamplingMode.kt

@@ -6,8 +6,13 @@ package org.jetbrains.skia
  * @see org.jetbrains.skia.CubicResampler
  */
 interface SamplingMode {
+    @Deprecated("Long can't be used because Long is an object in kotlin/js. Consider using _packedInt1 and _packedInt2")
     fun _pack(): Long
 
+    // _packedInt1 and _packedInt2 are used to serialize SamplingMode instances for interop
+    fun _packedInt1(): Int
+    fun _packedInt2(): Int
+
     companion object {
         val DEFAULT: SamplingMode = FilterMipmap(FilterMode.NEAREST, MipmapMode.NONE)
         val LINEAR: SamplingMode = FilterMipmap(FilterMode.LINEAR, MipmapMode.NONE)

skiko/src/commonTest/kotlin/org/jetbrains/skia/SamplingModeTest.kt

+package org.jetbrains.skia
+
+import org.jetbrains.skiko.tests.runTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class SamplingModeTest {
+
+    @Test
+    fun packFilterMipmap() = runTest {
+        FilterMode.values().forEach { filterMode ->
+            MipmapMode.values().forEach { mipmapMode ->
+                val samplingMode = FilterMipmap(filterMode, mipmapMode)
+
+                val long = samplingMode._pack() // we treat it as expected since it was used initially
+                val l1 = (long shr 32).toInt()
+                val l2 = (long and 0x00000000FFFFFFFF).toInt()
+
+                assertEquals(filterMode.ordinal, l1)
+                assertEquals(mipmapMode.ordinal, l2)
+
+                assertEquals(l1, samplingMode._packedInt1())
+                assertEquals(l2, samplingMode._packedInt2())
+            }
+        }
+    }
+
+    @Test
+    fun packCubicResampler() = runTest {
+        val floats = floatArrayOf(0f, 0.5f, 0.9f, 1f / 3, 2f / 3, 1f)
+
+        floats.forEach { b ->
+            floats.forEach { c ->
+                val samplingMode = CubicResampler(b = b, c = c)
+
+                val long = samplingMode._pack() // we treat it as expected since it was used initially
+                assertEquals(1.toULong(), long.toULong() shr 63)
+
+                val bBits = b.toBits()
+                val cBits = c.toBits()
+
+                assertEquals(((long and 0x7FFFFFFFFFFFFFFF) shr 32).toInt(), bBits)
+                assertEquals((long and 0xFFFFFFFF).toInt() , cBits)
+
+                val int1 = samplingMode._packedInt1()
+                val int2 = samplingMode._packedInt2()
+                assertEquals(long, (int1.toULong() shl 32 or int2.toULong()).toLong())
+            }
+        }
+    }
+}

skiko/src/jvmMain/cpp/common/Bitmap.cc

@@ -272,9 +272,9 @@ extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skia_BitmapKt__1nPeekPixel
 }
 
 extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skia_BitmapKt__1nMakeShader
-  (JNIEnv* env, jclass jclass, jlong ptr, jint tmx, jint tmy, jlong samplingMode, jfloatArray localMatrixArr) {
+  (JNIEnv* env, jclass jclass, jlong ptr, jint tmx, jint tmy, jint samplingModeVal1, jint samplingModeVal2, jfloatArray localMatrixArr) {
     SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
     std::unique_ptr<SkMatrix> localMatrix = skMatrix(env, localMatrixArr);
-    sk_sp<SkShader> shader = instance->makeShader(static_cast<SkTileMode>(tmx), static_cast<SkTileMode>(tmy), skija::SamplingMode::unpack(samplingMode), localMatrix.get());
+    sk_sp<SkShader> shader = instance->makeShader(static_cast<SkTileMode>(tmx), static_cast<SkTileMode>(tmy), skija::SamplingMode::unpackFrom2Ints(env, samplingModeVal1, samplingModeVal2), localMatrix.get());
     return reinterpret_cast<jlong>(shader.release());
 }

skiko/src/jvmMain/cpp/common/Canvas.cc

@@ -96,14 +96,14 @@ extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skia_CanvasKt__1nDrawPath
 }
 
 extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skia_CanvasKt__1nDrawImageRect
-  (JNIEnv* env, jclass jclass, jlong canvasPtr, jlong imagePtr, jfloat sl, jfloat st, jfloat sr, jfloat sb, jfloat dl, jfloat dt, jfloat dr, jfloat db, jlong samplingMode, jlong paintPtr, jboolean strict) {
+  (JNIEnv* env, jclass jclass, jlong canvasPtr, jlong imagePtr, jfloat sl, jfloat st, jfloat sr, jfloat sb, jfloat dl, jfloat dt, jfloat dr, jfloat db, jint samplingModeVal1, jint samplingModeVal2, jlong paintPtr, jboolean strict) {
     SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
     SkImage* image = reinterpret_cast<SkImage*>(static_cast<uintptr_t>(imagePtr));
     SkRect src {sl, st, sr, sb};
     SkRect dst {dl, dt, dr, db};
     SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
     SkCanvas::SrcRectConstraint constraint = strict ? SkCanvas::SrcRectConstraint::kStrict_SrcRectConstraint : SkCanvas::SrcRectConstraint::kFast_SrcRectConstraint;
-    canvas->drawImageRect(image, src, dst, skija::SamplingMode::unpack(samplingMode), paint, constraint);
+    canvas->drawImageRect(image, src, dst, skija::SamplingMode::unpackFrom2Ints(env, samplingModeVal1, samplingModeVal2), paint, constraint);
 }
 
 extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skia_CanvasKt__1nDrawImageNine

skiko/src/jvmMain/cpp/common/Image.cc

@@ -74,10 +74,10 @@ extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skia_ImageKt__1nEncodeToDa
 }
 
 extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skia_ImageKt_Image_1nMakeShader
-  (JNIEnv* env, jclass jclass, jlong ptr, jint tmx, jint tmy, jlong sampling, jfloatArray localMatrixArr) {
+  (JNIEnv* env, jclass jclass, jlong ptr, jint tmx, jint tmy, jint samplingVal1, jint samplingVal2, jfloatArray localMatrixArr) {
     SkImage* instance = reinterpret_cast<SkImage*>(static_cast<uintptr_t>(ptr));
     std::unique_ptr<SkMatrix> localMatrix = skMatrix(env, localMatrixArr);
-    sk_sp<SkShader> shader = instance->makeShader(static_cast<SkTileMode>(tmx), static_cast<SkTileMode>(tmy), skija::SamplingMode::unpack(sampling), localMatrix.get());
+    sk_sp<SkShader> shader = instance->makeShader(static_cast<SkTileMode>(tmx), static_cast<SkTileMode>(tmy), skija::SamplingMode::unpackFrom2Ints(env, samplingVal1, samplingVal2), localMatrix.get());
     return reinterpret_cast<jlong>(shader.release());
 }
 
@@ -119,9 +119,9 @@ extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skia_ImageKt__1nReadPix
 }
 
 extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skia_ImageKt__1nScalePixels
-  (JNIEnv* env, jclass jclass, jlong ptr, jlong pixmapPtr, jlong samplingOptions, jboolean cache) {
+  (JNIEnv* env, jclass jclass, jlong ptr, jlong pixmapPtr, jint samplingOptionsVal1, jint samplingOptionsVal2, jboolean cache) {
     SkImage* instance = reinterpret_cast<SkImage*>(static_cast<uintptr_t>(ptr));
     SkPixmap* pixmap = reinterpret_cast<SkPixmap*>(static_cast<uintptr_t>(pixmapPtr));
     auto cachingHint = cache ? SkImage::CachingHint::kAllow_CachingHint : SkImage::CachingHint::kDisallow_CachingHint;
-    return instance->scalePixels(*pixmap, skija::SamplingMode::unpack(samplingOptions), cachingHint);
+    return instance->scalePixels(*pixmap, skija::SamplingMode::unpackFrom2Ints(env, samplingOptionsVal1, samplingOptionsVal2), cachingHint);
 }

skiko/src/jvmMain/cpp/common/ImageFilter.cc

@@ -90,9 +90,9 @@ extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skia_ImageFilterKt__1nMake
 }
 
 extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skia_ImageFilterKt__1nMakeImage
-  (JNIEnv* env, jclass jclass, jlong imagePtr, jfloat l0, jfloat t0, jfloat r0, jfloat b0, jfloat l1, jfloat t1, jfloat r1, jfloat b1, jlong samplingMode) {
+  (JNIEnv* env, jclass jclass, jlong imagePtr, jfloat l0, jfloat t0, jfloat r0, jfloat b0, jfloat l1, jfloat t1, jfloat r1, jfloat b1, jint samplingModeVal1, jint samplingModeVal2) {
     SkImage* image = reinterpret_cast<SkImage*>(static_cast<uintptr_t>(imagePtr));
-    SkImageFilter* ptr = SkImageFilters::Image(sk_ref_sp(image), SkRect{l0, t0, r0, b0}, SkRect{l1, t1, r1, b1}, skija::SamplingMode::unpack(samplingMode)).release();
+    SkImageFilter* ptr = SkImageFilters::Image(sk_ref_sp(image), SkRect{l0, t0, r0, b0}, SkRect{l1, t1, r1, b1}, skija::SamplingMode::unpackFrom2Ints(env, samplingModeVal1, samplingModeVal2)).release();
     return reinterpret_cast<jlong>(ptr);
 }
 
@@ -116,10 +116,10 @@ extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skia_ImageFilterKt__1nMake
 }
 
 extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skia_ImageFilterKt__1nMakeMatrixTransform
-  (JNIEnv* env, jclass jclass, jfloatArray matrixArray, jlong samplingMode, jlong inputPtr) {
+  (JNIEnv* env, jclass jclass, jfloatArray matrixArray, jint samplingModeVal1, jint samplingModeVal2, jlong inputPtr) {
     std::unique_ptr<SkMatrix> matrix = skMatrix(env, matrixArray);
     SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
-    SkImageFilter* ptr = SkImageFilters::MatrixTransform(*matrix, skija::SamplingMode::unpack(samplingMode), sk_ref_sp(input)).release();
+    SkImageFilter* ptr = SkImageFilters::MatrixTransform(*matrix, skija::SamplingMode::unpackFrom2Ints(env, samplingModeVal1, samplingModeVal2), sk_ref_sp(input)).release();
     return reinterpret_cast<jlong>(ptr);
 }
 

skiko/src/jvmMain/cpp/common/Pixmap.cc

@@ -161,10 +161,10 @@ extern "C" {
     }
 
     JNIEXPORT jboolean JNICALL Java_org_jetbrains_skia_PixmapKt__1nScalePixels
-      (JNIEnv *env, jclass klass, jlong ptr, jlong dstPixmapPtr, jlong samplingOptions) {
+      (JNIEnv *env, jclass klass, jlong ptr, jlong dstPixmapPtr, jint samplingOptionsVal1, jint samplingOptionsVal2) {
         SkPixmap* pixmap = jlongToPtr<SkPixmap*>(ptr);
         SkPixmap* dstPixmap = jlongToPtr<SkPixmap*>(dstPixmapPtr);
-        return static_cast<jboolean>(pixmap->scalePixels(*dstPixmap, skija::SamplingMode::unpack(samplingOptions)));
+        return static_cast<jboolean>(pixmap->scalePixels(*dstPixmap, skija::SamplingMode::unpackFrom2Ints(env, samplingOptionsVal1, samplingOptionsVal2)));
     }
 
     JNIEXPORT jboolean JNICALL Java_org_jetbrains_skia_PixmapKt__1nErase

skiko/src/jvmMain/cpp/common/interop.cc

@@ -1066,6 +1066,20 @@ namespace skija {
                 return SkSamplingOptions(static_cast<SkFilterMode>(filter), static_cast<SkMipmapMode>(mipmap));
             }
         }
+
+        SkSamplingOptions unpackFrom2Ints(JNIEnv* env, jint samplingModeVal1, jint samplingModeVal2) {
+            if (0x80000000 & samplingModeVal1) {
+                uint64_t val1 = samplingModeVal1 & 0x7FFFFFFF;
+                uint64_t val = (val1 << 32) | samplingModeVal2;
+
+                float* ptr = reinterpret_cast<float*>(&val);
+                return SkSamplingOptions(SkCubicResampler {ptr[1], ptr[0]});
+            } else {
+                int32_t filter = samplingModeVal1;
+                int32_t mipmap = samplingModeVal2;
+                return SkSamplingOptions(static_cast<SkFilterMode>(filter), static_cast<SkMipmapMode>(mipmap));
+            }
+        }
     }
 }
 

skiko/src/jvmMain/cpp/common/interop.hh

@@ -299,6 +299,7 @@ namespace skija {
 
     namespace SamplingMode {
             SkSamplingOptions unpack(jlong val);
+            SkSamplingOptions unpackFrom2Ints(JNIEnv* env, jint val1, jint val2);
         }
 
     class UtfIndicesConverter {

skiko/src/nativeJsMain/cpp/Bitmap.cc

@@ -290,13 +290,13 @@ SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Bitmap__1nPeekPixels
 }
 
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_Bitmap__1nMakeShader
-  (KNativePointer ptr, KInt tmx, KInt tmy, KLong samplingMode, KFloat* localMatrixArr) {
+  (KNativePointer ptr, KInt tmx, KInt tmy, KInt samplingModeValue1, KInt samplingModeValue2, KFloat* localMatrixArr) {
     SkBitmap* instance = reinterpret_cast<SkBitmap*>(ptr);
     std::unique_ptr<SkMatrix> localMatrix = skMatrix(localMatrixArr);
     sk_sp<SkShader> shader = instance->makeShader(
         static_cast<SkTileMode>(tmx),
         static_cast<SkTileMode>(tmy),
-        skija::SamplingMode::unpack(samplingMode),
+        skija::SamplingMode::unpackFrom2Ints(samplingModeValue1, samplingModeValue2),
         localMatrix.get()
     );
     return reinterpret_cast<KNativePointer>(shader.release());

skiko/src/nativeJsMain/cpp/Canvas.cc

@@ -96,14 +96,14 @@ SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawPath
 }
 
 SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawImageRect
-  (KNativePointer canvasPtr, KNativePointer imagePtr, KFloat sl, KFloat st, KFloat sr, KFloat sb, KFloat dl, KFloat dt, KFloat dr, KFloat db, KInt samplingMode, KNativePointer paintPtr, KBoolean strict) {
+  (KNativePointer canvasPtr, KNativePointer imagePtr, KFloat sl, KFloat st, KFloat sr, KFloat sb, KFloat dl, KFloat dt, KFloat dr, KFloat db, KInt samplingModeVal1, KInt samplingModeVal2, KNativePointer paintPtr, KBoolean strict) {
     SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
     SkImage* image = reinterpret_cast<SkImage*>((imagePtr));
     SkRect src {sl, st, sr, sb};
     SkRect dst {dl, dt, dr, db};
     SkPaint* paint = reinterpret_cast<SkPaint*>((paintPtr));
     SkCanvas::SrcRectConstraint constraint = strict ? SkCanvas::SrcRectConstraint::kStrict_SrcRectConstraint : SkCanvas::SrcRectConstraint::kFast_SrcRectConstraint;
-    canvas->drawImageRect(image, src, dst, skija::SamplingMode::unpack(samplingMode), paint, constraint);
+    canvas->drawImageRect(image, src, dst, skija::SamplingMode::unpackFrom2Ints(samplingModeVal1, samplingModeVal2), paint, constraint);
 }
 
 SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawImageNine

skiko/src/nativeJsMain/cpp/Image.cc

@@ -72,13 +72,13 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_Image__1nEncodeToData
 
 
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_Image__1nMakeShader
-  (KNativePointer ptr, KInt tmx, KInt tmy, KLong samplingMode, KFloat* localMatrixArr) {
+  (KNativePointer ptr, KInt tmx, KInt tmy, KInt samplingModeVal1, KInt samplingModeVal2, KFloat* localMatrixArr) {
     SkImage* instance = reinterpret_cast<SkImage*>(ptr);
     std::unique_ptr<SkMatrix> localMatrix = skMatrix(localMatrixArr);
     sk_sp<SkShader> shader = instance->makeShader(
         static_cast<SkTileMode>(tmx),
         static_cast<SkTileMode>(tmy),
-        skija::SamplingMode::unpack(samplingMode),
+        skija::SamplingMode::unpackFrom2Ints(samplingModeVal1, samplingModeVal2),
         localMatrix.get()
     );
     return reinterpret_cast<KNativePointer>(shader.release());
@@ -121,9 +121,9 @@ SKIKO_EXPORT KBoolean org_jetbrains_skia_Image__1nReadPixelsPixmap
 }
 
 SKIKO_EXPORT KBoolean org_jetbrains_skia_Image__1nScalePixels
-  (KNativePointer ptr, KNativePointer pixmapPtr, KLong samplingOptions, KBoolean cache) {
+  (KNativePointer ptr, KNativePointer pixmapPtr, KInt samplingOptionsVal1, KInt samplingOptionsVal2, KBoolean cache) {
     SkImage* instance = reinterpret_cast<SkImage*>((ptr));
     SkPixmap* pixmap = reinterpret_cast<SkPixmap*>((pixmapPtr));
     auto cachingHint = cache ? SkImage::CachingHint::kAllow_CachingHint : SkImage::CachingHint::kDisallow_CachingHint;
-    return instance->scalePixels(*pixmap, skija::SamplingMode::unpack(samplingOptions), cachingHint);
+    return instance->scalePixels(*pixmap, skija::SamplingMode::unpackFrom2Ints(samplingOptionsVal1, samplingOptionsVal2), cachingHint);
 }

skiko/src/nativeJsMain/cpp/ImageFilter.cc

@@ -163,9 +163,9 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDropShadowOnly
 
 
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeImage
-  (KNativePointer imagePtr, KFloat l0, KFloat t0, KFloat r0, KFloat b0, KFloat l1, KFloat t1, KFloat r1, KFloat b1, KLong samplingMode) {
+  (KNativePointer imagePtr, KFloat l0, KFloat t0, KFloat r0, KFloat b0, KFloat l1, KFloat t1, KFloat r1, KFloat b1, KInt samplingModeVal1, KInt samplingModeVal2) {
     SkImage* image = reinterpret_cast<SkImage*>((imagePtr));
-    SkImageFilter* ptr = SkImageFilters::Image(sk_ref_sp(image), SkRect{l0, t0, r0, b0}, SkRect{l1, t1, r1, b1}, skija::SamplingMode::unpack(samplingMode)).release();
+    SkImageFilter* ptr = SkImageFilters::Image(sk_ref_sp(image), SkRect{l0, t0, r0, b0}, SkRect{l1, t1, r1, b1}, skija::SamplingMode::unpackFrom2Ints(samplingModeVal1, samplingModeVal2)).release();
     return reinterpret_cast<KNativePointer>(ptr);
 }
 
@@ -208,16 +208,16 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeMatrixConvolut
 
 
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeMatrixTransform
-  (KFloat* matrixArray, KNativePointer samplingMode, KNativePointer inputPtr) {
+  (KFloat* matrixArray, KInt samplingModeVal1, KInt samplingModeVal2, KNativePointer inputPtr) {
     TODO("implement org_jetbrains_skia_ImageFilter__1nMakeMatrixTransform");
 }
 
 #if 0
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeMatrixTransform
-  (KFloat* matrixArray, KNativePointer samplingMode, KNativePointer inputPtr) {
+  (KFloat* matrixArray, KInt samplingModeVal1, KInt samplingModeVal2, KNativePointer inputPtr) {
     std::unique_ptr<SkMatrix> matrix = skMatrix(env, matrixArray);
     SkImageFilter* input = reinterpret_cast<SkImageFilter*>((inputPtr));
-    SkImageFilter* ptr = SkImageFilters::MatrixTransform(*matrix, skija::SamplingMode::unpack(samplingMode), sk_ref_sp(input)).release();
+    SkImageFilter* ptr = SkImageFilters::MatrixTransform(*matrix, skija::SamplingMode::unpackFrom2Ints(samplingModeVal1, samplingModeVal2), sk_ref_sp(input)).release();
     return reinterpret_cast<KNativePointer>(ptr);
 }
 #endif

skiko/src/nativeJsMain/cpp/Pixmap.cc

@@ -159,10 +159,10 @@ SKIKO_EXPORT KBoolean org_jetbrains_skia_Pixmap__1nReadPixelsToPixmapFromPoint
 }
 
 SKIKO_EXPORT KBoolean org_jetbrains_skia_Pixmap__1nScalePixels
-  (KNativePointer ptr, KNativePointer dstPixmapPtr, KLong samplingOptions) {
+  (KNativePointer ptr, KNativePointer dstPixmapPtr, KInt samplingOptionsVal1, KInt samplingOptionsVal2) {
     SkPixmap* pixmap = interopToPtr<SkPixmap*>(ptr);
     SkPixmap* dstPixmap = interopToPtr<SkPixmap*>(dstPixmapPtr);
-    return static_cast<KBoolean>(pixmap->scalePixels(*dstPixmap, skija::SamplingMode::unpack(samplingOptions)));
+    return static_cast<KBoolean>(pixmap->scalePixels(*dstPixmap, skija::SamplingMode::unpackFrom2Ints(samplingOptionsVal1, samplingOptionsVal2)));
 }
 
 SKIKO_EXPORT KBoolean org_jetbrains_skia_Pixmap__1nErase

skiko/src/nativeJsMain/cpp/common.h

@@ -31,6 +31,7 @@ KLong packISize(SkISize p);
 namespace skija {
     namespace SamplingMode {
         SkSamplingOptions unpack(KLong val);
+        SkSamplingOptions unpackFrom2Ints(KInt val1, KInt val2);
     }
 
     class UtfIndicesConverter {

skiko/src/nativeJsMain/cpp/common_interop.cc

@@ -29,6 +29,21 @@ namespace skija {
                 return SkSamplingOptions(static_cast<SkFilterMode>(filter), static_cast<SkMipmapMode>(mipmap));
             }
         }
+
+        SkSamplingOptions unpackFrom2Ints(KInt samplingModeVal1, KInt samplingModeVal2) {
+            if (0x80000000 & samplingModeVal1) {
+                uint64_t val1 = samplingModeVal1 & 0x7FFFFFFF;
+                uint64_t val = (val1 << 32) | samplingModeVal2;
+
+                float* ptr = reinterpret_cast<float*>(&val);
+                return SkSamplingOptions(SkCubicResampler {ptr[1], ptr[0]});
+            } else {
+                int32_t filter = samplingModeVal1;
+                int32_t mipmap = samplingModeVal2;
+
+                return SkSamplingOptions(static_cast<SkFilterMode>(filter), static_cast<SkMipmapMode>(mipmap));
+            }
+        }
     }
 }