interopScope {} for all functions receiving primitive arrays (#195)

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

 @file:Suppress("NESTED_EXTERNAL_DECLARATION")
 package org.jetbrains.skia
 
+import org.jetbrains.skia.impl.*
 import org.jetbrains.skia.impl.Library.Companion.staticLoad
-import org.jetbrains.skia.impl.Managed
-import org.jetbrains.skia.impl.Stats
-import org.jetbrains.skia.impl.reachabilityBarrier
-import org.jetbrains.skia.impl.NativePointer
-import org.jetbrains.skia.impl.getPtr
 
 class Bitmap internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerHolder.PTR), IHasImageInfo {
     companion object {
@@ -564,16 +560,18 @@ class Bitmap internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerH
         return try {
             _imageInfo = null
             Stats.onNativeCall()
-            _nInstallPixels(
-                _ptr,
-                info.width,
-                info.height,
-                info.colorInfo.colorType.ordinal,
-                info.colorInfo.alphaType.ordinal,
-                getPtr(info.colorInfo.colorSpace),
-                pixels,
-                rowBytes
-            )
+            interopScope {
+                _nInstallPixels(
+                    _ptr,
+                    info.width,
+                    info.height,
+                    info.colorInfo.colorType.ordinal,
+                    info.colorInfo.alphaType.ordinal,
+                    getPtr(info.colorInfo.colorSpace),
+                    toInterop(pixels),
+                    rowBytes
+                )
+            }
         } finally {
             reachabilityBarrier(this)
             reachabilityBarrier(info.colorInfo.colorSpace)
@@ -1004,13 +1002,15 @@ class Bitmap internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerH
             require(sampling != null) { "Can’t Bitmap.makeShader with sampling == null" }
             Stats.onNativeCall()
             Shader(
-                _nMakeShader(
-                    _ptr,
-                    tmx.ordinal,
-                    tmy.ordinal,
-                    sampling._pack(),
-                    localMatrix?.mat
-                )
+                interopScope {
+                    _nMakeShader(
+                        _ptr,
+                        tmx.ordinal,
+                        tmy.ordinal,
+                        sampling._pack(),
+                        toInterop(localMatrix?.mat)
+                    )
+                }
             )
         } finally {
             reachabilityBarrier(this)
@@ -1118,7 +1118,7 @@ private external fun _nInstallPixels(
     colorType: Int,
     alphaType: Int,
     colorSpacePtr: NativePointer,
-    pixels: ByteArray?,
+    pixels: InteropPointer,
     rowBytes: Long
 ): Boolean
 
@@ -1180,4 +1180,4 @@ private external fun _nExtractAlpha(ptr: NativePointer, dstPtr: NativePointer, p
 private external fun _nPeekPixels(ptr: NativePointer): ByteBuffer?
 
 @ExternalSymbolName("org_jetbrains_skia_Bitmap__1nMakeShader")
-private external fun _nMakeShader(ptr: NativePointer, tmx: Int, tmy: Int, samplingMode: Long, localMatrix: FloatArray?): NativePointer
+private external fun _nMakeShader(ptr: NativePointer, tmx: Int, tmy: Int, samplingMode: Long, localMatrix: InteropPointer): NativePointer
\ No newline at end of file

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

@@ -2,8 +2,8 @@
 package org.jetbrains.skia
 
 import org.jetbrains.skia.ImageFilter.Companion.makeDropShadowOnly
-import org.jetbrains.skia.impl.Library.Companion.staticLoad
 import org.jetbrains.skia.impl.*
+import org.jetbrains.skia.impl.Library.Companion.staticLoad
 
 open class Canvas internal constructor(ptr: NativePointer, managed: Boolean, internal val _owner: Any) :
     Managed(ptr, _FinalizerHolder.PTR, managed) {
@@ -119,7 +119,9 @@ open class Canvas internal constructor(ptr: NativePointer, managed: Boolean, int
      */
     fun drawPoints(coords: FloatArray, paint: Paint): Canvas {
         Stats.onNativeCall()
-        _nDrawPoints(_ptr, 0 /* SkCanvas::PointMode::kPoints_PointMode */, coords, getPtr(paint))
+        interopScope {
+            _nDrawPoints(_ptr, 0 /* SkCanvas::PointMode::kPoints_PointMode */, toInterop(coords), getPtr(paint))
+        }
         reachabilityBarrier(paint)
         return this
     }
@@ -176,7 +178,9 @@ open class Canvas internal constructor(ptr: NativePointer, managed: Boolean, int
      */
     fun drawLines(coords: FloatArray, paint: Paint): Canvas {
         Stats.onNativeCall()
-        _nDrawPoints(_ptr, 1 /* SkCanvas::PointMode::kLines_PointMode */, coords, getPtr(paint))
+        interopScope {
+            _nDrawPoints(_ptr, 1 /* SkCanvas::PointMode::kLines_PointMode */, toInterop(coords), getPtr(paint))
+        }
         reachabilityBarrier(paint)
         return this
     }
@@ -231,7 +235,9 @@ open class Canvas internal constructor(ptr: NativePointer, managed: Boolean, int
      */
     fun drawPolygon(coords: FloatArray, paint: Paint): Canvas {
         Stats.onNativeCall()
-        _nDrawPoints(_ptr, 2 /* SkCanvas::PointMode::kPolygon_PointMode */, coords, getPtr(paint))
+        interopScope {
+            _nDrawPoints(_ptr, 2 /* SkCanvas::PointMode::kPolygon_PointMode */, toInterop(coords), getPtr(paint))
+        }
         reachabilityBarrier(paint)
         return this
     }
@@ -979,14 +985,16 @@ open class Canvas internal constructor(ptr: NativePointer, managed: Boolean, int
         require(colors.size == 4) { "Expected colors.length == 4, got: " + colors.size }
         require(texCoords == null || texCoords.size == 4) { "Expected texCoords.length == 4, got: " + texCoords!!.size }
         Stats.onNativeCall()
-        _nDrawPatch(
-            _ptr,
-            Point.flattenArray(cubics),
-            colors,
-            Point.flattenArray(texCoords),
-            mode.ordinal,
-            getPtr(paint)
-        )
+        interopScope {
+            _nDrawPatch(
+                _ptr,
+                toInterop(Point.flattenArray(cubics)),
+                toInterop(colors),
+                toInterop(Point.flattenArray(texCoords)),
+                mode.ordinal,
+                getPtr(paint)
+            )
+        }
         reachabilityBarrier(paint)
         return this
     }
@@ -1048,7 +1056,9 @@ open class Canvas internal constructor(ptr: NativePointer, managed: Boolean, int
      */
     fun drawDrawable(drawable: Drawable, matrix: Matrix33?): Canvas {
         Stats.onNativeCall()
-        _nDrawDrawable(_ptr, getPtr(drawable), matrix?.mat)
+        interopScope {
+            _nDrawDrawable(_ptr, getPtr(drawable), toInterop(matrix?.mat))
+        }
         reachabilityBarrier(drawable)
         return this
     }
@@ -1076,7 +1086,9 @@ open class Canvas internal constructor(ptr: NativePointer, managed: Boolean, int
      */
     fun setMatrix(matrix: Matrix33): Canvas {
         Stats.onNativeCall()
-        _nSetMatrix(_ptr, matrix.mat)
+        interopScope {
+            _nSetMatrix(_ptr, toInterop(matrix.mat))
+        }
         return this
     }
 
@@ -1451,7 +1463,7 @@ private external fun _nMakeFromBitmap(bitmapPtr: NativePointer, flags: Int, pixe
 private external fun _nDrawPoint(ptr: NativePointer, x: Float, y: Float, paintPtr: NativePointer)
 
 @ExternalSymbolName("org_jetbrains_skia_Canvas__1nDrawPoints")
-private external fun _nDrawPoints(ptr: NativePointer, mode: Int, coords: FloatArray?, paintPtr: NativePointer)
+private external fun _nDrawPoints(ptr: NativePointer, mode: Int, coords: InteropPointer, paintPtr: NativePointer)
 
 @ExternalSymbolName("org_jetbrains_skia_Canvas__1nDrawLine")
 private external fun _nDrawLine(ptr: NativePointer, x0: Float, y0: Float, x1: Float, y1: Float, paintPtr: NativePointer)
@@ -1575,16 +1587,16 @@ private external fun _nDrawVertices(
 @ExternalSymbolName("org_jetbrains_skia_Canvas__1nDrawPatch")
 private external fun _nDrawPatch(
     ptr: NativePointer,
-    cubics: FloatArray?,
-    colors: IntArray?,
-    texCoords: FloatArray?,
+    cubics: InteropPointer,
+    colors: InteropPointer,
+    texCoords: InteropPointer,
     blendMode: Int,
     paintPtr: NativePointer
 )
 
 
 @ExternalSymbolName("org_jetbrains_skia_Canvas__1nDrawDrawable")
-private external fun _nDrawDrawable(ptr: NativePointer, drawablePrt: NativePointer, matrix: FloatArray?)
+private external fun _nDrawDrawable(ptr: NativePointer, drawablePrt: NativePointer, matrix: InteropPointer)
 
 @ExternalSymbolName("org_jetbrains_skia_Canvas__1nClear")
 private external fun _nClear(ptr: NativePointer, color: Int)
@@ -1593,7 +1605,7 @@ private external fun _nClear(ptr: NativePointer, color: Int)
 private external fun _nDrawPaint(ptr: NativePointer, paintPtr: NativePointer)
 
 @ExternalSymbolName("org_jetbrains_skia_Canvas__1nSetMatrix")
-private external fun _nSetMatrix(ptr: NativePointer, matrix: FloatArray?)
+private external fun _nSetMatrix(ptr: NativePointer, matrix: InteropPointer)
 
 @ExternalSymbolName("org_jetbrains_skia_Canvas__1nGetLocalToDevice")
 private external fun _nGetLocalToDevice(ptr: NativePointer): FloatArray

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

@@ -28,12 +28,20 @@ class ColorFilter : RefCnt {
 
         fun makeMatrix(matrix: ColorMatrix): ColorFilter {
             Stats.onNativeCall()
-            return ColorFilter(_nMakeMatrix(matrix.mat))
+            return ColorFilter(
+                interopScope {
+                    _nMakeMatrix(toInterop(matrix.mat))
+                }
+            )
         }
 
         fun makeHSLAMatrix(matrix: ColorMatrix): ColorFilter {
             Stats.onNativeCall()
-            return ColorFilter(_nMakeHSLAMatrix(matrix.mat))
+            return ColorFilter(
+                interopScope {
+                    _nMakeHSLAMatrix(toInterop(matrix.mat))
+                }
+            )
         }
 
         fun makeLerp(dst: ColorFilter?, src: ColorFilter?, t: Float): ColorFilter {
@@ -61,7 +69,11 @@ class ColorFilter : RefCnt {
 
         fun makeTable(table: ByteArray): ColorFilter {
             require(table.size == 256) { "Expected 256 elements, got " + table.size }
-            return ColorFilter(_nMakeTable(table))
+            return ColorFilter(
+                interopScope {
+                    _nMakeTable(toInterop(table))
+                }
+            )
         }
 
         fun makeTableARGB(a: ByteArray?, r: ByteArray?, g: ByteArray?, b: ByteArray?): ColorFilter {
@@ -104,10 +116,10 @@ private external fun _nMakeComposed(outer: NativePointer, inner: NativePointer):
 private external fun _nMakeBlend(color: Int, blendMode: Int): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_ColorFilter__1nMakeMatrix")
-private external fun _nMakeMatrix(rowMajor: FloatArray?): NativePointer
+private external fun _nMakeMatrix(rowMajor: InteropPointer): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_ColorFilter__1nMakeHSLAMatrix")
-private external fun _nMakeHSLAMatrix(rowMajor: FloatArray?): NativePointer
+private external fun _nMakeHSLAMatrix(rowMajor: InteropPointer): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_ColorFilter__1nGetLinearToSRGBGamma")
 private external fun _nGetLinearToSRGBGamma(): NativePointer
@@ -125,7 +137,7 @@ private external fun _nMakeLighting(colorMul: Int, colorAdd: Int): NativePointer
 private external fun _nMakeHighContrast(grayscale: Boolean, inversionMode: Int, contrast: Float): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_ColorFilter__1nMakeTable")
-private external fun _nMakeTable(table: ByteArray?): NativePointer
+private external fun _nMakeTable(table: InteropPointer): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_ColorFilter__1nMakeOverdraw")
 private external fun _nMakeOverdraw(c0: Int, c1: Int, c2: Int, c3: Int, c4: Int, c5: Int): NativePointer

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

 @file:Suppress("NESTED_EXTERNAL_DECLARATION")
 package org.jetbrains.skia
 
+import org.jetbrains.skia.impl.*
 import org.jetbrains.skia.impl.Library.Companion.staticLoad
-import org.jetbrains.skia.impl.Managed
-import org.jetbrains.skia.impl.Native
-import org.jetbrains.skia.impl.NativePointer
-import org.jetbrains.skia.impl.Stats
-import org.jetbrains.skia.impl.getPtr
-import org.jetbrains.skia.impl.reachabilityBarrier
 
 /**
  * Data holds an immutable data buffer.
@@ -16,7 +11,11 @@ class Data internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerHol
     companion object {
         fun makeFromBytes(bytes: ByteArray, offset: Long = 0L, length: Long = bytes.size.toLong()): Data {
             Stats.onNativeCall()
-            return Data(_nMakeFromBytes(bytes, offset, length))
+            return Data(
+                interopScope {
+                    _nMakeFromBytes(toInterop(bytes), offset, length)
+                }
+            )
         }
 
         /**
@@ -128,7 +127,7 @@ private external fun _nEquals(ptr: NativePointer, otherPtr: NativePointer): Bool
 private external fun _nToByteBuffer(ptr: NativePointer): ByteBuffer
 
 @ExternalSymbolName("org_jetbrains_skia_Data__1nMakeFromBytes")
-private external fun _nMakeFromBytes(bytes: ByteArray?, offset: Long, length: Long): NativePointer
+private external fun _nMakeFromBytes(bytes: InteropPointer, offset: Long, length: Long): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_Data__1nMakeFromFileName")
 private external fun _nMakeFromFileName(path: String?): NativePointer

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

 @file:Suppress("NESTED_EXTERNAL_DECLARATION")
 package org.jetbrains.skia
 
+import org.jetbrains.skia.impl.*
 import org.jetbrains.skia.impl.Library.Companion.staticLoad
-import org.jetbrains.skia.impl.RefCnt
-import org.jetbrains.skia.impl.Stats
-import org.jetbrains.skia.impl.reachabilityBarrier
-import org.jetbrains.skia.impl.NativePointer
-import org.jetbrains.skia.impl.getPtr
 
 /**
  *
@@ -52,11 +48,13 @@ abstract class Drawable : RefCnt(Drawable_nMake()) {
     fun draw(canvas: Canvas?, matrix: Matrix33?): Drawable {
         return try {
             Stats.onNativeCall()
-            _nDraw(
-                _ptr,
-                getPtr(canvas),
-                matrix?.mat
-            )
+            interopScope {
+                _nDraw(
+                    _ptr,
+                    getPtr(canvas),
+                    toInterop(matrix?.mat)
+                )
+            }
             this
         } finally {
             reachabilityBarrier(canvas)
@@ -136,7 +134,7 @@ private external fun Drawable_nMake(): NativePointer
 private external fun Drawable_nGetGenerationId(ptr: NativePointer): Int
 
 @ExternalSymbolName("org_jetbrains_skia_Drawable__1nDraw")
-private external fun _nDraw(ptr: NativePointer, canvasPtr: NativePointer, matrix: FloatArray?)
+private external fun _nDraw(ptr: NativePointer, canvasPtr: NativePointer, matrix: InteropPointer)
 
 @ExternalSymbolName("org_jetbrains_skia_Drawable__1nMakePictureSnapshot")
 private external fun _nMakePictureSnapshot(ptr: NativePointer): NativePointer

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

 @file:Suppress("NESTED_EXTERNAL_DECLARATION")
 package org.jetbrains.skia
 
+import org.jetbrains.skia.impl.*
 import org.jetbrains.skia.impl.Library.Companion.staticLoad
-import org.jetbrains.skia.impl.RefCnt
-import org.jetbrains.skia.impl.Stats
-import org.jetbrains.skia.impl.reachabilityBarrier
-import org.jetbrains.skia.impl.NativePointer
-import org.jetbrains.skia.impl.getPtr
 
 class Image internal constructor(ptr: NativePointer) : RefCnt(ptr), IHasImageInfo {
     companion object {
@@ -34,15 +30,17 @@ class Image internal constructor(ptr: NativePointer) : RefCnt(ptr), IHasImageInf
         fun makeRaster(imageInfo: ImageInfo, bytes: ByteArray, rowBytes: NativePointer): Image {
             return try {
                 Stats.onNativeCall()
-                val ptr = _nMakeRaster(
-                    imageInfo.width,
-                    imageInfo.height,
-                    imageInfo.colorInfo.colorType.ordinal,
-                    imageInfo.colorInfo.alphaType.ordinal,
-                    getPtr(imageInfo.colorInfo.colorSpace),
-                    bytes,
-                    rowBytes
-                )
+                val ptr = interopScope {
+                    _nMakeRaster(
+                        imageInfo.width,
+                        imageInfo.height,
+                        imageInfo.colorInfo.colorType.ordinal,
+                        imageInfo.colorInfo.alphaType.ordinal,
+                        getPtr(imageInfo.colorInfo.colorSpace),
+                        toInterop(bytes),
+                        rowBytes
+                    )
+                }
                 if (ptr == NullPointer) throw RuntimeException("Failed to makeRaster $imageInfo $bytes $rowBytes")
                 Image(ptr)
             } finally {
@@ -136,7 +134,9 @@ class Image internal constructor(ptr: NativePointer) : RefCnt(ptr), IHasImageInf
 
         fun makeFromEncoded(bytes: ByteArray?): Image {
             Stats.onNativeCall()
-            val ptr = _nMakeFromEncoded(bytes)
+            val ptr = interopScope {
+                _nMakeFromEncoded(toInterop(bytes))
+            }
             require(ptr != NullPointer) { "Failed to Image::makeFromEncoded" }
             return Image(ptr)
         }
@@ -229,13 +229,15 @@ class Image internal constructor(ptr: NativePointer) : RefCnt(ptr), IHasImageInf
         return try {
             Stats.onNativeCall()
             Shader(
-                Image_nMakeShader(
-                    _ptr,
-                    tmx.ordinal,
-                    tmy.ordinal,
-                    sampling._pack(),
-                    localMatrix?.mat
-                )
+                interopScope {
+                    Image_nMakeShader(
+                        _ptr,
+                        tmx.ordinal,
+                        tmy.ordinal,
+                        sampling._pack(),
+                        toInterop(localMatrix?.mat)
+                    )
+                }
             )
         } finally {
             reachabilityBarrier(this)
@@ -370,7 +372,7 @@ class Image internal constructor(ptr: NativePointer) : RefCnt(ptr), IHasImageInf
 private external fun Image_nGetImageInfo(ptr: NativePointer): ImageInfo?
 
 @ExternalSymbolName("org_jetbrains_skia_Image__1nMakeShader")
-private external fun Image_nMakeShader(ptr: NativePointer, tmx: Int, tmy: Int, samplingMode: Long, localMatrix: FloatArray?): NativePointer
+private external fun Image_nMakeShader(ptr: NativePointer, tmx: Int, tmy: Int, samplingMode: Long, localMatrix: InteropPointer): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_Image__1nPeekPixels")
 private external fun Image_nPeekPixels(ptr: NativePointer): ByteBuffer?
@@ -382,7 +384,7 @@ private external fun _nMakeRaster(
     colorType: Int,
     alphaType: Int,
     colorSpacePtr: NativePointer,
-    pixels: ByteArray?,
+    pixels: InteropPointer,
     rowBytes: NativePointer
 ): NativePointer
 
@@ -406,7 +408,7 @@ private external fun _nMakeFromBitmap(bitmapPtr: NativePointer): NativePointer
 private external fun _nMakeFromPixmap(pixmapPtr: NativePointer): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_Image__1nMakeFromEncoded")
-private external fun _nMakeFromEncoded(bytes: ByteArray?): NativePointer
+private external fun _nMakeFromEncoded(bytes: InteropPointer): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_Image__1nEncodeToData")
 private external fun _nEncodeToData(ptr: NativePointer, format: Int, quality: Int): NativePointer

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

@@ -274,19 +274,21 @@ class ImageFilter internal constructor(ptr: NativePointer) : RefCnt(ptr) {
             return try {
                 Stats.onNativeCall()
                 ImageFilter(
-                    _nMakeMatrixConvolution(
-                        kernelW,
-                        kernelH,
-                        kernel,
-                        gain,
-                        bias,
-                        offsetX,
-                        offsetY,
-                        tileMode.ordinal,
-                        convolveAlpha,
-                        getPtr(input),
-                        crop
-                    )
+                    interopScope {
+                        _nMakeMatrixConvolution(
+                            kernelW,
+                            kernelH,
+                            toInterop(kernel),
+                            gain,
+                            bias,
+                            offsetX,
+                            offsetY,
+                            tileMode.ordinal,
+                            convolveAlpha,
+                            getPtr(input),
+                            crop
+                        )
+                    }
                 )
             } finally {
                 reachabilityBarrier(input)
@@ -297,11 +299,13 @@ class ImageFilter internal constructor(ptr: NativePointer) : RefCnt(ptr) {
             return try {
                 Stats.onNativeCall()
                 ImageFilter(
-                    _nMakeMatrixTransform(
-                        matrix.mat,
-                        mode._pack(),
-                        getPtr(input)
-                    )
+                    interopScope {
+                        _nMakeMatrixTransform(
+                            toInterop(matrix.mat),
+                            mode._pack(),
+                            getPtr(input)
+                        )
+                    }
                 )
             } finally {
                 reachabilityBarrier(input)
@@ -701,7 +705,7 @@ private external fun _nMakeMagnifier(
 private external fun _nMakeMatrixConvolution(
     kernelW: Int,
     kernelH: Int,
-    kernel: FloatArray?,
+    kernel: InteropPointer,
     gain: Float,
     bias: Float,
     offsetX: Int,
@@ -713,7 +717,7 @@ private external fun _nMakeMatrixConvolution(
 ): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_ImageFilter__1nMakeMatrixTransform")
-private external fun _nMakeMatrixTransform(matrix: FloatArray?, samplingMode: Long, input: NativePointer): NativePointer
+private external fun _nMakeMatrixTransform(matrix: InteropPointer, samplingMode: Long, 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/MaskFilter.kt

 @file:Suppress("NESTED_EXTERNAL_DECLARATION")
 package org.jetbrains.skia
 
+import org.jetbrains.skia.impl.*
 import org.jetbrains.skia.impl.Library.Companion.staticLoad
-import org.jetbrains.skia.impl.RefCnt
-import org.jetbrains.skia.impl.Stats
-import org.jetbrains.skia.impl.reachabilityBarrier
-import org.jetbrains.skia.impl.NativePointer
-import org.jetbrains.skia.impl.getPtr
 
 class MaskFilter internal constructor(ptr: NativePointer) : RefCnt(ptr) {
     companion object {
@@ -26,7 +22,11 @@ class MaskFilter internal constructor(ptr: NativePointer) : RefCnt(ptr) {
 
         fun makeTable(table: ByteArray?): MaskFilter {
             Stats.onNativeCall()
-            return MaskFilter(MaskFilter_nMakeTable(table))
+            return MaskFilter(
+                interopScope {
+                    MaskFilter_nMakeTable(toInterop(table))
+                }
+            )
         }
 
         fun makeGamma(gamma: Float): MaskFilter {
@@ -46,7 +46,7 @@ class MaskFilter internal constructor(ptr: NativePointer) : RefCnt(ptr) {
 }
 
 @ExternalSymbolName("org_jetbrains_skia_MaskFilter__1nMakeTable")
-private external fun MaskFilter_nMakeTable(table: ByteArray?): NativePointer
+private external fun MaskFilter_nMakeTable(table: InteropPointer): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_MaskFilter__1nMakeBlur")
 private external fun _nMakeBlur(mode: Int, sigma: Float, respectCTM: Boolean): NativePointer

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

@@ -193,7 +193,11 @@ class Path internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerHol
          */
         fun makeFromBytes(data: ByteArray?): Path {
             Stats.onNativeCall()
-            return Path(_nMakeFromBytes(data))
+            return Path(
+                interopScope {
+                    _nMakeFromBytes(toInterop(data))
+                }
+            )
         }
 
         init {
@@ -640,7 +644,9 @@ class Path internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerHol
             require(if (verbs == null) max == 0 else true)
             Stats.onNativeCall()
             val out = if (verbs == null) null else ByteArray(max)
-            val count = _nGetVerbs(_ptr, out, max)
+            val count = interopScope {
+                _nGetVerbs(_ptr, toInterop(out), max)
+            }
             if (verbs != null) for (i in 0 until minOf(count, max)) verbs[i] = PathVerb.values().get(
                 out!![i].toInt()
             )
@@ -1668,7 +1674,9 @@ class Path internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerHol
     fun addPoly(pts: FloatArray, close: Boolean): Path {
         require(pts.size % 2 == 0) { "Expected even amount of pts, got " + pts.size }
         Stats.onNativeCall()
-        _nAddPoly(_ptr, pts, close)
+        interopScope {
+            _nAddPoly(_ptr, toInterop(pts), close)
+        }
         return this
     }
     /**
@@ -1782,12 +1790,14 @@ class Path internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerHol
     fun addPath(src: Path?, matrix: Matrix33, extend: Boolean = false): Path {
         return try {
             Stats.onNativeCall()
-            _nAddPathTransform(
-                _ptr,
-                getPtr(src),
-                matrix.mat,
-                extend
-            )
+            interopScope {
+                _nAddPathTransform(
+                    _ptr,
+                    getPtr(src),
+                    toInterop(matrix.mat),
+                    extend
+                )
+            }
             this
         } finally {
             reachabilityBarrier(src)
@@ -1888,12 +1898,14 @@ class Path internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerHol
     fun transform(matrix: Matrix33, dst: Path? = null, applyPerspectiveClip: Boolean = true): Path {
         return try {
             Stats.onNativeCall()
-            _nTransform(
-                _ptr,
-                matrix.mat,
-                getPtr(dst),
-                applyPerspectiveClip
-            )
+            interopScope {
+                _nTransform(
+                    _ptr,
+                    toInterop(matrix.mat),
+                    getPtr(dst),
+                    applyPerspectiveClip
+                )
+            }
             this
         } finally {
             reachabilityBarrier(dst)
@@ -2220,7 +2232,7 @@ private external fun _nGetPoints(ptr: NativePointer, points: Array<Point?>?, max
 private external fun _nCountVerbs(ptr: NativePointer): Int
 
 @ExternalSymbolName("org_jetbrains_skia_Path__1nGetVerbs")
-private external fun _nGetVerbs(ptr: NativePointer, verbs: ByteArray?, max: Int): Int
+private external fun _nGetVerbs(ptr: NativePointer, verbs: InteropPointer, max: Int): Int
 
 @ExternalSymbolName("org_jetbrains_skia_Path__1nApproximateBytesUsed")
 private external fun _nApproximateBytesUsed(ptr: NativePointer): NativePointer
@@ -2358,7 +2370,7 @@ private external fun _nAddRRect(
 
 
 @ExternalSymbolName("org_jetbrains_skia_Path__1nAddPoly")
-private external fun _nAddPoly(ptr: NativePointer, coords: FloatArray?, close: Boolean)
+private external fun _nAddPoly(ptr: NativePointer, coords: InteropPointer, close: Boolean)
 
 @ExternalSymbolName("org_jetbrains_skia_Path__1nAddPath")
 private external fun _nAddPath(ptr: NativePointer, srcPtr: NativePointer, extend: Boolean)
@@ -2367,7 +2379,7 @@ private external fun _nAddPath(ptr: NativePointer, srcPtr: NativePointer, extend
 private external fun _nAddPathOffset(ptr: NativePointer, srcPtr: NativePointer, dx: Float, dy: Float, extend: Boolean)
 
 @ExternalSymbolName("org_jetbrains_skia_Path__1nAddPathTransform")
-private external fun _nAddPathTransform(ptr: NativePointer, srcPtr: NativePointer, matrix: FloatArray?, extend: Boolean)
+private external fun _nAddPathTransform(ptr: NativePointer, srcPtr: NativePointer, matrix: InteropPointer, extend: Boolean)
 
 @ExternalSymbolName("org_jetbrains_skia_Path__1nReverseAddPath")
 private external fun _nReverseAddPath(ptr: NativePointer, srcPtr: NativePointer)
@@ -2376,7 +2388,7 @@ private external fun _nReverseAddPath(ptr: NativePointer, srcPtr: NativePointer)
 private external fun _nOffset(ptr: NativePointer, dx: Float, dy: Float, dst: NativePointer)
 
 @ExternalSymbolName("org_jetbrains_skia_Path__1nTransform")
-private external fun _nTransform(ptr: NativePointer, matrix: FloatArray?, dst: NativePointer, applyPerspectiveClip: Boolean)
+private external fun _nTransform(ptr: NativePointer, matrix: InteropPointer, dst: NativePointer, applyPerspectiveClip: Boolean)
 
 @ExternalSymbolName("org_jetbrains_skia_Path__1nGetLastPt")
 private external fun _nGetLastPt(ptr: NativePointer): Point
@@ -2403,7 +2415,7 @@ private external fun _nSerializeToBytes(ptr: NativePointer): ByteArray
 private external fun _nMakeCombining(onePtr: NativePointer, twoPtr: NativePointer, op: Int): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_Path__1nMakeFromBytes")
-private external fun _nMakeFromBytes(data: ByteArray?): NativePointer
+private external fun _nMakeFromBytes(data: InteropPointer): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_Path__1nIsValid")
 private external fun _nIsValid(ptr: NativePointer): Boolean
\ No newline at end of file

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

 @file:Suppress("NESTED_EXTERNAL_DECLARATION")
 package org.jetbrains.skia
 
+import org.jetbrains.skia.impl.*
 import org.jetbrains.skia.impl.Library.Companion.staticLoad
-import org.jetbrains.skia.impl.RefCnt
-import org.jetbrains.skia.impl.Stats
-import org.jetbrains.skia.impl.reachabilityBarrier
-import org.jetbrains.skia.impl.NativePointer
-import org.jetbrains.skia.impl.getPtr
 
 class PathEffect internal constructor(ptr: NativePointer) : RefCnt(ptr) {
     companion object {
@@ -30,10 +26,12 @@ class PathEffect internal constructor(ptr: NativePointer) : RefCnt(ptr) {
             return try {
                 Stats.onNativeCall()
                 PathEffect(
-                    _nMakePath2D(
-                        matrix.mat,
-                        getPtr(path)
-                    )
+                    interopScope {
+                        _nMakePath2D(
+                            toInterop(matrix.mat),
+                            getPtr(path)
+                        )
+                    }
                 )
             } finally {
                 reachabilityBarrier(path)
@@ -42,7 +40,11 @@ class PathEffect internal constructor(ptr: NativePointer) : RefCnt(ptr) {
 
         fun makeLine2D(width: Float, matrix: Matrix33): PathEffect {
             Stats.onNativeCall()
-            return PathEffect(_nMakeLine2D(width, matrix.mat))
+            return PathEffect(
+                interopScope {
+                    _nMakeLine2D(width, toInterop(matrix.mat))
+                }
+            )
         }
 
         fun makeCorner(radius: Float): PathEffect {
@@ -52,7 +54,11 @@ class PathEffect internal constructor(ptr: NativePointer) : RefCnt(ptr) {
 
         fun makeDash(intervals: FloatArray?, phase: Float): PathEffect {
             Stats.onNativeCall()
-            return PathEffect(_nMakeDash(intervals, phase))
+            return PathEffect(
+                interopScope {
+                    _nMakeDash(toInterop(intervals), phase)
+                }
+            )
         }
 
         fun makeDiscrete(segLength: Float, dev: Float, seed: Int): PathEffect {
@@ -107,16 +113,16 @@ private external fun _nMakeSum(firstPtr: NativePointer, secondPtr: NativePointer
 private external fun _nMakePath1D(pathPtr: NativePointer, advance: Float, phase: Float, style: Int): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_PathEffect__1nMakePath2D")
-private external fun _nMakePath2D(matrix: FloatArray?, pathPtr: NativePointer): NativePointer
+private external fun _nMakePath2D(matrix: InteropPointer, pathPtr: NativePointer): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_PathEffect__1nMakeLine2D")
-private external fun _nMakeLine2D(width: Float, matrix: FloatArray?): NativePointer
+private external fun _nMakeLine2D(width: Float, matrix: InteropPointer): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_PathEffect__1nMakeCorner")
 private external fun _nMakeCorner(radius: Float): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_PathEffect__1nMakeDash")
-private external fun _nMakeDash(intervals: FloatArray?, phase: Float): NativePointer
+private external fun _nMakeDash(intervals: InteropPointer, phase: Float): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_PathEffect__1nMakeDiscrete")
 private external fun _nMakeDiscrete(segLength: Float, dev: Float, seed: Int): NativePointer

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

 @file:Suppress("NESTED_EXTERNAL_DECLARATION")
 package org.jetbrains.skia
 
+import org.jetbrains.skia.impl.*
 import org.jetbrains.skia.impl.Library.Companion.staticLoad
-import org.jetbrains.skia.impl.RefCnt
-import org.jetbrains.skia.impl.Stats
-import org.jetbrains.skia.impl.reachabilityBarrier
-import org.jetbrains.skia.impl.NativePointer
-import org.jetbrains.skia.impl.getPtr
 
 class Picture internal constructor(ptr: NativePointer) : RefCnt(ptr) {
     companion object {
@@ -212,7 +208,11 @@ class Picture internal constructor(ptr: NativePointer) : RefCnt(ptr) {
         return try {
             Stats.onNativeCall()
             val arr = localMatrix?.mat
-            Shader(_nMakeShader(_ptr, tmx.ordinal, tmy.ordinal, mode.ordinal, arr, tileRect))
+            Shader(
+                interopScope {
+                    _nMakeShader(_ptr, tmx.ordinal, tmy.ordinal, mode.ordinal, toInterop(arr), tileRect)
+                }
+            )
         } finally {
             reachabilityBarrier(this)
         }
@@ -250,6 +250,6 @@ private external fun _nMakeShader(
     tmx: Int,
     tmy: Int,
     filterMode: Int,
-    localMatrix: FloatArray?,
+    localMatrix: InteropPointer,
     tileRect: Rect?
 ): NativePointer

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

@@ -2,12 +2,8 @@
 
 package org.jetbrains.skia
 
+import org.jetbrains.skia.impl.*
 import org.jetbrains.skia.impl.Library.Companion.staticLoad
-import org.jetbrains.skia.impl.Managed
-import org.jetbrains.skia.impl.NativePointer
-import org.jetbrains.skia.impl.Stats
-import org.jetbrains.skia.impl.getPtr
-import org.jetbrains.skia.impl.reachabilityBarrier
 
 class Region : Managed(Region_nMake(), _FinalizerHolder.PTR) {
     companion object {
@@ -113,7 +109,9 @@ class Region : Managed(Region_nMake(), _FinalizerHolder.PTR) {
                 arr[i * 4 + 3] = rects[i].bottom
             }
             Stats.onNativeCall()
-            _nSetRects(_ptr, arr)
+            interopScope {
+                _nSetRects(_ptr, toInterop(arr))
+            }
         } finally {
             reachabilityBarrier(this)
         }
@@ -360,7 +358,7 @@ private external fun _nSetEmpty(ptr: NativePointer): Boolean
 private external fun _nSetRect(ptr: NativePointer, left: Int, top: Int, right: Int, bottom: Int): Boolean
 
 @ExternalSymbolName("org_jetbrains_skia_Region__1nSetRects")
-private external fun _nSetRects(ptr: NativePointer, rects: IntArray?): Boolean
+private external fun _nSetRects(ptr: NativePointer, rects: InteropPointer): Boolean
 
 @ExternalSymbolName("org_jetbrains_skia_Region__1nSetRegion")
 private external fun _nSetRegion(ptr: NativePointer, regionPtr: NativePointer): Boolean

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

 @file:Suppress("NESTED_EXTERNAL_DECLARATION")
 package org.jetbrains.skia
 
+import org.jetbrains.skia.impl.*
 import org.jetbrains.skia.impl.Library.Companion.staticLoad
-import org.jetbrains.skia.impl.RefCnt
-import org.jetbrains.skia.impl.Stats
-import org.jetbrains.skia.impl.reachabilityBarrier
-import org.jetbrains.skia.impl.NativePointer
-import org.jetbrains.skia.impl.getPtr
 
 class Shader internal constructor(ptr: NativePointer) : RefCnt(ptr) {
     companion object {
@@ -41,17 +37,19 @@ class Shader internal constructor(ptr: NativePointer) : RefCnt(ptr) {
             require(positions == null || colors.size == positions.size) { "colors.length " + colors.size + "!= positions.length " + positions!!.size }
             Stats.onNativeCall()
             return Shader(
-                _nMakeLinearGradient(
-                    x0,
-                    y0,
-                    x1,
-                    y1,
-                    colors,
-                    positions,
-                    style.tileMode.ordinal,
-                    style._getFlags(),
-                    style._getMatrixArray()
-                )
+                interopScope {
+                    _nMakeLinearGradient(
+                        x0,
+                        y0,
+                        x1,
+                        y1,
+                        toInterop(colors),
+                        toInterop(positions),
+                        style.tileMode.ordinal,
+                        style._getFlags(),
+                        toInterop(style._getMatrixArray())
+                    )
+                }
             )
         }
 
@@ -80,18 +78,20 @@ class Shader internal constructor(ptr: NativePointer) : RefCnt(ptr) {
                 require(positions == null || colors.size == positions.size) { "colors.length " + colors.size + "!= positions.length " + positions!!.size }
                 Stats.onNativeCall()
                 Shader(
-                    _nMakeLinearGradientCS(
-                        x0,
-                        y0,
-                        x1,
-                        y1,
-                        Color4f.flattenArray(colors),
-                        getPtr(cs),
-                        positions,
-                        style.tileMode.ordinal,
-                        style._getFlags(),
-                        style._getMatrixArray()
-                    )
+                    interopScope {
+                        _nMakeLinearGradientCS(
+                            x0,
+                            y0,
+                            x1,
+                            y1,
+                            toInterop(Color4f.flattenArray(colors)),
+                            getPtr(cs),
+                            toInterop(positions),
+                            style.tileMode.ordinal,
+                            style._getFlags(),
+                            toInterop(style._getMatrixArray())
+                        )
+                    }
                 )
             } finally {
                 reachabilityBarrier(cs)
@@ -128,16 +128,18 @@ class Shader internal constructor(ptr: NativePointer) : RefCnt(ptr) {
             require(positions == null || colors.size == positions.size) { "colors.length " + colors.size + "!= positions.length " + positions!!.size }
             Stats.onNativeCall()
             return Shader(
-                _nMakeRadialGradient(
-                    x,
-                    y,
-                    r,
-                    colors,
-                    positions,
-                    style.tileMode.ordinal,
-                    style._getFlags(),
-                    style._getMatrixArray()
-                )
+                interopScope {
+                    _nMakeRadialGradient(
+                        x,
+                        y,
+                        r,
+                        toInterop(colors),
+                        toInterop(positions),
+                        style.tileMode.ordinal,
+                        style._getFlags(),
+                        toInterop(style._getMatrixArray())
+                    )
+                }
             )
         }
 
@@ -165,17 +167,19 @@ class Shader internal constructor(ptr: NativePointer) : RefCnt(ptr) {
                 require(positions == null || colors.size == positions.size) { "colors.length " + colors.size + "!= positions.length " + positions!!.size }
                 Stats.onNativeCall()
                 Shader(
-                    _nMakeRadialGradientCS(
-                        x,
-                        y,
-                        r,
-                        Color4f.flattenArray(colors),
-                        getPtr(cs),
-                        positions,
-                        style.tileMode.ordinal,
-                        style._getFlags(),
-                        style._getMatrixArray()
-                    )
+                    interopScope {
+                        _nMakeRadialGradientCS(
+                            x,
+                            y,
+                            r,
+                            toInterop(Color4f.flattenArray(colors)),
+                            getPtr(cs),
+                            toInterop(positions),
+                            style.tileMode.ordinal,
+                            style._getFlags(),
+                            toInterop(style._getMatrixArray())
+                        )
+                    }
                 )
             } finally {
                 reachabilityBarrier(cs)
@@ -224,19 +228,21 @@ class Shader internal constructor(ptr: NativePointer) : RefCnt(ptr) {
             require(positions == null || colors.size == positions.size) { "colors.length " + colors.size + "!= positions.length " + positions!!.size }
             Stats.onNativeCall()
             return Shader(
-                _nMakeTwoPointConicalGradient(
-                    x0,
-                    y0,
-                    r0,
-                    x1,
-                    y1,
-                    r1,
-                    colors,
-                    positions,
-                    style.tileMode.ordinal,
-                    style._getFlags(),
-                    style._getMatrixArray()
-                )
+                interopScope {
+                    _nMakeTwoPointConicalGradient(
+                        x0,
+                        y0,
+                        r0,
+                        x1,
+                        y1,
+                        r1,
+                        toInterop(colors),
+                        toInterop(positions),
+                        style.tileMode.ordinal,
+                        style._getFlags(),
+                        toInterop(style._getMatrixArray())
+                    )
+                }
             )
         }
 
@@ -269,20 +275,22 @@ class Shader internal constructor(ptr: NativePointer) : RefCnt(ptr) {
                 require(positions == null || colors.size == positions.size) { "colors.length " + colors.size + "!= positions.length " + positions!!.size }
                 Stats.onNativeCall()
                 Shader(
-                    _nMakeTwoPointConicalGradientCS(
-                        x0,
-                        y0,
-                        r0,
-                        x1,
-                        y1,
-                        r1,
-                        Color4f.flattenArray(colors),
-                        getPtr(cs),
-                        positions,
-                        style.tileMode.ordinal,
-                        style._getFlags(),
-                        style._getMatrixArray()
-                    )
+                    interopScope {
+                        _nMakeTwoPointConicalGradientCS(
+                            x0,
+                            y0,
+                            r0,
+                            x1,
+                            y1,
+                            r1,
+                            toInterop(Color4f.flattenArray(colors)),
+                            getPtr(cs),
+                            toInterop(positions),
+                            style.tileMode.ordinal,
+                            style._getFlags(),
+                            toInterop(style._getMatrixArray())
+                        )
+                    }
                 )
             } finally {
                 reachabilityBarrier(cs)
@@ -343,17 +351,19 @@ class Shader internal constructor(ptr: NativePointer) : RefCnt(ptr) {
             require(positions == null || colors.size == positions.size) { "colors.length " + colors.size + "!= positions.length " + positions!!.size }
             Stats.onNativeCall()
             return Shader(
-                _nMakeSweepGradient(
-                    x,
-                    y,
-                    startAngle,
-                    endAngle,
-                    colors,
-                    positions,
-                    style.tileMode.ordinal,
-                    style._getFlags(),
-                    style._getMatrixArray()
-                )
+                interopScope {
+                    _nMakeSweepGradient(
+                        x,
+                        y,
+                        startAngle,
+                        endAngle,
+                        toInterop(colors),
+                        toInterop(positions),
+                        style.tileMode.ordinal,
+                        style._getFlags(),
+                        toInterop(style._getMatrixArray())
+                    )
+                }
             )
         }
 
@@ -383,18 +393,20 @@ class Shader internal constructor(ptr: NativePointer) : RefCnt(ptr) {
                 require(positions == null || colors.size == positions.size) { "colors.length " + colors.size + "!= positions.length " + positions!!.size }
                 Stats.onNativeCall()
                 Shader(
-                    _nMakeSweepGradientCS(
-                        x,
-                        y,
-                        startAngle,
-                        endAngle,
-                        Color4f.flattenArray(colors),
-                        getPtr(cs),
-                        positions,
-                        style.tileMode.ordinal,
-                        style._getFlags(),
-                        style._getMatrixArray()
-                    )
+                    interopScope {
+                        _nMakeSweepGradientCS(
+                            x,
+                            y,
+                            startAngle,
+                            endAngle,
+                            toInterop(Color4f.flattenArray(colors)),
+                            getPtr(cs),
+                            toInterop(positions),
+                            style.tileMode.ordinal,
+                            style._getFlags(),
+                            toInterop(style._getMatrixArray())
+                        )
+                    }
                 )
             } finally {
                 reachabilityBarrier(cs)
@@ -459,7 +471,11 @@ class Shader internal constructor(ptr: NativePointer) : RefCnt(ptr) {
                     arr[i * 2 + 1] = tiles[i].height
                 }
                 Stats.onNativeCall()
-                Shader(_nMakeFractalNoise(baseFrequencyX, baseFrequencyY, numOctaves, seed, arr))
+                Shader(
+                    interopScope {
+                        _nMakeFractalNoise(baseFrequencyX, baseFrequencyY, numOctaves, seed, toInterop(arr))
+                    }
+                )
             } finally {
                 reachabilityBarrier(this)
             }
@@ -479,7 +495,11 @@ class Shader internal constructor(ptr: NativePointer) : RefCnt(ptr) {
                     arr[i * 2 + 1] = tiles[i].height
                 }
                 Stats.onNativeCall()
-                Shader(_nMakeTurbulence(baseFrequencyX, baseFrequencyY, numOctaves, seed, arr))
+                Shader(
+                    interopScope {
+                        _nMakeTurbulence(baseFrequencyX, baseFrequencyY, numOctaves, seed, toInterop(arr))
+                    }
+                )
             } finally {
                 reachabilityBarrier(this)
             }
@@ -512,11 +532,11 @@ private external fun _nMakeLinearGradient(
     y0: Float,
     x1: Float,
     y1: Float,
-    colors: IntArray?,
-    positions: FloatArray?,
+    colors: InteropPointer,
+    positions: InteropPointer,
     tileType: Int,
     flags: Int,
-    matrix: FloatArray?
+    matrix: InteropPointer
 ): NativePointer
 
 
@@ -526,12 +546,12 @@ private external fun _nMakeLinearGradientCS(
     y0: Float,
     x1: Float,
     y1: Float,
-    colors: FloatArray?,
+    colors: InteropPointer,
     colorSpacePtr: NativePointer,
-    positions: FloatArray?,
+    positions: InteropPointer,
     tileType: Int,
     flags: Int,
-    matrix: FloatArray?
+    matrix: InteropPointer
 ): NativePointer
 
 
@@ -540,11 +560,11 @@ private external fun _nMakeRadialGradient(
     x: Float,
     y: Float,
     r: Float,
-    colors: IntArray?,
-    positions: FloatArray?,
+    colors: InteropPointer,
+    positions: InteropPointer,
     tileType: Int,
     flags: Int,
-    matrix: FloatArray?
+    matrix: InteropPointer
 ): NativePointer
 
 
@@ -553,12 +573,12 @@ private external fun _nMakeRadialGradientCS(
     x: Float,
     y: Float,
     r: Float,
-    colors: FloatArray?,
+    colors: InteropPointer,
     colorSpacePtr: NativePointer,
-    positions: FloatArray?,
+    positions: InteropPointer,
     tileType: Int,
     flags: Int,
-    matrix: FloatArray?
+    matrix: InteropPointer
 ): NativePointer
 
 
@@ -570,11 +590,11 @@ private external fun _nMakeTwoPointConicalGradient(
     x1: Float,
     y1: Float,
     r1: Float,
-    colors: IntArray?,
-    positions: FloatArray?,
+    colors: InteropPointer,
+    positions: InteropPointer,
     tileType: Int,
     flags: Int,
-    matrix: FloatArray?
+    matrix: InteropPointer
 ): NativePointer
 
 
@@ -586,12 +606,12 @@ private external fun _nMakeTwoPointConicalGradientCS(
     x1: Float,
     y1: Float,
     r1: Float,
-    colors: FloatArray?,
+    colors: InteropPointer,
     colorSpacePtr: NativePointer,
-    positions: FloatArray?,
+    positions: InteropPointer,
     tileType: Int,
     flags: Int,
-    matrix: FloatArray?
+    matrix: InteropPointer
 ): NativePointer
 
 
@@ -601,11 +621,11 @@ private external fun _nMakeSweepGradient(
     y: Float,
     startAngle: Float,
     endAngle: Float,
-    colors: IntArray?,
-    positions: FloatArray?,
+    colors: InteropPointer,
+    positions: InteropPointer,
     tileType: Int,
     flags: Int,
-    matrix: FloatArray?
+    matrix: InteropPointer
 ): NativePointer
 
 
@@ -615,12 +635,12 @@ private external fun _nMakeSweepGradientCS(
     y: Float,
     startAngle: Float,
     endAngle: Float,
-    colors: FloatArray?,
+    colors: InteropPointer,
     colorSpacePtr: NativePointer,
-    positions: FloatArray?,
+    positions: InteropPointer,
     tileType: Int,
     flags: Int,
-    matrix: FloatArray?
+    matrix: InteropPointer
 ): NativePointer
 
 
@@ -630,7 +650,7 @@ private external fun _nMakeFractalNoise(
     baseFrequencyY: Float,
     numOctaves: Int,
     seed: Float,
-    tiles: IntArray?
+    tiles: InteropPointer
 ): NativePointer
 
 
@@ -640,7 +660,7 @@ private external fun _nMakeTurbulence(
     baseFrequencyY: Float,
     numOctaves: Int,
     seed: Float,
-    tiles: IntArray?
+    tiles: InteropPointer
 ): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_Shader__1nMakeColor")

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

 @file:Suppress("NESTED_EXTERNAL_DECLARATION")
 package org.jetbrains.skia
 
+import org.jetbrains.skia.impl.*
 import org.jetbrains.skia.impl.Library.Companion.staticLoad
-import org.jetbrains.skia.impl.Managed
-import org.jetbrains.skia.impl.Stats
-import org.jetbrains.skia.impl.reachabilityBarrier
-import org.jetbrains.skia.impl.NativePointer
-import org.jetbrains.skia.impl.getPtr
 
 
 @ExternalSymbolName("org_jetbrains_skia_TextBlob__1nGetFinalizer")
@@ -28,13 +24,13 @@ private external fun _nBounds(ptr: NativePointer): Rect
 private external fun _nGetIntercepts(ptr: NativePointer, lower: Float, upper: Float, paintPtr: NativePointer): FloatArray?
 
 @ExternalSymbolName("org_jetbrains_skia_TextBlob__1nMakeFromPosH")
-private external fun _nMakeFromPosH(glyphs: ShortArray?, xpos: FloatArray?, ypos: Float, fontPtr: NativePointer): NativePointer
+private external fun _nMakeFromPosH(glyphs: InteropPointer, xpos: InteropPointer, ypos: Float, fontPtr: NativePointer): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_TextBlob__1nMakeFromPos")
-private external fun _nMakeFromPos(glyphs: ShortArray?, pos: FloatArray?, fontPtr: NativePointer): NativePointer
+private external fun _nMakeFromPos(glyphs: InteropPointer, pos: InteropPointer, fontPtr: NativePointer): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_TextBlob__1nMakeFromRSXform")
-private external fun _nMakeFromRSXform(glyphs: ShortArray?, xform: FloatArray?, fontPtr: NativePointer): NativePointer
+private external fun _nMakeFromRSXform(glyphs: InteropPointer, xform: InteropPointer, fontPtr: NativePointer): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_TextBlob__1nGetGlyphs")
 private external fun _nGetGlyphs(ptr: NativePointer): ShortArray
@@ -73,12 +69,14 @@ class TextBlob internal constructor(ptr: NativePointer) : Managed(ptr, _Finalize
             return try {
                 require(glyphs.size == xpos.size) { "glyphs.length " + glyphs.size + " != xpos.length " + xpos.size }
                 Stats.onNativeCall()
-                val ptr = _nMakeFromPosH(
-                    glyphs,
-                    xpos,
-                    ypos,
-                    getPtr(font)
-                )
+                val ptr = interopScope {
+                    _nMakeFromPosH(
+                        toInterop(glyphs),
+                        toInterop(xpos),
+                        ypos,
+                        getPtr(font)
+                    )
+                }
                 if (ptr == NullPointer) null else TextBlob(ptr)
             } finally {
                 reachabilityBarrier(font)
@@ -104,7 +102,9 @@ class TextBlob internal constructor(ptr: NativePointer) : Managed(ptr, _Finalize
                 }
                 Stats.onNativeCall()
                 val ptr =
-                    _nMakeFromPos(glyphs, floatPos, getPtr(font))
+                    interopScope {
+                        _nMakeFromPos(toInterop(glyphs), toInterop(floatPos), getPtr(font))
+                    }
                 if (ptr == NullPointer) null else TextBlob(ptr)
             } finally {
                 reachabilityBarrier(font)
@@ -122,11 +122,13 @@ class TextBlob internal constructor(ptr: NativePointer) : Managed(ptr, _Finalize
                     floatXform[i * 4 + 3] = xform[i].ty
                 }
                 Stats.onNativeCall()
-                val ptr = _nMakeFromRSXform(
-                    glyphs,
-                    floatXform,
-                    getPtr(font)
-                )
+                val ptr = interopScope {
+                    _nMakeFromRSXform(
+                        toInterop(glyphs),
+                        toInterop(floatXform),
+                        getPtr(font)
+                    )
+                }
                 if (ptr == NullPointer) null else TextBlob(ptr)
             } finally {
                 reachabilityBarrier(font)

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

 @file:Suppress("NESTED_EXTERNAL_DECLARATION")
 package org.jetbrains.skia
 
+import org.jetbrains.skia.impl.*
 import org.jetbrains.skia.impl.Library.Companion.staticLoad
-import org.jetbrains.skia.impl.Managed
-import org.jetbrains.skia.impl.Stats
-import org.jetbrains.skia.impl.reachabilityBarrier
-import org.jetbrains.skia.impl.NativePointer
-import org.jetbrains.skia.impl.getPtr
 
 class TextBlobBuilder internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerHolder.PTR) {
     companion object {
@@ -103,14 +99,16 @@ class TextBlobBuilder internal constructor(ptr: NativePointer) : Managed(ptr, _F
     fun appendRun(font: Font?, glyphs: ShortArray?, x: Float, y: Float, bounds: Rect?): TextBlobBuilder {
         return try {
             Stats.onNativeCall()
-            _nAppendRun(
-                _ptr,
-                getPtr(font),
-                glyphs,
-                x,
-                y,
-                bounds
-            )
+            interopScope {
+                _nAppendRun(
+                    _ptr,
+                    getPtr(font),
+                    toInterop(glyphs),
+                    x,
+                    y,
+                    bounds
+                )
+            }
             this
         } finally {
             reachabilityBarrier(font)
@@ -198,13 +196,15 @@ class TextBlobBuilder internal constructor(ptr: NativePointer) : Managed(ptr, _F
                 floatPos[i * 2 + 1] = pos[i].y
             }
             Stats.onNativeCall()
-            _nAppendRunPos(
-                _ptr,
-                getPtr(font),
-                glyphs,
-                floatPos,
-                bounds
-            )
+            interopScope {
+                _nAppendRunPos(
+                    _ptr,
+                    getPtr(font),
+                    toInterop(glyphs),
+                    toInterop(floatPos),
+                    bounds
+                )
+            }
             this
         } finally {
             reachabilityBarrier(font)
@@ -222,12 +222,14 @@ class TextBlobBuilder internal constructor(ptr: NativePointer) : Managed(ptr, _F
                 floatXform[i * 4 + 3] = xform[i].ty
             }
             Stats.onNativeCall()
-            _nAppendRunRSXform(
-                _ptr,
-                getPtr(font),
-                glyphs,
-                floatXform
-            )
+            interopScope {
+                _nAppendRunRSXform(
+                    _ptr,
+                    getPtr(font),
+                    toInterop(glyphs),
+                    toInterop(floatXform)
+                )
+            }
             this
         } finally {
             reachabilityBarrier(font)
@@ -250,7 +252,7 @@ private external fun TextBlobBuilder_nMake(): NativePointer
 private external fun _nBuild(ptr: NativePointer): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_TextBlobBuilder__1nAppendRun")
-private external fun _nAppendRun(ptr: NativePointer, fontPtr: NativePointer, glyphs: ShortArray?, x: Float, y: Float, bounds: Rect?)
+private external fun _nAppendRun(ptr: NativePointer, fontPtr: NativePointer, glyphs: InteropPointer, x: Float, y: Float, bounds: Rect?)
 
 @ExternalSymbolName("org_jetbrains_skia_TextBlobBuilder__1nAppendRunPosH")
 private external fun _nAppendRunPosH(
@@ -264,7 +266,7 @@ private external fun _nAppendRunPosH(
 
 
 @ExternalSymbolName("org_jetbrains_skia_TextBlobBuilder__1nAppendRunPos")
-private external fun _nAppendRunPos(ptr: NativePointer, fontPtr: NativePointer, glyphs: ShortArray?, pos: FloatArray?, bounds: Rect?)
+private external fun _nAppendRunPos(ptr: NativePointer, fontPtr: NativePointer, glyphs: InteropPointer, pos: InteropPointer, bounds: Rect?)
 
 @ExternalSymbolName("org_jetbrains_skia_TextBlobBuilder__1nAppendRunRSXform")
-private external fun _nAppendRunRSXform(ptr: NativePointer, fontPtr: NativePointer, glyphs: ShortArray?, xform: FloatArray?)
+private external fun _nAppendRunRSXform(ptr: NativePointer, fontPtr: NativePointer, glyphs: InteropPointer, xform: InteropPointer)

skiko/src/commonMain/kotlin/org/jetbrains/skia/impl/Native.kt

@@ -42,14 +42,7 @@ expect class InteropScope() {
     fun release()
 }
 
-inline fun <T> interopScope(block: InteropScope.() -> T): T {
-    val scope = InteropScope()
-    try {
-        return scope.block()
-    } finally {
-        scope.release()
-    }
-}
+expect inline fun <T> interopScope(block: InteropScope.() -> T): T
 
 inline fun withResult(result: ByteArray, block: (InteropPointer) -> Unit): ByteArray = interopScope {
     val handle = toInterop(result)

skiko/src/jsMain/kotlin/org/jetbrains/skia/impl/Native.js.kt

@@ -27,6 +27,15 @@ actual fun reachabilityBarrier(obj: Any?) {
 actual typealias NativePointer = Int
 actual typealias InteropPointer = Int
 
+actual inline fun <T> interopScope(block: InteropScope.() -> T): T {
+    val scope = InteropScope()
+    try {
+        return scope.block()
+    } finally {
+        scope.release()
+    }
+}
+
 actual class InteropScope actual constructor() {
     private val elements = mutableListOf<NativePointer>()
 

skiko/src/jvmMain/kotlin/org/jetbrains/skia/impl/Native.jvm.kt

@@ -50,7 +50,12 @@ actual typealias NativePointer = Long
 
 actual typealias InteropPointer = Any?
 
-actual class InteropScope actual constructor() {
+object theScope: InteropScope()
+actual inline fun <T> interopScope(block: InteropScope.() -> T): T {
+    return theScope.block()
+}
+
+actual open class InteropScope actual constructor() {
     actual fun toInterop(string: String?): InteropPointer = string
     actual fun InteropPointer.fromInterop(result: CharArray) {}
     actual fun toInterop(array: ByteArray?): InteropPointer = array

skiko/src/nativeMain/kotlin/org/jetbrains/skia/impl/Native.native.kt

@@ -32,6 +32,15 @@ actual fun reachabilityBarrier(obj: Any?) {
     // TODO: implement native barrier
 }
 
+actual inline fun <T> interopScope(block: InteropScope.() -> T): T {
+    val scope = InteropScope()
+    try {
+        return scope.block()
+    } finally {
+        scope.release()
+    }
+}
+
 actual class InteropScope actual constructor() {
     actual fun toInterop(string: String?): InteropPointer {
         return if (string != null) {