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
@@ -25,4 +28,4 @@ class FilterMipmap constructor(
     override fun toString(): String {
         return "FilterMipmap(_filterMode=$filterMode, _mipmapMode=$mipmapMode)"
     }
-}
+}
\ No newline at end of file

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,12 +6,17 @@ 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)
         val MITCHELL: SamplingMode = CubicResampler(0.33333334f, 0.33333334f)
         val CATMULL_ROM: SamplingMode = CubicResampler(0f, 0.5f)
     }
-}
+}
\ No newline at end of file

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
@@ -165,14 +165,14 @@ extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skia_CanvasKt__1nDrawVertic
         static_cast<SkVertices::VertexMode>(verticesMode),
         env->GetArrayLength(positionsArr) / 2,
         reinterpret_cast<SkPoint*>(positions),
-        reinterpret_cast<SkPoint*>(texCoords), 
+        reinterpret_cast<SkPoint*>(texCoords),
         reinterpret_cast<SkColor*>(colors),
         indexCount,
         reinterpret_cast<const uint16_t *>(indices));
     SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
 
     canvas->drawVertices(vertices, static_cast<SkBlendMode>(blendMode), *paint);
-    
+
     if (texCoords != nullptr)
         env->ReleaseFloatArrayElements(texCoordsArr, texCoords, 0);
     if (colors != nullptr)
@@ -189,7 +189,7 @@ extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skia_CanvasKt__1nDrawPatch
     SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
 
     canvas->drawPatch(reinterpret_cast<SkPoint*>(cubics), reinterpret_cast<SkColor*>(colors), reinterpret_cast<SkPoint*>(texCoords), static_cast<SkBlendMode>(blendMode), *paint);
-    
+
     if (texCoords != nullptr)
         env->ReleaseFloatArrayElements(texCoordsArr, texCoords, 0);
     env->ReleaseIntArrayElements(colorsArr, colors, 0);
@@ -321,4 +321,4 @@ extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skia_CanvasKt__1nRestore(JN
 
 extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skia_CanvasKt__1nRestoreToCount(JNIEnv* env, jclass jclass, jlong ptr, jint saveCount) {
     reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(ptr))->restoreToCount(saveCount);
-}
+}
\ No newline at end of file

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);
 }
 
@@ -230,4 +230,4 @@ extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skia_ImageFilterKt__1nMake
     std::unique_ptr<SkIRect> crop = skija::IRect::toSkIRect(env, cropObj);
     SkImageFilter* ptr = SkImageFilters::SpotLitSpecular(SkPoint3{x0, y0, z0}, SkPoint3{x1, y1, z1}, falloffExponent, cutoffAngle, lightColor, surfaceScale, ks, shininess, sk_ref_sp(input), crop.get()).release();
     return reinterpret_cast<jlong>(ptr);
-}
+}
\ No newline at end of file

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
@@ -174,7 +174,7 @@ SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawVertices
         static_cast<SkVertices::VertexMode>(verticesMode),
         vertexCount,
         reinterpret_cast<SkPoint*>(positions),
-        reinterpret_cast<SkPoint*>(texCoords), 
+        reinterpret_cast<SkPoint*>(texCoords),
         reinterpret_cast<SkColor*>(colors),
         indexCount,
         reinterpret_cast<const uint16_t *>(indices));
@@ -189,8 +189,8 @@ SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawPatch
   (KNativePointer ptr, KFloat* cubicsArr, KInt* colorsArr, KFloat* texCoordsArr, KInt blendMode, KNativePointer paintPtr) {
     TODO("implement org_jetbrains_skia_Canvas__1nDrawPatch");
 }
