def __init__(self, port):
self.port = port
self.apis = get_compiled_api()
self.output = None
self.input = None
self.api_out = None
self.api_in = None
def _rtmidi_virtual_ports_available():
'''Check whether rtimidi virtual ports are available.
These are not supported for some MIDI APIs (e.g. Windows or 'dummy').
'''
compiled_apis = [
rtmidi.get_api_name(api) for api in rtmidi.get_compiled_api()
]
env_api = rtmidi.get_api_name(rtmidi.midiutil.get_api_from_environment())
logging.info(
f"rtmidi compiled API: {compiled_apis}, API from env: {env_api}")
port_name = "vlcmidi virtual test"
try:
rtmidi.midiutil.open_midioutput(use_virtual=True,
interactive=False,
port_name=port_name)
except (rtmidi.InvalidPortError, rtmidi.NoDevicesError,
rtmidi.SystemError) as e:
logging.warning(
f"Virtual ports not available: couldn't open port ({e})")
return False
# make sure we can see the port
midi_in = rtmidi.MidiIn()
available_ports = midi_in.get_ports()
if len(available_ports) == 0 or not any(port_name in port
for port in available_ports):
logging.warning(
f"Virtual ports not available: port not in {available_ports}")
return False
return True
def __init__(self):
self.api_supported_idxs = rtmidi.get_compiled_api()
self.api_supported_names = [
rtmidi.get_api_name(idx) for idx in self.api_supported_idxs
]
self.midi_in = rtmidi.MidiIn()
self.midi_out = rtmidi.MidiOut()
self.devices = self.get_midi_devices()
def test_get_compiled_api_by_name(self):
for api, name in ((rtmidi.API_LINUX_ALSA,
'alsa'), (rtmidi.API_MACOSX_CORE, 'core'),
(rtmidi.API_RTMIDI_DUMMY,
'dummy'), (rtmidi.API_UNIX_JACK, 'jack'),
(rtmidi.API_WINDOWS_MM, 'winmm')):
res = rtmidi.get_compiled_api_by_name(name)
if api in rtmidi.get_compiled_api():
self.assertEqual(res, api)
else:
self.assertEqual(res, rtmidi.API_UNSPECIFIED)
def __init__(self, clientname):
QtCore.QObject.__init__(self)
self.clientname = clientname
self.api = rtmidi.get_compiled_api()[0]
self.listener_in = rtmidi.MidiIn(self.api, clientname)
self.listener_in.ignore_types(sysex=False)
self.listener_out = rtmidi.MidiOut(self.api, clientname)
self.ports = {INPUT: [self.listener_in], OUTPUT: [self.listener_out]}
self.connections = {self.listener_in: None, self.listener_out: None}
self.default_in_caps = 66
self.default_out_caps = 33
self.default_type = 1048578
self.alsa_mode = True if 'linux' in sys.platform else False
self.in_graph_dict = {}
self.out_graph_dict = {}
self.client_dict = {}
def getMidiPorts(self):
available_apis = get_compiled_api()
for api, api_name in sorted(apis.items()):
if api in available_apis:
for name, class_ in (("input", MidiIn), ("output", MidiOut)):
try:
midi = class_(api)
ports = midi.get_ports()
except StandardError as exc:
logging.info("Could not probe MIDI %s ports: %s" %
(name, exc))
continue
if not ports:
logging.info("No MIDI %s ports found." % name)
else:
return enumerate(ports)
logging.info('')
del midi
def probePorts():
"""print list of available MIDI ports to the console"""
apis = {
API_MACOSX_CORE: "macOS (OS X) CoreMIDI",
API_LINUX_ALSA: "Linux ALSA",
API_UNIX_JACK: "Jack Client",
API_WINDOWS_MM: "Windows MultiMedia",
API_RTMIDI_DUMMY: "RtMidi Dummy"
}
available_apis = get_compiled_api()
for api, api_name in sorted(apis.items()):
if api in available_apis:
# try:
# reply = input("Probe ports using the %s API? (Y/n) " % api_name)
# if reply.strip().lower() not in ['', 'y', 'yes']:
# continue
# except (KeyboardInterrupt, EOFError):
# print('')
# break
for name, class_ in (("input", MidiIn), ("output", MidiOut)):
try:
midi = class_(api)
ports = midi.get_ports()
except StandardError as exc:
print("Could not probe MIDI %s ports: %s" % (name, exc))
continue
if not ports:
print("No MIDI %s ports found." % name)
else:
print("Available MIDI %s ports:\n" % name)
for port, name in enumerate(ports):
print("[%i] %s" % (port, name))
print('')
del midi
def get_api_names():
return [_api_to_name[n] for n in rtmidi.get_compiled_api()]
try:
import rtmidi
import time
ENABLE_MIDI = True
except ImportError:
ENABLE_MIDI = False
CFG = 'dxtxmidi.cfg'
for pth in sys.path:
s = os.path.join(pth, CFG)
if os.path.exists(s):
CFG = s
break
LINUX = False
if ENABLE_MIDI and rtmidi.API_LINUX_ALSA in rtmidi.get_compiled_api():
LINUX = True
def validfname(fn):
ALLOWED_CHARACTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._-"
newname = ''
for k in fn:
if k in ALLOWED_CHARACTERS:
newname += k
else:
newname += '_'
if newname in ('CON', 'PRN', 'AUX', 'NUL', 'COM1', 'COM2', 'COM3', 'COM4', 'COM5', 'COM6', 'COM7', 'COM8', 'COM9', 'LPT1', 'LPT2', 'LPT3', 'LPT4', 'LPT5', 'LPT6', 'LPT7', 'LPT8', 'LPT9'):
newname += '_'
return newname
def get_api_names():
return [_api_to_name[n] for n in rtmidi.get_compiled_api()]
def test_get_compiled_api(self):
apilist = rtmidi.get_compiled_api()
self.assertTrue(isinstance(apilist, list))
self.assertTrue(len(apilist) >= 1)
for api in apilist:
self.assertTrue(api <= rtmidi.API_RTMIDI_DUMMY)
from sys import argv, stdin, stdout, version_info, version, exit
from binascii import hexlify, unhexlify
import traceback
import json as JSON
import re
def ipc_send(name, data):
print(JSON.dumps([name, data]))
stdout.flush()
try:
import rtmidi
from rtmidi.midiconstants import *
API = rtmidi.API_UNIX_JACK if 'jack' in argv else rtmidi.API_UNSPECIFIED
if API is rtmidi.API_UNIX_JACK and rtmidi.API_UNIX_JACK not in rtmidi.get_compiled_api():
API = rtmidi.API_UNSPECIFIED
ipc_send('log', 'python-rtmidi was not compiled with jack midi support, falling back to default API')
JACK = API == rtmidi.API_UNIX_JACK
in_dev = rtmidi.MidiIn(API, 'MIDI->OSC probe')
out_dev = rtmidi.MidiOut(API, 'OSC->MIDI probe')
except:
ipc_send('log', 'ERROR: MIDI: python-rtmidi not found (or wrong version)\nRunning with python version %s' % version)
ipc_send('log', '\nGet python-rtmidi at https://spotlightkid.github.io/python-rtmidi/')
exit()
if version_info.major == 3:
raw_input = input
try:
input = raw_input
except NameError:
# Python 3
StandardError = Exception
apis = {
API_MACOSX_CORE: "OS X CoreMIDI",
API_LINUX_ALSA: "Linux ALSA",
API_UNIX_JACK: "Jack Client",
API_WINDOWS_MM: "Windows MultiMedia",
API_RTMIDI_DUMMY: "RtMidi Dummy"
}
available_apis = get_compiled_api()
for api, api_name in sorted(apis.items()):
if api in available_apis:
try:
reply = input("Probe ports using the %s API? (Y/n) " % api_name)
if reply.strip().lower() not in ['', 'y', 'yes']:
continue
except (KeyboardInterrupt, EOFError):
print('')
break
for name, class_ in (("input", MidiIn), ("output", MidiOut)):
try:
midi = class_(api)
ports = midi.get_ports()
def _get_apis(self) -> ty.Dict[str, int]:
return {
rtmidi.get_api_name(api): api
for api in rtmidi.get_compiled_api()
}
import rtmidi
import time
import sys
from os import system
import random
try:
input = raw_input
except NameError:
StandardError = Exception
if rtmidi.API_WINDOWS_MM in rtmidi.get_compiled_api():
midiout = rtmidi.MidiOut()
ports = midiout.get_ports()
if not ports:
print("No MIDI ports found.")
else:
print("Available MIDI devices:\n")
for port, name in enumerate(ports):
print("\t[%i] %s" % (port, name))
reply = input("\nChoose Device: ")
try:
val = int(reply)
except ValueError:
print("Only Numbers Allowed")
system('cls')
midiout.open_port(val)
print(
"Demo Modes:\n\n\t[0] Every Other\n\t[1] Fast Wave\n\t[2] Slow Wave\n\t[3] Line\n\t[4] 1 Up\n\t[5] Exponential\n\t[6] Spike Fall\n\t[7] Lights Only\n\t[8] Full Demo"
client, port = port.split(':', 1)
if client.startswith("new_client") and port.startswith(
self.OUT_PORT_NAME):
found = True
break
assert found
class SetClientNameUnsupportedTests:
def test_set_client_name_unsupported(self):
self.assertRaises(NotImplementedError, self.midi_out.set_client_name,
"new_client")
if rtmidi.API_LINUX_ALSA in rtmidi.get_compiled_api():
class ALSATestCase(BaseTests, SetPortNameSupportedTests,
SetClientNameSupportedTests, VirtualPortsSupportedTests,
unittest.TestCase):
API = rtmidi.API_LINUX_ALSA
if rtmidi.API_UNIX_JACK in rtmidi.get_compiled_api():
class JACKTestCase(BaseTests, SetPortNameSupportedTests,
SetClientNameUnsupportedTests,
VirtualPortsSupportedTests, unittest.TestCase):
API = rtmidi.API_UNIX_JACK
def open_port(self, port=0, name=None):
pass
class Player:
def __init__(self, miditable=0):
self._table = MidiTable(miditable)
self.port = rtm.MidiOut()
self.isportopen = self.port.is_port_open()
@property
def table(self):
return self._table
@table.setter
def table(self, other=0):
self._table = MidiTable(other)
if __name__ == '__main__':
# Run rtmidi checks
COMP_API = rtm.get_compiled_api()
if rtm.API_WINDOWS_MM in COMP_API:
print("Windows system detected")
else:
raise NotImplementedError('Linux and Mac support soon')
pl = Player()
print(pl.port)
print(pl.get_ports())
def api(self) -> int:
if not self._api:
return rtmidi.get_compiled_api()[0] # type:ignore
return self._api
