Added naive implementation of MIDI parser

Author: lemcoder

core/src/androidMain/kotlin/pl/lemanski/mikroSoundFont/MikroSoundFontLogger.android.kt

@@ -0,0 +1,9 @@
+package pl.lemanski.mikroSoundFont
+
+import android.util.Log
+
+actual fun getLogger(): MikroSoundFontLogger = object : MikroSoundFontLogger {
+    override fun log(message: String) {
+        Log.d("MikroSoundFont", message)
+    }
+}

core/src/androidMain/kotlin/pl/lemanski/mikroSoundFont/io/File.android.kt

@@ -0,0 +1,25 @@
+package pl.lemanski.mikroSoundFont.io
+
+import java.io.File
+
+actual fun loadFile(path: String): ByteArray {
+    val file = File(path)
+    if (!file.exists()) {
+        throw IllegalArgumentException("File does not exist at: $path")
+    }
+
+    return try {
+        file.readBytes()
+    } catch (ex: Exception) {
+        byteArrayOf()
+    }
+}
+
+actual fun saveFile(path: String, byteArray: ByteArray) {
+    val file = File(path)
+    if (file.exists()) {
+        file.createNewFile()
+    }
+
+    file.writeBytes(byteArray)
+}

core/src/androidMain/kotlin/pl/lemanski/mikroSoundFont/io/wav/WavFileHeader.android.kt

@@ -2,6 +2,7 @@ package pl.lemanski.mikroSoundFont.io.wav
 
 import java.nio.ByteBuffer
 import java.nio.ByteOrder
