internal static async Task <RawMidiClient> CreateAsync(MidiInputDevice inputDevice, MidiOutputDevice outputDevice, Action <RawMidiMessage> messageHandler)
{
var input = await MidiAccessManager.Default.OpenInputAsync(inputDevice.SystemDeviceId);
var output = await MidiAccessManager.Default.OpenOutputAsync(outputDevice.SystemDeviceId);
return(new RawMidiClient(input, output, messageHandler));
}
public static async Task <RolandMidiClient> CreateRolandMidiClientAsync(MidiInputDevice inputDevice, MidiOutputDevice outputDevice, DeviceIdentity deviceIdentity, ModuleIdentifier identifier)
{
var input = await Manager.OpenInputAsync(inputDevice);
var output = await Manager.OpenOutputAsync(outputDevice);
return(new RolandMidiClient(input, output, inputDevice.Name, outputDevice.Name, deviceIdentity.RawDeviceId, identifier));
}
public void StartMidi()
{
_inDevice = new MidiInputDevice(this.cmbMidi.SelectedIndex);
_inDevice.MessageFilter = BuildFilter();
_inDevice.MessageReceived += new MidiMessageEventHandler(InDevice_MessageRecieved);
_inDevice.Open();
_inDevice.Start();
}
public void RefreshDevices()
{
if (MidiInputDevice.GetDeviceCount() == 0)
{
return;
}
this.midiInDevices = MidiInputDevice.GetDeviceDescriptions().ToList();
}
internal static async Task <RawMidiClient> CreateAsync(MidiInputDevice inputDevice, MidiOutputDevice outputDevice, Action <RawMidiMessage> messageHandler)
{
// TODO: Retry this; sometimes it doesn't work first time.
var input = await OpenInput(inputDevice.SystemDeviceId);
var output = await MidiAccessManager.Default.OpenOutputAsync(outputDevice.SystemDeviceId);
return(new RawMidiClient(input, inputDevice.Name, output, outputDevice.Name, messageHandler));
}
//-------------------------------------------Midi Functionality------------------------
public void InitializeMidi()
{
int[] inPorts = MidiInputDevice.GetMidiPorts();
foreach (int port in inPorts)
{
string name = MidiInputDevice.GetDeviceDescription(port);
this.cmbMidi.Items.Add(name);
}
}
private void InputsComboBox_SelectedIndexChanged(object sender, EventArgs e)
{
if (null != _device)
{
_device.Close();
}
_device = InputsComboBox.SelectedItem as MidiInputDevice;
_device.Input += device_Input;
_device.Open();
_device.Start();
}
public IMidiInputDevice GetMidiEndpoint(MidiInputDevice device)
{
foreach (var inputDevice in MidiDeviceManager.Default.InputDevices)
{
if (inputDevice.Name == device.Name)
{
return(inputDevice.CreateDevice());
}
}
return(null);
}
public void PatchPluginToMidiInput(Guid guid, MidiInputDevice device)
{
var plugin = GetPluginByGuid(guid);
try
{
_vstHost.PatchPluginToMidiInput(plugin, device);
}
catch (Exception e)
{
throw GetFaultException <GenericFault>(e);
}
}
internal static async Task <RolandMidiClient> CreateAsync(MidiInputDevice inputDevice, MidiOutputDevice outputDevice, byte rawDeviceId, int modelId)
{
// This is all a bit nasty... we can't create a RolandMidiClient instance until we have the raw client, and we can't
// create the raw client until we've got a method to call. LocalHandleMessage acts as a sort of trampoline.
// If we could make the constructor asynchronous, it wouldn't be a problem.
RolandMidiClient ret = null;
var rawClient = await RawMidiClient.CreateAsync(inputDevice, outputDevice, LocalHandleMessage);
ret = new RolandMidiClient(rawClient, rawDeviceId, modelId);
return(ret);
void LocalHandleMessage(RawMidiMessage message) => ret?.HandleMessage(message);
}
public NanoKontrol2(string midiDeviceName = "nanoKONTROL2")
{
Slider = new ControlStateCollection("Slider", _Slider);
Knob = new ControlStateCollection("Knob", _Knob);
Solo = new ButtonStateCollection(this, ButtonCategory.Solo, _Solo);
Mute = new ButtonStateCollection(this, ButtonCategory.Mute, _Mute);
Record = new ButtonStateCollection(this, ButtonCategory.Record, _Record);
Input = MidiInputDevice.OpenByName(midiDeviceName);
Output = MidiOutputDevice.OpenByName(midiDeviceName);
Input.OnData += Input_OnData;
}
private void MidiInComboBox_SelectedIndexChanged(object sender, System.EventArgs e)
{
if (null != _inputDevice)
{
_inputDevice.Close();
}
_inputDevice = MidiInComboBox.SelectedItem as MidiInputDevice;
if (null != _inputDevice)
{
_inputDevice.Input += _inputDevice_Input;
}
_inputDevice.Open();
_inputDevice.Start();
}
public MidiInputDeviceTests(ITestOutputHelper output) : base(output)
{
_inputDeviceMock = new RtMidiInputDeviceMock();
_sut = new MidiInputDevice(_inputDeviceMock, string.Empty);
_sut.NoteOff += (IMidiInputDevice sender, in NoteOffMessage e) => _noteOffMessages.Enqueue(e);
_sut.NoteOn += (IMidiInputDevice sender, in NoteOnMessage e) => _noteOnMessages.Enqueue(e);
_sut.PolyphonicKeyPressure += (IMidiInputDevice sender, in PolyphonicKeyPressureMessage e) => _polyphonicKeyPressureMessages.Enqueue(e);
_sut.ControlChange += (IMidiInputDevice sender, in ControlChangeMessage e) => _controlChangeMessages.Enqueue(e);
_sut.ProgramChange += (IMidiInputDevice sender, in ProgramChangeMessage e) => _programChangeMessages.Enqueue(e);
_sut.ChannelPressure += (IMidiInputDevice sender, in ChannelPressureMessage e) => _channelPressureMessages.Enqueue(e);
_sut.PitchBend += (IMidiInputDevice sender, in PitchBendMessage e) => _pitchBendMessages.Enqueue(e);
_sut.Nrpn += (IMidiInputDevice sender, in NrpnMessage e) => _nrpnMessages.Enqueue(e);
}
public void PatchPluginToMidiInput(RemoteVstPlugin plugin, MidiInputDevice device)
{
_midiTarget = plugin;
var midiService = new MidiService();
var midiInput = midiService.GetMidiEndpoint(device);
if (midiInput == null)
{
throw new Exception(
$"Unable to open MIDI device {device.Name} because the device (currently) doesn't exists");
}
midiInput.NoteOn += MidiInputOnNoteOn;
midiInput.NoteOff += MidiInputOnNoteOff;
midiInput.Open();
_midiInputDevices.Add(midiInput);
}
public MidiDevices()
{
InitializeComponent();
int[] inPorts = MidiInputDevice.GetMidiPorts();
foreach (int port in inPorts)
{
string name = MidiInputDevice.GetDeviceDescription(port);
Console.WriteLine("Input : {0}={1}", port, name);
this.comboBox1.Items.Add(name);
}
int[] outPorts = MidiOutputDevice.GetMidiPorts();
foreach (int port in outPorts)
{
string name = MidiOutputDevice.GetDeviceDescription(port);
Console.WriteLine("Output : {0}={1}", port, name);
}
}
protected override void OnClosed(EventArgs e)
{
base.OnClosed(e);
if (null != _inputDevice && _inputDevice.IsOpen)
{
// attempt to prevent any further
// events from firing
_inputDevice.Stop();
_inputDevice.Reset();
_inputDevice.Close();
_inputDevice = null;
}
if (null != _outputDevice && _outputDevice.IsOpen)
{
_outputDevice.Close();
_outputDevice = null;
}
}
public MidiInputDeviceTests(ITestOutputHelper output) : base(output)
{
_inputDeviceMock = new RtMidiInputDeviceMock();
_sut = new MidiInputDevice(_inputDeviceMock, string.Empty);
_sut.NoteOff += (IMidiInputDevice sender, in NoteOffMessage e) => _noteOffMessages.Enqueue(e);
_sut.NoteOn += (IMidiInputDevice sender, in NoteOnMessage e) => _noteOnMessages.Enqueue(e);
_sut.PolyphonicKeyPressure += (IMidiInputDevice sender, in PolyphonicKeyPressureMessage e) => _polyphonicKeyPressureMessages.Enqueue(e);
_sut.ControlChange += (IMidiInputDevice sender, in ControlChangeMessage e) => _controlChangeMessages.Enqueue(e);
_sut.ProgramChange += (IMidiInputDevice sender, in ProgramChangeMessage e) => _programChangeMessages.Enqueue(e);
_sut.ChannelPressure += (IMidiInputDevice sender, in ChannelPressureMessage e) => _channelPressureMessages.Enqueue(e);
_sut.PitchBend += (IMidiInputDevice sender, in PitchBendMessage e) => _pitchBendMessages.Enqueue(e);
_sut.Nrpn += (IMidiInputDevice sender, in NrpnMessage e) => _nrpnMessages.Enqueue(e);
_sut.SysEx += (IMidiInputDevice sender, in SysExMessage e) => _sysExMessages.Enqueue(e);
_sut.MidiTimeCodeQuarterFrame += (IMidiInputDevice sender, in MidiTimeCodeQuarterFrameMessage e) => _midiTimeCodeQuarterFrameMessages.Enqueue(e);
_sut.SongPositionPointer += (IMidiInputDevice sender, in SongPositionPointerMessage e) => _songPositionPointerMessages.Enqueue(e);
_sut.SongSelect += (IMidiInputDevice sender, in SongSelectMessage e) => _songSelectMessages.Enqueue(e);
_sut.TuneRequest += (IMidiInputDevice sender, in TuneRequestMessage e) => _tuneRequestMessages.Enqueue(e);
}
private void StartDevice(int deviceID)
{
this.textBoxMsg.Clear();
_inDevice = new MidiInputDevice(deviceID);
_inDevice.AutoPairController = this.checkBoxAutoPair.Checked;
_inDevice.MessageFilter = BuildFilter();
_inDevice.MessageReceived += new MidiMessageEventHandler(InDevice_MessageReceived);
if (_inDevice.Open())
{
this.buttonStop.Enabled = true;
this.buttonStart.Enabled = false;
if (!_inDevice.Start())
{
MessageBox.Show(this, "Midi device could not be started! Error " + _inDevice.LastErrorCode.ToString(), "Midi Error");
}
}
else
{
MessageBox.Show(this, "Midi device could not be opened! Error " + _inDevice.LastErrorCode.ToString(), "Midi Error");
}
}
private MidiOutputDevice OpenDevice(int indevice, int outdevice)
{
buttons = Helper.GetButtons();
_outDevice = new MidiOutputDevice(indevice);
_inDevice = new MidiInputDevice(outdevice);
if (!_outDevice.Open())
{
throw new Exception("Midi Open Error");
}
else
{
isReady = true;
}
if (!_inDevice.Open())
{
throw new Exception("Midi Open Error " + _inDevice.LastErrorCode.ToString() + _inDevice.Device);
}
else
{
isReady = true;
}
return(_outDevice);
}
private void SetCurrentDevice(string value)
{
if (this.currentMidiInDevice != null)
{
this.midiIn.Stop();
this.midiIn.Close();
this.midiIn.MessageReceived -= this.OnMidiMessageReceived;
}
this.currentMidiInDevice = value;
int index = this.midiInDevices.IndexOf(value);
this.midiIn = new MidiInputDevice(index);
this.midiIn.AutoPairController = true;
this.midiIn.MessageFilter = MIDIMessageType.SystemRealtime | MIDIMessageType.SystemExclusive;
this.midiIn.MessageReceived += this.OnMidiMessageReceived;
string error = null;
if (this.midiIn.Open())
{
if (!this.midiIn.Start())
{
error = this.midiIn.LastErrorCode.ToString();
}
}
else
{
error = this.midiIn.LastErrorCode.ToString();
}
if (error != null)
{
this.AddMessageToMonitor("Midi device could not be started! Error: " + error);
}
}
public static Task <RolandMidiClient> CreateRolandMidiClientAsync(MidiInputDevice input, MidiOutputDevice output, DeviceIdentity deviceIdentity, ModuleIdentifier identifier) => RolandMidiClient.CreateAsync(input, output, deviceIdentity.RawDeviceId, identifier);
internal MidiMessageBroker(MidiInputDevice sender, BitArray channelListeners)
{
_sender = sender;
_channelListeners = channelListeners;
}
public void PatchPluginToMidiInput(Guid guid, MidiInputDevice device)
{
}
public static async Task <IReadOnlyList <DeviceIdentity> > ListDeviceIdentities(MidiInputDevice input, MidiOutputDevice output, TimeSpan timeout)
{
List <DeviceIdentity> identities = new List <DeviceIdentity>();
using (var client = await RawMidiClient.CreateAsync(input, output, HandleMessage))
{
// Identity request message for all devices IDs.
client.Send(new RawMidiMessage(new byte[] { 0xf0, 0x7e, 0x7f, 0x06, 0x01, 0xf7 }));
await Task.Delay(timeout);
}
return(identities.AsReadOnly());
void HandleMessage(RawMidiMessage message)
{
// TODO: Handle 17-byte messages for "long" manufacturer IDs
var data = message.Data;
if (data.Length == 15 &&
data[0] == 0xf0 && // SysEx
data[1] == 0x7e && // Universal non-realtime message
data[3] == 0x06 && // General information
data[4] == 0x02) // Identity reply
{
byte rawDeviceId = data[2];
var manufacturerId = (ManufacturerId)data[5];
int familyCode = data[6] + (data[7] << 8);
int familyNumberCode = data[8] + (data[9] << 8);
int revision = data[10] + (data[11] << 8) + (data[12] << 16) + (data[13] << 24);
identities.Add(new DeviceIdentity(rawDeviceId, manufacturerId, familyCode, familyNumberCode, revision));
}
}
}
public static Task <RolandMidiClient> CreateRolandMidiClientAsync(MidiInputDevice input, MidiOutputDevice output, DeviceIdentity deviceIdentity, int modelId) => RolandMidiClient.CreateAsync(input, output, deviceIdentity.RawDeviceId, modelId);
public Task <IMidiInput> OpenInputAsync(MidiInputDevice input) => Task.FromResult((IMidiInput) new WebMidiInput(inputs[input]));
public void PatchPluginToMidiInput(MidiInputDevice device)
{
_remoteVstService.PatchPluginToMidiInput(_guid, device);
}
