Fix #103: handle realtime messages within SysEx chunks accordingly (Claude Code)

Author: atsushieno

ktmidi/src/commonMain/kotlin/dev/atsushieno/ktmidi/Midi1SysExChunkProcessor.kt

@@ -2,35 +2,72 @@ package dev.atsushieno.ktmidi
 
 class Midi1SysExChunkProcessor {
     val remaining = mutableListOf<Byte>()
+    private fun isStatusByte(byte: Byte): Boolean = (byte.toInt() and 0x80) != 0
+
+    private fun isRealTimeMessage(byte: Byte): Boolean {
+        val value = byte.toInt() and 0xFF
+        return value >= 0xF8
+    }
+
+    private fun findSysExTermination(input: List<Byte>, startPos: Int = 0): Int {
+        for (i in startPos until input.size) {
+            val byte = input[i]
+            val value = byte.toInt() and 0xFF
+
+            if (value == 0xF7)
+                return i
+
+            if (isStatusByte(byte) && !isRealTimeMessage(byte) && value != 0xF0)
+                return i - 1
+        }
+        return -1
+    }
+
     // Returns a sequence of "event list" that are "complete" i.e. not pending.
     // Any incomplete sysex buffer is stored in `remaining`.
     // If there is no buffer and the input is an incomplete SysEx buffer, then only an empty sequence is returned.
     fun process(input: List<Byte>): Sequence<List<Byte>> = sequence {
         if (remaining.isNotEmpty()) {
-            val f7Pos = input.indexOf(0xF7.toByte())
-            if (f7Pos < 0)
+            val terminationPos = findSysExTermination(input)
+            if (terminationPos < 0) {
                 remaining.addAll(input)
-            else {
-                yield(remaining + input.take(f7Pos + 1))
-                remaining.clear()
-                // process the remaining recursively
-                yieldAll(process(input.drop(f7Pos + 1)))
+            } else {
+                val endByte = input[terminationPos]
+                val isEOX = (endByte.toInt() and 0xFF) == 0xF7
+
+                if (isEOX) {
+                    yield(remaining + input.take(terminationPos + 1))
+                    remaining.clear()
+                    yieldAll(process(input.drop(terminationPos + 1)))
+                } else {
+                    yield(remaining + input.take(terminationPos + 1))
+                    remaining.clear()
+                    yieldAll(process(input.drop(terminationPos + 1)))
+                }
             }
         } else {
             // If sysex is found then check if it is incomplete.
             // F0 must occur only as the beginning of SysEx, so simply check it by indexOf().
             val f0Pos = input.indexOf(0xF0.toByte())
-            if (f0Pos < 0)
-                yield(input)
-            else {
-                yield(input.take(f0Pos))
-                val f7Pos = input.indexOf(0xF7.toByte())
-                if (f7Pos < 0)
-                    remaining.addAll(input)
-                else {
-                    yield(input.take(f7Pos + 1))
-                    // process the remaining recursively
-                    yieldAll(process(input.drop(f7Pos + 1)))
+            if (f0Pos < 0) {
+                if (input.isNotEmpty())
+                    yield(input)
+            } else {
+                    yield(input.take(f0Pos))
+                val terminationPos = findSysExTermination(input, f0Pos + 1)
+                if (terminationPos < 0) {
+                    remaining.addAll(input.drop(f0Pos))
+                } else {
+                    val endByte = input[terminationPos]
+                    val isEOX = (endByte.toInt() and 0xFF) == 0xF7
+
+                    if (isEOX) {
+                        yield(input.subList(f0Pos, terminationPos + 1))
+                        yieldAll(process(input.drop(terminationPos + 1)))
+                    } else {
+                        yield(input.subList(f0Pos, terminationPos + 1))
+                        yieldAll(process(input.drop(terminationPos + 1)))
+                    }
                 }
             }
         }

ktmidi/src/commonTest/kotlin/dev/atsushieno/ktmidi/Midi1SysExChunkProcessorTest.kt

@@ -2,6 +2,7 @@ package dev.atsushieno.ktmidi
 
 import kotlin.test.Test
 import kotlin.test.assertContentEquals
+import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 
 class Midi1SysExChunkProcessorTest {
@@ -22,4 +23,78 @@ class Midi1SysExChunkProcessorTest {
             assertContentEquals(sysex, seq2.toList(), "round $it: #2")
         }
     }
+
+    @Test
+    fun sysexTerminatedByNonRealTimeStatusByte() {
+        val processor = Midi1SysExChunkProcessor()
+        val input = listOf(
+            0xF0, 0x7E, 0x7F, 0x0D,
+            0x90, 0x3C, 0x40
+        ).map { it.toByte() }
+
+        val result = processor.process(input).toList()
+        assertEquals(2, result.size)
+        assertContentEquals(listOf(0xF0, 0x7E, 0x7F, 0x0D).map { it.toByte() }, result[0])
+        assertContentEquals(listOf(0x90, 0x3C, 0x40).map { it.toByte() }, result[1])
+    }
+
+    @Test
+    fun sysexTerminatedByNonRealTimeStatusByteInRemainingBuffer() {
+        val processor = Midi1SysExChunkProcessor()
+        val input1 = listOf(0xF0, 0x7E, 0x7F).map { it.toByte() }
+        val input2 = listOf(0x0D, 0x90, 0x3C, 0x40).map { it.toByte() }
+
+        val result1 = processor.process(input1).toList()
+        assertEquals(0, result1.size)
+
+        val result2 = processor.process(input2).toList()
+        assertEquals(2, result2.size)
+        assertContentEquals(listOf(0xF0, 0x7E, 0x7F, 0x0D).map { it.toByte() }, result2[0])
+        assertContentEquals(listOf(0x90, 0x3C, 0x40).map { it.toByte() }, result2[1])
+    }
+
+    @Test
+    fun realTimeMessagesDuringIncompleteSysex() {
+        val processor = Midi1SysExChunkProcessor()
+        val input1 = listOf(0xF0, 0x7E, 0xF8, 0x7F).map { it.toByte() }
+        val input2 = listOf(0x0D, 0xFE, 0x7E, 0xF7).map { it.toByte() }
+
+        val result1 = processor.process(input1).toList()
+        assertEquals(0, result1.size)
+
+        val result2 = processor.process(input2).toList()
+        assertEquals(1, result2.size)
+        assertContentEquals(
+            listOf(0xF0, 0x7E, 0xF8, 0x7F, 0x0D, 0xFE, 0x7E, 0xF7).map { it.toByte() },
+            result2[0]
+        )
+    }
+
+    @Test
+    fun realTimeMessagesInCompleteSysex() {
+        val processor = Midi1SysExChunkProcessor()
+        val input = listOf(0xF0, 0x7E, 0xF8, 0x7F, 0x0D, 0xFE, 0x7E, 0xF7).map { it.toByte() }
+
+        val result = processor.process(input).toList()
+        assertEquals(1, result.size)
+        assertContentEquals(input, result[0])
+    }
+
+    @Test
+    fun multipleSysexMessagesTerminatedByStatusBytes() {
+        val processor = Midi1SysExChunkProcessor()
+        val input = listOf(
+            0xF0, 0x01, 0x02,
+            0x90, 0x3C, 0x40,
+            0xF0, 0x03, 0x04, 0xF7,
+            0x80, 0x3C, 0x00
+        ).map { it.toByte() }
+
+        val result = processor.process(input).toList()
+        assertEquals(4, result.size)
+        assertContentEquals(listOf(0xF0, 0x01, 0x02).map { it.toByte() }, result[0])
+        assertContentEquals(listOf(0x90, 0x3C, 0x40).map { it.toByte() }, result[1])
+        assertContentEquals(listOf(0xF0, 0x03, 0x04, 0xF7).map { it.toByte() }, result[2])
+        assertContentEquals(listOf(0x80, 0x3C, 0x00).map { it.toByte() }, result[3])
+    }
 }