sync ms

app.py

@@ -4,6 +4,7 @@ import torch
 import shutil
 import gradio as gr
 from piano_transcription_inference import PianoTranscription, sample_rate, load_audio
+from midi2abc import midi2abc
 from convert import *
 
 
@@ -38,8 +39,8 @@ def audio2midi(audio_path: str):
 
 def inference(audio_path: str):
     midi_path = audio2midi(audio_path)
-    xml_path = midi2xml(midi_path)
-    abc = xml2abc(xml_path)
+    xml_path, title, artist = midi2xml(midi_path)
+    abc = midi2abc(midi_path, title, artist)
     mxl_path = xml2mxl(xml_path)
     pdf_path, jpg_path = mxl2jpg(mxl_path)
     return midi_path, pdf_path, xml_path, mxl_path, abc, jpg_path
@@ -47,14 +48,17 @@ def inference(audio_path: str):
 
 iface = gr.Interface(
     fn=inference,
-    inputs=gr.Audio(label="上传音频100%后再点提交", type="filepath"),
+    inputs=gr.Audio(
+        label="Please make sure that the audio has finished uploading before clicking submit.",
+        type="filepath",
+    ),
     outputs=[
-        gr.components.File(label="下载 MIDI"),
-        gr.components.File(label="下载 PDF 乐谱"),
-        gr.components.File(label="下载 MusicXML"),
-        gr.components.File(label="下载 MXL"),
-        gr.Textbox(label="abc 乐谱", show_copy_button=True),
-        gr.Image(label="五线谱", type="filepath"),
+        gr.components.File(label="Download MIDI"),
+        gr.components.File(label="Download PDF score"),
+        gr.components.File(label="Download MusicXML"),
+        gr.components.File(label="Download MXL"),
+        gr.Textbox(label="abc notation", show_copy_button=True),
+        gr.Image(label="Staff", type="filepath"),
     ],
 )
 

convert.py

@@ -4,6 +4,7 @@ import fitz
 import requests
 import subprocess
 from PIL import Image
+from music21 import converter
 
 
 def download(url: str, directory: str, filename: str):
@@ -56,6 +57,27 @@ else:
     mscore = "D:/Program Files/MuseScore 3/bin/MuseScore3.exe"
 
 
