Python midi.get_count函数代码示例

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 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 __init__(self):

        self.devIn = None
        self.devOut = None

        midi.init()

        # TODO: this sucks...
        try:
            midi.get_count()
        except:
            print("ERROR: MIDI not available...")

	def get_device(self, dev_name):
		for i in xrange(0, midi.get_count()):
			name = midi.get_device_info(i)[1]
			print midi.get_device_info(i)
			if name == dev_name:
				if midi.get_device_info(i)[3]: #Checking if output device
					return midi.Output(i)

def getInputDevices():
    for i in xrange(midi.get_count()):
        info = midi.get_device_info(i)
        (unusedInterface, name, isInput,
         unusedIsOutput, unusedOpened) = info
        if isInput:
            yield i, name

    def getMIDIDevices(self):
        midiOutputDevices = []
        midiInputDevices = []
        for index in xrange(0, midi.get_count()):
            device = midi.get_device_info(index)
            deviceName = device[1]
            if device[3] == 1 and device[4] == 0: #if the device is an output and not opened
                setattr(self, deviceName, QtGui.QAction(QtGui.QIcon(''), deviceName, self))
                deviceWidget = getattr(self, deviceName)
                deviceWidget.setCheckable(True)
                midiOutputDevices.append(deviceWidget)
                self.midiOutputDevicesDict[deviceWidget] = index
            elif device[2] == 1 and device[4] == 0: #if devices is an input and not opened
                deviceName = device[1]
                setattr(self, deviceName, QtGui.QAction(QtGui.QIcon(''), deviceName, self))
                deviceWidget = getattr(self, deviceName)
                deviceWidget.setCheckable(True)
                midiInputDevices.append(deviceWidget)
                self.midiInputDevicesDict[deviceWidget] = index
                
        if midiOutputDevices:
            self.ui.midiOutputDevicesMenu = self.ui.menubar.addMenu("&Midi Output Device")
            self.ui.midiOutputDevicesMenu.addActions(midiOutputDevices)
        if midiInputDevices:
            self.ui.midiInputDevicesMenu = self.ui.menubar.addMenu("&Midi Input Devices")
            self.ui.midiInputDevicesMenu.addActions(midiInputDevices)
        
        for device in midiOutputDevices:
            outputFunction = partial(self.windowHandler.midiOutputSelect, mainWindowInstance=self, device=device)
            device.triggered.connect(outputFunction)

        for device in midiInputDevices:
            inputFunction = partial(self.windowHandler.midiInputSelect, mainWindowInstance=self, device=device)
            device.triggered.connect(inputFunction)

 def __getDeviceId(self, midiport):
     n_device = pm.get_count()
     foundId = -1
     for id in range(n_device):
         if int(pm.get_device_info(id)[1] == midiport) & \
                 int(pm.get_device_info(id)[3] == 1):
             foundId = id
     return foundId

 def get_info(self):
     l = []
     for x in range(pm.get_count()):
         l.append(pm.get_device_info(x))
         #dev = DeviceInfo(Index=x, info=pm.get_device_info(x))
         #self.dev_info[dev.type].add_child(existing_object=dev)
         #dev.bind(active=self.on_dev_info_active_set)
     return l

	def createInterfaces(self):
		"""
		creates all midi interfaces available as devices
		@todo: sort in- and output of one hardware
		"""
		n = midi.get_count()
		for i in xrange(n/2):
			info = midi.get_device_info(i*2)
			newIf = Interface(info[1], i*2-1, i*2)

 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 GetPorts(self):
     i = {}
     o = {}
     for j in range(pm.get_count()):
         s,name,ins,outs,throughs = pm.get_device_info(j)
         if ins > 0:
             i[name] = j
         if outs > 0:
             o[name] = j
     return (i,o)

 def list_devices(self):
     for i in range(pm.get_count()):
         r = pm.get_device_info(i)
         (interf, name, input, output, opened) = r
         in_out = ""
         if input:
             in_out = "(input)"
         if output:
             in_out = "(output)"
         print ("%2i: interface :%s:, name :%s:, opened :%s: %s" % (i, interf, name, opened, in_out))

def get_devices(name):
    id_in, id_out = None, None
    for i in range(midi.get_count()):
        info = midi.get_device_info(i)
        if info[1] == name:
            if info[2]:
                id_in = i
            elif info[3]:
                id_out = i
    return id_in, id_out

def create_initial_data(mox):
    pin = {}
    pout = {}
    for i in xrange(pym.get_count()):
        info = pym.get_device_info(i)
        name = info[1]
        if info[2]:
            pin[name] = i
        if info[3]:
            pout[name] = i
    
    return {"ports_in": pin, "ports_out": pout}

    def get_devices():
        """Get a list of all MIDI output devices connected to the system."""

        if _midi is None:
            return
        outdevices = []
        all_ids = _midi.get_count()
        for device_id in all_ids:
            info = _midi.get_device_info(device_id)
            if info[3] == 1:
                outdevices.add([device_id, info[1]])
        return outdevices