public void PlaybackCompletedToEnd()
{
var vt = new VirtualMidiPlayerTimeManager();
var music = TestHelper.GetMidiMusic();
var qmsec = MidiMusic.GetPlayTimeMillisecondsAtTick(music.Tracks [0].Messages, 4998, 192);
var player = TestHelper.GetMidiPlayer(vt, music);
bool completed = false, finished = false;
player.PlaybackCompletedToEnd += () => completed = true;
player.Finished += () => finished = true;
Assert.IsTrue(!completed, "1 PlaybackCompletedToEnd already fired");
Assert.IsTrue(!finished, "2 Finished already fired");
player.Play();
vt.ProceedBy(100);
Assert.IsTrue(!completed, "3 PlaybackCompletedToEnd already fired");
Assert.IsTrue(!finished, "4 Finished already fired");
vt.ProceedBy(qmsec);
Assert.AreEqual(12989, qmsec, "qmsec");
// FIXME: this is ugly
while (player.PlayDeltaTime < 4988)
{
Task.Delay(100);
}
Assert.AreEqual(4988, player.PlayDeltaTime, "PlayDeltaTime");
player.Pause();
player.Dispose();
Assert.IsTrue(completed, "5 PlaybackCompletedToEnd not fired");
Assert.IsTrue(finished, "6 Finished not fired");
}
public Midi(string filepath)
{
if (File.Exists(filepath))
{
if (Path.GetExtension(filepath).ToLower() == ".mid")
{
using (var fileStream = new FileStream(filepath, FileMode.Open))
{
file = MidiMusic.Read(fileStream);
//get tempo information from the midi
var t = file.GetMetaEventsOfType(MidiMetaType.Tempo).GetEnumerator();
t.MoveNext();
}
}
else
{
throw new IOException("Incorrect file type.");
}
}
else
{
throw new IOException("File doesn't exist.");
}
}
public MidiMusic DemoPixelMidi()
{
MidiMusic result = new MidiMusic();
short noteLen = 0x03C0;
int offset = 4 * noteLen;
result.DeltaTimeSpec = noteLen;
result.Format = 1;
var track_sys = GetMetaTrack(FileName);
result.AddTrack(track_sys);
var track = new MidiTrack();
track.AddMessage(new MidiMessage(0, new MidiEvent(MidiEvent.Meta, 3, 0, Encoding.Default.GetBytes("Demo"))));
var delta = new int[128];
for (int x = 0; x < 128; x++)
{
var noteOn = new MidiEvent(MidiEvent.NoteOn, (byte)x, 0x64, Encoding.Default.GetBytes(""));
var noteOff = new MidiEvent(MidiEvent.NoteOn, (byte)x, 0x00, Encoding.Default.GetBytes(""));
track.AddMessage(new MidiMessage(0, noteOn));
track.AddMessage(new MidiMessage(offset, noteOff));
}
track.AddMessage(new MidiMessage(0, new MidiEvent(MidiEvent.Meta, 0x2F, 0, Encoding.Default.GetBytes(""))));
result.AddTrack(track);
return(result);
}
static void Main(string[] args)
{
Stopwatch stopwatch = new Stopwatch();
Console.Write("Enter seed: ");
string seed = Console.ReadLine();
Console.WriteLine("Generating Midi...");
stopwatch.Restart();
// Generate a MIDI using Abundant Music
using (Composition composition = MidiComposer.Compose(seed))
{
stopwatch.Stop();
Console.WriteLine("Seed: " + composition.Seed);
Console.WriteLine("Generated in: " + stopwatch.Elapsed);
// Play the MIDI using managed-midi
// https://github.com/atsushieno/managed-midi
var access = MidiAccessManager.Default;
var music = MidiMusic.Read(composition.Midi);
using (var player = new MidiPlayer(music, access))
{
long totalPlayTime = player.GetTotalPlayTimeMilliseconds();
Console.WriteLine("Play time: " + TimeSpan.FromMilliseconds(totalPlayTime).ToString("g"));
player.Play();
while (player.State == PlayerState.Playing)
{
}
}
}
}
public static int getBestShift(MidiMusic midiMusic)
{
int shift = 0;
int oldHit = 0;
for (int i = -21; i < 22; i++)
{
int hit = 0;
foreach (MidiTrack track in midiMusic.Tracks)
{
foreach (MidiMessage mm in track.Messages)
{
int tempo = mm.Event.Msb + i;
if (mapping.ContainsKey(tempo.ToString()))
{
hit++;
}
}
}
if (hit > oldHit)
{
shift = i;
oldHit = hit;
}
}
return(shift);
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
graphics.PreferredBackBufferWidth = this.windowWidth;
graphics.PreferredBackBufferHeight = this.windowHeight;
graphics.ApplyChanges();
base.Initialize();
player = new Player(playerTexture, new Vector2(widthMiddle, windowHeight - 50), new Rectangle(0, (int)(windowHeight * 0.66f), windowWidth, (int)(windowHeight - windowHeight * 0.66f)));
var access = MidiAccessManager.Default;
var output = access.OpenOutputAsync(access.Outputs.Last().Id).Result;
midiMusic = MidiMusic.Read(System.IO.File.OpenRead("midiFiles/something_doin'_(nc)smythe.mid"));
MidiAnalyser midiAnalyser = new MidiAnalyser();
midiAnalyser.analyseMidi(midiMusic);
noteManager = new NoteManager(new GameObject(ballTexture, new Vector2(this.widthMiddle, 0)), spawnArc, midiAnalyser, widthMiddle, 200, 800);
midiPlayer = new MidiPlayer(midiMusic, output);
midiPlayer.EventReceived += (MidiEvent midiEvent) => {
if (midiEvent.EventType == MidiEvent.NoteOn)
{
noteManager.addNote(midiEvent);
}
};
midiPlayer.PlayAsync();
}
public static void LoadMidi()
{
//File read stuff
var openFileDialog = new OpenFileDialog
{
InitialDirectory = System.Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
Filter = "mid files (*.mid)|*.mid",
FilterIndex = 2,
RestoreDirectory = true
};
if (openFileDialog.ShowDialog() == DialogResult.OK)
{
Globals.filePath = openFileDialog.FileName;
if (Globals.player == null)
{
Core.FirstLoad();
}
var music = MidiMusic.Read(System.IO.File.OpenRead(Globals.filePath));
//Console.WriteLine(Globals.filePath);
if (Globals.player != null)
{
Globals.player = new MidiPlayer(music, Core.Globals.output);
return;
}
Globals.player = new MidiPlayer(music, Core.Globals.output);
}
}
public static MidiPlayer GetMidiPlayer(IMidiPlayerTimeManager timeManager, MidiMusic midiMusic, IMidiAccess midiAccess = null)
{
var access = midiAccess ?? MidiAccessManager.Empty;
var music = midiMusic ?? GetMidiMusic();
var tm = timeManager ?? new VirtualMidiPlayerTimeManager();
return(new MidiPlayer(music, access, tm));
}
/// <summary>
/// Reads the given file with the given fileName. Expects a MIDI standard file. Otherwise an error will be trown.
/// </summary>
/// <param name="filePath">The path to the file.</param>
public void readFile(string filePath)
{
FileStream fileStream = File.OpenRead(filePath);
SmfReader reader = new SmfReader();
reader.Read(fileStream);
this.music = reader.Music;
fileStream.Close();
}
void StartNewSong(MidiMusic music)
{
if (player != null)
{
player.Dispose();
}
player = new MidiPlayer(music, MidiState.Instance.GetMidiOutput(this));
player.PlayAsync();
}
MidiMusic CompileMmlToSong(string mml)
{
mml += $"0 CH{Channel + 1} {mml}";
var compiler = new MmlCompiler();
var midiStream = new MemoryStream();
var source = new MmlInputSource("", new StringReader(mml));
compiler.Compile(false, Enumerable.Repeat(source, 1).ToArray(), null, midiStream, false);
return(MidiMusic.Read(new MemoryStream(midiStream.ToArray())));
}
MidiMusic CompileMmlToSong(string mml)
{
var compiler = new MmlCompiler();
compiler.Resolver = new AssetOrUrlResolver(this);
var midiStream = new MemoryStream();
var source = new MmlInputSource("", new StringReader(mml));
compiler.Compile(false, Enumerable.Repeat(source, 1).ToArray(), null, midiStream, false);
return(MidiMusic.Read(new MemoryStream(midiStream.ToArray())));
}
public void PlayPortMidi()
{
var stream = GetType().Assembly.GetManifestResourceStream("Commons.Music.Midi.Tests.Resources.testmidi.mid");
var vt = new AlmostVirtualMidiTimeManager();
var player = new MidiPlayer(MidiMusic.Read(stream), new PortMidi.PortMidiAccess(), vt);
player.PlayAsync();
vt.AdvanceBy(10000);
player.PauseAsync();
player.Dispose();
}
private MidiMusic getMusic()
{
try
{
using var sr = File.OpenRead(Path.Combine(jukebox.Settings.MIDIPath, jukebox.Current.Tune.Filepath));
return(MidiMusic.Read(sr));
}
catch
{
return(null);
}
}
private void cutMusic(int from, int to, MidiMusic music, string outputFilename)
{
FileStream stream = File.Create(outputFilename);
SmfWriter writer = new SmfWriter(stream);
writer.WriteHeader(music.Format, (short)music.Tracks.Count, music.DeltaTimeSpec);
IList <MidiTrack> tracks = music.Tracks;
for (var i = 0; i < tracks.Count; i++)
{
var track = tracks[i];
int passedTime = 0;
var newTrack = new MidiTrack();
bool isFirstMessage = true;
for (var j = 0; j < track.Messages.Count; j++)
{
var message = track.Messages[j];
passedTime += message.DeltaTime;
if (passedTime < from && message.Event.EventType != MidiEvent.NoteOn && message.Event.EventType != MidiEvent.NoteOff)
{
var convertedMsg = MidiUtil.convertTimeToZero(message);
newTrack.AddMessage(convertedMsg);
}
else if (passedTime >= from && passedTime < to)
{
if (isFirstMessage)
{
int newDeltaTime = passedTime - from;
newTrack.AddMessage(new MidiMessage(newDeltaTime, message.Event));
isFirstMessage = false;
}
else
{
newTrack.AddMessage(message);
}
}
else if (passedTime >= to && message.Event.EventType == MidiEvent.Meta && message.Event.MetaType == MidiMetaType.EndOfTrack)
{
MidiMessage convertedMsg = MidiUtil.convertTimeToZero(message);
newTrack.AddMessage(convertedMsg);
}
}
track = newTrack;
// Debug.Log("Track " + (i + 1) + " Passed time:" + passedTime);
writer.WriteTrack(track);
}
stream.Close();
}
private void LogMidiInformation(MidiMusic music)
{
Debug.Log("Divisions: " + System.Convert.ToString(music.DeltaTimeSpec, 2));
Debug.Log("Format: " + music.Format);
Debug.Log("Number of tracks: " + music.Tracks.Count);
try
{
Debug.Log("Time in milliseconds" + music.GetTotalPlayTimeMilliseconds());
}
catch (System.NotSupportedException)
{
Debug.Log("Library does not support calculating time of midi files with any format other than 0.");
}
}
public void analyseMidi(MidiMusic midiMusic)
{
minNoteVal = midiMusic.Tracks.Min(track => track.Messages.Where(message => message.Event.MetaType > minAllowedNoteValues).Min(message => message.Event.MetaType));
maxNoteVal = midiMusic.Tracks.Max(track => track.Messages.Max(message => message.Event.MetaType));
midiMusicAverage = midiMusic.Tracks.Average(track => track.Messages.Where(message => message.Event.MetaType > minAllowedNoteValues).Average(message => message.Event.MetaType));
//foreach(var track in midiMusic.Tracks)
//{
// var trackAverage = track.Messages.Average(message => message.Event.MetaType);
//}
largestDistanceFromAverage = Math.Max(midiMusicAverage - minNoteVal, maxNoteVal - midiMusicAverage);
Console.WriteLine($"Midi min value: {minNoteVal}");
Console.WriteLine($"Midi max value: {maxNoteVal}");
Console.WriteLine($"Midi mean: {midiMusicAverage}");
}
public static MidiMusic Load(string filename)
{
MidiMusic result = null;
if (File.Exists(filename))
{
using (FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read))
{
SmfReader smf = new SmfReader();
smf.Read(fs);
result = smf.Music;
}
}
return(result);
}
// Use this for initialization
void Start()
{
SmfReader reader = new SmfReader();
reader.Read(File.OpenRead("mysong2.mid"));
MidiMusic music = reader.Music;
Directory.CreateDirectory("midi-out");
this.cutMusic(10000, 30000, music, "midi-out/1.mid");
reader.Read(File.OpenRead("midi-out/1.mid"));
MidiMusic musicCut = reader.Music;
Debug.Log("Original file length:" + GetTimeLengthInMinutes(music));
Debug.Log("Cut file length: " + GetTimeLengthInMinutes(musicCut));
}
public void PlaySmf(MidiMusic music) //(Stream stream)
{
StopSmf();
//var midiFileStream = File.OpenRead("Data/001-praise-to-the-lord.mid");
Console.WriteLine($"Playing MIDI Stream");
//var music = MidiMusic.Read(midiFileStream);
_player = new MidiPlayer(music, this.output);
_player.Finished += () =>
{
// Destroy when finished
_player = null;
};
// foreach (var message in music.Tracks[0].Messages.Take(20))
// {
// Console.WriteLine($"Type:{message.Event.EventType.ToString()} Channel:{message.Event.Channel} Status:{message.Event.StatusByte} DeltaTime:{message.DeltaTime} ExData:{message.Event.ExtraDataLength} {BitConverter.ToString(message.Event.ExtraData.Take(message.Event.ExtraDataLength).ToArray())}");
// }
Console.WriteLine();
_player.Play();
}
public static MidiMusic GetMidiMusic()
{
var music = new MidiMusic();
music.DeltaTimeSpec = 192;
var track = new MidiTrack();
byte ch = 1;
track.Messages.Add(new MidiMessage(188, new MidiEvent((byte)(MidiEvent.Program + ch), 1, 0, null, 0, 0)));
for (int i = 0; i < 100; i++)
{
track.Messages.Add(
new MidiMessage(4, new MidiEvent((byte)(MidiEvent.NoteOn + ch), 60, 120, null, 0, 0)));
track.Messages.Add(
new MidiMessage(44, new MidiEvent((byte)(MidiEvent.NoteOff + ch), 60, 0, null, 0, 0)));
}
music.Tracks.Add(track);
return(music);
}
public bool Save(string filename, MidiMusic music = null)
{
bool result = false;
if (music == null)
{
music = Music;
}
if (music is MidiMusic && !string.IsNullOrEmpty(filename))
{
using (FileStream fs = new FileStream(filename, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite))
{
SmfWriter smf = new SmfWriter(fs);
smf.WriteMusic(music);
result = true;
}
}
return(result);
}
public void Play(MidiMusic music = null)
{
if (player is MidiPlayer)
{
Stop();
}
var access = MidiAccessManager.Default;
var output = access.OpenOutputAsync(access.Outputs.Last().Id).Result;
if (music is MidiMusic)
{
player = new MidiPlayer(music, output);
}
else if (Music is MidiMusic)
{
player = new MidiPlayer(Music, output);
}
else
{
return;
}
if (player is MidiPlayer)
{
if (player.State == PlayerState.Stopped || player.State == PlayerState.Paused)
{
//player.EventReceived += (MidiEvent e) => {
// if (e.EventType == MidiEvent.Program)
// Console.WriteLine($"Program changed: Channel:{e.Channel} Instrument:{e.Msb}");
//};
player.PlayAsync();
}
//Console.WriteLine("Type [CR] to stop.");
//Console.ReadLine();
//player.Dispose();
}
}
private void LoadMidiFile(string filePath)
{
try
{
midiMusic = MidiMusic.Read(File.OpenRead(filePath));
if (midiMusic.Tracks.Any())
{
var track = midiMusic.Tracks[0];
currentTrack = MidiHelper.ToSimpleMidiTrack(track, midiMusic.DeltaTimeSpec);
cbTrack.Items.Clear();
for (int x = 1; x <= midiMusic.Tracks.Count; x++)
{
cbTrack.Items.Add(x);
}
cbTrack.SelectedIndex = 0;
}
}
catch (Exception e)
{
ShowError(e.Message);
}
}
void StartNewSong(int playerIndex, MidiMusic music)
{
MidiPlayer mml_music_player = null;
if (players.Count > playerIndex)
{
players [playerIndex].Dispose();
}
mml_music_player = new MidiPlayer(music, Output);
mml_music_player.PlayAsync();
if (MusicListingChanged != null)
{
MusicListingChanged(this, new PlayerListingChangedEventArgs(playerIndex, music));
}
if (players.Count > playerIndex)
{
players [playerIndex] = mml_music_player;
}
else
{
players.Add(mml_music_player);
}
}
private void button1_Click(object sender, EventArgs e)
{
//Thread.Sleep(5000);
//FindWindow 参数一是进程名 参数2是 标题名
textBox1.Text = "";
listBox1.Items.Clear();
int shift = 0;
IntPtr calculatorHandle = WinApiUtils.FindWindow(null, "原神");
//判断是否找到
if (calculatorHandle == IntPtr.Zero)
{
MessageBox.Show("没有找到!");
return;
}
//var access = MidiAccessManager.Default;
var music = MidiMusic.Read(System.IO.File.OpenRead("./" + comboBox1.SelectedItem));
shift = TuneUtils.getBestShift(music);
textBox1.Text += "best shift =" + shift;
textBox1.Text += "\r\n";
SimpleAdjustingMidiPlayerTimeManager simpleAdjustingMidiPlayerTimeManager = new SimpleAdjustingMidiPlayerTimeManager();
player = new MidiPlayer(music, simpleAdjustingMidiPlayerTimeManager);
int val = 0;
string key;
WinApiUtils.SetForegroundWindow(calculatorHandle);
player.EventReceived += (MidiEvent me) =>
{
switch (me.EventType)
{
case MidiEvent.Meta:
//case MidiEvent.Reset:
listBox1.Items.Add("MidiEvent.Meta");
break;
case MidiEvent.ActiveSense:
listBox1.Items.Add("MidiEvent.ActiveSense");
break;
case MidiEvent.MidiStop:
listBox1.Items.Add("MidiEvent.MidiStop");
break;
case MidiEvent.MidiContinue:
listBox1.Items.Add("MidiEvent.MidiContinue");
break;
case MidiEvent.MidiStart:
listBox1.Items.Add("MidiEvent.MidiStart");
break;
case MidiEvent.MidiTick:
listBox1.Items.Add("MidiEvent.MidiTick");
break;
case MidiEvent.MidiClock:
listBox1.Items.Add("MidiEvent.MidiClock");
break;
case MidiEvent.EndSysEx:
//case MidiEvent.SysEx2:
listBox1.Items.Add("MidiEvent.EndSysEx");
break;
case MidiEvent.TuneRequest:
listBox1.Items.Add("MidiEvent.TuneRequest");
break;
case MidiEvent.SongPositionPointer:
listBox1.Items.Add("MidiEvent.SongPositionPointer");
break;
case MidiEvent.MtcQuarterFrame:
listBox1.Items.Add("MidiEvent.MtcQuarterFrame");
break;
case MidiEvent.SysEx1:
listBox1.Items.Add("MidiEvent.SysEx1");
break;
case MidiEvent.Pitch:
listBox1.Items.Add("MidiEvent.Pitch");
break;
case MidiEvent.CAf:
listBox1.Items.Add("MidiEvent.CAf");
break;
case MidiEvent.Program:
listBox1.Items.Add("MidiEvent.Program");
break;
case MidiEvent.CC:
listBox1.Items.Add("MidiEvent.CC");
break;
case MidiEvent.PAf:
listBox1.Items.Add("MidiEvent.PAf");
break;
case MidiEvent.SongSelect:
listBox1.Items.Add("MidiEvent.SongSelect");
break;
case MidiEvent.NoteOn:
listBox1.Items.Add("MidiEvent.NoteOn");
val = me.Msb + shift;
key = val.ToString();
if (mapping.ContainsKey(key))
{
int c = me.Lsb;
if (c == 0)
{
WinApiUtils.keybd_event((byte)letter[mapping[key]], 0, 2, 0);
textBox1.Text += ")";
textBox1.Text += " ";
}
else
{
//SendKeys.Send(mapping[key]);
WinApiUtils.keybd_event((byte)letter[mapping[key]], 0, 0, 0);
//WinApiUtils.PostMessage(calculatorHandle, WinApiUtils.WM_KEY_DOWN, (Keys)Enum.Parse(typeof(Keys), mapping[key].ToUpper()), letter[mapping[key]]);
textBox1.Text += "(" + mapping[key];
textBox1.Text += ";";
}
}
else
{
textBox1.Text += "[" + key + "]";
}
break;
case MidiEvent.NoteOff:
listBox1.Items.Add("MidiEvent.NoteOff");
val = me.Msb + shift;
key = val.ToString();
if (mapping.ContainsKey(key))
{
//SendKeys.Send(mapping[key]);
//WinApiUtils.PostMessage(calculatorHandle, WinApiUtils.WM_KEY_UP, (Keys)Enum.Parse(typeof(Keys), mapping[key].ToUpper()), letter[mapping[key]]);
WinApiUtils.keybd_event((byte)letter[mapping[key]], 0, 2, 0);
textBox1.Text += ")";
textBox1.Text += " ";
}
break;
default:
//textBox1.Text += me.EventType;
//textBox1.Text += "\r\n";
break;
}
};
player.Play();
}
static void Main(string[] args)
{
var access = MidiAccessManager.Default;
var output = access.OpenOutputAsync(access.Outputs.Last().Id).Result;
var music = MidiMusic.Read(System.IO.File.OpenRead("../../../midi/avengers.mid"));
var player = new MidiPlayer(music, output);
int HowHardPressed = 0;
string StrengthOfPress = "";
player.PlayAsync();
player.Dispose();
if (access.Inputs.Count() > 0)
{
var input = access.OpenInputAsync(access.Inputs.Last().Id).Result;
byte[] data = null;
input.MessageReceived += (o, e) =>
{
data = new byte[e.Length];
Array.Copy(e.Data, e.Start, data, 0, e.Length);
if (e.Data[1] != 0 && e.Data[0] == 144)
{
var note = e.Data[1] % 12 + 1;
string noteString = "N/A";
switch (note)
{
case 1:
noteString = "C";
break;
case 2:
noteString = "C#/D-";
break;
case 3:
noteString = "D";
break;
case 4:
noteString = "D#/E-";
break;
case 5:
noteString = "E";
break;
case 6:
noteString = "F";
break;
case 7:
noteString = "F#/G-";
break;
case 8:
noteString = "G";
break;
case 9:
noteString = "G#/A-";
break;
case 10:
noteString = "A";
break;
case 11:
noteString = "A#/B-";
break;
case 12:
noteString = "B";
break;
default:
noteString = "N/A";
break;
}
int octave = e.Data[1] / 12;
if (e.Data[1] != 0 && e.Data[0] != 144)
{
Console.Write("Not A NOTE?!?!?!?!?!?!?!??!?!!?!?");
Console.Write($"Note Played: {noteString}\t Octave Played: {octave.ToString()}\t");
Console.Write($"Data[0]: {e.Data[0]}\t");
Console.Write($"Note #: {e.Data[1]}\t");
}
else
{
/*
*
*
* Console.Write($"Note Played: {noteString}\t Octave Played: {octave.ToString()}\t");
* Console.Write($"Data[0]: {e.Data[0]}\t");
* Console.Write($"Note #: {e.Data[1]}\t");
* Console.WriteLine($"Data[2]: {e.Data[2]}");
*/
HowHardPressed = e.Data[2];
if (HowHardPressed < 1)
{
StrengthOfPress = "StoppedPressing";
}
if (HowHardPressed > 0)
{
StrengthOfPress = "Barely";
}
if (HowHardPressed > 30)
{
StrengthOfPress = "Softly";
}
if (HowHardPressed > 55)
{
StrengthOfPress = "a healthy ammount";
}
if (HowHardPressed > 80)
{
StrengthOfPress = "Hard";
}
if (HowHardPressed > 110)
{
StrengthOfPress = "Jesus Why ?!?!";
}
if (HowHardPressed != 0)
{
Console.WriteLine("You played: " + noteString + " " + octave.ToString() + "th octave " + StrengthOfPress);
}
}
}
};
}
while (true)
{
;
}
}
public static MidiMusic GetMidiMusic(string resourceId)
{
using (var stream = typeof(TestHelper).Assembly.GetManifestResourceStream(resourceId))
return(MidiMusic.Read(stream));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="instrument">Defines the sound and the ADSR envelope.</param>
/// <param name="midiFilePath">Path to a MIDI file to read its contents.</param>
/// <param name="filterChannel">Filter on a specific channel. Use -1 to disable filtering.</param>
/// <param name="steroPan">Stereo panning, from -1 to 1.</param>
/// <param name="tempoChange">Multiplier for the tempo. 1 = unchanged</param>
/// <param name="lengthChange">Multiplier for the note lengths. 1 = unchanged</param>
/// <param name="volumeChange">Multiplier for the volume. 1 = unchanged</param>
/// <param name="octaveShift">Shift the sequence by this amount of octaves. No change = 0</param>
public Sequence(Instrument instrument, string midiFilePath, int filterChannel = -1, double steroPan = 0, double tempoChange = 1,
double lengthChange = 1, double volumeChange = 1, int octaveShift = 0)
{
this.Instrument = instrument;
this.StereoPan = steroPan;
this.VolumeChange = volumeChange;
this.OctaveShift = octaveShift;
using (var stream = System.IO.File.OpenRead(midiFilePath)) {
var music = MidiMusic.Read(stream);
double timeConversion = (((double)music.GetTimePositionInMillisecondsForTick(1000)) / (1000000d)) / tempoChange;
foreach (var track in music.Tracks)
{
var tracker = new Dictionary <byte, Note>();
double currentTime = 0;
foreach (var message in track.Messages)
{
var type = message.Event.EventType >> 4;
if (type != 8 && type != 9)
{
continue;
}
if (filterChannel > -1)
{
if (filterChannel != message.Event.Channel)
{
continue;
}
}
if (message.Event.Channel == 10)
{
// Automatically filter the percussion channel
continue;
}
currentTime += ((double)message.DeltaTime) * timeConversion;
byte note = message.Event.Msb;
byte velocity = message.Event.Lsb;
if (type == 8 || (type == 9 && velocity == 0))
{
// Note OFF event
if (!tracker.ContainsKey(note))
{
// Ignore inconsistent data
continue;
}
var noteObj = tracker[note];
noteObj.SustainLength = (currentTime - noteObj.StartTime) * lengthChange;
Notes.Add(noteObj);
tracker.Remove(note);
var endTime = noteObj.StartTime + instrument.MinimalNoteLength + noteObj.SustainLength + 1;
if (endTime > TotalLength)
{
TotalLength = endTime;
}
continue;
}
if (type == 9)
{
// Note ON event
double frequency = instrument.Tuning.getFrequency(note, OctaveShift);
tracker[note] = new Note(frequency, currentTime, ((double)velocity) / 127d, 0);
continue;
}
}
}
}
}
public PlayerListingChangedEventArgs(int index, MidiMusic music)
{
Index = index;
Music = music;
}
