Improved architecture

Author: lemcoder

core/build.gradle.kts

@@ -37,8 +37,8 @@ kotlin {
     sourceSets {
 
         commonMain.dependencies {
-            implementation(libs.coroutines.core)
             implementation(projects.lib)
+            implementation(libs.kotlinx.io)
         }
 
         commonTest.dependencies {

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

@@ -57,32 +57,4 @@ fun ByteArray.readIntAt(index: Int): Int {
 
 fun ByteArray.readByteAt(index: Int): Byte {
     return this[index] and 0xFF.toByte()
-}
-
-fun ByteArray.readVariableLengthAt(index: Int): Pair<Int, Int>? {
-    var pos = index
-    var result = 0
-    var i = 0
-    var countinuation: Int
-
-    while (i < 4) {
-        if (pos >= size) {
-            break
-        }
-
-        countinuation = this[pos].toInt() and 0xFF
-        pos++
-
-        if (countinuation and 0x80 != 0) {
-            // store data bits in result
-            result = ((result or (countinuation and 0x7F)) shl 7)
-        } else {
-            // return result
-            return (result or countinuation) to pos
-        }
-
-        i++
-    }
-
-    return null
 }

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

@@ -1,56 +1,13 @@
 package pl.lemanski.mikroSoundFont.io.midi
 
-import pl.lemanski.mikroSoundFont.midi.MidiMessage
-import pl.lemanski.mikroSoundFont.midi.MidiMessageType
 import pl.lemanski.mikroSoundFont.midi.MidiTrack
 
-class MidiFile(
-    private val buffer: ByteArray
+data class MidiFile(
+    val header: Header,
+    val tracks: List<MidiTrack>
 ) {
-    val header: MidiFileHeader
-    val tracks: Array<MidiTrack>
-
-    init {
-        header = MidiFileHeader.fromBytes(buffer)
-        var data = buffer.copyOfRange(MidiFileHeader.SIZE_IN_BYTES, buffer.size)
-        tracks = Array(header.trackCount) {
-            val track = MidiTrack.fromBytes(data)
-            data = data.copyOfRange(track.rawData.size + 8, data.size)
-            track
-        }
-    }
-
-    /**
-     * Messages are ordered by the absolute time of occurrence
-     * meaning that delta times has been converted to absolute times.
-     *
-     * @return messages parsed from all tracks.
-     */
-    fun messages(): List<MidiMessage> {
-        val actualMessages = mutableListOf<MidiMessage>()
-        var totalTicks = 0
-        var tempoMsec = 0
-        var tempoTicks = 0
-        var ticksToTime = 500_000.0 / (1000.0 * header.division)
-
-        for (track in tracks) {
-            track.messages.sortedBy { it.time }
-            for (msg in track.messages) {
-                totalTicks += msg.time
-                val actualTime = tempoMsec + ((totalTicks - tempoTicks) * ticksToTime).toInt()
-                val actual = msg.copy(time = actualTime)
-
-                if (actual.type is MidiMessageType.SetTempo) {
-                    val tempo = actual.type.tempo
-                    ticksToTime = (tempo[0].toInt() shl 16 or (tempo[1].toInt() shl 8) or tempo[2].toInt()) / (1000.0 * header.division)
-                    tempoMsec = actualTime
-                    tempoTicks = totalTicks
-                }
-
-                actualMessages.add(actual)
-            }
-        }
-
-        return actualMessages
-    }
-}
+    data class Header(
+        val trackCount: Int,
+        val division: Int,
+    )
+}

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

@@ -0,0 +1,101 @@
+package pl.lemanski.mikroSoundFont.io.midi
+
+import kotlinx.io.Buffer
+import kotlinx.io.readString
+import kotlinx.io.readUInt
+import kotlinx.io.readUShort
+import pl.lemanski.mikroSoundFont.InvalidMidiDataException
+import pl.lemanski.mikroSoundFont.io.midi.message.MidiMessageContext
+import pl.lemanski.mikroSoundFont.midi.MidiMessage
+import pl.lemanski.mikroSoundFont.midi.MidiTrack
+
+internal class MidiFileParser(
+    private val data: ByteArray,
+) {
+    private val buffer = Buffer().apply {
+        write(data)
+    }
+
+    fun parse(): MidiFile {
+        val header = parseHeader()
+        val tracks = parseTracks(header.trackCount)
+
+        return MidiFile(
+            header = header,
+            tracks = tracks
+        )
+    }
+
+    internal fun parseHeader(): MidiFile.Header {
+        val hSize = 14
+
+        if (buffer.size < hSize) {
+            throw InvalidMidiDataException("Unexpected buffer size. Buffer is too small.")
+        }
+
+        if (buffer.readString(4) != "MThd") {
+            throw InvalidMidiDataException("Invalid MThd header: $buffer")
+        }
+
+        if (buffer.readUInt() != 6u) {
+            throw InvalidMidiDataException("Invalid MThd header: $buffer")
+        }
+
+        if (buffer.readUShort() > 2u) {
+            throw InvalidMidiDataException("Invalid MThd header: $buffer")
+        }
+
+        val trackCount: Int = buffer.readShort().toInt()
+        val division: Int = buffer.readShort().toInt() // ticks per beat
+
+        if ((division shl 8) and 0x80 != 0) {
+            throw InvalidMidiDataException("Unsupported SMPTE timing: $buffer")
+        }
+
+        if (trackCount <= 0) {
+            throw InvalidMidiDataException("Invalid track values: $trackCount")
+        }
+
+        if (division <= 0) {
+            throw InvalidMidiDataException("Invalid division values: $division")
+        }
+
+        return MidiFile.Header(
+            trackCount = trackCount,
+            division = division
+        )
+    }
+
+    internal fun parseTracks(n: Int): List<MidiTrack> = List(n) { idx -> parseTrack(idx) }
+
+    internal fun parseTrack(id: Int): MidiTrack {
+        val trackHeader = parseTrackHeader()
+        val trackBuffer = Buffer()
+        val messages = mutableListOf<MidiMessage>()
+
+        buffer.copyTo(trackBuffer, 0L, trackHeader.dataSize.toLong())
+
+        val messageContext = MidiMessageContext(trackBuffer)
+        while (trackBuffer.size > 0) {
+            messages.add(messageContext.readMessage())
+        }
+
+        return MidiTrack(
+            header = trackHeader,
+            messages = messages
+        )
+    }
+
+    internal fun parseTrackHeader(): MidiTrack.Header {
+        if (buffer.readString(4) != "MTrk") {
+            throw InvalidMidiDataException("Invalid MTrk header: $buffer")
+        }
+
+        val trackLength = buffer.readInt()
+        if (trackLength < 0) {
+            throw InvalidMidiDataException("Invalid MTrk header.Track length is negative: $buffer")
+        }
+
+        return MidiTrack.Header(dataSize = trackLength)
+    }
+}

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

@@ -0,0 +1,23 @@
+package pl.lemanski.mikroSoundFont.io.midi.message
+
+import kotlinx.io.Buffer
+import kotlinx.io.readUByte
+import pl.lemanski.mikroSoundFont.InvalidMidiDataException
+
+internal fun Buffer.readVarLen(): Int {
+    var r = 0
+    var c: Int
+    var bytesRead = 0
+
+    do {
+        c = readUByte().toInt()
+        bytesRead++
+        r = (r shl 7) or (c and 0x7F) // add 7 LSB of c to r
+    } while (c and 0x80 != 0 && bytesRead < 4) // until c MSB is 1
+
+    if (bytesRead >= 4) {
+        throw InvalidMidiDataException("Malformed MIDI. Variable length quantity exceeds 32 bits.")
+    }
+
+    return r
+}

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

@@ -0,0 +1,37 @@
+package pl.lemanski.mikroSoundFont.io.midi.message
+
+import kotlinx.io.Buffer
+import kotlinx.io.readUByte
+import pl.lemanski.mikroSoundFont.io.midi.message.read.MidiMessageParser
+import pl.lemanski.mikroSoundFont.io.midi.message.read.MidiMetaMessageParser
+import pl.lemanski.mikroSoundFont.io.midi.message.read.MidiSystemMessageParser
+import pl.lemanski.mikroSoundFont.io.midi.message.read.MidiVoiceMessageParser
+import pl.lemanski.mikroSoundFont.midi.MidiMessage
+import pl.lemanski.mikroSoundFont.midi.UnsupportedMidiMessage
+
+internal class MidiMessageContext(
+    private val buffer: Buffer
+) {
+    private val systemMessageParser = MidiSystemMessageParser(buffer)
+    private val voiceMessageParser = MidiVoiceMessageParser(buffer)
+    private val metaMessageParser = MidiMetaMessageParser(buffer)
+    private lateinit var parser: MidiMessageParser
+
+    fun readMessage(): MidiMessage {
+        val dt = buffer.readVarLen()
+        val status = buffer.readUByte().toInt()
+
+        parser = when (status) {
+            in systemMessageParser.supportedTypes() -> systemMessageParser
+            in metaMessageParser.supportedTypes()   -> metaMessageParser
+            in voiceMessageParser.supportedTypes()  -> voiceMessageParser
+            else                                    -> return UnsupportedMidiMessage
+        }
+
+        return parser.parse(status, dt)
+    }
+
+    fun writeMessage() {
+        // TODO
+    }
+}

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

@@ -0,0 +1,21 @@
+package pl.lemanski.mikroSoundFont.io.midi.message.read
+
+import pl.lemanski.mikroSoundFont.midi.MidiMessage
+
+/**
+ * Parser for midi messages.
+ */
+internal interface MidiMessageParser {
+    /**
+     * Parses a midi message.
+     * @param deltaTime the delta time since the last message
+     *
+     * @return [MidiMessage]
+     */
+    fun parse(status: Int, deltaTime: Int = 0): MidiMessage
+
+    /**
+     * @return the types of midi messages that this parser supports.
+     */
+    fun supportedTypes(): Set<Int>
+}