Python mido.open_output函数代码示例

 def __new__(cls, port_name=None):
     """Open a named port."""
     if MidiPort.__instance is None:
         if port_name is not None:
             MidiPort.__instance = mido.open_output(port_name)
         else:
             MidiPort.__instance = mido.open_output()
     return MidiPort.__instance

    def __init__(self, input=None, output=None):
        if input is None:
            try:
                input = mido.open_input('Launchpad S', callback=True)
            except IOError:
                input = mido.open_input('Launchpad S MIDI 1', callback=True)
        if output is None:
            try:
                output = mido.open_output('Launchpad S')
            except IOError:
                output = mido.open_output('Launchpad S MIDI 1')

        super(LaunchpadS, self).__init__(input, output)

    def __init__(self, target=MIDIOUT_DEFAULT):
        self.midi = None
        self.debug = False
        ports = mido.get_output_names()
        if len(ports) == 0:
            raise Exception("No MIDI output ports found")

        for name in ports:
            if name == target:
                isobar.log("Found MIDI output (%s)" % name)
                self.midi = mido.open_output(name)

        if self.midi is None:
            print "Could not find MIDI target %s, using default" % target
            self.midi = mido.open_output()

  def __init__(self, input_midi_port, output_midi_port, texture_type,
               passthrough=True):
    self._texture_type = texture_type
    self._passthrough = passthrough
    # When `passthrough` is True, this is the set of open MIDI note pitches.
    self._open_notes = set()
    # This lock is used by the serialized decorator.
    self._lock = threading.RLock()
    # A dictionary mapping a string-formatted mido.Messages to a condition
    # variable that will be notified when a matching messsage is received,
    # ignoring the time field.
    self._signals = {}
    # A dictionary mapping integer control numbers to most recently-received
    # integer value.
    self._control_values = {}
    # Threads actively being used to capture incoming messages.
    self._captors = []
    # Potentially active player threads.
    self._players = []
    self._metronome = None

    # Open MIDI ports.
    self._inport = (
        input_midi_port if isinstance(input_midi_port, mido.ports.BaseInput)
        else mido.open_input(
            input_midi_port,
            virtual=input_midi_port not in get_available_input_ports()))
    self._outport = (
        output_midi_port if isinstance(output_midi_port, mido.ports.BaseOutput)
        else mido.open_output(
            output_midi_port,
            virtual=output_midi_port not in get_available_output_ports()))

    # Start processing incoming messages.
    self._inport.callback = self._timestamp_and_handle_message

def Run(fi, minnote=21, maxnote=108, forcelowest=False, minvelocity=64, maxvelocity=115, timingdivisor=127, shortestnoteon=0.00390625, step=3, mono=True, microgranny=True, sendCC=True, sendsamplechange=True, loop=False):

    if minnote < 0:
        print("Negative minimum note")
        minnote = 0
        
    if maxnote >127:
        print("Maximum note too high")
        maxnote = 127

    if maxnote < minnote or minnote > maxnote:
        print("Maxnote and minnote swapped")
        hold = maxnote
        maxnote = minnote
        minnote = hold

    ##open file as a byte array
    with open(fi, "rb") as inFile:
        f = inFile.read()
        b = bytearray(f)

    ##send midi
    with mido.open_output() as o:
        if(loop):
            while True:
                print("looping")
                Play(o, b,minnote,maxnote, forcelowest, minvelocity, maxvelocity, timingdivisor,shortestnoteon,step,mono,microgranny,sendCC,sendsamplechange)
                
        else:
            Play(o, b,minnote,maxnote,forcelowest, minvelocity, maxvelocity,timingdivisor,shortestnoteon,step,mono,microgranny,sendCC,sendsamplechange)

def Run():
    global mt
    global nvalue
    global pnvalue
    
    with mido.open_output(autoreset = True) as o:
        with mido.open_input() as i:
            while True:
                for message in i:
                    if message.type == 'control_change':## and not message.control == 13:
                        print("in : " + str(message))
                        Translate(message,o)
                        
                    if 'note' in mt:
                        if not pnvalue == nvalue:
                            mo = mido.Message(mt,note = nvalue, velocity = 100)
                            print("out : " + str(mo))
                            o.send(mo)
                            pnvalue = nvalue
                        ##microgranny tends not to respond to off or time, or anything it doesn't like
                        if 'off'in mt:
                            mt = ''
                            o.send(mido.Message('note_off',note = pnvalue))
                            o.send(mido.Message('note_off',note=nvalue))
                            print("out : note_off")
                            o.reset()
                            o.panic()
                            ManualPanic(o)

    def open_output(self):
        if self.backend == 'mido':
            if self.debug>0:
                print('------ OUTPUT ------')
                for port in mido.get_output_names():
                  print(port)
                print('-------------------------')
            try:
                self.outputport  = mido.open_output(self.config.get('midi', 'device'))
                print "Connected to MIDI output"
            except:
                print "Error: cannot connect to MIDI output"
                raise RuntimeError("Error: cannot connect to MIDI output")

        elif self.backend == 'midiosc':
            try:
                self.outputport = OSC.OSCClient()
                self.outputport.connect((self.config.get('midi','hostname'), self.config.getint('midi','port')))
                print "Connected to OSC server"
            except:
                print "Error: cannot connect to OSC server"
                raise RuntimeErrror("cannot connect to OSC server")

        else:
            print 'Error: unsupported backend: ' + self.backend
            raise RuntimeError('unsupported backend: ' + self.backend)

