Add toInterop for FontFeature.kt and update bindings accordingly (#329)

* Add toInterop for FontFeature.kt and update bindings accordingly

* fix: add reinterpret_cast
Co-authored-by: Oleksandr Karpovich <oleksandr.karpovich@jetbrains.com>

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

 package org.jetbrains.skia
 
-class FontFeature(val _tag: Int, val value: Int, val start: Long, val end: Long) {
+import org.jetbrains.skia.impl.InteropPointer
+import org.jetbrains.skia.impl.InteropScope
 
-    constructor(feature: String, value: Int, start: Long, end: Long) : this(
+class FontFeature(val _tag: Int, val value: Int, val start: UInt, val end: UInt) {
+
+    constructor(feature: String, value: Int, start: UInt, end: UInt) : this(
         FourByteTag.fromString(feature),
         value,
         start,
@@ -30,8 +33,8 @@ class FontFeature(val _tag: Int, val value: Int, val start: Long, val end: Long)
 
     override fun toString(): String {
         var range = ""
-        if (start > 0 || end < Long.MAX_VALUE) {
-            range = "[" + (if (start > 0) start else "") + ":" + (if (end < Long.MAX_VALUE) end else "") + "]"
+        if (start > 0u || end < UInt.MAX_VALUE) {
+            range = "[" + (if (start > 0u) start else "") + ":" + (if (end < UInt.MAX_VALUE) end else "") + "]"
         }
         var valuePrefix = ""
         var valueSuffix = ""
@@ -53,14 +56,25 @@ class FontFeature(val _tag: Int, val value: Int, val start: Long, val end: Long)
         var result = 1
         result = result * PRIME + (_tag.hashCode())
         result = result * PRIME + value
-        result = result * PRIME + (start ushr 32 xor start).toInt()
-        result = result * PRIME + (end ushr 32 xor end).toInt()
+        result = result * PRIME + (start shr 16 xor start).toInt()
+        result = result * PRIME + (end shr 16 xor end).toInt()
         return result
     }
 
+    internal fun toInteropIntArray(): IntArray {
+        return intArrayOf(_tag, value, start.toInt(), end.toInt())
+    }
+
+    internal fun InteropScope.toInterop(): InteropPointer {
+        return toInterop(toInteropIntArray())
+    }
+
     companion object {
-        const val GLOBAL_START: Long = 0
-        const val GLOBAL_END = Long.MAX_VALUE
+        const val GLOBAL_START: UInt = 0u
+        // according to https://github.com/google/skia/blob/main/modules/skshaper/src/SkShaper_harfbuzz.cpp#L48
+        // define HB_FEATURE_GLOBAL_END ((unsigned int) -1)
+        const val GLOBAL_END: UInt = UInt.MAX_VALUE
+
         val EMPTY = arrayOfNulls<FontFeature>(0)
         val _splitPattern = compilePattern("\\s+")
         val _featurePattern =
@@ -71,13 +85,37 @@ class FontFeature(val _tag: Int, val value: Int, val start: Long, val end: Long)
             require(m.matches()) { "Can’t parse FontFeature: $s" }
             val value = if (m.group("value") != null) m.group("value")!!
                 .toInt() else if (m.group("sign") == null) 1 else if ("-" == m.group("sign")) 0 else 1
-            val start = if (m.group("start") == null) 0 else m.group("start")!!.toLong()
-            val end = if (m.group("end") == null) Long.MAX_VALUE else m.group("end")!!.toLong()
+            val start = if (m.group("start") == null) 0u else m.group("start")!!.toUInt()
+            val end = if (m.group("end") == null) UInt.MAX_VALUE else m.group("end")!!.toUInt()
             return FontFeature(m.group("tag")!!, value, start, end)
         }
 
         fun parse(str: String): Array<FontFeature?> {
             return _splitPattern.split(str)?.map { s -> parseOne(s!!) }?.toTypedArray() ?: emptyArray()
         }
+
+        internal fun InteropScope.toInterop(fontFeatures: Array<FontFeature>?): InteropPointer {
+            val ints = fontFeatures?.flatMap {
+                it.toInteropIntArray().toList()
+            }?.toIntArray()
+
+            return toInterop(ints)
+        }
+
+        /**
+         * This function can be used to convert IntArray to FontFeatures.
+         * Every FontFeature is represented by 2 ints (_tag, value)
+         */
+        internal fun fromInteropEncodedBy2Ints(fontFeatures: IntArray): Array<FontFeature> {
+            val featuresCount = fontFeatures.size / 2
+
+            return Array(featuresCount) {
+                val j = it * 2
+                FontFeature(
+                    fontFeatures[j], fontFeatures[j + 1],
+                    GLOBAL_START, GLOBAL_END
+                )
+            }
+        }
     }
 }

skiko/src/commonMain/kotlin/org/jetbrains/skia/paragraph/TextStyle.kt

@@ -181,7 +181,13 @@ class TextStyle internal constructor(ptr: NativePointer) : Managed(ptr, _Finaliz
     val fontFeatures: Array<FontFeature>
         get() = try {
             Stats.onNativeCall()
-            _nGetFontFeatures(_ptr)
+
+            val size = _nGetFontFeaturesSize(_ptr)
+            withResult(IntArray(size * 2)) {
+                _nGetFontFeatures(_ptr, it)
+            }.let {
+                FontFeature.fromInteropEncodedBy2Ints(it)
+            }
         } finally {
             reachabilityBarrier(this)
         }
@@ -457,7 +463,10 @@ private external fun _nAddShadow(ptr: NativePointer, color: Int, offsetX: Float,
 private external fun _nClearShadows(ptr: NativePointer)
 
 @ExternalSymbolName("org_jetbrains_skia_paragraph_TextStyle__1nGetFontFeatures")
-private external fun _nGetFontFeatures(ptr: NativePointer): Array<FontFeature>
+private external fun _nGetFontFeatures(ptr: NativePointer, resultIntsArray: InteropPointer)
+
+@ExternalSymbolName("org_jetbrains_skia_paragraph_TextStyle__1nGetFontFeaturesSize")
+private external fun _nGetFontFeaturesSize(ptr: NativePointer): Int
 
 @ExternalSymbolName("org_jetbrains_skia_paragraph_TextStyle__1nAddFontFeature")
 private external fun _nAddFontFeature(ptr: NativePointer, name: String?, value: Int)

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

@@ -7,6 +7,7 @@
 #include "shaper/interop.hh"
 #include "src/utils/SkUTF.h"
 #include "paragraph/interop.hh"
+#include "TextStyle.h"
 
 namespace java {
     namespace io {
@@ -259,6 +260,43 @@ namespace skija {
             }
             return features;
         }
+
+        // every feature is encoded as 4 ints
+        std::vector<SkShaper::Feature> fromIntArray(JNIEnv* env, jintArray array, jint featuresLen) {
+            jint* ints = env->GetIntArrayElements(array, NULL);
+            std::vector<SkShaper::Feature> features(featuresLen);
+            for (int i = 0; i < featuresLen; ++i) {
+                int j = i * 4;
+                features[i] = {
+                    static_cast<SkFourByteTag>(ints[j]),
+                    static_cast<uint32_t>(ints[j + 1]),
+                    static_cast<size_t>(ints[j + 2]),
+                    static_cast<size_t>(ints[j + 3])
+                };
+            }
+            env->ReleaseIntArrayElements(array, ints, 0);
+
+            return features;
+        }
+
+        // every FontFeature is represented by 2 ints in resultArr
+        void writeToIntArray(std::vector<skia::textlayout::FontFeature> features, int* resultArr) {
+            for (int i = 0; i < features.size(); ++i) {
+                int j = i * 2;
+                resultArr[j] = skija::FontFeature::FourByteTag::fromString(features[i].fName);
+                resultArr[j + 1] = features[i].fValue;;
+            }
+        }
+
+        namespace FourByteTag {
+            int fromString(SkString str) {
+                int code1 = (int)str[0];
+                int code2 = (int)str[1];
+                int code3 = (int)str[2];
+                int code4 = (int)str[3];
+                return (code1 & 0xFF << 24) | (code2 & 0xFF << 16) | (code3 & 0xFF << 8) | (code4 & 0xFF);
+            }
+        }
     }
 
     namespace FontMetrics {

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

@@ -17,6 +17,7 @@
 #include "SkShaper.h"
 #include "SkString.h"
 #include "SkSurfaceProps.h"
+#include "TextStyle.h"
 
 namespace java {
     namespace io {
@@ -142,6 +143,16 @@ namespace skija {
         void onLoad(JNIEnv* env);
         void onUnload(JNIEnv* env);
         std::vector<SkShaper::Feature> fromJavaArray(JNIEnv* env, jobjectArray featuresArr);
+
+        // every feature is encoded as 4 ints
+        std::vector<SkShaper::Feature> fromIntArray(JNIEnv* env, jintArray array, jint featuresCount);
+
+        // caller needs to ensure the resultArr size is sufficient (every feature is encoded as 2 ints)
+        void writeToIntArray(std::vector<skia::textlayout::FontFeature> features, int* resultArr);
+
+        namespace FourByteTag {
+            int fromString(SkString str);
+        }
     }
 
     namespace FontMetrics {

skiko/src/jvmMain/cpp/common/paragraph/TextStyle.cc

@@ -151,18 +151,21 @@ extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skia_paragraph_TextStyleKt_
     instance->resetShadows();
 }
 
-extern "C" JNIEXPORT jobjectArray JNICALL Java_org_jetbrains_skia_paragraph_TextStyleKt__1nGetFontFeatures
-  (JNIEnv* env, jclass jclass, jlong ptr) {
+extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skia_paragraph_TextStyleKt__1nGetFontFeaturesSize
+(JNIEnv* env, jclass jclass, jlong ptr) {
     TextStyle* instance = reinterpret_cast<TextStyle*>(static_cast<uintptr_t>(ptr));
     std::vector<FontFeature> fontFeatures = instance->getFontFeatures();
-    jobjectArray fontFeaturesArr = env->NewObjectArray((jsize) fontFeatures.size(), skija::FontFeature::cls, nullptr);
-    for (int i = 0; i < fontFeatures.size(); ++i) {
-        const FontFeature& ff = fontFeatures[i];
-        auto featureObj = env->NewObject(skija::FontFeature::cls, skija::FontFeature::ctor, javaString(env, ff.fName), ff.fValue);
-        env->SetObjectArrayElement(fontFeaturesArr, i, featureObj);
-        env->DeleteLocalRef(featureObj);
-    }
-    return fontFeaturesArr;
+    return static_cast<jint>(fontFeatures.size());
+}
+
+extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skia_paragraph_TextStyleKt__1nGetFontFeatures
+  (JNIEnv* env, jclass jclass, jlong ptr, jintArray resultArr) {
+    TextStyle* instance = reinterpret_cast<TextStyle*>(static_cast<uintptr_t>(ptr));
+    std::vector<FontFeature> fontFeatures = instance->getFontFeatures();
+
+    jint* ints = env->GetIntArrayElements(resultArr, NULL);
+    skija::FontFeature::writeToIntArray(fontFeatures, reinterpret_cast<int*>(ints));
+    env->ReleaseIntArrayElements(resultArr, ints, 0);
 }
 
 extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skia_paragraph_TextStyleKt__1nAddFontFeature

skiko/src/nativeJsMain/cpp/common.h

@@ -19,6 +19,7 @@
 #include "SkShaper.h"
 #include "SkString.h"
 #include "SkSurfaceProps.h"
+#include "TextStyle.h"
 
 #include "types.h"
 
@@ -68,6 +69,18 @@ namespace skija {
     namespace IRect {
         std::unique_ptr<SkIRect> toSkIRect(KInt* rectInts);
     }
+
+    namespace FontFeature {
+        // every feature is encoded as 4 ints
+        std::vector<SkShaper::Feature> fromIntArray(KInt* array, KInt featuresLen);
+
+        // caller needs to ensure the resultArr size is sufficient (every feature is encoded as 2 ints)
+        void writeToIntArray(std::vector<skia::textlayout::FontFeature> features, int* resultArr);
+
+        namespace FourByteTag {
+            int fromString(SkString str);
+        }
+    }
 }
 
 std::unique_ptr<SkMatrix> skMatrix(KFloat* matrixArray);

skiko/src/nativeJsMain/cpp/common_interop.cc

 #include "common.h"
 #include "src/utils/SkUTF.h"
 #include "include/core/SkImageInfo.h"
+#include "TextStyle.h"
 #include <stdio.h>
 
 KLong packTwoInts(int32_t a, int32_t b) {
@@ -45,6 +46,40 @@ namespace skija {
             }
         }
     }
+
+    namespace FontFeature {
+        std::vector<SkShaper::Feature> fromIntArray(KInt* array, KInt featuresLen) {
+            std::vector<SkShaper::Feature> features(featuresLen);
+            for (int i = 0; i < featuresLen; ++i) {
+                int j = i * 4;
+                features[i] = {
+                    static_cast<SkFourByteTag>(array[j]),
+                    static_cast<uint32_t>(array[j + 1]),
+                    static_cast<size_t>(array[j + 2]),
+                    static_cast<size_t>(array[j + 3])
+                };
+            }
+            return features;
+        }
+
+        void writeToIntArray(std::vector<skia::textlayout::FontFeature> features, int* resultArr) {
+            for (int i = 0; i < features.size(); ++i) {
+                int j = i * 2;
+                resultArr[j] = skija::FontFeature::FourByteTag::fromString(features[i].fName);
+                resultArr[j + 1] = features[i].fValue;;
+            }
+        }
+
+        namespace FourByteTag {
+            int fromString(SkString str) {
+                int code1 = (int)str[0];
+                int code2 = (int)str[1];
+                int code3 = (int)str[2];
+                int code4 = (int)str[3];
+                return (code1 & 0xFF << 24) | (code2 & 0xFF << 16) | (code3 & 0xFF << 8) | (code4 & 0xFF);
+            }
+        }
+    }
 }
 
 skija::UtfIndicesConverter::UtfIndicesConverter(const char* chars8, size_t len8):

skiko/src/nativeJsMain/cpp/paragraph/TextStyle.cc

@@ -168,28 +168,19 @@ SKIKO_EXPORT void org_jetbrains_skia_paragraph_TextStyle__1nClearShadows
     instance->resetShadows();
 }
 
-
-SKIKO_EXPORT KInteropPointerArray org_jetbrains_skia_paragraph_TextStyle__1nGetFontFeatures
+SKIKO_EXPORT KInt org_jetbrains_skia_paragraph_TextStyle__1nGetFontFeaturesSize
   (KNativePointer ptr) {
-    TODO("implement org_jetbrains_skia_paragraph_TextStyle__1nGetFontFeatures");
+    TextStyle* instance = reinterpret_cast<TextStyle*>(ptr);
+    std::vector<FontFeature> fontFeatures = instance->getFontFeatures();
+    return static_cast<KInt>(fontFeatures.size());
 }
 
-#if 0 
-SKIKO_EXPORT KInteropPointerArray org_jetbrains_skia_paragraph_TextStyle__1nGetFontFeatures
-  (KNativePointer ptr) {
+SKIKO_EXPORT void org_jetbrains_skia_paragraph_TextStyle__1nGetFontFeatures
+  (KNativePointer ptr, KInt* resultArr) {
     TextStyle* instance = reinterpret_cast<TextStyle*>((ptr));
     std::vector<FontFeature> fontFeatures = instance->getFontFeatures();
-    KInteropPointerArray fontFeaturesArr = env->NewObjectArray((jsize) fontFeatures.size(), skija::FontFeature::cls, nullptr);
-    for (int i = 0; i < fontFeatures.size(); ++i) {
-        const FontFeature& ff = fontFeatures[i];
-        auto featureObj = env->NewObject(skija::FontFeature::cls, skija::FontFeature::ctor, javaString(env, ff.fName), ff.fValue);
-        env->SetObjectArrayElement(fontFeaturesArr, i, featureObj);
-        env->DeleteLocalRef(featureObj);
-    }
-    return fontFeaturesArr;
+    skija::FontFeature::writeToIntArray(fontFeatures, resultArr);
 }
-#endif
-
 
 
 SKIKO_EXPORT void org_jetbrains_skia_paragraph_TextStyle__1nAddFontFeature