Fix DIRECT_SOFTWARE, rename it to SOFTWARE (#347)

skiko/src/commonMain/kotlin/org/jetbrains/skiko/GraphicsApi.kt

 package org.jetbrains.skiko
 
 enum class GraphicsApi {
-    UNKNOWN, SOFTWARE, DIRECT_SOFTWARE, OPENGL, DIRECT3D, VULKAN, METAL, WEBGL
+    UNKNOWN,
+
+    /**
+     * Fast software rendering that works in 95% of cases. If it doesn't work, Skiko will fallback to SOFTWARE_COMPAT.
+     *
+     * For example, on JVM it doesn't work if the system has 16-bit color.
+     */
+    SOFTWARE_FAST,
+
+    /**
+     * Slower software rendering that works in all cases. On JVM uses [java.awt.BufferedImage] as intermediate buffer.
+     */
+    SOFTWARE_COMPAT,
+
+    OPENGL,
+    DIRECT3D,
+    VULKAN,
+    METAL,
+    WEBGL
 }
 
 enum class GpuPriority(val value: String) {

skiko/src/jvmMain/cpp/linux/SoftwareRedrawer.cc

@@ -12,7 +12,6 @@ public:
     Display* display;
     Window window;
     GC gc;
-    SkAutoMalloc surfaceMemory;
     sk_sp<SkSurface> surface;
     unsigned int depth = 0;
     SkColorType colorSpace = kUnknown_SkColorType;
@@ -80,10 +79,11 @@ extern "C"
         device->surface = SkSurface::MakeRaster(info);
     }
 
-    JNIEXPORT jlong JNICALL Java_org_jetbrains_skiko_redrawer_AbstractDirectSoftwareRedrawer_getSurface(
+    JNIEXPORT jlong JNICALL Java_org_jetbrains_skiko_redrawer_AbstractDirectSoftwareRedrawer_acquireSurface(
         JNIEnv *env, jobject redrawer, jlong devicePtr)
     {
         SoftwareDevice *device = fromJavaPointer<SoftwareDevice *>(devicePtr);
+        device->surface.get()->ref();
         return toJavaPointer(device->surface.get());
     }
 

skiko/src/jvmMain/cpp/windows/SoftwareRedrawer.cc

@@ -64,11 +64,12 @@ extern "C"
         }
     }
 
