private static bool SetMute(MidiConfiguration midiConfig, MidiControlChangeMessage msg, bool oldMute)
{
var newMute = oldMute;
if (midiConfig.ControllerType == ControllerTypes.LinearPotentiometer)
{
var calcVolume = Current.CalculateVolume(msg.ControlValue, midiConfig.MinValue, midiConfig.MaxValue,
midiConfig.ScalingValue);
newMute = calcVolume < 50;
}
else if (midiConfig.ControllerType == ControllerTypes.Button)
{
if (msg.ControlValue == midiConfig.MaxValue)
{
newMute = !newMute;
}
}
else if (midiConfig.ControllerType == ControllerTypes.RotaryEncoder)
{
if (msg.ControlValue == midiConfig.MaxValue)
{
newMute = false;
}
else
{
newMute = true;
}
}
return(newMute);
}
// Handler for all Sliders ValueChanged events
private void Slider_ValueChanged(object sender, RangeBaseValueChangedEventArgs e)
{
// If we're using the App keyboard, and have an output, send the correct messages
if (!hasMidiInputSelected && midiOutPort != null)
{
MidiControlChangeMessage mccmsg = null;
MidiPitchBendChangeMessage mpcmsg = null;
if (sender == SliderPitch)
{
mpcmsg = new MidiPitchBendChangeMessage(0, (ushort)e.NewValue);
}
else if (sender == SliderMod)
{
mccmsg = new MidiControlChangeMessage(0, 1, (byte)e.NewValue);
}
else if (sender == SliderPan)
{
mccmsg = new MidiControlChangeMessage(0, 10, (byte)e.NewValue);
}
else if (sender == SliderVolume)
{
mccmsg = new MidiControlChangeMessage(0, 7, (byte)e.NewValue);
}
if (mccmsg != null)
{
midiOutPort.SendMessage(mccmsg);
}
else if (mpcmsg != null)
{
midiOutPort.SendMessage(mpcmsg);
}
}
}
private void DefaultDevice(CommandControlMappingElement command, MidiControlChangeMessage msg)
{
var config = (MidiConfiguration)command.hardwareConfiguration;
var calcVolume = Current.CalculateVolume(msg.ControlValue, config.MinValue, config.MaxValue, config.ScalingValue);
if (calcVolume > 50)
{
foreach (var device in _audioDeviceManager.Devices)
{
if (device.DisplayName == command.audioDevice)
{
try
{
_audioDeviceManager.Default = device;
}
catch (NotSupportedException)
{
}
return;
}
}
}
}
/// <summary>
/// Updates the state of a top button
/// </summary>
/// <param name="changeMessage"></param>
void UpdateTopButton(MidiControlChangeMessage changeMessage)
{
Debug.WriteLine($"Top Button Ch:{changeMessage.Channel}, ID:{changeMessage.Controller}, Velocity:{changeMessage.ControlValue}");
try
{
// Get a reference to the button
var topButton = topButtons.FirstOrDefault(button => button.Id == changeMessage.Controller);
// If the top button could not be found (should never happen), return
if (topButton == null)
{
return;
}
// Update its state
topButton.State = changeMessage.ControlValue > 0
? LaunchpadButtonState.Pressed
: LaunchpadButtonState.Released;
// Notify people interested in this event
whenButtonStateChanged.OnNext(topButton);
}
catch (Exception ex)
{
Debug.WriteLine($"Could not update top button. {ex}");
}
}
public void When_RawData()
{
var message = new MidiControlChangeMessage(9, 114, 64);
var data = message.RawData.ToArray();
CollectionAssert.AreEqual(new byte[] { 185, 114, 64 }, data);
}
void onMidiMessageReceived(object sender, MidiMessageBroker.MessageReceivedEventArgs e)
{
if (!_isActive)
{
return;
}
int channel = e.Channel.Number;
string note = String.Empty;
switch (e.Message.Type)
{
case MidiMessageType.ControlChange:
MidiControlChangeMessage ccMsg = e.Message as MidiControlChangeMessage;
note = String.Format("CC.{0:000}", ccMsg.ControlId);
break;
case MidiMessageType.NoteOff:
case MidiMessageType.NoteOn:
MidiNoteMessage noteMsg = e.Message as MidiNoteMessage;
note = "Note." + _keyConverter.GetKeyTextIPN(noteMsg.Key);
break;
case MidiMessageType.PitchBend:
note = "PitchBend";
break;
default:
return;
}
_lastSignal = new MidiSignal(channel, note);
notify();
}
// Buttons to set Pan to Left, Center, or Right
private void BtnPan_Click(object sender, RoutedEventArgs e)
{
if (!hasMidiInputSelected)
{
string content = ((Button)sender).Content as string;
byte value = 64;
switch (content)
{
case "L":
value = 0;
break;
case "R":
value = 127;
break;
default:
break;
}
SliderPan.Value = value;
if (midiOutPort != null)
{
MidiControlChangeMessage msg = new MidiControlChangeMessage(0, 10, value);
midiOutPort.SendMessage(msg);
}
}
}
private void ResetKnob(byte controller)
{
byte channel = 10; // Seems to always be channel 10 on the X-Touch Mini? TODO: If it isn't, fix this.
byte controlValue = KNOB_CENTER;
IMidiMessage midiMessageToSend = new MidiControlChangeMessage(channel, controller, controlValue);
midiOutPort.SendMessage(midiMessageToSend);
}
/// <summary>
/// A new MIDI message has been received.
/// </summary>
/// <param name="receivedMidiMessage">Received MIDI message as IMidiMessage object</param>
/// <param name="e">PropertyChangedEventArgs</param>
private async void MidiMessageReceived(object receivedMidiMessage, PropertyChangedEventArgs e)
{
await this.globalEventHandlerInstance.controllerDispatcher.RunAsync(
CoreDispatcherPriority.Normal, () =>
{
MidiControlChangeMessage currentMidiMessage = (MidiControlChangeMessage)receivedMidiMessage;
});
}
public void AllNotesOff(byte currentChannel)
{
if (midiOutPort != null)
{
IMidiMessage midiMessageToSend = new MidiControlChangeMessage(currentChannel, 0x78, 0);
midiOutPort.SendMessage(midiMessageToSend);
}
}
public void SetVolume(byte currentChannel, byte volume)
{
if (midiOutPort != null)
{
IMidiMessage midiMessageToSend = new MidiControlChangeMessage(currentChannel, 0x07, volume);
midiOutPort.SendMessage(midiMessageToSend);
}
}
public void SendControlChange(byte channel, byte controller, byte value)
{
if (midiOutPort != null)
{
IMidiMessage midiMessageToSend = new MidiControlChangeMessage(channel, controller, value);
midiOutPort.SendMessage(midiMessageToSend);
}
}
protected override void ProcessRecord()
{
if (ValidateCommonParameters())
{
var message = new MidiControlChangeMessage(Channel, Controller, Value);
Port.RawPort.SendMessage(message);
}
}
private void SystemMute(CommandControlMappingElement command, MidiControlChangeMessage msg)
{
var devices = GetDevicesByName(command.audioDevice);
foreach (var device in devices)
{
device.IsMuted = SetMute((MidiConfiguration)command.hardwareConfiguration, msg, device.IsMuted);
}
}
public MidiMessage[] GetSequence(uint channel, uint value)
{
var result = new MidiMessage[3];
result[0] = new MidiControlChangeMessage(channel, registered ? EMidiController.RpnMSB: EMidiController.NrpnMSB, number / 128);
result[1] = new MidiControlChangeMessage(channel, registered ? EMidiController.RpnLSB : EMidiController.NrpnLSB, number % 128);
result[2] = new MidiControlChangeMessage(channel, EMidiController.DataEntryMSB, value);
return(result);
}
protected override void ProcessRecord()
{
if (ValidateCommonParameters())
{
var message = new MidiControlChangeMessage(Channel, Controller, Value);
Port.RawPort.SendMessage(message);
}
}
public static void bankchangeme(int x, int bank)
{
byte channel = (byte)x;
byte controller = 0;
byte controlValue = (byte)bank;
byte prg = (byte)room[x].prg;
IMidiMessage midiMessageToSend = new MidiControlChangeMessage(channel, controller, controlValue);
IMidiMessage midiMessageToSend1 = new MidiProgramChangeMessage(channel, prg);
midiOutPort.SendMessage(midiMessageToSend);
midiOutPort.SendMessage(midiMessageToSend1);
}
public void ProgramChange(byte currentChannel, byte msb, byte lsb, byte pc)
{
try
{
MidiControlChangeMessage controlChangeMsb = new MidiControlChangeMessage(currentChannel, 0x00, msb);
MidiControlChangeMessage controlChangeLsb = new MidiControlChangeMessage(currentChannel, 0x20, lsb);
MidiProgramChangeMessage programChange = new MidiProgramChangeMessage(currentChannel, (byte)(pc - 1));
midiOutPort.SendMessage(controlChangeMsb);
midiOutPort.SendMessage(controlChangeLsb);
midiOutPort.SendMessage(programChange);
}
catch { }
}
public void ProgramChange(byte currentChannel, String smsb, String slsb, String spc)
{
try
{
MidiControlChangeMessage controlChangeMsb = new MidiControlChangeMessage(currentChannel, 0x00, (byte)(UInt16.Parse(smsb)));
MidiControlChangeMessage controlChangeLsb = new MidiControlChangeMessage(currentChannel, 0x20, (byte)(UInt16.Parse(slsb)));
MidiProgramChangeMessage programChange = new MidiProgramChangeMessage(currentChannel, (byte)(UInt16.Parse(spc) - 1));
midiOutPort.SendMessage(controlChangeMsb);
midiOutPort.SendMessage(controlChangeLsb);
midiOutPort.SendMessage(programChange);
}
catch { }
}
private static int SetVolume(MidiConfiguration midiConfig, MidiControlChangeMessage msg, int oldVolume)
{
var newVolume = oldVolume;
switch (midiConfig.ControllerType)
{
case ControllerTypes.LinearPotentiometer:
newVolume = Current.CalculateVolume(msg.ControlValue, midiConfig.MinValue, midiConfig.MaxValue,
midiConfig.ScalingValue);
break;
case ControllerTypes.Button:
{
if (msg.ControlValue == midiConfig.MaxValue)
{
newVolume = oldVolume > 0 ? 0 : 100;
}
break;
}
case ControllerTypes.RotaryEncoder when msg.ControlValue == midiConfig.MinValue:
{
newVolume -= (int)midiConfig.ScalingValue;
if (newVolume < 0)
{
newVolume = 0;
}
break;
}
case ControllerTypes.RotaryEncoder:
{
if (msg.ControlValue == midiConfig.MaxValue)
{
newVolume += (int)midiConfig.ScalingValue;
if (newVolume > 100)
{
newVolume = 100;
}
}
break;
}
}
return(newVolume);
}
private void onMidiEventHandle(cmdr.MidiLib.Core.MidiIO.Data.MidiEvent ev)
{
bool checkSysEx = false;
var handleEvent = (ev.MidiEventType == cmdr.MidiLib.Core.MidiIO.Definitions.EMidiEventType.Short)
? _channelListeners[ev.Status & 0x0F]
: checkSysEx;
if (!handleEvent)
{
return;
}
MidiChannel channel = MidiManager.Channels[(ev.Status & 0x0F) + 1];
MidiMessage message = null;
var type = getMidiEventType(ev);
switch (type)
{
case MidiMessageType.ControlChange:
message = new MidiControlChangeMessage(ev, type);
break;
case MidiMessageType.NoteOff:
case MidiMessageType.NoteOn:
message = new MidiNoteMessage(ev, type);
break;
case MidiMessageType.ProgramChange:
message = new MidiProgramChangeMessage(ev, type);
break;
case MidiMessageType.PitchBend:
message = new MidiPitchBendMessage(ev, type);
break;
default:
Console.WriteLine("MidiMessageType is unknown");
break;
}
if (message != null && MessageReceived != null)
{
MessageReceived(_sender, new MessageReceivedEventArgs(channel, message));
}
}
/// <summary>
/// Get the relevant value of the MIDI message.
/// </summary>
/// <param name="inputMidiMessage">Raw MIDI message.</param>
/// <returns>The value as int.</returns>
private int ExtractMidiMessageValue(IMidiMessage inputMidiMessage)
{
// Check controller type messages.
if (inputMidiMessage.Type == MidiMessageType.ControlChange)
{
MidiControlChangeMessage currentMidiMessage = (MidiControlChangeMessage)inputMidiMessage;
return(currentMidiMessage.ControlValue);
}
// Check note on type messages.
if (inputMidiMessage.Type == MidiMessageType.NoteOn)
{
MidiNoteOnMessage currentMidiMessage = (MidiNoteOnMessage)inputMidiMessage;
return(currentMidiMessage.Velocity);
}
return(0);
}
private void MidiCallback(MidiInPort sender, MidiControlChangeMessage msg)
{
foreach (var command in _commandControlMappings)
{
var config = (MidiConfiguration)command.hardwareConfiguration;
if (config.MidiDevice == GetMidiDeviceById(sender.DeviceId))
{
if (MidiEquals(config, msg))
{
switch (command.command)
{
case CommandControlMappingElement.Command.SystemVolume:
SystemVolume(command, msg);
break;
case CommandControlMappingElement.Command.SystemMute:
SystemMute(command, msg);
break;
case CommandControlMappingElement.Command.ApplicationVolume:
ApplicationVolume(command, msg);
break;
case CommandControlMappingElement.Command.ApplicationMute:
ApplicationMute(command, msg);
break;
case CommandControlMappingElement.Command.SetDefaultDevice:
DefaultDevice(command, msg);
break;
case CommandControlMappingElement.Command.CycleDefaultDevice:
CycleDefaultDevice(command, msg);
break;
}
}
}
}
}
private async void midiInControlChangeCallback(MidiControlChangeMessage msg)
{
//Todo: When the selected midi device is changed and the list got cleared, the first control input is not auto-selected -> no idea how to fix that
await _dispatcher.InvokeAsync(() =>
{
bool elementFound = false;
for (var i = 0; i < _capturedMidiInControls.Count(); i++)
{
if (-1 != _capturedMidiInControls[i].IndexOf("Channel=" + msg.Channel + ", Controller=" + msg.Controller))
{
// This channel and controller pair is already part of the list.
// -> Just refresh the value.
_capturedMidiInControls[i] = "Channel=" + msg.Channel + ", Controller=" + msg.Controller + ", Value=" + msg.ControlValue;
elementFound = true;
// PreviewValue must be updated when the changed channel and controller pair is the selected one.
if (i == CapturedMidiInControlsSelected)
{
UpdatePreviewValue();
}
break;
}
}
if (!elementFound)
{
// The channel and controller pair was not part of the list, so add it.
_capturedMidiInControls.Add("Channel=" + msg.Channel + ", Controller=" + msg.Controller + ", Value=" + msg.ControlValue);
// Select the first item when the first control is added
if (_capturedMidiInControls.Count == 1)
{
CapturedMidiInControlsSelected = 0;
RaisePropertyChanged("CapturedMidiInControlsSelected");
}
}
});
}
public void SendMessage(Event evt)
{
IMidiMessage msg;
switch (evt)
{
case NoteOnEvent on:
msg = new MidiNoteOnMessage(evt.Channel, on.Note, on.Velocity);
break;
case NoteOffEvent off:
msg = new MidiNoteOffMessage(evt.Channel, off.Note, off.Velocity);
break;
case ControlEvent ctrl:
msg = new MidiControlChangeMessage(evt.Channel, ctrl.Controller, ctrl.ControlValue);
break;
default:
throw new ArgumentException("unsupported message type");
}
intSynth.SendMessage(msg);
}
private void ApplicationMute(CommandControlMappingElement command, MidiControlChangeMessage msg)
{
List <IAppItemViewModel> apps = null;
if (command.mode == CommandControlMappingElement.Mode.ApplicationSelection)
{
apps = GetAppsByName(command.audioDevice, command.indexApplicationSelection);
}
else if (command.mode == CommandControlMappingElement.Mode.Indexed)
{
apps = GetAppsByIndex(command.audioDevice, command.indexApplicationSelection);
}
if (apps == null)
{
return;
}
foreach (var app in apps)
{
app.IsMuted = SetMute((MidiConfiguration)command.hardwareConfiguration, msg, app.IsMuted);
}
}
private MidiMessage[] GetMessages()
{
if (messages == null)
{
var msgList = new List <MidiMessage>();
for (int b = 0; b < data.Length; b++)
{
MidiMessage result = null;
uint rawCommand = data[b];
uint channel = (rawCommand & 0x0f) + 1;
EMidiCommand command = (EMidiCommand)(rawCommand & 0xF0);
if (command != EMidiCommand.SystemMessageMask)
{
// Common message
switch (command)
{
case EMidiCommand.NoteOff:
case EMidiCommand.NoteOn:
case EMidiCommand.KeyAfterTouch:
result = new MidiNoteMessage(channel, command, data[++b], data[++b]);
break;
case EMidiCommand.ControlChange:
result = new MidiControlChangeMessage(channel, data[++b], data[++b]);
break;
case EMidiCommand.PatchChange:
result = new MidiPatchChangeMessage(channel, data[++b]);
break;
case EMidiCommand.ChannelAfterTouch:
result = new MidiChannelAfterTouchMessage(channel, data[++b]);
break;
case EMidiCommand.PitchWheelChange:
result = new MidiPitchChangeMessage(channel, data[++b] + ((uint)data[++b] << 7));
break;
default:
throw new InvalidOperationException("Unsupported message in sequence: " + command);
}
}
else if (rawCommand == (uint)EMidiCommand.SystemExclusive)
{
var sysexBody = new List <byte>();
sysexBody.Add((byte)EMidiCommand.SystemExclusive);
byte bodyByte = 0;
while ((bodyByte = data[++b]) != (uint)EMidiCommand.EndOfSystemExclusive)
{
sysexBody.Add(bodyByte);
}
sysexBody.Add((byte)EMidiCommand.EndOfSystemExclusive);
result = new MidiSysexMessage(sysexBody.ToArray());
}
else
{
// System message
throw new InvalidOperationException("Only sysex and common messages supported in sequence");
}
msgList.Add(result);
}
messages = msgList.ToArray();
}
return(messages);
}
/// <summary>
/// Create a new MIDI message based on the message type and parameter(s) values,
/// and send it to the chosen output device
/// </summary>
/// <param name="sender">Element that fired the event</param>
/// <param name="e">Event arguments</param>
private void sendButton_Click(object sender, Windows.UI.Xaml.RoutedEventArgs e)
{
IMidiMessage midiMessageToSend = null;
switch (this.currentMessageType)
{
case MidiMessageType.NoteOff:
midiMessageToSend = new MidiNoteOffMessage(Convert.ToByte(this.parameter1.SelectedValue), Convert.ToByte(this.parameter2.SelectedValue), Convert.ToByte(this.parameter3.SelectedValue));
break;
case MidiMessageType.NoteOn:
midiMessageToSend = new MidiNoteOnMessage(Convert.ToByte(this.parameter1.SelectedValue), Convert.ToByte(this.parameter2.SelectedValue), Convert.ToByte(this.parameter3.SelectedValue));
break;
case MidiMessageType.PolyphonicKeyPressure:
midiMessageToSend = new MidiPolyphonicKeyPressureMessage(Convert.ToByte(this.parameter1.SelectedValue), Convert.ToByte(this.parameter2.SelectedValue), Convert.ToByte(this.parameter3.SelectedValue));
break;
case MidiMessageType.ControlChange:
midiMessageToSend = new MidiControlChangeMessage(Convert.ToByte(this.parameter1.SelectedValue), Convert.ToByte(this.parameter2.SelectedValue), Convert.ToByte(this.parameter3.SelectedValue));
break;
case MidiMessageType.ProgramChange:
midiMessageToSend = new MidiProgramChangeMessage(Convert.ToByte(this.parameter1.SelectedValue), Convert.ToByte(this.parameter2.SelectedValue));
break;
case MidiMessageType.ChannelPressure:
midiMessageToSend = new MidiChannelPressureMessage(Convert.ToByte(this.parameter1.SelectedValue), Convert.ToByte(this.parameter2.SelectedValue));
break;
case MidiMessageType.PitchBendChange:
midiMessageToSend = new MidiPitchBendChangeMessage(Convert.ToByte(this.parameter1.SelectedValue), Convert.ToUInt16(this.parameter2.SelectedValue));
break;
case MidiMessageType.SystemExclusive:
var dataWriter = new DataWriter();
var sysExMessage = this.sysExMessageContent.Text;
var sysExMessageLength = sysExMessage.Length;
// Do not send a blank SysEx message
if (sysExMessageLength == 0)
{
return;
}
// SysEx messages are two characters long with 1-character space in between them
// So we add 1 to the message length, so that it is perfectly divisible by 3
// The loop count tracks the number of individual message pieces
int loopCount = (sysExMessageLength + 1) / 3;
// Expecting a string of format "F0 NN NN NN NN.... F7", where NN is a byte in hex
for (int i = 0; i < loopCount; i++)
{
var messageString = sysExMessage.Substring(3 * i, 2);
var messageByte = Convert.ToByte(messageString, 16);
dataWriter.WriteByte(messageByte);
}
midiMessageToSend = new MidiSystemExclusiveMessage(dataWriter.DetachBuffer());
break;
case MidiMessageType.MidiTimeCode:
midiMessageToSend = new MidiTimeCodeMessage(Convert.ToByte(this.parameter1.SelectedValue), Convert.ToByte(this.parameter2.SelectedValue));
break;
case MidiMessageType.SongPositionPointer:
midiMessageToSend = new MidiSongPositionPointerMessage(Convert.ToUInt16(this.parameter1.SelectedValue));
break;
case MidiMessageType.SongSelect:
midiMessageToSend = new MidiSongSelectMessage(Convert.ToByte(this.parameter1.SelectedValue));
break;
case MidiMessageType.TuneRequest:
midiMessageToSend = new MidiTuneRequestMessage();
break;
case MidiMessageType.TimingClock:
midiMessageToSend = new MidiTimingClockMessage();
break;
case MidiMessageType.Start:
midiMessageToSend = new MidiStartMessage();
break;
case MidiMessageType.Continue:
midiMessageToSend = new MidiContinueMessage();
break;
case MidiMessageType.Stop:
midiMessageToSend = new MidiStopMessage();
break;
case MidiMessageType.ActiveSensing:
midiMessageToSend = new MidiActiveSensingMessage();
break;
case MidiMessageType.SystemReset:
midiMessageToSend = new MidiSystemResetMessage();
break;
case MidiMessageType.None:
default:
return;
}
// Send the message
this.currentMidiOutputDevice.SendMessage(midiMessageToSend);
this.rootPage.NotifyUser("Message sent successfully", NotifyType.StatusMessage);
}
public static void vol_value(int x, int v)
{
IMidiMessage midiMessageToSend = new MidiControlChangeMessage((byte)x, 7, (byte)v);
midiOutPort.SendMessage(midiMessageToSend);
}
private void MidiInPort_MessageRecieved(object sender, MidiMessageReceivedEventArgs args)
{
stopwatch.Restart();
IMidiMessage message = args.Message;
if (message.Type == MidiMessageType.NoteOn)
{
MidiNoteOnMessage msg = (MidiNoteOnMessage)message;
//channels[msg.Channel] = true;
//DebugChannels();
if (controlKeys.Contains(msg.Note) && !openControlRecords.ContainsKey(msg.Channel))
{
heapInProgress = true;
openControlRecords.Add(msg.Channel, new ChannelRecord(msg.Note));
}
else if (!openDownRecords.ContainsKey(msg.Note))
{
heapInProgress = true;
openDownRecords.Add(msg.Note, new ChannelRecord(msg.Note));
}
}
else if (message.Type == MidiMessageType.NoteOff)
{
MidiNoteOffMessage msg = (MidiNoteOffMessage)message;
//channels[msg.Channel] = false;
//DebugChannels();
if (controlKeys.Contains(msg.Note) && openControlRecords.ContainsKey(msg.Channel))
{
suspendedRecords.Add(openControlRecords[msg.Channel]);
openControlRecords.Remove(msg.Channel);
}
else if (openDownRecords.ContainsKey(msg.Note))
{
suspendedRecords.Add(openDownRecords[msg.Note]);
openDownRecords.Remove(msg.Note);
}
if (openControlRecords.Count == 0 && openDownRecords.Count == 0)
{
BeginDebounce();
}
}
else if (message.Type == MidiMessageType.ControlChange)
{
MidiControlChangeMessage controlMessage = (MidiControlChangeMessage)message;
int channel = controlMessage.Channel;
if (openControlRecords.ContainsKey(channel))
{
switch (controlMessage.Controller)
{
case 1:
openControlRecords[channel].MakeRecord(controlMessage.ControlValue);
//Debug.WriteLine(openRecords[channel].ToString());
break;
default:
Debug.WriteLine("Got unexpected control change on controller " + controlMessage.Controller);
break;
}
}
}
}
/// <summary>
/// Create a new MIDI message based on the message type and parameter(s) values,
/// and send it to the chosen output device
/// </summary>
/// <param name="sender">Element that fired the event</param>
/// <param name="e">Event arguments</param>
private void sendButton_Click(object sender, Windows.UI.Xaml.RoutedEventArgs e)
{
IMidiMessage midiMessageToSend = null;
switch (_currentMessageType)
{
case MidiMessageType.NoteOff:
midiMessageToSend = new MidiNoteOffMessage(Convert.ToByte(GetParameterValue(parameter1)), Convert.ToByte(GetParameterValue(parameter2)), Convert.ToByte(GetParameterValue(parameter3)));
break;
case MidiMessageType.NoteOn:
midiMessageToSend = new MidiNoteOnMessage(Convert.ToByte(GetParameterValue(parameter1)), Convert.ToByte(GetParameterValue(parameter2)), Convert.ToByte(GetParameterValue(parameter3)));
break;
case MidiMessageType.PolyphonicKeyPressure:
midiMessageToSend = new MidiPolyphonicKeyPressureMessage(Convert.ToByte(GetParameterValue(parameter1)), Convert.ToByte(GetParameterValue(parameter2)), Convert.ToByte(GetParameterValue(parameter3)));
break;
case MidiMessageType.ControlChange:
midiMessageToSend = new MidiControlChangeMessage(Convert.ToByte(GetParameterValue(parameter1)), Convert.ToByte(GetParameterValue(parameter2)), Convert.ToByte(GetParameterValue(parameter3)));
break;
case MidiMessageType.ProgramChange:
midiMessageToSend = new MidiProgramChangeMessage(Convert.ToByte(GetParameterValue(parameter1)), Convert.ToByte(GetParameterValue(parameter2)));
break;
case MidiMessageType.ChannelPressure:
midiMessageToSend = new MidiChannelPressureMessage(Convert.ToByte(GetParameterValue(parameter1)), Convert.ToByte(GetParameterValue(parameter2)));
break;
case MidiMessageType.PitchBendChange:
midiMessageToSend = new MidiPitchBendChangeMessage(Convert.ToByte(GetParameterValue(parameter1)), Convert.ToUInt16(GetParameterValue(parameter2)));
break;
case MidiMessageType.SystemExclusive:
var dataWriter = new DataWriter();
var sysExMessage = sysExMessageContent.Text;
var sysExMessageLength = sysExMessage.Length;
// Do not send a blank SysEx message
if (sysExMessageLength == 0)
{
return;
}
// SysEx messages are two characters long with 1-character space in between them
// So we add 1 to the message length, so that it is perfectly divisible by 3
// The loop count tracks the number of individual message pieces
int loopCount = (sysExMessageLength + 1) / 3;
// Expecting a string of format "F0 NN NN NN NN.... F7", where NN is a byte in hex
for (int i = 0; i < loopCount; i++)
{
var messageString = sysExMessage.Substring(3 * i, 2);
var messageByte = Convert.ToByte(messageString, 16);
dataWriter.WriteByte(messageByte);
}
midiMessageToSend = new MidiSystemExclusiveMessage(dataWriter.DetachBuffer());
break;
case MidiMessageType.MidiTimeCode:
midiMessageToSend = new MidiTimeCodeMessage(Convert.ToByte(GetParameterValue(parameter1)), Convert.ToByte(GetParameterValue(parameter2)));
break;
case MidiMessageType.SongPositionPointer:
midiMessageToSend = new MidiSongPositionPointerMessage(Convert.ToUInt16(GetParameterValue(parameter1)));
break;
case MidiMessageType.SongSelect:
midiMessageToSend = new MidiSongSelectMessage(Convert.ToByte(GetParameterValue(parameter1)));
break;
case MidiMessageType.TuneRequest:
midiMessageToSend = new MidiTuneRequestMessage();
break;
case MidiMessageType.TimingClock:
midiMessageToSend = new MidiTimingClockMessage();
break;
case MidiMessageType.Start:
midiMessageToSend = new MidiStartMessage();
break;
case MidiMessageType.Continue:
midiMessageToSend = new MidiContinueMessage();
break;
case MidiMessageType.Stop:
midiMessageToSend = new MidiStopMessage();
break;
case MidiMessageType.ActiveSensing:
midiMessageToSend = new MidiActiveSensingMessage();
break;
case MidiMessageType.SystemReset:
midiMessageToSend = new MidiSystemResetMessage();
break;
case MidiMessageType.None:
default:
return;
}
// Send the message
_currentMidiOutputDevice.SendMessage(midiMessageToSend);
NotifyUser("Message sent successfully");
}
private int ParseBuffer(byte[] data, int offset, int length, out MidiMessage message)
{
message = null;
int messageLength = 0;
if (length == 0)
{
// Should not happen
return(0);
}
uint rawCommand = data[offset];
uint channel = (rawCommand & 0x0f) + 1;
EMidiCommand command = (EMidiCommand)(rawCommand & 0xF0);
if (command == EMidiCommand.SystemMessageMask)
{
// System message
channel = 0;
command = (EMidiCommand)rawCommand;
messageLength = 1;
switch (command)
{
case EMidiCommand.TimingClock:
message = new TimingClockMessage();
break;
case EMidiCommand.StartSequence:
message = new StartSequenceMessage();
break;
case EMidiCommand.ContinueSequence:
message = new ContinueSequenceMessage();
break;
case EMidiCommand.StopSequence:
message = new StopSequenceMessage();
break;
case EMidiCommand.ActiveSensing:
message = new ActiveSensingMessage();
break;
case EMidiCommand.SystemExclusive:
messageLength = ParseSysex(data, offset, length, ref message);
break;
}
}
else
{
uint p1 = (length >= 2) ? data[offset + 1] : 0u;
uint p2 = (length >= 3) ? data[offset + 2] : 0u;
// Common message
switch (command)
{
case EMidiCommand.NoteOff:
case EMidiCommand.NoteOn:
case EMidiCommand.KeyAfterTouch:
message = new MidiNoteMessage(channel, command, p1, p2);
messageLength = 3;
break;
case EMidiCommand.ControlChange:
message = new MidiControlChangeMessage(channel, p1, p2);
messageLength = 3;
break;
case EMidiCommand.PatchChange:
message = new MidiPatchChangeMessage(channel, p1);
messageLength = 2;
break;
case EMidiCommand.ChannelAfterTouch:
message = new MidiChannelAfterTouchMessage(channel, p1);
messageLength = 2;
break;
case EMidiCommand.PitchWheelChange:
message = new MidiPitchChangeMessage(channel, p1 + (p2 << 7));
messageLength = 3;
break;
}
// Indicate truncated message in reply
if (length < messageLength)
{
messageLength = -1;
}
}
return(messageLength);
}