import gstt
is_py2 = sys.version[0] == '2'
if is_py2:
from queue import Queue
from OSC import OSCServer, OSCClient, OSCMessage
else:
from queue import Queue
from OSC3 import OSCServer, OSCClient, OSCMessage
print("")
midiname = ["Name"] * 16
midiport = [rtmidi.MidiOut() for i in range(16) ]
OutDevice = []
InDevice = []
midisync = True
# max 16 midi port array
midinputsname = ["Name"] * 16
midinputsqueue = [Queue() for i in range(16) ]
midinputs = []
# False = server / True = Client
gstt.clientmode = False
#!/usr/bin/env python
import logging
import sys
import time
import rtmidi
from rtmidi.midiutil import open_midiport
client_name = "testall"
midiout = rtmidi.MidiOut(name=client_name)
midiout.open_virtual_port("out")
log = logging.getLogger('test_midiin_callback')
logging.basicConfig(level=logging.DEBUG)
def midiSolver(message):
print(message)
def testAll():
time.sleep(10)
for y in range(0, 127):
message = [144, y, 127]
#time.sleep(0.1)
input()
midiout.send_message(message)
print(message)
def init_midi(self):
self.midi = rtmidi.MidiOut(rtapi=rtmidi.API_UNIX_JACK, name='inputtomidi')
##self.midi_obj = rtmidi.MidiOut(rtapi=rtmidi.API_LINUX_ALSA, name='inputtomidi')
self.midi.open_virtual_port('out')
## 1. Parts converteren naar drukheid per part (en totaal?) en adhdv parts de voller of leger maken bij zowel 1e als latere iteraties
## 2. Unison modus, mss meer modi voor variatie
## 3. Akkoorden buiten de key (negative harmony?): Zorg dat hij altijd een optie vindt dmv. movement ipv index
## 4. Sound design
## 5. CC's voor timbral changes etc.
import random
import time, sched
import rtmidi
import _thread as thread
import sys
from midiutil.MidiFile import MIDIFile
midiouts = [rtmidi.MidiOut() for i in range(5)]
tracknames = ['Bass', 'Lead', 'Drums', 'Keys', 'Chords']
for i in range(len(midiouts)):
midiouts[i].open_virtual_port(tracknames[i])
# set bpm
bpm = int(input("Choose BPM \n >"))
swing = random.randint(15, 30) / bpm
measureCount = 0
key = 0
shortkey = key
pause = 0
print("0: 4/4 1:5/4 2:7/8")
timesigchoice = input("Choose time signature: \n >")
if timesigchoice == '0':
beatsPerMeasure = 8
length = 32
from ms_interface.ms_interface import MainStageConcert, MainStageSink
from kle_lib.kle import KLE
import asyncio
import threading
import rtmidi
import time
import sys
kle = KLE()
ms_out = rtmidi.MidiOut()
ms_out.open_virtual_port(name="KLE MS")
ms_in = rtmidi.MidiIn()
ms_in.open_virtual_port(name="KLE MS")
concert = MainStageConcert(sys.argv[1], kle)
sink = MainStageSink(concert)
for i in range(8):
if i<4:
if (i)/2 == int((i)/2):
kle.controls.pads[i].rgbLightUp(kle._dawout, 255,0,0)
else:
kle.controls.pads[i].rgbLightUp(kle._dawout, 0, 255, 0)
else:
if (i)/2 == int((i)/2):
kle.controls.pads[i].rgbLightUp(kle._dawout, 0, 255, 0)
else:
kle.controls.pads[i].rgbLightUp(kle._dawout, 255, 0, 0)
def get_midiout_ports(api="UNSPECIFIED"):
mo = rtmidi.MidiOut(rtapi=getattr(rtmidi, 'API_' + api))
return sorted(mo.get_ports())
def setup(device):
global midiout #Makes midiout global, so other functions can use it later
midiout = rtmidi.MidiOut() #Creates an MIDI Out
midiout.open_port(device) #Opens the specified MIDI Device
def __init__(self):
super(RtMidiHandler, self).__init__()
self.sysex = []
self.midiin = rtmidi.MidiIn()
self.midiin.ignore_types(sysex=False, timing=True, active_sense=True)
self.midiout = rtmidi.MidiOut()
def __init__(self, port):
self.midi = rtmidi.MidiOut()
self.midi.open_port(port)
def main(out_port, in_port):
# LOAD PARAMS FROM CONFIG
load_config()
# DEFINE BOUNDING BOX(ES)
cube_min = array([10, 50, 7, 0, 0])
edge_length = 40 # 35
cube = Swarm.Cube(cube_min, edge_length)
cube2 = Swarm.Cube(array([10 + edge_length, 50, 7, 0, 0]), edge_length)
cube3 = Swarm.Cube(array([10 + 2 * edge_length, 50, 7, 0, 0]), edge_length)
# MAKE SWARM OBJECTS
# TODO make the 'follow' implicit
# format: swarm, channel
swarm_data = [
(Swarm.Swarm(13, cube, 6), 3),
# (Swarm.Swarm(7, cube, follow=7), 1),
# (Swarm.Swarm(15, cube3, follow=12), 2),
# (Swarm.Swarm(4, cube2, follow=7), 9)
]
swarms = list(map(lambda x: x[0], swarm_data))
# SET UP MIDI
midiout = rtmidi.MidiOut()
midiout.open_port(out_port)
interps = list()
i1 = PolyInterpreter(0, midiout, swarm_data[0])
start_interp(i1,
tempo=120,
scale=Scales.satie,
preset="piano",
instrument="")
interps.append(i1)
# i2 = PolyInterpreter(1, midiout, swarm_data[1])
# start_interp(i2, tempo=130, scale=Scales.chrom, preset="piano", instrument="")
# interps.append(i2)
# #
# i3 = PolyInterpreter(2, midiout, swarm_data[2])
# start_interp(i3, tempo=90, scale=Scales.satie, preset="synth", instrument="fantasia")
# interps.append(i3)
# start up the midi in stream
# in_stream = None
if Parameters.SP.ATTRACTOR_MODE == 2:
in_stream = InStream(interps, in_port)
ren_att = True
else:
in_stream = None
ren_att = False
config = pyglet.gl.Config(sample_buffers=1, samples=4)
# resolution
import os
if os.name != 'nt':
w = 1200
h = 900
else:
w = 1920
h = 1080
# creates the window and sets its properties
Window(swarms,
interps,
ren_att,
config=config,
width=w,
height=h,
caption='Murmurations',
resizable=True)
# start the application
pyglet.app.run()
# CLEAN UP
for interp in interps:
interp.done = True # kill it.
interp.join()
del midiout
if in_stream:
in_stream.done = True
in_stream.join()
print("Exiting")
def __init__(self, port=0):
self.midi_out = rtmidi.MidiOut()
self.midi_out.open_port(port)
available_ports = self.midi_out.get_ports()
logger.info(f"Opened port: {available_ports[port]}")
def main():
# Port name we are looking for
port_name = "FIT"
in_port_num = -1
out_port_num = -1
midiin = rtmidi.MidiIn()
available_ports = midiin.get_ports()
for idx, name in enumerate(available_ports):
if name[0:len(port_name)] == port_name:
in_port_num = idx
midiout = rtmidi.MidiOut()
available_ports = midiout.get_ports()
for idx, name in enumerate(available_ports):
if name[0:len(port_name)] == port_name:
out_port_num = idx
if in_port_num == -1:
raise BaseException("could not find midi in device")
if out_port_num == -1:
raise BaseException("could not find midi out device")
mp = MidiPlus(in_port_num, out_port_num)
mp.clear_screens()
for fader in mp.faders:
fader.register_callback("fader_move", lambda self, pos:
self.set_row(1, str(pos)))
fader.register_callback("knob_turn", lambda self, speed:
self.set_row(3, str(speed)))
fader.register_callback("fader_touch", lambda self:
self.set_row(5, "FTouch"))
fader.register_callback("fader_release", lambda self:
self.set_row(5, ""))
fader.register_callback("select_press", lambda self:
self.set_led_select(True))
fader.register_callback("select_release", lambda self:
self.set_led_select(False))
fader.register_callback("solo_press", lambda self:
self.set_led_solo(True))
fader.register_callback("solo_release", lambda self:
self.set_led_solo(False))
fader.register_callback("mute_press", lambda self:
self.set_led_mute(True))
fader.register_callback("mute_release", lambda self:
self.set_led_mute(False))
fader.register_callback("knob_press", lambda self:
self.set_row(4, "KPress"))
fader.register_callback("knob_release", lambda self:
self.set_row(4, ""))
mp.register_callback("layer_press", lambda self, layer:
self.set_led_layer(layer, True))
mp.register_callback("layer_release", lambda self, layer:
self.set_led_layer(layer, False))
mp.register_callback("util_press", lambda self, util:
self.set_led_util(util, True))
mp.register_callback("util_release", lambda self, util:
self.set_led_util(util, False))
mp.register_callback("tempo_press", lambda self:
self.set_led_tempo(True))
mp.register_callback("tempo_release", lambda self:
self.set_led_tempo(False))
mp.clear_screens()
while True:
time.sleep(1)
def __init__(self):
self.serial_number = ""
self.firmware_version = ""
# create midi objects fot communication
self.nanosync_midi_out = rtmidi.MidiOut()
self.nanosync_midi_in = rtmidi.MidiIn()
self.midi_in_port = None
self.midi_out_port = None
self._select_correct_ports()
# important commands used for NanoSyncs
self.serial_message = [
1
] # F0 2C 4E 53 01 F7 - command to return S/N of Nano Sync and firmware version
self.query_current_Config = [
3
] # F0 2C 4E 53 03 F7 - Queries the nano sync about its current setup
# abstraction for the Nano sync control
# <editor-fold desc="Settings dictionaries">
self.video_ref = bidict({
"internal": 1,
"external pal": 2,
"external ntsc": 3,
"external tri": 4
})
self.video_standard = bidict({
"ntsc": 1,
"pal 25": 2,
"pal 24": 3,
"pal 23.98": 4
})
self.HD_standard = bidict({
"1080i x2 fps": 1,
"1080p x1 fps": 2,
"1080p x2 fps": 3,
"720p x1 fps": 4,
"720p x2 fps": 5
})
self.FPS = bidict({
"23.98 fps": 1,
"24 fps": 2,
"25 fps": 3,
"29.97 fps": 4,
"30 fps": 5
})
self.video_definition = bidict({"SD": 1, "HD": 2})
self.audio_ref = bidict({
"follow video": 1,
"external word clock": 2,
"external word 1:1": 3,
"LTC": 4
})
self.external_word_fs = bidict({"44.1 khz": 1, "48 khz": 2})
self.external_word_fs_multiplier = bidict({"x1": 1, "x2": 2})
self.external_word_fs_modifier = bidict({"1/1": 1, "+0.1%": 2})
self.external_LTC_fps = bidict({
"23.98 fps": 1,
" 24 fps": 2,
"25 fps": 3,
"29.98 fps": 4,
"30 fps": 5
})
self.audio_sample_rate = bidict({"48 khz": 1, "44.1 khz": 2})
self.audio_sample_rate_modifier = bidict({
"x1": 1,
"+4%": 2,
"+0.1%": 3,
"-0.1%": 4,
"-4%": 5
})
self.word_multiplier_1_6 = bidict({"x1": 1, "x2": 2, "x4": 3})
self.word_multiplier_7_8 = bidict({
"x1": 1,
"x2": 2,
"x4": 4,
"x256": 5
})
self.AES_multiplier = bidict({"x1": 1, "x2": 2})
self.SPDIF_multiplier = bidict({"x1": 1, "x2": 2})
# </editor-fold>
# Setting some default values
self.cursor_pos = 0 # Placeholder
self.video_ref_setting = self.video_ref["internal"]
self.video_standard_setting = self.video_standard["ntsc"]
self.HD_standard_setting = self.HD_standard["1080p x2 fps"]
self.FPS_setting = self.FPS["30 fps"]
self.video_1_to_3_setting = self.video_definition["HD"]
self.video_4_setting = self.video_definition["HD"]
self.video_5_setting = self.video_definition["HD"]
self.video_6_setting = self.video_definition["HD"]
# audio stuff below, best to leave it all alone
self.audio_ref_setting = self.audio_ref["follow video"]
self.external_word_fs_setting = self.external_word_fs["44.1 khz"]
self.external_word_fs_multiplier_setting = self.external_word_fs_multiplier[
"x1"]
self.external_word_fs_modifier_setting = self.external_word_fs_modifier[
"1/1"]
self.external_LTC_fps_setting = self.external_LTC_fps["23.98 fps"]
self.audio_sample_rate_setting = self.audio_sample_rate["48 khz"]
self.audio_sample_rate_modifier_setting = self.audio_sample_rate_modifier[
"x1"]
self.word_multiplier_1_6_setting = self.word_multiplier_1_6["x1"]
self.word_multiplier_7_8_setting = self.word_multiplier_7_8["x1"]
self.AES_multiplier_setting = self.AES_multiplier["x1"]
self.SPDIF_multiplier_setting = self.SPDIF_multiplier["x1"]
self.current_config = None # Puts all the settings above into a list
self._update_current_config()
self._connect()
self._get_current_config()
def __init__(self):
self.midiout = rtmidi.MidiOut()
self.midiout.open_port(0)
def __init__(self, portn: str or int = None, rtapi=rtmidi.API_UNSPECIFIED):
super().__init__(arg=portn, port=rtmidi.MidiOut(rtapi=rtapi))
self.player: PlayerProc = None
import rtmidi
import time
import random
# Global Midi Parameters with RtMidi
# You can find your midi ports on your own computer using the .get_ports() method on a rtmidi object in a Python console
midi_out = rtmidi.MidiOut()
midi_out.open_port(0)
midi_in = rtmidi.MidiIn()
midi_in.open_port(0)
moog_send = rtmidi.MidiOut()
moog_send.open_port(3)
# Creating a class for the launchpad with a C major scale in MIDI
# There are empty dictionaries and lists for storing the Values received and to be sent to the launchpad
class Launchpad:
scale = [72, 71, 69, 67, 65, 64, 62, 60]
sends = []
meter = 7
notes_on = {}
column_on = {}
#Here are some global MIDI parameters for the Launchpad MK1 which made sense to have as class variables.
make_blank = 0
make_red = 15
make_green = 60
make_yellow = 63
send_on = 0x90
send_off = 0x80
#!/usr/bin/env python
# coding: utf-8
import argparse
import rtmidi
import time
send = rtmidi.MidiOut()
recv = rtmidi.MidiIn()
recv.ignore_types(False) # Don't ignore sysex!
class MPK2Sysex:
akaiHeader = [0xf0, 0x47, 0x00]
mpkID = {
0x24: 'MPK249',
0x25: 'MPK261',
}
padColors = {
0x00: 'Off',
0x01: 'Red',
0x02: 'Orange',
0x03: 'Amber',
0x04: 'Yellow',
0x05: 'Green',
0x06: 'Green_Blue',
0x07: 'Aqua',
0x08: 'Light_Blue',
0x09: 'Blue',
0x0A: 'Purple',
0x0B: 'Pink',
0x0C: 'Hot_Pink',
# Change pad colors on an MPK249
# Erases operating system, preserves factory bootloader
# at 0-0x6000.
import time
import rtmidi
bridge = rtmidi.MidiOut()
bridge.open_virtual_port("My virtual output")
bridge_back = rtmidi.MidiIn()
bridge_back.open_virtual_port("My virtual output")
# Connect to Akai249
midiin = rtmidi.MidiIn()
midiin.open_port(0)
midiout = rtmidi.MidiOut()
midiout.open_port(0)
header = [0xF0, 0x47, 0x00, 0x24]
footer = [0xF7]
base_color = 0x2
pad_address = [0x0a, 0x7c]
midiout.send_message(header + [0x31, 0, 43, 40] + pad_address +
[base_color] * 64 + footer)
# End
import time
import os
import mido
import rtmidi
import random
import sys
from mido import Message, MidiFile, MidiTrack
drum = rtmidi.MidiOut()
drum.open_virtual_port("udukBot")
time.sleep(0.2)
os.system("aconnect 130:0 14:0")
BEATTXT = "/tmp/beat.txt"
def ParseMIDI(filename):
notes = []
mid1 = MidiFile(filename)
for i, track in enumerate(mid1.tracks):
for msg in track:
if not msg.is_meta:
s = str(msg).split(" ")
time = str(s[4]).split("=")
time = int(time[1])
try:
m = Message.from_bytes(msg.bytes())
def main(args=None):
"""Main program function.
Parses command line (parsed via ``args`` or from ``sys.argv``), detects
and optionally lists MIDI output ports, opens given MIDI output port,
assembles list of sysex files and calls ``send_sysex_file`` on each of
them.
"""
parser = argparse.ArgumentParser(description=__doc__)
padd = parser.add_argument
padd(dest='sysexfiles',
nargs="*",
metavar="SYSEX",
help='MIDI system exclusive files or directories to send.')
padd('-l',
'--list-ports',
action="store_true",
help='list available MIDI output ports')
padd('-p',
'--port',
dest='port',
default=0,
type=int,
help='MIDI output port number (default: %(default)s)')
padd('-d',
'--delay',
default="50",
metavar="MS",
type=int,
help='delay between sending each Sysex message in milliseconds '
'(default: %(default)s)')
padd('-y',
'--no-prompt',
dest='prompt',
action="store_false",
help='do not ask for confirmation before sending')
padd('-v', '--verbose', action="store_true", help='verbose output')
args = parser.parse_args(args if args is not None else sys.argv[1:])
logging.basicConfig(format="%(name)s: %(levelname)s - %(message)s",
level=logging.DEBUG if args.verbose else logging.INFO)
try:
midiout = rtmidi.MidiOut()
ports = midiout.get_ports()
if ports:
if args.list_ports:
for i, port in enumerate(ports):
print(("%i: %s" % (i, port)))
return 0
if args.port < len(ports):
midiout.open_port(args.port)
portname = midiout.get_port_name(args.port)
else:
log.error("MIDI port number out of range.")
log.error("Use '-l' option to list MIDI ports.")
return 2
else:
log.error("No MIDI output ports found.")
return 1
files = []
for path in args.sysexfiles or [os.curdir]:
if isdir(path):
files.extend(
sorted([
join(path, fn) for fn in os.listdir(path)
if fn.lower().endswith('.syx')
]))
elif exists(path):
files.append(path)
else:
log.error("File '%s' not found.")
if not files:
log.warning("No sysex (.syx) files found in given directories or "
"working directory.")
for filename in files:
try:
send_sysex_file(filename, midiout, portname, args.prompt,
args.delay)
except StopIteration:
break
except Exception as exc:
log.error("Error while sending file '%s': %s", (filename, exc))
finally:
midiout.close_port()
del midiout
return 0
import time
import rtmidi
mo = rtmidi.MidiOut()
mo.open_port(3)
def domath():
res = 1333 * 14123
res *= 134165
mo.send_message([0x90, 0x1, 127])
return res
def test(ticks=10):
history = []
offset = 0
for i in range(ticks):
history.append(time.time())
time.sleep(1 - offset)
stime = time.time()
domath()
offset = time.time() - stime
for i in range(len(history)):
print("Pass " + str(i) + ": " + str(history[i]))
def test2(ticks=10):
history = []
stime = time.time()
history.append(stime)
for i in range(ticks):
etime = stime + 1
domath()
while time.time() < etime:
def __init__(self):
self.midiout = rtmidi.MidiOut()
self.out_ports = self.midiout.get_ports()
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
debug = 'debug' in argv
def play(self,
channels=allChannels,
trackSections=['Main A'],
tempo=120,
midiPort=0,
key='c',
chord='Maj7'):
channels.insert(0, None)
def getEvents(trackSections, eot=True, transpose=True):
sectionTime = 0
events = []
for name in trackSections:
section = self.trackSections[name]
for channel in channels:
channelId = getChannelId(channel)
if channelId in section['channels']:
inEvents = clone(section['channels'][channelId])
if channel is None or not transpose:
pass
elif name not in self.casm or channel not in self.casm[
name] or self.casm[name][channel][
'type'] != 'ctb2':
print(
f'Warning: Skipping transposition of channel {channel} in track section "{name}" because ctb2 entry was not found in CASM'
)
else:
fromChord = self.casm[name][channel][
'source-chord-type']
fromKey = self.casm[name][channel][
'source-chord-key']
ctb2 = self.casm[name][channel]
ctb2Part = ctb2['middle']
nttRule = ctb2Part['ntt']['rule']
inEvents = self._transposeEvents(
inEvents, nttRule, fromKey, fromChord, key,
chord)
for event in inEvents:
if channel != None:
event['channel'] = channel
event['time'] += sectionTime
events.append(event)
sectionTime += section['length']
events.sort(key=lambda event: event['time'])
globalTime = 0
for event in events:
event['time'] -= globalTime
globalTime += event['time']
if eot:
events.append({
'time': sectionTime - globalTime,
'command': 'meta-eot'
})
return events
def playEvents(events):
for event in events:
tm = event['time']
if tm > 0:
time.sleep(tm * (60 / tempo / beats))
if event['command'][0:4] != 'meta':
data = midiEventCodec.build(event)
midiout.send_message(data)
initEvents = getEvents(trackSections=['Prologue', 'SInt'],
eot=False,
transpose=False)
loopEvents = getEvents(trackSections=trackSections)
midiout = rtmidi.MidiOut()
midiout.open_port(midiPort)
playEvents(initEvents)
try:
while True:
playEvents(loopEvents)
except KeyboardInterrupt:
pass
for channel in channels:
if channel is not None:
event = {'command': 'cc-all-notes-off', 'channel': channel}
data = midiEventCodec.build(event)
midiout.send_message(data)
del midiout
def main():
parser = argparse.ArgumentParser(description="Virtual MIDI keyboard")
parser.add_argument('device', help="Evdev input device", nargs='?')
parser.add_argument('-l',
'--list',
help="List MIDI input ports, input devices and quit",
dest='list',
action='store_true')
parser.add_argument('-n',
'--port-name',
help="MIDI output port name to create",
dest='port_name',
default="PyMIDIK")
parser.add_argument('-o',
'--connect',
help="MIDI input port to connect to",
dest='connect_port')
parser.add_argument('-c',
'--channel',
help="MIDI channel number (1-16)",
dest='channel',
type=parse_channel,
default=0)
parser.add_argument('-t',
'--transpose',
help="Transpose MIDI notes by amount (+/- 0-126)",
dest='transpose',
type=parse_transpose,
default=0)
parser.add_argument('-g',
'--grab',
help="Grab input device, swallow input events",
dest='grab',
action='store_true')
parser.add_argument('-v',
'--verbose',
help="Print MIDI messages",
dest='verbose',
action='store_true')
global args
args = parser.parse_args()
if args.list:
list_ports_and_devices()
sys.exit(0)
if args.device is None:
parser.print_help()
sys.exit(1)
midiout = rtmidi.MidiOut()
if args.connect_port is None:
midiout.open_virtual_port(args.port_name)
print("Opened virtual port \"%s\"" % (args.port_name, ))
else:
ports = list(
filter(lambda p: p[1].startswith(args.connect_port),
enumerate(midiout.get_ports())))
if len(ports) == 0:
print("No MIDI input ports found matching \"%s\"" %
(args.connect_port, ))
sys.exit(3)
else:
port = ports[0]
midiout.open_port(port[0])
print("Connected to port \"%s\"" % (port[1]))
dev = evdev.InputDevice(args.device)
if args.grab:
dev.grab()
ctrl_down = False
for ev in dev.read_loop():
if ev.type == evdev.ecodes.EV_KEY:
if ev.code == ecodes.KEY_LEFTCTRL:
ctrl_down = ev.value != 0
elif ev.code == ecodes.KEY_C:
if ctrl_down:
if args.grab:
print("^C detected, exiting")
break
if ev.value == 1:
note = key_code_to_midi_note(ev.code)
if note is not None:
_send_message(midiout, [
midiconstants.NOTE_ON + args.channel,
(note + args.transpose) % 127, 127
])
elif ev.value == 0:
note = key_code_to_midi_note(ev.code)
if note is not None:
_send_message(midiout, [
midiconstants.NOTE_OFF + args.channel,
(note + args.transpose) % 127, 0
])
if args.grab:
dev.ungrab()
#!/usr/bin/env python
#
# panic.py
#
"""Send AllSoundOff and ResetAllControllers on all JACK MIDI outputs and all channels."""
from __future__ import print_function
import rtmidi
from rtmidi.midiconstants import (ALL_SOUND_OFF, CONTROL_CHANGE,
RESET_ALL_CONTROLLERS)
midiout = rtmidi.MidiOut(rtapi=rtmidi.API_UNIX_JACK)
print(__doc__)
for portnum, portname in enumerate(midiout.get_ports()):
print("Port:", portname)
midiout.open_port(portnum)
for channel in range(16):
midiout.send_message([CONTROL_CHANGE, ALL_SOUND_OFF, 0])
midiout.send_message([CONTROL_CHANGE, RESET_ALL_CONTROLLERS, 0])
midiout.close_port()
## 0. Lijsten samenvoegen, for loops vervangen met list comprehensions waar mogelijk
## 1. Parts balancen aan de hand van hoe vol de afgelopen 8x16e waren ofzo
## 2. Unison modus, mss meer modi voor variatie
## 3. Meer verschil in chord progressions en extentions etc, akkoorden buiten de key (negative harmony?)
## 4. Sound design
## 5. CC's voor timbral changes etc.
import random
import time, sched
import rtmidi
import _thread as thread
import sys
from midiutil.MidiFile import MIDIFile
midiout = rtmidi.MidiOut()
available_ports = midiout.get_ports()
midiout.open_virtual_port("Drums")
midiout2 = rtmidi.MidiOut()
available_ports = midiout2.get_ports()
midiout2.open_virtual_port("Bass")
midiout3 = rtmidi.MidiOut()
available_ports = midiout3.get_ports()
midiout3.open_virtual_port("Keys")
midiout4 = rtmidi.MidiOut()
available_ports = midiout4.get_ports()
midiout4.open_virtual_port("Lead")
# set bpm
def __init__(self, api=rtmidi.API_UNSPECIFIED):
self.masterout = rtmidi.MidiOut(rtapi=api)
self.api = self.masterout.get_current_api()
self.outports = {}
self.inports = {}
#!/usr/bin/env python
#
# test_midiin_callback.py
#
"""Shows how to use a MidiOut instance as a context manager."""
import time
import rtmidi
from rtmidi.midiconstants import NOTE_OFF, NOTE_ON
NOTE = 60 # middle C
midiout = rtmidi.MidiOut()
with (midiout.open_port(0) if midiout.get_ports() else
midiout.open_virtual_port("My virtual output")):
note_on = [NOTE_ON, NOTE, 112]
note_off = [NOTE_OFF, NOTE, 0]
midiout.send_message(note_on)
time.sleep(0.5)
midiout.send_message(note_off)
del midiout
def __init__(self, concert: MainStageConcert):
self.mi = rtmidi.MidiIn()
self.mi.open_virtual_port("ms_sink")
self.mo = rtmidi.MidiOut()
self.mo.open_virtual_port("ms_sink")
self.concert = concert
