Add audio generation from bytes

Author: lemcoder

app/build.gradle.kts

@@ -11,7 +11,8 @@ kotlin {
 
     sourceSets {
         mingwMain.dependencies {
-            implementation(projects.core)
+            implementation(libs.kotlinx.io)
+            implementation(libs.pandamidi.core)
         }
     }
 }

app/src/nativeMain/kotlin/Main.kt

@@ -1,8 +1,20 @@
+import kotlinx.cinterop.ExperimentalForeignApi
+import kotlinx.cinterop.memScoped
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import kotlinx.io.Buffer
+import kotlinx.io.files.Path
+import kotlinx.io.files.SystemFileSystem
+import kotlinx.io.readByteArray
 import pl.lemanski.pandamidi.core.Note
+import pl.lemanski.pandamidi.io.getMidiProcessor
 import pl.lemanski.pandamidi.io.getMidiWavConverter
 import pl.lemanski.pandamidi.sequencer.MidiEvent
 import pl.lemanski.pandamidi.sequencer.MidiSequence
+import platform.posix.sleep
 
+@OptIn(ExperimentalForeignApi::class)
 fun main() {
     val c = MidiEvent(MidiEvent.Type.NOTE_ON, Note(60), 0, 0)
     val e = MidiEvent(MidiEvent.Type.NOTE_ON, Note(64), 0, 0)
@@ -11,10 +23,39 @@ fun main() {
     sequence.addEvent(c)
     sequence.addEvent(e)
 
-    val soundFontPath = "C:\\Users\\lenovo\\Desktop\\midiWavConverter\\florestan-subset.sf2"
-    val midiPath = "C:\\Users\\lenovo\\Desktop\\midiWavConverter\\venture.mid"
+    val soundFontPath = Path("D:\\src\\MidiWavConverter\\Example\\florestan-subset.sf2")
+    val midiPath = Path("D:\\src\\MidiWavConverter\\Example\\venture.mid")
+
+    SystemFileSystem.metadataOrNull(midiPath)?.let {
+        println("size of file is: ${it.size}")
+    }
+
+    val sink = Buffer()
+
+    SystemFileSystem.source(midiPath).let {
+        var bytesRead = it.readAtMostTo(sink, 100)
+        while (bytesRead > 0) {
+            bytesRead = it.readAtMostTo(sink, 100)
+        }
+    }
 
     val midiToWavConverter = getMidiWavConverter()
-    val path = midiToWavConverter.generate(soundFontPath, midiPath)
+    val path = midiToWavConverter.generate(soundFontPath.toString(), midiPath.toString())
     println(path)
+
+
+    val midiProcessor = getMidiProcessor()
+    midiProcessor.setSoundFontFromPath(soundFontPath.toString())
+    midiProcessor.setAudioCallback { audioBytes ->
+        println("Audio data received: ${audioBytes.size} bytes")
+
+    }
+
+    memScoped {
+        CoroutineScope(Job()).launch {
+            midiProcessor.processMidiBytes(sink.readByteArray())
+        }
+    }
+
+    sleep(5u)
 }

core/build.gradle.kts

@@ -1,26 +1,41 @@
 plugins {
     alias(libs.plugins.kotlinMultiplatform)
+    id("maven-publish")
 }
 
+group = "pl.lemanski.pandamidi"
+version = "0.0.1"
+
 kotlin {
     mingwX64().apply {
         val main by compilations.getting
 
-        main.cinterops.create("mwc") {
-            packageName = "pl.lemanski.mwc"
-            extraOpts("-header", "$rootDir\\native\\include\\midi_wav_converter.h")
+        main.compileTaskProvider.configure {
+            compilerOptions {
+                freeCompilerArgs.add("-Xbinary=gc=noop")
+            }
+        }
+
+        main.cinterops.create("libmwc") {
+            definitionFile = File(rootDir, "native/libmwc.def")
+            includeDirs.headerFilterOnly("$rootDir\\native\\include")
             extraOpts("-libraryPath", "$rootDir\\native\\lib")
-            extraOpts("-staticLibrary", "libmwc.a")
         }
     }
 
     sourceSets {
         commonMain.dependencies {
-            //put your multiplatform dependencies here
+            implementation(libs.coroutines.core)
         }
 
         commonTest.dependencies {
             implementation(libs.kotlin.test)
         }
     }
+}
+
+publishing {
+    repositories {
+        mavenLocal()
+    }
 }

core/src/commonMain/kotlin/pl/lemanski/pandamidi/io/MidiProcessor.kt

@@ -0,0 +1,23 @@
+package pl.lemanski.pandamidi.io
+
+/**
+ * Represents a MIDI processor that can process MIDI bytes and generate audio data.
+ */
+interface MidiProcessor : AutoCloseable {
+    /**
+     * Sets the callback function to be called when audio data is available.
+     */
+    fun setAudioCallback(callback: (ByteArray) -> Unit)
+
+    /**
+     * Sets the sound font from a path.
+     */
+    fun setSoundFontFromPath(soundFontPath: String)
+
+    /**
+     * Processes MIDI bytes and generates audio data.
+     */
+    suspend fun processMidiBytes(midiBytes: ByteArray)
+}
+
+expect fun getMidiProcessor(): MidiProcessor

core/src/mingwX64Main/kotlin/pl/lemanski/pandamidi/io/MidiProcessor.mingwX64.kt

@@ -0,0 +1,45 @@
+package pl.lemanski.pandamidi.io
+
+import kotlinx.cinterop.CPointer
+import kotlinx.cinterop.ExperimentalForeignApi
+import kotlinx.cinterop.ULongVar
+import kotlinx.cinterop.memScoped
+import kotlinx.cinterop.pointed
+import kotlinx.cinterop.readBytes
+import kotlinx.cinterop.refTo
+import kotlinx.cinterop.reinterpret
+import kotlinx.cinterop.value
+import platform.posix.malloc
+
+@OptIn(ExperimentalForeignApi::class)
+actual fun getMidiProcessor(): MidiProcessor {
+    return object : MidiProcessor {
+        private var audioCallback: (ByteArray) -> Unit = { }
+
+        override fun setAudioCallback(callback: (ByteArray) -> Unit) {
+            audioCallback = callback
+        }
+
+        override fun setSoundFontFromPath(soundFontPath: String) {
+            val sanitizedSoundFontPath = soundFontPath.replace("/", "\\")
+            libmwc.initialize_soundfont(sanitizedSoundFontPath)
+        }
+
+        override suspend fun processMidiBytes(midiBytes: ByteArray) {
+            memScoped {
+                val pOutputBufferSize: CPointer<ULongVar> = malloc(8u)?.reinterpret() ?: throw RuntimeException("Memory allocation failed")
+                val pUByteArray = midiBytes.toUByteArray().refTo(0)
+                val midiSize = midiBytes.size.toULong()
+
+                val buffer = libmwc.generate_from_midi_buffer(pUByteArray, midiSize, pOutputBufferSize) ?: throw RuntimeException("Failed to generate audio buffer")
+                val bufferBytes = buffer.readBytes(pOutputBufferSize.pointed.value.toInt())
+
+                audioCallback(bufferBytes)
+            }
+        }
+
+        override fun close() {
+            libmwc.release_soundfont()
+        }
+    }
+}

core/src/mingwX64Main/kotlin/pl/lemanski/pandamidi/io/MidiWavConverter.mingwX64.kt

@@ -1,15 +1,8 @@
 package pl.lemanski.pandamidi.io
 
 import kotlinx.cinterop.ExperimentalForeignApi
-import kotlinx.cinterop.addressOf
-import kotlinx.cinterop.toKString
-import kotlinx.cinterop.usePinned
-import platform.posix.getcwd
-
-@OptIn(ExperimentalForeignApi::class)
-internal fun getCwd(): String? {
-    return ByteArray(1024).usePinned { getcwd(it.addressOf(0), 1024) }?.toKString()
-}
+import kotlinx.cinterop.memScoped
+import pl.lemanski.pandamidi.util.getCwd
 
 @OptIn(ExperimentalForeignApi::class)
 actual fun getMidiWavConverter(): MidiWavConverter {
@@ -21,7 +14,11 @@ actual fun getMidiWavConverter(): MidiWavConverter {
 
             val midiFileName = sanitizedMidiFilePath.split("\\").last().replace(".mid", "")
             val wavFilePath = "$pwd\\$midiFileName.wav"
-            pl.lemanski.mwc.generate(sanitizedSoundFontPath, sanitizedMidiFilePath, wavFilePath)
+            memScoped {
+                libmwc.initialize_soundfont(sanitizedSoundFontPath)
+                libmwc.generate(sanitizedMidiFilePath, wavFilePath)
+                libmwc.release_soundfont()
+            }
             return wavFilePath
         }
     }

core/src/mingwX64Main/kotlin/pl/lemanski/pandamidi/util/PosixUtils.kt

@@ -0,0 +1,13 @@
+package pl.lemanski.pandamidi.util
+
+import kotlinx.cinterop.ExperimentalForeignApi
+import kotlinx.cinterop.addressOf
+import kotlinx.cinterop.toKString
+import kotlinx.cinterop.usePinned
+import platform.posix.getcwd
+
+
+@OptIn(ExperimentalForeignApi::class)
+internal fun getCwd(): String? {
+    return ByteArray(1024).usePinned { getcwd(it.addressOf(0), 1024) }?.toKString()
+}

core/src/nativeInterop/cinterop/tsf.def

@@ -5,7 +5,4 @@ org.gradle.configuration-cache=true
 
 #Kotlin
 kotlin.code.style=official
-
-#Android
-android.useAndroidX=true
-android.nonTransitiveRClass=true
+kotlin.mpp.enableCInteropCommonization=true

gradle.properties

@@ -1,8 +1,14 @@
 [versions]
 kotlin = "2.0.0"
+coroutines = "1.9.0-RC"
+pandaMidi = "0.0.1"
+kotlinxIo = "0.5.1"
 
 [libraries]
 kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }
+kotlinx-io = { module = "org.jetbrains.kotlinx:kotlinx-io-core", version.ref = "kotlinxIo" }
+coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "coroutines" }
+pandamidi-core = { module = "pl.lemanski.pandamidi:core", version.ref = "pandaMidi" }
 
 [plugins]
 kotlinMultiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }