Rewrited IO methods to kotlinx io

Author: lemcoder

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

@@ -1,7 +1,5 @@
 package pl.lemanski.mikroSoundFont.io
 
-import kotlin.experimental.and
-
 /**
  * Convert byte array to float array with little endian order
  */
@@ -42,19 +40,4 @@ fun FloatArray.toByteArrayBigEndian(): ByteArray {
         byteArray[i * Float.SIZE_BYTES + 3] = (intBits and 0xFF).toByte()
     }
     return byteArray
-}
-
-
-fun ByteArray.readShortAt(index: Int): Short {
-    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()
 }

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

@@ -1,5 +1,24 @@
 package pl.lemanski.mikroSoundFont.io
 
-expect fun loadFile(path: String): ByteArray
+import kotlinx.io.buffered
+import kotlinx.io.files.Path
+import kotlinx.io.files.SystemFileSystem
+import kotlinx.io.readByteArray
 
-expect fun saveFile(byteArray: ByteArray, path: String)
+fun loadFile(path: String): ByteArray {
+    if (!SystemFileSystem.exists(Path(path))) {
+        return byteArrayOf()
+    }
+
+    return SystemFileSystem.source(Path(path)).buffered().readByteArray()
+}
+
+fun saveFile(byteArray: ByteArray, path: String) {
+    val p = Path(path)
+
+    if (!SystemFileSystem.exists(p)) {
+        SystemFileSystem.createDirectories(p)
+    }
+
+    SystemFileSystem.sink(p).buffered().write(byteArray)
+}

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

@@ -1,7 +1,6 @@
 package pl.lemanski.mikroSoundFont.io.midi
 
 import pl.lemanski.mikroSoundFont.midi.MidiMessage
-import pl.lemanski.mikroSoundFont.midi.MidiMetaMessage
 import pl.lemanski.mikroSoundFont.midi.MidiTrack
 import pl.lemanski.mikroSoundFont.midi.UnsupportedMidiMessage
 
@@ -17,8 +16,6 @@ data class MidiFile(
     fun getMessagesOverTime(): List<MidiMessage> {
         val division = header.division
         var ticks2time = 500000 / (1000.0 * division)
-        var tempoTicks = 0     // Tick count at the last tempo change
-        var tempoMsec = 0      // Milliseconds at the last tempo change
 
         val allMessages = mutableListOf<MidiMessage>()
 
@@ -29,15 +26,16 @@ data class MidiFile(
                 if (msg is UnsupportedMidiMessage) continue
                 trackTicks += msg.time
 
-                val millis = tempoMsec + ((trackTicks - tempoTicks) * ticks2time).toInt()
-                msg.time = millis
+                val millis = trackTicks * ticks2time
+                msg.time = millis.toInt()
+// TODO
 
-                if (msg is MidiMetaMessage.SetTempo) {
-                    val tempo = msg.tempo
-                    ticks2time = tempo / (1000.0 * division)
-                    tempoTicks = trackTicks
-                    tempoMsec = millis
-                }
+//                if (msg is MidiMetaMessage.SetTempo) {
+//                    val tempo = msg.tempo
+//                    ticks2time = tempo / (1000.0 * division)
+//                    tempoTicks = trackTicks
+//                    tempoMsec = millis
+//                }
 
                 allMessages.add(msg)
             }

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

@@ -1,5 +1,10 @@
 package pl.lemanski.mikroSoundFont.io.wav
 
+import kotlinx.io.Buffer
+import kotlinx.io.readByteArray
+import kotlinx.io.writeIntLe
+import kotlinx.io.writeShortLe
+
 data class WavFileHeader(
     val chunkID: String = "RIFF",
     val chunkSize: UInt,
@@ -29,4 +34,21 @@ data class WavFileHeader(
     }
 }
 
-expect fun WavFileHeader.toByteArray(): ByteArray
+fun WavFileHeader.toByteArray(): ByteArray {
+    return Buffer()
+        .apply {
+            write(chunkID.encodeToByteArray(), 0, 4)
+            writeIntLe(chunkSize.toInt())
+            write(format.encodeToByteArray(), 0, 4)
+            write(subchunk1ID.encodeToByteArray(), 0, 4)
+            writeIntLe(subchunk1Size.toInt())
+            writeShortLe(audioFormat.toShort())
+            writeShortLe(numChannels.toShort())
+            writeIntLe(sampleRate.toInt())
+            writeIntLe(byteRate.toInt())
+            writeShortLe(blockAlign.toShort())
+            writeShortLe(bitsPerSample.toShort())
+            write(subchunk2ID.encodeToByteArray(), 0, 4)
+            writeIntLe(subchunk2Size.toInt())
+        }.readByteArray()
+}

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

@@ -6,28 +6,24 @@ import pl.lemanski.mikroSoundFont.getLogger
 class MidiSequencer(
     private val soundFont: SoundFont,
     private val sampleRate: Int,
-    private val sampleBlockSize: Int
 ) {
+    private val sampleBlockSize: Int = 512
     private val logger = getLogger()
     private var currentTime = 0L
-    private val events = mutableListOf<MidiMessage>()
+    private val messages = mutableListOf<MidiMessage>()
 
-    fun loadMidiEvents(midiEvents: List<MidiMessage>) {
-        events.clear()
-        events.addAll(midiEvents)
+    fun loadMidiEvents(midiMessages: List<MidiMessage>) {
+        messages.clear()
+        messages.addAll(midiMessages)
     }
 
     fun generate(): FloatArray {
         var currentTime = 0.0
         var audioBuffer = FloatArray(0)
-        val i = events.iterator()
-        var message: MidiMessage? = if (i.hasNext()) i.next() else return floatArrayOf()
 
-        while (i.hasNext()) {
-            message?.process()
-            message = i.next()
-
-            val targetTime = message.time.toDouble()
+        for (msg in messages) {
+            msg.process()
+            val targetTime = msg.time.toDouble()
 
             while (targetTime >= currentTime) {
                 currentTime += sampleBlockSize * (1000.0 / sampleRate)
@@ -39,8 +35,11 @@ class MidiSequencer(
     }
 
     private fun MidiMessage.process() = when (this) {
-        is MidiVoiceMessage.NoteOff -> soundFont.noteOff(channel, key)
-        is MidiVoiceMessage.NoteOn  -> soundFont.noteOn(channel, key, velocity / 127.0f)
-        else                        -> logger.log("Unknown message type")
+        is MidiVoiceMessage.NoteOff       -> soundFont.channels[channel].noteOff(key)
+        is MidiVoiceMessage.NoteOn        -> soundFont.channels[channel].noteOn(key, velocity / 127.0f)
+        is MidiVoiceMessage.PitchBend     -> soundFont.channels[channel].setPitchWheel(pitchBend)
+        is MidiVoiceMessage.ProgramChange -> soundFont.channels[channel].setPresetNumber(program, channel == 9)
+        is MidiVoiceMessage.ControlChange -> soundFont.channels[channel].setMidiControl(control, controlValue)
+        else                              -> { }
     }
 }

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

@@ -14,15 +14,16 @@ class MidiTest {
 
     @Test
     fun testMidi() {
-        val midiFileBuffer = loadFile("$dir\\venture.mid")
+        val midiFileBuffer = loadFile("$dir\\hbd.mid")
         val midiFile = MidiFileParser(midiFileBuffer).parse()
         val messages = midiFile.getMessagesOverTime()
 
         val soundFont = MikroSoundFont.load("$dir\\font.sf2")
 
-        val sequencer = MidiSequencer(soundFont, 44100, 512)
+        val sequencer = MidiSequencer(soundFont, 44_100)
         sequencer.loadMidiEvents(messages)
         val wavBytes = sequencer.generate()
+        println(wavBytes.size)
 
         val wavHeader =  WavFileHeader.write(44_100u, wavBytes.size.toUInt(), 2u)
         val file = wavHeader.toByteArray() + wavBytes.toByteArrayLittleEndian()

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

@@ -2,6 +2,6 @@ package pl.lemanski.mikroSoundFont
 
 actual fun getLogger(): MikroSoundFontLogger = object : MikroSoundFontLogger {
     override fun log(message: String) {
-        println("message")
+        println(message)
     }
 }