def restoreSettings(self, mainWindowHandler):
mainWindowHandler.midiInputChannel = self.settings.value('midiInputChannel').toInt()[0]
if not mainWindowHandler.midiInputChannel:
self.midiInputChannel = 1
self.midiOutputChannel = self.settings.value('midiOutputChannel').toInt()[0]
if not mainWindowHandler.midiOutputChannel:
mainWindowHandler.midiOutputChannel = 1
registryInputDeviceList = []
for inputDeviceHash in self.settings.value('midiInputDevices', []).toList():
inputDeviceHash = str(inputDeviceHash.toString())
for deviceWidget, index in self.midiInputDevicesDict.iteritems():
deviceName = midi.get_device_info(index)[1]
deviceHash = hashlib.md5(deviceName).hexdigest()
if deviceHash == inputDeviceHash:
deviceWidget.setChecked(True)
self.windowHandler.midiInputSelect(self, deviceWidget)
registryInputDeviceList.append(deviceHash)
self.settings.setValue('midiInputDevices', registryInputDeviceList)
#update the registry so unplugged devices aren't
#reselected when plugged back in at some later time
outputDeviceHash = str(self.settings.value('midiOutputDevice').toString())
registryOutputDevice = None
for deviceWidget, index in self.midiOutputDevicesDict.iteritems():
deviceName = midi.get_device_info(index)[1]
deviceHash = hashlib.md5(deviceName).hexdigest()
if deviceHash == outputDeviceHash:
deviceWidget.setChecked(True)
self.windowHandler.midiOutputSelect(self, deviceWidget)
registryOutputDevice = deviceHash
self.settings.setValue('midiOutputDevice', registryOutputDevice)
def __init__(self):
if sequencer.running:
sequencer.stop()
BUTTON_S = BUTTON_W, BUTTON_H = (310, 27)
SPACE = 5
ypos = SPACE
midi_in = 'Midi In: None'
if midi.m_in:
name = pm.get_device_info(midi.m_in.device_id)[1]
midi_in = 'Midi In: {}'.format(name)
self.midi_in_button = ActionButton((SPACE, ypos),
BUTTON_S,
midi_in,
True, True)
self.channel_counter = Counter((SPACE * 2 + BUTTON_W, ypos),
BUTTON_H,
'Channel', 1, 16, start=midi.in_channel)
ypos += SPACE + BUTTON_H
midi_out = 'Midi Out: None'
if midi.out:
name = pm.get_device_info(midi.out.device_id)[1]
midi_out = 'Midi Out: {}'.format(name)
self.midi_out_button = ActionButton((SPACE, ypos),
BUTTON_S,
midi_out,
True, True)
ypos += SPACE + BUTTON_H
self.bpm_counter = Counter((SPACE, ypos),
BUTTON_H,
'BPM', 20, 320,
start=sequencer.project['bpm'])
def get_device(self, dev_name): for i in xrange(0, midi.get_count()): name = midi.get_device_info(i)[1] print midi.get_device_info(i) if name == dev_name: if midi.get_device_info(i)[3]: #Checking if output device return midi.Output(i)
def get_midi(self):
buffer1 = []
buffer2 = []
cm = bpy.context.scene.cm_pg
if self.is_pygame_init and self.midi_input is not None:
# messages are formatted this way: [[message type, note / parameter ID, velocity
# / parameter value, ?], TimeStamp]
buffer1 = pgm.Input.read(self.midi_input, self.num_packets)
if len(buffer1) > 0:
cm.midi_buffer["buffer1"] = [b[0] for b in buffer1]
if cm.midi_debug:
print('Dev 1: ' + str(pgm.get_device_info(0)))
print(str(cm.midi_buffer["buffer1"]))
if self.midi_input2 is not None:
buffer2 = pgm.Input.read(self.midi_input2, self.num_packets)
if len(buffer2) > 0:
cm.midi_buffer["buffer2"] = [b[0] for b in buffer2]
if cm.midi_debug:
print('Dev 2: ' + str(pgm.get_device_info(1)))
print(str(cm.midi_buffer["buffer2"]))
return [cm.midi_buffer["buffer1"], cm.midi_buffer["buffer2"]]
else:
return None
def get_device(self, dev_name):
for i in xrange(0, midi.get_count()):
name = midi.get_device_info(i)[1]
print midi.get_device_info(i)
if name == dev_name:
if midi.get_device_info(i)[3]: #Checking if output device
return midi.Output(i)
def __getDeviceId(self, midiport):
n_device = pm.get_count()
foundId = -1
for id in range(n_device):
if int(pm.get_device_info(id)[1] == midiport) & \
int(pm.get_device_info(id)[3] == 1):
foundId = id
return foundId
def __getDeviceId(self, midiport):
n_device = pm.get_count()
foundId = -1
for id in range(n_device):
if int(pm.get_device_info(id)[1] == midiport.encode()) & \
int(pm.get_device_info(id)[3] == 1):
foundId = id
return foundId
def display_devices():
'''
Displays all available MIDI devices seen by mido
'''
midi = pygame.midi
midi.init()
print 'List of available MIDI devices:'
print '(interf, name, input, output, opened)'
for dev in xrange(0, midi.get_count()):
print midi.get_device_info(dev)
quit()
def construct_input(type='MK-449C USB MIDI Keyboard'): pm.init() n_device = pm.get_count() in_id = -1 for id in range(n_device): if int(pm.get_device_info(id)[1]==type) & int(pm.get_device_info(id)[2]==1): in_id = id print "input: "+type # if in_id == -1: # print "desired input: "+type+ " not available" eingang = pm.Input(in_id) return eingang
def close(self):
sequencer.project['bpm'] = self.bpm_counter.value
midi.in_channel = self.channel_counter.value
in_name = None
out_name = None
if midi.m_in:
in_name = pm.get_device_info(midi.m_in.device_id)[1]
if midi.out:
out_name = pm.get_device_info(midi.out.device_id)[1]
config_dict = {'midi_out': out_name,
'midi_in': in_name,
'midi_in_channel': midi.in_channel}
stream = file('config.yml', 'w')
yaml.dump(config_dict, stream)
def get_input_devices(self):
"""
Queries midi interface for available devices.
Checks that they are input devices (third element in return tuple corresponds to input flag, 1 if input else 0).
Returns a dict of the form {device_name: device_id}, device_id = -1 corresponds to no device.
"""
input_devices = {}
for i in range(midi.get_count()):
if midi.get_device_info(i)[2] == 1:
input_devices[midi.get_device_info(i)[1].decode('utf-8')] = i
input_devices['None'] = -1
return input_devices
def construct_output(type='SimpleSynth virtual input',instrument=1): # this constructs an output pygame.init() pm.init() pm.init() n_device = pm.get_count() out_id = -1 for id in range(n_device): if int(pm.get_device_info(id)[1]==type) & int(pm.get_device_info(id)[3]==1): out_id = id ausgang = pm.Output(out_id,0) ausgang.set_instrument(instrument) print "output: "+type return ausgang print "output: "+type+" not available"
def parse_args():
if '-l' in sys.argv or '-d' in sys.argv or '-t' in sys.argv:
testMode = False
if '-t' in sys.argv: testMode = True
if '-l' in sys.argv:
list_devices()
if '-d' in sys.argv:
i = sys.argv.index('-d')
if len(sys.argv)>i+1:
# get devices list
devices_t = sys.argv[i+1].split(',')
devices = []
for i in range(0,len(devices_t)):
device = int(devices_t[i])
# if device exists add it to list
if device_exists(device):
devices.append(device)
print("Using midi device: %s" % (midi.get_device_info(device)[1]))
else:
print("Seems like the device #%d does not exist. Is it plugged in?" % device)
return
if testMode:
print("Running in test mode. No server was opened and your midi signals will be printed.")
test_mode(devices)
else: start(devices)
else:
print("Please specify the number of midi-in device(s)")
return
else:
print("Command line arguments:\n-l Print out a list of midi-devices\n-d [device numbers] Comma seperated list of device numbers to use. E.g. '2,3' (no spaces!)\-t Run in test mode")
def close(self):
sequencer.project['bpm'] = self.bpm_counter.value
midi.in_channel = self.channel_counter.value
in_name = None
out_name = None
if midi.m_in:
in_name = pm.get_device_info(midi.m_in.device_id)[1]
if midi.out:
out_name = pm.get_device_info(midi.out.device_id)[1]
config_dict = {
'midi_out': out_name,
'midi_in': in_name,
'midi_in_channel': midi.in_channel
}
stream = file('config.yml', 'w')
yaml.dump(config_dict, stream)
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 getInputDevices():
for i in xrange(midi.get_count()):
info = midi.get_device_info(i)
(unusedInterface, name, isInput,
unusedIsOutput, unusedOpened) = info
if isInput:
yield i, name
def midiInputSelect(self, mainWindowInstance, device):
deviceIndex = mainWindowInstance.midiInputDevicesDict[device]
if not device.isChecked():
try:
self.midiSelectedInputDevicesDict.pop(deviceIndex).close()
device.setChecked(False)
except midi.MidiException as e:
QtGui.QMessageBox.warning(mainWindowInstance, "MIDI Error", unicode(e))
except:
QtGui.QMessageBox.warning(mainWindowInstance, "MIDI Error", "Device error.")
mainWindowInstance.midiInputDevicesDict.pop(device)
mainWindowInstance.ui.midiInputDevicesMenu.removeAction(device)
else:
try:
self.midiSelectedInputDevicesDict[deviceIndex] = midi.Input(deviceIndex)
except midi.MidiException as e:
QtGui.QMessageBox.warning(mainWindowInstance, "MIDI Error", unicode(e))
except:
QtGui.QMessageBox.warning(mainWindowInstance, "MIDI Error", "Device error.")
mainWindowInstance.midiInputDevicesDict.pop(device)
mainWindowInstance.ui.midiInputDevicesMenu.removeAction(device)
deviceNameList = []
for deviceIndex in self.midiSelectedInputDevicesDict.keys():
deviceNameList.append(hashlib.md5(midi.get_device_info(deviceIndex)[1]).hexdigest())
mainWindowInstance.settings.setValue('midiInputDevices', deviceNameList)
def get_device(device_id):
midi.init()
keys = ['interface', 'name', 'is_input', 'is_output', 'opened']
info = dict(zip(keys, midi.get_device_info(device_id)))
info['device_id'] = device_id
return info
def get_device(device_id):
midi.init()
keys = ['interface', 'name', 'is_input', 'is_output', 'opened']
info = dict(zip(keys, midi.get_device_info(device_id)))
info['device_id'] = device_id
return info
def getMIDIDevices(self):
midiOutputDevices = []
midiInputDevices = []
for index in xrange(0, midi.get_count()):
device = midi.get_device_info(index)
deviceName = device[1]
if device[3] == 1 and device[4] == 0: #if the device is an output and not opened
setattr(self, deviceName, QtGui.QAction(QtGui.QIcon(''), deviceName, self))
deviceWidget = getattr(self, deviceName)
deviceWidget.setCheckable(True)
midiOutputDevices.append(deviceWidget)
self.midiOutputDevicesDict[deviceWidget] = index
elif device[2] == 1 and device[4] == 0: #if devices is an input and not opened
deviceName = device[1]
setattr(self, deviceName, QtGui.QAction(QtGui.QIcon(''), deviceName, self))
deviceWidget = getattr(self, deviceName)
deviceWidget.setCheckable(True)
midiInputDevices.append(deviceWidget)
self.midiInputDevicesDict[deviceWidget] = index
if midiOutputDevices:
self.ui.midiOutputDevicesMenu = self.ui.menubar.addMenu("&Midi Output Device")
self.ui.midiOutputDevicesMenu.addActions(midiOutputDevices)
if midiInputDevices:
self.ui.midiInputDevicesMenu = self.ui.menubar.addMenu("&Midi Input Devices")
self.ui.midiInputDevicesMenu.addActions(midiInputDevices)
for device in midiOutputDevices:
outputFunction = partial(self.windowHandler.midiOutputSelect, mainWindowInstance=self, device=device)
device.triggered.connect(outputFunction)
for device in midiInputDevices:
inputFunction = partial(self.windowHandler.midiInputSelect, mainWindowInstance=self, device=device)
device.triggered.connect(inputFunction)
def input_device_ids():
device_ids = []
for device_id in range(midi.get_count()):
info = midi.get_device_info(device_id)
if info[IN] == 1:
device_ids.append(device_id)
return device_ids
def run(self):
pygame.midi.init()
self.device_id = midi.get_default_input_id()
if self.device_id == NO_DEVICE_FOUND:
raise NoPianoDetectedException('Device not detected.')
self.midiObject = midi.Input(self.device_id)
pygame.init()
self._resize_surface((WIDTH, HEIGHT))
clock = pygame.time.Clock()
if DEBUG_TRACE:
interface, name, is_input, is_output, is_open = midi.get_device_info(self.device_id)
print('Device Interface: ', interface)
print('Device Name: ', name)
print('Device IsInput: ', is_input == 1)
print('Device IsOutput: ', is_output == 1)
print('Device Open: ', is_open == 1)
self._game = GameModes.PressNext((WIDTH, HEIGHT))
while(True):
clock.tick(MAX_FRAMES_PER_SECOND)
self._event_handler()
self.midiObject.close()
midi.quit()
def __init__(self, debug=False):
print('Using Pygame MIDI interface')
self.debug = debug
midi.init()
self.midi_input = None
for device_id in range(midi.get_count()):
interf, name, is_input, is_output, opened = midi.get_device_info(
device_id)
interf = interf.decode('utf-8')
name = name.decode('utf-8')
imode = 'input' if is_input else 'output' if is_output else 'none'
iopen = '(open)' if opened else ''
if self.debug:
print(f'{interf} / {name} ({imode}) {iopen}')
if name in known_devices and is_input:
self.midi_input = midi.Input(device_id)
self.midi_input.name = f'{name} ({imode})'
print(f'Using midi input device {name}')
break
self.binds = {}
self.running = True
self.done = False
def midiOutputSelect(self, mainWindowInstance, device):
deviceIndex = mainWindowInstance.midiOutputDevicesDict[device]
for outputDevice in mainWindowInstance.midiOutputDevicesDict.keys():
if outputDevice != device:
outputDevice.setChecked(False)
else:
if outputDevice.isChecked():
try:
self.midiSelectedOutputDevice = midi.Output(deviceIndex)
if not self.midiSelectedOutputDevice:
raise Exception
mainWindowInstance.settings.setValue(
"midiOutputDevice", hashlib.md5(midi.get_device_info(deviceIndex)[1]).hexdigest()
)
except midi.MidiException as e:
QtGui.QMessageBox.warning(mainWindowInstance, "MIDI Error", unicode(e))
except:
QtGui.QMessageBox.warning(mainWindowInstance, "MIDI Error", "Device error.")
mainWindowInstance.midiOutputDevicesDict.pop(device)
mainWindowInstance.ui.midiOutputDevicesMenu.removeAction(device)
else:
try:
self.midiSelectedOutputDevice.close()
except midi.MidiException as e:
QtGui.QMessageBox.warning(mainWindowInstance, "MIDI Error", unicode(e))
except:
QtGui.QMessageBox.warning(mainWindowInstance, "MIDI Error", "Device error.")
mainWindowInstance.midiOutputDevicesDict.pop(device)
mainWindowInstance.ui.midiOutputDevicesMenu.removeAction(device)
self.midiSelectedOutputDevice = None
mainWindowInstance.settings.setValue("midiOutputDevice", "")
def midiInputSelect(self, mainWindowInstance, device):
deviceIndex = mainWindowInstance.midiInputDevicesDict[device]
if not device.isChecked():
try:
# in nachfolgender Anweisung tritt ein Problem auf
# PortMidi attempts to close open streams when the application exits -- this is particularly difficult under Windows.
# Exception Exception: "PortMidi: `Bad pointer'" in <pypm.Input object at 0x00BAFA58> ignored
self.midiSelectedInputDevicesDict.pop(deviceIndex).close()
device.setChecked(False)
except midi.MidiException as e:
QtGui.QMessageBox.warning(mainWindowInstance, "MIDI Error", unicode(e))
except:
QtGui.QMessageBox.warning(mainWindowInstance, "MIDI Error", "Device error.")
mainWindowInstance.midiInputDevicesDict.pop(device)
mainWindowInstance.ui.midiInputDevicesMenu.removeAction(device)
else:
try:
self.midiSelectedInputDevicesDict[deviceIndex] = midi.Input(deviceIndex)
except midi.MidiException as e:
QtGui.QMessageBox.warning(mainWindowInstance, "MIDI Error", unicode(e))
except:
QtGui.QMessageBox.warning(mainWindowInstance, "MIDI Error", "Device error.")
mainWindowInstance.midiInputDevicesDict.pop(device)
mainWindowInstance.ui.midiInputDevicesMenu.removeAction(device)
deviceNameList = []
for deviceIndex in self.midiSelectedInputDevicesDict.keys():
deviceNameList.append(hashlib.md5(midi.get_device_info(deviceIndex)[1]).hexdigest())
mainWindowInstance.settings.setValue("midiInputDevices", deviceNameList)
def _get_device(device_id):
keys = ['interface', 'name', 'is_input', 'is_output', 'opened']
info = dict(zip(keys, midi.get_device_info(device_id)))
# TODO: correct encoding?
info['name'] = info['name'].decode('utf-8')
info['id'] = device_id
return info
def __init__(self, program=3, bank=0, buffer_size=50):
"""
Class constructor
Note that buffer_siez has been set to 50 and is a recommended value for LPD8
It allows turning control knobs full speed without choking the reader
:param program: numeric value from 0 to 3 corresponding to choice triggered by PROGRAM key on LPD8
:param bank: numeric value from 0 to 7 corresponding to choice triggered by PROG/CHNG key on LPD8
:param buffer_size: MIDI buffer size for read operations
"""
# Store class properties
self._program = program
self._bank = bank
self._buffer_size = buffer_size
# Searching for LPD8 in available MIDI devices
print('starting midi...')
midi.init()
nb_of_devices = midi.get_count()
id = 0
while id < nb_of_devices:
infos = midi.get_device_info(id)
if (infos[1] == b'LPD8' and infos[2] == 1):
break
id += 1
try:
self._lpd8_in = midi.Input(id, buffer_size)
self._ctrl_knob_array = LPD8_Ctrl_Knob_Array()
print('LPD8 input device connected...')
except midi.MidiException:
self._lpd8_in = None
print('LPD8 input device not found...')
def list_input_devices():
devices = []
for i in range(255):
info = midi.get_device_info(i)
if info is None:
continue
if info[2] == 1: # check that device is an output device
print(info[1].decode()) # print device name
def get_info(self):
l = []
for x in range(pm.get_count()):
l.append(pm.get_device_info(x))
#dev = DeviceInfo(Index=x, info=pm.get_device_info(x))
#self.dev_info[dev.type].add_child(existing_object=dev)
#dev.bind(active=self.on_dev_info_active_set)
return l
def open_stream(name):
''' Searches for a MIDI input device matching the passed name and opens
a stream. If name=None, opens the first input device.
'''
for i in range(255):
info = midi.get_device_info(i)
if (name is None or info[1].decode() == name) and info[2] == 1:
return midi.Input(i)
def select(self, index, *largs):
try:
self.parent.midi.setDevice(index)
self.selected = index
self.selectedname = midi.get_device_info(index)[1]
except:
raise
self.refresh()
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():
global bpm
global skip
global pad_in
global pad_out
global in_chan
global out_chan
global fastmode
if not len(sys.argv[1:]):
usage()
try:
opts, args = getopt.getopt(
sys.argv[1:], "hb:sfi:o:",
["help", "bpm", "skip", "fast", "input", "output"])
except getopt.GetoptError as err:
print str(err)
usage()
if len(args):
usage()
for o, a in opts:
if o in ["-h", "--help"]:
usage()
elif o in ["-b", "--bpm"]:
bpm = float(a)
elif o in ["-s", "--skip"]:
skip = True
elif o in ["-f", "--fast"]:
fastmode = True
elif o in ["-i", "--input"]:
in_chan = int(a)
elif o in ["-o", "--output"]:
out_chan = int(a)
else:
assert False, "Unhandled Option"
if midi.get_device_info(in_chan) != ('ALSA', 'Launchpad S MIDI 1', 1, 0,
0):
print "[!] Launchpad input channel invalid"
sys.exit(0)
if midi.get_device_info(out_chan) != ('ALSA', 'Launchpad S MIDI 1', 0, 1,
0):
print "[!] Launchpad output channel invalid"
sys.exit(0)
pad_in = midi.Input(in_chan)
pad_out = midi.Output(out_chan)
loop()
def createInterfaces(self): """ creates all midi interfaces available as devices @todo: sort in- and output of one hardware """ n = midi.get_count() for i in xrange(n/2): info = midi.get_device_info(i*2) newIf = Interface(info[1], i*2-1, i*2)
def scan_midi_all_port(self):
self.all_ports = []
devnum = pmd.get_count()
for i in range(devnum):
dev = pmd.get_device_info(i)
if dev[3] == 1: # MIDI Output なら
name = dev[1].decode()
self.all_ports.append([i, name, False])
return self.all_ports
def find_midi_device(device_name, direction):
for index in range(midi.get_count()):
_, name, is_input, is_output, _ = midi.get_device_info(index)
name = name.decode("utf8")
if name == device_name:
if ((is_input and direction == "in") or
(is_output and direction == "out")):
return index
raise UserError("Could not find {} device \"{}\"".format(direction.upper(), device_name))
def get_devices() -> DeviceList:
from pygame import midi
midi.init()
names = [
midi.get_device_info(x)[1].decode('ascii')
for x in range(0, midi.get_count())
]
midi.quit()
return names
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 find_id(target='Teensy MIDI'): init() for d in range( get_count() ): (interf, name, input, out, op) = get_device_info(d) name = str(object=name, encoding='utf-8') if (name == 'Teensy MIDI' and out == 1): return d quit() return None
def select_MIDI_out():
""" Select and appropriate midi device"""
midi_count = midi.get_count()
avail_devices = [midi.get_device_info(i) for i in range(midi_count)]
print("Please select a MIDI device by selecting appropriate number")
for num, device in enumerate(avail_devices):
print("{}. {}".format(num, device))
midi_choice = input("device id: ")
return int(midi_choice)
def __init__(self, ctlname):
global theSmartie
theSmartie = self
self.ctl8x8 = []
self.btn8x9 = []
midi.init()
for i in range(midi.get_count()):
(_, name, b_in, bout, _) = midi.get_device_info(i)
if ctlname in str(name) and b_in:
self.indev = midi.Input(i)
if ctlname in str(name) and bout:
self.outdev = midi.Output(i)
self.device = midi.get_device_info(self.indev.device_id)[1]
print "Midi device is %s" % self.device
self.default_btns(self.ctl8x8, self.btn8x9)
def GetPorts(self):
i = {}
o = {}
for j in range(pm.get_count()):
s,name,ins,outs,throughs = pm.get_device_info(j)
if ins > 0:
i[name] = j
if outs > 0:
o[name] = j
return (i,o)
def GetPorts(self):
i = {}
o = {}
for j in range(pm.get_count()):
s, name, ins, outs, throughs = pm.get_device_info(j)
if ins > 0:
i[name] = j
if outs > 0:
o[name] = j
return (i, o)
def list_devices(self):
for i in range(pm.get_count()):
r = pm.get_device_info(i)
(interf, name, input, output, opened) = r
in_out = ""
if input:
in_out = "(input)"
if output:
in_out = "(output)"
print ("%2i: interface :%s:, name :%s:, opened :%s: %s" % (i, interf, name, opened, in_out))
def get_devices(name):
id_in, id_out = None, None
for i in range(midi.get_count()):
info = midi.get_device_info(i)
if info[1] == name:
if info[2]:
id_in = i
elif info[3]:
id_out = i
return id_in, id_out
def get_devices(name):
id_in, id_out = None, None
for i in range(midi.get_count()):
info = midi.get_device_info(i)
if info[1] == name:
if info[2]:
id_in = i
elif info[3]:
id_out = i
return id_in, id_out
def main():
# Init midi lib
Midi.init()
done = False
receivingSysEx = False
sysExMsg = []
device_count = Midi.get_count()
#get info on devices
if device_count > 0:
print("Midi-devices found:")
for device in range(device_count):
temp = Midi.get_device_info(device) #get info on midi devices
io = ""
#Check if input or output
if temp[2] and not temp[3]:
io = "Input"
elif temp[3] and not temp[2]:
io = "Output"
else:
io = "Unrecognized"
#Print info
print(io, "Device #", device, temp[1])
else:
print("No Midi devices found \n exiting...")
sys.exit(0) #No reason to carry on so exit
#Prompt user for devices
input_id = raw_input("Choose midi input device #: ")
output_id = raw_input("Choose midi output device #: ")
controller_id = raw_input("Choose midi controller: ")
#Create handler
tx7 = TX7(int(input_id),int(output_id))
keyboard = MidiController(int(controller_id))
#Change the first character to an 'A'
#tx7.write_param(145,65)
#Main loop. Currently no way to terminate!!! besides killing the process
while not done:
if tx7.poll():
data = tx7.read()
if data != 0:
print(data)
elif keyboard.poll():
data = keyboard.read_noteMsg()
if data != None:
print(data)
tx7.write_noteOn(data[1],data[2])
def output_port(self):
for a in range(midi.get_count()):
device = midi.get_device_info(a)
name = str(device[1]).lower()
if ("launchpad" in name and device[3]):
id = a
if (self.mode != "live"):
id = a + 1
return midi.Output(id)
return False
def list_devices(self):
for i in range(pm.get_count()):
r = pm.get_device_info(i)
(interf, name, input, output, opened) = r
in_out = ""
if input:
in_out = "(input)"
if output:
in_out = "(output)"
print("%2i: interface :%s:, name :%s:, opened :%s: %s" %
(i, interf, name, opened, in_out))
def create_initial_data(mox):
pin = {}
pout = {}
for i in xrange(pym.get_count()):
info = pym.get_device_info(i)
name = info[1]
if info[2]:
pin[name] = i
if info[3]:
pout[name] = i
return {"ports_in": pin, "ports_out": pout}
def _open_device(name='SSCOM MIDI 1', device_index=1):
'''Opens midi device with given name and port number'''
# This code stinks. Is there any better way to find the device?
for dn in range(midi.get_count()):
md = midi.get_device_info(dn)
if (md[1] == name) and (md[3] == 1): # md[3] == 1 <=> output device
device_index -= 1
if device_index == 0:
return midi.Output(dn)
raise RuntimeError("Could not find a SoftStep Controller")
def setDevice(self, idnum):
r = pm.get_device_info(idnum)
if r is not None:
self.device = pm.Input(idnum)
self.device_id = idnum
self.device_name = r[1]
if r[2]:
self.device_type = "input"
elif r[3]:
self.device_type = "output"
self.device_opened = r[4]
def get_devices():
"""Get a list of all MIDI output devices connected to the system."""
if _midi is None:
return
outdevices = []
all_ids = _midi.get_count()
for device_id in all_ids:
info = _midi.get_device_info(device_id)
if info[3] == 1:
outdevices.add([device_id, info[1]])
return outdevices
def connecter_sortie():
''' Appeler cette fonction pour récupérer une sortie MIDI.
'''
pgm.init(
) ### mettre le init ici va peut etre réler le bug sur le portable
for ident in range(pgm.get_count()):
info = pgm.get_device_info(ident)
if info[3] == 1: # c'est un output
print("MIDI: Utilisation de", info[1])
break
#ident=pgm.get_default_output_id()
return pgm.Output(ident)
def devices(self):
devices = []
for i in range(midi.get_count()):
driver, name, inp, outp, opened = midi.get_device_info(i)
if outp:
devices.append((i, driver, name, inp, outp))
return devices
def midiPassthruSelect(self, mainWindowInstance, device):
deviceIndex = mainWindowInstance.midiPassthruDevicesDict[device]
if not device.isChecked():
self.midiSelectedPassthruDevicesDict.pop(deviceIndex)
device.setChecked(False)
else:
self.midiSelectedPassthruDevicesDict[deviceIndex] = deviceIndex
deviceNameList = []
for deviceIndex in self.midiSelectedPassthruDevicesDict.keys():
deviceNameList.append(hashlib.md5(midi.get_device_info(deviceIndex)[1]).hexdigest())
mainWindowInstance.settings.setValue("midiPassthruDevices", deviceNameList)
def get_devices():
"""Get a list of all MIDI input devices connected to the system."""
if _midi is None:
return
indevices = []
all_ids = _midi.get_count()
for device_id in all_ids:
info = _midi.get_device_info(device_id)
if info[2] == 1:
indevices.add([device_id, info[1]])
return indevices
def __init__(self):
self.pin = {}
self.pout = {}
for i in xrange(pym.get_count()):
info = pym.get_device_info(i)
if info[2]:
self.pin[i] = pym.Input(i)
if info[3]:
self.pout[i] = pym.Output(i)
self.thread = threading.Thread(target=self._run)
self.thread.daemon = True
self.thread.start()