+import java.util.Stack
 
 actual fun WavFileHeader.toByteArray(): ByteArray {
     val byteArray = ByteArray(44) // The size is based on the structure
@@ -36,4 +37,22 @@ actual fun WavFileHeader.toByteArray(): ByteArray {
     buffer.putInt(40, subchunk2Size.toInt())
 
     return byteArray
+}
+
+fun isValid(s: String): Boolean {
+    if (s.length % 2 != 0) {
+        return false
+    }
+
+    val stack = mutableListOf<Char>()
+    s.forEach {
+        when (it) {
+            '(', '{', '[' -> stack.add(it)
+            ')' -> if (stack.lastOrNull() == '(') stack.removeLast() else return false
+            '}' -> if (stack.lastOrNull() == '{') stack.removeLast() else return false
+            ']' -> if (stack.lastOrNull() == '[') stack.removeLast() else return false
+        }
+    }
+
+    return stack.size == 0
 }

core/src/commonMain/kotlin/pl/lemanski/mikroSoundFont/MikroSoundFontLogger.kt

@@ -0,0 +1,7 @@
+package pl.lemanski.mikroSoundFont
+
+interface MikroSoundFontLogger {
+    fun log(message: String)
+}
+
+expect fun getLogger(): MikroSoundFontLogger

core/src/commonMain/kotlin/pl/lemanski/mikroSoundFont/io/File.kt

@@ -0,0 +1,5 @@
+package pl.lemanski.mikroSoundFont.io
+
+expect fun loadFile(path: String): ByteArray
+
+expect fun saveFile(path: String, byteArray: ByteArray)

core/src/commonMain/kotlin/pl/lemanski/mikroSoundFont/io/midi/MidiFileHeader.kt

@@ -0,0 +1,7 @@
+package pl.lemanski.mikroSoundFont.io.midi
+
+data class MidiFileHeader(
+    val format: Int,
+    val numTracks: Int,
+    val division: Int
+)

core/src/commonMain/kotlin/pl/lemanski/mikroSoundFont/io/midi/MidiFileParser.kt

@@ -0,0 +1,90 @@
+package pl.lemanski.mikroSoundFont.io.midi
+
+import pl.lemanski.mikroSoundFont.midi.EventType
+import pl.lemanski.mikroSoundFont.midi.MidiEvent
+
+class MidiFileParser {
+    fun parseMidiFile(data: ByteArray): List<MidiEvent> {
+        val header = parseMidiHeader(data)
+        val events = mutableListOf<MidiEvent>()
+
+        var trackStart = 14 // Header ends at byte 14
+        repeat(header.numTracks) {
+            events.addAll(parseTrack(data, trackStart))
+            trackStart += 8 // Skip over track header and length (MTrk + track length)
+        }
+
+        return events
+    }
+
+    fun readVariableLengthQuantity(data: ByteArray, index: Int): Pair<Int, Int> {
+        var value = 0
+        var i = index
+        var byte: Int
+
+        do {
+            byte = data[i].toInt() and 0xFF
+            value = (value shl 7) or (byte and 0x7F)
+            i++
+        } while (byte and 0x80 != 0)
+
+        return Pair(value, i)
+    }
+
+    fun parseMidiHeader(data: ByteArray): MidiFileHeader {
+        val chunkType = data.sliceArray(0..3).map { it.toInt().toChar() }.joinToString("")
+        if (chunkType != "MThd") throw IllegalArgumentException("Invalid MIDI header")
+
+        val format = ((data[8].toInt() and 0xFF) shl 8) or (data[9].toInt() and 0xFF)
+        val numTracks = ((data[10].toInt() and 0xFF) shl 8) or (data[11].toInt() and 0xFF)
+        val division = ((data[12].toInt() and 0xFF) shl 8) or (data[13].toInt() and 0xFF)
+
+        return MidiFileHeader(format, numTracks, division)
+    }
+
+    fun parseTrack(data: ByteArray, trackStart: Int): List<MidiEvent> {
+        val events = mutableListOf<MidiEvent>()
+        var index = trackStart + 8 // Skip "MTrk" and track length
+        var lastStatusByte = 0
+
+        while (index < data.size) {
+            // Read delta time
+            val (deltaTime, newIndex) = readVariableLengthQuantity(data, index)
+            index = newIndex
+
+            val statusByte = data[index].toInt() and 0xFF
+            index++
+
+            // MIDI running status (if the status byte is missing, reuse the last one)
+            if (statusByte and 0x80 == 0) {
+                index--
+            } else {
+                lastStatusByte = statusByte
+            }
+
+            val command = lastStatusByte and 0xF0
+            val channel = lastStatusByte and 0x0F
+
+            when (command) {
+                0x90 -> { // Note On
+                    val key = data[index].toInt() and 0xFF
+                    val velocity = data[index + 1].toInt() and 0xFF
+                    events.add(MidiEvent(deltaTime.toLong(), EventType.NOTE_ON, listOf(channel, key, velocity)))
+                    index += 2
+                }
+                0x80 -> { // Note Off
+                    val key = data[index].toInt() and 0xFF
+                    events.add(MidiEvent(deltaTime.toLong(), EventType.NOTE_OFF, listOf(channel, key)))
+                    index += 2
+                }
+                0xC0 -> { // Program Change
+                    val program = data[index].toInt() and 0xFF
+                    events.add(MidiEvent(deltaTime.toLong(), EventType.PROGRAM_CHANGE, listOf(channel, program)))
+                    index++
+                }
+                // Add more cases for other types of MIDI events
+            }
+        }
+        return events
+    }
+}

core/src/commonMain/kotlin/pl/lemanski/mikroSoundFont/midi/MidiEvent.kt

@@ -0,0 +1,14 @@
+package pl.lemanski.mikroSoundFont.midi
+
+data class MidiEvent(
+    val deltaTime: Long,
+    val eventType: EventType,
+    val data: List<Int>
+)
+
+enum class EventType {
+    NOTE_ON,
+    NOTE_OFF,
+    PROGRAM_CHANGE,
+    CONTROL_CHANGE
+}

core/src/commonMain/kotlin/pl/lemanski/mikroSoundFont/midi/MidiHeader.kt

@@ -0,0 +1,2 @@
+package pl.lemanski.mikroSoundFont.midi
+

core/src/commonMain/kotlin/pl/lemanski/mikroSoundFont/midi/MidiSequencer.kt

@@ -0,0 +1,47 @@
+package pl.lemanski.mikroSoundFont.midi
+
+import pl.lemanski.mikroSoundFont.SoundFont
+
+class MidiSequencer(
+    private val soundFont: SoundFont
+) {
+    private var currentTime = 0L
+    private val events = mutableListOf<MidiEvent>()
+
+    fun loadMidiEvents(midiEvents: List<MidiEvent>) {
+        events.clear()
+        events.addAll(midiEvents)
+    }
+
+    fun play() {
+        events.forEach { event ->
+            currentTime += event.deltaTime
+            handleEvent(event)
+        }
+    }
+
+    private fun handleEvent(event: MidiEvent) {
+        when (event.eventType) {
+            EventType.NOTE_ON        -> soundFont.noteOn(
+                event.data[0],
+                event.data[1],
+                event.data[2] / 127.0f
+            )
+            EventType.NOTE_OFF       -> soundFont.noteOff(event.data[0], event.data[1])
+            EventType.PROGRAM_CHANGE -> soundFont.setBankPreset(
+                0,
+                event.data[0],
+                event.data[1]
+            )
+            EventType.CONTROL_CHANGE -> handleControlChange(
+                event.data[0],
+                event.data[1],
+                event.data[2]
+            )
+        }
+    }
+
+    private fun handleControlChange(controller: Int, value: Int, channel: Int) {
+        // Handle pitch bends, volume controls, etc.
+    }
+}