def __init__(self, output_device=None, latency=None):
"""
@type output_device: int
@param output_device: Portmidi device number to use for output. Will
use the reported default if not given.
@type latency: int
@param latency: latency value to use PortMidi output with. 0 is
not permitted, as it prevents us doing timestamped events.
"""
if output_device is None:
output_device = pgmidi.get_default_output_id()
self.output_device = output_device
latency = 100
# Check the output device exists
devs = Sequencer.get_devices()
if output_device >= len(devs):
raise SequencerInitializationError, "sequencer tried to use "\
"non-existent output device: %d. Only %d devices exist." % \
(output_device, len(devs))
# Check it can accept output
if devs[output_device][1][3] == 0:
raise SequencerInitializationError, "cannot use %s as an "\
"output device: it doesn't accept output." % \
devs[output_device][1][1]
# Initialize the output device
self.output = pgmidi.Output(output_device,
latency=latency,
buffer_size=1024 * 50)
self._sequencer = None
self._queue = {}
def __init__(self, output_device=None, latency=None):
"""
@type output_device: int
@param output_device: Portmidi device number to use for output. Will
use the reported default if not given.
@type latency: int
@param latency: latency value to use PortMidi output with. 0 is
not permitted, as it prevents us doing timestamped events.
"""
if output_device is None:
output_device = pgmidi.get_default_output_id()
self.output_device = output_device
latency = 100
# Check the output device exists
devs = Sequencer.get_devices()
if output_device >= len(devs):
raise SequencerInitializationError, "sequencer tried to use "\
"non-existent output device: %d. Only %d devices exist." % \
(output_device, len(devs))
# Check it can accept output
if devs[output_device][1][3] == 0:
raise SequencerInitializationError, "cannot use %s as an "\
"output device: it doesn't accept output." % \
devs[output_device][1][1]
# Initialize the output device
self.output = pgmidi.Output(output_device, latency=latency, buffer_size=1024*50)
self._sequencer = None
self._queue = {}
def main():
"""Initiates program and loop."""
pygame.init()
midi.init()
print "Number of MIDI devices:", midi.get_count()
if midi.get_count() == 0:
print "No MIDI devices detected :P"
return
out_device = midi.get_default_output_id()
if out_device == -1:
print "No MIDI output device detected :P"
return
print "Uses device no:", out_device
try:
output = midi.Output( out_device )
output.set_instrument( instrument )
keyboard = init_keyboard(53)
screen = pygame.display.set_mode([250,80])
screen.fill((0,0,0))
pygame.display.set_caption("MIDI Keyboard")
pygame.display.flip()
io_loop(keyboard, output, instrument)
finally:
del output
midi.quit()
def midi_info():
"""
midi is an instance of pygame.midi
Returns a dictionary containing info
about the systems MIDI devices.
The dictionary contains:
'count' - number of devices.
'def_in' - default input.
'def_out' - default output.
'devices' - a list of device info.
"""
info = {}
#Store info.
info.keys().append('count')
info['count'] = midi.get_count()
info.keys().append('def_in')
info['def_in'] = midi.get_default_input_id()
info.keys().append('def_out')
info['def_out'] = midi.get_default_output_id()
devices = []
for i in range(0, midi.get_count()):
devices.append(midi.get_device_info(i))
info.keys().append('devices')
info['devices'] = devices
return info
def __enter__(self) -> 'MidiOutput':
if not m.get_init():
m.init()
port = m.get_default_output_id()
self._output = m.Output(port)
return self
def __init__(self,
signal,
sampling_rate,
recording_time,
with_instrument=0):
"""
Synthesizer class
Transforms the whistle audio signal into MIDI format, and plays back in chosen instrument
:param signal: whistle audio signal
:param sampling_rate: the sampling rate of the recording in Hz
:param recording_time: recording duration
:param with_instrument: number of the musical instrument (between 0 and 127)
"""
Thread.__init__(self)
print()
print("------------------------")
print("Initializing Synth class!")
self.signal = np.squeeze(signal)
self.fs = sampling_rate
self.dur = recording_time
self.instrument_num = with_instrument
# threshold filter
self.th_filt = None
self.__calc_th_filt()
# pitch tracking
self.pitches = None
self.__pitch_tracking()
# filtered MIDI
self.filtered_midi = None
self.small_th = None
self.__filter_and_round()
# MIDI data for MIDI player
self.midi_input = None
self.__create_midi_data()
# For playing midi synth
pygame.init()
midi.init()
self.device = midi.get_default_output_id()
print("Default MIDI device found: " +
str(midi.get_default_output_id()))
def init_output_device():
out = midi.Output(midi.get_default_output_id())
# set all channels to guitar
for c in xrange(15):
out.set_instrument(24, c + 1)
return out
def init_output_device():
out = midi.Output(midi.get_default_output_id())
# set all channels to guitar
for c in xrange(15):
out.set_instrument(24, c + 1)
return out
def get_midi_output_id():
for id in range(midi.get_count()):
interface, name, input, output, open = midi.get_device_info(id)
if not output:
continue
name = name.decode('utf-8').lower()
if name.find('synth') != -1:
return id
return midi.get_default_output_id()
def _get_default_device(get_input):
if get_input:
device_id = midi.get_default_input_id()
else:
device_id = midi.get_default_output_id()
if device_id < 0:
raise IOError('no default port found')
return _get_device(device_id)
def _get_default_device(get_input):
if get_input:
device_id = midi.get_default_input_id()
else:
device_id = midi.get_default_output_id()
if device_id < 0:
raise IOError('no default port found')
return _get_device(device_id)
def get_target_device(first = True):
if (first):
print("If you want to use the default, just press 'Enter'.")
try:
device_id_string = input("Please select your output device: ")
if (device_id_string == ""): # Returning system default output id if user pressed enter
return midi.get_default_output_id()
return int(device_id_string)
except ValueError:
print("This input must be an integer.")
return get_target_device(False) # Recursively giving the user another chance
def __init__(self, channel=1, device_id=None):
super().__init__()
self.output = None
if not midi.get_init():
midi.init()
if device_id is None:
device_id = midi.get_default_output_id()
mididevs = {}
dfldev = None
for did in range(midi.get_count()):
dev = midi.get_device_info(did)
if dev[3] == 1:
devname = dev[1].decode()
mididevs[devname] = did
if did == device_id:
dfldev = devname
def config_devbox(combo):
def _set_dev_cb(c):
self.set_device(self.device)
combo.connect("changed", _set_dev_cb)
self.set_device(self.device)
self.setup_configurable(
"MIDI Output",
"midi",
confmap={
# "mode": ListConfiguration("Output Mode", "mode", default_val, items),
"channel":
NumericConfiguration(
"MIDI Channel",
"channel",
Gtk.SpinButton,
channel,
1,
16,
step_incr=1,
page_incr=1,
),
"device":
ListConfiguration(
"MIDI Device",
"device",
dfldev,
mididevs,
gui_setup_cb=config_devbox,
),
},
)
def set_midi_port(self, idx):
if idx < len(self.all_ports) and idx >= 0:
devid = self.all_ports[idx][0]
self.all_ports[idx][2] = True
else:
devid = pmd.get_default_output_id()
for pt in self.all_ports:
if devid == pt[0]:
pt[2] = True
try:
self.midi_port = pmd.Output(devid)
except:
devid = -1
return devid
def main():
pygame.init()
midi.init()
default_input_device = midi.get_default_input_id()
default_output_device = midi.get_default_output_id()
if default_input_device < 0:
print "No MIDI input device found"
return
melodies = []
keyboard = ChordBuilderKeyBoard(default_input_device, melodies, output_device_id=default_output_device)
print "Initialized"
keyboard.start()
def mainloop(self,
inputdeviceid=None,
outputdeviceid=None,
ignoreerror=False,
highervelocity=False):
midi.init()
try:
inputdeviceid = inputdeviceid if inputdeviceid is not None else midi.get_default_input_id(
)
print("MIDI Input:", midi.get_device_info(inputdeviceid))
self._midi_in = midi.Input(inputdeviceid)
except midi.MidiException as e:
if ignoreerror:
self._midi_in = None
print("No MIDI In!", e)
else:
raise e
try:
outputdeviceid = outputdeviceid if outputdeviceid is not None else midi.get_default_output_id(
)
print("MIDI Output:", midi.get_device_info(outputdeviceid))
self._midi_out = midi.Output(outputdeviceid)
self._midi_out.set_instrument(0)
except (midi.MidiException, Exception) as e:
if ignoreerror:
print("No MIDI Out!", e)
self._midi_out = None
else:
raise e
if self._midi_in:
while True:
if self._midi_in.poll():
events = self._midi_in.read(10)
for event in events:
self._parse_midi_event(event,
highervelocity=highervelocity)
try:
self._root.update()
except:
midi.quit()
break
else:
self._root.mainloop()
def main():
pygame.init()
midi.init()
default_input_device = midi.get_default_input_id()
default_output_device = midi.get_default_output_id()
if default_input_device < 0:
print "No MIDI input device found"
return
melodies = []
# Gary Jules - Mad World
melody = [
Note.Gsharp, Note.C, Note.G, Note.Gsharp, Note.F, Note.G, Note.Dsharp,
Note.D, Note.Gsharp, Note.C, Note.G, Note.Gsharp, Note.F, Note.G,
Note.Gsharp, Note.Asharp
]
melodies.append(PrintMelody(melody, name="Mad World"))
# Happy birthday
melody = [Note.D, Note.D, Note.E, Note.D, Note.G, Note.F]
melodies.append(TerminalMelody(melody, name="Happy Birthday"))
# Chord example
melody = [
{Note.C, Note.E, Note.G}, # C Major Chord
Note.D,
{Note.F, Note.Aflat, Note.C}, # F Minor Chord
Note.D
]
melodies.append(PrintMelody(melody, name="Chord Example"))
keyboard = KeyBoard(default_input_device,
melodies,
output_device_id=default_output_device)
print "Initialized"
keyboard.start()
def main():
pygame.init()
midi.init()
default_input_device = midi.get_default_input_id()
default_output_device = midi.get_default_output_id()
if default_input_device < 0:
print "No MIDI input device found"
return
melodies = []
# Gary Jules - Mad World
melody = [Note.Gsharp, Note.C, Note.G, Note.Gsharp, Note.F, Note.G, Note.Dsharp, Note.D, Note.Gsharp, Note.C, Note.G, Note.Gsharp, Note.F, Note.G, Note.Gsharp, Note.Asharp]
melodies.append(
PrintMelody(melody, name="Mad World")
)
# Happy birthday
melody = [Note.D, Note.D, Note.E, Note.D, Note.G, Note.F]
melodies.append(
TerminalMelody(melody, name="Happy Birthday")
)
# Chord example
melody = [
{Note.C, Note.E, Note.G}, # C Major Chord
Note.D,
{Note.F, Note.Aflat, Note.C}, # F Minor Chord
Note.D
]
melodies.append(
PrintMelody(melody, name="Chord Example")
)
keyboard = KeyBoard(default_input_device, melodies, output_device_id=default_output_device)
print "Initialized"
keyboard.start()
def playSong(self, e):
""""""
midi.init()
O = Output(midi.get_default_output_id())
onNotes = []
notes = []
for y in range(len(self.myChords)):
self.myChords[y] = [x + 36 for x in self.myChords[y]]
for i in range(len(self.myNotes)):
notes.append(self.myChords[i] + [(self.myNotes[i])])
rhythms = self.myRhythm
for i in range(len(self.myNotes)):
for k in notes[i]:
if k not in onNotes:
O.note_on(k, 127)
onNotes.append(k)
time.sleep(rhythms[2 * i + 1] - rhythms[2 * i])
for k in notes[i]:
if k in onNotes:
onNotes.remove(k)
O.note_off(k)
self.pop = wx.POPUP_WINDOW(self, name="Test")
del O
midi.quit()
def main_loop():
''' A convenience function to keep the program alive. '''
import time
while True:
time.sleep(1)
if __name__ == '__main__':
# Find a suitable midi output. On Linux the default will probably
# be an alsa "Midi Through" port, which is convenient for testing
# (because clients won't be disconnected when you restart the patch)
midi.init()
midi_out = midi.Output(midi.get_default_output_id())
# Initializes foococo
init(model=1) # Use model=2 for a SoftStep 2
# Scroll some text
Scroller.setText('WELCOME TO FOOCOCO')
# The main patch
# Building a list is just a way to keep the objects referenced
# so that they don't get garbage-collected.
patch = [
# Single action on single press:
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
'''
from pygame import midi
import pickle
import rlcompleter
import readline
readline.parse_and_bind("tab: complete")
#it would be nice if these were constants
midi.init()
midi_out = midi.Output(midi.get_default_output_id())
hi = [0xf0, 0x7e, 0x7f, 0x07, 0x06, 0x01, 0xf7]
default = [
0xf0,
0x00,
0x01, #3
0x5f,
0x7a,
0x1a,
0x00,
0x01,
0x00,
0x02,
0x22,
0x20,
0x2e,
###################################################################################
## ##
## Markovian Chant employs Markov chains and Pygame.midi in order to ##
## procedurally generate pseudo-Gregorian chant in the 6th Mode. The 6th ##
## Gregorian mode contains some of the most recognisable melodies from the ##
## Gregorian repertoire, such as the "Requiem aeternam" Intoit, the Agnus Dei ##
## from the "Missa de angelis" and the "Regina caeli" Antiphon. ##
## ##
###################################################################################
midi.init()
if os.name == 'posix':
player = midi.Output(2) #two works in Linux, but not 0 which was the default output
else:
player = midi.Output(midi.get_default_output_id()) #device_id, latency, buffer_size
player.set_instrument(48, 1) #instrument_id=value between 0 and 127, channel
starting_order = 4
#encode the notes (note name : value)
NOTES = { \
'a': 58, \
'b': 60, \
'c': 61, \
'd': 63, \
'e': 65, \
'f': 66, \
'g': 68, \
'h': 70, \
def __init__(self):
pygame.init()
midi.init()
self.device = midi.get_default_output_id()
print("Default MIDI device found: " +
str(midi.get_default_output_id()))
# Start TShark
cmd = [tshark, "-i", interface, "-l", "-Q", "-T", "fields"]
for fieldName in fieldList:
cmd += ["-e", fieldName]
if targs:
cmd += targs
if verbose:
print("Starting TShark with '{}'".format(" ".join(cmd)))
try:
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, text=True)
except FileNotFoundError:
sys.exit("Unable to locate TShark executable at {}".format(tshark))
# Set up midi
midi.init()
port = midi.get_default_output_id()
if verbose:
print("Outputting to {}".format(midi.get_device_info(port)))
midiOut = midi.Output(port)
if drum:
beatTimer = repeatTimer(beat[0], drumbeat)
beatTimer.start()
activeNotes = [] # threads currently playing
queuedNotes = [] # notes to play
for line in p.stdout:
if stopping:
continue
# TShark output is tab delimited
# These imports are necessary for PyLance to autocomplete for some reason
#isort:split
import pygame.display
import pygame.draw
import pygame.event
import pygame.key
import pygame.time
#isort:split
from pygame import *
from pygame.locals import *
pygame.init()
from typing import Optional
from pygame import midi
MIDI_DEVICE: Optional[midi.Output]
MIDI_ENABLED: bool
try:
midi.init()
MIDI_DEVICE = midi.Output(midi.get_default_output_id())
MIDI_ENABLED = True
except (pygame.error, midi.MidiException) as e:
import sys
print('Unable to load midi:', e, file=sys.stderr)
MIDI_DEVICE = None
MIDI_ENABLED = False
all__ = []
from pygame import midi
import time
midi.init()
print midi.get_count()
print midi.get_default_output_id()
output = midi.Output(midi.get_default_output_id()+1)
output.set_instrument(1)
output.note_on(64)
time.sleep(3)
output.note_off(64)
x = raw_input("::")
midi.quit()
# This script is written by Wells Lucas Santo, for the final project component of #
# EE4163 at the NYU Tandon School of Engineering. Please give credit if you wish #
# to reproduce this code. #
# #
# Be sure to read README.md for more information on these scripts. #
# #
###################################################################################
# Import the PyGame package, with the MIDI functionality specifically
from pygame import midi
# To use MIDI functionality, we need to first initialize MIDI
midi.init()
# This prints the default device ids that we are outputting to / taking input from
print "Output ID", midi.get_default_output_id()
print "Input ID", midi.get_default_input_id()
# List the MIDI devices that can be used
for i in range(0, midi.get_count()):
print i, midi.get_device_info(i)
# Here, you must check what the device # for your MIDI controller is
# You will not be guaranteed that the MIDI controller you want to use is the default
# Start the input stream
input = midi.Input(midi.get_default_input_id())
# Here's an example of setting the input device to something other than the default
# input = midi.Input(3)
