diff --git "a/midi_to_colab_audio.py" "b/midi_to_colab_audio.py" deleted file mode 100644--- "a/midi_to_colab_audio.py" +++ /dev/null @@ -1,3090 +0,0 @@ -r'''#=================================================================================================================== -# -# MIDI to Colab AUdio Python Module -# -# Converts any MIDI file to raw audio which is compatible -# with Google Colab or HUgging Face Gradio -# -# Version 1.0 -# -# Includes full source code of MIDI, pyfluidsynth, and midi_synthesizer Python modules -# -# Original source code for all modules was retrieved on 10/23/2023 -# -# Project Los Angeles -# Tegridy Code 2023 -# -#=================================================================================================================== -# -# Critical dependencies -# -# pip install numpy -# sudo apt install fluidsynth -# -#=================================================================================================================== -# -# Example usage: -# -# from midi_to_colab_audio import midi_to_colab_audio -# from IPython.display import display, Audio -# -# raw_audio = midi_to_colab_audio('/content/input.mid') -# -# display(Audio(raw_audio, rate=16000, normalize=False)) -# -#=================================================================================================================== -#! /usr/bin/python3 -# unsupported 20091104 ... -# ['set_sequence_number', dtime, sequence] -# ['raw_data', dtime, raw] - -# 20150914 jimbo1qaz MIDI.py str/bytes bug report -# I found a MIDI file which had Shift-JIS titles. When midi.py decodes it as -# latin-1, it produces a string which cannot even be accessed without raising -# a UnicodeDecodeError. Maybe, when converting raw byte strings from MIDI, -# you should keep them as bytes, not improperly decode them. However, this -# would change the API. (ie: text = a "string" ? of 0 or more bytes). It -# could break compatiblity, but there's not much else you can do to fix the bug -# https://en.wikipedia.org/wiki/Shift_JIS - -This module offers functions: concatenate_scores(), grep(), -merge_scores(), mix_scores(), midi2opus(), midi2score(), opus2midi(), -opus2score(), play_score(), score2midi(), score2opus(), score2stats(), -score_type(), segment(), timeshift() and to_millisecs(), -where "midi" means the MIDI-file bytes (as can be put in a .mid file, -or piped into aplaymidi), and "opus" and "score" are list-structures -as inspired by Sean Burke's MIDI-Perl CPAN module. - -Warning: Version 6.4 is not necessarily backward-compatible with -previous versions, in that text-data is now bytes, not strings. -This reflects the fact that many MIDI files have text data in -encodings other that ISO-8859-1, for example in Shift-JIS. - -Download MIDI.py from http://www.pjb.com.au/midi/free/MIDI.py -and put it in your PYTHONPATH. MIDI.py depends on Python3. - -There is also a call-compatible translation into Lua of this -module: see http://www.pjb.com.au/comp/lua/MIDI.html - -Backup web site: https://peterbillam.gitlab.io/miditools/ - -The "opus" is a direct translation of the midi-file-events, where -the times are delta-times, in ticks, since the previous event. - -The "score" is more human-centric; it uses absolute times, and -combines the separate note_on and note_off events into one "note" -event, with a duration: - ['note', start_time, duration, channel, note, velocity] # in a "score" - - EVENTS (in an "opus" structure) - ['note_off', dtime, channel, note, velocity] # in an "opus" - ['note_on', dtime, channel, note, velocity] # in an "opus" - ['key_after_touch', dtime, channel, note, velocity] - ['control_change', dtime, channel, controller(0-127), value(0-127)] - ['patch_change', dtime, channel, patch] - ['channel_after_touch', dtime, channel, velocity] - ['pitch_wheel_change', dtime, channel, pitch_wheel] - ['text_event', dtime, text] - ['copyright_text_event', dtime, text] - ['track_name', dtime, text] - ['instrument_name', dtime, text] - ['lyric', dtime, text] - ['marker', dtime, text] - ['cue_point', dtime, text] - ['text_event_08', dtime, text] - ['text_event_09', dtime, text] - ['text_event_0a', dtime, text] - ['text_event_0b', dtime, text] - ['text_event_0c', dtime, text] - ['text_event_0d', dtime, text] - ['text_event_0e', dtime, text] - ['text_event_0f', dtime, text] - ['end_track', dtime] - ['set_tempo', dtime, tempo] - ['smpte_offset', dtime, hr, mn, se, fr, ff] - ['time_signature', dtime, nn, dd, cc, bb] - ['key_signature', dtime, sf, mi] - ['sequencer_specific', dtime, raw] - ['raw_meta_event', dtime, command(0-255), raw] - ['sysex_f0', dtime, raw] - ['sysex_f7', dtime, raw] - ['song_position', dtime, song_pos] - ['song_select', dtime, song_number] - ['tune_request', dtime] - - DATA TYPES - channel = a value 0 to 15 - controller = 0 to 127 (see http://www.pjb.com.au/muscript/gm.html#cc ) - dtime = time measured in "ticks", 0 to 268435455 - velocity = a value 0 (soft) to 127 (loud) - note = a value 0 to 127 (middle-C is 60) - patch = 0 to 127 (see http://www.pjb.com.au/muscript/gm.html ) - pitch_wheel = a value -8192 to 8191 (0x1FFF) - raw = bytes, of length 0 or more (for sysex events see below) - sequence_number = a value 0 to 65,535 (0xFFFF) - song_pos = a value 0 to 16,383 (0x3FFF) - song_number = a value 0 to 127 - tempo = microseconds per crochet (quarter-note), 0 to 16777215 - text = bytes, of length 0 or more - ticks = the number of ticks per crochet (quarter-note) - - In sysex_f0 events, the raw data must not start with a \xF0 byte, - since this gets added automatically; - but it must end with an explicit \xF7 byte! - In the very unlikely case that you ever need to split sysex data - into one sysex_f0 followed by one or more sysex_f7s, then only the - last of those sysex_f7 events must end with the explicit \xF7 byte - (again, the raw data of individual sysex_f7 events must not start - with any \xF7 byte, since this gets added automatically). - - Since version 6.4, text data is in bytes, not in a ISO-8859-1 string. - - - GOING THROUGH A SCORE WITHIN A PYTHON PROGRAM - channels = {2,3,5,8,13} - itrack = 1 # skip 1st element which is ticks - while itrack < len(score): - for event in score[itrack]: - if event[0] == 'note': # for example, - pass # do something to all notes - # or, to work on events in only particular channels... - channel_index = MIDI.Event2channelindex.get(event[0], False) - if channel_index and (event[channel_index] in channels): - pass # do something to channels 2,3,5,8 and 13 - itrack += 1 - -''' - -import sys, struct, copy -# sys.stdout = os.fdopen(sys.stdout.fileno(), 'wb') -Version = '6.7' -VersionDate = '20201120' -# 20201120 6.7 call to bytest() removed, and protect _unshift_ber_int -# 20160702 6.6 to_millisecs() now handles set_tempo across multiple Tracks -# 20150921 6.5 segment restores controllers as well as patch and tempo -# 20150914 6.4 text data is bytes or bytearray, not ISO-8859-1 strings -# 20150628 6.3 absent any set_tempo, default is 120bpm (see MIDI file spec 1.1) -# 20150101 6.2 all text events can be 8-bit; let user get the right encoding -# 20141231 6.1 fix _some_text_event; sequencer_specific data can be 8-bit -# 20141230 6.0 synth_specific data can be 8-bit -# 20120504 5.9 add the contents of mid_opus_tracks() -# 20120208 5.8 fix num_notes_by_channel() ; should be a dict -# 20120129 5.7 _encode handles empty tracks; score2stats num_notes_by_channel -# 20111111 5.6 fix patch 45 and 46 in Number2patch, should be Harp -# 20110129 5.5 add mix_opus_tracks() and event2alsaseq() -# 20110126 5.4 "previous message repeated N times" to save space on stderr -# 20110125 5.2 opus2score terminates unended notes at the end of the track -# 20110124 5.1 the warnings in midi2opus display track_num -# 21110122 5.0 if garbage, midi2opus returns the opus so far -# 21110119 4.9 non-ascii chars stripped out of the text_events -# 21110110 4.8 note_on with velocity=0 treated as a note-off -# 21110108 4.6 unknown F-series event correctly eats just one byte -# 21011010 4.2 segment() uses start_time, end_time named params -# 21011005 4.1 timeshift() must not pad the set_tempo command -# 21011003 4.0 pitch2note_event must be chapitch2note_event -# 21010918 3.9 set_sequence_number supported, FWIW -# 20100913 3.7 many small bugfixes; passes all tests -# 20100910 3.6 concatenate_scores enforce ticks=1000, just like merge_scores -# 20100908 3.5 minor bugs fixed in score2stats -# 20091104 3.4 tune_request now supported -# 20091104 3.3 fixed bug in decoding song_position and song_select -# 20091104 3.2 unsupported: set_sequence_number tune_request raw_data -# 20091101 3.1 document how to traverse a score within Python -# 20091021 3.0 fixed bug in score2stats detecting GM-mode = 0 -# 20091020 2.9 score2stats reports GM-mode and bank msb,lsb events -# 20091019 2.8 in merge_scores, channel 9 must remain channel 9 (in GM) -# 20091018 2.7 handles empty tracks gracefully -# 20091015 2.6 grep() selects channels -# 20091010 2.5 merge_scores reassigns channels to avoid conflicts -# 20091010 2.4 fixed bug in to_millisecs which now only does opusses -# 20091010 2.3 score2stats returns channels & patch_changes, by_track & total -# 20091010 2.2 score2stats() returns also pitches and percussion dicts -# 20091010 2.1 bugs: >= not > in segment, to notice patch_change at time 0 -# 20091010 2.0 bugs: spurious pop(0) ( in _decode sysex -# 20091008 1.9 bugs: ISO decoding in sysex; str( not int( in note-off warning -# 20091008 1.8 add concatenate_scores() -# 20091006 1.7 score2stats() measures nticks and ticks_per_quarter -# 20091004 1.6 first mix_scores() and merge_scores() -# 20090424 1.5 timeshift() bugfix: earliest only sees events after from_time -# 20090330 1.4 timeshift() has also a from_time argument -# 20090322 1.3 timeshift() has also a start_time argument -# 20090319 1.2 add segment() and timeshift() -# 20090301 1.1 add to_millisecs() - -_previous_warning = '' # 5.4 -_previous_times = 0 # 5.4 -#------------------------------- Encoding stuff -------------------------- - -def opus2midi(opus=[]): - r'''The argument is a list: the first item in the list is the "ticks" -parameter, the others are the tracks. Each track is a list -of midi-events, and each event is itself a list; see above. -opus2midi() returns a bytestring of the MIDI, which can then be -written either to a file opened in binary mode (mode='wb'), -or to stdout by means of: sys.stdout.buffer.write() - -my_opus = [ - 96, - [ # track 0: - ['patch_change', 0, 1, 8], # and these are the events... - ['note_on', 5, 1, 25, 96], - ['note_off', 96, 1, 25, 0], - ['note_on', 0, 1, 29, 96], - ['note_off', 96, 1, 29, 0], - ], # end of track 0 -] -my_midi = opus2midi(my_opus) -sys.stdout.buffer.write(my_midi) -''' - if len(opus) < 2: - opus=[1000, [],] - tracks = copy.deepcopy(opus) - ticks = int(tracks.pop(0)) - ntracks = len(tracks) - if ntracks == 1: - format = 0 - else: - format = 1 - - my_midi = b"MThd\x00\x00\x00\x06"+struct.pack('>HHH',format,ntracks,ticks) - for track in tracks: - events = _encode(track) - my_midi += b'MTrk' + struct.pack('>I',len(events)) + events - _clean_up_warnings() - return my_midi - - -def score2opus(score=None): - r''' -The argument is a list: the first item in the list is the "ticks" -parameter, the others are the tracks. Each track is a list -of score-events, and each event is itself a list. A score-event -is similar to an opus-event (see above), except that in a score: - 1) the times are expressed as an absolute number of ticks - from the track's start time - 2) the pairs of 'note_on' and 'note_off' events in an "opus" - are abstracted into a single 'note' event in a "score": - ['note', start_time, duration, channel, pitch, velocity] -score2opus() returns a list specifying the equivalent "opus". - -my_score = [ - 96, - [ # track 0: - ['patch_change', 0, 1, 8], - ['note', 5, 96, 1, 25, 96], - ['note', 101, 96, 1, 29, 96] - ], # end of track 0 -] -my_opus = score2opus(my_score) -''' - if len(score) < 2: - score=[1000, [],] - tracks = copy.deepcopy(score) - ticks = int(tracks.pop(0)) - opus_tracks = [] - for scoretrack in tracks: - time2events = dict([]) - for scoreevent in scoretrack: - if scoreevent[0] == 'note': - note_on_event = ['note_on',scoreevent[1], - scoreevent[3],scoreevent[4],scoreevent[5]] - note_off_event = ['note_off',scoreevent[1]+scoreevent[2], - scoreevent[3],scoreevent[4],scoreevent[5]] - if time2events.get(note_on_event[1]): - time2events[note_on_event[1]].append(note_on_event) - else: - time2events[note_on_event[1]] = [note_on_event,] - if time2events.get(note_off_event[1]): - time2events[note_off_event[1]].append(note_off_event) - else: - time2events[note_off_event[1]] = [note_off_event,] - continue - if time2events.get(scoreevent[1]): - time2events[scoreevent[1]].append(scoreevent) - else: - time2events[scoreevent[1]] = [scoreevent,] - - sorted_times = [] # list of keys - for k in time2events.keys(): - sorted_times.append(k) - sorted_times.sort() - - sorted_events = [] # once-flattened list of values sorted by key - for time in sorted_times: - sorted_events.extend(time2events[time]) - - abs_time = 0 - for event in sorted_events: # convert abs times => delta times - delta_time = event[1] - abs_time - abs_time = event[1] - event[1] = delta_time - opus_tracks.append(sorted_events) - opus_tracks.insert(0,ticks) - _clean_up_warnings() - return opus_tracks - -def score2midi(score=None): - r''' -Translates a "score" into MIDI, using score2opus() then opus2midi() -''' - return opus2midi(score2opus(score)) - -#--------------------------- Decoding stuff ------------------------ - -def midi2opus(midi=b''): - r'''Translates MIDI into a "opus". For a description of the -"opus" format, see opus2midi() -''' - my_midi=bytearray(midi) - if len(my_midi) < 4: - _clean_up_warnings() - return [1000,[],] - id = bytes(my_midi[0:4]) - if id != b'MThd': - _warn("midi2opus: midi starts with "+str(id)+" instead of 'MThd'") - _clean_up_warnings() - return [1000,[],] - [length, format, tracks_expected, ticks] = struct.unpack( - '>IHHH', bytes(my_midi[4:14])) - if length != 6: - _warn("midi2opus: midi header length was "+str(length)+" instead of 6") - _clean_up_warnings() - return [1000,[],] - my_opus = [ticks,] - my_midi = my_midi[14:] - track_num = 1 # 5.1 - while len(my_midi) >= 8: - track_type = bytes(my_midi[0:4]) - if track_type != b'MTrk': - _warn('midi2opus: Warning: track #'+str(track_num)+' type is '+str(track_type)+" instead of b'MTrk'") - [track_length] = struct.unpack('>I', my_midi[4:8]) - my_midi = my_midi[8:] - if track_length > len(my_midi): - _warn('midi2opus: track #'+str(track_num)+' length '+str(track_length)+' is too large') - _clean_up_warnings() - return my_opus # 5.0 - my_midi_track = my_midi[0:track_length] - my_track = _decode(my_midi_track) - my_opus.append(my_track) - my_midi = my_midi[track_length:] - track_num += 1 # 5.1 - _clean_up_warnings() - return my_opus - -def opus2score(opus=[]): - r'''For a description of the "opus" and "score" formats, -see opus2midi() and score2opus(). -''' - if len(opus) < 2: - _clean_up_warnings() - return [1000,[],] - tracks = copy.deepcopy(opus) # couple of slices probably quicker... - ticks = int(tracks.pop(0)) - score = [ticks,] - for opus_track in tracks: - ticks_so_far = 0 - score_track = [] - chapitch2note_on_events = dict([]) # 4.0 - for opus_event in opus_track: - ticks_so_far += opus_event[1] - if opus_event[0] == 'note_off' or (opus_event[0] == 'note_on' and opus_event[4] == 0): # 4.8 - cha = opus_event[2] - pitch = opus_event[3] - key = cha*128 + pitch - if chapitch2note_on_events.get(key): - new_event = chapitch2note_on_events[key].pop(0) - new_event[2] = ticks_so_far - new_event[1] - score_track.append(new_event) - elif pitch > 127: - pass #_warn('opus2score: note_off with no note_on, bad pitch='+str(pitch)) - else: - pass #_warn('opus2score: note_off with no note_on cha='+str(cha)+' pitch='+str(pitch)) - elif opus_event[0] == 'note_on': - cha = opus_event[2] - pitch = opus_event[3] - key = cha*128 + pitch - new_event = ['note',ticks_so_far,0,cha,pitch, opus_event[4]] - if chapitch2note_on_events.get(key): - chapitch2note_on_events[key].append(new_event) - else: - chapitch2note_on_events[key] = [new_event,] - else: - opus_event[1] = ticks_so_far - score_track.append(opus_event) - # check for unterminated notes (Oisín) -- 5.2 - for chapitch in chapitch2note_on_events: - note_on_events = chapitch2note_on_events[chapitch] - for new_e in note_on_events: - new_e[2] = ticks_so_far - new_e[1] - score_track.append(new_e) - pass #_warn("opus2score: note_on with no note_off cha="+str(new_e[3])+' pitch='+str(new_e[4])+'; adding note_off at end') - score.append(score_track) - _clean_up_warnings() - return score - -def midi2score(midi=b''): - r''' -Translates MIDI into a "score", using midi2opus() then opus2score() -''' - return opus2score(midi2opus(midi)) - -def midi2ms_score(midi=b''): - r''' -Translates MIDI into a "score" with one beat per second and one -tick per millisecond, using midi2opus() then to_millisecs() -then opus2score() -''' - return opus2score(to_millisecs(midi2opus(midi))) - -#------------------------ Other Transformations --------------------- - -def to_millisecs(old_opus=None): - r'''Recallibrates all the times in an "opus" to use one beat -per second and one tick per millisecond. This makes it -hard to retrieve any information about beats or barlines, -but it does make it easy to mix different scores together. -''' - if old_opus == None: - return [1000,[],] - try: - old_tpq = int(old_opus[0]) - except IndexError: # 5.0 - _warn('to_millisecs: the opus '+str(type(old_opus))+' has no elements') - return [1000,[],] - new_opus = [1000,] - # 6.7 first go through building a table of set_tempos by absolute-tick - ticks2tempo = {} - itrack = 1 - while itrack < len(old_opus): - ticks_so_far = 0 - for old_event in old_opus[itrack]: - if old_event[0] == 'note': - raise TypeError('to_millisecs needs an opus, not a score') - ticks_so_far += old_event[1] - if old_event[0] == 'set_tempo': - ticks2tempo[ticks_so_far] = old_event[2] - itrack += 1 - # then get the sorted-array of their keys - tempo_ticks = [] # list of keys - for k in ticks2tempo.keys(): - tempo_ticks.append(k) - tempo_ticks.sort() - # then go through converting to millisec, testing if the next - # set_tempo lies before the next track-event, and using it if so. - itrack = 1 - while itrack < len(old_opus): - ms_per_old_tick = 500.0 / old_tpq # float: will round later 6.3 - i_tempo_ticks = 0 - ticks_so_far = 0 - ms_so_far = 0.0 - previous_ms_so_far = 0.0 - new_track = [['set_tempo',0,1000000],] # new "crochet" is 1 sec - for old_event in old_opus[itrack]: - # detect if ticks2tempo has something before this event - # 20160702 if ticks2tempo is at the same time, leave it - event_delta_ticks = old_event[1] - if (i_tempo_ticks < len(tempo_ticks) and - tempo_ticks[i_tempo_ticks] < (ticks_so_far + old_event[1])): - delta_ticks = tempo_ticks[i_tempo_ticks] - ticks_so_far - ms_so_far += (ms_per_old_tick * delta_ticks) - ticks_so_far = tempo_ticks[i_tempo_ticks] - ms_per_old_tick = ticks2tempo[ticks_so_far] / (1000.0*old_tpq) - i_tempo_ticks += 1 - event_delta_ticks -= delta_ticks - new_event = copy.deepcopy(old_event) # now handle the new event - ms_so_far += (ms_per_old_tick * old_event[1]) - new_event[1] = round(ms_so_far - previous_ms_so_far) - if old_event[0] != 'set_tempo': - previous_ms_so_far = ms_so_far - new_track.append(new_event) - ticks_so_far += event_delta_ticks - new_opus.append(new_track) - itrack += 1 - _clean_up_warnings() - return new_opus - -def event2alsaseq(event=None): # 5.5 - r'''Converts an event into the format needed by the alsaseq module, -http://pp.com.mx/python/alsaseq -The type of track (opus or score) is autodetected. -''' - pass - -def grep(score=None, channels=None): - r'''Returns a "score" containing only the channels specified -''' - if score == None: - return [1000,[],] - ticks = score[0] - new_score = [ticks,] - if channels == None: - return new_score - channels = set(channels) - global Event2channelindex - itrack = 1 - while itrack < len(score): - new_score.append([]) - for event in score[itrack]: - channel_index = Event2channelindex.get(event[0], False) - if channel_index: - if event[channel_index] in channels: - new_score[itrack].append(event) - else: - new_score[itrack].append(event) - itrack += 1 - return new_score - -def play_score(score=None): - r'''Converts the "score" to midi, and feeds it into 'aplaymidi -' -''' - if score == None: - return - import subprocess - pipe = subprocess.Popen(['aplaymidi','-'], stdin=subprocess.PIPE) - if score_type(score) == 'opus': - pipe.stdin.write(opus2midi(score)) - else: - pipe.stdin.write(score2midi(score)) - pipe.stdin.close() - -def timeshift(score=None, shift=None, start_time=None, from_time=0, tracks={0,1,2,3,4,5,6,7,8,10,12,13,14,15}): - r'''Returns a "score" shifted in time by "shift" ticks, or shifted -so that the first event starts at "start_time" ticks. - -If "from_time" is specified, only those events in the score -that begin after it are shifted. If "start_time" is less than -"from_time" (or "shift" is negative), then the intermediate -notes are deleted, though patch-change events are preserved. - -If "tracks" are specified, then only those tracks get shifted. -"tracks" can be a list, tuple or set; it gets converted to set -internally. - -It is deprecated to specify both "shift" and "start_time". -If this does happen, timeshift() will print a warning to -stderr and ignore the "shift" argument. - -If "shift" is negative and sufficiently large that it would -leave some event with a negative tick-value, then the score -is shifted so that the first event occurs at time 0. This -also occurs if "start_time" is negative, and is also the -default if neither "shift" nor "start_time" are specified. -''' - #_warn('tracks='+str(tracks)) - if score == None or len(score) < 2: - return [1000, [],] - new_score = [score[0],] - my_type = score_type(score) - if my_type == '': - return new_score - if my_type == 'opus': - _warn("timeshift: opus format is not supported\n") - # _clean_up_scores() 6.2; doesn't exist! what was it supposed to do? - return new_score - if not (shift == None) and not (start_time == None): - _warn("timeshift: shift and start_time specified: ignoring shift\n") - shift = None - if shift == None: - if (start_time == None) or (start_time < 0): - start_time = 0 - # shift = start_time - from_time - - i = 1 # ignore first element (ticks) - tracks = set(tracks) # defend against tuples and lists - earliest = 1000000000 - if not (start_time == None) or shift < 0: # first find the earliest event - while i < len(score): - if len(tracks) and not ((i-1) in tracks): - i += 1 - continue - for event in score[i]: - if event[1] < from_time: - continue # just inspect the to_be_shifted events - if event[1] < earliest: - earliest = event[1] - i += 1 - if earliest > 999999999: - earliest = 0 - if shift == None: - shift = start_time - earliest - elif (earliest + shift) < 0: - start_time = 0 - shift = 0 - earliest - - i = 1 # ignore first element (ticks) - while i < len(score): - if len(tracks) == 0 or not ((i-1) in tracks): # 3.8 - new_score.append(score[i]) - i += 1 - continue - new_track = [] - for event in score[i]: - new_event = list(event) - #if new_event[1] == 0 and shift > 0 and new_event[0] != 'note': - # pass - #elif new_event[1] >= from_time: - if new_event[1] >= from_time: - # 4.1 must not rightshift set_tempo - if new_event[0] != 'set_tempo' or shift<0: - new_event[1] += shift - elif (shift < 0) and (new_event[1] >= (from_time+shift)): - continue - new_track.append(new_event) - if len(new_track) > 0: - new_score.append(new_track) - i += 1 - _clean_up_warnings() - return new_score - -def segment(score=None, start_time=None, end_time=None, start=0, end=100000000, - tracks={0,1,2,3,4,5,6,7,8,10,11,12,13,14,15}): - r'''Returns a "score" which is a segment of the one supplied -as the argument, beginning at "start_time" ticks and ending -at "end_time" ticks (or at the end if "end_time" is not supplied). -If the set "tracks" is specified, only those tracks will -be returned. -''' - if score == None or len(score) < 2: - return [1000, [],] - if start_time == None: # as of 4.2 start_time is recommended - start_time = start # start is legacy usage - if end_time == None: # likewise - end_time = end - new_score = [score[0],] - my_type = score_type(score) - if my_type == '': - return new_score - if my_type == 'opus': - # more difficult (disconnecting note_on's from their note_off's)... - _warn("segment: opus format is not supported\n") - _clean_up_warnings() - return new_score - i = 1 # ignore first element (ticks); we count in ticks anyway - tracks = set(tracks) # defend against tuples and lists - while i < len(score): - if len(tracks) and not ((i-1) in tracks): - i += 1 - continue - new_track = [] - channel2cc_num = {} # most recent controller change before start - channel2cc_val = {} - channel2cc_time = {} - channel2patch_num = {} # keep most recent patch change before start - channel2patch_time = {} - set_tempo_num = 500000 # most recent tempo change before start 6.3 - set_tempo_time = 0 - earliest_note_time = end_time - for event in score[i]: - if event[0] == 'control_change': # 6.5 - cc_time = channel2cc_time.get(event[2]) or 0 - if (event[1] <= start_time) and (event[1] >= cc_time): - channel2cc_num[event[2]] = event[3] - channel2cc_val[event[2]] = event[4] - channel2cc_time[event[2]] = event[1] - elif event[0] == 'patch_change': - patch_time = channel2patch_time.get(event[2]) or 0 - if (event[1]<=start_time) and (event[1] >= patch_time): # 2.0 - channel2patch_num[event[2]] = event[3] - channel2patch_time[event[2]] = event[1] - elif event[0] == 'set_tempo': - if (event[1]<=start_time) and (event[1]>=set_tempo_time): #6.4 - set_tempo_num = event[2] - set_tempo_time = event[1] - if (event[1] >= start_time) and (event[1] <= end_time): - new_track.append(event) - if (event[0] == 'note') and (event[1] < earliest_note_time): - earliest_note_time = event[1] - if len(new_track) > 0: - new_track.append(['set_tempo', start_time, set_tempo_num]) - for c in channel2patch_num: - new_track.append(['patch_change',start_time,c,channel2patch_num[c]],) - for c in channel2cc_num: # 6.5 - new_track.append(['control_change',start_time,c,channel2cc_num[c],channel2cc_val[c]]) - new_score.append(new_track) - i += 1 - _clean_up_warnings() - return new_score - -def score_type(opus_or_score=None): - r'''Returns a string, either 'opus' or 'score' or '' -''' - if opus_or_score == None or str(type(opus_or_score)).find('list')<0 or len(opus_or_score) < 2: - return '' - i = 1 # ignore first element - while i < len(opus_or_score): - for event in opus_or_score[i]: - if event[0] == 'note': - return 'score' - elif event[0] == 'note_on': - return 'opus' - i += 1 - return '' - -def concatenate_scores(scores): - r'''Concatenates a list of scores into one score. -If the scores differ in their "ticks" parameter, -they will all get converted to millisecond-tick format. -''' - # the deepcopys are needed if the input_score's are refs to the same obj - # e.g. if invoked by midisox's repeat() - input_scores = _consistentise_ticks(scores) # 3.7 - output_score = copy.deepcopy(input_scores[0]) - for input_score in input_scores[1:]: - output_stats = score2stats(output_score) - delta_ticks = output_stats['nticks'] - itrack = 1 - while itrack < len(input_score): - if itrack >= len(output_score): # new output track if doesn't exist - output_score.append([]) - for event in input_score[itrack]: - output_score[itrack].append(copy.deepcopy(event)) - output_score[itrack][-1][1] += delta_ticks - itrack += 1 - return output_score - -def merge_scores(scores): - r'''Merges a list of scores into one score. A merged score comprises -all of the tracks from all of the input scores; un-merging is possible -by selecting just some of the tracks. If the scores differ in their -"ticks" parameter, they will all get converted to millisecond-tick -format. merge_scores attempts to resolve channel-conflicts, -but there are of course only 15 available channels... -''' - input_scores = _consistentise_ticks(scores) # 3.6 - output_score = [1000] - channels_so_far = set() - all_channels = {0,1,2,3,4,5,6,7,8,10,11,12,13,14,15} - global Event2channelindex - for input_score in input_scores: - new_channels = set(score2stats(input_score).get('channels_total', [])) - new_channels.discard(9) # 2.8 cha9 must remain cha9 (in GM) - for channel in channels_so_far & new_channels: - # consistently choose lowest avaiable, to ease testing - free_channels = list(all_channels - (channels_so_far|new_channels)) - if len(free_channels) > 0: - free_channels.sort() - free_channel = free_channels[0] - else: - free_channel = None - break - itrack = 1 - while itrack < len(input_score): - for input_event in input_score[itrack]: - channel_index=Event2channelindex.get(input_event[0],False) - if channel_index and input_event[channel_index]==channel: - input_event[channel_index] = free_channel - itrack += 1 - channels_so_far.add(free_channel) - - channels_so_far |= new_channels - output_score.extend(input_score[1:]) - return output_score - -def _ticks(event): - return event[1] -def mix_opus_tracks(input_tracks): # 5.5 - r'''Mixes an array of tracks into one track. A mixed track -cannot be un-mixed. It is assumed that the tracks share the same -ticks parameter and the same tempo. -Mixing score-tracks is trivial (just insert all events into one array). -Mixing opus-tracks is only slightly harder, but it's common enough -that a dedicated function is useful. -''' - output_score = [1000, []] - for input_track in input_tracks: # 5.8 - input_score = opus2score([1000, input_track]) - for event in input_score[1]: - output_score[1].append(event) - output_score[1].sort(key=_ticks) - output_opus = score2opus(output_score) - return output_opus[1] - -def mix_scores(scores): - r'''Mixes a list of scores into one one-track score. -A mixed score cannot be un-mixed. Hopefully the scores -have no undesirable channel-conflicts between them. -If the scores differ in their "ticks" parameter, -they will all get converted to millisecond-tick format. -''' - input_scores = _consistentise_ticks(scores) # 3.6 - output_score = [1000, []] - for input_score in input_scores: - for input_track in input_score[1:]: - output_score[1].extend(input_track) - return output_score - -def score2stats(opus_or_score=None): - r'''Returns a dict of some basic stats about the score, like -bank_select (list of tuples (msb,lsb)), -channels_by_track (list of lists), channels_total (set), -general_midi_mode (list), -ntracks, nticks, patch_changes_by_track (list of dicts), -num_notes_by_channel (list of numbers), -patch_changes_total (set), -percussion (dict histogram of channel 9 events), -pitches (dict histogram of pitches on channels other than 9), -pitch_range_by_track (list, by track, of two-member-tuples), -pitch_range_sum (sum over tracks of the pitch_ranges), -''' - bank_select_msb = -1 - bank_select_lsb = -1 - bank_select = [] - channels_by_track = [] - channels_total = set([]) - general_midi_mode = [] - num_notes_by_channel = dict([]) - patches_used_by_track = [] - patches_used_total = set([]) - patch_changes_by_track = [] - patch_changes_total = set([]) - percussion = dict([]) # histogram of channel 9 "pitches" - pitches = dict([]) # histogram of pitch-occurrences channels 0-8,10-15 - pitch_range_sum = 0 # u pitch-ranges of each track - pitch_range_by_track = [] - is_a_score = True - if opus_or_score == None: - return {'bank_select':[], 'channels_by_track':[], 'channels_total':[], - 'general_midi_mode':[], 'ntracks':0, 'nticks':0, - 'num_notes_by_channel':dict([]), - 'patch_changes_by_track':[], 'patch_changes_total':[], - 'percussion':{}, 'pitches':{}, 'pitch_range_by_track':[], - 'ticks_per_quarter':0, 'pitch_range_sum':0} - ticks_per_quarter = opus_or_score[0] - i = 1 # ignore first element, which is ticks - nticks = 0 - while i < len(opus_or_score): - highest_pitch = 0 - lowest_pitch = 128 - channels_this_track = set([]) - patch_changes_this_track = dict({}) - for event in opus_or_score[i]: - if event[0] == 'note': - num_notes_by_channel[event[3]] = num_notes_by_channel.get(event[3],0) + 1 - if event[3] == 9: - percussion[event[4]] = percussion.get(event[4],0) + 1 - else: - pitches[event[4]] = pitches.get(event[4],0) + 1 - if event[4] > highest_pitch: - highest_pitch = event[4] - if event[4] < lowest_pitch: - lowest_pitch = event[4] - channels_this_track.add(event[3]) - channels_total.add(event[3]) - finish_time = event[1] + event[2] - if finish_time > nticks: - nticks = finish_time - elif event[0] == 'note_off' or (event[0] == 'note_on' and event[4] == 0): # 4.8 - finish_time = event[1] - if finish_time > nticks: - nticks = finish_time - elif event[0] == 'note_on': - is_a_score = False - num_notes_by_channel[event[2]] = num_notes_by_channel.get(event[2],0) + 1 - if event[2] == 9: - percussion[event[3]] = percussion.get(event[3],0) + 1 - else: - pitches[event[3]] = pitches.get(event[3],0) + 1 - if event[3] > highest_pitch: - highest_pitch = event[3] - if event[3] < lowest_pitch: - lowest_pitch = event[3] - channels_this_track.add(event[2]) - channels_total.add(event[2]) - elif event[0] == 'patch_change': - patch_changes_this_track[event[2]] = event[3] - patch_changes_total.add(event[3]) - elif event[0] == 'control_change': - if event[3] == 0: # bank select MSB - bank_select_msb = event[4] - elif event[3] == 32: # bank select LSB - bank_select_lsb = event[4] - if bank_select_msb >= 0 and bank_select_lsb >= 0: - bank_select.append((bank_select_msb,bank_select_lsb)) - bank_select_msb = -1 - bank_select_lsb = -1 - elif event[0] == 'sysex_f0': - if _sysex2midimode.get(event[2], -1) >= 0: - general_midi_mode.append(_sysex2midimode.get(event[2])) - if is_a_score: - if event[1] > nticks: - nticks = event[1] - else: - nticks += event[1] - if lowest_pitch == 128: - lowest_pitch = 0 - channels_by_track.append(channels_this_track) - patch_changes_by_track.append(patch_changes_this_track) - pitch_range_by_track.append((lowest_pitch,highest_pitch)) - pitch_range_sum += (highest_pitch-lowest_pitch) - i += 1 - - return {'bank_select':bank_select, - 'channels_by_track':channels_by_track, - 'channels_total':channels_total, - 'general_midi_mode':general_midi_mode, - 'ntracks':len(opus_or_score)-1, - 'nticks':nticks, - 'num_notes_by_channel':num_notes_by_channel, - 'patch_changes_by_track':patch_changes_by_track, - 'patch_changes_total':patch_changes_total, - 'percussion':percussion, - 'pitches':pitches, - 'pitch_range_by_track':pitch_range_by_track, - 'pitch_range_sum':pitch_range_sum, - 'ticks_per_quarter':ticks_per_quarter} - -#----------------------------- Event stuff -------------------------- - -_sysex2midimode = { - "\x7E\x7F\x09\x01\xF7": 1, - "\x7E\x7F\x09\x02\xF7": 0, - "\x7E\x7F\x09\x03\xF7": 2, -} - -# Some public-access tuples: -MIDI_events = tuple('''note_off note_on key_after_touch -control_change patch_change channel_after_touch -pitch_wheel_change'''.split()) - -Text_events = tuple('''text_event copyright_text_event -track_name instrument_name lyric marker cue_point text_event_08 -text_event_09 text_event_0a text_event_0b text_event_0c -text_event_0d text_event_0e text_event_0f'''.split()) - -Nontext_meta_events = tuple('''end_track set_tempo -smpte_offset time_signature key_signature sequencer_specific -raw_meta_event sysex_f0 sysex_f7 song_position song_select -tune_request'''.split()) -# unsupported: raw_data - -# Actually, 'tune_request' is is F-series event, not strictly a meta-event... -Meta_events = Text_events + Nontext_meta_events -All_events = MIDI_events + Meta_events - -# And three dictionaries: -Number2patch = { # General MIDI patch numbers: -0:'Acoustic Grand', -1:'Bright Acoustic', -2:'Electric Grand', -3:'Honky-Tonk', -4:'Electric Piano 1', -5:'Electric Piano 2', -6:'Harpsichord', -7:'Clav', -8:'Celesta', -9:'Glockenspiel', -10:'Music Box', -11:'Vibraphone', -12:'Marimba', -13:'Xylophone', -14:'Tubular Bells', -15:'Dulcimer', -16:'Drawbar Organ', -17:'Percussive Organ', -18:'Rock Organ', -19:'Church Organ', -20:'Reed Organ', -21:'Accordion', -22:'Harmonica', -23:'Tango Accordion', -24:'Acoustic Guitar(nylon)', -25:'Acoustic Guitar(steel)', -26:'Electric Guitar(jazz)', -27:'Electric Guitar(clean)', -28:'Electric Guitar(muted)', -29:'Overdriven Guitar', -30:'Distortion Guitar', -31:'Guitar Harmonics', -32:'Acoustic Bass', -33:'Electric Bass(finger)', -34:'Electric Bass(pick)', -35:'Fretless Bass', -36:'Slap Bass 1', -37:'Slap Bass 2', -38:'Synth Bass 1', -39:'Synth Bass 2', -40:'Violin', -41:'Viola', -42:'Cello', -43:'Contrabass', -44:'Tremolo Strings', -45:'Pizzicato Strings', -46:'Orchestral Harp', -47:'Timpani', -48:'String Ensemble 1', -49:'String Ensemble 2', -50:'SynthStrings 1', -51:'SynthStrings 2', -52:'Choir Aahs', -53:'Voice Oohs', -54:'Synth Voice', -55:'Orchestra Hit', -56:'Trumpet', -57:'Trombone', -58:'Tuba', -59:'Muted Trumpet', -60:'French Horn', -61:'Brass Section', -62:'SynthBrass 1', -63:'SynthBrass 2', -64:'Soprano Sax', -65:'Alto Sax', -66:'Tenor Sax', -67:'Baritone Sax', -68:'Oboe', -69:'English Horn', -70:'Bassoon', -71:'Clarinet', -72:'Piccolo', -73:'Flute', -74:'Recorder', -75:'Pan Flute', -76:'Blown Bottle', -77:'Skakuhachi', -78:'Whistle', -79:'Ocarina', -80:'Lead 1 (square)', -81:'Lead 2 (sawtooth)', -82:'Lead 3 (calliope)', -83:'Lead 4 (chiff)', -84:'Lead 5 (charang)', -85:'Lead 6 (voice)', -86:'Lead 7 (fifths)', -87:'Lead 8 (bass+lead)', -88:'Pad 1 (new age)', -89:'Pad 2 (warm)', -90:'Pad 3 (polysynth)', -91:'Pad 4 (choir)', -92:'Pad 5 (bowed)', -93:'Pad 6 (metallic)', -94:'Pad 7 (halo)', -95:'Pad 8 (sweep)', -96:'FX 1 (rain)', -97:'FX 2 (soundtrack)', -98:'FX 3 (crystal)', -99:'FX 4 (atmosphere)', -100:'FX 5 (brightness)', -101:'FX 6 (goblins)', -102:'FX 7 (echoes)', -103:'FX 8 (sci-fi)', -104:'Sitar', -105:'Banjo', -106:'Shamisen', -107:'Koto', -108:'Kalimba', -109:'Bagpipe', -110:'Fiddle', -111:'Shanai', -112:'Tinkle Bell', -113:'Agogo', -114:'Steel Drums', -115:'Woodblock', -116:'Taiko Drum', -117:'Melodic Tom', -118:'Synth Drum', -119:'Reverse Cymbal', -120:'Guitar Fret Noise', -121:'Breath Noise', -122:'Seashore', -123:'Bird Tweet', -124:'Telephone Ring', -125:'Helicopter', -126:'Applause', -127:'Gunshot', -} -Notenum2percussion = { # General MIDI Percussion (on Channel 9): -35:'Acoustic Bass Drum', -36:'Bass Drum 1', -37:'Side Stick', -38:'Acoustic Snare', -39:'Hand Clap', -40:'Electric Snare', -41:'Low Floor Tom', -42:'Closed Hi-Hat', -43:'High Floor Tom', -44:'Pedal Hi-Hat', -45:'Low Tom', -46:'Open Hi-Hat', -47:'Low-Mid Tom', -48:'Hi-Mid Tom', -49:'Crash Cymbal 1', -50:'High Tom', -51:'Ride Cymbal 1', -52:'Chinese Cymbal', -53:'Ride Bell', -54:'Tambourine', -55:'Splash Cymbal', -56:'Cowbell', -57:'Crash Cymbal 2', -58:'Vibraslap', -59:'Ride Cymbal 2', -60:'Hi Bongo', -61:'Low Bongo', -62:'Mute Hi Conga', -63:'Open Hi Conga', -64:'Low Conga', -65:'High Timbale', -66:'Low Timbale', -67:'High Agogo', -68:'Low Agogo', -69:'Cabasa', -70:'Maracas', -71:'Short Whistle', -72:'Long Whistle', -73:'Short Guiro', -74:'Long Guiro', -75:'Claves', -76:'Hi Wood Block', -77:'Low Wood Block', -78:'Mute Cuica', -79:'Open Cuica', -80:'Mute Triangle', -81:'Open Triangle', -} - -Event2channelindex = { 'note':3, 'note_off':2, 'note_on':2, - 'key_after_touch':2, 'control_change':2, 'patch_change':2, - 'channel_after_touch':2, 'pitch_wheel_change':2 -} - -################################################################ -# The code below this line is full of frightening things, all to -# do with the actual encoding and decoding of binary MIDI data. - -def _twobytes2int(byte_a): - r'''decode a 16 bit quantity from two bytes,''' - return (byte_a[1] | (byte_a[0] << 8)) - -def _int2twobytes(int_16bit): - r'''encode a 16 bit quantity into two bytes,''' - return bytes([(int_16bit>>8) & 0xFF, int_16bit & 0xFF]) - -def _read_14_bit(byte_a): - r'''decode a 14 bit quantity from two bytes,''' - return (byte_a[0] | (byte_a[1] << 7)) - -def _write_14_bit(int_14bit): - r'''encode a 14 bit quantity into two bytes,''' - return bytes([int_14bit & 0x7F, (int_14bit>>7) & 0x7F]) - -def _ber_compressed_int(integer): - r'''BER compressed integer (not an ASN.1 BER, see perlpacktut for -details). Its bytes represent an unsigned integer in base 128, -most significant digit first, with as few digits as possible. -Bit eight (the high bit) is set on each byte except the last. -''' - ber = bytearray(b'') - seven_bits = 0x7F & integer - ber.insert(0, seven_bits) # XXX surely should convert to a char ? - integer >>= 7 - while integer > 0: - seven_bits = 0x7F & integer - ber.insert(0, 0x80|seven_bits) # XXX surely should convert to a char ? - integer >>= 7 - return ber - -def _unshift_ber_int(ba): - r'''Given a bytearray, returns a tuple of (the ber-integer at the -start, and the remainder of the bytearray). -''' - if not len(ba): # 6.7 - _warn('_unshift_ber_int: no integer found') - return ((0, b"")) - byte = ba.pop(0) - integer = 0 - while True: - integer += (byte & 0x7F) - if not (byte & 0x80): - return ((integer, ba)) - if not len(ba): - _warn('_unshift_ber_int: no end-of-integer found') - return ((0, ba)) - byte = ba.pop(0) - integer <<= 7 - -def _clean_up_warnings(): # 5.4 - # Call this before returning from any publicly callable function - # whenever there's a possibility that a warning might have been printed - # by the function, or by any private functions it might have called. - global _previous_times - global _previous_warning - if _previous_times > 1: - # E:1176, 0: invalid syntax (, line 1176) (syntax-error) ??? - # print(' previous message repeated '+str(_previous_times)+' times', file=sys.stderr) - # 6.7 - sys.stderr.write(' previous message repeated {0} times\n'.format(_previous_times)) - elif _previous_times > 0: - sys.stderr.write(' previous message repeated\n') - _previous_times = 0 - _previous_warning = '' - -def _warn(s=''): - global _previous_times - global _previous_warning - if s == _previous_warning: # 5.4 - _previous_times = _previous_times + 1 - else: - _clean_up_warnings() - sys.stderr.write(str(s)+"\n") - _previous_warning = s - -def _some_text_event(which_kind=0x01, text=b'some_text'): - if str(type(text)).find("'str'") >= 0: # 6.4 test for back-compatibility - data = bytes(text, encoding='ISO-8859-1') - else: - data = bytes(text) - return b'\xFF'+bytes((which_kind,))+_ber_compressed_int(len(data))+data - -def _consistentise_ticks(scores): # 3.6 - # used by mix_scores, merge_scores, concatenate_scores - if len(scores) == 1: - return copy.deepcopy(scores) - are_consistent = True - ticks = scores[0][0] - iscore = 1 - while iscore < len(scores): - if scores[iscore][0] != ticks: - are_consistent = False - break - iscore += 1 - if are_consistent: - return copy.deepcopy(scores) - new_scores = [] - iscore = 0 - while iscore < len(scores): - score = scores[iscore] - new_scores.append(opus2score(to_millisecs(score2opus(score)))) - iscore += 1 - return new_scores - - -########################################################################### - -def _decode(trackdata=b'', exclude=None, include=None, - event_callback=None, exclusive_event_callback=None, no_eot_magic=False): - r'''Decodes MIDI track data into an opus-style list of events. -The options: - 'exclude' is a list of event types which will be ignored SHOULD BE A SET - 'include' (and no exclude), makes exclude a list - of all possible events, /minus/ what include specifies - 'event_callback' is a coderef - 'exclusive_event_callback' is a coderef -''' - trackdata = bytearray(trackdata) - if exclude == None: - exclude = [] - if include == None: - include = [] - if include and not exclude: - exclude = All_events - include = set(include) - exclude = set(exclude) - - # Pointer = 0; not used here; we eat through the bytearray instead. - event_code = -1; # used for running status - event_count = 0; - events = [] - - while(len(trackdata)): - # loop while there's anything to analyze ... - eot = False # When True, the event registrar aborts this loop - event_count += 1 - - E = [] - # E for events - we'll feed it to the event registrar at the end. - - # Slice off the delta time code, and analyze it - [time, remainder] = _unshift_ber_int(trackdata) - - # Now let's see what we can make of the command - first_byte = trackdata.pop(0) & 0xFF - - if (first_byte < 0xF0): # It's a MIDI event - if (first_byte & 0x80): - event_code = first_byte - else: - # It wants running status; use last event_code value - trackdata.insert(0, first_byte) - if (event_code == -1): - _warn("Running status not set; Aborting track.") - return [] - - command = event_code & 0xF0 - channel = event_code & 0x0F - - if (command == 0xF6): # 0-byte argument - pass - elif (command == 0xC0 or command == 0xD0): # 1-byte argument - parameter = trackdata.pop(0) # could be B - else: # 2-byte argument could be BB or 14-bit - parameter = (trackdata.pop(0), trackdata.pop(0)) - - ################################################################# - # MIDI events - - if (command == 0x80): - if 'note_off' in exclude: - continue - E = ['note_off', time, channel, parameter[0], parameter[1]] - elif (command == 0x90): - if 'note_on' in exclude: - continue - E = ['note_on', time, channel, parameter[0], parameter[1]] - elif (command == 0xA0): - if 'key_after_touch' in exclude: - continue - E = ['key_after_touch',time,channel,parameter[0],parameter[1]] - elif (command == 0xB0): - if 'control_change' in exclude: - continue - E = ['control_change',time,channel,parameter[0],parameter[1]] - elif (command == 0xC0): - if 'patch_change' in exclude: - continue - E = ['patch_change', time, channel, parameter] - elif (command == 0xD0): - if 'channel_after_touch' in exclude: - continue - E = ['channel_after_touch', time, channel, parameter] - elif (command == 0xE0): - if 'pitch_wheel_change' in exclude: - continue - E = ['pitch_wheel_change', time, channel, - _read_14_bit(parameter)-0x2000] - else: - _warn("Shouldn't get here; command="+hex(command)) - - elif (first_byte == 0xFF): # It's a Meta-Event! ################## - #[command, length, remainder] = - # unpack("xCwa*", substr(trackdata, $Pointer, 6)); - #Pointer += 6 - len(remainder); - # # Move past JUST the length-encoded. - command = trackdata.pop(0) & 0xFF - [length, trackdata] = _unshift_ber_int(trackdata) - if (command == 0x00): - if (length == 2): - E = ['set_sequence_number',time,_twobytes2int(trackdata)] - else: - _warn('set_sequence_number: length must be 2, not '+str(length)) - E = ['set_sequence_number', time, 0] - - elif command >= 0x01 and command <= 0x0f: # Text events - # 6.2 take it in bytes; let the user get the right encoding. - # text_str = trackdata[0:length].decode('ascii','ignore') - # text_str = trackdata[0:length].decode('ISO-8859-1') - # 6.4 take it in bytes; let the user get the right encoding. - text_data = bytes(trackdata[0:length]) # 6.4 - # Defined text events - if (command == 0x01): - E = ['text_event', time, text_data] - elif (command == 0x02): - E = ['copyright_text_event', time, text_data] - elif (command == 0x03): - E = ['track_name', time, text_data] - elif (command == 0x04): - E = ['instrument_name', time, text_data] - elif (command == 0x05): - E = ['lyric', time, text_data] - elif (command == 0x06): - E = ['marker', time, text_data] - elif (command == 0x07): - E = ['cue_point', time, text_data] - # Reserved but apparently unassigned text events - elif (command == 0x08): - E = ['text_event_08', time, text_data] - elif (command == 0x09): - E = ['text_event_09', time, text_data] - elif (command == 0x0a): - E = ['text_event_0a', time, text_data] - elif (command == 0x0b): - E = ['text_event_0b', time, text_data] - elif (command == 0x0c): - E = ['text_event_0c', time, text_data] - elif (command == 0x0d): - E = ['text_event_0d', time, text_data] - elif (command == 0x0e): - E = ['text_event_0e', time, text_data] - elif (command == 0x0f): - E = ['text_event_0f', time, text_data] - - # Now the sticky events ------------------------------------- - elif (command == 0x2F): - E = ['end_track', time] - # The code for handling this, oddly, comes LATER, - # in the event registrar. - elif (command == 0x51): # DTime, Microseconds/Crochet - if length != 3: - _warn('set_tempo event, but length='+str(length)) - E = ['set_tempo', time, - struct.unpack(">I", b'\x00'+trackdata[0:3])[0]] - elif (command == 0x54): - if length != 5: # DTime, HR, MN, SE, FR, FF - _warn('smpte_offset event, but length='+str(length)) - E = ['smpte_offset',time] + list(struct.unpack(">BBBBB",trackdata[0:5])) - elif (command == 0x58): - if length != 4: # DTime, NN, DD, CC, BB - _warn('time_signature event, but length='+str(length)) - E = ['time_signature', time]+list(trackdata[0:4]) - elif (command == 0x59): - if length != 2: # DTime, SF(signed), MI - _warn('key_signature event, but length='+str(length)) - E = ['key_signature',time] + list(struct.unpack(">bB",trackdata[0:2])) - elif (command == 0x7F): # 6.4 - E = ['sequencer_specific',time, bytes(trackdata[0:length])] - else: - E = ['raw_meta_event', time, command, - bytes(trackdata[0:length])] # 6.0 - #"[uninterpretable meta-event command of length length]" - # DTime, Command, Binary Data - # It's uninterpretable; record it as raw_data. - - # Pointer += length; # Now move Pointer - trackdata = trackdata[length:] - - ###################################################################### - elif (first_byte == 0xF0 or first_byte == 0xF7): - # Note that sysexes in MIDI /files/ are different than sysexes - # in MIDI transmissions!! The vast majority of system exclusive - # messages will just use the F0 format. For instance, the - # transmitted message F0 43 12 00 07 F7 would be stored in a - # MIDI file as F0 05 43 12 00 07 F7. As mentioned above, it is - # required to include the F7 at the end so that the reader of the - # MIDI file knows that it has read the entire message. (But the F7 - # is omitted if this is a non-final block in a multiblock sysex; - # but the F7 (if there) is counted in the message's declared - # length, so we don't have to think about it anyway.) - #command = trackdata.pop(0) - [length, trackdata] = _unshift_ber_int(trackdata) - if first_byte == 0xF0: - # 20091008 added ISO-8859-1 to get an 8-bit str - # 6.4 return bytes instead - E = ['sysex_f0', time, bytes(trackdata[0:length])] - else: - E = ['sysex_f7', time, bytes(trackdata[0:length])] - trackdata = trackdata[length:] - - ###################################################################### - # Now, the MIDI file spec says: - # = + - # = - # = | | - # I know that, on the wire, can include note_on, - # note_off, and all the other 8x to Ex events, AND Fx events - # other than F0, F7, and FF -- namely, , - # , and . - # - # Whether these can occur in MIDI files is not clear specified - # from the MIDI file spec. So, I'm going to assume that - # they CAN, in practice, occur. I don't know whether it's - # proper for you to actually emit these into a MIDI file. - - elif (first_byte == 0xF2): # DTime, Beats - # ::= F2 - E = ['song_position', time, _read_14_bit(trackdata[:2])] - trackdata = trackdata[2:] - - elif (first_byte == 0xF3): # ::= F3 - # E = ['song_select', time, struct.unpack('>B',trackdata.pop(0))[0]] - E = ['song_select', time, trackdata[0]] - trackdata = trackdata[1:] - # DTime, Thing (what?! song number? whatever ...) - - elif (first_byte == 0xF6): # DTime - E = ['tune_request', time] - # What would a tune request be doing in a MIDI /file/? - - ######################################################### - # ADD MORE META-EVENTS HERE. TODO: - # f1 -- MTC Quarter Frame Message. One data byte follows - # the Status; it's the time code value, from 0 to 127. - # f8 -- MIDI clock. no data. - # fa -- MIDI start. no data. - # fb -- MIDI continue. no data. - # fc -- MIDI stop. no data. - # fe -- Active sense. no data. - # f4 f5 f9 fd -- unallocated - - r''' - elif (first_byte > 0xF0) { # Some unknown kinda F-series event #### - # Here we only produce a one-byte piece of raw data. - # But the encoder for 'raw_data' accepts any length of it. - E = [ 'raw_data', - time, substr(trackdata,Pointer,1) ] - # DTime and the Data (in this case, the one Event-byte) - ++Pointer; # itself - -''' - elif first_byte > 0xF0: # Some unknown F-series event - # Here we only produce a one-byte piece of raw data. - # E = ['raw_data', time, bytest(trackdata[0])] # 6.4 - E = ['raw_data', time, trackdata[0]] # 6.4 6.7 - trackdata = trackdata[1:] - else: # Fallthru. - _warn("Aborting track. Command-byte first_byte="+hex(first_byte)) - break - # End of the big if-group - - - ###################################################################### - # THE EVENT REGISTRAR... - if E and (E[0] == 'end_track'): - # This is the code for exceptional handling of the EOT event. - eot = True - if not no_eot_magic: - if E[1] > 0: # a null text-event to carry the delta-time - E = ['text_event', E[1], ''] - else: - E = [] # EOT with a delta-time of 0; ignore it. - - if E and not (E[0] in exclude): - #if ( $exclusive_event_callback ): - # &{ $exclusive_event_callback }( @E ); - #else: - # &{ $event_callback }( @E ) if $event_callback; - events.append(E) - if eot: - break - - # End of the big "Event" while-block - - return events - - -########################################################################### -def _encode(events_lol, unknown_callback=None, never_add_eot=False, - no_eot_magic=False, no_running_status=False): - # encode an event structure, presumably for writing to a file - # Calling format: - # $data_r = MIDI::Event::encode( \@event_lol, { options } ); - # Takes a REFERENCE to an event structure (a LoL) - # Returns an (unblessed) REFERENCE to track data. - - # If you want to use this to encode a /single/ event, - # you still have to do it as a reference to an event structure (a LoL) - # that just happens to have just one event. I.e., - # encode( [ $event ] ) or encode( [ [ 'note_on', 100, 5, 42, 64] ] ) - # If you're doing this, consider the never_add_eot track option, as in - # print MIDI ${ encode( [ $event], { 'never_add_eot' => 1} ) }; - - data = [] # what I'll store the chunks of byte-data in - - # This is so my end_track magic won't corrupt the original - events = copy.deepcopy(events_lol) - - if not never_add_eot: - # One way or another, tack on an 'end_track' - if events: - last = events[-1] - if not (last[0] == 'end_track'): # no end_track already - if (last[0] == 'text_event' and len(last[2]) == 0): - # 0-length text event at track-end. - if no_eot_magic: - # Exceptional case: don't mess with track-final - # 0-length text_events; just peg on an end_track - events.append(['end_track', 0]) - else: - # NORMAL CASE: replace with an end_track, leaving DTime - last[0] = 'end_track' - else: - # last event was neither 0-length text_event nor end_track - events.append(['end_track', 0]) - else: # an eventless track! - events = [['end_track', 0],] - - # maybe_running_status = not no_running_status # unused? 4.7 - last_status = -1 - - for event_r in (events): - E = copy.deepcopy(event_r) - # otherwise the shifting'd corrupt the original - if not E: - continue - - event = E.pop(0) - if not len(event): - continue - - dtime = int(E.pop(0)) - # print('event='+str(event)+' dtime='+str(dtime)) - - event_data = '' - - if ( # MIDI events -- eligible for running status - event == 'note_on' - or event == 'note_off' - or event == 'control_change' - or event == 'key_after_touch' - or event == 'patch_change' - or event == 'channel_after_touch' - or event == 'pitch_wheel_change' ): - - # This block is where we spend most of the time. Gotta be tight. - if (event == 'note_off'): - status = 0x80 | (int(E[0]) & 0x0F) - parameters = struct.pack('>BB', int(E[1])&0x7F, int(E[2])&0x7F) - elif (event == 'note_on'): - status = 0x90 | (int(E[0]) & 0x0F) - parameters = struct.pack('>BB', int(E[1])&0x7F, int(E[2])&0x7F) - elif (event == 'key_after_touch'): - status = 0xA0 | (int(E[0]) & 0x0F) - parameters = struct.pack('>BB', int(E[1])&0x7F, int(E[2])&0x7F) - elif (event == 'control_change'): - status = 0xB0 | (int(E[0]) & 0x0F) - parameters = struct.pack('>BB', int(E[1])&0xFF, int(E[2])&0xFF) - elif (event == 'patch_change'): - status = 0xC0 | (int(E[0]) & 0x0F) - parameters = struct.pack('>B', int(E[1]) & 0xFF) - elif (event == 'channel_after_touch'): - status = 0xD0 | (int(E[0]) & 0x0F) - parameters = struct.pack('>B', int(E[1]) & 0xFF) - elif (event == 'pitch_wheel_change'): - status = 0xE0 | (int(E[0]) & 0x0F) - parameters = _write_14_bit(int(E[1]) + 0x2000) - else: - _warn("BADASS FREAKOUT ERROR 31415!") - - # And now the encoding - # w = BER compressed integer (not ASN.1 BER, see perlpacktut for - # details). Its bytes represent an unsigned integer in base 128, - # most significant digit first, with as few digits as possible. - # Bit eight (the high bit) is set on each byte except the last. - - data.append(_ber_compressed_int(dtime)) - if (status != last_status) or no_running_status: - data.append(struct.pack('>B', status)) - data.append(parameters) - - last_status = status - continue - else: - # Not a MIDI event. - # All the code in this block could be more efficient, - # but this is not where the code needs to be tight. - # print "zaz $event\n"; - last_status = -1 - - if event == 'raw_meta_event': - event_data = _some_text_event(int(E[0]), E[1]) - elif (event == 'set_sequence_number'): # 3.9 - event_data = b'\xFF\x00\x02'+_int2twobytes(E[0]) - - # Text meta-events... - # a case for a dict, I think (pjb) ... - elif (event == 'text_event'): - event_data = _some_text_event(0x01, E[0]) - elif (event == 'copyright_text_event'): - event_data = _some_text_event(0x02, E[0]) - elif (event == 'track_name'): - event_data = _some_text_event(0x03, E[0]) - elif (event == 'instrument_name'): - event_data = _some_text_event(0x04, E[0]) - elif (event == 'lyric'): - event_data = _some_text_event(0x05, E[0]) - elif (event == 'marker'): - event_data = _some_text_event(0x06, E[0]) - elif (event == 'cue_point'): - event_data = _some_text_event(0x07, E[0]) - elif (event == 'text_event_08'): - event_data = _some_text_event(0x08, E[0]) - elif (event == 'text_event_09'): - event_data = _some_text_event(0x09, E[0]) - elif (event == 'text_event_0a'): - event_data = _some_text_event(0x0A, E[0]) - elif (event == 'text_event_0b'): - event_data = _some_text_event(0x0B, E[0]) - elif (event == 'text_event_0c'): - event_data = _some_text_event(0x0C, E[0]) - elif (event == 'text_event_0d'): - event_data = _some_text_event(0x0D, E[0]) - elif (event == 'text_event_0e'): - event_data = _some_text_event(0x0E, E[0]) - elif (event == 'text_event_0f'): - event_data = _some_text_event(0x0F, E[0]) - # End of text meta-events - - elif (event == 'end_track'): - event_data = b"\xFF\x2F\x00" - - elif (event == 'set_tempo'): - #event_data = struct.pack(">BBwa*", 0xFF, 0x51, 3, - # substr( struct.pack('>I', E[0]), 1, 3)) - event_data = b'\xFF\x51\x03'+struct.pack('>I',E[0])[1:] - elif (event == 'smpte_offset'): - # event_data = struct.pack(">BBwBBBBB", 0xFF, 0x54, 5, E[0:5] ) - event_data = struct.pack(">BBBbBBBB", 0xFF,0x54,0x05,E[0],E[1],E[2],E[3],E[4]) - elif (event == 'time_signature'): - # event_data = struct.pack(">BBwBBBB", 0xFF, 0x58, 4, E[0:4] ) - event_data = struct.pack(">BBBbBBB", 0xFF, 0x58, 0x04, E[0],E[1],E[2],E[3]) - elif (event == 'key_signature'): - event_data = struct.pack(">BBBbB", 0xFF, 0x59, 0x02, E[0],E[1]) - elif (event == 'sequencer_specific'): - # event_data = struct.pack(">BBwa*", 0xFF,0x7F, len(E[0]), E[0]) - event_data = _some_text_event(0x7F, E[0]) - # End of Meta-events - - # Other Things... - elif (event == 'sysex_f0'): - #event_data = struct.pack(">Bwa*", 0xF0, len(E[0]), E[0]) - #B=bitstring w=BER-compressed-integer a=null-padded-ascii-str - event_data = bytearray(b'\xF0')+_ber_compressed_int(len(E[0]))+bytearray(E[0]) - elif (event == 'sysex_f7'): - #event_data = struct.pack(">Bwa*", 0xF7, len(E[0]), E[0]) - event_data = bytearray(b'\xF7')+_ber_compressed_int(len(E[0]))+bytearray(E[0]) - - elif (event == 'song_position'): - event_data = b"\xF2" + _write_14_bit( E[0] ) - elif (event == 'song_select'): - event_data = struct.pack('>BB', 0xF3, E[0] ) - elif (event == 'tune_request'): - event_data = b"\xF6" - elif (event == 'raw_data'): - _warn("_encode: raw_data event not supported") - # event_data = E[0] - continue - # End of Other Stuff - - else: - # The Big Fallthru - if unknown_callback: - # push(@data, &{ $unknown_callback }( @$event_r )) - pass - else: - _warn("Unknown event: "+str(event)) - # To surpress complaint here, just set - # 'unknown_callback' => sub { return () } - continue - - #print "Event $event encoded part 2\n" - if str(type(event_data)).find("'str'") >= 0: - event_data = bytearray(event_data.encode('Latin1', 'ignore')) - if len(event_data): # how could $event_data be empty - # data.append(struct.pack('>wa*', dtime, event_data)) - # print(' event_data='+str(event_data)) - data.append(_ber_compressed_int(dtime)+event_data) - - return b''.join(data) - -#=============================================================================== - -""" -================================================================================ - - pyFluidSynth - - Python bindings for FluidSynth - - Copyright 2008, Nathan Whitehead - - - Released under the LGPL - - This module contains python bindings for FluidSynth. FluidSynth is a - software synthesizer for generating music. It works like a MIDI - synthesizer. You load patches, set parameters, then send NOTEON and - NOTEOFF events to play notes. Instruments are defined in SoundFonts, - generally files with the extension SF2. FluidSynth can either be used - to play audio itself, or you can call a function that returns chunks - of audio data and output the data to the soundcard yourself. - FluidSynth works on all major platforms, so pyFluidSynth should also. - -================================================================================ -""" - -from ctypes import * -from ctypes.util import find_library -import os - -# A short circuited or expression to find the FluidSynth library -# (mostly needed for Windows distributions of libfluidsynth supplied with QSynth) - -# DLL search method changed in Python 3.8 -# https://docs.python.org/3/library/os.html#os.add_dll_directory -if hasattr(os, 'add_dll_directory'): - os.add_dll_directory(os.getcwd()) - -lib = find_library('fluidsynth') or \ - find_library('libfluidsynth') or \ - find_library('libfluidsynth-3') or \ - find_library('libfluidsynth-2') or \ - find_library('libfluidsynth-1') - -if lib is None: - raise ImportError("Couldn't find the FluidSynth library.") - -# Dynamically link the FluidSynth library -# Architecture (32-/64-bit) must match your Python version -_fl = CDLL(lib) - -# Helper function for declaring function prototypes -def cfunc(name, result, *args): - """Build and apply a ctypes prototype complete with parameter flags""" - if hasattr(_fl, name): - atypes = [] - aflags = [] - for arg in args: - atypes.append(arg[1]) - aflags.append((arg[2], arg[0]) + arg[3:]) - return CFUNCTYPE(result, *atypes)((name, _fl), tuple(aflags)) - else: # Handle Fluidsynth 1.x, 2.x, etc. API differences - return None - -# Bump this up when changing the interface for users -api_version = '1.3.1' - -# Function prototypes for C versions of functions - -FLUID_OK = 0 -FLUID_FAILED = -1 - -fluid_version = cfunc('fluid_version', c_void_p, - ('major', POINTER(c_int), 1), - ('minor', POINTER(c_int), 1), - ('micro', POINTER(c_int), 1)) - -majver = c_int() -fluid_version(majver, c_int(), c_int()) -if majver.value > 1: - FLUIDSETTING_EXISTS = FLUID_OK -else: - FLUIDSETTING_EXISTS = 1 - -# fluid settings -new_fluid_settings = cfunc('new_fluid_settings', c_void_p) - -fluid_settings_setstr = cfunc('fluid_settings_setstr', c_int, - ('settings', c_void_p, 1), - ('name', c_char_p, 1), - ('str', c_char_p, 1)) - -fluid_settings_setnum = cfunc('fluid_settings_setnum', c_int, - ('settings', c_void_p, 1), - ('name', c_char_p, 1), - ('val', c_double, 1)) - -fluid_settings_setint = cfunc('fluid_settings_setint', c_int, - ('settings', c_void_p, 1), - ('name', c_char_p, 1), - ('val', c_int, 1)) - -fluid_settings_copystr = cfunc('fluid_settings_copystr', c_int, - ('settings', c_void_p, 1), - ('name', c_char_p, 1), - ('str', c_char_p, 1), - ('len', c_int, 1)) - -fluid_settings_getnum = cfunc('fluid_settings_getnum', c_int, - ('settings', c_void_p, 1), - ('name', c_char_p, 1), - ('val', POINTER(c_double), 1)) - -fluid_settings_getint = cfunc('fluid_settings_getint', c_int, - ('settings', c_void_p, 1), - ('name', c_char_p, 1), - ('val', POINTER(c_int), 1)) - -delete_fluid_settings = cfunc('delete_fluid_settings', None, - ('settings', c_void_p, 1)) - -fluid_synth_activate_key_tuning = cfunc('fluid_synth_activate_key_tuning', c_int, - ('synth', c_void_p, 1), - ('bank', c_int, 1), - ('prog', c_int, 1), - ('name', c_char_p, 1), - ('pitch', POINTER(c_double), 1), - ('apply', c_int, 1)) - -fluid_synth_activate_tuning = cfunc('fluid_synth_activate_tuning', c_int, - ('synth', c_void_p, 1), - ('chan', c_int, 1), - ('bank', c_int, 1), - ('prog', c_int, 1), - ('apply', c_int, 1)) - -fluid_synth_deactivate_tuning = cfunc('fluid_synth_deactivate_tuning', c_int, - ('synth', c_void_p, 1), - ('chan', c_int, 1), - ('apply', c_int, 1)) - -fluid_synth_tuning_dump = cfunc('fluid_synth_tuning_dump', c_int, - ('synth', c_void_p, 1), - ('bank', c_int, 1), - ('prog', c_int, 1), - ('name', c_char_p, 1), - ('length', c_int, 1), - ('pitch', POINTER(c_double), 1)) - -# fluid synth -new_fluid_synth = cfunc('new_fluid_synth', c_void_p, - ('settings', c_void_p, 1)) - -delete_fluid_synth = cfunc('delete_fluid_synth', None, - ('synth', c_void_p, 1)) - -fluid_synth_sfload = cfunc('fluid_synth_sfload', c_int, - ('synth', c_void_p, 1), - ('filename', c_char_p, 1), - ('update_midi_presets', c_int, 1)) - -fluid_synth_sfunload = cfunc('fluid_synth_sfunload', c_int, - ('synth', c_void_p, 1), - ('sfid', c_int, 1), - ('update_midi_presets', c_int, 1)) - -fluid_synth_program_select = cfunc('fluid_synth_program_select', c_int, - ('synth', c_void_p, 1), - ('chan', c_int, 1), - ('sfid', c_int, 1), - ('bank', c_int, 1), - ('preset', c_int, 1)) - -fluid_synth_noteon = cfunc('fluid_synth_noteon', c_int, - ('synth', c_void_p, 1), - ('chan', c_int, 1), - ('key', c_int, 1), - ('vel', c_int, 1)) - -fluid_synth_noteoff = cfunc('fluid_synth_noteoff', c_int, - ('synth', c_void_p, 1), - ('chan', c_int, 1), - ('key', c_int, 1)) - -fluid_synth_pitch_bend = cfunc('fluid_synth_pitch_bend', c_int, - ('synth', c_void_p, 1), - ('chan', c_int, 1), - ('val', c_int, 1)) - -fluid_synth_cc = cfunc('fluid_synth_cc', c_int, - ('synth', c_void_p, 1), - ('chan', c_int, 1), - ('ctrl', c_int, 1), - ('val', c_int, 1)) - -fluid_synth_get_cc = cfunc('fluid_synth_get_cc', c_int, - ('synth', c_void_p, 1), - ('chan', c_int, 1), - ('num', c_int, 1), - ('pval', POINTER(c_int), 1)) - -fluid_synth_program_change = cfunc('fluid_synth_program_change', c_int, - ('synth', c_void_p, 1), - ('chan', c_int, 1), - ('prg', c_int, 1)) - -fluid_synth_unset_program = cfunc('fluid_synth_unset_program', c_int, - ('synth', c_void_p, 1), - ('chan', c_int, 1)) - -fluid_synth_get_program = cfunc('fluid_synth_get_program', c_int, - ('synth', c_void_p, 1), - ('chan', c_int, 1), - ('sfont_id', POINTER(c_int), 1), - ('bank_num', POINTER(c_int), 1), - ('preset_num', POINTER(c_int), 1)) - -fluid_synth_bank_select = cfunc('fluid_synth_bank_select', c_int, - ('synth', c_void_p, 1), - ('chan', c_int, 1), - ('bank', c_int, 1)) - -fluid_synth_sfont_select = cfunc('fluid_synth_sfont_select', c_int, - ('synth', c_void_p, 1), - ('chan', c_int, 1), - ('sfid', c_int, 1)) - -fluid_synth_program_reset = cfunc('fluid_synth_program_reset', c_int, - ('synth', c_void_p, 1)) - -fluid_synth_system_reset = cfunc('fluid_synth_system_reset', c_int, - ('synth', c_void_p, 1)) - -fluid_synth_write_s16 = cfunc('fluid_synth_write_s16', c_void_p, - ('synth', c_void_p, 1), - ('len', c_int, 1), - ('lbuf', c_void_p, 1), - ('loff', c_int, 1), - ('lincr', c_int, 1), - ('rbuf', c_void_p, 1), - ('roff', c_int, 1), - ('rincr', c_int, 1)) - -fluid_synth_all_notes_off = cfunc('fluid_synth_all_notes_off', c_int, - ('synth', c_void_p, 1), - ('chan', c_int, 1)) - -fluid_synth_all_sounds_off = cfunc('fluid_synth_all_sounds_off', c_int, - ('synth', c_void_p, 1), - ('chan', c_int, 1)) - - -class fluid_synth_channel_info_t(Structure): - _fields_ = [ - ('assigned', c_int), - ('sfont_id', c_int), - ('bank', c_int), - ('program', c_int), - ('name', c_char*32), - ('reserved', c_char*32)] - -fluid_synth_get_channel_info = cfunc('fluid_synth_get_channel_info', c_int, - ('synth', c_void_p, 1), - ('chan', c_int, 1), - ('info', POINTER(fluid_synth_channel_info_t), 1)) - -fluid_synth_set_reverb_full = cfunc('fluid_synth_set_reverb_full', c_int, - ('synth', c_void_p, 1), - ('set', c_int, 1), - ('roomsize', c_double, 1), - ('damping', c_double, 1), - ('width', c_double, 1), - ('level', c_double, 1)) - -fluid_synth_set_chorus_full = cfunc('fluid_synth_set_chorus_full', c_int, - ('synth', c_void_p, 1), - ('set', c_int, 1), - ('nr', c_int, 1), - ('level', c_double, 1), - ('speed', c_double, 1), - ('depth_ms', c_double, 1), - ('type', c_int, 1)) - -fluid_synth_set_reverb = cfunc('fluid_synth_set_reverb', c_int, - ('synth', c_void_p, 1), - ('roomsize', c_double, 1), - ('damping', c_double, 1), - ('width', c_double, 1), - ('level', c_double, 1)) - -fluid_synth_set_chorus = cfunc('fluid_synth_set_chorus', c_int, - ('synth', c_void_p, 1), - ('nr', c_int, 1), - ('level', c_double, 1), - ('speed', c_double, 1), - ('depth_ms', c_double, 1), - ('type', c_int, 1)) - -fluid_synth_set_reverb_roomsize = cfunc('fluid_synth_set_reverb_roomsize', c_int, - ('synth', c_void_p, 1), - ('roomsize', c_double, 1)) - -fluid_synth_set_reverb_damp = cfunc('fluid_synth_set_reverb_damp', c_int, - ('synth', c_void_p, 1), - ('damping', c_double, 1)) - -fluid_synth_set_reverb_level = cfunc('fluid_synth_set_reverb_level', c_int, - ('synth', c_void_p, 1), - ('level', c_double, 1)) - -fluid_synth_set_reverb_width = cfunc('fluid_synth_set_reverb_width', c_int, - ('synth', c_void_p, 1), - ('width', c_double, 1)) - -fluid_synth_set_chorus_nr = cfunc('fluid_synth_set_chorus_nr', c_int, - ('synth', c_void_p, 1), - ('nr', c_int, 1)) - -fluid_synth_set_chorus_level = cfunc('fluid_synth_set_chorus_level', c_int, - ('synth', c_void_p, 1), - ('level', c_double, 1)) - -fluid_synth_set_chorus_type = cfunc('fluid_synth_set_chorus_type', c_int, - ('synth', c_void_p, 1), - ('type', c_int, 1)) -fluid_synth_get_reverb_roomsize = cfunc('fluid_synth_get_reverb_roomsize', c_double, - ('synth', c_void_p, 1)) - -fluid_synth_get_reverb_damp = cfunc('fluid_synth_get_reverb_damp', c_double, - ('synth', c_void_p, 1)) - -fluid_synth_get_reverb_level = cfunc('fluid_synth_get_reverb_level', c_double, - ('synth', c_void_p, 1)) - -fluid_synth_get_reverb_width = cfunc('fluid_synth_get_reverb_width', c_double, - ('synth', c_void_p, 1)) - - -fluid_synth_get_chorus_nr = cfunc('fluid_synth_get_chorus_nr', c_int, - ('synth', c_void_p, 1)) - -fluid_synth_get_chorus_level = cfunc('fluid_synth_get_chorus_level', c_double, - ('synth', c_void_p, 1)) - -fluid_synth_get_chorus_speed_Hz = cfunc('fluid_synth_get_chorus_speed_Hz', c_double, - ('synth', c_void_p, 1)) - -fluid_synth_get_chorus_depth_ms = cfunc('fluid_synth_get_chorus_depth_ms', c_double, - ('synth', c_void_p, 1)) - -fluid_synth_get_chorus_type = cfunc('fluid_synth_get_chorus_type', c_int, - ('synth', c_void_p, 1)) - -fluid_synth_set_midi_router = cfunc('fluid_synth_set_midi_router', None, - ('synth', c_void_p, 1), - ('router', c_void_p, 1)) - -fluid_synth_handle_midi_event = cfunc('fluid_synth_handle_midi_event', c_int, - ('data', c_void_p, 1), - ('event', c_void_p, 1)) - -# fluid sequencer -new_fluid_sequencer2 = cfunc('new_fluid_sequencer2', c_void_p, - ('use_system_timer', c_int, 1)) - -fluid_sequencer_process = cfunc('fluid_sequencer_process', None, - ('seq', c_void_p, 1), - ('msec', c_uint, 1)) - -fluid_sequencer_register_fluidsynth = cfunc('fluid_sequencer_register_fluidsynth', c_short, - ('seq', c_void_p, 1), - ('synth', c_void_p, 1)) - -fluid_sequencer_register_client = cfunc('fluid_sequencer_register_client', c_short, - ('seq', c_void_p, 1), - ('name', c_char_p, 1), - ('callback', CFUNCTYPE(None, c_uint, c_void_p, c_void_p, c_void_p), 1), - ('data', c_void_p, 1)) - -fluid_sequencer_get_tick = cfunc('fluid_sequencer_get_tick', c_uint, - ('seq', c_void_p, 1)) - -fluid_sequencer_set_time_scale = cfunc('fluid_sequencer_set_time_scale', None, - ('seq', c_void_p, 1), - ('scale', c_double, 1)) - -fluid_sequencer_get_time_scale = cfunc('fluid_sequencer_get_time_scale', c_double, - ('seq', c_void_p, 1)) - -fluid_sequencer_send_at = cfunc('fluid_sequencer_send_at', c_int, - ('seq', c_void_p, 1), - ('evt', c_void_p, 1), - ('time', c_uint, 1), - ('absolute', c_int, 1)) - - -delete_fluid_sequencer = cfunc('delete_fluid_sequencer', None, - ('seq', c_void_p, 1)) - -# fluid event -new_fluid_event = cfunc('new_fluid_event', c_void_p) - -fluid_event_set_source = cfunc('fluid_event_set_source', None, - ('evt', c_void_p, 1), - ('src', c_void_p, 1)) - -fluid_event_set_dest = cfunc('fluid_event_set_dest', None, - ('evt', c_void_p, 1), - ('dest', c_void_p, 1)) - -fluid_event_timer = cfunc('fluid_event_timer', None, - ('evt', c_void_p, 1), - ('data', c_void_p, 1)) - -fluid_event_note = cfunc('fluid_event_note', None, - ('evt', c_void_p, 1), - ('channel', c_int, 1), - ('key', c_short, 1), - ('vel', c_short, 1), - ('duration', c_uint, 1)) - -fluid_event_noteon = cfunc('fluid_event_noteon', None, - ('evt', c_void_p, 1), - ('channel', c_int, 1), - ('key', c_short, 1), - ('vel', c_short, 1)) - -fluid_event_noteoff = cfunc('fluid_event_noteoff', None, - ('evt', c_void_p, 1), - ('channel', c_int, 1), - ('key', c_short, 1)) - -delete_fluid_event = cfunc('delete_fluid_event', None, - ('evt', c_void_p, 1)) - -fluid_midi_event_get_channel = cfunc('fluid_midi_event_get_channel', c_int, - ('evt', c_void_p, 1)) - -fluid_midi_event_get_control = cfunc('fluid_midi_event_get_control', c_int, - ('evt', c_void_p, 1)) - -fluid_midi_event_get_program = cfunc('fluid_midi_event_get_program', c_int, - ('evt', c_void_p, 1)) - -fluid_midi_event_get_key = cfunc('fluid_midi_event_get_key', c_int, - ('evt', c_void_p, 1)) - -fluid_midi_event_get_type = cfunc('fluid_midi_event_get_type', c_int, - ('evt', c_void_p, 1)) - -fluid_midi_event_get_value = cfunc('fluid_midi_event_get_value', c_int, - ('evt', c_void_p, 1)) - -fluid_midi_event_get_velocity = cfunc('fluid_midi_event_get_velocity', c_int, - ('evt', c_void_p, 1)) - -# fluid_player_status returned by fluid_player_get_status() -FLUID_PLAYER_READY = 0 -FLUID_PLAYER_PLAYING = 1 -FLUID_PLAYER_STOPPING = 2 -FLUID_PLAYER_DONE = 3 - -# tempo_type used by fluid_player_set_tempo() -FLUID_PLAYER_TEMPO_INTERNAL = 0 -FLUID_PLAYER_TEMPO_EXTERNAL_BPM = 1 -FLUID_PLAYER_TEMPO_EXTERNAL_MIDI = 2 - -new_fluid_player = cfunc('new_fluid_player', c_void_p, - ('synth', c_void_p, 1)) - -delete_fluid_player = cfunc('delete_fluid_player', None, - ('player', c_void_p, 1)) - -fluid_player_add = cfunc('fluid_player_add', c_int, - ('player', c_void_p, 1), - ('filename', c_char_p, 1)) - - -fluid_player_get_status = cfunc('fluid_player_get_status', c_int, - ('player', c_void_p, 1)) -fluid_player_join = cfunc('fluid_player_join', c_int, - ('player', c_void_p, 1)) - -fluid_player_play = cfunc('fluid_player_play', c_int, - ('player', c_void_p, 1)) - -fluid_player_set_playback_callback = cfunc('fluid_player_set_playback_callback', c_int, - ('player', c_void_p, 1), - ('handler', CFUNCTYPE(c_int, c_void_p, c_void_p), 1), - ('event_handler_data', c_void_p, 1)) - -fluid_player_set_tempo = cfunc('fluid_player_set_tempo', c_int, - ('player', c_void_p, 1), - ('tempo_type', c_int, 1), - ('tempo', c_double, 1)) - -fluid_player_seek = cfunc('fluid_player_seek', c_int, - ('player', c_void_p, 1), - ('ticks', c_int, 1)) - -fluid_player_stop = cfunc('fluid_player_stop', c_int, - ('player', c_void_p, 1)) - -# fluid audio driver -new_fluid_audio_driver = cfunc('new_fluid_audio_driver', c_void_p, - ('settings', c_void_p, 1), - ('synth', c_void_p, 1)) - -delete_fluid_audio_driver = cfunc('delete_fluid_audio_driver', None, - ('driver', c_void_p, 1)) - -# fluid midi driver -new_fluid_midi_driver = cfunc('new_fluid_midi_driver', c_void_p, - ('settings', c_void_p, 1), - ('handler', CFUNCTYPE(c_int, c_void_p, c_void_p), 1), - ('event_handler_data', c_void_p, 1)) - - -# fluid midi router rule -class fluid_midi_router_t(Structure): - _fields_ = [ - ('synth', c_void_p), - ('rules_mutex', c_void_p), - ('rules', c_void_p*6), - ('free_rules', c_void_p), - ('event_handler', c_void_p), - ('event_handler_data', c_void_p), - ('nr_midi_channels', c_int), - ('cmd_rule', c_void_p), - ('cmd_rule_type', POINTER(c_int))] - -delete_fluid_midi_router_rule = cfunc('delete_fluid_midi_router_rule', c_int, - ('rule', c_void_p, 1)) - -new_fluid_midi_router_rule = cfunc('new_fluid_midi_router_rule', c_void_p) - -fluid_midi_router_rule_set_chan = cfunc('fluid_midi_router_rule_set_chan', None, - ('rule', c_void_p, 1), - ('min', c_int, 1), - ('max', c_int, 1), - ('mul', c_float, 1), - ('add', c_int, 1)) - -fluid_midi_router_rule_set_param1 = cfunc('fluid_midi_router_rule_set_param1', None, - ('rule', c_void_p, 1), - ('min', c_int, 1), - ('max', c_int, 1), - ('mul', c_float, 1), - ('add', c_int, 1)) - -fluid_midi_router_rule_set_param2 = cfunc('fluid_midi_router_rule_set_param2', None, - ('rule', c_void_p, 1), - ('min', c_int, 1), - ('max', c_int, 1), - ('mul', c_float, 1), - ('add', c_int, 1)) - -# fluid midi router -new_fluid_midi_router = cfunc('new_fluid_midi_router', POINTER(fluid_midi_router_t), - ('settings', c_void_p, 1), - ('handler', CFUNCTYPE(c_int, c_void_p, c_void_p), 1), - ('event_handler_data', c_void_p, 1)) - -fluid_midi_router_handle_midi_event = cfunc('fluid_midi_router_handle_midi_event', c_int, - ('data', c_void_p, 1), - ('event', c_void_p, 1)) - -fluid_midi_router_clear_rules = cfunc('fluid_midi_router_clear_rules', c_int, - ('router', POINTER(fluid_midi_router_t), 1)) - -fluid_midi_router_set_default_rules = cfunc('fluid_midi_router_set_default_rules', c_int, - ('router', POINTER(fluid_midi_router_t), 1)) - -fluid_midi_router_add_rule = cfunc('fluid_midi_router_add_rule', c_int, - ('router', POINTER(fluid_midi_router_t), 1), - ('rule', c_void_p, 1), - ('type', c_int, 1)) - -# fluidsynth 2.x -new_fluid_cmd_handler=cfunc('new_fluid_cmd_handler', c_void_p, - ('synth', c_void_p, 1), - ('router', c_void_p, 1)) - -fluid_synth_get_sfont_by_id = cfunc('fluid_synth_get_sfont_by_id', c_void_p, - ('synth', c_void_p, 1), - ('id', c_int, 1)) - -fluid_sfont_get_preset = cfunc('fluid_sfont_get_preset', c_void_p, - ('sfont', c_void_p, 1), - ('banknum', c_int, 1), - ('prenum', c_int, 1)) - -fluid_preset_get_name = cfunc('fluid_preset_get_name', c_char_p, - ('preset', c_void_p, 1)) - -fluid_synth_set_reverb = cfunc('fluid_synth_set_reverb', c_int, - ('synth', c_void_p, 1), - ('roomsize', c_double, 1), - ('damping', c_double, 1), - ('width', c_double, 1), - ('level', c_double, 1)) - -fluid_synth_set_chorus = cfunc('fluid_synth_set_chorus', c_int, - ('synth', c_void_p, 1), - ('nr', c_int, 1), - ('level', c_double, 1), - ('speed', c_double, 1), - ('depth_ms', c_double, 1), - ('type', c_int, 1)) - -fluid_synth_get_chorus_speed = cfunc('fluid_synth_get_chorus_speed', c_double, - ('synth', c_void_p, 1)) - -fluid_synth_get_chorus_depth = cfunc('fluid_synth_get_chorus_depth', c_double, - ('synth', c_void_p, 1)) - - -def fluid_synth_write_s16_stereo(synth, len): - """Return generated samples in stereo 16-bit format - - Return value is a Numpy array of samples. - - """ - import numpy - buf = create_string_buffer(len * 4) - fluid_synth_write_s16(synth, len, buf, 0, 2, buf, 1, 2) - return numpy.frombuffer(buf[:], dtype=numpy.int16) - - -# Object-oriented interface, simplifies access to functions - -class Synth: - """Synth represents a FluidSynth synthesizer""" - def __init__(self, gain=0.2, samplerate=44100, channels=256, **kwargs): - """Create new synthesizer object to control sound generation - - Optional keyword arguments: - gain : scale factor for audio output, default is 0.2 - lower values are quieter, allow more simultaneous notes - samplerate : output samplerate in Hz, default is 44100 Hz - added capability for passing arbitrary fluid settings using args - """ - self.settings = new_fluid_settings() - self.setting('synth.gain', gain) - self.setting('synth.sample-rate', float(samplerate)) - self.setting('synth.midi-channels', channels) - for opt,val in kwargs.items(): - self.setting(opt, val) - self.synth = new_fluid_synth(self.settings) - self.audio_driver = None - self.midi_driver = None - self.router = None - def setting(self, opt, val): - """change an arbitrary synth setting, type-smart""" - if isinstance(val, (str, bytes)): - fluid_settings_setstr(self.settings, opt.encode(), val.encode()) - elif isinstance(val, int): - fluid_settings_setint(self.settings, opt.encode(), val) - elif isinstance(val, float): - fluid_settings_setnum(self.settings, opt.encode(), c_double(val)) - def get_setting(self, opt): - """get current value of an arbitrary synth setting""" - val = c_int() - if fluid_settings_getint(self.settings, opt.encode(), byref(val)) == FLUIDSETTING_EXISTS: - return val.value - strval = create_string_buffer(32) - if fluid_settings_copystr(self.settings, opt.encode(), strval, 32) == FLUIDSETTING_EXISTS: - return strval.value.decode() - num = c_double() - if fluid_settings_getnum(self.settings, opt.encode(), byref(num)) == FLUIDSETTING_EXISTS: - return round(num.value, 6) - return None - - def start(self, driver=None, device=None, midi_driver=None, midi_router=None): - """Start audio output driver in separate background thread - - Call this function any time after creating the Synth object. - If you don't call this function, use get_samples() to generate - samples. - - Optional keyword argument: - driver : which audio driver to use for output - device : the device to use for audio output - midi_driver : the midi driver to use for communicating with midi devices - see http://www.fluidsynth.org/api/fluidsettings.xml for allowed values and defaults by platform - """ - driver = driver or self.get_setting('audio.driver') - device = device or self.get_setting('audio.%s.device' % driver) - midi_driver = midi_driver or self.get_setting('midi.driver') - - self.setting('audio.driver', driver) - self.setting('audio.%s.device' % driver, device) - self.audio_driver = new_fluid_audio_driver(self.settings, self.synth) - self.setting('midi.driver', midi_driver) - self.router = new_fluid_midi_router(self.settings, fluid_synth_handle_midi_event, self.synth) - if new_fluid_cmd_handler: - new_fluid_cmd_handler(self.synth, self.router) - else: - fluid_synth_set_midi_router(self.synth, self.router) - if midi_router == None: ## Use fluidsynth to create a MIDI event handler - self.midi_driver = new_fluid_midi_driver(self.settings, fluid_midi_router_handle_midi_event, self.router) - self.custom_router_callback = None - else: ## Supply an external MIDI event handler - self.custom_router_callback = CFUNCTYPE(c_int, c_void_p, c_void_p)(midi_router) - self.midi_driver = new_fluid_midi_driver(self.settings, self.custom_router_callback, self.router) - return FLUID_OK - - def delete(self): - if self.audio_driver: - delete_fluid_audio_driver(self.audio_driver) - delete_fluid_synth(self.synth) - delete_fluid_settings(self.settings) - def sfload(self, filename, update_midi_preset=0): - """Load SoundFont and return its ID""" - return fluid_synth_sfload(self.synth, filename.encode(), update_midi_preset) - def sfunload(self, sfid, update_midi_preset=0): - """Unload a SoundFont and free memory it used""" - return fluid_synth_sfunload(self.synth, sfid, update_midi_preset) - def program_select(self, chan, sfid, bank, preset): - """Select a program""" - return fluid_synth_program_select(self.synth, chan, sfid, bank, preset) - def program_unset(self, chan): - """Set the preset of a MIDI channel to an unassigned state""" - return fluid_synth_unset_program(self.synth, chan) - def channel_info(self, chan): - """get soundfont, bank, prog, preset name of channel""" - if fluid_synth_get_channel_info is not None: - info=fluid_synth_channel_info_t() - fluid_synth_get_channel_info(self.synth, chan, byref(info)) - return (info.sfont_id, info.bank, info.program, info.name) - else: - (sfontid, banknum, presetnum) = self.program_info(chan) - presetname = self.sfpreset_name(sfontid, banknum, presetnum) - return (sfontid, banknum, presetnum, presetname) - def program_info(self, chan): - """get active soundfont, bank, prog on a channel""" - if fluid_synth_get_program is not None: - sfontid=c_int() - banknum=c_int() - presetnum=c_int() - fluid_synth_get_program(self.synth, chan, byref(sfontid), byref(banknum), byref(presetnum)) - return (sfontid.value, banknum.value, presetnum.value) - else: - (sfontid, banknum, prognum, presetname) = self.channel_info(chan) - return (sfontid, banknum, prognum) - def sfpreset_name(self, sfid, bank, prenum): - """Return name of a soundfont preset""" - if fluid_synth_get_sfont_by_id is not None: - sfont=fluid_synth_get_sfont_by_id(self.synth, sfid) - preset=fluid_sfont_get_preset(sfont, bank, prenum) - if not preset: - return None - return fluid_preset_get_name(preset).decode('ascii') - else: - (sfontid, banknum, presetnum, presetname) = self.channel_info(chan) - return presetname - def router_clear(self): - if self.router is not None: - fluid_midi_router_clear_rules(self.router) - def router_default(self): - if self.router is not None: - fluid_midi_router_set_default_rules(self.router) - def router_begin(self, type): - """types are [note|cc|prog|pbend|cpress|kpress]""" - if self.router is not None: - if type=='note': - self.router.cmd_rule_type=0 - elif type=='cc': - self.router.cmd_rule_type=1 - elif type=='prog': - self.router.cmd_rule_type=2 - elif type=='pbend': - self.router.cmd_rule_type=3 - elif type=='cpress': - self.router.cmd_rule_type=4 - elif type=='kpress': - self.router.cmd_rule_type=5 - if 'self.router.cmd_rule' in globals(): - delete_fluid_midi_router_rule(self.router.cmd_rule) - self.router.cmd_rule = new_fluid_midi_router_rule() - def router_end(self): - if self.router is not None: - if self.router.cmd_rule is None: - return - if fluid_midi_router_add_rule(self.router, self.router.cmd_rule, self.router.cmd_rule_type)<0: - delete_fluid_midi_router_rule(self.router.cmd_rule) - self.router.cmd_rule=None - def router_chan(self, min, max, mul, add): - if self.router is not None: - fluid_midi_router_rule_set_chan(self.router.cmd_rule, min, max, mul, add) - def router_par1(self, min, max, mul, add): - if self.router is not None: - fluid_midi_router_rule_set_param1(self.router.cmd_rule, min, max, mul, add) - def router_par2(self, min, max, mul, add): - if self.router is not None: - fluid_midi_router_rule_set_param2(self.router.cmd_rule, min, max, mul, add) - def set_reverb(self, roomsize=-1.0, damping=-1.0, width=-1.0, level=-1.0): - """ - roomsize Reverb room size value (0.0-1.0) - damping Reverb damping value (0.0-1.0) - width Reverb width value (0.0-100.0) - level Reverb level value (0.0-1.0) - """ - if fluid_synth_set_reverb is not None: - return fluid_synth_set_reverb(self.synth, roomsize, damping, width, level) - else: - set=0 - if roomsize>=0: - set+=0b0001 - if damping>=0: - set+=0b0010 - if width>=0: - set+=0b0100 - if level>=0: - set+=0b1000 - return fluid_synth_set_reverb_full(self.synth, set, roomsize, damping, width, level) - def set_chorus(self, nr=-1, level=-1.0, speed=-1.0, depth=-1.0, type=-1): - """ - nr Chorus voice count (0-99, CPU time consumption proportional to this value) - level Chorus level (0.0-10.0) - speed Chorus speed in Hz (0.29-5.0) - depth_ms Chorus depth (max value depends on synth sample rate, 0.0-21.0 is safe for sample rate values up to 96KHz) - type Chorus waveform type (0=sine, 1=triangle) - """ - if fluid_synth_set_chorus is not None: - return fluid_synth_set_chorus(self.synth, nr, level, speed, depth, type) - else: - set=0 - if nr>=0: - set+=0b00001 - if level>=0: - set+=0b00010 - if speed>=0: - set+=0b00100 - if depth>=0: - set+=0b01000 - if type>=0: - set+=0b10000 - return fluid_synth_set_chorus_full(self.synth, set, nr, level, speed, depth, type) - def set_reverb_roomsize(self, roomsize): - if fluid_synth_set_reverb_roomsize is not None: - return fluid_synth_set_reverb_roomsize(self.synth, roomsize) - else: - return self.set_reverb(roomsize=roomsize) - def set_reverb_damp(self, damping): - if fluid_synth_set_reverb_damp is not None: - return fluid_synth_set_reverb_damp(self.synth, damping) - else: - return self.set_reverb(damping=damping) - def set_reverb_level(self, level): - if fluid_synth_set_reverb_level is not None: - return fluid_synth_set_reverb_level(self.synth, level) - else: - return self.set_reverb(level=level) - def set_reverb_width(self, width): - if fluid_synth_set_reverb_width is not None: - return fluid_synth_set_reverb_width(self.synth, width) - else: - return self.set_reverb(width=width) - def set_chorus_nr(self, nr): - if fluid_synth_set_chorus_nr is not None: - return fluid_synth_set_chorus_nr(self.synth, nr) - else: - return self.set_chorus(nr=nr) - def set_chorus_level(self, level): - if fluid_synth_set_chorus_level is not None: - return fluid_synth_set_chorus_level(self.synth, level) - else: - return self.set_chorus(leve=level) - def set_chorus_speed(self, speed): - if fluid_synth_set_chorus_speed is not None: - return fluid_synth_set_chorus_speed(self.synth, speed) - else: - return self.set_chorus(speed=speed) - def set_chorus_depth(self, depth): - if fluid_synth_set_chorus_depth is not None: - return fluid_synth_set_chorus_depth(self.synth, depth) - else: - return self.set_chorus(depth=depth) - def set_chorus_type(self, type): - if fluid_synth_set_chorus_type is not None: - return fluid_synth_set_chorus_type(self.synth, type) - else: - return self.set_chorus(type=type) - def get_reverb_roomsize(self): - return fluid_synth_get_reverb_roomsize(self.synth) - def get_reverb_damp(self): - return fluid_synth_get_reverb_damp(self.synth) - def get_reverb_level(self): - return fluid_synth_get_reverb_level(self.synth) - def get_reverb_width(self): - return fluid_synth_get_reverb_width(self.synth) - def get_chorus_nr(self): - return fluid_synth_get_chorus_nr(self.synth) - def get_chorus_level(self): - return fluid_synth_get_reverb_level(self.synth) - def get_chorus_speed(self): - if fluid_synth_get_chorus_speed is not None: - return fluid_synth_get_chorus_speed(self.synth) - else: - return fluid_synth_get_chorus_speed_Hz(self.synth) - def get_chorus_depth(self): - if fluid_synth_get_chorus_depth is not None: - return fluid_synth_get_chorus_depth(self.synth) - else: - return fluid_synth_get_chorus_depth_ms(self.synth) - def get_chorus_type(self): - return fluid_synth_get_chorus_type(self.synth) - def noteon(self, chan, key, vel): - """Play a note""" - if key < 0 or key > 127: - return False - if chan < 0: - return False - if vel < 0 or vel > 127: - return False - return fluid_synth_noteon(self.synth, chan, key, vel) - def noteoff(self, chan, key): - """Stop a note""" - if key < 0 or key > 127: - return False - if chan < 0: - return False - return fluid_synth_noteoff(self.synth, chan, key) - def pitch_bend(self, chan, val): - """Adjust pitch of a playing channel by small amounts - - A pitch bend value of 0 is no pitch change from default. - A value of -2048 is 1 semitone down. - A value of 2048 is 1 semitone up. - Maximum values are -8192 to +8192 (transposing by 4 semitones). - - """ - return fluid_synth_pitch_bend(self.synth, chan, val + 8192) - def cc(self, chan, ctrl, val): - """Send control change value - - The controls that are recognized are dependent on the - SoundFont. Values are always 0 to 127. Typical controls - include: - 1 : vibrato - 7 : volume - 10 : pan (left to right) - 11 : expression (soft to loud) - 64 : sustain - 91 : reverb - 93 : chorus - """ - return fluid_synth_cc(self.synth, chan, ctrl, val) - def get_cc(self, chan, num): - i=c_int() - fluid_synth_get_cc(self.synth, chan, num, byref(i)) - return i.value - def program_change(self, chan, prg): - """Change the program""" - return fluid_synth_program_change(self.synth, chan, prg) - def bank_select(self, chan, bank): - """Choose a bank""" - return fluid_synth_bank_select(self.synth, chan, bank) - def all_notes_off(self, chan): - """Turn off all notes on a channel (release all keys)""" - return fluid_synth_all_notes_off(self.synth, chan) - def all_sounds_off(self, chan): - """Turn off all sounds on a channel (equivalent to mute)""" - return fluid_synth_all_sounds_off(self.synth, chan) - def sfont_select(self, chan, sfid): - """Choose a SoundFont""" - return fluid_synth_sfont_select(self.synth, chan, sfid) - def program_reset(self): - """Reset the programs on all channels""" - return fluid_synth_program_reset(self.synth) - def system_reset(self): - """Stop all notes and reset all programs""" - return fluid_synth_system_reset(self.synth) - def get_samples(self, len=1024): - """Generate audio samples - - The return value will be a NumPy array containing the given - length of audio samples. If the synth is set to stereo output - (the default) the array will be size 2 * len. - - """ - return fluid_synth_write_s16_stereo(self.synth, len) - def tuning_dump(self, bank, prog, pitch): - return fluid_synth_tuning_dump(self.synth, bank, prog, name.encode(), length(name), pitch) - - def midi_event_get_type(self, event): - return fluid_midi_event_get_type(event) - def midi_event_get_velocity(self, event): - return fluid_midi_event_get_velocity(event) - def midi_event_get_key(self, event): - return fluid_midi_event_get_key(event) - def midi_event_get_channel(self, event): - return fluid_midi_event_get_channel(event) - def midi_event_get_control(self, event): - return fluid_midi_event_get_control(event) - def midi_event_get_program(self, event): - return fluid_midi_event_get_program(event) - def midi_event_get_value(self, event): - return fluid_midi_event_get_value(event) - - def play_midi_file(self, filename): - self.player = new_fluid_player(self.synth) - if self.player == None: return FLUID_FAILED - if self.custom_router_callback != None: - fluid_player_set_playback_callback(self.player, self.custom_router_callback, self.synth) - status = fluid_player_add(self.player, filename.encode()) - if status == FLUID_FAILED: return status - status = fluid_player_play(self.player) - return status - - def play_midi_stop(self): - status = fluid_player_stop(self.player) - if status == FLUID_FAILED: return status - status = fluid_player_seek(self.player, 0) - delete_fluid_player(self.player) - return status - - def player_set_tempo(self, tempo_type, tempo): - return fluid_player_set_tempo(self.player, tempo_type, tempo) - - - -class Sequencer: - def __init__(self, time_scale=1000, use_system_timer=True): - """Create new sequencer object to control and schedule timing of midi events - - Optional keyword arguments: - time_scale: ticks per second, defaults to 1000 - use_system_timer: whether the sequencer should advance by itself - """ - self.client_callbacks = [] - self.sequencer = new_fluid_sequencer2(use_system_timer) - fluid_sequencer_set_time_scale(self.sequencer, time_scale) - - def register_fluidsynth(self, synth): - response = fluid_sequencer_register_fluidsynth(self.sequencer, synth.synth) - if response == FLUID_FAILED: - raise Error("Registering fluid synth failed") - return response - - def register_client(self, name, callback, data=None): - c_callback = CFUNCTYPE(None, c_uint, c_void_p, c_void_p, c_void_p)(callback) - response = fluid_sequencer_register_client(self.sequencer, name.encode(), c_callback, data) - if response == FLUID_FAILED: - raise Error("Registering client failed") - - # store in a list to prevent garbage collection - self.client_callbacks.append(c_callback) - - return response - - def note(self, time, channel, key, velocity, duration, source=-1, dest=-1, absolute=True): - evt = self._create_event(source, dest) - fluid_event_note(evt, channel, key, velocity, duration) - self._schedule_event(evt, time, absolute) - delete_fluid_event(evt) - - def note_on(self, time, channel, key, velocity=127, source=-1, dest=-1, absolute=True): - evt = self._create_event(source, dest) - fluid_event_noteon(evt, channel, key, velocity) - self._schedule_event(evt, time, absolute) - delete_fluid_event(evt) - - def note_off(self, time, channel, key, source=-1, dest=-1, absolute=True): - evt = self._create_event(source, dest) - fluid_event_noteoff(evt, channel, key) - self._schedule_event(evt, time, absolute) - delete_fluid_event(evt) - - def timer(self, time, data=None, source=-1, dest=-1, absolute=True): - evt = self._create_event(source, dest) - fluid_event_timer(evt, data) - self._schedule_event(evt, time, absolute) - delete_fluid_event(evt) - - def _create_event(self, source=-1, dest=-1): - evt = new_fluid_event() - fluid_event_set_source(evt, source) - fluid_event_set_dest(evt, dest) - return evt - - def _schedule_event(self, evt, time, absolute=True): - response = fluid_sequencer_send_at(self.sequencer, evt, time, absolute) - if response == FLUID_FAILED: - raise Error("Scheduling event failed") - - def get_tick(self): - return fluid_sequencer_get_tick(self.sequencer) - - def process(self, msec): - fluid_sequencer_process(self.sequencer, msec) - - def delete(self): - delete_fluid_sequencer(self.sequencer) - -def raw_audio_string(data): - """Return a string of bytes to send to soundcard - - Input is a numpy array of samples. Default output format - is 16-bit signed (other formats not currently supported). - - """ - import numpy - return (data.astype(numpy.int16)).tostring() - -#=============================================================================== - -import numpy as np -import wave - -def midi_opus_to_colab_audio(midi_opus, - soundfont_path='/usr/share/sounds/sf2/FluidR3_GM.sf2', - sample_rate=16000, # 44100 - volume_scale=10, - trim_silence=True, - silence_threshold=0.1, - output_for_gradio=False, - write_audio_to_WAV='' - ): - - def normalize_volume(matrix, factor=10): - norm = np.linalg.norm(matrix) - matrix = matrix/norm # normalized matrix - mult_matrix = matrix * factor - final_matrix = np.clip(mult_matrix, -1.0, 1.0) - return final_matrix - - if midi_opus[1]: - - ticks_per_beat = midi_opus[0] - event_list = [] - for track_idx, track in enumerate(midi_opus[1:]): - abs_t = 0 - for event in track: - abs_t += event[1] - event_new = [*event] - event_new[1] = abs_t - event_list.append(event_new) - event_list = sorted(event_list, key=lambda e: e[1]) - - tempo = int((60 / 120) * 10 ** 6) # default 120 bpm - ss = np.empty((0, 2), dtype=np.int16) - fl = Synth(samplerate=float(sample_rate)) - sfid = fl.sfload(soundfont_path) - last_t = 0 - for c in range(16): - fl.program_select(c, sfid, 128 if c == 9 else 0, 0) - for event in event_list: - name = event[0] - sample_len = int(((event[1] / ticks_per_beat) * tempo / (10 ** 6)) * sample_rate) - sample_len -= int(((last_t / ticks_per_beat) * tempo / (10 ** 6)) * sample_rate) - last_t = event[1] - if sample_len > 0: - sample = fl.get_samples(sample_len).reshape(sample_len, 2) - ss = np.concatenate([ss, sample]) - if name == "set_tempo": - tempo = event[2] - elif name == "patch_change": - c, p = event[2:4] - fl.program_select(c, sfid, 128 if c == 9 else 0, p) - elif name == "control_change": - c, cc, v = event[2:5] - fl.cc(c, cc, v) - elif name == "note_on" and event[3] > 0: - c, p, v = event[2:5] - fl.noteon(c, p, v) - elif name == "note_off" or (name == "note_on" and event[3] == 0): - c, p = event[2:4] - fl.noteoff(c, p) - - fl.delete() - if ss.shape[0] > 0: - max_val = np.abs(ss).max() - if max_val != 0: - ss = (ss / max_val) * np.iinfo(np.int16).max - ss = ss.astype(np.int16) - - if trim_silence: - threshold = np.std(np.abs(ss)) * silence_threshold - exceeded_thresh = np.abs(ss) > threshold - if np.any(exceeded_thresh): - last_idx = np.where(exceeded_thresh)[0][-1] - ss = ss[:last_idx+1] - - if output_for_gradio: - return ss - - ss = ss.swapaxes(1, 0) - - raw_audio = normalize_volume(ss, volume_scale) - - if write_audio_to_WAV != '': - - r_audio = raw_audio.T - - r_audio = np.int16(r_audio / np.max(np.abs(r_audio)) * 32767) - - with wave.open(write_audio_to_WAV, 'w') as wf: - wf.setframerate(sample_rate) - wf.setsampwidth(2) - wf.setnchannels(r_audio.shape[1]) - wf.writeframes(r_audio) - - return raw_audio - - else: - return None - -def midi_to_colab_audio(midi_file, - soundfont_path='/usr/share/sounds/sf2/FluidR3_GM.sf2', - sample_rate=16000, # 44100 - volume_scale=10, - trim_silence=True, - silence_threshold=0.1, - output_for_gradio=False, - write_audio_to_WAV=False - ): - - ''' - - Returns raw audio to pass to IPython.disaply.Audio func - - Example usage: - - from IPython.display import Audio - - display(Audio(raw_audio, rate=16000, normalize=False)) - - ''' - - def normalize_volume(matrix, factor=10): - norm = np.linalg.norm(matrix) - matrix = matrix/norm # normalized matrix - mult_matrix = matrix * factor - final_matrix = np.clip(mult_matrix, -1.0, 1.0) - return final_matrix - - midi_opus = midi2opus(open(midi_file, 'rb').read()) - - if midi_opus[1]: - - ticks_per_beat = midi_opus[0] - event_list = [] - for track_idx, track in enumerate(midi_opus[1:]): - abs_t = 0 - for event in track: - abs_t += event[1] - event_new = [*event] - event_new[1] = abs_t - event_list.append(event_new) - event_list = sorted(event_list, key=lambda e: e[1]) - - tempo = int((60 / 120) * 10 ** 6) # default 120 bpm - ss = np.empty((0, 2), dtype=np.int16) - fl = Synth(samplerate=float(sample_rate)) - sfid = fl.sfload(soundfont_path) - last_t = 0 - for c in range(16): - fl.program_select(c, sfid, 128 if c == 9 else 0, 0) - for event in event_list: - name = event[0] - sample_len = int(((event[1] / ticks_per_beat) * tempo / (10 ** 6)) * sample_rate) - sample_len -= int(((last_t / ticks_per_beat) * tempo / (10 ** 6)) * sample_rate) - last_t = event[1] - if sample_len > 0: - sample = fl.get_samples(sample_len).reshape(sample_len, 2) - ss = np.concatenate([ss, sample]) - if name == "set_tempo": - tempo = event[2] - elif name == "patch_change": - c, p = event[2:4] - fl.program_select(c, sfid, 128 if c == 9 else 0, p) - elif name == "control_change": - c, cc, v = event[2:5] - fl.cc(c, cc, v) - elif name == "note_on" and event[3] > 0: - c, p, v = event[2:5] - fl.noteon(c, p, v) - elif name == "note_off" or (name == "note_on" and event[3] == 0): - c, p = event[2:4] - fl.noteoff(c, p) - - fl.delete() - if ss.shape[0] > 0: - max_val = np.abs(ss).max() - if max_val != 0: - ss = (ss / max_val) * np.iinfo(np.int16).max - ss = ss.astype(np.int16) - - if trim_silence: - threshold = np.std(np.abs(ss)) * silence_threshold - exceeded_thresh = np.abs(ss) > threshold - if np.any(exceeded_thresh): - last_idx = np.where(exceeded_thresh)[0][-1] - ss = ss[:last_idx+1] - - if output_for_gradio: - return ss - - ss = ss.swapaxes(1, 0) - - raw_audio = normalize_volume(ss, volume_scale) - - if write_audio_to_WAV: - - filename = midi_file.split('.')[-2] + '.wav' - - r_audio = raw_audio.T - - r_audio = np.int16(r_audio / np.max(np.abs(r_audio)) * 32767) - - with wave.open(filename, 'w') as wf: - wf.setframerate(sample_rate) - wf.setsampwidth(2) - wf.setnchannels(r_audio.shape[1]) - wf.writeframes(r_audio) - - return raw_audio - - else: - return None - -#=================================================================================================================== \ No newline at end of file