+def add_title_to_xml(xml_path: str):
+    """
+    给 MIDI 文件添加标题，标题为去后缀的文件名。
+    参数：
+    - midi_file_path: MIDI 文件的路径
+    """
+    # 获取文件名（不带路径）
+    file_name = os.path.basename(xml_path)
+    title = file_name.split(".")[0]
+    artist = "Transcripted by AI"
+    # 读取 MIDI 文件
+    midi_data = converter.parse(xml_path)
+    # 将标题添加到 MIDI 文件中
+    midi_data.metadata.title = title
+    midi_data.metadata.movementName = title
+    midi_data.metadata.composer = artist
+    # 保存修改后的 MIDI 文件
+    midi_data.write("musicxml", fp=xml_path)
+    return title, artist
+
+
 def xml2abc(xml_path: str):
     result = subprocess.run(
         f"python xml2abc.py {xml_path}", stdout=subprocess.PIPE, text=True
@@ -78,8 +100,17 @@ def midi2xml(mid_file: str):
     xml_file = mid_file.replace(".mid", ".musicxml")
     command = [mscore, "-o", xml_file, mid_file]
     result = subprocess.run(command)
+    title, artist = add_title_to_xml(xml_file)
+    print(result)
+    return xml_file, title, artist
+
+
+def xml2midi(xml_file: str):
+    midi_file = xml_file.replace(".musicxml", ".mid")
+    command = [mscore, "-o", midi_file, xml_file]
+    result = subprocess.run(command)
     print(result)
-    return xml_file
+    return midi_file
 
 
 def pdf2img(pdf_path: str):

midi/DataTypeConverters.py

@@ -0,0 +1,155 @@
+# -*- coding: ISO-8859-1 -*-
+
+from struct import pack, unpack
+
+"""
+This module contains functions for reading and writing the special data types
+that a midi file contains.
+"""
+
+"""
+nibbles are four bits. A byte consists of two nibles.
+hiBits==0xF0, loBits==0x0F Especially used for setting
+channel and event in 1. byte of musical midi events
+"""
+
+
+
+def getNibbles(byte):
+    """
+    Returns hi and lo bits in a byte as a tuple
+    >>> getNibbles(142)
+    (8, 14)
+    
+    Asserts byte value in byte range
+    >>> getNibbles(256)
+    Traceback (most recent call last):
+        ...
+    ValueError: Byte value out of range 0-255: 256
+    """
+    if not 0 <= byte <= 255:
+        raise ValueError('Byte value out of range 0-255: %s' % byte)
+    return (byte >> 4 & 0xF, byte & 0xF)
+
+
+def setNibbles(hiNibble, loNibble):
+    """
+    Returns byte with value set according to hi and lo bits
+    Asserts hiNibble and loNibble in range(16)
+    >>> setNibbles(8, 14)
+    142
+    
+    >>> setNibbles(8, 16)
+    Traceback (most recent call last):
+        ...
+    ValueError: Nible value out of range 0-15: (8, 16)
+    """
+    if not (0 <= hiNibble <= 15) or not (0 <= loNibble <= 15):
+        raise ValueError('Nible value out of range 0-15: (%s, %s)' % (hiNibble, loNibble))
+    return (hiNibble << 4) + loNibble
+
+
+
+def readBew(value):
+    """
+    Reads string as big endian word, (asserts len(value) in [1,2,4])
+    >>> readBew('a���')
+    1642193635L
+    >>> readBew('a�')
+    25057
+    """
+    return unpack('>%s' % {1:'B', 2:'H', 4:'L'}[len(value)], value)[0]
+
+
+def writeBew(value, length):
+    """
+    Write int as big endian formatted string, (asserts length in [1,2,4])
+    Difficult to print the result in doctest, so I do a simple roundabout test.
+    >>> readBew(writeBew(25057, 2))
+    25057
+    >>> readBew(writeBew(1642193635L, 4))
+    1642193635L
+    """
+    return pack('>%s' % {1:'B', 2:'H', 4:'L'}[length], value)
+
+
+
+"""
+Variable Length Data (varlen) is a data format sprayed liberally throughout
+a midi file. It can be anywhere from 1 to 4 bytes long.
+If the 8'th bit is set in a byte another byte follows. The value is stored
+in the lowest 7 bits of each byte. So max value is 4x7 bits = 28 bits.
+"""
+
+
+def readVar(value):
+    """
+    Converts varlength format to integer. Just pass it 0 or more chars that
+    might be a varlen and it will only use the relevant chars.
+    use varLen(readVar(value)) to see how many bytes the integer value takes.
+    asserts len(value) >= 0
+    >>> readVar('�@')
+    64
+    >>> readVar('���a')
+    205042145
+    """
+    sum = 0
+    for byte in unpack('%sB' % len(value), value):
+        sum = (sum << 7) + (byte & 0x7F)
+        if not 0x80 & byte: break # stop after last byte
+    return sum
+
+
+
+def varLen(value):
+    """
+    Returns the the number of bytes an integer will be when
+    converted to varlength
+    """
+    if value <= 127:
+        return 1
+    elif value <= 16383:
+        return 2
+    elif value <= 2097151:
+        return 3
+    else:
+        return 4
+
+
+def writeVar(value):
+    "Converts an integer to varlength format"
+    sevens = to_n_bits(value, varLen(value))
+    for i in range(len(sevens)-1):
+        sevens[i] = sevens[i] | 0x80
+    return fromBytes(sevens)
+
+
+def to_n_bits(value, length=1, nbits=7):
+    "returns the integer value as a sequence of nbits bytes"
+    bytes = [(value >> (i*nbits)) & 0x7F for i in range(length)]
+    bytes.reverse()
+    return bytes
+
+
+def toBytes(value):
+    "Turns a string into a list of byte values"
+    return unpack('%sB' % len(value), value)
+
+
+def fromBytes(value):
+    "Turns a list of bytes into a string"
+    if not value:
+        return ''
+    return pack('%sB' % len(value), *value)
+
+              
+              
+             
+             
+             
+           
+           
+           
+          
+          
+          

midi/EventDispatcher.py

@@ -0,0 +1,289 @@
+# -*- coding: ISO-8859-1 -*-
+
+# std library
+from struct import unpack
+
+# custom
+from .DataTypeConverters import readBew, readVar, varLen, toBytes
+
+# uhh I don't really like this, but there are so many constants to 
+# import otherwise
+from .constants import *
+
+
+class EventDispatcher:
+
+
+    def __init__(self, outstream):
+        
+        """
+        
+        The event dispatcher generates events on the outstream.
+        
+        """
+        
+        # internal values, don't mess with 'em directly
+        self.outstream = outstream
+        
+        # public flags
+
+        # A note_on with a velocity of 0x00 is actually the same as a 
+        # note_off with a velocity of 0x40. When 
+        # "convert_zero_velocity" is set, the zero velocity note_on's 
+        # automatically gets converted into note_off's. This is a less 
+        # suprising behaviour for those that are not into the intimate 
+        # details of the midi spec.
+        self.convert_zero_velocity = 1
+        
+        # If dispatch_continuos_controllers is true, continuos 
+        # controllers gets dispatched to their defined handlers. Else 
+        # they just trigger the "continuous_controller" event handler.
+        self.dispatch_continuos_controllers = 1 # NOT IMPLEMENTED YET
+        
+        # If dispatch_meta_events is true, meta events get's dispatched 
+        # to their defined events. Else they all they trigger the 
+        # "meta_event" handler.
+        self.dispatch_meta_events = 1
+
+
+
+    def header(self, format, nTracks, division):
+        "Triggers the header event"
+        self.outstream.header(format, nTracks, division)
+
+
+    def start_of_track(self, current_track):
+        "Triggers the start of track event"
+        
+        # I do this twice so that users can overwrite the 
+        # start_of_track event handler without worrying whether the 
+        # track number is updated correctly.
+        self.outstream.set_current_track(current_track)
+        self.outstream.start_of_track(current_track)
+        
+    
+    def sysex_event(self, data):
+        "Dispatcher for sysex events"
+        self.outstream.sysex_event(data)
+    
+    
+    def eof(self):
+        "End of file!"
+        self.outstream.eof()
+
+
+    def update_time(self, new_time=0, relative=1):
+        "Updates relative/absolute time."
+        self.outstream.update_time(new_time, relative)
+        
+        
+    def reset_time(self):
+        "Updates relative/absolute time."
+        self.outstream.reset_time()
+        
+        
+    # Event dispatchers for similar types of events
+    
+    
+    def channel_messages(self, hi_nible, channel, data):
+    
+        "Dispatches channel messages"
+        
+        stream = self.outstream
+        data = toBytes(data)
+        
+        if (NOTE_ON & 0xF0) == hi_nible:
+            note, velocity = data
+            # note_on with velocity 0x00 are same as note 
+            # off with velocity 0x40 according to spec!
+            if velocity==0 and self.convert_zero_velocity:
+                stream.note_off(channel, note, 0x40)
+            else:
+                stream.note_on(channel, note, velocity)
+        
+        elif (NOTE_OFF & 0xF0) == hi_nible:
+            note, velocity = data
+            stream.note_off(channel, note, velocity)
+        
+        elif (AFTERTOUCH & 0xF0) == hi_nible:
+            note, velocity = data
+            stream.aftertouch(channel, note, velocity)
+        
+        elif (CONTINUOUS_CONTROLLER & 0xF0) == hi_nible:
+            controller, value = data
+            # A lot of the cc's are defined, so we trigger those directly
+            if self.dispatch_continuos_controllers:
+                self.continuous_controllers(channel, controller, value)
+            else:
+                stream.continuous_controller(channel, controller, value)
+            
+        elif (PATCH_CHANGE & 0xF0) == hi_nible:
+            program = data[0]
+            stream.patch_change(channel, program)
+            
+        elif (CHANNEL_PRESSURE & 0xF0) == hi_nible:
+            pressure = data[0]
+            stream.channel_pressure(channel, pressure)
+            
+        elif (PITCH_BEND & 0xF0) == hi_nible:
+            hibyte, lobyte = data
+            value = (hibyte<<7) + lobyte
+            stream.pitch_bend(channel, value)
+
+        else:
+
+            raise ValueError('Illegal channel message!')
+
+
+
+    def continuous_controllers(self, channel, controller, value):
+    
+        "Dispatches channel messages"
+
+        stream = self.outstream
+        
+        # I am not really shure if I ought to dispatch continuous controllers
+        # There's so many of them that it can clutter up the OutStream 
+        # classes.
+        
+        # So I just trigger the default event handler
+        stream.continuous_controller(channel, controller, value)
+
+
+
+    def system_commons(self, common_type, common_data):
+    
+        "Dispatches system common messages"
+        
+        stream = self.outstream
+        
+        # MTC Midi time code Quarter value
+        if common_type == MTC:
+            data = readBew(common_data)
+            msg_type = (data & 0x07) >> 4
+            values = (data & 0x0F)
+            stream.midi_time_code(msg_type, values)
+        
+        elif common_type == SONG_POSITION_POINTER:
+            hibyte, lobyte = toBytes(common_data)
+            value = (hibyte<<7) + lobyte
+            stream.song_position_pointer(value)
+
+        elif common_type == SONG_SELECT:
+            data = readBew(common_data)
+            stream.song_select(data)
+
+        elif common_type == TUNING_REQUEST:
+            # no data then
+            stream.tuning_request(time=None)
+
+
+
+    def meta_event(self, meta_type, data):
+        
+        "Dispatches meta events"
+        
+        stream = self.outstream
+        
+        # SEQUENCE_NUMBER = 0x00 (00 02 ss ss (seq-number))
+        if meta_type == SEQUENCE_NUMBER:
+            number = readBew(data)
+            stream.sequence_number(number)
+        
+        # TEXT = 0x01 (01 len text...)
+        elif meta_type == TEXT:
+            stream.text(data)
+        
+        # COPYRIGHT = 0x02 (02 len text...)
+        elif meta_type == COPYRIGHT:
+            stream.copyright(data)
+        
+        # SEQUENCE_NAME = 0x03 (03 len text...)
+        elif meta_type == SEQUENCE_NAME:
+            stream.sequence_name(data)
+        
+        # INSTRUMENT_NAME = 0x04 (04 len text...)
+        elif meta_type == INSTRUMENT_NAME:
+            stream.instrument_name(data)
+        
+        # LYRIC = 0x05 (05 len text...)
+        elif meta_type == LYRIC:
+            stream.lyric(data)
+        
+        # MARKER = 0x06 (06 len text...)
+        elif meta_type == MARKER:
+            stream.marker(data)
+        
+        # CUEPOINT = 0x07 (07 len text...)
+        elif meta_type == CUEPOINT:
+            stream.cuepoint(data)
+        
+        # PROGRAM_NAME = 0x08 (05 len text...)
+        elif meta_type == PROGRAM_NAME:
+            stream.program_name(data)
+        
+        # DEVICE_NAME = 0x09 (09 len text...)
+        elif meta_type == DEVICE_NAME:
+            try:                           #p08 patch
+                stream.device_name(data)
+            except:
+                pass 
+        # MIDI_CH_PREFIX = 0x20 (20 01 channel)
+        elif meta_type == MIDI_CH_PREFIX:
+            channel = readBew(data)
+            stream.midi_ch_prefix(channel)
+        
+        # MIDI_PORT  = 0x21 (21 01 port (legacy stuff))
+        elif meta_type == MIDI_PORT:
+            port = readBew(data)
+            stream.midi_port(port)
+        
+        # END_OFF_TRACK = 0x2F (2F 00)
+        elif meta_type == END_OF_TRACK:
+            stream.end_of_track()
+        
+        # TEMPO = 0x51 (51 03 tt tt tt (tempo in us/quarternote))
+        elif meta_type == TEMPO:
+            b1, b2, b3 = toBytes(data)
+            # uses 3 bytes to represent time between quarter 
+            # notes in microseconds
+            stream.tempo((b1<<16) + (b2<<8) + b3)
+        
+        # SMTP_OFFSET = 0x54 (54 05 hh mm ss ff xx)
+        elif meta_type == SMTP_OFFSET:
+            hour, minute, second, frame, framePart = toBytes(data)
+            stream.smtp_offset(
+                    hour, minute, second, frame, framePart)
+        
+        # TIME_SIGNATURE = 0x58 (58 04 nn dd cc bb)
+        elif meta_type == TIME_SIGNATURE:
+            nn, dd, cc, bb = toBytes(data)
+            stream.time_signature(nn, dd, cc, bb)
+        
+        # KEY_SIGNATURE = 0x59 (59 02 sf mi)
+        elif meta_type == KEY_SIGNATURE:
+            sf, mi = toBytes(data)
+            stream.key_signature(sf, mi)
+        
+        # SPECIFIC = 0x7F (Sequencer specific event)
+        elif meta_type == SPECIFIC:
+            meta_data = toBytes(data)
+            stream.sequencer_specific(meta_data)
+        
+        # Handles any undefined meta events
+        else: # undefined meta type
+            meta_data = toBytes(data)
+            stream.meta_event(meta_type, meta_data)
+
+
+
+
+
+if __name__ == '__main__':
+
+
+    from MidiToText import MidiToText
+    
+    outstream = MidiToText()
+    dispatcher = EventDispatcher(outstream)
+    dispatcher.channel_messages(NOTE_ON, 0x00, '\x40\x40')

midi/MidiFileParser.py

@@ -0,0 +1,191 @@
+# -*- coding: ISO-8859-1 -*-
+
+# std library
+from struct import unpack
+
+# uhh I don't really like this, but there are so many constants to 
+# import otherwise
+from .constants import *
+
+from .EventDispatcher import EventDispatcher
+
+class MidiFileParser:
+
+    """
+    
+    The MidiFileParser is the lowest level parser that see the data as 
+    midi data. It generates events that gets triggered on the outstream.
+    
+    """
+
+    def __init__(self, raw_in, outstream):
+
+        """
+        raw_data is the raw content of a midi file as a string.
+        """
+
+        # internal values, don't mess with 'em directly
+        self.raw_in = raw_in
+        self.dispatch = EventDispatcher(outstream)
+
+        # Used to keep track of stuff
+        self._running_status = None
+
+
+
+
+    def parseMThdChunk(self):
+        
+        "Parses the header chunk"
+        
+        raw_in = self.raw_in
+
+        header_chunk_type = raw_in.nextSlice(4)
+        header_chunk_zise = raw_in.readBew(4)
+        # check if it is a proper midi file
+        if header_chunk_type != b'MThd':
+            raise TypeError("It is not a valid midi file!")
+
+        # Header values are at fixed locations, so no reason to be clever
+        self.format = raw_in.readBew(2)
+        self.nTracks = raw_in.readBew(2)
+        self.division = raw_in.readBew(2)
+        
+        # Theoretically a header larger than 6 bytes can exist
+        # but no one has seen one in the wild
+        # But correctly ignore unknown data if it is though
+        if header_chunk_zise > 6:
+            raw_in.moveCursor(header_chunk_zise-6)
+
+        # call the header event handler on the stream
+        self.dispatch.header(self.format, self.nTracks, self.division)
+
+
+
+    def parseMTrkChunk(self):
+        
+        "Parses a track chunk. This is the most important part of the parser."
+        
+        # set time to 0 at start of a track
+        self.dispatch.reset_time()
+        
+        dispatch = self.dispatch
+        raw_in = self.raw_in
+        
+        # Trigger event at the start of a track
+        dispatch.start_of_track(self._current_track)
+        # position cursor after track header
+        raw_in.moveCursor(4)
+        # unsigned long is 4 bytes
+        tracklength = raw_in.readBew(4)
+        track_endposition = raw_in.getCursor() + tracklength # absolute position!
+
+        while raw_in.getCursor() < track_endposition:
+        
+            # find relative time of the event
+            time = raw_in.readVarLen()
+            dispatch.update_time(time)
+            
+            # be aware of running status!!!!
+            peak_ahead = raw_in.readBew(move_cursor=0)
+            if (peak_ahead & 0x80): 
+                # the status byte has the high bit set, so it
+                # was not running data but proper status byte
+                status = self._running_status = raw_in.readBew()
+            else:
+                # use that darn running status
+                status = self._running_status
+                # could it be illegal data ?? Do we need to test for that?
+                # I need more example midi files to be shure.
+                
+                # Also, while I am almost certain that no realtime 
+                # messages will pop up in a midi file, I might need to 
+                # change my mind later.
+
+            # we need to look at nibbles here
+            hi_nible, lo_nible = status & 0xF0, status & 0x0F
+            
+            # match up with events
+
+            # Is it a meta_event ??
+            # these only exists in midi files, not in transmitted midi data
+            # In transmitted data META_EVENT (0xFF) is a system reset
+            if status == META_EVENT:
+                meta_type = raw_in.readBew()
+                meta_length = raw_in.readVarLen()
+                meta_data = raw_in.nextSlice(meta_length)
+                dispatch.meta_event(meta_type, meta_data)
+
+
+            # Is it a sysex_event ??
+            elif status == SYSTEM_EXCLUSIVE:
+                # ignore sysex events
+                sysex_length = raw_in.readVarLen()
+                # don't read sysex terminator
+                sysex_data = raw_in.nextSlice(sysex_length-1)
+                # only read last data byte if it is a sysex terminator
+                # It should allways be there, but better safe than sorry
+                if raw_in.readBew(move_cursor=0) == END_OFF_EXCLUSIVE:
+                    eo_sysex = raw_in.readBew()
+                dispatch.sysex_event(sysex_data)
+                # the sysex code has not been properly tested, and might be fishy!
+
+
+            # is it a system common event?
+            elif hi_nible == 0xF0: # Hi bits are set then
+                data_sizes = {
+                    MTC:1,
+                    SONG_POSITION_POINTER:2,
+                    SONG_SELECT:1,
+                }
+                data_size = data_sizes.get(hi_nible, 0)
+                common_data = raw_in.nextSlice(data_size)
+                common_type = lo_nible
+                dispatch.system_common(common_type, common_data)
+            
+
+            # Oh! Then it must be a midi event (channel voice message)
+            else:
+                data_sizes = {
+                    PATCH_CHANGE:1,
+                    CHANNEL_PRESSURE:1,
+                    NOTE_OFF:2,
+                    NOTE_ON:2,
+                    AFTERTOUCH:2,
+                    CONTINUOUS_CONTROLLER:2,
+                    PITCH_BEND:2,
+                }
+                data_size = data_sizes.get(hi_nible, 0)
+                channel_data = raw_in.nextSlice(data_size)
+                event_type, channel = hi_nible, lo_nible
+                dispatch.channel_messages(event_type, channel, channel_data)
+
+
+    def parseMTrkChunks(self):
+        "Parses all track chunks."
+        for t in range(self.nTracks):
+            self._current_track = t
+            self.parseMTrkChunk() # this is where it's at!
+        self.dispatch.eof()
+
+
+
+if __name__ == '__main__':
+
+    # get data
+    test_file = 'test/midifiles/minimal.mid'
+    test_file = 'test/midifiles/cubase-minimal.mid'
+    test_file = 'test/midifiles/Lola.mid'
+#    f = open(test_file, 'rb')
+#    raw_data = f.read()
+#    f.close()
+#    
+#    
+#    # do parsing
+    from MidiToText import MidiToText
+    from RawInstreamFile import RawInstreamFile
+
+    midi_in = MidiFileParser(RawInstreamFile(test_file), MidiToText())
+    midi_in.parseMThdChunk()
+    midi_in.parseMTrkChunks()
+    

midi/MidiInFile.py

@@ -0,0 +1,55 @@
+# -*- coding: ISO-8859-1 -*-
+
+from .RawInstreamFile import RawInstreamFile
+from .MidiFileParser import MidiFileParser
+
+
+class MidiInFile:
+
+    """
+    
+    Parses a midi file, and triggers the midi events on the outStream 
+    object.
+    
+    Get example data from a minimal midi file, generated with cubase.
+    >>> test_file = 'C:/Documents and Settings/maxm/Desktop/temp/midi/src/midi/tests/midifiles/minimal-cubase-type0.mid'
+    
+    Do parsing, and generate events with MidiToText,
+    so we can see what a minimal midi file contains
+    >>> from MidiToText import MidiToText
+    >>> midi_in = MidiInFile(MidiToText(), test_file)
+    >>> midi_in.read()
+    format: 0, nTracks: 1, division: 480
+    ----------------------------------
+    <BLANKLINE>
+    Start - track #0
+    sequence_name: Type 0
+    tempo: 500000
+    time_signature: 4 2 24 8
+    note_on  - ch:00,  note:48,  vel:64 time:0
+    note_off - ch:00,  note:48,  vel:40 time:480
+    End of track
+    <BLANKLINE>
+    End of file
+    
+    
+    """
+
+    def __init__(self, outStream, infile):
+        # these could also have been mixins, would that be better? Nah!
+        self.raw_in = RawInstreamFile(infile)
+        self.parser = MidiFileParser(self.raw_in, outStream)
+
+
+    def read(self):
+        "Start parsing the file"
+        p = self.parser
+        p.parseMThdChunk()
+        p.parseMTrkChunks()
+
+
+    def setData(self, data=''):
+        "Sets the data from a plain string"
+        self.raw_in.setData(data)
+    
+    

midi/MidiInStream.py

@@ -0,0 +1,52 @@
+# -*- coding: ISO-8859-1 -*-
+
+from MidiOutStream import MidiOutStream
+
+class MidiInStream:
+
+    """
+    Takes midi events from the midi input and calls the apropriate
+    method in the eventhandler object
+    """
+
+    def __init__(self, midiOutStream, device):
+
+        """
+
+        Sets a default output stream, and sets the device from where
+        the input comes
+
+        """
+
+        if midiOutStream is None:
+            self.midiOutStream = MidiOutStream()
+        else:
+            self.midiOutStream = midiOutStream
+
+
+    def close(self):
+
+        """
+        Stop the MidiInstream
+        """
+
+
+    def read(self, time=0):
+
+        """
+
+        Start the MidiInstream.
+
+        "time" sets timer to specific start value.
+
+        """
+
+
+    def resetTimer(self, time=0):
+        """
+
+        Resets the timer, probably a good idea if there is some kind
+        of looping going on
+
+        """
+

midi/MidiOutFile.py

@@ -0,0 +1,448 @@
+# -*- coding: ISO-8859-1 -*-
+
+from MidiOutStream import MidiOutStream
+from RawOutstreamFile import RawOutstreamFile
+
+from constants import *
+from DataTypeConverters import fromBytes, writeVar
+
+class MidiOutFile(MidiOutStream):
+
+
+    """
+    MidiOutFile is an eventhandler that subclasses MidiOutStream.
+    """
+
+
+    def __init__(self, raw_out=''):
+
+        self.raw_out = RawOutstreamFile(raw_out)
+        MidiOutStream.__init__(self)
+        
+    
+    def write(self):
+        self.raw_out.write()
+
+
+    def event_slice(self, slc):
+        """
+        Writes the slice of an event to the current track. Correctly 
+        inserting a varlen timestamp too.
+        """
+        trk = self._current_track_buffer
+        trk.writeVarLen(self.rel_time())
+        trk.writeSlice(slc)
+        
+    
+    #####################
+    ## Midi events
+
+
+    def note_on(self, channel=0, note=0x40, velocity=0x40):
+
+        """
+        channel: 0-15
+        note, velocity: 0-127
+        """
+        slc = fromBytes([NOTE_ON + channel, note, velocity])
+        self.event_slice(slc)
+
+
+    def note_off(self, channel=0, note=0x40, velocity=0x40):
+
+        """
+        channel: 0-15
+        note, velocity: 0-127
+        """
+        slc = fromBytes([NOTE_OFF + channel, note, velocity])
+        self.event_slice(slc)
+
+
+    def aftertouch(self, channel=0, note=0x40, velocity=0x40):
+
+        """
+        channel: 0-15
+        note, velocity: 0-127
+        """
+        slc = fromBytes([AFTERTOUCH + channel, note, velocity])
+        self.event_slice(slc)
+
+
+    def continuous_controller(self, channel, controller, value):
+
+        """
+        channel: 0-15
+        controller, value: 0-127
+        """
+        slc = fromBytes([CONTINUOUS_CONTROLLER + channel, controller, value])
+        self.event_slice(slc)
+        # These should probably be implemented
+        # http://users.argonet.co.uk/users/lenny/midi/tech/spec.html#ctrlnums
+
+
+    def patch_change(self, channel, patch):
+
+        """
+        channel: 0-15
+        patch: 0-127
+        """
+        slc = fromBytes([PATCH_CHANGE + channel, patch])
+        self.event_slice(slc)
+
+
+    def channel_pressure(self, channel, pressure):
+
+        """
+        channel: 0-15
+        pressure: 0-127
+        """
+        slc = fromBytes([CHANNEL_PRESSURE + channel, pressure])
+        self.event_slice(slc)
+
+
+    def pitch_bend(self, channel, value):
+
+        """
+        channel: 0-15
+        value: 0-16383
+        """
+        msb = (value>>7) & 0xFF
+        lsb = value & 0xFF
+        slc = fromBytes([PITCH_BEND + channel, msb, lsb])
+        self.event_slice(slc)
+
+
+
+
+    #####################
+    ## System Exclusive
+
+#    def sysex_slice(sysex_type, data):
+#        ""
+#        sysex_len = writeVar(len(data)+1)
+#        self.event_slice(SYSTEM_EXCLUSIVE + sysex_len + data + END_OFF_EXCLUSIVE)
+#
+    def system_exclusive(self, data):
+
+        """
+        data: list of values in range(128)
+        """
+        sysex_len = writeVar(len(data)+1)
+        self.event_slice(chr(SYSTEM_EXCLUSIVE) + sysex_len + data + chr(END_OFF_EXCLUSIVE))
+
+
+    #####################
+    ## Common events
+
+    def midi_time_code(self, msg_type, values):
+        """
+        msg_type: 0-7
+        values: 0-15
+        """
+        value = (msg_type<<4) + values
+        self.event_slice(fromBytes([MIDI_TIME_CODE, value]))
+
+
+    def song_position_pointer(self, value):
+
+        """
+        value: 0-16383
+        """
+        lsb = (value & 0x7F)
+        msb = (value >> 7) & 0x7F
+        self.event_slice(fromBytes([SONG_POSITION_POINTER, lsb, msb]))
+
+
+    def song_select(self, songNumber):
+
+        """
+        songNumber: 0-127
+        """
+        self.event_slice(fromBytes([SONG_SELECT, songNumber]))
+
+
+    def tuning_request(self):
+
+        """
+        No values passed
+        """
+        self.event_slice(chr(TUNING_REQUEST))
+
+            
+    #########################
+    # header does not really belong here. But anyhoo!!!
+    
+    def header(self, format=0, nTracks=1, division=96):
+
+        """
+        format: type of midi file in [0,1,2]
+        nTracks: number of tracks. 1 track for type 0 file
+        division: timing division ie. 96 ppq.
+        
+        """        
+        raw = self.raw_out
+        raw.writeSlice('MThd')
+        bew = raw.writeBew
+        bew(6, 4) # header size
+        bew(format, 2)
+        bew(nTracks, 2)
+        bew(division, 2)
+
+
+    def eof(self):
+
+        """
+        End of file. No more events to be processed.
+        """
+        # just write the file then.
+        self.write()
+
+
+    #####################
+    ## meta events
+
+
+    def meta_slice(self, meta_type, data_slice):
+        "Writes a meta event"
+        slc = fromBytes([META_EVENT, meta_type]) + \
+                         writeVar(len(data_slice)) +  data_slice
+        self.event_slice(slc)
+
+
+    def meta_event(self, meta_type, data):
+        """
+        Handles any undefined meta events
+        """
+        self.meta_slice(meta_type, fromBytes(data))
+
+
+    def start_of_track(self, n_track=0):
+        """
+        n_track: number of track
+        """
+        self._current_track_buffer = RawOutstreamFile()
+        self.reset_time()
+        self._current_track += 1
+
+
+    def end_of_track(self):
+        """
+        Writes the track to the buffer.
+        """
+        raw = self.raw_out
+        raw.writeSlice(TRACK_HEADER)
+        track_data = self._current_track_buffer.getvalue()
+        # wee need to know size of track data.
+        eot_slice = writeVar(self.rel_time()) + fromBytes([META_EVENT, END_OF_TRACK, 0])
+        raw.writeBew(len(track_data)+len(eot_slice), 4)
+        # then write
+        raw.writeSlice(track_data)
+        raw.writeSlice(eot_slice)
+        
+
+
+    def sequence_number(self, value):
+
+        """
+        value: 0-65535
+        """
+        self.meta_slice(meta_type, writeBew(value, 2))
+
+
+    def text(self, text):
+        """
+        Text event
+        text: string
+        """
+        self.meta_slice(TEXT, text)
+
+
+    def copyright(self, text):
+
+        """
+        Copyright notice
+        text: string
+        """
+        self.meta_slice(COPYRIGHT, text)
+
+
+    def sequence_name(self, text):
+        """
+        Sequence/track name
+        text: string
+        """
+        self.meta_slice(SEQUENCE_NAME, text)
+
+
+    def instrument_name(self, text):
+
+        """
+        text: string
+        """
+        self.meta_slice(INSTRUMENT_NAME, text)
+
+
+    def lyric(self, text):
+
+        """
+        text: string
+        """
+        self.meta_slice(LYRIC, text)
+
+
+    def marker(self, text):
+
+        """
+        text: string
+        """
+        self.meta_slice(MARKER, text)
+
+
+    def cuepoint(self, text):
+
+        """
+        text: string
+        """
+        self.meta_slice(CUEPOINT, text)
+
+
+    def midi_ch_prefix(self, channel):
+
+        """
+        channel: midi channel for subsequent data
+        (deprecated in the spec)
+        """
+        self.meta_slice(MIDI_CH_PREFIX, chr(channel))
+
+
+    def midi_port(self, value):
+
+        """
+        value: Midi port (deprecated in the spec)
+        """
+        self.meta_slice(MIDI_CH_PREFIX, chr(value))
+
+
+    def tempo(self, value):
+
+        """
+        value: 0-2097151
+        tempo in us/quarternote
+        (to calculate value from bpm: int(60,000,000.00 / BPM))
+        """
+        hb, mb, lb = (value>>16 & 0xff), (value>>8 & 0xff), (value & 0xff)
+        self.meta_slice(TEMPO, fromBytes([hb, mb, lb]))
+
+
+    def smtp_offset(self, hour, minute, second, frame, framePart):
+
+        """
+        hour,
+        minute,
+        second: 3 bytes specifying the hour (0-23), minutes (0-59) and 
+                seconds (0-59), respectively. The hour should be 
+                encoded with the SMPTE format, just as it is in MIDI 
+                Time Code.
+        frame: A byte specifying the number of frames per second (one 
+               of : 24, 25, 29, 30).
+        framePart: A byte specifying the number of fractional frames, 
+                   in 100ths of a frame (even in SMPTE-based tracks 
+                   using a different frame subdivision, defined in the 
+                   MThd chunk).
+        """
+        self.meta_slice(SMTP_OFFSET, fromBytes([hour, minute, second, frame, framePart]))
+
+
+
+    def time_signature(self, nn, dd, cc, bb):
+
+        """
+        nn: Numerator of the signature as notated on sheet music
+        dd: Denominator of the signature as notated on sheet music
+            The denominator is a negative power of 2: 2 = quarter 
+            note, 3 = eighth, etc.
+        cc: The number of MIDI clocks in a metronome click
+        bb: The number of notated 32nd notes in a MIDI quarter note 
+            (24 MIDI clocks)        
+        """
+        self.meta_slice(TIME_SIGNATURE, fromBytes([nn, dd, cc, bb]))
+
+
+
+
+    def key_signature(self, sf, mi):
+
+        """
+        sf: is a byte specifying the number of flats (-ve) or sharps 
+            (+ve) that identifies the key signature (-7 = 7 flats, -1 
+            = 1 flat, 0 = key of C, 1 = 1 sharp, etc).
+        mi: is a byte specifying a major (0) or minor (1) key.
+        """
+        self.meta_slice(KEY_SIGNATURE, fromBytes([sf, mi]))
+
+
+
+    def sequencer_specific(self, data):
+
+        """
+        data: The data as byte values
+        """
+        self.meta_slice(SEQUENCER_SPECIFIC, data)
+
+
+
+
+
+#    #####################
+#    ## realtime events
+
+#    These are of no use in a midi file, so they are ignored!!!
+
+#    def timing_clock(self):
+#    def song_start(self):
+#    def song_stop(self):
+#    def song_continue(self):
+#    def active_sensing(self):
+#    def system_reset(self):
+
+
+
+if __name__ == '__main__':
+
+    out_file = 'test/midifiles/midiout.mid'
+    midi = MidiOutFile(out_file)
+
+#format: 0, nTracks: 1, division: 480
+#----------------------------------
+#
+#Start - track #0
+#sequence_name: Type 0
+#tempo: 500000
+#time_signature: 4 2 24 8
+#note_on  - ch:00,  note:48,  vel:64 time:0
+#note_off - ch:00,  note:48,  vel:40 time:480
+#End of track
+#
+#End of file
+
+
+    midi.header(0, 1, 480)
+    
+    midi.start_of_track()
+    midi.sequence_name('Type 0')
+    midi.tempo(750000)
+    midi.time_signature(4, 2, 24, 8)
+    ch = 0
+    for i in range(127):
+        midi.note_on(ch, i, 0x64)
+        midi.update_time(96)
+        midi.note_off(ch, i, 0x40)
+        midi.update_time(0)
+    
+    midi.update_time(0)
+    midi.end_of_track()
+    
+    midi.eof() # currently optional, should it do the write instead of write??
+
+
+    midi.write()

midi/MidiOutStream.py

@@ -0,0 +1,471 @@
+# -*- coding: ISO-8859-1 -*-
+
+class MidiOutStream:
+
+
+    """
+
+    MidiOutstream is Basically an eventhandler. It is the most central
+    class in the Midi library. You use it both for writing events to
+    an output stream, and as an event handler for an input stream.
+
+    This makes it extremely easy to take input from one stream and
+    send it to another. Ie. if you want to read a Midi file, do some
+    processing, and send it to a midiport.
+
+    All time values are in absolute values from the opening of a
+    stream. To calculate time values, please use the MidiTime and
+    MidiDeltaTime classes.
+
+    """
+
+    def __init__(self):
+        
+        # the time is rather global, so it needs to be stored 
+        # here. Otherwise there would be no really simple way to 
+        # calculate it. The alternative would be to have each event 
+        # handler do it. That sucks even worse!
+        self._absolute_time = 0
+        self._relative_time = 0
+        self._current_track = 0
+        self._running_status = None
+
+    # time handling event handlers. They should be overwritten with care
+
+    def update_time(self, new_time=0, relative=1):
+        """
+        Updates the time, if relative is true, new_time is relative, 
+        else it's absolute.
+        """
+        if relative:
+            self._relative_time = new_time
+            self._absolute_time += new_time
+        else:
+            self._relative_time = new_time - self._absolute_time
+            self._absolute_time = new_time
+
+    def reset_time(self):
+        """
+        reset time to 0
+        """
+        self._relative_time = 0
+        self._absolute_time = 0
+        
+    def rel_time(self):
+        "Returns the relative time"
+        return self._relative_time
+
+    def abs_time(self):
+        "Returns the absolute time"
+        return self._absolute_time
+
+    # running status methods
+    
+    def reset_run_stat(self):
+        "Invalidates the running status"
+        self._running_status = None
+
+    def set_run_stat(self, new_status):
+        "Set the new running status"
+        self._running_status = new_status
+
+    def get_run_stat(self):
+        "Set the new running status"
+        return self._running_status
+
+    # track handling event handlers
+    
+    def set_current_track(self, new_track):
+        "Sets the current track number"
+        self._current_track = new_track
+    
+    def get_current_track(self):
+        "Returns the current track number"
+        return self._current_track
+    
+    
+    #####################
+    ## Midi events
+
+
+    def channel_message(self, message_type, channel, data):
+        """The default event handler for channel messages"""
+        pass
+
+
+    def note_on(self, channel=0, note=0x40, velocity=0x40):
+
+        """
+        channel: 0-15
+        note, velocity: 0-127
+        """
+        pass
+
+
+    def note_off(self, channel=0, note=0x40, velocity=0x40):
+
+        """
+        channel: 0-15
+        note, velocity: 0-127
+        """
+        pass
+
+
+    def aftertouch(self, channel=0, note=0x40, velocity=0x40):
+
+        """
+        channel: 0-15
+        note, velocity: 0-127
+        """
+        pass
+
+
+    def continuous_controller(self, channel, controller, value):
+
+        """
+        channel: 0-15
+        controller, value: 0-127
+        """
+        pass
+
+
+    def patch_change(self, channel, patch):
+
+        """
+        channel: 0-15
+        patch: 0-127
+        """
+        pass
+
+
+    def channel_pressure(self, channel, pressure):
+
+        """
+        channel: 0-15
+        pressure: 0-127
+        """
+        pass
+
+
+    def pitch_bend(self, channel, value):
+
+        """
+        channel: 0-15
+        value: 0-16383
+
+        """
+        pass
+
+
+
+
+    #####################
+    ## System Exclusive
+
+    def system_exclusive(self, data):
+
+        """
+        data: list of values in range(128)
+        """
+        pass
+
+
+    #####################
+    ## Common events
+
+    def song_position_pointer(self, value):
+
+        """
+        value: 0-16383
+        """
+        pass
+
+
+    def song_select(self, songNumber):
+
+        """
+        songNumber: 0-127
+        """
+        pass
+
+
+    def tuning_request(self):
+
+        """
+        No values passed
+        """
+        pass
+
+            
+    def midi_time_code(self, msg_type, values):
+        """
+        msg_type: 0-7
+        values: 0-15
+        """
+        pass
+
+
+    #########################
+    # header does not really belong here. But anyhoo!!!
+    
+    def header(self, format=0, nTracks=1, division=96):
+
+        """
+        format: type of midi file in [1,2]
+        nTracks: number of tracks
+        division: timing division
+        """
+        pass
+
+
+    def eof(self):
+
+        """
+        End of file. No more events to be processed.
+        """
+        pass
+
+
+    #####################
+    ## meta events
+
+
+    def meta_event(self, meta_type, data):
+        
+        """
+        Handles any undefined meta events
+        """
+        pass
+
+
+    def start_of_track(self, n_track=0):
+
+        """
+        n_track: number of track
+        """
+        pass
+
+
+    def end_of_track(self):
+
+        """
+        n_track: number of track
+        """
+        pass
+
+
+    def sequence_number(self, value):
+
+        """
+        value: 0-16383
+        """
+        pass
+
+
+    def text(self, text):
+
+        """
+        Text event
+        text: string
+        """
+        pass
+
+
+    def copyright(self, text):
+
+        """
+        Copyright notice
+        text: string
+        """
+        pass
+
+
+    def sequence_name(self, text):
+
+        """
+        Sequence/track name
+        text: string
+        """
+        pass
+
+
+    def instrument_name(self, text):
+
+        """
+        text: string
+        """
+        pass
+
+
+    def lyric(self, text):
+
+        """
+        text: string
+        """
+        pass
+
+
+    def marker(self, text):
+
+        """
+        text: string
+        """
+        pass
+
+
+    def cuepoint(self, text):
+
+        """
+        text: string
+        """
+        pass
+
+
+    def midi_ch_prefix(self, channel):
+
+        """
+        channel: midi channel for subsequent data (deprecated in the spec)
+        """
+        pass
+
+
+    def midi_port(self, value):
+
+        """
+        value: Midi port (deprecated in the spec)
+        """
+        pass
+
+
+    def tempo(self, value):
+
+        """
+        value: 0-2097151
+        tempo in us/quarternote
+        (to calculate value from bpm: int(60,000,000.00 / BPM))
+        """
+        pass
+
+
+    def smtp_offset(self, hour, minute, second, frame, framePart):
+
+        """
+        hour,
+        minute,
+        second: 3 bytes specifying the hour (0-23), minutes (0-59) and 
+                seconds (0-59), respectively. The hour should be 
+                encoded with the SMPTE format, just as it is in MIDI 
+                Time Code.
+        frame: A byte specifying the number of frames per second (one 
+               of : 24, 25, 29, 30).
+        framePart: A byte specifying the number of fractional frames, 
+                   in 100ths of a frame (even in SMPTE-based tracks 
+                   using a different frame subdivision, defined in the 
+                   MThd chunk).
+        """
+        pass
+
+
+
+    def time_signature(self, nn, dd, cc, bb):
+
+        """
+        nn: Numerator of the signature as notated on sheet music
+        dd: Denominator of the signature as notated on sheet music
+            The denominator is a negative power of 2: 2 = quarter 
+            note, 3 = eighth, etc.
+        cc: The number of MIDI clocks in a metronome click
+        bb: The number of notated 32nd notes in a MIDI quarter note 
+            (24 MIDI clocks)        
+        """
+        pass
+
+
+
+    def key_signature(self, sf, mi):
+
+        """
+        sf: is a byte specifying the number of flats (-ve) or sharps 
+            (+ve) that identifies the key signature (-7 = 7 flats, -1 
+            = 1 flat, 0 = key of C, 1 = 1 sharp, etc).
+        mi: is a byte specifying a major (0) or minor (1) key.
+        """
+        pass
+
+
+
+    def sequencer_specific(self, data):
+
+        """
+        data: The data as byte values
+        """
+        pass
+
+
+
+
+    #####################
+    ## realtime events
+
+    def timing_clock(self):
+
+        """
+        No values passed
+        """
+        pass
+
+
+
+    def song_start(self):
+
+        """
+        No values passed
+        """
+        pass
+
+
+
+    def song_stop(self):
+
+        """
+        No values passed
+        """
+        pass
+
+
+
+    def song_continue(self):
+
+        """
+        No values passed
+        """
+        pass
+
+
+
+    def active_sensing(self):
+
+        """
+        No values passed
+        """
+        pass
+
+
+
+    def system_reset(self):
+
+        """
+        No values passed
+        """
+        pass
+
+
+
+if __name__ == '__main__':
+
+    midiOut = MidiOutStream()
+    midiOut.update_time(0,0)
+    midiOut.note_on(0, 63, 127)
+    midiOut.note_off(0, 63, 127)
+
+    

midi/MidiToText.py

@@ -0,0 +1,149 @@
+# -*- coding: ISO-8859-1 -*-
+
+from MidiOutStream import MidiOutStream
+
+
+class MidiToText(MidiOutStream):
+
+    """
+    This class renders a midi file as text. It is mostly used for debugging
+    """
+
+    #############################
+    # channel events
+
+    def channel_message(self, message_type, channel, data):
+        """The default event handler for channel messages"""
+        print('message_type:%X, channel:%X, data size:%X' %
+              (message_type, channel, len(data)))
+
+    def note_on(self, channel=0, note=0x40, velocity=0x40):
+        print('note_on  - ch:%02X,  note:%02X,  vel:%02X time:%s' %
+              (channel, note, velocity, self.rel_time()))
+
+    def note_off(self, channel=0, note=0x40, velocity=0x40):
+        print('note_off - ch:%02X,  note:%02X,  vel:%02X time:%s' %
+              (channel, note, velocity, self.rel_time()))
+
+    def aftertouch(self, channel=0, note=0x40, velocity=0x40):
+        print('aftertouch', channel, note, velocity)
+
+    def continuous_controller(self, channel, controller, value):
+        print('controller - ch: %02X, cont: #%02X, value: %02X' %
+              (channel, controller, value))
+
+    def patch_change(self, channel, patch):
+        print('patch_change - ch:%02X, patch:%02X' % (channel, patch))
+
+    def channel_pressure(self, channel, pressure):
+        print('channel_pressure', channel, pressure)
+
+    def pitch_bend(self, channel, value):
+        print('pitch_bend ch:%s, value:%s' % (channel, value))
+
+    #####################
+    # Common events
+
+    def system_exclusive(self, data):
+        print('system_exclusive - data size: %s' % len(data))
+
+    def song_position_pointer(self, value):
+        print('song_position_pointer: %s' % value)
+
+    def song_select(self, songNumber):
+        print('song_select: %s' % songNumber)
+
+    def tuning_request(self):
+        print('tuning_request')
+
+    def midi_time_code(self, msg_type, values):
+        print('midi_time_code - msg_type: %s, values: %s' % (msg_type, values))
+
+    #########################
+    # header does not really belong here. But anyhoo!!!
+
+    def header(self, format=0, nTracks=1, division=96):
+        print('format: %s, nTracks: %s, division: %s' %
+              (format, nTracks, division))
+        print('----------------------------------')
+        print('')
+
+    def eof(self):
+        print('End of file')
+
+    def start_of_track(self, n_track=0):
+        print('Start - track #%s' % n_track)
+
+    def end_of_track(self):
+        print('End of track')
+        print('')
+
+    ###############
+    # sysex event
+
+    def sysex_event(self, data):
+        print('sysex_event - datasize: %X' % len(data))
+
+    #####################
+    # meta events
+
+    def meta_event(self, meta_type, data):
+        print('undefined_meta_event:', meta_type, len(data))
+
+    def sequence_number(self, value):
+        print('sequence_number', value)
+
+    def text(self, text):
+        print('text', text)
+
+    def copyright(self, text):
+        print('copyright', text)
+
+    def sequence_name(self, text):
+        print('sequence_name:', text)
+
+    def instrument_name(self, text):
+        print('instrument_name:', text)
+
+    def lyric(self, text):
+        print('lyric', text)
+
+    def marker(self, text):
+        print('marker', text)
+
+    def cuepoint(self, text):
+        print('cuepoint', text)
+
+    def midi_ch_prefix(self, channel):
+        print('midi_ch_prefix', channel)
+
+    def midi_port(self, value):
+        print('midi_port:', value)
+
+    def tempo(self, value):
+        print('tempo:', value)
+
+    def smtp_offset(self, hour, minute, second, frame, framePart):
+        print('smtp_offset', hour, minute, second, frame, framePart)
+
+    def time_signature(self, nn, dd, cc, bb):
+        print('time_signature:', nn, dd, cc, bb)
+
+    def key_signature(self, sf, mi):
+        print('key_signature', sf, mi)
+
+    def sequencer_specific(self, data):
+        print('sequencer_specific', len(data))
+
+
+if __name__ == '__main__':
+
+    # get data
+    test_file = 'test/midifiles/minimal.mid'
+    f = open(test_file, 'rb')
+
+    # do parsing
+    from MidiInFile import MidiInFile
+    midiIn = MidiInFile(MidiToText(), f)
+    midiIn.read()
+    f.close()

midi/RawInstreamFile.py

@@ -0,0 +1,118 @@
+# -*- coding: ISO-8859-1 -*-
+
+import sys
+PY3 = sys.version_info.major > 2
+
+if PY3:
+    unichr = chr
+    xrange = range
+    def unicode(s):
+        return s
+    max_int = sys.maxsize
+    basestring = str
+
+# standard library imports
+from struct import unpack
+
+# custom import
+from .DataTypeConverters import readBew, readVar, varLen
+
+
+class RawInstreamFile:
+    
+    """
+    
+    It parses and reads data from an input file. It takes care of big 
+    endianess, and keeps track of the cursor position. The midi parser 
+    only reads from this object. Never directly from the file.
+    
+    """
+    
+    def __init__(self, infile=''):
+        """ 
+        If 'file' is a string we assume it is a path and read from 
+        that file.
+        If it is a file descriptor we read from the file, but we don't 
+        close it.
+        Midi files are usually pretty small, so it should be safe to 
+        copy them into memory.
+        """
+        if infile:
+            if isinstance(infile, basestring):
+                infile = open(infile, 'rb')
+                self.data = infile.read()
+                infile.close()
+            else:
+                # don't close the f
+                self.data = infile.read()
+        else:
+            self.data = ''
+        # start at beginning ;-)
+        self.cursor = 0
+
+
+    # setting up data manually
+    
+    def setData(self, data=''):
+        "Sets the data from a string."
+        self.data = data
+    
+    # cursor operations
+
+    def setCursor(self, position=0):
+        "Sets the absolute position if the cursor"
+        self.cursor = position
+
+
+    def getCursor(self):
+        "Returns the value of the cursor"
+        return self.cursor
+        
+        
+    def moveCursor(self, relative_position=0):
+        "Moves the cursor to a new relative position"
+        self.cursor += relative_position
+
+    # native data reading functions
+        
+    def nextSlice(self, length, move_cursor=1):
+        "Reads the next text slice from the raw data, with length"
+        c = self.cursor
+        slc = self.data[c:c+length]
+        if move_cursor:
+            self.moveCursor(length)
+        return slc
+        
+        
+    def readBew(self, n_bytes=1, move_cursor=1):
+        """
+        Reads n bytes of date from the current cursor position.
+        Moves cursor if move_cursor is true
+        """
+        return readBew(self.nextSlice(n_bytes, move_cursor))
+
+
+    def readVarLen(self):
+        """
+        Reads a variable length value from the current cursor position.
+        Moves cursor if move_cursor is true
+        """
+        MAX_VARLEN = 4 # Max value varlen can be
+        var = readVar(self.nextSlice(MAX_VARLEN, 0))
+        # only move cursor the actual bytes in varlen
+        self.moveCursor(varLen(var))
+        return var
+
+
+
+if __name__ == '__main__':
+
+    test_file = 'test/midifiles/minimal.mid'
+    fis = RawInstreamFile(test_file)
+    print(fis.nextSlice(len(fis.data)))
+
+    test_file = 'test/midifiles/cubase-minimal.mid'
+    cubase_minimal = open(test_file, 'rb')
+    fis2 = RawInstreamFile(cubase_minimal)
+    print(fis2.nextSlice(len(fis2.data)))
+    cubase_minimal.close()

midi/RawOutstreamFile.py

@@ -0,0 +1,69 @@
+# -*- coding: ISO-8859-1 -*-
+
+# standard library imports
+import sys
+from types import StringType
+from struct import unpack
+from cStringIO import StringIO
+
+# custom import
+from DataTypeConverters import writeBew, writeVar, fromBytes
+
+class RawOutstreamFile:
+    
+    """
+    
+    Writes a midi file to disk.
+    
+    """
+
+    def __init__(self, outfile=''):
+        self.buffer = StringIO()
+        self.outfile = outfile
+
+
+    # native data reading functions
+
+
+    def writeSlice(self, str_slice):
+        "Writes the next text slice to the raw data"
+        self.buffer.write(str_slice)
+        
+        
+    def writeBew(self, value, length=1):
+        "Writes a value to the file as big endian word"
+        self.writeSlice(writeBew(value, length))
+
+
+    def writeVarLen(self, value):
+        "Writes a variable length word to the file"
+        var = self.writeSlice(writeVar(value))
+
+
+    def write(self):
+        "Writes to disc"
+        if self.outfile:
+            if isinstance(self.outfile, StringType):
+                outfile = open(self.outfile, 'wb')
+                outfile.write(self.getvalue())
+                outfile.close()
+            else:
+                self.outfile.write(self.getvalue())
+        else:
+            sys.stdout.write(self.getvalue())
+                
+    def getvalue(self):
+        return self.buffer.getvalue()
+
+
+if __name__ == '__main__':
+
+    out_file = 'test/midifiles/midiout.mid'
+    out_file = ''
+    rawOut = RawOutstreamFile(out_file)
+    rawOut.writeSlice('MThd')
+    rawOut.writeBew(6, 4)
+    rawOut.writeBew(1, 2)
+    rawOut.writeBew(2, 2)
+    rawOut.writeBew(15360, 2)
+    rawOut.write()

midi/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: ISO-8859-1 -*-
+
+#import MidiOutStream
+#import MidiInStream
+#import MidiInFile
+#import MidiToText

midi/changes.txt

@@ -0,0 +1,45 @@
+------------------------------------------------------------------------
+r409 | maxm | 2006-01-05 16:37:29 +0100 (to, 05 jan 2006) | 1 line
+
+Made RawOutstreamFile.py write to std out if no outfile is given.
+------------------------------------------------------------------------
+r403 | maxm | 2006-01-05 13:34:11 +0100 (to, 05 jan 2006) | 1 line
+
+
+------------------------------------------------------------------------
+r402 | maxm | 2006-01-05 13:33:56 +0100 (to, 05 jan 2006) | 1 line
+
+- Fixed minor bugs, added coding headers
+------------------------------------------------------------------------
+r401 | maxm | 2006-01-01 23:09:17 +0100 (s_, 01 jan 2006) | 1 line
+
+Fixed sysex dispathcer bug.
+------------------------------------------------------------------------
+r268 | maxm | 2005-02-04 12:26:59 +0100 (fr, 04 feb 2005) | 1 line
+
+
+------------------------------------------------------------------------
+r128 | maxm | 2004-12-18 14:05:27 +0100 (l_, 18 dec 2004) | 1 line
+
+Fixed bug when using relative time
+------------------------------------------------------------------------
+r15 | maxm | 2004-03-09 15:01:41 +0100 (ti, 09 mar 2004) | 1 line
+
+made a copy to meta folder
+------------------------------------------------------------------------
+r13 | maxm | 2004-03-09 09:17:23 +0100 (ti, 09 mar 2004) | 1 line
+
+Deleted .pyc files
+------------------------------------------------------------------------
+r12 | maxm | 2004-03-09 09:15:54 +0100 (ti, 09 mar 2004) | 1 line
+
+Removed file/folder
+------------------------------------------------------------------------
+r3 | maxm | 2004-03-08 23:16:25 +0100 (ma, 08 mar 2004) | 1 line
+
+Adde midi
+------------------------------------------------------------------------
+r1 | maxm | 2004-03-08 22:49:23 +0100 (ma, 08 mar 2004) | 1 line
+
+Initial Import
+------------------------------------------------------------------------

midi/constants.py

@@ -0,0 +1,210 @@
+# -*- coding: ISO-8859-1 -*-
+
+###################################################
+## Definitions of the different midi events
+
+
+
+###################################################
+## Midi channel events (The most usual events)
+## also called "Channel Voice Messages"
+
+NOTE_OFF = 0x80
+# 1000cccc 0nnnnnnn 0vvvvvvv (channel, note, velocity)
+
+NOTE_ON = 0x90
+# 1001cccc 0nnnnnnn 0vvvvvvv (channel, note, velocity)
+
+AFTERTOUCH = 0xA0
+# 1010cccc 0nnnnnnn 0vvvvvvv (channel, note, velocity)
+
+CONTINUOUS_CONTROLLER = 0xB0 # see Channel Mode Messages!!!
+# 1011cccc 0ccccccc 0vvvvvvv (channel, controller, value)
+
+PATCH_CHANGE = 0xC0
+# 1100cccc 0ppppppp (channel, program)
+
+CHANNEL_PRESSURE = 0xD0
+# 1101cccc 0ppppppp (channel, pressure)
+
+PITCH_BEND = 0xE0
+# 1110cccc 0vvvvvvv 0wwwwwww (channel, value-lo, value-hi)
+
+
+###################################################
+##  Channel Mode Messages (Continuous Controller)
+##  They share a status byte.
+##  The controller makes the difference here
+
+# High resolution continuous controllers (MSB)
+
+BANK_SELECT = 0x00
+MODULATION_WHEEL = 0x01
+BREATH_CONTROLLER = 0x02
+FOOT_CONTROLLER = 0x04
+PORTAMENTO_TIME = 0x05
+DATA_ENTRY = 0x06
+CHANNEL_VOLUME = 0x07
+BALANCE = 0x08
+PAN = 0x0A
+EXPRESSION_CONTROLLER = 0x0B
+EFFECT_CONTROL_1 = 0x0C
+EFFECT_CONTROL_2 = 0x0D
+GEN_PURPOSE_CONTROLLER_1 = 0x10
+GEN_PURPOSE_CONTROLLER_2 = 0x11
+GEN_PURPOSE_CONTROLLER_3 = 0x12
+GEN_PURPOSE_CONTROLLER_4 = 0x13
+
+# High resolution continuous controllers (LSB)
+
+BANK_SELECT = 0x20
+MODULATION_WHEEL = 0x21
+BREATH_CONTROLLER = 0x22
+FOOT_CONTROLLER = 0x24
+PORTAMENTO_TIME = 0x25
+DATA_ENTRY = 0x26
+CHANNEL_VOLUME = 0x27
+BALANCE = 0x28
+PAN = 0x2A
+EXPRESSION_CONTROLLER = 0x2B
+EFFECT_CONTROL_1 = 0x2C
+EFFECT_CONTROL_2 = 0x2D
+GENERAL_PURPOSE_CONTROLLER_1 = 0x30
+GENERAL_PURPOSE_CONTROLLER_2 = 0x31
+GENERAL_PURPOSE_CONTROLLER_3 = 0x32
+GENERAL_PURPOSE_CONTROLLER_4 = 0x33
+
+# Switches
+
+SUSTAIN_ONOFF = 0x40
+PORTAMENTO_ONOFF = 0x41
+SOSTENUTO_ONOFF = 0x42
+SOFT_PEDAL_ONOFF = 0x43
+LEGATO_ONOFF = 0x44
+HOLD_2_ONOFF = 0x45
+
+# Low resolution continuous controllers
+
+SOUND_CONTROLLER_1 = 0x46                  # (TG: Sound Variation;   FX: Exciter On/Off)
+SOUND_CONTROLLER_2 = 0x47                  # (TG: Harmonic Content;   FX: Compressor On/Off)
+SOUND_CONTROLLER_3 = 0x48                  # (TG: Release Time;   FX: Distortion On/Off)
+SOUND_CONTROLLER_4 = 0x49                  # (TG: Attack Time;   FX: EQ On/Off)
+SOUND_CONTROLLER_5 = 0x4A                  # (TG: Brightness;   FX: Expander On/Off)75	SOUND_CONTROLLER_6   (TG: Undefined;   FX: Reverb OnOff)
+SOUND_CONTROLLER_7 = 0x4C                  # (TG: Undefined;   FX: Delay OnOff)
+SOUND_CONTROLLER_8 = 0x4D                  # (TG: Undefined;   FX: Pitch Transpose OnOff)
+SOUND_CONTROLLER_9 = 0x4E                  # (TG: Undefined;   FX: Flange/Chorus OnOff)
+SOUND_CONTROLLER_10 = 0x4F                 # (TG: Undefined;   FX: Special Effects OnOff)
+GENERAL_PURPOSE_CONTROLLER_5 = 0x50
+GENERAL_PURPOSE_CONTROLLER_6 = 0x51
+GENERAL_PURPOSE_CONTROLLER_7 = 0x52
+GENERAL_PURPOSE_CONTROLLER_8 = 0x53
+PORTAMENTO_CONTROL = 0x54                  # (PTC)   (0vvvvvvv is the source Note number)   (Detail)
+EFFECTS_1 = 0x5B                           # (Ext. Effects Depth)
+EFFECTS_2 = 0x5C                           # (Tremelo Depth)
+EFFECTS_3 = 0x5D                           # (Chorus Depth)
+EFFECTS_4 = 0x5E                           # (Celeste Depth)
+EFFECTS_5 = 0x5F                           # (Phaser Depth)
+DATA_INCREMENT = 0x60                      # (0vvvvvvv is n/a; use 0)
+DATA_DECREMENT = 0x61                      # (0vvvvvvv is n/a; use 0)
+NON_REGISTERED_PARAMETER_NUMBER = 0x62     # (LSB)
+NON_REGISTERED_PARAMETER_NUMBER = 0x63     # (MSB)
+REGISTERED_PARAMETER_NUMBER = 0x64         # (LSB)
+REGISTERED_PARAMETER_NUMBER = 0x65         # (MSB)
+
+# Channel Mode messages - (Detail)
+
+ALL_SOUND_OFF = 0x78
+RESET_ALL_CONTROLLERS = 0x79
+LOCAL_CONTROL_ONOFF = 0x7A
+ALL_NOTES_OFF = 0x7B
+OMNI_MODE_OFF = 0x7C          # (also causes ANO)
+OMNI_MODE_ON = 0x7D           # (also causes ANO)
+MONO_MODE_ON = 0x7E           # (Poly Off; also causes ANO)
+POLY_MODE_ON = 0x7F           # (Mono Off; also causes ANO)
+
+
+
+###################################################
+## System Common Messages, for all channels
+
+SYSTEM_EXCLUSIVE = 0xF0
+# 11110000 0iiiiiii 0ddddddd ... 11110111
+
+MTC = 0xF1 # MIDI Time Code Quarter Frame
+# 11110001
+
+SONG_POSITION_POINTER = 0xF2
+# 11110010 0vvvvvvv 0wwwwwww (lo-position, hi-position)
+
+SONG_SELECT = 0xF3
+# 11110011 0sssssss (songnumber)
+
+#UNDEFINED = 0xF4
+## 11110100
+
+#UNDEFINED = 0xF5
+## 11110101
+
+TUNING_REQUEST = 0xF6
+# 11110110
+
+END_OFF_EXCLUSIVE = 0xF7 # terminator
+# 11110111 # End of system exclusive
+
+
+###################################################
+## Midifile meta-events
+
+SEQUENCE_NUMBER = 0x00      # 00 02 ss ss (seq-number)
+TEXT            = 0x01      # 01 len text...
+COPYRIGHT       = 0x02      # 02 len text...
+SEQUENCE_NAME   = 0x03      # 03 len text...
+INSTRUMENT_NAME = 0x04      # 04 len text...
+LYRIC           = 0x05      # 05 len text...
+MARKER          = 0x06      # 06 len text...
+CUEPOINT        = 0x07      # 07 len text...
+PROGRAM_NAME    = 0x08      # 08 len text...
+DEVICE_NAME     = 0x09      # 09 len text...
+
+MIDI_CH_PREFIX  = 0x20      # MIDI channel prefix assignment (unofficial)
+
+MIDI_PORT       = 0x21      # 21 01 port, legacy stuff but still used
+END_OF_TRACK    = 0x2F      # 2f 00
+TEMPO           = 0x51      # 51 03 tt tt tt (tempo in us/quarternote)
+SMTP_OFFSET     = 0x54      # 54 05 hh mm ss ff xx
+TIME_SIGNATURE  = 0x58      # 58 04 nn dd cc bb
+KEY_SIGNATURE   = 0x59      # ??? len text...
+SPECIFIC        = 0x7F      # Sequencer specific event
+
+FILE_HEADER     = 'MThd'
+TRACK_HEADER    = 'MTrk'
+
+###################################################
+## System Realtime messages
+## I don't supose these are to be found in midi files?!
+
+TIMING_CLOCK   = 0xF8
+# undefined    = 0xF9
+SONG_START     = 0xFA
+SONG_CONTINUE  = 0xFB
+SONG_STOP      = 0xFC
+# undefined    = 0xFD
+ACTIVE_SENSING = 0xFE
+SYSTEM_RESET   = 0xFF
+
+
+###################################################
+## META EVENT, it is used only in midi files.
+## In transmitted data it means system reset!!!
+
+META_EVENT     = 0xFF
+# 11111111
+
+
+###################################################
+## Helper functions
+
+def is_status(byte):
+    return (byte & 0x80) == 0x80 # 1000 0000
+
+

midi/example_mimimal_type0.py

@@ -0,0 +1,29 @@
+from MidiOutFile import MidiOutFile
+
+"""
+This is an example of the smallest possible type 0 midi file, where 
+all the midi events are in the same track.
+"""
+
+out_file = 'midiout/minimal_type0.mid'
+midi = MidiOutFile(out_file)
+
+# non optional midi framework
+midi.header()
+midi.start_of_track() 
+
+
+# musical events
+
+midi.update_time(0)
+midi.note_on(channel=0, note=0x40)
+
+midi.update_time(192)
+midi.note_off(channel=0, note=0x40)
+
+
+# non optional midi framework
+midi.update_time(0)
+midi.end_of_track()
+
+midi.eof()

midi/example_print_channel_0.py

@@ -0,0 +1,22 @@
+from MidiOutStream import MidiOutStream
+from MidiInFile import MidiInFile
+
+"""
+This prints all note on events on midi channel 0
+"""
+
+
+class Transposer(MidiOutStream):
+
+    "Transposes all notes by 1 octave"
+
+    def note_on(self, channel=0, note=0x40, velocity=0x40):
+        if channel == 0:
+            print(channel, note, velocity, self.rel_time())
+
+
+event_handler = Transposer()
+
+in_file = 'midiout/minimal_type0.mid'
+midi_in = MidiInFile(event_handler, in_file)
+midi_in.read()

midi/example_print_events.py

@@ -0,0 +1,28 @@
+from MidiToText import MidiToText
+
+"""
+This is an example that uses the MidiToText eventhandler. When an 
+event is triggered on it, it prints the event to the console.
+"""
+
+midi = MidiToText()
+
+# non optional midi framework
+midi.header()
+midi.start_of_track() 
+
+
+# musical events
+
+midi.update_time(0)
+midi.note_on(channel=0, note=0x40)
+
+midi.update_time(192)
+midi.note_off(channel=0, note=0x40)
+
+
+# non optional midi framework
+midi.update_time(0)
+midi.end_of_track() # not optional!
+
+midi.eof()

midi/example_print_file.py

@@ -0,0 +1,19 @@
+"""
+This is an example that uses the MidiToText eventhandler. When an 
+event is triggered on it, it prints the event to the console.
+
+It gets the events from the MidiInFile.
+
+So it prints all the events from the infile to the console. great for 
+debugging :-s
+"""
+
+
+# get data
+test_file = 'test/midifiles/minimal-cubase-type0.mid'
+
+# do parsing
+from MidiInFile import MidiInFile
+from MidiToText import MidiToText # the event handler
+midiIn = MidiInFile(MidiToText(), test_file)
+midiIn.read()

midi/example_transpose_octave.py

@@ -0,0 +1,40 @@
+from MidiOutFile import MidiOutFile
+from MidiInFile import MidiInFile
+
+"""
+This is an example of the smallest possible type 0 midi file, where 
+all the midi events are in the same track.
+"""
+
+
+class Transposer(MidiOutFile):
+    
+    "Transposes all notes by 1 octave"
+    
+    def _transp(self, ch, note):
+        if ch != 9: # not the drums!
+            note += 12
+            if note > 127:
+                note = 127
+        return note
+
+
+    def note_on(self, channel=0, note=0x40, velocity=0x40):
+        note = self._transp(channel, note)
+        MidiOutFile.note_on(self, channel, note, velocity)
+        
+        
+    def note_off(self, channel=0, note=0x40, velocity=0x40):
+        note = self._transp(channel, note)
+        MidiOutFile.note_off(self, channel, note, velocity)
+
+
+out_file = 'midiout/transposed.mid'
+midi_out = Transposer(out_file)
+
+#in_file = 'midiout/minimal_type0.mid'
+#in_file = 'test/midifiles/Lola.mid'
+in_file = 'test/midifiles/tennessee_waltz.mid'
+midi_in = MidiInFile(midi_out, in_file)
+midi_in.read()
+

midi/experimental/EventDispatcherBase.py

@@ -0,0 +1,76 @@
+class EventDispatcherBase:
+
+
+    def __init__(self, outstream):
+        """
+        The event dispatcher generates events on the outstream. This 
+        is the base implementation. It is more like an interface for 
+        how the EventDispatcher. It has the methods that are used by 
+        the Midi Parser.
+        """
+        # internal values, don't mess with 'em directly
+        self.outstream = outstream
+
+
+    def eof(self):
+        "End of file!"
+        self.outstream.eof()
+
+
+    def update_time(self, new_time=0, relative=1):
+        "Updates relative/absolute time."
+        self.outstream.update_time(new_time, relative)
+
+    # 'official' midi events
+
+    def header(self, format, nTracks, division):
+        "Triggers the header event"
+        self.outstream.header(format, nTracks, division)
+
+
+    def start_of_track(self, current_track):
+        "Triggers the start of track event"
+        
+        # I do this twice so that users can overwrite the 
+        # start_of_track event handler without worrying whether the 
+        # track number is updated correctly.
+        self.outstream.set_current_track(current_track)
+        self.outstream.start_of_track(current_track)
+
+    # Event dispatchers for midi events
+
+    def channel_messages(self, hi_nible, channel, data):
+        "Dispatches channel messages"
+        self.outstream.channel_message(hi_nible, channel, data)
+
+
+    def continuous_controllers(self, channel, controller, value):
+        "Dispatches channel messages"
+        self.outstream.continuous_controller(channel, controller, value)
+    
+    
+    def system_commons(self, common_type, common_data):
+        "Dispatches system common messages"
+        self.outstream.system_common(common_type, common_data)
+
+
+    def meta_event(self, meta_type, data):
+        "Dispatches meta events"
+        self.outstream.meta_event(meta_type, data)
+
+
+    def sysex_events(self, data):
+        "Dispatcher for sysex events"
+        self.outstream.sysex_event(data)
+
+
+
+if __name__ == '__main__':
+
+
+    from MidiToText import MidiToText
+    from constants import NOTE_ON
+    
+    outstream = MidiToText()
+    dispatcher = EventDispatcherBase(outstream)
+    dispatcher.channel_messages(NOTE_ON, 0x00, '\x40\x40')

midi/experimental/MidiOutPassThrough.py

@@ -0,0 +1,182 @@
+from MidiOutStream import MidiOutStream
+
+class MidiOutPassThrough(MidiOutStream):
+
+
+    """
+
+    This class i mainly used for testing the event dispatcher. The 
+    methods just returns the passed parameters as a tupple.
+
+    """
+
+
+    #####################
+    ## Midi channel events
+
+
+    def note_on(self, channel, note, velocity, time=None):
+        return channel, note, velocity, time
+
+
+    def note_off(self, channel, note, velocity, time=None):
+        return channel, note, velocity, time
+
+
+    def aftertouch(self, channel, note, velocity, time=None):
+        return channel, note, velocity, time
+
+        
+    def continuous_controller(self, channel, controller, value, time=None):
+        return channel, controller, value, time
+
+
+    def patch_change(self, channel, patch, time=None):
+        return channel, patch, time
+
+
+    def channel_pressure(self, channel, pressure, time=None):
+        return channel, pressure, time
+
+
+    #####################
+    ## defined continuous controller events
+    
+#    def cc_
+
+    #####################
+    ## Common events
+
+    def system_exclusive(self, data, time=None):
+        return data, time
+
+
+    def song_position_pointer(self, hiPos, loPos, time=None):
+        return hiPos, loPos, time
+
+
+    def song_select(self, songNumber, time=None):
+        return songNumber, time
+
+
+    def tuning_request(self, time=None):
+        return time
+
+
+
+    #########################
+    # header does not really belong here. But anyhoo!!!
+    
+    def header(self, format, nTracks, division):
+        return format, nTracks, division
+
+
+    def eof(self):
+        return 'eof'
+
+
+    #####################
+    ## meta events
+
+    def start_of_track(self, n_track=0):
+        return n_track
+
+
+    def end_of_track(self, n_track=0, time=None):
+        return n_track, time
+
+
+    def sequence_number(self, hiVal, loVal, time=None):
+        return hiVal, loVal, time
+
+
+    def text(self, text, time=None):
+        return text, time
+
+
+    def copyright(self, text, time=None):
+        return text, time
+
+
+    def sequence_name(self, text, time=None):
+        return text, time
+
+
+    def instrument_name(self, text, time=None):
+        return text, time
+
+
+    def lyric(self, text, time=None):
+        return text, time
+
+
+    def marker(self, text, time=None):
+        return text, time
+
+
+    def cuepoint(self, text, time=None):
+        return text, time
+
+
+    def midi_port(self, value, time=None):
+        return value, time
+
+
+    def tempo(self, value, time=None):
+        return value, time
+
+    def smtp_offset(self, hour, minute, second, frame, framePart, time=None):
+        return hour, minute, second, frame, framePart, time
+
+
+    def time_signature(self, nn, dd, cc, bb, time=None):
+        return nn, dd, cc, bb, time
+
+
+    def key_signature(self, sf, mi, time=None):
+        return sf, mi, time
+
+
+    def sequencer_specific(self, data, time=None):
+        return data, time
+
+
+
+
+    #####################
+    ## realtime events
+
+    def timing_clock(self, time=None):
+        return time
+
+
+    def song_start(self, time=None):
+        return time
+
+
+    def song_stop(self, time=None):
+        return time
+
+
+    def song_continue(self, time=None):
+        return time
+
+
+    def active_sensing(self, time=None):
+        return time
+
+
+    def system_reset(self, time=None):
+        return time
+
+
+
+
+
+if __name__ == '__main__':
+
+    midiOut = MidiOutStream()
+    midiOut.note_on(0, 63, 127, 0)
+    midiOut.note_off(0, 63, 127, 384)
+
+    

midi/experimental/MidiOutStreamBase.py

@@ -0,0 +1,135 @@
+class MidiOutStreamBase:
+
+
+    """
+
+    MidiOutStreamBase is Basically an eventhandler. It is the most central
+    class in the Midi library. You use it both for writing events to
+    an output stream, and as an event handler for an input stream.
+
+    This makes it extremely easy to take input from one stream and
+    send it to another. Ie. if you want to read a Midi file, do some
+    processing, and send it to a midiport.
+
+    All time values are in absolute values from the opening of a
+    stream. To calculate time values, please use the MidiTime and
+    MidiDeltaTime classes.
+
+    """
+
+    def __init__(self):
+        
+        # the time is rather global, so it needs to be stored 
+        # here. Otherwise there would be no really simple way to 
+        # calculate it. The alternative would be to have each event 
+        # handler do it. That sucks even worse!
+        self._absolute_time = 0
+        self._relative_time = 0
+        self._current_track = 0
+
+    # time handling event handlers. They should overwritten with care
+
+    def update_time(self, new_time=0, relative=1):
+        """
+        Updates the time, if relative is true, new_time is relative, 
+        else it's absolute.
+        """
+        if relative:
+            self._relative_time = new_time
+            self._absolute_time += new_time
+        else:
+            self._absolute_time = new_time
+            self._relative_time = new_time - self._absolute_time
+
+    def rel_time(self):
+        "Returns the relative time"
+        return self._relative_time
+
+    def abs_time(self):
+        "Returns the absolute time"
+        return self._absolute_time
+
+    # track handling event handlers
+    
+    def set_current_track(self, new_track):
+        "Sets the current track number"
+        self._current_track = new_track
+    
+    def get_current_track(self):
+        "Returns the current track number"
+        return self._current_track
+    
+    
+    #####################
+    ## Midi events
+
+
+    def channel_message(self, message_type, channel, data):
+        """The default event handler for channel messages"""
+        pass
+
+
+    #####################
+    ## Common events
+
+    def system_exclusive(self, data):
+
+        """The default event handler for system_exclusive messages"""
+        pass
+
+
+    def system_common(self, common_type, common_data):
+
+        """The default event handler for system common messages"""
+        pass
+
+
+    #########################
+    # header does not really belong here. But anyhoo!!!
+    
+    def header(self, format, nTracks, division):
+
+        """
+        format: type of midi file in [1,2]
+        nTracks: number of tracks
+        division: timing division
+        """
+        pass
+
+
+    def start_of_track(self, n_track=0):
+
+        """
+        n_track: number of track
+        """
+        pass
+
+
+    def eof(self):
+
+        """
+        End of file. No more events to be processed.
+        """
+        pass
+
+
+    #####################
+    ## meta events
+
+
+    def meta_event(self, meta_type, data, time):
+        
+        """The default event handler for meta_events"""
+        pass
+
+
+
+
+if __name__ == '__main__':
+
+    midiOut = MidiOutStreamBase()
+    midiOut.update_time(0,0)
+    midiOut.note_on(0, 63, 127)
+    midiOut.note_off(0, 63, 127)
+
+    

midi/experimental/readme.txt

@@ -0,0 +1 @@
+Stuff that I am just playing around with

midi/readme.txt

@@ -0,0 +1,50 @@
+This is the documentation for the midi package
+==============================================
+
+
+The modules follows the following naming convention:
+
+
+MidiIn<StreamType>.py
+---------------------
+
+The MidiIn modules reads midi content for a specific type of stream. Ie. a file or a midi port. It then generates events and triggers them on a MidiOutStream.
+
+
+MidiOut<StreamType>.py
+----------------------
+
+The MidiOut modules are event handlers, that reacts to events generated by a a Midi in module.
+
+
+MidiInBase.py
+---------------
+
+The base class for input streams.
+
+
+MidiOutBase.py
+----------------
+
+The base class for the output streams.
+
+
+
+
+
+
+Internal modules
+================
+
+
+DataTypeConverters.py
+---------------------
+
+A collection of functions that converts the special data types used in midi files to and from strings.
+
+
+constants.py
+------------
+
+A collection of constants from the midi spec.
+

midi/version.txt

@@ -0,0 +1 @@
+0.1.4

midi2abc.py

@@ -0,0 +1,619 @@
+#!/usr/bin/python
+#
+#    Copyright (C) 2011 Nils Liberg (mail: kotorinl at yahoo.co.uk)
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Lesser General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Lesser General Public License for more details.
+#
+#    You should have received a copy of the GNU Lesser General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+#
+#    New in version 0.2:
+#    better handling of accidentals in keys with many flats and sharps
+
+from midi.MidiOutStream import MidiOutStream
+from midi.MidiInFile import MidiInFile
+from fractions import Fraction
+import os
+import os.path
+import sys
+import getopt
+import math
+from simple_abc_parser import get_best_key_for_midi_notes, get_accidentals_for_key
+from io import StringIO
+
+num_quarter_notes_per_bar = 3
+bars_per_line = 4
+
+usage = """PyMidi2Abc version 0.1 May 30 2008, usage:
+
+python pymidi2abc.py <options>
+        [-f] <input file>
+        -o <output file>
+        -k <key signature> key name, or -6 to 6 sharps
+        -l <default note length (L: field)>
+        -m <time signature>
+        --nbb no beam breaks
+        --aux=<denominator of L: unit length>
+        --nt Do not look for triplets or broken rhythm
+        --s8 insert slurs on groups of 8th notes
+        --s16 insert slurs on groups of 16th notes
+        --bpl=<number> of bars printed per line
+        --title=<string> Adds T: field containing string
+        --origin=<string> Adds O: field containing string
+"""
+
+
+def time_to_note_length(time):
+    # corresponds to the length of a 16th note (one forth of a quarter which corresponds to 1.0)
+    unit_time = 0.25
+    num = int(round(time / unit_time))
+    length = Fraction(1, 16) * num
+    return length
+
+
+class Note:
+    def __init__(self, start, end, note):
+        self.start = start
+        self.end = end
+        self.note = note
+        self.length = time_to_note_length(self.end - self.start)
+
+
+class MidiHandler(MidiOutStream):
+    def __init__(self, first_channel, last_channel):
+        MidiOutStream.__init__(self)
+        self.division = None
+        self.first_channel = first_channel
+        self.last_channel = last_channel
+        self.noteon_time = {}
+        self.notes = []
+
+    def sysex_event(self, data):
+        pass
+
+    def time_signature(self, nn, dd, cc, bb):
+        sig = Fraction(nn, 2**dd)
+
+    def header(self, format=0, nTracks=1, division=96):
+        self.division = division
+
+    def note_on(self, channel=0, note=0x40, velocity=0x40):
+        if self.first_channel <= channel <= self.last_channel:
+            self.noteon_time[note] = float(self.abs_time()) / self.division
+
+    def note_off(self, channel=0, note=0x40, velocity=0x40):
+        if self.first_channel <= channel <= self.last_channel:
+            if note in self.noteon_time:
+                end_time = float(self.abs_time()) / self.division
+                self.notes.append(Note(self.noteon_time[note], end_time, note))
+
+
+def is_triplet(notes):
+    if len(notes) < 3:
+        return False
+    tolerance = 0.025
+    for total_len in [1.0, 0.5]:
+        if (
+            abs(notes[0].end - notes[1].start) < tolerance
+            and abs(notes[1].end - notes[2].start) < tolerance
+            and abs(notes[2].end - notes[0].start - total_len) < tolerance
+            and abs(notes[1].start - notes[0].start - total_len / 3) < tolerance
+        ):
+            return True
+    return False
+
+
+def bar(time):
+    global num_quarter_notes_per_bar
+    return int(time / num_quarter_notes_per_bar + 0.003)
+
+
+def bar_residue(time):
+    global num_quarter_notes_per_bar
+    return time - bar(time) * float(num_quarter_notes_per_bar)
+
+
+def duration2abc(f):
+    if f == Fraction(1, 1):
+        return ""
+    elif f == Fraction(1, 2):
+        return "/"
+    elif f == Fraction(1, 4):
+        return "//"
+    elif f.numerator == "1":
+        return "/%d" % f.denumerator
+    else:
+        return str(f)
+
+
+def note_to_string(note, duration, default_len, key_accidentals, cur_accidentals):
+    n_accidentals = sum(key_accidentals)
+    accidentals_to_scale = {
+        7: "^B ^C ^^C ^D ^^D ^E ^F ^^F ^G ^^G ^A =B",
+        6: "^B ^C ^^C ^D =E ^E ^F ^^F ^G ^^G ^A B",
+        5: "^B ^C ^^C ^D E ^E ^F ^^F ^G =A ^A B",
+        4: "^B ^C =D ^D E ^E ^F ^^F ^G A ^A B",
+        3: "^B ^C D ^D E ^E ^F =G ^G A ^A B",
+        2: "=C ^C D ^D E ^E ^F G ^G A ^A B",
+        1: "C ^C D ^D E =F ^F G ^G A ^A B",
+        0: "C ^C D ^D E F ^F G ^G A _B =B",
+        -1: "C ^C D _E =E F ^F G ^G A _B =B",
+        -2: "C ^C D _E =E F ^F G _A =A _B =B",
+        -3: "C _D =D _E =E F ^F G _A =A _B =B",
+        -4: "C _D =D _E =E F _G =G _A =A _B =B",
+        -5: "=C _D =D _E =E F _G =G _A =A _B _C",
+        -6: "=C _D =D _E _F =F _G =G _A =A _B _C",
+        -7: "=C _D =D _E _F =F _G =G _A __B _B _C",
+    }
+
+    scale = accidentals_to_scale[n_accidentals].split()
+    notes = [
+        n.lower().translate(str.maketrans("", "", "_=^")) for n in scale
+    ]  # for semitone: the name of the note
+    # for semitone: 0 if white key, -1 or -2 if flat, 1 or 2 if sharp
+    accidentals = [n.count("^") - n.count("_") for n in scale]
+
+    note_scale = "CDEFGAB"
+    middle_C = 60
+    octave_note = (note - middle_C) % 12
+
+    n = notes[octave_note].upper()
+    accidental_num = accidentals[octave_note]
+    accidental_string = ""
+    scale_number = note_scale.index(n)
+    if cur_accidentals[scale_number] != accidental_num:
+        cur_accidentals[scale_number] = accidental_num
+        accidental_string = {-1: "_", -2: "__", 0: "=", 1: "^", 2: "^^"}[accidental_num]
+
+    octave = (note - middle_C) // 12
+
+    # handle the border cases of Cb and B# to make sure that we use the right octave
+    if octave_note == 11 and accidental_num == -1:
+        octave += 1
+    elif octave_note == 0 and accidental_num == 1:
+        octave -= 1
+
+    if octave > 0:
+        if octave >= 1:
+            n = n.lower()
+        if octave > 1:
+            n = n + "'" * int(octave - 1)
+    elif octave < 0:
+        if abs(octave) >= 1:
+            n = n + "," * abs(octave)
+    result = accidental_string + n
+    shown_duration = duration / default_len
+    if shown_duration != Fraction(1, 1):
+        result = result + duration2abc(shown_duration)
+    return result
+
+
+def is_at_even(time, note_value):
+    offset_in_16ths = time_to_note_length(bar_residue(time)) / note_value
+    return offset_in_16ths.denominator == 1
+
+
+def fix_lengths(notes):
+    for i1 in range(0, len(notes)):
+        for i2 in range(i1 + 1, len(notes)):
+            # if the i2 note starts at a later time and there is a sufficiently large difference between either start times or end times
+            if (
+                notes[i2].start > notes[i1].start
+                and abs(notes[i2].start - notes[i1].start)
+                + abs(notes[i2].end - notes[i1].end)
+                > 0.25
+            ):
+                notes[i1].end = notes[i2].start
+                notes[i1].length = time_to_note_length(
+                    notes[i1].end - notes[i1].start
+                )  # update length
+                break
+
+
+def midi_to_abc(
+    filename=None,
+    notes=None,
+    key=None,
+    metre=Fraction(3, 4),
+    default_len=Fraction(1, 16),
+    bars_per_line=4,
+    title="",
+    artist="",
+    source="",
+    no_triplets=False,
+    no_broken_rythms=False,
+    slur_8th_pairs=False,
+    slur_16th_pairs=False,
+    slur_triplets=True,
+    no_beam_breaks=False,
+    index="1",
+    anacrusis_notes=0,
+):
+    global num_quarter_notes_per_bar
+    num_quarter_notes_per_bar = metre * 4  # int(metre * 4)
+
+    if filename and not notes:
+        # read midi notes
+        handler1 = MidiHandler(0, 15)  # channels 0-15
+        # handler1 = MidiHandler(0, 0)  # channels 0-15
+        MidiInFile(handler1, filename).read()
+        notes = handler1.notes
+    elif not filename and not notes:
+        raise Exception(
+            "midi_to_abc needs to be passed either a filename or a notes argument"
+        )
+
+    # sequence of Note(start, end, note)
+    notes = sorted(notes, key=lambda n: n.start)
+    fix_lengths(notes)
+
+    # determine key and accidentals
+    if not key:
+        key = get_best_key_for_midi_notes([note.note for note in notes])
+    key_accidentals = get_accidentals_for_key(key)
+    cur_accidentals = key_accidentals[:]
+
+    output = StringIO()
+    output.write("X:%s\n" % index)
+    if source:
+        output.write("S:%s\n" % source)
+    if title:
+        output.write("T:%s\n" % title)
+    if artist:
+        output.write("A:%s\n" % artist)
+    output.write("M:%s\n" % metre)
+    output.write("L:%s\n" % default_len)
+    output.write("K:%s\n" % key.capitalize())
+
+    # initialize variables used in loop
+    last_note_start = -1.0
+    bow_started = False
+    broken_rythm_factor = Fraction(1, 1)
+    num_notes = len(notes)
+    bar_num = -1
+
+    if anacrusis_notes:
+        time_shift = 4 * float(metre) - notes[anacrusis_notes].start
+        # print notes[0].start, notes[1].start, notes[2].start
+        # print 'shift', time_shift
+        for n in notes:
+            n.start += time_shift
+            n.end += time_shift
+
+    # don't count the first bar if it's an upbeat (to get equal number of bars on each line)
+    inside_upbeat = (notes and bar_residue(notes[0].start) > 1.0) or anacrusis_notes
+
+    while notes:
+        # if current note is in a different bar than the last one, emit '|'
+        if bar(notes[0].start) > bar(last_note_start):
+            if len(notes) != num_notes:
+                output.write(" |")
+                cur_accidentals = key_accidentals[:]
+            if not inside_upbeat:
+                bar_num += 1
+            inside_upbeat = False
+            if bar_num % bars_per_line == 0 and bar_num > 0:
+                output.write("\n")
+
+        # if we have advanced the length of a quarter note, emit space (for note grouping)
+        br = bar_residue(notes[0].start)
+        if is_at_even(notes[0].start, Fraction(1, 4)) and not no_beam_breaks:
+            output.write(" ")
+
+        # check if next three notes can be interpreted as a triplet
+        if is_triplet(notes) and not no_triplets:
+            length = time_to_note_length(notes[2].end - notes[0].start)
+            _notes = [n.note for n in notes[:3]]
+
+            # convert notes to string representation
+            s = "(3" + "".join(
+                [
+                    note_to_string(
+                        n.note,
+                        n.length * 2,
+                        default_len,
+                        key_accidentals,
+                        cur_accidentals,
+                    )
+                    for n in notes[:3]
+                ]
+            )
+            if slur_triplets:
+                s = "(" + s + ")"
+            output.write(s)
+
+            last_note_start = notes[0].start
+            notes = notes[3:]
+
+        # else handle notes one by one or as a chord
+        else:
+            is_four_16th_notes = (
+                len([n for n in notes[0:4] if n.length == Fraction(1, 16)]) == 4
+            )
+            # either two eights or two eights with broken rythm
+            is_two_8th_notes = (
+                len([n for n in notes[0:2] if n.length == Fraction(1, 8)]) == 2
+                or len(notes) >= 2
+                and (notes[0].length, notes[1].length)
+                in [
+                    (Fraction(3, 16), Fraction(1, 16)),
+                    (Fraction(1, 16), Fraction(3, 16)),
+                ]
+            )
+
+            note = notes.pop(0)
+            last_note_start = note.start
+
+            # build a chord from notes near each other in time (will result in just one element in the non-chord case)
+            chord_notes = [note.note]
+            while notes and abs(notes[0].start - note.start) < 1.0 / 50:
+                chord_notes.append(notes.pop(0).note)
+
+            # let the duration of the first note determine the chord's duration (for simplicity)
+            length = note.length
+
+            # if the current note is the first of four 16th notes then add a bow on the two first notes
+            bow_started_here = False
+            if (
+                notes
+                and abs(br - int(br)) < 1.0 / 20
+                and not bow_started
+                and is_four_16th_notes
+                and slur_16th_pairs
+            ):
+                bow_started_here = True
+                bow_started = True
+                output.write("(")
+            elif (
+                notes
+                and abs(br - int(br)) < 1.0 / 20
+                and not bow_started
+                and is_two_8th_notes
+                and slur_8th_pairs
+                and br < 2.0
+            ):
+                bow_started_here = True
+                bow_started = True
+                output.write("(")
+
+            # check if it's possible to use a broken rytm (< or >) between the current and next note/chord
+            broken_rythm_symbol = ""
+            if not no_broken_rythms:
+                # a broken rythm was activated at the previous note
+                if broken_rythm_factor != Fraction(1, 1):
+                    length = length * broken_rythm_factor
+                    broken_rythm_factor = Fraction(1, 1)
+                elif (
+                    notes
+                    and is_at_even(last_note_start, Fraction(1, 8))
+                    and bar(last_note_start) == bar(notes[0].start)
+                ):
+                    # use > between this and next note
+                    if notes[0].length == length / 3:
+                        broken_rythm_symbol = ">"
+                        length = length * Fraction(2, 3)
+                        broken_rythm_factor = Fraction(2, 1)
+                    # use < between this and next note
+                    if notes[0].length == length * 3:
+                        broken_rythm_symbol = "<"
+                        length = length * Fraction(2, 1)
+                        broken_rythm_factor = Fraction(2, 3)
+
+            # convert notes to string representation and output
+            s = "".join(
+                [
+                    note_to_string(
+                        n, length, default_len, key_accidentals, cur_accidentals
+                    )
+                    for n in chord_notes
+                ]
+            )
+            if len(chord_notes) > 1:
+                s = "[" + s + "]"  # wrap chord
+            output.write(s)
+
+            # output broken rythm symbol if set
+            if broken_rythm_symbol:
+                output.write(str(broken_rythm_symbol))
+
+            # if a bow was previously started end it here
+            if bow_started and not bow_started_here:
+                output.write(")")
+                bow_started = False
+
+            # print 'note', note.start, length, chord_notes, '%.2f' % last_note_start, bar(last_note_start), '%.2f' % bar_residue(last_note_start)#, note.note
+
+    output.write(" |")
+    output.write("\n")
+
+    # left strip lines
+    lines = output.getvalue().split("\n")
+    lines = [l.lstrip() for l in lines]
+    return "\n".join(lines)
+
+
+def main(argv):
+    # setup default values
+    filename = ""
+    output_filename = ""
+    key = None
+    default_len = Fraction(1, 16)
+    metre = Fraction(3, 4)
+    bars_per_line = 4
+    title = ""
+    source = ""
+    no_triplets = False
+    no_broken_rythms = False
+    slur_8th_pairs = False
+    slur_16th_pairs = False
+    no_beam_breaks = False
+
+    # if a single parameter was given and it's a path to an existing file use it as filename
+    if len(argv) == 1 and os.path.exists(argv[0]):
+        filename = argv[0]
+
+    # otherwise interpret options
+    else:
+        try:
+            opts, args = getopt.getopt(
+                argv,
+                "hm:k:f:o:l:",
+                [
+                    "help",
+                    "metre=",
+                    "key=",
+                    "bpl=",
+                    "file=",
+                    "outfile=",
+                    "length=",
+                    "bpl=",
+                    "title=",
+                    "source=",
+                    "nbb",
+                    "nt",
+                    "s8",
+                    "s16",
+                    "aux=",
+                ],
+            )
+        except getopt.GetoptError:
+            print(usage)
+            sys.exit(2)
+
+        for opt, arg in opts:
+            try:
+                if opt in ("-h", "--help"):
+                    print(usage)
+                    sys.exit()
+                elif opt in ("-m", "--metre"):
+                    x, y = map(int, arg.split("/"))
+                    metre = Fraction(x, y)
+                elif opt in ("-k", "--key"):
+                    try:
+                        k = int(arg)
+                        key = {
+                            -7: "cb",
+                            -6: "gb",
+                            -5: "db",
+                            -4: "ab",
+                            -3: "eb",
+                            -2: "bb",
+                            -1: "f",
+                            0: "c",
+                            1: "g",
+                            2: "d",
+                            3: "a",
+                            4: "e",
+                            5: "b",
+                            6: "f#",
+                            7: "c#",
+                        }[k]
+                    except ValueError:
+                        key = arg.lower()
+                elif opt in ("--bpl",):
+                    bars_per_line = int(arg)
+                elif opt in ("--title",):
+                    title = arg
+                elif opt in ("--source",):
+                    source = arg
+                elif opt in ("--aux",):
+                    default_len = Fraction(1, int(arg))
+                elif opt in (
+                    "-l",
+                    "--length",
+                ):
+                    x, y = map(int, arg.split("/"))
+                    default_len = Fraction(x, y)
+                elif opt in ("--nt"):
+                    no_triplets = True
+                    no_broken_rythms = True
+                elif opt in ("--nbb"):
+                    no_beam_breaks = True
+                elif opt in ("--s8"):
+                    slur_8th_pairs = True
+                elif opt in ("--s16"):
+                    slur_16th_pairs = True
+                elif opt in ("-f",):
+                    filename = arg
+                elif opt in ("-o",):
+                    output_filename = arg
+            except Exception:
+                print("Error parsing argument: %s" % opt)
+                print(usage)
+                sys.exit(2)
+
+    if not filename:
+        print("Error: filename (-f) required!")
+        print(usage)
+        sys.exit(2)
+
+    # do midi to abc conversion
+    result = midi_to_abc(
+        filename,
+        None,
+        key,
+        metre,
+        default_len,
+        bars_per_line,
+        title,
+        source,
+        no_triplets,
+        no_broken_rythms,
+        slur_8th_pairs,
+        slur_16th_pairs,
+        no_beam_breaks=no_beam_breaks,
+    )
+
+    # output to stdout or file
+    if output_filename:
+        open(output_filename, "w").write(result)
+    else:
+        print(result)
+
+
+def midi2abc(filename, title, artist):
+    key = None
+    default_len = Fraction(1, 16)
+    metre = Fraction(3, 4)
+    bars_per_line = 4
+    no_triplets = False
+    no_broken_rythms = False
+    slur_8th_pairs = False
+    slur_16th_pairs = False
+    no_beam_breaks = False
+
+    if not filename:
+        print("Error: filename (-f) required!")
+        print(usage)
+        sys.exit(2)
+
+    # do midi to abc conversion
+    return midi_to_abc(
+        filename,
+        None,
+        key,
+        metre,
+        default_len,
+        bars_per_line,
+        title,
+        artist,
+        "",
+        no_triplets,
+        no_broken_rythms,
+        slur_8th_pairs,
+        slur_16th_pairs,
+        no_beam_breaks=no_beam_breaks,
+    )
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

requirements.txt

@@ -1,4 +1,4 @@
 librosa==0.9.2
 piano_transcription_inference
 pymupdf
-torch
+music21

simple_abc_parser.py

@@ -0,0 +1,170 @@
+#    Copyright (C) 2011 Nils Liberg (mail: kotorinl at yahoo.co.uk)
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Lesser General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Lesser General Public License for more details.
+#
+#    You should have received a copy of the GNU Lesser General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from fractions import Fraction
+
+key_data = \
+    {'c':  ('#', 0), 'am':  ('#', 0), 'ddor':   ('#', 0),
+        'f':  ('b', 1), 'dm':  ('b', 1), 'gdor':   ('#', 1),
+        'bb': ('b', 2), 'gm':  ('b', 2), 'cdor':   ('#', 2),
+        'eb': ('b', 3), 'cm':  ('b', 3), 'bbdor':  ('#', 3),
+        'ab': ('b', 4), 'fm':  ('b', 4), 'ebdor':  ('#', 4),
+        'db': ('b', 5), 'bbm': ('b', 5), 'abdor':  ('#', 5),
+        'gb': ('b', 6), 'ebm': ('b', 6), 'abdor':  ('#', 6),
+        'cb': ('b', 7), 'abm': ('b', 7), 'dbdor':  ('#', 7),
+        'g':  ('#', 1), 'em':  ('#', 1), 'ador':   ('#', 0),
+        'd':  ('#', 2), 'bm':  ('#', 2), 'edor':   ('#', 0),
+        'a':  ('#', 3), 'f#m': ('#', 3), 'bdor':   ('#', 0),
+        'e':  ('#', 4), 'c#m': ('#', 4), 'f#dor':  ('#', 0),
+        'b':  ('#', 5), 'g#m': ('#', 5), 'c#dor':  ('#', 0),
+        'f#': ('#', 6), 'd#m': ('#', 6), 'g#dor':  ('#', 0),
+        'c#': ('#', 7), 'a#m': ('#', 7), 'c#dor':  ('#', 0), }
+
+
+def get_base_note_for_key(key):
+    key = key[:2]
+    # print key, notes_sharp, notes_flat
+    if key in notes_sharp:
+        return notes_sharp.index(key)
+    if key in notes_flat:
+        return notes_flat.index(key)
+    key = key[:1]
+    if key in notes_sharp:
+        return notes_sharp.index(key)
+    if key in notes_flat:
+        return notes_flat.index(key)
+    raise Exception("error, incorrect key:%s" % key)
+
+
+def get_best_key_for_midi_notes(notes):
+    notes = [n % 12 for n in notes]
+    penalty_key_tuples = []
+    for key in key_data:
+        accidentals = get_accidentals_for_key(key)
+        basic_notes_in_key = [x+y for x,
+                              y in zip(doremi2chromatic, accidentals)]
+        penalty = len(
+            [note for note in notes if not note in basic_notes_in_key])
+        if notes[-1] != get_base_note_for_key(key):
+            penalty += 2
+        if key.endswith('dor'):
+            penalty += 1
+        penalty_key_tuples.append((penalty, key))
+    penalty_key_tuples.sort()
+    # print '\n'.join((str(x) for x in penalty_key_tuples))
+    # print 'notes[-1]=', notes[-1]
+    # print 'penalty', penalty_key_tuples[0][0]
+    return penalty_key_tuples[0][1]  # key of the first (and best) item
+
+
+def update_extra_accidentals_for_note(basic_accidentals, extra_accidentals, note):
+    # merge the basic and extra accidentals and let the later have precedence over the former
+    accidentals = [b if b is not None else a for a,
+                   b in zip(basic_accidentals, extra_accidentals)]
+
+    basic_notes_in_key = [x+y for x,
+                          y in zip(doremi2chromatic, basic_accidentals)]
+    current_notes_in_key = [x+y for x, y in zip(doremi2chromatic, accidentals)]
+
+    change = None
+
+    # if not note in current_notes_in_key:
+    #    if
+
+    return {None: '',
+            0:    '=',
+            -1:    '_',
+            1:     '^'}[change]
+
+
+# map from do-re-mi scale index to chromatic interval
+doremi2chromatic = [0, 2, 4, 5, 7, 9, 11, 13]
+
+# map from note name to note number in a C scale
+note2number = 'cdefgab'
+
+notes_sharp = 'c c# d d# e f f# g g# a a# b'.split()
+notes_flat = 'c db d eb e f gb g ab a bb b'.split()
+
+
+def get_accidentals(fifths):
+    # determine the accidentals for one octave
+    steps = 'C D E F G A B'.split()
+    one_octave = [0] * 7
+    if fifths > 0:
+        for i in range(fifths):
+            one_octave[(3 + i*4) % 7] = 1
+    else:
+        for i in range(fifths+1, 1):
+            one_octave[(6 + i*4) % 7] = -1
+    scale = []
+    for i in range(7):
+        scale.append(steps[i] + {-1: 'b', 0: '', 1: '#'}[one_octave[i]])
+    print(' '.join(scale))
+
+    # use the same for all octaves
+    accidentals = {}
+    for octave in range(1, 7):
+        for step in range(7):
+            note = '%s%s' % (steps[step], octave)  # eg. G4
+            accidentals[note] = one_octave[step]
+    return accidentals
+
+
+def get_accidentals_for_key(key):
+    ''' returns a list of seven values corresponding to the notes in the C scale. 1 means #, -1 means b, and 0 means no change. '''
+    key = key.lower().strip().strip()
+    sharp_or_flat, number = key_data[key]
+    # initially no of the seven notes are flat or sharp (0=neutral)
+    accidentals = [0] * 7
+    # add accidentals
+    for i in range(number):
+        if sharp_or_flat == '#':
+            accidentals[(3 - 3*i) % 7] = 1
+        else:
+            accidentals[(6 + 3*i) % 7] = -1
+    return accidentals
+
+
+class Note:
+    def __init__(self, note, duration, ties_to_next=False, broken_rythm=''):
+        self.note = note                   # number of semitones from centre note
+        self.duration = duration           # duration expressed as a Fraction object
+        # whether the abc representation of this note ended with '-' representing a tie to the next note
+        self.ties_to_next = ties_to_next
+        self.broken_rythm = broken_rythm   # the ABC broken rythm symbol or an empty string
+        # (used when the duration of the next note is established)
+
+    def __repr__(self):
+        ''' returns a string representation of this Note object '''
+        notes = ('c', 'c#', 'd', 'd#', 'e', 'f',
+                 'f#', 'g', 'g#', 'a', 'a#', 'b')
+        n = notes[self.note % 12].upper()
+        octave = self.note / 12
+        if octave > 0:
+            if octave >= 1:
+                n = n.lower()
+            if octave > 1:
+                n = n + "'" * (octave - 1)
+        elif octave < 0:
+            if abs(octave) > 1:
+                n = n + "," * abs(octave)
+        return n  # + str(self.duration)
+
+    def __str__(self):
+        return repr(self)
+
+# print get_best_key_for_midi_notes([0, 2, 4, 6, 6, 6, 7, 0])
+# print get_base_note_for_key('c')