private static void TestInsert()
{
Track track = new Track();
int midiEventCount = 2000;
int positionMax = 32000;
int endOfTrackOffset = 1000;
int length = 0;
int position = 0;
ChannelMessage message = new ChannelMessage(ChannelCommand.NoteOff, 0, 60, 0);
Random r = new Random();
for(int i = 0; i < midiEventCount; i++)
{
position = r.Next(positionMax);
if(position > length)
{
length = position;
}
track.Insert(position, message);
}
track.EndOfTrackOffset = endOfTrackOffset;
length += track.EndOfTrackOffset;
Debug.Assert(track.Count == midiEventCount + 1);
Debug.Assert(track.Length == length);
}
private static void TestRemoveAt()
{
Track a = new Track();
ChannelMessage message = new ChannelMessage(ChannelCommand.NoteOff, 0, 60, 0);
a.Insert(0, message);
a.Insert(10, message);
a.Insert(20, message);
a.Insert(30, message);
a.Insert(40, message);
int count = a.Count;
a.RemoveAt(0);
Debug.Assert(a.Count == count - 1);
a.RemoveAt(a.Count - 2);
Debug.Assert(a.Count == count - 2);
Debug.Assert(a.GetMidiEvent(0).AbsoluteTicks == 10);
Debug.Assert(a.GetMidiEvent(a.Count - 2).AbsoluteTicks == 30);
a.RemoveAt(0);
a.RemoveAt(0);
a.RemoveAt(0);
Debug.Assert(a.Count == 1);
}
public void Process(ChannelMessage message)
{
switch(message.Command)
{
case ChannelCommand.Controller:
controllerMessages[message.MidiChannel, message.Data1] = message;
break;
case ChannelCommand.ChannelPressure:
channelPressureMessages[message.MidiChannel] = message;
break;
case ChannelCommand.PitchWheel:
pitchBendMessages[message.MidiChannel] = message;
break;
case ChannelCommand.PolyPressure:
polyPressureMessages[message.MidiChannel] = message;
break;
case ChannelCommand.ProgramChange:
programChangeMessages[message.MidiChannel] = message;
break;
}
}
public override void SetData(ChannelMessage midiChannelMessage)
{
if (midiChannelMessage.Command != channelCommand ) return;
if (midiChannelMessage.MidiChannel != midiChannel) return;
if (midiChannelMessage.Data1 != data1) return;
Value = midiChannelMessage.Data2;
}
public void Process(ChannelMessage message)
{
switch(message.Command)
{
case ChannelCommand.NoteOn:
if(message.Data2 > 0)
{
noteOnMessage[message.MidiChannel, message.Data1] = message;
}
else
{
noteOnMessage[message.MidiChannel, message.Data1] = null;
}
break;
case ChannelCommand.NoteOff:
noteOnMessage[message.MidiChannel, message.Data1] = null;
break;
case ChannelCommand.Controller:
switch(message.Data1)
{
case (int)ControllerType.HoldPedal1:
if(message.Data2 > 63)
{
holdPedal1Message[message.MidiChannel] = true;
}
else
{
holdPedal1Message[message.MidiChannel] = false;
}
break;
case (int)ControllerType.HoldPedal2:
if(message.Data2 > 63)
{
holdPedal2Message[message.MidiChannel] = true;
}
else
{
holdPedal2Message[message.MidiChannel] = false;
}
break;
case (int)ControllerType.SustenutoPedal:
if(message.Data2 > 63)
{
sustenutoMessage[message.MidiChannel] = true;
}
else
{
sustenutoMessage[message.MidiChannel] = false;
}
break;
}
break;
}
}
public static void appendFingeringToMidiFile(Midi.Sequence file, Fingering[] fingerings)
{
if (file.Count == 0)
{
Debug.LogWarning("MIDI no track found.");
return;
}
var FingerMap = new Dictionary <int, Dictionary <int, Finger> >();
foreach (var fingering in fingerings)
{
if (fingering.markers == null)
{
Debug.LogWarning("fingering markers is null.");
continue;
}
foreach (var marker in fingering.markers)
{
if (!FingerMap.ContainsKey(marker.tick))
{
FingerMap[marker.tick] = new Dictionary <int, Finger>();
}
FingerMap[marker.tick][marker.pitch] = marker.finger;
//Debug.LogFormat("marker: {0}, {1}, {2}", marker.tick, marker.pitch, marker.finger);
}
}
clearFingeringInMidiFile(file);
foreach (Midi.Track track in file)
{
foreach (Midi.MidiEvent e in track.Iterator())
{
if (e.MidiMessage.MessageType == Midi.MessageType.Channel)
{
Midi.ChannelMessage cm = e.MidiMessage as Midi.ChannelMessage;
if (cm.Command == Midi.ChannelCommand.NoteOn)
{
if (FingerMap.ContainsKey(e.AbsoluteTicks) && FingerMap[e.AbsoluteTicks].ContainsKey(cm.Data1))
{
Finger f = FingerMap[e.AbsoluteTicks][cm.Data1];
string marker = string.Format("finger:{0}|{1}", cm.Data1, (int)f);
track.Insert(e.AbsoluteTicks, new Midi.MetaMessage(Midi.MetaType.Marker, Encoding.Default.GetBytes(marker)));
}
}
}
}
}
file[0].Insert(0, new Midi.MetaMessage(Midi.MetaType.Text, Encoding.Default.GetBytes(MidiSignatureText)));
}
public override void SetData(ChannelMessage midiChannelMessage)
{
if (midiChannelMessage.Command == ChannelCommand.NoteOff || midiChannelMessage.Command == ChannelCommand.NoteOn)
{
if (midiChannelMessage.MidiChannel != midiChannel) return;
if (midiChannelMessage.Data1 != data1) return;
Velocity = (midiChannelMessage.Command == ChannelCommand.NoteOff ) ? 0 : midiChannelMessage.Data2;
Pressed = (midiChannelMessage.Command == ChannelCommand.NoteOff) ? false : midiChannelMessage.Data2 > 0;
}
}
public void Send(ChannelMessage message)
{
if (message.Command == ChannelCommand.NoteOn &&
message.Data1 >= LowNoteID && message.Data1 <= HighNoteID)
{
if (message.Data2 > 0)
{
string sbName = "";
switch (message.Data1)
{
case (int)DrumInstrument.AcousticSnare: //38,
case (int)DrumInstrument.ElectricSnare: //40,
sbName = "sbSnareDrum";
break;
case (int)DrumInstrument.LowFloorTom: //41,
case (int)DrumInstrument.HighFloorTom: //43,
sbName = "sbFloorTom";
break;
case (int)DrumInstrument.LowTom: //45,
case (int)DrumInstrument.LowMidTom: //47,
sbName = "sbTom1";
break;
case (int)DrumInstrument.HiMidtom: //48,
case (int)DrumInstrument.HighTom: //50,
sbName = "sbTom2";
break;
case (int)DrumInstrument.AcousticBassDrum: //35,
case (int)DrumInstrument.BassDrum: //36,
sbName = "sbBassDrum";
break;
case (int)DrumInstrument.ClosedHiHat: //42,
case (int)DrumInstrument.PedalHiHat: //44,
case (int)DrumInstrument.OpenHiHat: //46,
sbName = "sbHiHat";
break;
case (int)DrumInstrument.CrashCymbal: //49,
case (int)DrumInstrument.RideCymbal: //51
sbName = "sbRideCymbal";
break;
}
if (!string.IsNullOrEmpty(sbName))
{
Storyboard sb = (Storyboard)FindResource(sbName);
sb.Stop();
sb.Begin();
}
}
}
}
public void Send(ChannelMessage message)
{
int LowNoteID = 0;
int HighNoteID = 87;
Byte b ;
if (message.Command == ChannelCommand.NoteOn &&
message.Data1 >= LowNoteID && message.Data1 <= HighNoteID)
{
b = (byte) (message.Data1 -21) ;
KeyDown(b);
}
else if (message.Command == ChannelCommand.NoteOff &&
message.Data1 >= LowNoteID && message.Data1 <= HighNoteID)
{
b = (byte) (message.Data1 - 21);
KeyUp(b);
}
}
public static PianoKeyStrokeEventArgs ConvertChannelMessageToKeyStrokeEventArgs(ChannelMessage channelMessage)
{
var pksea = new PianoKeyStrokeEventArgs();
//If the key stroke is neither a press or a release, return a null object
switch (channelMessage.Command)
{
case ChannelCommand.NoteOn:
pksea.keyStrokeType = KeyStrokeType.KeyPress;
break;
case ChannelCommand.NoteOff:
pksea.keyStrokeType = KeyStrokeType.KeyRelease;
break;
default: return null;
}
pksea.midiKeyId = channelMessage.Data1;
pksea.KeyVelocity = channelMessage.Data2;
//Velocity 0 is effectively a key release
if (pksea.KeyVelocity == 0) pksea.keyStrokeType = KeyStrokeType.KeyRelease;
return pksea;
}
/// <summary>
/// Builds a ChannelMessageEventArgs.
/// </summary>
public void Build()
{
result = (ChannelMessage)messageCache[message];
// If the message does not exist.
if(result == null)
{
result = new ChannelMessage(message);
// Add message to cache.
messageCache.Add(message, result);
}
}
/// <summary>
/// Initializes the ChannelMessageBuilder with the specified
/// ChannelMessageEventArgs.
/// </summary>
/// <param name="message">
/// The ChannelMessageEventArgs to use for initializing the ChannelMessageBuilder.
/// </param>
public void Initialize(ChannelMessage message)
{
this.message = message.Message;
}
/* public override bool Equals(Object obj)
{
var midiInputEvent = obj as IMidiEventListener;
if (midiInputEvent == null)
{
return false;
}
return Command == midiInputEvent.Command &&
MidiChannel == midiInputEvent.MidiChannel &&
Data1 == midiInputEvent.Data1;
}
*/
public abstract void SetData(ChannelMessage midiChannelMessage);
/// <summary>
/// Initializes the ChannelMessageBuilder with the specified
/// ChannelMessageEventArgs.
/// </summary>
/// <param name="message">
/// The ChannelMessageEventArgs to use for initializing the ChannelMessageBuilder.
/// </param>
public void Initialize(ChannelMessage message)
{
this.message = message.Message;
}
public override void Send(ChannelMessage message)
{
#region Require
if(IsDisposed)
{
throw new ObjectDisposedException(this.GetType().Name);
}
#endregion
lock(lockObject)
{
// If running status is enabled.
if(runningStatusEnabled)
{
// If the message's status value matches the running status.
if(message.Status == runningStatus)
{
// Send only the two data bytes without the status byte.
Send(message.Message >> 8);
}
// Else the message's status value does not match the running
// status.
else
{
// Send complete message with status byte.
Send(message.Message);
// Update running status.
runningStatus = message.Status;
}
}
// Else running status has not been enabled.
else
{
Send(message.Message);
}
}
}
public ChannelMessageBuilder Initialize(ChannelMessage message)
{
this.message = message.Message;
return this;
}
/// <summary>
/// Evaluate a received midi message and take the appropriate action.
/// </summary>
private void CheckReceivedMessage(ChannelMessage channelMessage)
{
if (GameMode != GameMode.InFlashcard)
return;
if (channelMessage.Command != ChannelCommand.NoteOn)
return;
var receivedNote = Note.FromMIDI(channelMessage.Data1);
bool correct = false;
bool flashcardFinished = false;
if (!_currentResponse.ContainsKey(receivedNote)) // incorrect note.
{
correct = false;
flashcardFinished = true;
// play the flashcard out on the MIDI device so the user hears the correct answer.
if (_outputDevice != null)
PlayFlashcard(_currentFlashcard);
}
else
{
correct = true;
_currentResponse[receivedNote] = true; // mark the note as complete.
flashcardFinished = _currentResponse.Values.All(r => r); // if we got them all, the flashcard is correct.
}
if (flashcardFinished)
{
_flashcardTimer.Stop();
GameMode = GameMode.BetweenFlashcards;
FlashcardResult result;
int points;
if (correct)
{
result = FlashcardResult.Correct(_currentFlashcard, _currentFlashcardStartTime);
points = POINTS_CORRECT;
}
else
{
result = FlashcardResult.Incorrect(_currentFlashcard, _currentFlashcardStartTime);
points = POINTS_INCORRECT;
}
Points += points;
_flashcardResults.Add(result);
if (FlashcardResponded != null)
FlashcardResponded(this, new FlashcardResultEventArgs(result));
_nextFlashcardTimer.Start();
}
}
private void ProcessMIDI()
{
Midi.Sequence _MIDISequence;
// default MIDI tempos/milliseconds per tick
int tempo = 500000;
float msPerTick = (tempo / 48) / 1000.0f;
_MIDISequence = new Midi.Sequence();
_MIDISequence.Load(_sequence.MusicFile);
if (_MIDISequence.SequenceType != Sanford.Multimedia.Midi.SequenceType.Ppqn)
{
MessageBox.Show("Unsupported MIDI type...sorry!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
foreach (Midi.Track t in _MIDISequence)
{
IEnumerator <Midi.MidiEvent> en = t.Iterator().GetEnumerator();
while (en.MoveNext())
{
Midi.MidiEvent e = en.Current;
switch (e.MidiMessage.MessageType)
{
// starta new channel
case Sanford.Multimedia.Midi.MessageType.Channel:
Midi.ChannelMessage channel = (Midi.ChannelMessage)e.MidiMessage;
// if it's a note on command and it's in our mapping list
if (channel.Command == Sanford.Multimedia.Midi.ChannelCommand.NoteOn &&
_midiMap.ContainsKey(channel.MidiChannel) &&
(int)((e.AbsoluteTicks * msPerTick) / 50) < _sequence.Channels[_midiMap[channel.MidiChannel]].Data.Length)
{
// this means the note is on
if (channel.Data2 > 0)
{
_sequence.Channels[_midiMap[channel.MidiChannel]].Data[(int)((e.AbsoluteTicks * msPerTick) / 50)] = true;
}
else
{
// the note is off
_sequence.Channels[_midiMap[channel.MidiChannel]].Data[(int)((e.AbsoluteTicks * msPerTick) / 50)] = false;
if (chkHold.Checked)
{
// backfill the grid
for (int i = (int)((e.AbsoluteTicks * msPerTick) / 50); i > 0 && !_sequence.Channels[_midiMap[channel.MidiChannel]].Data[i]; i--)
{
_sequence.Channels[_midiMap[channel.MidiChannel]].Data[i] = true;
}
}
}
}
// true note off...don't see this used much
if (channel.Command == Sanford.Multimedia.Midi.ChannelCommand.NoteOff &&
_midiMap.ContainsKey(channel.MidiChannel))
{
_sequence.Channels[_midiMap[channel.MidiChannel]].Data[(int)((e.AbsoluteTicks * msPerTick) / 50)] = false;
if (chkHold.Checked)
{
for (int i = (int)((e.AbsoluteTicks * msPerTick) / 50); i > 0 && !_sequence.Channels[_midiMap[channel.MidiChannel]].Data[i]; i--)
{
_sequence.Channels[_midiMap[channel.MidiChannel]].Data[i] = true;
}
}
}
break;
case Sanford.Multimedia.Midi.MessageType.Meta:
Midi.MetaMessage meta = (Midi.MetaMessage)e.MidiMessage;
switch (meta.MetaType)
{
// again, get the tempo value
case Sanford.Multimedia.Midi.MetaType.Tempo:
tempo = meta.GetBytes()[0] << 16 | meta.GetBytes()[1] << 8 | meta.GetBytes()[2];
msPerTick = (tempo / _MIDISequence.Division) / 1000.0f;
break;
}
break;
}
}
}
}
/// <summary>
/// Initializes a new instance of the ChannelMessageBuilder class with
/// the specified ChannelMessageEventArgs.
/// </summary>
/// <param name="message">
/// The ChannelMessageEventArgs to use for initializing the ChannelMessageBuilder.
/// </param>
/// <remarks>
/// The ChannelMessageBuilder uses the specified ChannelMessageEventArgs to
/// initialize its property values.
/// </remarks>
public ChannelMessageBuilder(ChannelMessage message)
{
Initialize(message);
}
/// <summary>
/// Play the notes from a flashcard through the output device.
/// </summary>
/// <param name="f"></param>
private void PlayFlashcard(Flashcard f)
{
ChannelMessageBuilder cbm = new ChannelMessageBuilder();
cbm.Command = ChannelCommand.NoteOn;
cbm.Data2 = 75;
cbm.MidiChannel = 0;
cbm.Build();
cbm.Command = ChannelCommand.NoteOff;
var onMessages = new ChannelMessage[f.StaffNotes.Length];
var offMessages = new ChannelMessage[f.StaffNotes.Length];
for (var i = 0; i < f.StaffNotes.Length; i++)
{
cbm.Data1 = f.StaffNotes[i].NoteRepresentation.Note.MIDINumber;
cbm.Command = ChannelCommand.NoteOn;
cbm.Build();
onMessages[i] = cbm.Result;
cbm.Command = ChannelCommand.NoteOff;
cbm.Build();
offMessages[i] = cbm.Result;
}
var t = new Timer(500) { AutoReset = false };
t.Elapsed += (s, a) => Array.ForEach(offMessages, m => _outputDevice.Send(m));
Array.ForEach(onMessages, m => _outputDevice.Send(m));
t.Start();
}
private void GetMIDIInfo(string file, bool fillTime)
{
Midi.Sequence MIDISequence;
int tempo = 500000;
int maxtick = 0;
float msPerTick = (tempo / 48) / 1000.0f;
string title = string.Empty;
_MIDIChannels = new BindingList <MIDIChannel>();
// load the MIDI file
MIDISequence = new Midi.Sequence();
MIDISequence.Load(file);
// we don't handle non-PPQN MIDI files
if (MIDISequence.SequenceType != Sanford.Multimedia.Midi.SequenceType.Ppqn)
{
MessageBox.Show("Unsupported MIDI type...sorry!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
foreach (Midi.Track t in MIDISequence)
{
// get the command enumerator
IEnumerator <Midi.MidiEvent> en = t.Iterator().GetEnumerator();
bool channelAdded = false;
while (en.MoveNext())
{
Midi.MidiEvent e = en.Current;
switch (e.MidiMessage.MessageType)
{
case Sanford.Multimedia.Midi.MessageType.Channel: // track the # of channels
Midi.ChannelMessage channel = (Midi.ChannelMessage)e.MidiMessage;
if (!channelAdded)
{
_MIDIChannels.Add(new MIDIChannel(channel.MidiChannel, title));
channelAdded = true;
}
break;
case Sanford.Multimedia.Midi.MessageType.Meta:
Midi.MetaMessage meta = (Midi.MetaMessage)e.MidiMessage;
switch (meta.MetaType)
{
// cache away the track name for the grid
case Sanford.Multimedia.Midi.MetaType.TrackName:
title = Encoding.ASCII.GetString(meta.GetBytes());
break;
// get the tempo and convert to a time value we can use
case Sanford.Multimedia.Midi.MetaType.Tempo:
tempo = meta.GetBytes()[0] << 16 | meta.GetBytes()[1] << 8 | meta.GetBytes()[2];
msPerTick = (tempo / MIDISequence.Division) / 1000.0f;
break;
}
break;
}
// find the highest time value
if (e.AbsoluteTicks > maxtick)
{
maxtick = e.AbsoluteTicks;
}
}
}
// and use that value to fill in the minutes/seconds
if (fillTime)
{
txtMinutes.Text = (((int)(msPerTick * maxtick) / 1000) / 60).ToString();
txtSeconds.Text = (((int)(msPerTick * maxtick) / 1000) % 60 + 1).ToString();
}
}
/// <summary>
/// Stop note
/// </summary>
/// <param name="note">Note number</param>
/// <param name="v">Velocity</param>
public void StopNote(int note, int v)
{
ChannelMessage mess = new ChannelMessage(ChannelCommand.NoteOff, 0, note, v);
outDevice.Send(mess);
}
private void Write(ChannelMessage message)
{
if (runningStatus != message.Status)
{
trackData.Add((byte)message.Status);
runningStatus = message.Status;
}
trackData.Add((byte)message.Data1);
if (ChannelMessage.DataBytesPerType(message.Command) == 2)
{
trackData.Add((byte)message.Data2);
}
}
public void Send(ChannelMessage message)
{
if (message.Command == ChannelCommand.NoteOn &&
message.Data1 >= LowNoteID && message.Data1 <= HighNoteID)
{
if (message.Data2 > 0)
{
if (!dicNotesOn.ContainsKey(message.Data1))
{
var row = 0;
var col = 0;
var stringId = 0;
Rectangle stringRect = null;
//We look for the StringInfo matching the
//note information
var stringInfoQuery = from si in stringInfos
where message.Data1 >= si.Min && message.Data1 <= si.Max
select si;
if (stringInfoQuery.Any())
{
var stringInfo = stringInfoQuery.First();
row = stringInfo.Row;
col = message.Data1 - stringInfo.Min;
stringRect = stringInfo.Rect;
stringId = stringInfo.Row;
}
if (stringRect != null)
{
stringRect.Stroke =
stringRect.Fill = stringOnColor;
stringRect.Height = 1;
}
//This border shows which note
//is being played
var noteOn = new Border()
{
Width = 12,
Height = 12,
Background = innerColor,
BorderBrush = outerColor,
Tag = stringId,
CornerRadius = new CornerRadius(2, 2, 2, 2)
};
//This text block displays
//the fret number
var txt = new TextBlock()
{
Text = col.ToString(),
Foreground = fontBrush,
HorizontalAlignment = System.Windows.HorizontalAlignment.Center,
VerticalAlignment = System.Windows.VerticalAlignment.Center,
FontWeight = FontWeights.Bold,
FontSize = 10
};
noteOn.Child = txt;
noteOn.SetValue(Grid.RowProperty, row);
noteOn.SetValue(Grid.ColumnProperty, col);
dicNotesOn.Add(message.Data1, noteOn);
grdArm.Children.Add(noteOn);
}
}
else if (message.Data2 == 0)
{
if (dicNotesOn.ContainsKey(message.Data1))
{
var noteOff = dicNotesOn[message.Data1];
dicNotesOn.Remove(message.Data1);
grdArm.Children.Remove(noteOff);
var stringId = (int)noteOff.Tag;
TurnOffString(stringId);
}
}
}
else if (message.Command == ChannelCommand.NoteOff)
{
if (dicNotesOn.ContainsKey(message.Data1))
{
var noteOff = dicNotesOn[message.Data1];
dicNotesOn.Remove(message.Data1);
grdArm.Children.Remove(noteOff);
var stringId = (int)noteOff.Tag;
TurnOffString(stringId);
}
}
}
public static NotationTrack parseMidiTrack(Midi.Track track, int division, ref Regex fingerPattern)
{
int microsecondsPerBeat = Midi.PpqnClock.DefaultTempo;
float time = 0;
TrackStatus trackStatus = new TrackStatus();
FingerChordMap fingerMap = new FingerChordMap();
List <Note> notes = new List <Note>();
Regex fingerMetaPattern = new Regex("fingering-marker-pattern:(.*)");
string name = "";
foreach (Midi.MidiEvent e in track.Iterator())
{
time += e.DeltaTicks * microsecondsPerBeat / (division * 1000);
switch (e.MidiMessage.MessageType)
{
case Midi.MessageType.Meta:
Midi.MetaMessage mm = e.MidiMessage as Midi.MetaMessage;
switch (mm.MetaType)
{
case Midi.MetaType.Tempo:
Midi.TempoChangeBuilder builder = new Midi.TempoChangeBuilder(mm);
microsecondsPerBeat = builder.Tempo;
break;
case Midi.MetaType.Text:
{
string text = Encoding.Default.GetString(mm.GetBytes());
var match = fingerMetaPattern.Match(text);
if (match.Success)
{
fingerPattern = new Regex(match.Groups[1].ToString());
Debug.LogFormat("Finger Pattern found: {0}", fingerPattern.ToString());
}
}
break;
case Midi.MetaType.Marker:
if (fingerPattern != null)
{
string text = Encoding.Default.GetString(mm.GetBytes());
var match = fingerPattern.Match(text);
if (match.Success)
{
//Debug.LogFormat("Finger: {0}", text);
try
{
int pitch = int.Parse(match.Groups[1].ToString());
Finger finger = (Finger)int.Parse(match.Groups[2].ToString());
if (!fingerMap.ContainsKey(e.AbsoluteTicks))
{
fingerMap[e.AbsoluteTicks] = new FingerChord();
}
fingerMap[e.AbsoluteTicks][pitch] = finger;
}
catch (System.Exception except)
{
Debug.LogWarningFormat("fingering marker parse failed: {0}, {1}", text, except.Message);
}
}
//else
// Debug.LogWarningFormat("fail marker: {0}", text);
}
break;
case Midi.MetaType.TrackName:
name = Encoding.Default.GetString(mm.GetBytes());
break;
}
break;
case Midi.MessageType.Channel:
Midi.ChannelMessage cm = e.MidiMessage as Midi.ChannelMessage;
if (!trackStatus.ContainsKey(cm.MidiChannel))
{
trackStatus[cm.MidiChannel] = new ChannelStatus();
}
var commandType = cm.Command;
if (commandType == Midi.ChannelCommand.NoteOn && cm.Data2 == 0)
{
commandType = Midi.ChannelCommand.NoteOff;
}
switch (commandType)
{
case Midi.ChannelCommand.NoteOn:
{
int pitch = cm.Data1;
int velocity = cm.Data2;
if (pitch >= Piano.PitchMin && pitch <= Piano.PitchMax)
{
trackStatus[cm.MidiChannel][pitch] = new PitchStatus {
tick = e.AbsoluteTicks, startTime = time, velocity = velocity
}
}
;
}
break;
case Midi.ChannelCommand.NoteOff:
{
int pitch = cm.Data1;
if (!trackStatus[cm.MidiChannel].ContainsKey(pitch))
{
Debug.LogWarningFormat("Unexpected noteOff: {0}, {1}", e.AbsoluteTicks, pitch);
}
else
{
PitchStatus status = trackStatus[cm.MidiChannel][pitch];
Note note = new Note {
tick = status.tick, start = status.startTime, duration = time - status.startTime, pitch = pitch, velocity = status.velocity
};
if (fingerMap.ContainsKey(note.tick) && fingerMap[note.tick].ContainsKey(note.pitch))
{
note.finger = fingerMap[note.tick][note.pitch];
}
notes.Add(note);
}
}
break;
}
break;
}
}
NotationTrack notation = new NotationTrack();
notation.notes = notes.ToArray();
notation.name = name;
return(notation);
}
/// <summary>
/// Initializes a new instance of the ChannelMessageBuilder class with
/// the specified ChannelMessageEventArgs.
/// </summary>
/// <param name="message">
/// The ChannelMessageEventArgs to use for initializing the ChannelMessageBuilder.
/// </param>
/// <remarks>
/// The ChannelMessageBuilder uses the specified ChannelMessageEventArgs to
/// initialize its property values.
/// </remarks>
public ChannelMessageBuilder(ChannelMessage message)
{
Initialize(message);
}
public void AddToTrack(Track track, double secondToTickMultiplier)
{
int startAbsoluteTick = (int)((StartTime + Program.MIDIPlaybackOffset) / secondToTickMultiplier);
int endAbsoluteTick = (int)((EndTime + Program.MIDIPlaybackOffset) / secondToTickMultiplier);
ChannelMessage startMessage = new ChannelMessage(ChannelCommand.NoteOn, 0, NoteIndex - Program.MIDI_OFFSET, Program.MIDIPlayer.Volume);
ChannelMessage endMessage = new ChannelMessage(ChannelCommand.NoteOff, 0, NoteIndex - Program.MIDI_OFFSET);
try
{
track.Insert(startAbsoluteTick, startMessage);
track.Insert(endAbsoluteTick, endMessage);
}
catch (Exception) { }
}
private static void TestMerge()
{
Track a = new Track();
Track b = new Track();
a.Merge(b);
Debug.Assert(a.Count == 1);
ChannelMessage message = new ChannelMessage(ChannelCommand.NoteOff, 0, 60, 0);
b.Insert(0, message);
b.Insert(10, message);
b.Insert(20, message);
b.Insert(30, message);
b.Insert(40, message);
a.Merge(b);
Debug.Assert(a.Count == 1 + b.Count - 1);
a.Clear();
Debug.Assert(a.Count == 1);
a.Insert(0, message);
a.Insert(10, message);
a.Insert(20, message);
a.Insert(30, message);
a.Insert(40, message);
int count = a.Count;
a.Merge(b);
Debug.Assert(a.Count == count + b.Count - 1);
Debug.Assert(a.GetMidiEvent(0).DeltaTicks == 0);
Debug.Assert(a.GetMidiEvent(1).DeltaTicks == 0);
Debug.Assert(a.GetMidiEvent(2).DeltaTicks == 10);
Debug.Assert(a.GetMidiEvent(3).DeltaTicks == 0);
Debug.Assert(a.GetMidiEvent(4).DeltaTicks == 10);
Debug.Assert(a.GetMidiEvent(5).DeltaTicks == 0);
Debug.Assert(a.GetMidiEvent(6).DeltaTicks == 10);
Debug.Assert(a.GetMidiEvent(7).DeltaTicks == 0);
Debug.Assert(a.GetMidiEvent(8).DeltaTicks == 10);
Debug.Assert(a.GetMidiEvent(9).DeltaTicks == 0);
}
public ChannelMessageEventArgs(ChannelMessage message)
{
this.message = message;
}
public static string GetID(ChannelMessage message)
{
if (message != null)
{
return GetID(message.Command, message.MidiChannel, message.Data1, message.Data2);
}
return null;
}
public virtual void Send(ChannelMessage message)
{
#region Require
if (IsDisposed)
{
throw new ObjectDisposedException(this.GetType().Name);
}
#endregion
Send(message.Message);
}
public ChannelMessageEventArgs(ChannelMessage message, int absoluteTicks = -1)
{
this.message = message;
this.AbsoluteTicks = absoluteTicks;
}