-    JNIEXPORT jlong JNICALL Java_org_jetbrains_skiko_redrawer_AbstractDirectSoftwareRedrawer_getSurface(
+    JNIEXPORT jlong JNICALL Java_org_jetbrains_skiko_redrawer_AbstractDirectSoftwareRedrawer_acquireSurface(
         JNIEnv *env, jobject redrawer, jlong devicePtr)
     {
         SoftwareDevice *device = fromJavaPointer<SoftwareDevice *>(devicePtr);
-        return toJavaPointer(device->surface.release());
+        device->surface.get()->ref();
+        return toJavaPointer(device->surface.get());
     }
 
     JNIEXPORT void JNICALL Java_org_jetbrains_skiko_redrawer_AbstractDirectSoftwareRedrawer_finishFrame(

skiko/src/jvmMain/kotlin/org/jetbrains/skiko/RenderFactory.kt

@@ -18,18 +18,18 @@ private fun makeDefaultRenderFactory(): RenderFactory {
             properties: SkiaLayerProperties
         ): Redrawer = when (hostOs) {
             OS.MacOS -> when (renderApi) {
-                GraphicsApi.SOFTWARE, GraphicsApi.DIRECT_SOFTWARE -> SoftwareRedrawer(layer, properties)
+                GraphicsApi.SOFTWARE_COMPAT, GraphicsApi.SOFTWARE_FAST -> SoftwareRedrawer(layer, properties)
                 else -> MetalRedrawer(layer, properties)
             }
             OS.Windows -> when (renderApi) {
-                GraphicsApi.SOFTWARE -> SoftwareRedrawer(layer, properties)
-                GraphicsApi.DIRECT_SOFTWARE -> WindowsSoftwareRedrawer(layer, properties)
+                GraphicsApi.SOFTWARE_COMPAT -> SoftwareRedrawer(layer, properties)
+                GraphicsApi.SOFTWARE_FAST -> WindowsSoftwareRedrawer(layer, properties)
                 GraphicsApi.OPENGL -> WindowsOpenGLRedrawer(layer, properties)
                 else -> Direct3DRedrawer(layer, properties)
             }
             OS.Linux -> when (renderApi) {
-                GraphicsApi.SOFTWARE -> SoftwareRedrawer(layer, properties)
-                GraphicsApi.DIRECT_SOFTWARE -> LinuxSoftwareRedrawer(layer, properties)
+                GraphicsApi.SOFTWARE_COMPAT -> SoftwareRedrawer(layer, properties)
+                GraphicsApi.SOFTWARE_FAST -> LinuxSoftwareRedrawer(layer, properties)
                 else -> LinuxOpenGLRedrawer(layer, properties)
             }
             OS.JS, OS.Ios -> {

skiko/src/jvmMain/kotlin/org/jetbrains/skiko/SkikoProperties.kt

@@ -36,8 +36,8 @@ internal object SkikoProperties {
 
     internal fun parseRenderApi(text: String?): GraphicsApi {
         when(text) {
-            "SOFTWARE" -> return GraphicsApi.SOFTWARE
-            "DIRECT_SOFTWARE" -> return GraphicsApi.DIRECT_SOFTWARE
+            "SOFTWARE_COMPAT" -> return GraphicsApi.SOFTWARE_COMPAT
+            "SOFTWARE_FAST", "DIRECT_SOFTWARE", "SOFTWARE" -> return GraphicsApi.SOFTWARE_FAST
             "OPENGL" -> return GraphicsApi.OPENGL
             "DIRECT3D" -> {
                 return if (hostOs == OS.Windows) GraphicsApi.DIRECT3D
@@ -62,9 +62,9 @@ internal object SkikoProperties {
 
     fun fallbackRenderApiQueue(initialApi: GraphicsApi) : List<GraphicsApi> {
         var fallbackApis = when (hostOs) {
-            OS.Linux -> listOf(GraphicsApi.OPENGL, GraphicsApi.DIRECT_SOFTWARE, GraphicsApi.SOFTWARE)
-            OS.MacOS -> listOf(GraphicsApi.METAL, GraphicsApi.SOFTWARE)
-            OS.Windows -> listOf(GraphicsApi.DIRECT3D, GraphicsApi.OPENGL, GraphicsApi.DIRECT_SOFTWARE, GraphicsApi.SOFTWARE)
+            OS.Linux -> listOf(GraphicsApi.OPENGL, GraphicsApi.SOFTWARE_FAST, GraphicsApi.SOFTWARE_COMPAT)
+            OS.MacOS -> listOf(GraphicsApi.METAL, GraphicsApi.SOFTWARE_COMPAT)
+            OS.Windows -> listOf(GraphicsApi.DIRECT3D, GraphicsApi.OPENGL, GraphicsApi.SOFTWARE_FAST, GraphicsApi.SOFTWARE_COMPAT)
             OS.JS, OS.Ios -> TODO("commonize me")
         }
 

skiko/src/jvmMain/kotlin/org/jetbrains/skiko/context/DirectSoftwareContextHandler.kt

@@ -40,7 +40,7 @@ internal class DirectSoftwareContextHandler(layer: SkiaLayer) : JvmContextHandle
         if (isSizeChanged(w, h)) {
             disposeCanvas()
             softwareRedrawer.resize(w, h)
-            surface = softwareRedrawer.getSurface()
+            surface = softwareRedrawer.acquireSurface()
             canvas = surface!!.canvas
         }
     }

skiko/src/jvmMain/kotlin/org/jetbrains/skiko/redrawer/AbstractDirectSoftwareRedrawer.kt

@@ -26,7 +26,7 @@ internal abstract class AbstractDirectSoftwareRedrawer(
 
         if (layer.isShowing) {
             layer.update(System.nanoTime())
-            layer.inDrawScope(contextHandler::draw)
+            draw()
         }
     }
 
@@ -36,14 +36,16 @@ internal abstract class AbstractDirectSoftwareRedrawer(
         frameDispatcher.scheduleFrame()
     }
 
+    protected open fun draw() = layer.inDrawScope(contextHandler::draw)
+
     override fun redrawImmediately() {
         layer.update(System.nanoTime())
         layer.inDrawScope(contextHandler::draw)
     }
 
     open fun resize(width: Int, height: Int) = resize(device, width, height)
-    fun getSurface(): Surface {
-        val surface = getSurface(device)
+    fun acquireSurface(): Surface {
+        val surface = acquireSurface(device)
         if (surface == 0L) {
             throw RenderException("Failed to create Surface")
         }
@@ -60,7 +62,7 @@ internal abstract class AbstractDirectSoftwareRedrawer(
     }
 
     private external fun resize(devicePtr: Long, width: Int, height: Int)
-    private external fun getSurface(devicePtr: Long): Long
+    private external fun acquireSurface(devicePtr: Long): Long
     private external fun finishFrame(devicePtr: Long)
     private external fun disposeDevice(devicePtr: Long)
 }
\ No newline at end of file

skiko/src/jvmMain/kotlin/org/jetbrains/skiko/redrawer/LinuxSoftwareRedrawer.kt

@@ -20,6 +20,14 @@ internal class LinuxSoftwareRedrawer(
         }
     }
 
+    override fun dispose() = layer.backedLayer.lockLinuxDrawingSurface {
+        super.dispose()
+    }
+
+    override fun draw() = layer.backedLayer.lockLinuxDrawingSurface {
+        super.draw()
+    }
+
     override fun redrawImmediately() = layer.backedLayer.lockLinuxDrawingSurface {
         super.redrawImmediately()
     }

skiko/src/jvmTest/kotlin/org/jetbrains/skiko/SkiaLayerPerformanceTest.kt

@@ -80,8 +80,8 @@ class SkiaLayerPerformanceTest {
             }
 
             if (
-                renderApi == GraphicsApi.SOFTWARE ||
-                renderApi == GraphicsApi.DIRECT_SOFTWARE
+                renderApi == GraphicsApi.SOFTWARE_COMPAT ||
+                renderApi == GraphicsApi.SOFTWARE_FAST
             ) {
                 val slowFrames = frameTimeDeltas.filter { it > 1E9 / 55 }
                 val fastFrames = frameTimeDeltas.filter { it < expectedFrameNanos * 0.5 }

skiko/src/jvmTest/kotlin/org/jetbrains/skiko/SkiaLayerTest.kt

@@ -394,7 +394,7 @@ class SkiaLayerTest {
             delay(1000)
             screenshots.assert(window.bounds, "frame2", "testFallbackToSoftware")
 
-            assertEquals(GraphicsApi.SOFTWARE, window.layer.renderApi)
+            assertEquals(GraphicsApi.SOFTWARE_COMPAT, window.layer.renderApi)
         } finally {
             window.close()
         }
@@ -408,7 +408,7 @@ class SkiaLayerTest {
             renderApi: GraphicsApi,
             properties: SkiaLayerProperties
         ): Redrawer {
-            return if (renderApi == GraphicsApi.SOFTWARE) {
+            return if (renderApi == GraphicsApi.SOFTWARE_COMPAT) {
                 RenderFactory.Default.createRedrawer(layer, renderApi, properties)
             } else {
                 nonSoftwareRenderFactory.createRedrawer(layer, renderApi, properties)