Added some work on midi parsing

Author: lemcoder

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

@@ -1,5 +1,7 @@
 package pl.lemanski.mikroSoundFont.io
 
+import kotlin.experimental.and
+
 /**
  * Convert byte array to float array with little endian order
  */
@@ -44,5 +46,43 @@ fun FloatArray.toByteArrayBigEndian(): ByteArray {
 
 
 fun ByteArray.readShortAt(index: Int): Short {
-    return ((this[index].toInt() and 0xFF) shl 8 or (this[index + 1].toInt() and 0xFF)).toShort()
+    val shortBuffer = this.copyOfRange(index, index + 2).map { it.toInt() and 0xFF }
+    return (shortBuffer[1] or (shortBuffer[0] shl 8)).toShort()
+}
+
+fun ByteArray.readIntAt(index: Int): Int {
+    val intBuffer = this.copyOfRange(index, index + 4).map { it.toInt() and 0xFF }
+    return intBuffer[3] or (intBuffer[2] shl 8) or (intBuffer[1] shl 16) or (intBuffer[0] shl 24)
+}
+
+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

@@ -0,0 +1,56 @@
+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
+) {
+    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
+    }
+}

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

@@ -5,19 +5,21 @@ import pl.lemanski.mikroSoundFont.io.readShortAt
 
 data class MidiFileHeader(
     val trackCount: Int,
-    val division: Int
+    val division: Int,
 ) {
     companion object {
+        const val SIZE_IN_BYTES = 14
+
         @OptIn(ExperimentalStdlibApi::class)
         fun fromBytes(buffer: ByteArray): MidiFileHeader {
             val trackCount: Int
             val division: Int
 
-            if (buffer.size < 14) {
+            if (buffer.size < SIZE_IN_BYTES) {
                 throw InvalidMidiDataException("Unexpected buffer size. Buffer is too small.")
             }
 
-            val headerBytes = buffer.copyOfRange(0, 14)
+            val headerBytes = buffer.copyOfRange(0, SIZE_IN_BYTES)
 
             if (headerBytes.copyOfRange(0, 4).decodeToString() != "MThd" || headerBytes[7] != 6.toByte() || headerBytes[9] > 2) {
                 throw InvalidMidiDataException("Invalid MThd header: ${headerBytes.toHexString()}")
@@ -30,7 +32,7 @@ data class MidiFileHeader(
             trackCount = headerBytes.readShortAt(10).toInt()
             division = headerBytes.readShortAt(12).toInt() // ticks per beat
 
-            if (trackCount <= 0 ) {
+            if (trackCount <= 0) {
                 throw InvalidMidiDataException("Invalid track values: $trackCount")
             }
 
@@ -44,4 +46,4 @@ data class MidiFileHeader(
             )
         }
     }
-}
+}