def main():
    output_name = ''
    input_name = ''
    device_names = mido.get_input_names()
    for device_name in device_names:
        # FIXME: Heuristic to get our USB stick device
        if '-' in device_name and 'Through' not in device_name:
            output_name = device_name
            break
    else:
        print "No appropriate MIDI device. MIDI device names: ", device_names
        return

    print "Connected devices: ", device_names
    print "Opening device: ", output_name

    # or, with mido.open_ioport(output_name) as iop:
    with mido.open_output(output_name) as output:
        with mido.open_input(output_name, callback=print_message) as inp:
            #msg = mido.Message('sysex', data=[10]) Set type to digital output
            #msg = mido.Message('sysex', data=[101]) # send watchdog timer reset
            #msg = mido.Message('sysex', data=[99]) # Request device type
            msg = mido.Message('sysex', data=[77]) # Request device name
            #msg = mido.Message('sysex', data=[54,1,2,3,4]) # Set device name to '0x010203'
            #msg = mido.Message('note_on')
            print "sending msg: ", msg
            output.send(msg);
            print "waiting for response message"
            time.sleep(1) # Pause while we get MIDO callback print-outs
    print "script done"

    def __init__(self, _save_path, songfile, _plyr_ctrls):
        super(PlayerThread, self).__init__()
        self.name = 'Player'
        self.stoprequest = threading.Event()
        self.plyr_ctrls = _plyr_ctrls
        self.chan_roles = [0 for i in range(10)]
        self.plyr_ctrls['songfile'] = songfile
        self.midifile = MidiFile(_save_path + songfile)
        # 0 - drum fill
        self.counter = [0 for i in range(4)]
        self.wt = WolfTonesSong()
        self.save_path = _save_path
        self.load_song(songfile)
        self.alt_meas = []

        #get the portname (system specific)
        env = socket.gethostname()
        if(env == 'record_synth'):
            names = str(mido.get_output_names())
            ports = names.split(',')
            sobj = re.search(r'Synth input port \(\d*:0\)', ports[0], flags=0)
            portname = sobj.group()
        if(env == 'colinsullivan.me'):
            #dummy port for testing on a headless server with no audio
            portname = 'Midi Through:Midi Through Port-0 14:0'
        self.outport = mido.open_output(portname, autoreset=True)

    def __init__(self, loop, scale, bpm=120, midi_port=u"TiMidity port 0", midi_chan=1):
        self.loop = loop
        self.scale = scale
        self.bpm = 60 / bpm
        self.start = True

        # initialize midi output
        self.midi_output = mido.open_output(midi_port)
        self.midi_output.send(mido.Message("program_change", program=midi_chan))

 def __init__(self, input_midi_port, output_midi_port):
   self._inport = mido.open_input(input_midi_port)
   self._outport = mido.open_output(output_midi_port)
   # This lock is used by the serialized decorator.
   self._lock = threading.RLock()
   self._control_cvs = dict()
   self._player = None
   self._capture_start_time = None
   self._sequence_start_time = None

 def __init__(self):
     QtGui.QWidget.__init__(self)
     try:
         self.output = mido.open_output(self.outputPort)
     except IOError:
         print ("sorry; couldn't setup MIDI player")
         print ("perhapsoverruling outputPort (currently {0} will help".format(self.outputPort))
         self.output = None
     dbg_print('MidiPlayer:__init__', self.output)

    def __init__(self, input=None, output=None):
        if input is None:
            try:
                input = mido.open_input(
                    'Ableton Push User Port',
                    callback=True)
            except IOError:
                input = mido.open_input('Ableton Push MIDI 2', callback=True)
        if output is None:
            try:
                output = mido.open_output('Ableton Push User Port')
            except IOError:
                output = mido.open_output('Ableton Push MIDI 2')

        self.lights = lights((8, 8))
        self.buttons = buttons((8, 8))

        super(Push, self).__init__(input, output)

    def __init__(self, daemonize=False, buflen=80):
        self.scrollwheel = 0
        self.buflen = buflen
        self.lines = collections.deque([''] * self.buflen)
        self.lock = threading.Lock()

        try:
            # Ports on MAC OSX
            self.output = mido.open_output('Ableton Push User Port')
            self.input = mido.open_input('Ableton Push User Port',
                                         callback=self.callback)
        except IOError:
            # Ports on Arch Linux
            self.output = mido.open_output('Ableton Push MIDI 2')
            self.input = mido.open_input('Ableton Push MIDI 2',
                                         callback=self.callback)

        while True:
            line = sys.stdin.readline()
            if not line:
                # EOF from STDIN
                break

            # We need to use mutex because concurrent reads and writes on
            # dequeue (scrolling while there is new text coming in from stdin)
            # will issue warnings.
            self.lock.acquire()
            self.lines.append(line)
            self.lines.popleft()
            self.lock.release()
            self.redraw()

        # Do not quit process if running daemonized
        # This enables scrolling for one-show piping to Push
        #
        # e.g. ping www.google.de | pushcat is scrollable as long as ping runs
        # ls | pushcat is not scrollable as ls immediately terminates
        # ls | pushcat -d enables scrolling
        if daemonize:
            while True:
                try:
                    time.sleep(0.1)
                except KeyboardInterrupt:
                    sys.exit(0)

def say(message, times = 1):
    message = message + " "
    with mido.open_output(CONTROLLER) as output:
        print("saying \"{}\"".format(message))
        delay = lambda: sleep(0.25)
        for i in range(0,times):
            for frame in text_to_bitmap(message):
                send_lights_to_output(frame, output)
                delay()
            delay()