-     
-#if 0 
+
+#if 0
 SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawPatch
   (KNativePointer ptr, KFloat* cubicsArr, KInt* colorsArr, KFloat* texCoordsArr, KInt blendMode, KNativePointer paintPtr) {
     SkCanvas* canvas = reinterpret_cast<SkCanvas*>   ((ptr));
@@ -200,7 +200,7 @@ SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawPatch
     SkPaint* paint = reinterpret_cast<SkPaint*>((paintPtr));
 
     canvas->drawPatch(reinterpret_cast<SkPoint*>(cubics), reinterpret_cast<SkColor*>(colors), reinterpret_cast<SkPoint*>(texCoords), static_cast<SkBlendMode>(blendMode), *paint);
-    
+
     if (texCoords != nullptr)
         env->ReleaseFloatArrayElements(texCoordsArr, texCoords, 0);
     env->ReleaseIntArrayElements(colorsArr, colors, 0);
@@ -214,8 +214,8 @@ SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawDrawable
   (KNativePointer ptr, KNativePointer drawablePtr, KFloat* matrixArr) {
     TODO("implement org_jetbrains_skia_Canvas__1nDrawDrawable");
 }
-     
-#if 0 
+
+#if 0
 SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawDrawable
   (KNativePointer ptr, KNativePointer drawablePtr, KFloat* matrixArr) {
     SkCanvas* canvas = reinterpret_cast<SkCanvas*>((ptr));
@@ -243,8 +243,8 @@ SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nSetMatrix
   (KNativePointer canvasPtr, KFloat* matrixArr) {
     TODO("implement org_jetbrains_skia_Canvas__1nSetMatrix");
 }
-     
-#if 0 
+
+#if 0
 SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nSetMatrix
   (KNativePointer canvasPtr, KFloat* matrixArr) {
     SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
@@ -265,7 +265,7 @@ SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Canvas__1nGetLocalToDevice
 (KNativePointer canvasPtr) {
     TODO("implement org_jetbrains_skia_Canvas__1nGetLocalToDevice");
 }
-     
+
 #if 0
 SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Canvas__1nGetLocalToDevice
 (KNativePointer canvasPtr) {

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

@@ -14,8 +14,8 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeAlphaThreshold
   (KNativePointer regionPtr, KFloat innerMin, KFloat outerMax, KNativePointer inputPtr, KInteropPointer cropObj) {
     TODO("implement org_jetbrains_skia_ImageFilter__1nMakeAlphaThreshold");
 }
-     
-#if 0 
+
+#if 0
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeAlphaThreshold
   (KNativePointer regionPtr, KFloat innerMin, KFloat outerMax, KNativePointer inputPtr, KInteropPointer cropObj) {
     SkRegion* region = reinterpret_cast<SkRegion*>((regionPtr));
@@ -32,8 +32,8 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeArithmetic
   (KFloat k1, KFloat k2, KFloat k3, KFloat k4, KBoolean enforcePMColor, KNativePointer bgPtr, KNativePointer fgPtr, KInteropPointer cropObj) {
     TODO("implement org_jetbrains_skia_ImageFilter__1nMakeArithmetic");
 }
-     
-#if 0 
+
+#if 0
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeArithmetic
   (KFloat k1, KFloat k2, KFloat k3, KFloat k4, KBoolean enforcePMColor, KNativePointer bgPtr, KNativePointer fgPtr, KInteropPointer cropObj) {
     SkImageFilter* bg = reinterpret_cast<SkImageFilter*>((bgPtr));
@@ -50,8 +50,8 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeBlend
   (KInt blendModeInt, KNativePointer bgPtr, KNativePointer fgPtr, KInteropPointer cropObj) {
     TODO("implement org_jetbrains_skia_ImageFilter__1nMakeBlend");
 }
-     
-#if 0 
+
+#if 0
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeBlend
   (KInt blendModeInt, KNativePointer bgPtr, KNativePointer fgPtr, KInteropPointer cropObj) {
     SkBlendMode blendMode = static_cast<SkBlendMode>(blendModeInt);
@@ -69,8 +69,8 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeBlur
   (KFloat sigmaX, KFloat sigmaY, KInt tileModeInt, KNativePointer inputPtr, KInteropPointer cropObj) {
     TODO("implement org_jetbrains_skia_ImageFilter__1nMakeBlur");
 }
-     
-#if 0 
+
+#if 0
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeBlur
   (KFloat sigmaX, KFloat sigmaY, KInt tileModeInt, KNativePointer inputPtr, KInteropPointer cropObj) {
     SkTileMode tileMode = static_cast<SkTileMode>(tileModeInt);
@@ -87,8 +87,8 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeColorFilter
   (KNativePointer colorFilterPtr, KNativePointer inputPtr, KInteropPointer cropObj) {
     TODO("implement org_jetbrains_skia_ImageFilter__1nMakeColorFilter");
 }
-     
-#if 0 
+
+#if 0
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeColorFilter
   (KNativePointer colorFilterPtr, KNativePointer inputPtr, KInteropPointer cropObj) {
     SkColorFilter* colorFilter = reinterpret_cast<SkColorFilter*>((colorFilterPtr));
@@ -113,8 +113,8 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDisplacementMa
   (KInt xChanInt, KInt yChanInt, KFloat scale, KNativePointer displacementPtr, KNativePointer colorPtr, KInteropPointer cropObj) {
     TODO("implement org_jetbrains_skia_ImageFilter__1nMakeDisplacementMap");
 }
-     
-#if 0 
+
+#if 0
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDisplacementMap
   (KInt xChanInt, KInt yChanInt, KFloat scale, KNativePointer displacementPtr, KNativePointer colorPtr, KInteropPointer cropObj) {
     SkColorChannel xChan = static_cast<SkColorChannel>(xChanInt);
@@ -133,8 +133,8 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDropShadow
   (KFloat dx, KFloat dy, KFloat sigmaX, KFloat sigmaY, KInt color, KNativePointer inputPtr, KInteropPointer cropObj) {
     TODO("implement org_jetbrains_skia_ImageFilter__1nMakeDropShadow");
 }
-     
-#if 0 
+
+#if 0
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDropShadow
   (KFloat dx, KFloat dy, KFloat sigmaX, KFloat sigmaY, KInt color, KNativePointer inputPtr, KInteropPointer cropObj) {
     SkImageFilter* input = reinterpret_cast<SkImageFilter*>((inputPtr));
@@ -150,8 +150,8 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDropShadowOnly
   (KFloat dx, KFloat dy, KFloat sigmaX, KFloat sigmaY, KInt color, KNativePointer inputPtr, KInteropPointer cropObj) {
     TODO("implement org_jetbrains_skia_ImageFilter__1nMakeDropShadowOnly");
 }
-     
-#if 0 
+
+#if 0
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDropShadowOnly
   (KFloat dx, KFloat dy, KFloat sigmaX, KFloat sigmaY, KInt color, KNativePointer inputPtr, KInteropPointer cropObj) {
     SkImageFilter* input = reinterpret_cast<SkImageFilter*>((inputPtr));
@@ -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);
 }
 
@@ -174,8 +174,8 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeMagnifier
   (KFloat l, KFloat t, KFloat r, KFloat b, KFloat inset, KNativePointer inputPtr, KInteropPointer cropObj) {
     TODO("implement org_jetbrains_skia_ImageFilter__1nMakeMagnifier");
 }
-     
-#if 0 
+
+#if 0
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeMagnifier
   (KFloat l, KFloat t, KFloat r, KFloat b, KFloat inset, KNativePointer inputPtr, KInteropPointer cropObj) {
     SkImageFilter* input = reinterpret_cast<SkImageFilter*>((inputPtr));
@@ -191,8 +191,8 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeMatrixConvolut
   (KInt kernelW, KInt kernelH, KFloat* kernelArray, KFloat gain, KFloat bias, KInt offsetX, KInt offsetY, KInt tileModeInt, KBoolean convolveAlpha, KNativePointer inputPtr, KInteropPointer cropObj) {
     TODO("implement org_jetbrains_skia_ImageFilter__1nMakeMatrixConvolution");
 }
-     
-#if 0 
+
+#if 0
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeMatrixConvolution
   (KInt kernelW, KInt kernelH, KFloat* kernelArray, KFloat gain, KFloat bias, KInt offsetX, KInt offsetY, KInt tileModeInt, KBoolean convolveAlpha, KNativePointer inputPtr, KInteropPointer cropObj) {
     KFloat* kernel = env->GetFloatArrayElements(kernelArray, 0);
@@ -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 
+
+#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
@@ -228,8 +228,8 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeMerge
   (KNativePointerArray filtersArray, KInteropPointer cropObj) {
     TODO("implement org_jetbrains_skia_ImageFilter__1nMakeMerge");
 }
-     
-#if 0 
+
+#if 0
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeMerge
   (KNativePointerArray filtersArray, KInteropPointer cropObj) {
     KNativePointer* f = env->GetLongArrayElements(filtersArray, 0);
@@ -252,8 +252,8 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeOffset
   (KFloat dx, KFloat dy, KNativePointer inputPtr, KInteropPointer cropObj) {
     TODO("implement org_jetbrains_skia_ImageFilter__1nMakeOffset");
 }
-     
-#if 0 
+
+#if 0
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeOffset
   (KFloat dx, KFloat dy, KNativePointer inputPtr, KInteropPointer cropObj) {
     SkImageFilter* input = reinterpret_cast<SkImageFilter*>((inputPtr));
@@ -269,8 +269,8 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakePaint
   (KNativePointer paintPtr, KInteropPointer cropObj) {
     TODO("implement org_jetbrains_skia_ImageFilter__1nMakePaint");
 }
-     
-#if 0 
+
+#if 0
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakePaint
   (KNativePointer paintPtr, KInteropPointer cropObj) {
     SkPaint* paint = reinterpret_cast<SkPaint*>((paintPtr));
@@ -300,8 +300,8 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDilate
   (float rx, KFloat ry, KNativePointer inputPtr, KInteropPointer cropObj) {
     TODO("implement org_jetbrains_skia_ImageFilter__1nMakeDilate");
 }
-     
-#if 0 
+
+#if 0
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDilate
   (float rx, KFloat ry, KNativePointer inputPtr, KInteropPointer cropObj) {
     SkImageFilter* input = reinterpret_cast<SkImageFilter*>((inputPtr));
@@ -317,8 +317,8 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeErode
   (float rx, KFloat ry, KNativePointer inputPtr, KInteropPointer cropObj) {
     TODO("implement org_jetbrains_skia_ImageFilter__1nMakeErode");
 }
-     
-#if 0 
+
+#if 0
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeErode
   (float rx, KFloat ry, KNativePointer inputPtr, KInteropPointer cropObj) {
     SkImageFilter* input = reinterpret_cast<SkImageFilter*>((inputPtr));
@@ -334,8 +334,8 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDistantLitDiff
   (KFloat x, KFloat y, KFloat z, KInt lightColor, KFloat surfaceScale, KFloat kd, KNativePointer inputPtr, KInteropPointer cropObj) {
     TODO("implement org_jetbrains_skia_ImageFilter__1nMakeDistantLitDiffuse");
 }
-     
-#if 0 
+
+#if 0
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDistantLitDiffuse
   (KFloat x, KFloat y, KFloat z, KInt lightColor, KFloat surfaceScale, KFloat kd, KNativePointer inputPtr, KInteropPointer cropObj) {
     SkImageFilter* input = reinterpret_cast<SkImageFilter*>((inputPtr));
@@ -351,8 +351,8 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakePointLitDiffus
   (KFloat x, KFloat y, KFloat z, KInt lightColor, KFloat surfaceScale, KFloat kd, KNativePointer inputPtr, KInteropPointer cropObj) {
     TODO("implement org_jetbrains_skia_ImageFilter__1nMakePointLitDiffuse");
 }
-     
-#if 0 
+
+#if 0
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakePointLitDiffuse
   (KFloat x, KFloat y, KFloat z, KInt lightColor, KFloat surfaceScale, KFloat kd, KNativePointer inputPtr, KInteropPointer cropObj) {
     SkImageFilter* input = reinterpret_cast<SkImageFilter*>((inputPtr));
@@ -368,8 +368,8 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeSpotLitDiffuse
   (KFloat x0, KFloat y0, KFloat z0, KFloat x1, KFloat y1, KFloat z1, KFloat falloffExponent, KFloat cutoffAngle, KInt lightColor, KFloat surfaceScale, KFloat kd, KNativePointer inputPtr, KInteropPointer cropObj) {
     TODO("implement org_jetbrains_skia_ImageFilter__1nMakeSpotLitDiffuse");
 }
-     
-#if 0 
+
+#if 0
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeSpotLitDiffuse
   (KFloat x0, KFloat y0, KFloat z0, KFloat x1, KFloat y1, KFloat z1, KFloat falloffExponent, KFloat cutoffAngle, KInt lightColor, KFloat surfaceScale, KFloat kd, KNativePointer inputPtr, KInteropPointer cropObj) {
     SkImageFilter* input = reinterpret_cast<SkImageFilter*>((inputPtr));
@@ -385,8 +385,8 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDistantLitSpec
   (KFloat x, KFloat y, KFloat z, KInt lightColor, KFloat surfaceScale, KFloat ks, KFloat shininess, KNativePointer inputPtr, KInteropPointer cropObj) {
     TODO("implement org_jetbrains_skia_ImageFilter__1nMakeDistantLitSpecular");
 }
-     
-#if 0 
+
+#if 0
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDistantLitSpecular
   (KFloat x, KFloat y, KFloat z, KInt lightColor, KFloat surfaceScale, KFloat ks, KFloat shininess, KNativePointer inputPtr, KInteropPointer cropObj) {
     SkImageFilter* input = reinterpret_cast<SkImageFilter*>((inputPtr));
@@ -402,8 +402,8 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakePointLitSpecul
   (KFloat x, KFloat y, KFloat z, KInt lightColor, KFloat surfaceScale, KFloat ks, KFloat shininess, KNativePointer inputPtr, KInteropPointer cropObj) {
     TODO("implement org_jetbrains_skia_ImageFilter__1nMakePointLitSpecular");
 }
-     
-#if 0 
+
+#if 0
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakePointLitSpecular
   (KFloat x, KFloat y, KFloat z, KInt lightColor, KFloat surfaceScale, KFloat ks, KFloat shininess, KNativePointer inputPtr, KInteropPointer cropObj) {
     SkImageFilter* input = reinterpret_cast<SkImageFilter*>((inputPtr));
@@ -419,8 +419,8 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeSpotLitSpecula
   (KFloat x0, KFloat y0, KFloat z0, KFloat x1, KFloat y1, KFloat z1, KFloat falloffExponent, KFloat cutoffAngle, KInt lightColor, KFloat surfaceScale, KFloat ks, KFloat shininess, KNativePointer inputPtr, KInteropPointer cropObj) {
     TODO("implement org_jetbrains_skia_ImageFilter__1nMakeSpotLitSpecular");
 }
-     
-#if 0 
+
+#if 0
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeSpotLitSpecular
   (KFloat x0, KFloat y0, KFloat z0, KFloat x1, KFloat y1, KFloat z1, KFloat falloffExponent, KFloat cutoffAngle, KInt lightColor, KFloat surfaceScale, KFloat ks, KFloat shininess, KNativePointer inputPtr, KInteropPointer cropObj) {
     SkImageFilter* input = reinterpret_cast<SkImageFilter*>((inputPtr));

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));
+            }
+        }
     }
 }