private void MidiInPort_MessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
IMidiMessage receivedMidiMessage = args.Message;
byte[] rawData = receivedMidiMessage.RawData.ToArray();
mainPage.CSignetic6502.MemoryBus.ACIA.MidiInPort_MessageReceived(rawData);
}
public void MidiInPort_MessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
IMidiMessage receivedMidiMessage = args.Message;
rawData = receivedMidiMessage.RawData.ToArray();
MessageReceived = true;
}
/// <summary>
/// Process messages received from the Launchpad
/// </summary>
/// <param name="sender">Launchpad</param>
/// <param name="args">Midi Message</param>
void InPort_MessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
// Determine what kind of message it is
switch (args.Message)
{
case MidiNoteOnMessage onMessage: // Grid and side buttons come as Midi Note On Message
Debug.WriteLine($"Grid ({onMessage.Note % 16}, {(int)(onMessage.Note / 16)}) " + (onMessage.Velocity == 0 ? "Released" : "Pressed"));
// Get a reference to the button
var gridButton = gridButtons.FirstOrDefault(button => button.Id == onMessage.Note);
// If the grid button could not be found (should never happen), return
if (gridButton == null)
{
return;
}
// Update the state (Launchpad sends midi on message for press and release - Velocity 0 is released, 127 is pressed)
gridButton.State = onMessage.Velocity == 0
? LaunchpadButtonState.Released
: LaunchpadButtonState.Pressed;
// Notify any observable subscribers of the event
whenButtonStateChanged.OnNext(gridButton);
break;
case MidiControlChangeMessage changeMessage: // Top row comes as Control Change message
break;
}
}
private void MidiInPort_MessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
IMidiMessage receivedMidiMessage = args.Message;
System.Diagnostics.Debug.WriteLine(receivedMidiMessage.Timestamp.ToString());
if (receivedMidiMessage.Type == MidiMessageType.NoteOn)
{
byte channel = ((MidiNoteOnMessage)receivedMidiMessage).Channel;
byte note = ((MidiNoteOnMessage)receivedMidiMessage).Note;
byte velocity = ((MidiNoteOnMessage)receivedMidiMessage).Velocity;
int octave = note / 12;
int fundamental = note % 12;
System.Diagnostics.Debug.WriteLine(channel);
System.Diagnostics.Debug.WriteLine(note);
System.Diagnostics.Debug.WriteLine(velocity);
System.Diagnostics.Debug.WriteLine(octave);
System.Diagnostics.Debug.WriteLine(fundamental);
IMidiMessage message = new MidiNoteOnMessage(channel, note, velocity);
midiOutPort.SendMessage(message);
}
else if (receivedMidiMessage.Type == MidiMessageType.NoteOff)
{
byte channel = ((MidiNoteOffMessage)receivedMidiMessage).Channel;
byte note = ((MidiNoteOffMessage)receivedMidiMessage).Note;
byte velocity = ((MidiNoteOffMessage)receivedMidiMessage).Velocity;
IMidiMessage message = new MidiNoteOffMessage(channel, note, velocity);
midiOutPort.SendMessage(message);
}
}
void DispatchMessageReceived(MidiInPort port, MidiMessageReceivedEventArgs args)
{
var data = args.Message.RawData.ToArray();
MessageReceived(this, new MidiReceivedEventArgs {
Data = data, Start = 0, Length = data.Length, Timestamp = (long)args.Message.Timestamp.TotalMilliseconds
});
}
private void MidiInPort_MessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
// Recieved message
IMidiMessage receivedMidiMessage = args.Message;
System.Diagnostics.Debug.WriteLine(receivedMidiMessage.Timestamp.ToString());
if (receivedMidiMessage.Type == MidiMessageType.NoteOn)
{
System.Diagnostics.Debug.WriteLine(((MidiNoteOnMessage)receivedMidiMessage).Channel);
System.Diagnostics.Debug.WriteLine(((MidiNoteOnMessage)receivedMidiMessage).Note);
System.Diagnostics.Debug.WriteLine(((MidiNoteOnMessage)receivedMidiMessage).Velocity);
// Play the note
byte channel = ((MidiNoteOnMessage)receivedMidiMessage).Channel;
byte note = ((MidiNoteOnMessage)receivedMidiMessage).Note;
//If the player releases the key there should be no sound
byte velocity;
if (((MidiNoteOnMessage)receivedMidiMessage).Velocity != 0)
{
if (Settings.feedback == true)
{
//Use the input from the keyboard the see what the normal velocity is and then add the volume the user chose
velocity = ((MidiNoteOnMessage)receivedMidiMessage).Velocity;
if (velocity + DoubleToByte(Settings.volume) <= 127 && velocity + DoubleToByte(Settings.volume) >= 0)
{
velocity += DoubleToByte(Settings.volume);
}
else if (velocity + DoubleToByte(Settings.volume) > 127)
{
velocity = 127;
}
else
{
velocity = 0;
}
//Else use the static velocity the user chose
}
else
{
velocity = DoubleToByte(Settings.velocity);
}
//Else do not produce any sound, when the input is 0
}
else
{
velocity = ((MidiNoteOnMessage)receivedMidiMessage).Velocity;
}
IMidiMessage midiMessageToSend = new MidiNoteOnMessage(channel, note, velocity);
FillKey(note);
Settings.midiOutPort.SendMessage(midiMessageToSend);
}
}
private async void MidiInPort_MessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
IMidiMessage receivedMidiMessage = args.Message;
// Use helper class to check message, and if it's something we can deal with, send the message to MIDI out if connected
bool sendMessage = await msgHelper.UseMessage(receivedMidiMessage);
if (midiOutPort != null && sendMessage)
{
midiOutPort.SendMessage(receivedMidiMessage);
}
}
private void MidiInPort_MessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
IMidiMessage receivedMidiMessage = args.Message;
if (receivedMidiMessage.Type == MidiMessageType.ControlChange)
{
var message = (MidiControlChangeMessage)receivedMidiMessage;
ResetKnob(message.Controller);
}
MidiMessageQueue.Enqueue(receivedMidiMessage);
}
private async void DeepMind_MessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
if (args.Message.Type == MidiMessageType.NoteOn)
{
var noteOnMessage = (MidiNoteOnMessage)args.Message;
await Dispatcher.RunAsync(CoreDispatcherPriority.High, () =>
{
this.textBlock.Text = noteOnMessage.Note + ", velocity " + noteOnMessage.Velocity;
}
);
}
}
private void MidiInPort_MessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
IMidiMessage receivedMidiMessage = args.Message;
System.Diagnostics.Debug.WriteLine(receivedMidiMessage.Timestamp.ToString());
if (receivedMidiMessage.Type == MidiMessageType.NoteOn)
{
System.Diagnostics.Debug.WriteLine(((MidiNoteOnMessage)receivedMidiMessage).Channel);
System.Diagnostics.Debug.WriteLine(((MidiNoteOnMessage)receivedMidiMessage).Note);
System.Diagnostics.Debug.WriteLine(((MidiNoteOnMessage)receivedMidiMessage).Velocity);
}
}
private void OnMidiInMessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
// handle incoming messages
// these are USB single-device connections, so we're not going to do any filtering
if (args.Message is MidiNoteOnMessage)
{
var msg = args.Message as MidiNoteOnMessage;
if (msg.Velocity == 0)
{
// note off
if (PadReleased != null)
{
PadReleased(this, new PadReleasedEventArgs(msg.Note, (IMidiMessage)msg));
}
}
else
{
// velocity is always 127 on the novation, but still passing it along here
// in case they add touch sensitivity in the future
// note on
if (PadPressed != null)
{
PadPressed(this, new PadPressedEventArgs(msg.Note, msg.Velocity, (IMidiMessage)msg));
}
}
}
else if (args.Message is MidiControlChangeMessage)
{
var msg = args.Message as MidiControlChangeMessage;
if (msg.Controller == 0 && msg.ControlValue == 3)
{
// this is the notification that text has stopped scrolling
if (TextScrollingComplete != null)
{
TextScrollingComplete(this, EventArgs.Empty);
}
}
else
{
System.Diagnostics.Debug.WriteLine("Unhandled MIDI-IN control change message controller: " + msg.Controller + ", value: " + msg.ControlValue);
}
}
else
{
System.Diagnostics.Debug.WriteLine("Unhandled MIDI-IN message " + args.Message.GetType().ToString());
}
}
private async void MidiInPort_MessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
IMidiMessage receivedMidiMessage = args.Message;
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Brush x = receivedMidiMessage.Type switch
{
MidiMessageType.NoteOn =>
((Button)myGrid.Children.First(x => ((Button)x).Content.ToString() == ((MidiNoteOnMessage)receivedMidiMessage).Note.ToString())).Background = new SolidColorBrush(Colors.MediumSpringGreen),
MidiMessageType.NoteOff =>
((Button)myGrid.Children.First(x => ((Button)x).Content.ToString() == ((MidiNoteOffMessage)receivedMidiMessage).Note.ToString())).Background = new SolidColorBrush(Colors.LightGray),
_ => null
};
});
public static void MidiDeviceService_MessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
var message = args.Message;
if (message.Type == MidiMessageType.NoteOn)
{
var noteOn = (MidiNoteOnMessage)message;
Console.WriteLine($"Key {noteOn.Note} pressed!");
}
else if (message.Type == MidiMessageType.NoteOff)
{
var noteOff = (MidiNoteOffMessage)message;
Console.WriteLine($"Key {noteOff.Note} depressed!");
}
}
/// <summary>
/// A new MIDI message was received.
/// Check if the message is relevant by checking the trained MIDI events
/// and if so, send a notification.
/// </summary>
/// <param name="sender">MIDI port that sent the message</param>
/// <param name="args">MidiMessageReceivedEventArgs</param>
private void MidiMessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
// Get the message as simple IMidiMessage.
IMidiMessage rawMidiMessage = (IMidiMessage)args.Message;
// Get the id and relevant value of the MIDI message.
int midiMessageID = this.ExtractMidiMessageID(rawMidiMessage);
int midiMessageValue = this.ExtractMidiMessageValue(rawMidiMessage);
// First check if we are in MIDI learn mode.
// If so, do not interpret the message, but instead use the message to associate
// its type with an event type.
if (this.midiLearningActive)
{
// Initialize new MIDI event.
MidiEventTrigger learnedMidiEvent = new MidiEventTrigger();
learnedMidiEvent.type = this.midiLearningType;
learnedMidiEvent.rawOriginalMessage = rawMidiMessage;
// Set the ID of the message.
learnedMidiEvent.id = midiMessageID;
// Store identified MIDI event.
this.learnedMidiTriggers[(int)this.midiLearningType] = learnedMidiEvent;
this.midiLearningActive = false;
// Notify that the event has been learned.
this.globalEventHandlerInstance.NotifyMidiEventLearned(this.midiLearningType);
// Do not continue to analyze the input.
return;
}
// Iterate through all types if the message was recognized.
for (int i = 0; i < Enum.GetNames(typeof(MidiEventType)).Length; i++)
{
if (this.learnedMidiTriggers[i].id == midiMessageID)
{
// Relevant event found, send the notification.
MidiEvent midiEvent = new MidiEvent();
midiEvent.type = this.learnedMidiTriggers[i].type;
midiEvent.value = midiMessageValue;
this.globalEventHandlerInstance.NotifyMidiEventReceived(midiEvent);
}
}
}
public async void MidiInPort_MessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
IMidiMessage receivedMidiMessage = args.Message;
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
double x = receivedMidiMessage.Type switch
{
MidiMessageType.ControlChange =>
((MidiControlChangeMessage)receivedMidiMessage).Controller switch
{
48 => redSlider.Value = ((MidiControlChangeMessage)receivedMidiMessage).ControlValue * 2.008,
49 => greenSlider.Value = ((MidiControlChangeMessage)receivedMidiMessage).ControlValue * 2.008,
50 => blueSlider.Value = ((MidiControlChangeMessage)receivedMidiMessage).ControlValue * 2.008,
56 => masterSlider.Value = ((MidiControlChangeMessage)receivedMidiMessage).ControlValue * 2.008,
51 => redSlider2.Value = ((MidiControlChangeMessage)receivedMidiMessage).ControlValue * 2.008,
52 => greenSlider2.Value = ((MidiControlChangeMessage)receivedMidiMessage).ControlValue * 2.008,
53 => blueSlider2.Value = ((MidiControlChangeMessage)receivedMidiMessage).ControlValue * 2.008,
_ => 1
},
private void MidiInPort_MessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
IMidiMessage receivedMidiMessage = args.Message;
System.Diagnostics.Debug.WriteLine(receivedMidiMessage.Timestamp.ToString());
if (receivedMidiMessage.Type == MidiMessageType.NoteOn)
{
System.Diagnostics.Debug.WriteLine(((MidiNoteOnMessage)receivedMidiMessage).Channel);
System.Diagnostics.Debug.WriteLine(((MidiNoteOnMessage)receivedMidiMessage).Note);
System.Diagnostics.Debug.WriteLine(((MidiNoteOnMessage)receivedMidiMessage).Velocity);
byte channel = ((MidiNoteOnMessage)receivedMidiMessage).Channel;
byte note = ((MidiNoteOnMessage)receivedMidiMessage).Note;
byte velocity = ((MidiNoteOnMessage)receivedMidiMessage).Velocity;
IMidiMessage midiMessageToSend = new MidiNoteOnMessage(channel, note, velocity);
midiOutPort.SendMessage(midiMessageToSend);
}
}
public static void MessageHandler(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
var dataReader = Windows.Storage.Streams.DataReader.FromBuffer(args.Message.RawData);
byte garbage = dataReader.ReadByte();
byte noteId = dataReader.ReadByte();
byte velocity = dataReader.ReadByte();
//form.Text = noteId.ToString();
//form.lastMidiID.Text = noteId.ToString();
form.setNote(noteId.ToString());
if (noteId == MIDI_NOTE_ID)
{
if (velocity == 0)
{
isPressed = false;
}
else
{
isPressed = true;
}
}
form.pressState(isPressed);
}
private static void MessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
var received = args.Message;
if (received.Type == MidiMessageType.ControlChange)
{
var msg = (MidiControlChangeMessage)received;
foreach (var callback in generalCallbacks)
{
callback(sender, msg);
}
string id = sender.DeviceId;
if (!callbacks.ContainsKey(id))
{
return;
}
var key = new Tuple <byte, byte>(msg.Channel, msg.Controller);
if (callbacks[id].ContainsKey(key))
{
foreach (var callback in callbacks[id][key])
{
callback(msg);
}
}
var universalKey = new Tuple <byte, byte>(255, 255);
if (callbacks[id].ContainsKey(universalKey))
{
foreach (var callback in callbacks[id][universalKey])
{
callback(msg);
}
}
}
}
/// <summary>
/// Process messages received from the Launchpad
/// </summary>
/// <param name="sender">Launchpad</param>
/// <param name="args">Midi Message</param>
void InPort_MessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
// Determine what kind of message it is
switch (args.Message)
{
// Grid and side buttons come as Midi Note On Message
case MidiNoteOnMessage onMessage:
// If it's a side button
if (onMessage.Note % 10 == 9)
{
UpdateSideButton(onMessage);
}
else // If it's a grid button
{
UpdateGridButton(onMessage);
}
break;
// Top row comes as Control Change message
case MidiControlChangeMessage changeMessage:
UpdateTopButton(changeMessage);
break;
}
}
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;
}
}
}
}
//
//
//
private void MidiInputDevice_MessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
IMidiMessage receivedMidiMessage = args.Message;
// Build the received MIDI message into a readable format
StringBuilder outputMessage = new StringBuilder();
outputMessage.Append(receivedMidiMessage.Timestamp.ToString()).Append(", Type: ").Append(receivedMidiMessage.Type);
// Add MIDI message parameters to the output, depending on the type of message
switch (receivedMidiMessage.Type)
{
case MidiMessageType.NoteOff:
var noteOffMessage = (MidiNoteOffMessage)receivedMidiMessage;
outputMessage.Append(", Channel: ").Append(noteOffMessage.Channel).Append(", Note: ").Append(noteOffMessage.Note).Append(", Velocity: ").Append(noteOffMessage.Velocity);
break;
case MidiMessageType.NoteOn:
var noteOnMessage = (MidiNoteOnMessage)receivedMidiMessage;
outputMessage.Append(", Channel: ").Append(noteOnMessage.Channel).Append(", Note: ").Append(noteOnMessage.Note).Append(", Velocity: ").Append(noteOnMessage.Velocity);
break;
case MidiMessageType.PolyphonicKeyPressure:
var polyphonicKeyPressureMessage = (MidiPolyphonicKeyPressureMessage)receivedMidiMessage;
outputMessage.Append(", Channel: ").Append(polyphonicKeyPressureMessage.Channel).Append(", Note: ").Append(polyphonicKeyPressureMessage.Note).Append(", Pressure: ").Append(polyphonicKeyPressureMessage.Pressure);
break;
case MidiMessageType.ControlChange:
var controlChangeMessage = (MidiControlChangeMessage)receivedMidiMessage;
outputMessage.Append(", Channel: ").Append(controlChangeMessage.Channel).Append(", Controller: ").Append(controlChangeMessage.Controller).Append(", Value: ").Append(controlChangeMessage.ControlValue);
break;
case MidiMessageType.ProgramChange:
var programChangeMessage = (MidiProgramChangeMessage)receivedMidiMessage;
outputMessage.Append(", Channel: ").Append(programChangeMessage.Channel).Append(", Program: ").Append(programChangeMessage.Program);
break;
case MidiMessageType.ChannelPressure:
var channelPressureMessage = (MidiChannelPressureMessage)receivedMidiMessage;
outputMessage.Append(", Channel: ").Append(channelPressureMessage.Channel).Append(", Pressure: ").Append(channelPressureMessage.Pressure);
break;
case MidiMessageType.PitchBendChange:
var pitchBendChangeMessage = (MidiPitchBendChangeMessage)receivedMidiMessage;
outputMessage.Append(", Channel: ").Append(pitchBendChangeMessage.Channel).Append(", Bend: ").Append(pitchBendChangeMessage.Bend);
break;
case MidiMessageType.SystemExclusive:
var systemExclusiveMessage = (MidiSystemExclusiveMessage)receivedMidiMessage;
outputMessage.Append(", ");
// Read the SysEx bufffer
var sysExDataReader = DataReader.FromBuffer(systemExclusiveMessage.RawData);
while (sysExDataReader.UnconsumedBufferLength > 0)
{
byte byteRead = sysExDataReader.ReadByte();
// Pad with leading zero if necessary
outputMessage.Append(byteRead.ToString("X2")).Append(" ");
}
break;
case MidiMessageType.MidiTimeCode:
var timeCodeMessage = (MidiTimeCodeMessage)receivedMidiMessage;
outputMessage.Append(", FrameType: ").Append(timeCodeMessage.FrameType).Append(", Values: ").Append(timeCodeMessage.Values);
break;
case MidiMessageType.SongPositionPointer:
var songPositionPointerMessage = (MidiSongPositionPointerMessage)receivedMidiMessage;
outputMessage.Append(", Beats: ").Append(songPositionPointerMessage.Beats);
break;
case MidiMessageType.SongSelect:
var songSelectMessage = (MidiSongSelectMessage)receivedMidiMessage;
outputMessage.Append(", Song: ").Append(songSelectMessage.Song);
break;
case MidiMessageType.TuneRequest:
var tuneRequestMessage = (MidiTuneRequestMessage)receivedMidiMessage;
//
break;
case MidiMessageType.TimingClock:
var timingClockMessage = (MidiTimingClockMessage)receivedMidiMessage;
//
break;
case MidiMessageType.Start:
var startMessage = (MidiStartMessage)receivedMidiMessage;
//
break;
case MidiMessageType.Continue:
var continueMessage = (MidiContinueMessage)receivedMidiMessage;
//
break;
case MidiMessageType.Stop:
var stopMessage = (MidiStopMessage)receivedMidiMessage;
//
break;
case MidiMessageType.ActiveSensing:
var activeSensingMessage = (MidiActiveSensingMessage)receivedMidiMessage;
//
break;
case MidiMessageType.SystemReset:
var systemResetMessage = (MidiSystemResetMessage)receivedMidiMessage;
//
break;
case MidiMessageType.None:
throw new InvalidOperationException();
default:
break;
}
//
//
//
midiMessagesReceived = outputMessage.ToString();
//
EventArgs e = new EventArgs();
MidiInputMessageReceived(this, e);
}
private void Port_MessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
if (args.Message.Type == MidiMessageType.NoteOn)
{
var msg = (MidiNoteOnMessage)args.Message;
if (msg.Note != 0)
{
view.Title = $"Pitch: {msg.Note}, Velocity: {msg.Velocity}";
if (msg.Velocity != 0)
{
notesPlaying++;
freq = notes[msg.Note];
theta = 0;
input.Start();
}
else
{
notesPlaying--;
if (notesPlaying == 0)
input.Stop();
}
}
}
}
/// <summary>
/// Display the received MIDI message in a readable format
/// </summary>
/// <param name="sender">Element that fired the event</param>
/// <param name="args">The received message</param>
private async void MidiInputDevice_MessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
IMidiMessage receivedMidiMessage = args.Message;
// Build the received MIDI message into a readable format
StringBuilder outputMessage = new StringBuilder();
outputMessage.Append(receivedMidiMessage.Timestamp.ToString()).Append(", Type: ").Append(receivedMidiMessage.Type);
// Add MIDI message parameters to the output, depending on the type of message
switch (receivedMidiMessage.Type)
{
case MidiMessageType.NoteOff:
var noteOffMessage = (MidiNoteOffMessage)receivedMidiMessage;
outputMessage.Append(", Channel: ").Append(noteOffMessage.Channel).Append(", Note: ").Append(noteOffMessage.Note).Append(", Velocity: ").Append(noteOffMessage.Velocity);
break;
case MidiMessageType.NoteOn:
var noteOnMessage = (MidiNoteOnMessage)receivedMidiMessage;
outputMessage.Append(", Channel: ").Append(noteOnMessage.Channel).Append(", Note: ").Append(noteOnMessage.Note).Append(", Velocity: ").Append(noteOnMessage.Velocity);
break;
case MidiMessageType.PolyphonicKeyPressure:
var polyphonicKeyPressureMessage = (MidiPolyphonicKeyPressureMessage)receivedMidiMessage;
outputMessage.Append(", Channel: ").Append(polyphonicKeyPressureMessage.Channel).Append(", Note: ").Append(polyphonicKeyPressureMessage.Note).Append(", Pressure: ").Append(polyphonicKeyPressureMessage.Pressure);
break;
case MidiMessageType.ControlChange:
var controlChangeMessage = (MidiControlChangeMessage)receivedMidiMessage;
outputMessage.Append(", Channel: ").Append(controlChangeMessage.Channel).Append(", Controller: ").Append(controlChangeMessage.Controller).Append(", Value: ").Append(controlChangeMessage.ControlValue);
break;
case MidiMessageType.ProgramChange:
var programChangeMessage = (MidiProgramChangeMessage)receivedMidiMessage;
outputMessage.Append(", Channel: ").Append(programChangeMessage.Channel).Append(", Program: ").Append(programChangeMessage.Program);
break;
case MidiMessageType.ChannelPressure:
var channelPressureMessage = (MidiChannelPressureMessage)receivedMidiMessage;
outputMessage.Append(", Channel: ").Append(channelPressureMessage.Channel).Append(", Pressure: ").Append(channelPressureMessage.Pressure);
break;
case MidiMessageType.PitchBendChange:
var pitchBendChangeMessage = (MidiPitchBendChangeMessage)receivedMidiMessage;
outputMessage.Append(", Channel: ").Append(pitchBendChangeMessage.Channel).Append(", Bend: ").Append(pitchBendChangeMessage.Bend);
break;
case MidiMessageType.SystemExclusive:
var systemExclusiveMessage = (MidiSystemExclusiveMessage)receivedMidiMessage;
outputMessage.Append(", ");
// Read the SysEx bufffer
var sysExDataReader = DataReader.FromBuffer(systemExclusiveMessage.RawData);
while (sysExDataReader.UnconsumedBufferLength > 0)
{
byte byteRead = sysExDataReader.ReadByte();
// Pad with leading zero if necessary
outputMessage.Append(byteRead.ToString("X2")).Append(" ");
}
break;
case MidiMessageType.MidiTimeCode:
var timeCodeMessage = (MidiTimeCodeMessage)receivedMidiMessage;
outputMessage.Append(", FrameType: ").Append(timeCodeMessage.FrameType).Append(", Values: ").Append(timeCodeMessage.Values);
break;
case MidiMessageType.SongPositionPointer:
var songPositionPointerMessage = (MidiSongPositionPointerMessage)receivedMidiMessage;
outputMessage.Append(", Beats: ").Append(songPositionPointerMessage.Beats);
break;
case MidiMessageType.SongSelect:
var songSelectMessage = (MidiSongSelectMessage)receivedMidiMessage;
outputMessage.Append(", Song: ").Append(songSelectMessage.Song);
break;
case MidiMessageType.TuneRequest:
var tuneRequestMessage = (MidiTuneRequestMessage)receivedMidiMessage;
break;
case MidiMessageType.TimingClock:
var timingClockMessage = (MidiTimingClockMessage)receivedMidiMessage;
break;
case MidiMessageType.Start:
var startMessage = (MidiStartMessage)receivedMidiMessage;
break;
case MidiMessageType.Continue:
var continueMessage = (MidiContinueMessage)receivedMidiMessage;
break;
case MidiMessageType.Stop:
var stopMessage = (MidiStopMessage)receivedMidiMessage;
break;
case MidiMessageType.ActiveSensing:
var activeSensingMessage = (MidiActiveSensingMessage)receivedMidiMessage;
break;
case MidiMessageType.SystemReset:
var systemResetMessage = (MidiSystemResetMessage)receivedMidiMessage;
break;
case MidiMessageType.None:
throw new InvalidOperationException();
default:
break;
}
// Use the Dispatcher to update the messages on the UI thread
await Dispatcher.RunAsync(CoreDispatcherPriority.High, () =>
{
// Skip TimingClock and ActiveSensing messages to avoid overcrowding the list. Commment this check out to see all messages
if ((receivedMidiMessage.Type != MidiMessageType.TimingClock) && (receivedMidiMessage.Type != MidiMessageType.ActiveSensing))
{
this.inputDeviceMessages.Items.Add(outputMessage + "\n");
this.inputDeviceMessages.ScrollIntoView(this.inputDeviceMessages.Items[this.inputDeviceMessages.Items.Count - 1]);
this.rootPage.NotifyUser("Message received successfully!", NotifyType.StatusMessage);
}
});
}
private void OnMidiMessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
// Console.WriteLine("OnMidiMessageReceived: " + args.Message.Type);
switch (args.Message.Type)
{
case MidiMessageType.NoteOn:
var noteOnMessage = args.Message as MidiNoteOnMessage;
// a zero-velocity note-on message is equivalent to note-off
if (noteOnMessage.Velocity == 0 && TranslateZeroVelocityNoteOnMessage)
{
var ev1 = NoteOffMessageReceived;
if (ev1 != null)
ev1(this, new MidiNoteOffMessageReceivedEventArgs(noteOnMessage.Channel, noteOnMessage.Note, noteOnMessage.Velocity, true));
}
else
{
// normal note on message
var ev2 = NoteOnMessageReceived;
if (ev2 != null)
{
try
{
ev2(this, new MidiNoteOnMessageReceivedEventArgs(noteOnMessage.Channel, noteOnMessage.Note, noteOnMessage.Velocity));
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
}
break;
case MidiMessageType.NoteOff:
var noteOffMessage = args.Message as MidiNoteOffMessage;
var ev3 = NoteOffMessageReceived;
if (ev3 != null)
ev3(this, new MidiNoteOffMessageReceivedEventArgs(noteOffMessage.Channel, noteOffMessage.Note, noteOffMessage.Velocity, false));
break;
case MidiMessageType.ControlChange:
var ccMessage = args.Message as MidiControlChangeMessage;
var ev4 = ControlChangeMessageReceived;
if (ev4 != null)
ev4(this, new MidiControlChangeMessageReceivedEventArgs(ccMessage.Channel, ccMessage.Controller, ccMessage.ControlValue));
break;
case MidiMessageType.ProgramChange:
var programMessage = args.Message as MidiProgramChangeMessage;
var ev5 = ProgramChangeMessageReceived;
if (ev5 != null)
ev5(this, new MidiProgramChangeMessageReceivedEventArgs(programMessage.Channel, programMessage.Program));
break;
case MidiMessageType.PitchBendChange:
var pitchBendChangeMessage = args.Message as MidiPitchBendChangeMessage;
var ev6 = PitchBendChangeMessageReceived;
if (ev6 != null)
ev6(this, new MidiPitchBendChangeMessageReceivedEventArgs(pitchBendChangeMessage.Channel, pitchBendChangeMessage.Bend));
break;
// TODO: Add more message types
default:
// message type we don't handle above. Ignore
break;
}
}
void DispatchMessageReceived(MidiInPort port, MidiMessageReceivedEventArgs args)
{
MessageReceived(this, new MidiReceivedEventArgs {
Data = args.Message.RawData.ToArray(), Timestamp = (long)args.Message.Timestamp.TotalMilliseconds
});
}
private void MidiInputDevice_MessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
IMidiMessage msg = args.Message;
midiMessageRecieved(msg);
}
/// <summary>
/// Display the received MIDI message in a readable format
/// </summary>
/// <param name="sender">Element that fired the event</param>
/// <param name="args">The received message</param>
private async void MidiInputDevice_MessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
IMidiMessage receivedMidiMessage = args.Message;
// Build the received MIDI message into a readable format
StringBuilder outputMessage = new StringBuilder();
outputMessage.Append(receivedMidiMessage.Timestamp.ToString()).Append(", Type: ").Append(receivedMidiMessage.Type);
// Add MIDI message parameters to the output, depending on the type of message
switch (receivedMidiMessage.Type)
{
case MidiMessageType.NoteOff:
var noteOffMessage = (MidiNoteOffMessage)receivedMidiMessage;
outputMessage.Append(", Channel: ").Append(noteOffMessage.Channel).Append(", Note: ").Append(noteOffMessage.Note).Append(", Velocity: ").Append(noteOffMessage.Velocity);
break;
case MidiMessageType.NoteOn:
var noteOnMessage = (MidiNoteOnMessage)receivedMidiMessage;
outputMessage.Append(", Channel: ").Append(noteOnMessage.Channel).Append(", Note: ").Append(noteOnMessage.Note).Append(", Velocity: ").Append(noteOnMessage.Velocity);
break;
case MidiMessageType.PolyphonicKeyPressure:
var polyphonicKeyPressureMessage = (MidiPolyphonicKeyPressureMessage)receivedMidiMessage;
outputMessage.Append(", Channel: ").Append(polyphonicKeyPressureMessage.Channel).Append(", Note: ").Append(polyphonicKeyPressureMessage.Note).Append(", Pressure: ").Append(polyphonicKeyPressureMessage.Pressure);
break;
case MidiMessageType.ControlChange:
var controlChangeMessage = (MidiControlChangeMessage)receivedMidiMessage;
outputMessage.Append(", Channel: ").Append(controlChangeMessage.Channel).Append(", Controller: ").Append(controlChangeMessage.Controller).Append(", Value: ").Append(controlChangeMessage.ControlValue);
break;
case MidiMessageType.ProgramChange:
var programChangeMessage = (MidiProgramChangeMessage)receivedMidiMessage;
outputMessage.Append(", Channel: ").Append(programChangeMessage.Channel).Append(", Program: ").Append(programChangeMessage.Program);
break;
case MidiMessageType.ChannelPressure:
var channelPressureMessage = (MidiChannelPressureMessage)receivedMidiMessage;
outputMessage.Append(", Channel: ").Append(channelPressureMessage.Channel).Append(", Pressure: ").Append(channelPressureMessage.Pressure);
break;
case MidiMessageType.PitchBendChange:
var pitchBendChangeMessage = (MidiPitchBendChangeMessage)receivedMidiMessage;
outputMessage.Append(", Channel: ").Append(pitchBendChangeMessage.Channel).Append(", Bend: ").Append(pitchBendChangeMessage.Bend);
break;
case MidiMessageType.SystemExclusive:
var systemExclusiveMessage = (MidiSystemExclusiveMessage)receivedMidiMessage;
outputMessage.Append(", ");
// Read the SysEx bufffer
var sysExDataReader = DataReader.FromBuffer(systemExclusiveMessage.RawData);
while (sysExDataReader.UnconsumedBufferLength > 0)
{
byte byteRead = sysExDataReader.ReadByte();
// Pad with leading zero if necessary
outputMessage.Append(byteRead.ToString("X2")).Append(" ");
}
break;
case MidiMessageType.MidiTimeCode:
var timeCodeMessage = (MidiTimeCodeMessage)receivedMidiMessage;
outputMessage.Append(", FrameType: ").Append(timeCodeMessage.FrameType).Append(", Values: ").Append(timeCodeMessage.Values);
break;
case MidiMessageType.SongPositionPointer:
var songPositionPointerMessage = (MidiSongPositionPointerMessage)receivedMidiMessage;
outputMessage.Append(", Beats: ").Append(songPositionPointerMessage.Beats);
break;
case MidiMessageType.SongSelect:
var songSelectMessage = (MidiSongSelectMessage)receivedMidiMessage;
outputMessage.Append(", Song: ").Append(songSelectMessage.Song);
break;
case MidiMessageType.TuneRequest:
var tuneRequestMessage = (MidiTuneRequestMessage)receivedMidiMessage;
break;
case MidiMessageType.TimingClock:
var timingClockMessage = (MidiTimingClockMessage)receivedMidiMessage;
break;
case MidiMessageType.Start:
var startMessage = (MidiStartMessage)receivedMidiMessage;
break;
case MidiMessageType.Continue:
var continueMessage = (MidiContinueMessage)receivedMidiMessage;
break;
case MidiMessageType.Stop:
var stopMessage = (MidiStopMessage)receivedMidiMessage;
break;
case MidiMessageType.ActiveSensing:
var activeSensingMessage = (MidiActiveSensingMessage)receivedMidiMessage;
break;
case MidiMessageType.SystemReset:
var systemResetMessage = (MidiSystemResetMessage)receivedMidiMessage;
break;
case MidiMessageType.None:
throw new InvalidOperationException();
default:
break;
}
// Use the Dispatcher to update the messages on the UI thread
await Dispatcher.RunAsync(CoreDispatcherPriority.High, () =>
{
// Skip TimingClock and ActiveSensing messages to avoid overcrowding the list. Commment this check out to see all messages
if ((receivedMidiMessage.Type != MidiMessageType.TimingClock) && (receivedMidiMessage.Type != MidiMessageType.ActiveSensing))
{
this.inputDeviceMessages.Items.Add(outputMessage + "\n");
this.inputDeviceMessages.ScrollIntoView(this.inputDeviceMessages.Items[this.inputDeviceMessages.Items.Count - 1]);
this.rootPage.NotifyUser("Message received successfully!", NotifyType.StatusMessage);
}
});
}
private void OnMidiMessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
{
// Console.WriteLine("OnMidiMessageReceived: " + args.Message.Type);
switch (args.Message.Type)
{
case MidiMessageType.NoteOn:
var noteOnMessage = args.Message as MidiNoteOnMessage;
// a zero-velocity note-on message is equivalent to note-off
if (noteOnMessage.Velocity == 0 && TranslateZeroVelocityNoteOnMessage)
{
var ev1 = NoteOffMessageReceived;
if (ev1 != null)
{
ev1(this, new MidiNoteOffMessageReceivedEventArgs(noteOnMessage.Channel, noteOnMessage.Note, noteOnMessage.Velocity, true));
}
}
else
{
// normal note on message
var ev2 = NoteOnMessageReceived;
if (ev2 != null)
{
try
{
ev2(this, new MidiNoteOnMessageReceivedEventArgs(noteOnMessage.Channel, noteOnMessage.Note, noteOnMessage.Velocity));
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
}
break;
case MidiMessageType.NoteOff:
var noteOffMessage = args.Message as MidiNoteOffMessage;
var ev3 = NoteOffMessageReceived;
if (ev3 != null)
{
ev3(this, new MidiNoteOffMessageReceivedEventArgs(noteOffMessage.Channel, noteOffMessage.Note, noteOffMessage.Velocity, false));
}
break;
case MidiMessageType.ControlChange:
var ccMessage = args.Message as MidiControlChangeMessage;
var ev4 = ControlChangeMessageReceived;
if (ev4 != null)
{
ev4(this, new MidiControlChangeMessageReceivedEventArgs(ccMessage.Channel, ccMessage.Controller, ccMessage.ControlValue));
}
break;
case MidiMessageType.ProgramChange:
var programMessage = args.Message as MidiProgramChangeMessage;
var ev5 = ProgramChangeMessageReceived;
if (ev5 != null)
{
ev5(this, new MidiProgramChangeMessageReceivedEventArgs(programMessage.Channel, programMessage.Program));
}
break;
case MidiMessageType.PitchBendChange:
var pitchBendChangeMessage = args.Message as MidiPitchBendChangeMessage;
var ev6 = PitchBendChangeMessageReceived;
if (ev6 != null)
{
ev6(this, new MidiPitchBendChangeMessageReceivedEventArgs(pitchBendChangeMessage.Channel, pitchBendChangeMessage.Bend));
}
break;
// TODO: Add more message types
default:
// message type we don't handle above. Ignore
break;
}
}
