/// <summary>
/// Indicates if the stream has enough room to write the specified <paramref name="message"/> to the stream.
/// </summary>
/// <param name="message">Must no be null.</param>
/// <returns>Returns true if the message can be written.</returns>
public virtual bool CanWrite(IMidiMessage message)
{
Check.IfArgumentNull(message, nameof(message));
if (message is MidiShortMessage shortMessage)
{
return(StreamWriter.CanWriteShort());
}
if (message is MidiLongMessage longMessage)
{
return(StreamWriter.CanWriteLong(longMessage.GetData()));
}
throw new ArgumentException(
String.Format(CultureInfo.InvariantCulture,
"The type '{0}' is not supported for message argument.", message.GetType().FullName), nameof(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);
}
protected void SendMessage(IMidiMessage message)
{
Type type = message.GetType();
if (type == typeof(ChannelMessage))
{
this._midiSender.Send((ChannelMessage)message);
}
else if (type == typeof(SysExMessage))
{
this._midiSender.Send((SysExMessage)message);
}
if (TrackMessage != null)
{
TrackMessage(this, message);
}
}
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 bool IsTrackNameMetaMessage(IMidiMessage message)
{
// Guard.
if (!(message is MetaMessage))
{
return(false);
}
MetaMessage msg = (MetaMessage)message;
if (msg.Type == MetaType.TrackName)
{
return(true);
}
else
{
return(false);
}
}
protected void OnMessageReceived(IMidiMessage message)
{
MidiMessageEventHandler handler = MessageReceived;
if (handler != null)
{
if (PostEventsOnCreationContext)
{
context.Post(delegate(object dummy)
{
handler(message);
}, null);
}
else
{
handler(message);
}
}
}
public override void midiMessageRecieved(IMidiMessage msg)
{
LaunchpadKeySignalInfo sigInfo = convertToLaunchpadKeySignalInfo(msg);
LaunchpadKey key = launchpadKeyArrays[GlobalVariables.currentMode][sigInfo.row, sigInfo.col];
if (key.functions.Count > 0)
{
if (sigInfo.velocity == 127)
{
key.buttonActivated(true);
sendMidiMessage(convertToIMidiMessage(sigInfo.row, sigInfo.col, key.functions[key.currentFunction].lightControl.colorPressed));
}
else
{
key.buttonActivated(false);
sendMidiMessage(convertToIMidiMessage(sigInfo.row, sigInfo.col, key.functions[key.currentFunction].lightControl.colorReleased));
}
}
}
public string Parse(Sequence sequence)
{
StringBuilder lilypondContent = new StringBuilder();
List <string> stringList = new List <string>();
lilypondContent.AppendLine("\\relative c' {");
lilypondContent.AppendLine("\\clef treble");
System.Diagnostics.Debug.WriteLine(sequence);
_division = sequence.Division;
for (int i = 0; i < sequence.Count(); i++)
{
Track track = sequence[i];
foreach (var midiEvent in track.Iterator())
{
IMidiMessage midiMessage = midiEvent.MidiMessage;
// TODO: Split this switch statements and create separate logic.
// We want to split this so that we can expand our functionality later with new keywords for example.
// Hint: Command pattern? Strategies? Factory method?
if (midiMessage.MessageType == MessageType.Meta)
{
System.Diagnostics.Debug.WriteLine("Meta: " + (midiEvent.MidiMessage as MetaMessage).MetaType);
stringList.Add(getMetaString(midiMessage as MetaMessage, midiEvent, ref lilypondContent));
}
else
{
System.Diagnostics.Debug.WriteLine("Channel: " + (midiEvent.MidiMessage as ChannelMessage).Message);
stringList.Add(getChannelString(midiMessage as ChannelMessage, midiEvent, ref lilypondContent));
}
}
}
foreach (string s in stringList)
{
// Console.WriteLine(s);
}
lilypondContent.Append("}");
return(lilypondContent.ToString());
}
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);
}
}
/// <summary>
/// Writes a new event to the stream for the <paramref name="message"/>.
/// </summary>
/// <param name="message">Must not be null.</param>
/// <param name="deltaTime">The delta-time for the event.</param>
public virtual void Write(IMidiMessage message, int deltaTime)
{
Check.IfArgumentNull(message, nameof(message));
if (message is MidiShortMessage shortMessage)
{
Write(shortMessage, deltaTime);
return;
}
if (message is MidiLongMessage longMessage)
{
Write(longMessage, deltaTime);
return;
}
throw new ArgumentException(
String.Format(CultureInfo.InvariantCulture,
"The type '{0}' is not supported for message argument.", message.GetType().FullName), nameof(message));
}
public void processFile(Sequence midiSequence)
{
division = midiSequence.Division;
List <MidiEvent> allEvents = new List <MidiEvent>();;
//add all events to list
foreach (var track in midiSequence)
{
foreach (var midiEvent in track.Iterator())
{
IMidiMessage midiMessage = midiEvent.MidiMessage;
if (midiMessage.GetType() == typeof(MetaMessage))
{
addMetaMessage(midiEvent, allEvents);
}
if (midiMessage.GetType() == typeof(ChannelMessage))
{
addChannelMessage(midiEvent, allEvents);
}
}
}
//sort allNodes
MidiEvent[] allEventsArray = allEvents.ToArray();
sortAllEvents(allEventsArray);
noteBuilder.SetClef(new Clef(Clef.Key.G));
lastAbsoluteTicks = 0;
foreach (var midiEvent in allEventsArray)
{
IMidiMessage midiMessage = midiEvent.MidiMessage;
if (midiMessage.GetType() == typeof(MetaMessage))
{
handleMetaMessage(midiMessage);
}
if (midiMessage.GetType() == typeof(ChannelMessage))
{
handleChannelMessage(midiEvent);
}
}
}
public void ParseEvent(MidiEvent @event)
{
IMidiMessage message = @event.MidiMessage;
if (message.MessageType == MessageType.Channel)
{
ParseChannelMessage((ChannelMessage)message, @event);
}
else if (message.MessageType == MessageType.Meta)
{
ParseMetaMessage((MetaMessage)message, @event);
}
else if (message.MessageType == MessageType.SystemExclusive)
{
ParseSysExMessage((SysExMessage)message, @event);
}
else
{
UnhandledMidiEvent?.Invoke(this, new MidiEventArgs(@event));
}
}
private void tp_TrackMessage(object sender, IMidiMessage message)
{
if (!(message is Endogine.Midi.ChannelMessage)) //message.GetType() != typeof(Endogine.Midi.ChannelMessage))
{
return;
}
TrackPlayer tp = (TrackPlayer)sender;
ChannelMessage cm = (ChannelMessage)message;
if (cm.Command != ChannelCommand.NoteOn)
{
return;
}
if (cm.Data2 == 0)
{
return;
}
this._factory.CreateInteractor(tp, cm);
}
public static string MessageToString(IMidiMessage message)
{
switch (message.MessageType)
{
case MessageType.Channel:
var cm = (ChannelMessage)message;
return(cm.Command.ToString() + " Ch: " +
cm.MidiChannel.ToString() + " Nr: " +
cm.Data1.ToString() + " Value: " +
cm.Data2.ToString());
case MessageType.SystemExclusive:
var syx = (SysExMessage)message;
string result = "SysEx Message: ";
foreach (byte b in syx)
{
result += string.Format("{0:X2} ", b);
}
return(result);
case MessageType.SystemCommon:
var sym = (SysCommonMessage)message;
return(sym.SysCommonType.ToString() + " Data 1: " +
sym.Data1.ToString() + " Data 2: " +
sym.Data2.ToString());
case MessageType.SystemRealtime:
var rm = (SysRealtimeMessage)message;
return("Realtime Mesage: " + rm.SysRealtimeType.ToString());
case MessageType.Meta:
return("Meta Message");
case MessageType.Short:
var sm = (ShortMessage)message;
return("Short Message");
}
return(message.ToString());
}
public virtual bool CanWrite(IMidiMessage message)
{
Contract.Requires(message != null);
Check.IfArgumentNull(message, "message");
var shortMessage = message as MidiShortMessage;
if (shortMessage != null)
{
return(this.StreamWriter.CanWriteShort());
}
var longMessage = message as MidiLongMessage;
if (longMessage != null)
{
return(this.StreamWriter.CanWriteLong(longMessage.GetData()));
}
throw new ArgumentException(
String.Format(CultureInfo.InvariantCulture, "The type '{0}' is not supported for message argument.", message.GetType().FullName));
}
private List <Symbol> GetSymbolsFromTrack(Track track, int division, TimeSignature timeSignature, int start, int?end)
{
_symbols = new List <Symbol>();
_startedNoteIsClosed = true;
foreach (var midiEvent in track.Iterator())
{
IMidiMessage midiMessage = midiEvent.MidiMessage;
if (midiEvent.AbsoluteTicks < start)
{
continue;
}
if (end != null && midiEvent.AbsoluteTicks >= end)
{
return(_symbols);
}
if (midiMessage.MessageType != MessageType.Channel)
{
continue;
}
if (midiEvent.MidiMessage is ChannelMessage channelMessage)
{
if (channelMessage.Command == ChannelCommand.NoteOn)
{
StartNote(channelMessage, midiEvent.AbsoluteTicks, division);
}
else if (channelMessage.Command == ChannelCommand.NoteOff)
{
CloseNote(_symbols[_symbols.Count - 1], midiEvent.AbsoluteTicks, division);
}
}
}
return(_symbols);
}
public virtual void Write(IMidiMessage message, int deltaTime)
{
Contract.Requires(message != null);
Check.IfArgumentNull(message, "message");
var shortMessage = message as MidiShortMessage;
if (shortMessage != null)
{
this.Write(shortMessage, deltaTime);
return;
}
var longMessage = message as MidiLongMessage;
if (longMessage != null)
{
this.Write(longMessage, deltaTime);
return;
}
throw new ArgumentException(
String.Format(CultureInfo.InvariantCulture, "The type '{0}' is not supported for message argument.", message.GetType().FullName));
}
internal MidiEvent(object owner, int absoluteTicks, IMidiMessage message)
{
#region Require
if(owner == null)
{
throw new ArgumentNullException("owner");
}
else if(absoluteTicks < 0)
{
throw new ArgumentOutOfRangeException("absoluteTicks", absoluteTicks,
"Absolute ticks out of range.");
}
else if(message == null)
{
throw new ArgumentNullException("e");
}
#endregion
this.owner = owner;
this.absoluteTicks = absoluteTicks;
this.message = message;
}
internal MidiEvent(object owner, int absoluteTicks, IMidiMessage message)
{
#region Require
if (owner == null)
{
throw new ArgumentNullException("owner");
}
else if (absoluteTicks < 0)
{
throw new ArgumentOutOfRangeException("absoluteTicks", absoluteTicks,
"Absolute ticks out of range.");
}
else if (message == null)
{
throw new ArgumentNullException("e");
}
#endregion
this.owner = owner;
this.absoluteTicks = absoluteTicks;
this.message = message;
}
public TimestampedMessage(int ticks, IMidiMessage message)
{
this.ticks = ticks;
this.message = message;
}
public MidiEvent Insert(int absoluteTicks, IMidiMessage ev)
{
return(midiTrack.Insert(absoluteTicks, ev));
}
/// <summary>
/// Inserts an IMidiMessage at the specified position in absolute ticks.
/// </summary>
/// <param name="position">
/// The position in the Track in absolute ticks in which to insert the
/// IMidiMessage.
/// </param>
/// <param name="message">
/// The IMidiMessage to insert.
/// </param>
public void Insert(int position, IMidiMessage message)
{
#region Require
if(position < 0)
{
throw new ArgumentOutOfRangeException("position", position,
"IMidiMessage position out of range.");
}
else if(message == null)
{
throw new ArgumentNullException("message");
}
#endregion
MidiEvent newMidiEvent = new MidiEvent(this, position, message);
if(head == null)
{
head = newMidiEvent;
tail = newMidiEvent;
}
else if(position >= tail.AbsoluteTicks)
{
newMidiEvent.Previous = tail;
tail.Next = newMidiEvent;
tail = newMidiEvent;
endOfTrackMidiEvent.SetAbsoluteTicks(Length);
endOfTrackMidiEvent.Previous = tail;
}
else
{
MidiEvent current = head;
while(current.AbsoluteTicks < position)
{
current = current.Next;
}
newMidiEvent.Next = current;
newMidiEvent.Previous = current.Previous;
if(current.Previous != null)
{
current.Previous.Next = newMidiEvent;
}
else
{
head = newMidiEvent;
}
current.Previous = newMidiEvent;
}
count++;
#region Invariant
AssertValid();
#endregion
}
static void writeMessage(IMidiMessage m, Stream s)
{
s.WriteMidiMultiByte(m.DeltaTime);
switch (m)
{
case IMidiEvent e:
var status = (byte)(e.Channel | (byte)e.Type);
if (status != running_status)
{
s.WriteByte(status);
running_status = status;
}
switch (e)
{
case NoteOffEvent x:
s.WriteByte(x.Key);
s.WriteByte(x.Velocity);
break;
case NoteOnEvent x:
s.WriteByte(x.Key);
s.WriteByte(x.Velocity);
break;
case NotePressureEvent x:
s.WriteByte(x.Key);
s.WriteByte(x.Pressure);
break;
case ControllerEvent x:
s.WriteByte(x.Controller);
s.WriteByte(x.Value);
break;
case ProgramChgEvent x:
s.WriteByte(x.Program);
break;
case ChannelPressureEvent x:
s.WriteByte(x.Pressure);
break;
case PitchBendEvent x:
s.WriteBE(x.Bend);
break;
}
break;
case MetaEvent e:
// cancel running status
running_status = 0;
s.WriteByte(0xFF);
s.WriteByte((byte)e.MetaType);
switch (e)
{
case SequenceNumber x:
s.WriteMidiMultiByte(2);
s.WriteBE(x.Number);
break;
case TextEvent x:
s.WriteMidiMultiByte((uint)x.Text.Length);
s.Write(System.Text.Encoding.ASCII.GetBytes(x.Text), 0, x.Text.Length);
break;
case CopyrightNotice x:
s.WriteMidiMultiByte((uint)x.Text.Length);
s.Write(System.Text.Encoding.ASCII.GetBytes(x.Text), 0, x.Text.Length);
break;
case TrackName x:
s.WriteMidiMultiByte((uint)x.Text.Length);
s.Write(System.Text.Encoding.ASCII.GetBytes(x.Text), 0, x.Text.Length);
break;
case InstrumentName x:
s.WriteMidiMultiByte((uint)x.Text.Length);
s.Write(System.Text.Encoding.ASCII.GetBytes(x.Text), 0, x.Text.Length);
break;
case Lyric x:
s.WriteMidiMultiByte((uint)x.Text.Length);
s.Write(System.Text.Encoding.ASCII.GetBytes(x.Text), 0, x.Text.Length);
break;
case Marker x:
s.WriteMidiMultiByte((uint)x.Text.Length);
s.Write(System.Text.Encoding.ASCII.GetBytes(x.Text), 0, x.Text.Length);
break;
case CuePoint x:
s.WriteMidiMultiByte((uint)x.Text.Length);
s.Write(System.Text.Encoding.ASCII.GetBytes(x.Text), 0, x.Text.Length);
break;
case ChannelPrefix x:
s.WriteMidiMultiByte(1);
s.WriteByte(x.Channel);
break;
case EndOfTrackEvent x:
s.WriteMidiMultiByte(0);
break;
case TempoEvent x:
s.WriteMidiMultiByte(3);
s.WriteUInt24BE(x.MicrosPerQn);
break;
case SmtpeOffset x:
s.WriteMidiMultiByte(5);
var sdata = new byte[5] {
x.Hours, x.Minutes, x.Seconds, x.Frames, x.FrameHundredths
};
s.Write(sdata, 0, 5);
break;
case TimeSignature x:
s.WriteMidiMultiByte(4);
var tdata = new byte[4] {
x.Numerator, x.Denominator, x.ClocksPerTick, x.ThirtySecondNotesPer24Clocks
};
s.Write(tdata, 0, 4);
break;
case KeySignature x:
s.WriteMidiMultiByte(2);
s.WriteByte(x.Sharps);
s.WriteByte(x.Tonality);
break;
case SequencerSpecificEvent x:
s.WriteMidiMultiByte((uint)x.Data.Length);
s.Write(x.Data, 0, x.Data.Length);
break;
}
break;
case SysexEvent e:
// cancel running status
running_status = 0;
s.WriteByte(0xF0);
s.WriteMidiMultiByte((uint)e.Data.Length);
s.Write(e.Data, 0, e.Data.Length);
break;
}
}
/// <summary>
/// Adds a MIDI message to the chaser to use for updating the playback
/// settings later.
/// </summary>
/// <param name="message">
/// The MIDI message to add to the chaser.
/// </param>
/// <remarks>
/// Only certain MIDI messages are accepted by the chaser. If the
/// message is not accepted, no operation occurs.
/// </remarks>
public void Add(IMidiMessage message)
{
message.Accept(this);
}
/// <summary>
/// Inserts an IMidiMessage at the specified position in absolute ticks.
/// </summary>
/// <param name="position">
/// The position in the Track in absolute ticks in which to insert the
/// IMidiMessage.
/// </param>
/// <param name="message">
/// The IMidiMessage to insert.
/// </param>
public void Insert(int position, IMidiMessage message)
{
#region Require
if (position < 0)
{
throw new ArgumentOutOfRangeException("position", position,
"IMidiMessage position out of range.");
}
else if (message == null)
{
throw new ArgumentNullException("message");
}
#endregion
MidiEvent newMidiEvent = new MidiEvent(this, position, message);
if (head == null)
{
head = newMidiEvent;
tail = newMidiEvent;
}
else if (position >= tail.AbsoluteTicks)
{
newMidiEvent.Previous = tail;
tail.Next = newMidiEvent;
tail = newMidiEvent;
endOfTrackMidiEvent.SetAbsoluteTicks(Length);
endOfTrackMidiEvent.Previous = tail;
}
else
{
MidiEvent current = head;
while (current.AbsoluteTicks < position)
{
current = current.Next;
}
newMidiEvent.Next = current;
newMidiEvent.Previous = current.Previous;
if (current.Previous != null)
{
current.Previous.Next = newMidiEvent;
}
else
{
head = newMidiEvent;
}
current.Previous = newMidiEvent;
}
count++;
#region Invariant
AssertValid();
#endregion
}
/// <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);
}
});
}
public PadReleasedEventArgs(byte padNumber, IMidiMessage message)
: base(padNumber, message)
{
}
public MidiSequenceReader(string fileName)
{
Sequence midiSequence = new Sequence();
midiSequence.Load(fileName);
int division = midiSequence.Division;
INote previousNote = null;
int previousNoteAbsoluteTicks = 0;
double percentageOfBarReached = 0;
bool startedNoteIsClosed = true;
TimeSignature previousTimeSignature = null;
Sequence.Symbols.Add(new Clef(ClefType.GClef));
foreach (Track track in midiSequence)
{
foreach (MidiEvent midiEvent in track.Iterator())
{
IMidiMessage midiMessage = midiEvent.MidiMessage;
switch (midiMessage.MessageType)
{
case MessageType.Meta:
MetaMessage metaMessage = midiMessage as MetaMessage;
switch (metaMessage.MetaType)
{
case MetaType.TimeSignature:
ITimeSignatureEvent timeSignatureEvent = new MidiTimeSignatureEvent(metaMessage);
Sequence.Symbols.Add(timeSignatureEvent.TimeSignature);
previousTimeSignature = timeSignatureEvent.TimeSignature;
break;
case MetaType.Tempo:
ITempoEvent tempoEvent = new MidiTempoEvent(metaMessage);
Sequence.BeatsPerMinute = tempoEvent.BeatsPerMinute;
break;
case MetaType.EndOfTrack:
break;
}
break;
case MessageType.Channel:
ChannelMessage channelMessage = midiEvent.MidiMessage as ChannelMessage;
if (channelMessage.Command == ChannelCommand.NoteOn)
{
INoteEvent noteEvent = new MidiNoteEvent(channelMessage);
INote note = noteEvent.Note;
if (note != null)
{
Sequence.Symbols.Add(note);
previousNote = note;
startedNoteIsClosed = false;
}
else
{
// Previous note must be closed
IBarLineEvent barLineEvent = new MidiBarLineEvent(
midiEvent, previousNote, ref startedNoteIsClosed,
ref previousNoteAbsoluteTicks, division, previousTimeSignature,
ref percentageOfBarReached);
if (barLineEvent.BarLine != null) // End of bar has been reached, start a new one
{
Sequence.Symbols.Add(barLineEvent.BarLine);
}
}
}
break;
}
}
}
}
/// <summary>
/// Dispatches IMidiMessages to their corresponding sink.
/// </summary>
/// <param name="message">
/// The IMidiMessage to dispatch.
/// </param>
public void Dispatch(IMidiMessage message)
{
#region Require
if (message == null)
{
throw new ArgumentNullException("message");
}
#endregion
switch (message.MessageType)
{
case MessageType.Channel:
OnChannelMessageDispatched(new ChannelMessageEventArgs((ChannelMessage)message));
break;
case MessageType.SystemExclusive:
OnSysExMessageDispatched(new SysExMessageEventArgs((SysExMessage)message));
break;
case MessageType.Meta:
OnMetaMessageDispatched(new MetaMessageEventArgs((MetaMessage)message));
break;
case MessageType.SystemCommon:
OnSysCommonMessageDispatched(new SysCommonMessageEventArgs((SysCommonMessage)message));
break;
case MessageType.SystemRealtime:
switch (((SysRealtimeMessage)message).SysRealtimeType)
{
case SysRealtimeType.ActiveSense:
OnSysRealtimeMessageDispatched(SysRealtimeMessageEventArgs.ActiveSense);
break;
case SysRealtimeType.Clock:
OnSysRealtimeMessageDispatched(SysRealtimeMessageEventArgs.Clock);
break;
case SysRealtimeType.Continue:
OnSysRealtimeMessageDispatched(SysRealtimeMessageEventArgs.Continue);
break;
case SysRealtimeType.Reset:
OnSysRealtimeMessageDispatched(SysRealtimeMessageEventArgs.Reset);
break;
case SysRealtimeType.Start:
OnSysRealtimeMessageDispatched(SysRealtimeMessageEventArgs.Start);
break;
case SysRealtimeType.Stop:
OnSysRealtimeMessageDispatched(SysRealtimeMessageEventArgs.Stop);
break;
case SysRealtimeType.Tick:
OnSysRealtimeMessageDispatched(SysRealtimeMessageEventArgs.Tick);
break;
}
break;
}
}
public MidiEvent Insert(int absoluteTicks, IMidiMessage ev)
{
return midiTrack.Insert(absoluteTicks, ev);
}
private bool IsTrackNameMetaMessage(IMidiMessage message)
{
// Guard.
if(!(message is MetaMessage))
return false;
MetaMessage msg = (MetaMessage)message;
if(msg.Type == MetaType.TrackName)
return true;
else
return false;
}
protected void SendMessage(IMidiMessage message)
{
Type type = message.GetType();
if (type == typeof(ChannelMessage))
this._midiSender.Send((ChannelMessage)message);
else if (type == typeof(SysExMessage))
this._midiSender.Send((SysExMessage)message);
if (TrackMessage!=null)
TrackMessage(this, message);
}
public PadEventArgs(byte padNumber, IMidiMessage message)
{
PadNumber = padNumber;
Message = message;
}
public void SendMessage(IMidiMessage midiMessage)
{
throw new NotImplementedException();
}
public PadPressedEventArgs(byte padNumber, byte velocity, IMidiMessage message)
: base(padNumber, message)
{
Velocity = velocity;
}
/// <summary>
/// Initializes a new instance of the Midi event struct with the
/// specified Midi message and the number of ticks for this event.
/// </summary>
/// <param name="message">
/// The Midi message for the event.
/// </param>
/// <param name="ticks">
/// The delta tick value for the event.
/// </param>
public MidiEvent(IMidiMessage message, int ticks)
{
this.message = message;
this.ticks = ticks;
}
/// <summary>
/// Dispatches IMidiMessages to their corresponding sink.
/// </summary>
/// <param name="message">
/// The IMidiMessage to dispatch.
/// </param>
public void Dispatch(IMidiMessage message)
{
#region Require
if(message == null)
{
throw new ArgumentNullException("message");
}
#endregion
switch(message.MessageType)
{
case MessageType.Channel:
OnChannelMessageDispatched(new ChannelMessageEventArgs((ChannelMessage)message));
break;
case MessageType.SystemExclusive:
OnSysExMessageDispatched(new SysExMessageEventArgs((SysExMessage)message));
break;
case MessageType.Meta:
//OnMetaMessageDispatched(new MetaMessageEventArgs((MetaMessage)message));
//broke this so it would stop %$&^ing around after position data was changed. UNFORGIVABLE
break;
case MessageType.SystemCommon:
OnSysCommonMessageDispatched(new SysCommonMessageEventArgs((SysCommonMessage)message));
break;
case MessageType.SystemRealtime:
switch(((SysRealtimeMessage)message).SysRealtimeType)
{
case SysRealtimeType.ActiveSense:
OnSysRealtimeMessageDispatched(SysRealtimeMessageEventArgs.ActiveSense);
break;
case SysRealtimeType.Clock:
OnSysRealtimeMessageDispatched(SysRealtimeMessageEventArgs.Clock);
break;
case SysRealtimeType.Continue:
OnSysRealtimeMessageDispatched(SysRealtimeMessageEventArgs.Continue);
break;
case SysRealtimeType.Reset:
OnSysRealtimeMessageDispatched(SysRealtimeMessageEventArgs.Reset);
break;
case SysRealtimeType.Start:
OnSysRealtimeMessageDispatched(SysRealtimeMessageEventArgs.Start);
break;
case SysRealtimeType.Stop:
OnSysRealtimeMessageDispatched(SysRealtimeMessageEventArgs.Stop);
break;
case SysRealtimeType.Tick:
OnSysRealtimeMessageDispatched(SysRealtimeMessageEventArgs.Tick);
break;
}
break;
}
}
/// <summary>
/// TODO: Create our own domain classes to be independent of external libraries/languages.
/// </summary>
/// <param name="sequence"></param>
/// <returns></returns>
public string LoadMidiIntoLilypond(Sequence sequence)
{
StringBuilder lilypondContent = new StringBuilder();
lilypondContent.AppendLine("\\relative c' {");
lilypondContent.AppendLine("\\clef treble");
int division = sequence.Division;
int previousMidiKey = 60; // Central C;
int previousNoteAbsoluteTicks = 0;
double percentageOfBarReached = 0;
bool startedNoteIsClosed = true;
for (int i = 0; i < sequence.Count(); i++)
{
Track track = sequence[i];
foreach (var midiEvent in track.Iterator())
{
IMidiMessage midiMessage = midiEvent.MidiMessage;
// TODO: Split this switch statements and create separate logic.
// We want to split this so that we can expand our functionality later with new keywords for example.
// Hint: Command pattern? Strategies? Factory method?
switch (midiMessage.MessageType)
{
case MessageType.Meta:
var metaMessage = midiMessage as MetaMessage;
switch (metaMessage.MetaType)
{
case MetaType.TimeSignature:
byte[] timeSignatureBytes = metaMessage.GetBytes();
_beatNote = timeSignatureBytes[0];
_beatsPerBar = (int)(1 / Math.Pow(timeSignatureBytes[1], -2));
lilypondContent.AppendLine($"\\time {_beatNote}/{_beatsPerBar}");
break;
case MetaType.Tempo:
byte[] tempoBytes = metaMessage.GetBytes();
int tempo = (tempoBytes[0] & 0xff) << 16 | (tempoBytes[1] & 0xff) << 8 | (tempoBytes[2] & 0xff);
_bpm = 60000000 / tempo;
lilypondContent.AppendLine($"\\tempo 4={_bpm}");
break;
case MetaType.EndOfTrack:
if (previousNoteAbsoluteTicks > 0)
{
// Finish the last notelength.
double percentageOfBar;
lilypondContent.Append(MidiToLilyHelper.GetLilypondNoteLength(previousNoteAbsoluteTicks, midiEvent.AbsoluteTicks, division, _beatNote, _beatsPerBar, out percentageOfBar));
lilypondContent.Append(" ");
percentageOfBarReached += percentageOfBar;
if (percentageOfBarReached >= 1)
{
lilypondContent.AppendLine("|");
percentageOfBar = percentageOfBar - 1;
}
}
break;
default: break;
}
break;
case MessageType.Channel:
var channelMessage = midiEvent.MidiMessage as ChannelMessage;
if (channelMessage.Command == ChannelCommand.NoteOn)
{
if (channelMessage.Data2 > 0) // Data2 = loudness
{
// Append the new note.
lilypondContent.Append(MidiToLilyHelper.GetLilyNoteName(previousMidiKey, channelMessage.Data1));
previousMidiKey = channelMessage.Data1;
startedNoteIsClosed = false;
}
else if (!startedNoteIsClosed)
{
// Finish the previous note with the length.
double percentageOfBar;
lilypondContent.Append(MidiToLilyHelper.GetLilypondNoteLength(previousNoteAbsoluteTicks, midiEvent.AbsoluteTicks, division, _beatNote, _beatsPerBar, out percentageOfBar));
previousNoteAbsoluteTicks = midiEvent.AbsoluteTicks;
lilypondContent.Append(" ");
percentageOfBarReached += percentageOfBar;
if (percentageOfBarReached >= 1)
{
lilypondContent.AppendLine("|");
percentageOfBarReached -= 1;
}
startedNoteIsClosed = true;
}
else
{
lilypondContent.Append("r");
}
}
break;
}
}
}
lilypondContent.Append("}");
return(lilypondContent.ToString());
}
public MidiEvent Insert(int position, IMidiMessage message)
{
var newMidiEvent = new MidiEvent(position, message);
if (newMidiEvent.Command == ChannelCommand.NoteOn && newMidiEvent.Data2 == 0)
{
newMidiEvent.SetChanMessageData(ChannelMessage.PackCommand(newMidiEvent.MessageData, ChannelCommand.NoteOff));
}
var isAtEnd = position >= Length - 1;
var isChanMessage = newMidiEvent.MessageType == MessageType.Channel;
if (isAtEnd)
{
AddEvent(newMidiEvent);
}
else
{
var after = eventList.SkipWhile(x => x.AbsoluteTicks < position).ToList();
if (!after.Any())
{
AddEvent(newMidiEvent);
}
else
{
var eq = after.TakeWhile(x => x.AbsoluteTicks == position).ToList();
if (!eq.Any())
{
InsertAt(eventList.IndexOf(after.First()), newMidiEvent);
}
else
{
if (message.MessageType == MessageType.Channel)
{
var chanMess = (ChannelMessage)message;
var eqChan = eq.Where(x => x.MessageType == MessageType.Channel).ToList().Select(x => new ChannelMessage(x.MessageData)).ToList();
if (!eqChan.Any())
{
InsertAt(eventList.IndexOf(eq.First()), newMidiEvent);
}
else
{
if (chanMess.Command == ChannelCommand.NoteOff)
{
InsertAt(eventList.IndexOf(eq.First()), newMidiEvent);
}
else
{
InsertAt(eventList.IndexOf(eq.Last()) + 1, newMidiEvent);
}
}
}
else
{
InsertAt(eventList.IndexOf(eq.First()), newMidiEvent);
}
}
}
}
Dirty = true;
return(newMidiEvent);
}
private void tp_TrackMessage(object sender, IMidiMessage message)
{
if (!(message is Endogine.Midi.ChannelMessage)) //message.GetType() != typeof(Endogine.Midi.ChannelMessage))
return;
TrackPlayer tp = (TrackPlayer)sender;
ChannelMessage cm = (ChannelMessage)message;
if (cm.Command != ChannelCommand.NoteOn)
return;
if (cm.Data2 == 0)
return;
this._factory.CreateInteractor(tp, cm);
}
