Create MIDI.py

MIDI.py

@@ -0,0 +1,330 @@
+#!/usr/bin/python3
+"""
+A simplified MIDI file parsing and generation module.
+
+This module provides functions to convert between MIDI files and two list-based
+representations: "opus" (delta-time events) and "score" (absolute-time notes).
+Text events are kept as bytes to handle various encodings (e.g., Shift-JIS)
+correctly, avoiding decoding errors noted in the original comment.
+
+Core functions:
+- midi2opus: Parse MIDI bytes to an opus structure.
+- opus2midi: Convert an opus to MIDI bytes.
+- score2opus: Convert a score to an opus.
+- opus2score: Convert an opus to a score.
+- midi2score: Parse MIDI bytes to a score.
+- score2midi: Convert a score to MIDI bytes.
+
+Event formats:
+- Opus: ['event_type', delta_time, ...] (e.g., ['note_on', 5, 0, 60, 100])
+- Score: ['note', start_time, duration, channel, pitch, velocity] for notes,
+         other events retain their opus format with absolute times.
+
+Dependencies: Python 3, struct module.
+"""
+
+import struct
+
+# Version info
+__version__ = "1.0"
+__date__ = "2023-10-01"
+
+# --- Helper Functions ---
+
+def _read_vlq(data, offset):
+    """Read a variable-length quantity from data at offset."""
+    value = 0
+    while True:
+        byte = data[offset]
+        offset += 1
+        value = (value << 7) | (byte & 0x7F)
+        if not (byte & 0x80):
+            break
+    return value, offset
+
+def _write_vlq(value):
+    """Write a variable-length quantity as bytes."""
+    if value == 0:
+        return b'\x00'
+    parts = []
+    while value > 0:
+        parts.append(value & 0x7F)
+        value >>= 7
+    parts.reverse()
+    for i in range(len(parts) - 1):
+        parts[i] |= 0x80
+    return bytes(parts)
+
+def _write_14_bit(value):
+    """Encode a 14-bit value into two bytes."""
+    return bytes([value & 0x7F, (value >> 7) & 0x7F])
+
+# --- Decoding Functions ---
+
+def _decode_track(data):
+    """Decode MIDI track bytes into a list of opus events."""
+    events = []
+    offset = 0
+    running_status = None
+
+    while offset < len(data):
+        # Read delta time
+        delta_time, offset = _read_vlq(data, offset)
+        event_type = data[offset]
+        offset += 1
+
+        # Handle running status
+        if event_type >= 0x80:
+            status = event_type
+            running_status = status
+        else:
+            if running_status is None:
+                raise ValueError("Running status used without prior status")
+            status = running_status
+            offset -= 1  # Backtrack to use byte as parameter
+
+        # Channel messages (0x80-0xEF)
+        if 0x80 <= status <= 0xEF:
+            channel = status & 0x0F
+            command = status & 0xF0
+
+            if command in (0x80, 0x90, 0xA0, 0xB0, 0xE0):  # Two parameters
+                param1, param2 = data[offset], data[offset + 1]
+                offset += 2
+                if command == 0x80:
+                    event = ['note_off', delta_time, channel, param1, param2]
+                elif command == 0x90:
+                    event = ['note_on' if param2 > 0 else 'note_off', delta_time, channel, param1, param2]
+                elif command == 0xA0:
+                    event = ['key_after_touch', delta_time, channel, param1, param2]
+                elif command == 0xB0:
+                    event = ['control_change', delta_time, channel, param1, param2]
+                elif command == 0xE0:
+                    pitch = ((param2 << 7) | param1) - 0x2000
+                    event = ['pitch_wheel_change', delta_time, channel, pitch]
+            elif command in (0xC0, 0xD0):  # One parameter
+                param1 = data[offset]
+                offset += 1
+                event = ['patch_change' if command == 0xC0 else 'channel_after_touch', delta_time, channel, param1]
+            events.append(event)
+
+        # Meta events (0xFF)
+        elif status == 0xFF:
+            meta_type = data[offset]
+            offset += 1
+            length, offset = _read_vlq(data, offset)
+            meta_data = data[offset:offset + length]
+            offset += length
+
+            if meta_type == 0x2F:
+                event = ['end_track', delta_time]
+            elif meta_type == 0x51 and length == 3:
+                event = ['set_tempo', delta_time, int.from_bytes(meta_data, 'big')]
+            elif 0x01 <= meta_type <= 0x0F:
+                event = [f'text_event_{meta_type:02x}', delta_time, meta_data]  # Text as bytes
+            else:
+                event = ['raw_meta_event', delta_time, meta_type, meta_data]
+            events.append(event)
+
+        # System exclusive events (0xF0, 0xF7)
+        elif status in (0xF0, 0xF7):
+            length, offset = _read_vlq(data, offset)
+            sysex_data = data[offset:offset + length]
+            offset += length
+            event = ['sysex_f0' if status == 0xF0 else 'sysex_f7', delta_time, sysex_data]
+            events.append(event)
+
+        else:
+            raise ValueError(f"Unknown status byte: {status:02x}")
+
+    return events
+
+def midi2opus(midi_bytes):
+    """Convert MIDI bytes to an opus structure: [ticks_per_quarter, [track_events, ...]]."""
+    if not isinstance(midi_bytes, (bytes, bytearray)) or len(midi_bytes) < 14 or midi_bytes[:4] != b'MThd':
+        return [1000, []]  # Default empty opus
+
+    header_size = int.from_bytes(midi_bytes[4:8], 'big')
+    if header_size != 6:
+        raise ValueError("Invalid MIDI header size")
+
+    ticks_per_quarter = int.from_bytes(midi_bytes[12:14], 'big')
+    num_tracks = int.from_bytes(midi_bytes[10:12], 'big')
+    opus = [ticks_per_quarter]
+    offset = 14
+
+    for _ in range(num_tracks):
+        if offset + 8 > len(midi_bytes) or midi_bytes[offset:offset+4] != b'MTrk':
+            break
+        track_size = int.from_bytes(midi_bytes[offset+4:offset+8], 'big')
+        track_data = midi_bytes[offset+8:offset+8+track_size]
+        opus.append(_decode_track(track_data))
+        offset += 8 + track_size
+
+    return opus
+
+# --- Encoding Functions ---
+
+def _encode_track(events):
+    """Encode a list of opus events into track bytes."""
+    track_data = bytearray()
+    running_status = None
+
+    for event in events:
+        event_type, delta_time = event[0], event[1]
+        track_data.extend(_write_vlq(delta_time))
+
+        if event_type == 'note_on':
+            status = 0x90 | event[2]
+            params = bytes([event[3], event[4]])
+        elif event_type == 'note_off':
+            status = 0x80 | event[2]
+            params = bytes([event[3], event[4]])
+        elif event_type == 'control_change':
+            status = 0xB0 | event[2]
+            params = bytes([event[3], event[4]])
+        elif event_type == 'patch_change':
+            status = 0xC0 | event[2]
+            params = bytes([event[3]])
+        elif event_type == 'pitch_wheel_change':
+            status = 0xE0 | event[2]
+            params = _write_14_bit(event[3] + 0x2000)
+        elif event_type.startswith('text_event_'):
+            meta_type = int(event_type.split('_')[-1], 16)
+            text_data = event[2]
+            track_data.extend(b'\xFF' + bytes([meta_type]) + _write_vlq(len(text_data)) + text_data)
+            continue
+        elif event_type == 'set_tempo':
+            tempo = event[2]
+            track_data.extend(b'\xFF\x51\x03' + struct.pack('>I', tempo)[1:])
+            continue
+        elif event_type == 'end_track':
+            track_data.extend(b'\xFF\x2F\x00')
+            continue
+        else:
+            continue  # Skip unsupported events
+
+        if status != running_status:
+            track_data.append(status)
+            running_status = status
+        track_data.extend(params)
+
+    return track_data
+
+def opus2midi(opus):
+    """Convert an opus structure to MIDI bytes."""
+    if len(opus) < 2:
+        opus = [1000, []]
+    ticks_per_quarter = opus[0]
+    tracks = opus[1:]
+    midi_bytes = b'MThd' + struct.pack('>IHHH', 6, 1 if len(tracks) > 1 else 0, len(tracks), ticks_per_quarter)
+
+    for track in tracks:
+        track_data = _encode_track(track)
+        midi_bytes += b'MTrk' + struct.pack('>I', len(track_data)) + track_data
+
+    return midi_bytes
+
+# --- Score Conversion Functions ---
+
+def score2opus(score):
+    """Convert a score to an opus structure."""
+    if len(score) < 2:
+        return [1000, []]
+    ticks = score[0]
+    opus = [ticks]
+
+    for track in score[1:]:
+        time_to_events = {}
+        for event in track:
+            if event[0] == 'note':
+                time_to_events.setdefault(event[1], []).append(
+                    ['note_on', event[1], event[3], event[4], event[5]])
+                time_to_events.setdefault(event[1] + event[2], []).append(
+                    ['note_off', event[1] + event[2], event[3], event[4], 0])
+            else:
+                time_to_events.setdefault(event[1], []).append(event)
+
+        sorted_times = sorted(time_to_events.keys())
+        opus_track = []
+        abs_time = 0
+        for time in sorted_times:
+            delta = time - abs_time
+            abs_time = time
+            for evt in time_to_events[time]:
+                evt_copy = evt.copy()
+                evt_copy[1] = delta
+                opus_track.append(evt_copy)
+            delta = 0  # Subsequent events at same time have delta 0
+        opus.append(opus_track)
+
+    return opus
+
+def opus2score(opus):
+    """Convert an opus to a score structure."""
+    if len(opus) < 2:
+        return [1000, []]
+    ticks = opus[0]
+    score = [ticks]
+
+    for track in opus[1:]:
+        score_track = []
+        abs_time = 0
+        pending_notes = {}  # (channel, pitch) -> note event
+
+        for event in track:
+            abs_time += event[1]
+            if event[0] == 'note_on' and event[4] > 0:
+                key = (event[2], event[3])
+                pending_notes[key] = ['note', abs_time, 0, event[2], event[3], event[4]]
+            elif event[0] in ('note_off',) or (event[0] == 'note_on' and event[4] == 0):
+                key = (event[2], event[3])
+                if key in pending_notes:
+                    note = pending_notes.pop(key)
+                    note[2] = abs_time - note[1]
+                    score_track.append(note)
+            else:
+                event_copy = event.copy()
+                event_copy[1] = abs_time
+                score_track.append(event_copy)
+
+        # Handle unterminated notes
+        for note in pending_notes.values():
+            note[2] = abs_time - note[1]
+            score_track.append(note)
+
+        score.append(score_track)
+
+    return score
+
+# --- Direct MIDI-Score Conversions ---
+
+def midi2score(midi_bytes):
+    """Convert MIDI bytes directly to a score."""
+    return opus2score(midi2opus(midi_bytes))
+
+def score2midi(score):
+    """Convert a score directly to MIDI bytes."""
+    return opus2midi(score2opus(score))
+
+# --- Example Usage ---
+if __name__ == "__main__":
+    # Example opus
+    test_opus = [
+        96,
+        [
+            ['patch_change', 0, 1, 8],
+            ['note_on', 5, 1, 60, 96],
+            ['note_off', 96, 1, 60, 0],
+            ['text_event_01', 0, b'Shift-JIS: \x83e\x83X\x83g'],  # Shift-JIS "テスト" (Test)
+            ['end_track', 0]
+        ]
+    ]
+    midi_data = opus2midi(test_opus)
+    with open("test.mid", "wb") as f:
+        f.write(midi_data)
+
+    # Parse it back
+    parsed_opus = midi2opus(midi_data)
+    score = opus2score(parsed_opus)
+    print("Parsed Score:", score)