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 _open(self, **kwargs): if kwargs.get('virtual'): raise ValueError('virtual ports are not supported' ' by the Pygame backend') elif kwargs.get('callback'): raise ValueError('callbacks are not supported' ' by the Pygame backend') midi.init() if self.name is None: device = _get_default_device(self.is_input) self.name = device['name'] else: device = _get_named_device(self.name, self.is_input) if device['opened']: if self.is_input: devtype = 'input' else: devtype = 'output' raise IOError('{} port {!r} is already open'.format( devtype, self.name)) if self.is_input: self._port = midi.Input(device['id']) else: self._port = midi.Output(device['id']) self._device_type = 'Pygame/{}'.format(device['interface'])
def _open(self, **kwargs): if 'virtual' in kwargs: raise IOError( "virtual ports are not supported by the Pygame backend") midi.init() opening_input = hasattr(self, 'receive') if self.name is None: device = _get_default_device(opening_input) self.name = device['name'] else: device = _get_named_device(self.name, opening_input) if device['opened']: if opening_input: devtype = 'input' else: devtype = 'output' raise IOError('{} port {!r} is already open'.format( devtype, self.name)) if opening_input: self._port = midi.Input(device['id']) else: self._port = midi.Output(device['id']) self._device_type = 'Pygame/{}'.format(device['interface'])
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 _open(self): midi.init() self.device = None opening_input = (self.__class__ is Input) if self.name is None: self.device = self._get_default_device(opening_input) self.name = self.device['name'] else: self.device = self._get_named_device(self.name, opening_input) if self.device['opened']: if opening_input: devtype = 'input' else: devtype = 'output' raise IOError('{} port {!r} is already open'.format( devtype, self.name)) if opening_input: self._port = midi.Input(self.device['device_id']) else: self._port = midi.Output(self.device['device_id']) atexit.register(self.close)
def openById(self, id): dev = self.devices[id] if dev["direction"] == "OUTPUT": self.midiDevice = midi.Output(dev["device"]) if dev["direction"] == "INPUT": self.midiDevice = midi.Input(dev["device"]) return self.midiDevice
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, device, buffer_size=None): """Create a MIDI input. Parameters ---------- device : int or str id or name of the MIDI device buffer_size : int, optional number of events to be buffered """ import types if type(_midi) is not types.ModuleType: raise ImportError("""Sorry, MIDI input is not supported on this computer.""") if not expyriment._active_exp.is_initialized: raise RuntimeError( "Cannot create MidiIn before expyriment.initialize()!") _midi.init() Input.__init__(self) self._id = device if buffer_size is None: buffer_size = defaults.midiin_buffer_size self._buffer_size = buffer_size self.input = _midi.Input(device, buffer_size)
def __init__(self, **kwargs): """Keywords are 'input_id', 'output_id' and 'chan'""" if kwargs is not None: if 'input_id' in kwargs.keys(): self.input_id = kwargs['input_id'] # Create streams self.inStream = Midi.Input(self.input_id) #If given an output id, assign it a variable if 'output_id' in kwargs.keys(): self.output_id = kwargs['output_id'] # Create streams self.outStream = Midi.Output(self.output_id) if 'chan' in kwargs.keys(): self.chan = kwargs['chan'] else: #Use chan 0 on default self.chan = 0 else: raise Exception("At least on id must be given") #Init variables self.receiving_sysEx = False self.sysExMsg = [] #Create status messages. Should maybe not be constant for devices, but is sufficient for my needs now. self.key_on_status_with_chan = (self.KEY_ON_ID << 4) | self.chan self.key_off_status_with_chan = (self.KEY_OFF_ID << 4) | self.chan
def OpenInput(self, midi_id): if self.devIn is None: try: self.devIn = midi.Input(midi_id, MIDI_BUFFER_IN) except: self.devIn = None return False return True
def openByName(self, name, direction): for dev in self.devices: if (dev["name"] == name) & (dev["direction"] == direction): if direction == "OUTPUT": self.midiDevice = midi.Output(dev["device"]) if direction == "INPUT": self.midiDevice = midi.Input(dev["device"]) return self.midiDevice
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 set_in_device(name): global m_in if m_in: m_in.close() for in_d in inDevices(): if in_d[0] == name: m_in = pm.Input(in_d[1]) return True return False
def __init__(self, input_device_id, melodies, output_device_id=None): self.melodies = melodies self.midi_input = midi.Input(input_device_id) self.midi_output = None if output_device_id is not None: self.midi_output = midi.Output(output_device_id, buffer_size=8, latency=1) self.pitches = {} self.continue_processing = True
def input_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[2]): id = a if (self.mode != "live"): id = a + 1 return midi.Input(id) return False
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 _input_device(self, device_id: int): """ Create new Input object. Catches MidiException if no controller found or none configured. """ try: self._midi_active = True return midi.Input(device_id) except MidiException: self._midi_active = False self.close_controller() return None
def __init__(self): infos = [midi.get_device_info(n) for n in range(0, midi.get_count())] i = 0 o = 0 for (n, info) in enumerate(infos): if info[2] and "Launchpad" in info[1]: i = n elif info[3] and "Launchpad" in info[1]: o = n print "Detected Launchpad on input " + str(i) + " and output " + str(o) self.input = midi.Input(i) self.output = midi.Output(o) print "Connection established"
def __init__(self, midiin_id, midiout_id): self.midiin_id = midiin_id self.midiout_id = midiout_id pg.init() pg.fastevent.init() midi.init() self._screen = pg.display.set_mode(WINDOW_SIZE) self._clock = pg.time.Clock() self._midin = midi.Input(midiin_id) self._midout = midi.Output(midiout_id) self._font = pg.font.Font('freesansbold.ttf', 32) self.note = 0 self.render_text("")
def __init__(self, input, output, flash=True): midi.init() while not midi.get_init(): pass self._midiIn = midi.Input(input) self._midiOut = midi.Output(output) if flash: for i in (5, 3, 1, 0): for j in range(64): self._midiOut.note_on(j, i) time.sleep(0.01)
def __init__(self, Input=1, Output=3, PadConfig={}, bypassexit=False): try: midi.init() self.In = midi.Input(Input, 1024) self.Out = midi.Output(Output, 1024) except: PrintError("Midi Pad not found") if not bypassexit: PrintError("Exiting program") exit() else: PrintWithTime("Connected Midi Pad") self.Pad = PadConfig
def init(self): pg.init() pgm.init() pg.fastevent.init() self.event_get = pg.fastevent.get self.event_post = pg.fastevent.post # print_device_info() print(f'Available resolutions: {pg.display.list_modes()}') if not self.midi_input_id: self.midi_input_id = detect_input_device() if not self.midi_output_id: self.midi_output_id = detect_output_device() self.midi_in = pgm.Input(self.midi_input_id) self.midi_out = pgm.Output(self.midi_output_id) infoObject = pg.display.Info() self.w = infoObject.current_w self.h = infoObject.current_h # FULLSCREEN has this problem: https://github.com/pygame/pygame/issues/2538 # Using the workaround there. self.screen = pg.display.set_mode([0, 0], pg.NOFRAME | pg.DOUBLEBUF | pg.HWSURFACE) # pg.display.toggle_fullscreen() pprint(self.screen) pg.display.set_caption('Velocity Visualizer') icon = pg.image.load(os.path.dirname(__file__) + '/piano.png') pg.display.set_icon(icon) self.w = self.screen.get_width() self.h = self.screen.get_height() # print(f"{w} x {h}") self.hm = self.w * HORIZONTAL_MARGIN self.vm = self.h * VERTICAL_MARGIN print(int(self.w - self.hm * 2), int(self.h - self.vm * 2)) self.roll = pg.Surface( (int(self.w - self.hm * 2), int(self.h - self.vm * 2))) self.roll.fill((0, 0, 0)) self.roll_tick = 0 self.reset_midi_out() self.initialized = True return self
def getMidi(self): midIn = m.Input(m.get_default_input_id()) while not midIn.poll() and self.running: if not m.get_init(): m.init() else: pass if not self.running: return event = midIn.read(1) mob = mObject(event[0][0][0] >> 4, event[0][0][1], event[0][0][2]) midIn.close() return mob
def selectInput(): index = 0 midi_input = None while 1: description = midi.get_device_info(index) if description != None: if description[3] == 0: # it's a midi output print("%i %s"%(index, description[1])) index += 1 else: break txt = input("Select a midi input device") if txt != "": midi_input = midi.Input(int(txt)) return midi_input
def __init__(self): midi.init() try: if (midi.get_count() < 1): logger.error("no MIDI device connected") sys.exit(-1) except SystemExit: raise except: logger.error("MIDI not available") sys.exit(-2) self.name = midi.get_device_info(0)[1] self.input_stream = midi.Input(0, 16) self.output_stream = midi.Output(1, 128)
def run(self): midi.init() i = [ i for i in range(midi.get_count()) if self._name in midi.get_device_info(i)[1] ][0] i = midi.Input(i) while not self._halt: e = i.read(1) if len(e): e = e[0][0] if e[2] and (36 <= e[1] <= 84): #print(e[1]) self._on_note(music.midi_note(e[1])) else: sleep(.001) i = None
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 open(self, device_name=DEFAULT_DRIVER_NAME): try: for index, device in enumerate(self.devices): (interface, name, is_input, is_output, is_opened) = device if name.decode("utf-8") == device_name: if is_input: self.input = midi.Input(index) if is_output: self.output = midi.Output(index) if self.input and self.output: break if self.input is None or self.output is None: raise Exception(f'{device_name} does not exist.\nAvailable devices: {[x[1] for x in self.devices]}') self.get_config() except Exception as e: self._end() raise e
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 connect_midi(): global default_midi_input midi_in = None while midi_in == None: try: midi_in = midi.Input(int(default_midi_input), 1024) print("Connected to default midi device") return midi_in except Exception as e: print(f"Connection to default midi device failed. Error: {e}") print("Choose a device (num) or manual mode (m)") for i in range(midi.get_count()): info = midi.get_device_info(i) if info[2]: print(i, info) default_midi_input = input("->") if default_midi_input == "m": return False