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 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_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)