public void Read(Stream strm, int midiTrack)
{
// clear the channel message builder's cache
ChannelMessageBuilder.Clear();
trackNumber = midiTrack;
stream = strm;
FindTrack();
int trackLength = GetTrackLength();
trackData = new byte[trackLength];
int result = strm.Read(trackData, 0, trackLength);
if (result < 0)
{
throw new MidiFileException("End of MIDI file unexpectedly reached.");
}
newTrack = new Track();
newTrack.TrackId = trackNumber;
ParseTrackData();
track = newTrack;
}
public PlayingMidi()
{
this.transpose = 60;
if (OutputDevice.DeviceCount == 0)
{
MessageBox.Show("No MIDI output devices available.", "Error!", MessageBoxButtons.OK, MessageBoxIcon.Stop);
}
outDevice = new OutputDevice(0);
builder = new ChannelMessageBuilder();
isDeviceOpen = true;
//Set instrument to piano
builder.Command = ChannelCommand.ProgramChange;
builder.MidiChannel = 0;
builder.Data1 = 0;
builder.Build();
outDevice.Send(builder.Result);
ParseCommaDelimited();
tmpmidiFilePlayer = new MidiFilePlayer(outDevice);
midiFilePlayer1 = new MidiFilePlayer(outDevice);
midiFilePlayer1.PlayingFinished += this.midiFilePlayer1_PlayingFinished;
}
internal static void controlMess(int note, float velocity) // Sends a Control message to the MIDI device
{
if (ControlSender == false)
{
if (HardwareSetup.BCF2000_i != null)
{
ChannelMessageBuilder builder = new ChannelMessageBuilder(); // build MIDI Message
builder.MidiChannel = 0; // Always channel 0
builder.Command = ChannelCommand.Controller; // Control message for knobs and faders
builder.Data1 = note; // Control number
builder.Data2 = (int)velocity; // send the value from interface
builder.Build();
try
{
BCF2000_o.Send(builder.Result);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("MIDI Device not conencted. " + ex.Message);
if (inForm != null)
{
inForm.ChangeStatusText(ex);
}
}
}
}
if (FormSender == false)
{
if (inForm != null)
{
inForm.setValue(note, (decimal)velocity);
}
}
}
void inDevScan_ChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
ChannelMessageBuilder builder = new ChannelMessageBuilder();
if ((e.Message.Command == ChannelCommand.NoteOn) ||
(e.Message.Command == ChannelCommand.NoteOff))
{
/*
* NoteList.Items.Add("nuta");
* if (NoteList.Items.Count >= 20)
* NoteList.Clear();
*/
NoteVal.Text = e.Message.Data1.ToString();
if (e.Message.Command == ChannelCommand.NoteOn)
{
builder.Command = ChannelCommand.NoteOn;
}
if (e.Message.Command == ChannelCommand.NoteOff)
{
builder.Command = ChannelCommand.NoteOff;
}
builder.MidiChannel = e.Message.MidiChannel;
builder.Data1 = e.Message.Data1; // note val
builder.Data2 = e.Message.Data2; // velocity
builder.Build();
outDevice.Send(builder.Result);
}
}
public PlayingMidi()
{
this.transpose = 60;
if (OutputDevice.DeviceCount == 0)
{
MessageBox.Show("No MIDI output devices available.", "Error!", MessageBoxButtons.OK, MessageBoxIcon.Stop);
}
outDevice = new OutputDevice(0);
builder = new ChannelMessageBuilder();
isDeviceOpen = true;
//Set instrument to piano
builder.Command = ChannelCommand.ProgramChange;
builder.MidiChannel = 0;
builder.Data1 = 0;
builder.Build();
outDevice.Send(builder.Result);
ParseCommaDelimited();
tmpmidiFilePlayer = new MidiFilePlayer(outDevice);
midiFilePlayer1 = new MidiFilePlayer(outDevice);
midiFilePlayer1.PlayingFinished += this.midiFilePlayer1_PlayingFinished;
}
private void InternalNote(Object o, ChannelMessageEventArgs args)
{
ChannelMessageBuilder builder = new ChannelMessageBuilder(args.Message);
NoteEvent noteEvent = new NoteEvent {
note = builder.Data1,
origNote = builder.Data1,
trackNum = sequencer.GetTrackNum(args.MidiTrack),
track = args.MidiTrack,
};
if (sequencer.GetTrackNum(noteEvent.track) == this.TrackNum)
{
noteEvent.note = NoteHelper.ApplyOctaveShift(noteEvent.note, this.OctaveNum);
ChannelCommand cmd = args.Message.Command;
int vel = builder.Data2;
if ((cmd == ChannelCommand.NoteOff) || (cmd == ChannelCommand.NoteOn && vel == 0))
{
this.ProcessOffNote(noteEvent);
}
if ((cmd == ChannelCommand.NoteOn) && vel > 0)
{
this.ProcessOnNote(noteEvent);
}
}
}
public void AddTrack(string TrackName, List <TLBaseKeyFrame> KeyFrames)
{
Track t = new Track();
MetaTextBuilder mtBuilder = new MetaTextBuilder(MetaType.TrackName, TrackName);
mtBuilder.Build();
t.Insert(0, mtBuilder.Result);
foreach (TLMidiKeyFrame mk in KeyFrames)
{
ChannelMessageBuilder cmBuilder = new ChannelMessageBuilder();
cmBuilder.Command = ChannelCommand.NoteOn;
cmBuilder.MidiChannel = mk.Channel;
cmBuilder.Data1 = mk.Note;
cmBuilder.Data2 = mk.Velocity;
cmBuilder.Build();
t.Insert((int)(mk.Time / SecondsPerMidiUnit), cmBuilder.Result);
cmBuilder.Command = ChannelCommand.NoteOff;
cmBuilder.Data1 = mk.Note;
cmBuilder.Data2 = 0;
cmBuilder.Build();
t.Insert((int)(mk.End / SecondsPerMidiUnit), cmBuilder.Result);
}
FSequence.Add(t);
}
public static void PlayPiano()
{
Sequencer a = new Sequencer();
using (OutputDevice outDevice = new OutputDevice(0))
{
for (int i = 60; i < 100; i++)
{
ChannelMessageBuilder builder = new ChannelMessageBuilder();
builder.Command = ChannelCommand.NoteOn;
builder.MidiChannel = 14;
builder.Data1 = i;
builder.Data2 = i - 20;
builder.Build();
outDevice.Send(builder.Result);
Thread.Sleep(500);
builder.Command = ChannelCommand.NoteOff;
builder.Data2 = 0;
builder.Build();
outDevice.Send(builder.Result);
}
}
}
/// <summary>
/// Set Midi instrument for all channels
/// </summary>
/// <param name="instrument"></param>
public void SetInstrument(MyMidi.Instrument instrument)
{
try
{
foreach (var c in Enum.GetValues(typeof(MyMidi.Channel)))
{
//outputDevice.SendProgramChange((Midi.Channel)c, instrument);
// Change the patch while playing
int nChannel = (int)c;
int p = (int)instrument;
int v = 0;
ChannelMessageBuilder builder = new ChannelMessageBuilder()
{
Command = ChannelCommand.ProgramChange,
MidiChannel = nChannel,
Data1 = p,
Data2 = v,
};
builder.Build();
outDevice.Send(builder.Result);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public MidiCom()
{
this.context = SynchronizationContext.Current;
this.builder = new ChannelMessageBuilder();
this.m_Timer = new System.Timers.Timer(1000.0);
this.m_Timer.Elapsed += (ElapsedEventHandler)((sender, e) => MidiCom.MyElapsedMethod(sender, e, this));
this.m_Timer.Enabled = true;
}
public static void Send(this OutputDevice device, ChannelMessageBuilder builder,
ChannelCommand command, int data1, int data2 = 0, int midiChannel = 0)
{
builder.Command = command;
builder.Data1 = data1;
builder.Data2 = data2;
builder.MidiChannel = midiChannel;
builder.Build();
device.Send(builder.Result);
}
protected void OnChannelMessagePlayed(object sender, ChannelMessageEventArgs e)
{
if (Midi.DeviceID != -1)
{
ChannelMessageBuilder cmb = new ChannelMessageBuilder(e.Message);
cmb.Command = e.Message.Command;
cmb.Data1 = note_to_button(cmb.Data1);
cmb.Build();
Midi.Device.Send(cmb.Result);
}
}
protected static ChannelMessage makeStopEvent(int pitch)
{
ChannelMessageBuilder builder = new ChannelMessageBuilder();
builder.Command = ChannelCommand.NoteOff;
builder.MidiChannel = 0;
builder.Data1 = pitch;
builder.Data2 = 127;
builder.Build();
return(builder.Result);
}
private void endNote(int note, int channel)
{
ChannelMessageBuilder builder = new ChannelMessageBuilder();
builder.Command = ChannelCommand.NoteOff;
builder.MidiChannel = channel;
builder.Data1 = note;
builder.Data2 = 0;
builder.Build();
stream.Send(builder.Result);
}
/// <summary>
/// Adds a MIDI event to the current track
/// </summary>
/// <param name="command">MIDI command represented by the message</param>
/// <param name="data">The first data byte</param>
public void AddEvent(ChannelCommand command, int data)
{
var shortMessageBuilder = new ChannelMessageBuilder
{
Command = command,
Data1 = CurrentTrackNumber,
Data2 = data,
};
shortMessageBuilder.Build();
QueueMessage(shortMessageBuilder.Result);
}
public void Silence(int channel)
{
var builder = new ChannelMessageBuilder
{
MidiChannel = channel - 1,
Command = ChannelCommand.Controller,
Data1 = (int)ControllerType.AllSoundOff
};
builder.Build();
output.Send(builder.Result);
}
private void ZapalMidi(Panel panel, ChannelCommand cm)
{
ChannelMessageBuilder cmb = new ChannelMessageBuilder();
cmb.Command = cm;
cmb.MidiChannel = 3;
cmb.Data1 = Convert.ToInt32(panel.Tag);
cmb.Data2 = 127;
cmb.Build();
outDevice1.Send(cmb.Result);
}
public void Dispose()
{
for (int i = 0; i < Score.Staves.Count * 2; i++)
{
ChannelMessageBuilder builder = new ChannelMessageBuilder();
builder.Command = ChannelCommand.NoteOff;
builder.Data2 = i;
builder.Build();
outDevice.Send(builder.Result);
}
outDevice.Dispose();
}
public void ChangeChannelPan(int Channel, int Pan)
{
ChannelMessageBuilder builder = new ChannelMessageBuilder()
{
Command = ChannelCommand.Controller,
MidiChannel = Channel,
Data1 = (int)ControllerType.Pan,
Data2 = Pan,
};
builder.Build();
outDevice.Send(builder.Result);
}
public void ChangeChannelProgram(int Channel, int Instrument)
{
ChannelMessageBuilder builder = new ChannelMessageBuilder()
{
Command = ChannelCommand.ProgramChange,
MidiChannel = Channel,
Data1 = Instrument,
Data2 = 0,
};
builder.Build();
outDevice.Send(builder.Result);
}
public static void ThreadSendingMidi()
{
while (true)
{
rstEvent.WaitOne();
while (GlobalSettings.queueMidi.Count() > 0)
{
var mod = GlobalSettings.queueMidi.Dequeue();
var sendingMidi = GlobalSettings.sendingMidi;
if (!sendingMidi)
{
sendingMidi = true;
using (OutputDevice outDevice = new OutputDevice(1))
{
ChannelMessageBuilder builder = new ChannelMessageBuilder();
builder.Command = mod.channelCommand;
builder.MidiChannel = mod.B1;
builder.Data1 = mod.B2;
builder.Data2 = mod.B3;
builder.Build();
outDevice.Send(builder.Result);
//Console.WriteLine(midiChannel + data1 + data2);
}
sendingMidi = false;
}
}
while (GlobalSettings.queueMidiSysex.Count() > 0)
{
var model = GlobalSettings.queueMidiSysex.Dequeue();
using (OutputDevice outDevice = new OutputDevice(1))
{
outDevice.Send(model.msg);
//Console.WriteLine(midiChannel + data1 + data2);
}
}
rstEvent.Reset();
}
}
private void StopNoteFor(string laserNote)
{
if (midiSynth == null)
{
return;
}
ChannelMessageBuilder builder = new ChannelMessageBuilder();
builder.Command = ChannelCommand.NoteOff;
builder.MidiChannel = midiChannel;
builder.Data1 = laserToMidiTranslation[laserNote];
builder.Data2 = 0;
builder.Build();
midiSynth.Send(builder.Result);
}
void SetInstrument(GeneralMidiInstrument gmInstrument)
{
if (midiSynth == null)
{
return;
}
ChannelMessageBuilder builder = new ChannelMessageBuilder();
builder.Command = ChannelCommand.ProgramChange;
builder.MidiChannel = midiChannel;
builder.Data1 = Convert.ToInt32(gmInstrument); // INSTRUMENT ID
builder.Data2 = 0;
builder.Build();
midiSynth.Send(builder.Result);
}
/// <summary>
/// Set the color of a key/button.
/// </summary>
/// <param name="channel">0-7</param>
/// <param name="note">8x8 keys + 8x4 buttons </param>
/// <param name="color">Color 0-127</param>
public void SetColor(int note, int color)
{
if (Midi.DeviceID != -1 && note >= 0)
{
ChannelMessageBuilder cmb = new ChannelMessageBuilder
{
Command = ChannelCommand.NoteOn,
MidiChannel = Channel,
Data1 = note,
Data2 = color
};
cmb.Build();
Midi.Device.Send(cmb.Result);
}
}
private void cbxInstrument_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (midiSynth == null)
{
return;
}
ChannelMessageBuilder builder = new ChannelMessageBuilder();
builder.Command = ChannelCommand.ProgramChange;
builder.MidiChannel = midiChannel;
builder.Data1 = Convert.ToInt32(cbxInstrument.SelectedItem); // INSTRUMENT ID
builder.Data2 = 0;
builder.Build();
midiSynth.Send(builder.Result);
}
/// <summary>
/// connexion au launchpad
/// </summary>
/// <param name="name"></param>
/// <exception cref="AlreadyConnectedMidiDevice"></exception>
/// <exception cref="ErrorMidiConnexionException"></exception>
public static void Connect()
{
_VirtualMidiPort = new TeVirtualMIDI("VirtualPort");
_msg = new ChannelMessageBuilder();
if (!connected)
{
try
{
OutDevCount = OutputDevice.DeviceCount;
InDevCount = InputDevice.DeviceCount;
for (int i = 0; i < OutDevCount; i++)
{
if (OutputDevice.GetDeviceCapabilities(i).name == midiDeviceName)
{
LaunchpadOutID = i;
}
}
for (int i = 0; i < InDevCount; i++)
{
if (InputDevice.GetDeviceCapabilities(i).name == midiDeviceName)
{
LaunchpadInID = i;
}
}
_InputLaunchPad = new InputDevice(LaunchpadInID);
_InputLaunchPad.ChannelMessageReceived += HandleChannelMessageReceived;
_OutputLaunchPad = new OutputDevice(LaunchpadOutID);
_InputLaunchPad.StartRecording();
connected = true;
}
catch (Exception)
{
throw new ErrorMidiConnexionException();
}
}
else
{
throw new AlreadyConnectedMidiDevice();
}
}
public void PlayNoteFromBuffer(Byte[] buf, int length)
{
if (length < 3 || buf[0] == 0)
{
return;
}
ChannelMessageBuilder cmb = new ChannelMessageBuilder();
cmb.Command = (ChannelCommand)buf[0];
cmb.Data1 = buf[1];
cmb.Data2 = buf[2];
cmb.Build();
outMIDI.Send(cmb.Result);
}
void StopNote(string laserNote)
{
if (midiSynth == null || laserNote == string.Empty)
{
return;
}
Debug.WriteLine("---- " + laserNote);
ChannelMessageBuilder builder = new ChannelMessageBuilder();
builder.Command = ChannelCommand.NoteOff;
builder.MidiChannel = Channel;
builder.Data1 = laserToMidiTranslation[laserNote];
builder.Data2 = 0;
builder.Build();
midiSynth.Send(builder.Result);
}
void PlayNote(string laserNote)
{
Debug.WriteLine("PLAY " + laserNote);
if (midiSynth == null)
{
return;
}
ChannelMessageBuilder builder = new ChannelMessageBuilder();
builder.Command = ChannelCommand.NoteOn;
builder.MidiChannel = Channel;
builder.Data1 = laserToMidiTranslation[laserNote];
builder.Data2 = 127;
builder.Build();
midiSynth.Send(builder.Result);
}
private void SilenceAllNotes()
{
foreach (var c in Enum.GetValues(typeof(MyMidi.Channel)))
{
ChannelMessageBuilder builder = new ChannelMessageBuilder()
{
Command = ChannelCommand.Controller,
MidiChannel = (int)c,
Data1 = (int)ControllerType.AllNotesOff,
Data2 = 0,
};
builder.Build();
outDevice.Send(builder.Result);
}
}
public void Send(int midiChannel, int controller, byte value)
{
if (this.outputDevice == null)
{
return;
}
var builder = new ChannelMessageBuilder();
builder.Command = ChannelCommand.Controller;
builder.Data1 = controller;
builder.Data2 = value;
builder.MidiChannel = midiChannel;
builder.Build();
this.outputDevice.Send(builder.Result);
}
protected ChannelMessage BuildMessage(ChannelCommand command, int channel, int data1, int data2)
{
if(channel > 15 || channel < 0)
throw new ApplicationException("Channel index must be in range 0..15");
if(data1 > 127 || data1 < 0)
throw new ApplicationException("Value must be in range 0..127");
if(data2 > 127 || data2 < 0)
throw new ApplicationException("Value must be in range 0..127");
ChannelMessageBuilder builder = new ChannelMessageBuilder();
builder.Command = command;
builder.MidiChannel = channel;
builder.Data1 = data1;
builder.Data2 = data2;
builder.Build();
return builder.Result;
}
protected List<ChannelMessage> GetChannelMessages(ChannelCommand noteOnOff)
{
List<ChannelMessage> messages = new List<ChannelMessage>();
ChannelMessageBuilder builder = new ChannelMessageBuilder();
builder.MidiChannel = this.Channel;
//foreach(MidiControl midiControl in this.MidiControls)
//{
// messages.AddRange(midiControl.ChannelMessages);
//}
builder.Command = noteOnOff;
foreach(NoteMessage midiNote in _notes)
{
builder.Data1 = midiNote.Pitch;
builder.Data2 = midiNote.Velocity;
builder.Build();
messages.Add(builder.Result);
}
return messages;
}
