public FaderDef(bool _delta, float _range, int _channel,
bool _selectPresent, bool _mutePresent, bool _recordPresent,
int _faderOffset, int _selectOffset, int _muteOffset, int _recordOffset,
MidiCommandCode _faderCode, MidiCommandCode _selectCode, MidiCommandCode _muteCode, MidiCommandCode _recordCode,
int _faderChannelOverride = -1, int _selectChannelOverride = -1, int _muteChannelOverride = -1, int _recordChannelOverride = -1)
{
delta = _delta;
range = _range;
channel = _channel;
selectPresent = _selectPresent;
mutePresent = _mutePresent;
recordPresent = _recordPresent;
faderOffset = _faderOffset;
selectOffset = _selectOffset;
muteOffset = _muteOffset;
recordOffset = _recordOffset;
faderCode = _faderCode;
selectCode = _selectCode;
muteCode = _muteCode;
recordCode = _recordCode;
faderChannelOverride = _faderChannelOverride;
selectChannelOverride = _selectChannelOverride;
muteChannelOverride = _muteChannelOverride;
recordChannelOverride = _recordChannelOverride;
}
public NoteEventReceivedEventArgs(int channel, string note, int octave, int velocity, MidiCommandCode command)
{
Channel = channel;
Note = note;
Octave = octave;
Velocity = velocity;
Command = command;
}
public Button(ref MidiOut midiOutRef, ButtonType butType, int cont, bool initialState, MidiCommandCode code = MidiCommandCode.ControlChange)
{
commandCode = code;
channel = 1;
buttonType = butType;
controller = cont;
midiOut = midiOutRef;
SetLight(initialState);
}
/// <summary>
/// Creates a MidiEvent from a raw message received using
/// the MME MIDI In APIs
/// </summary>
/// <param name="rawMessage">The short MIDI message</param>
/// <returns>A new MIDI Event</returns>
public static MidiEvent FromRawMessage(int rawMessage)
{
long absoluteTime = 0;
int b = rawMessage & 0xFF;
int data1 = (rawMessage >> 8) & 0xFF;
int data2 = (rawMessage >> 16) & 0xFF;
MidiCommandCode commandCode;
int channel = 1;
if ((b & 0xF0) == 0xF0)
{
// both bytes are used for command code in this case
commandCode = (MidiCommandCode)b;
}
else
{
commandCode = (MidiCommandCode)(b & 0xF0);
channel = (b & 0x0F) + 1;
}
MidiEvent me;
switch (commandCode)
{
case MidiCommandCode.NoteOn:
case MidiCommandCode.NoteOff:
case MidiCommandCode.KeyAfterTouch:
if (data2 > 0 && commandCode == MidiCommandCode.NoteOn)
{
me = new NoteOnEvent(absoluteTime, channel, data1, data2, 0);
}
else
{
me = new NoteEvent(absoluteTime, channel, commandCode, data1, data2);
}
break;
case MidiCommandCode.TimingClock:
case MidiCommandCode.StartSequence:
case MidiCommandCode.ContinueSequence:
case MidiCommandCode.StopSequence:
case MidiCommandCode.AutoSensing:
me = new MidiEvent(absoluteTime, channel, commandCode);
break;
case MidiCommandCode.MetaEvent:
case MidiCommandCode.Sysex:
default:
throw new FormatException(String.Format("Unsupported MIDI Command Code for Raw Message {0}", commandCode));
}
return(me);
}
public void AddEvent(MidiEvent midiEvent, int originalTrack)
{
if (this.midiFileType == 0)
{
this.EnsureTracks(1);
this.trackEvents[0].Add(midiEvent);
return;
}
if (originalTrack == 0)
{
MidiCommandCode commandCode = midiEvent.CommandCode;
if (commandCode <= MidiCommandCode.KeyAfterTouch)
{
if (commandCode != MidiCommandCode.NoteOff && commandCode != MidiCommandCode.NoteOn && commandCode != MidiCommandCode.KeyAfterTouch)
{
goto IL_A1;
}
}
else if (commandCode <= MidiCommandCode.PatchChange)
{
if (commandCode != MidiCommandCode.ControlChange && commandCode != MidiCommandCode.PatchChange)
{
goto IL_A1;
}
}
else if (commandCode != MidiCommandCode.ChannelAfterTouch && commandCode != MidiCommandCode.PitchWheelChange)
{
goto IL_A1;
}
this.EnsureTracks(midiEvent.Channel + 1);
this.trackEvents[midiEvent.Channel].Add(midiEvent);
return;
IL_A1:
this.EnsureTracks(1);
this.trackEvents[0].Add(midiEvent);
return;
}
this.EnsureTracks(originalTrack + 1);
this.trackEvents[originalTrack].Add(midiEvent);
}
public bool Match(int faderNumber, MidiEvent midiEvent, MidiCommandCode code, int offset, int channel = -1)
{
if (channel < 0)
{
channel = faderDef.channel;
}
if (midiEvent.Channel != channel)
{
return(false);
}
if (midiEvent.CommandCode != code)
{
return(false);
}
if (code == MidiCommandCode.ControlChange)
{
var me = (ControlChangeEvent)midiEvent;
if ((int)me.Controller == faderNumber + offset)
{
return(true);
}
}
else if (code == MidiCommandCode.NoteOn)
{
var me = (NoteEvent)midiEvent;
if (me.NoteNumber == faderNumber + offset)
{
return(true);
}
}
else if (code == MidiCommandCode.PitchWheelChange)
{
return(true);
}
return(false);
}
public NoteEvent(long absoluteTime, int channel, MidiCommandCode commandCode, int noteNumber, int velocity) : base(absoluteTime, channel, commandCode)
{
this.NoteNumber = noteNumber;
this.Velocity = velocity;
}
/// <summary>
/// Creates a MIDI Note Event with specified parameters
/// </summary>
/// <param name="absoluteTime">Absolute time of this event</param>
/// <param name="channel">MIDI channel number</param>
/// <param name="commandCode">MIDI command code</param>
/// <param name="noteNumber">MIDI Note Number</param>
/// <param name="velocity">MIDI Note Velocity</param>
public NoteEvent(long absoluteTime, int channel, MidiCommandCode commandCode, int noteNumber, int velocity)
: base(absoluteTime, channel, commandCode)
{
this.NoteNumber = noteNumber;
this.Velocity = velocity;
}
/// <summary>
/// Creates a MIDI event with specified parameters
/// </summary>
/// <param name="absoluteTime">Absolute time of this event</param>
/// <param name="channel">MIDI channel number</param>
/// <param name="commandCode">MIDI command code</param>
public MidiEvent(long absoluteTime, int channel, MidiCommandCode commandCode)
{
this.absoluteTime = absoluteTime;
this.Channel = channel;
this.commandCode = commandCode;
}
/// <summary>
/// Constructs a MidiEvent from a BinaryStream
/// </summary>
/// <param name="br">The binary stream of MIDI data</param>
/// <param name="previous">The previous MIDI event (pass null for first event)</param>
/// <returns>A new MidiEvent</returns>
public static MidiEvent ReadNextEvent(BinaryReader br, MidiEvent previous)
{
int deltaTime = MidiEvent.ReadVarInt(br);
MidiCommandCode commandCode;
int channel = 1;
byte b = br.ReadByte();
if((b & 0x80) == 0)
{
// a running command - command & channel are same as previous
commandCode = previous.CommandCode;
channel = previous.Channel;
br.BaseStream.Position--; // need to push this back
}
else
{
if((b & 0xF0) == 0xF0)
{
// both bytes are used for command code in this case
commandCode = (MidiCommandCode) b;
}
else
{
commandCode = (MidiCommandCode) (b & 0xF0);
channel = (b & 0x0F) + 1;
}
}
MidiEvent me;
switch(commandCode)
{
case MidiCommandCode.NoteOn:
me = new NoteOnEvent(br);
break;
case MidiCommandCode.NoteOff:
case MidiCommandCode.KeyAfterTouch:
me = new NoteEvent(br);
break;
//case MidiCommandCode.ControlChange:
// me = new ControlChangeEvent(br);
// break;
case MidiCommandCode.PatchChange:
me = new PatchChangeEvent(br);
break;
case MidiCommandCode.ChannelAfterTouch:
me = new ChannelAfterTouchEvent(br);
break;
case MidiCommandCode.PitchWheelChange:
me = new PitchWheelChangeEvent(br);
break;
case MidiCommandCode.TimingClock:
case MidiCommandCode.StartSequence:
case MidiCommandCode.ContinueSequence:
case MidiCommandCode.StopSequence:
me = new MidiEvent();
break;
case MidiCommandCode.Sysex:
me = SysexEvent.ReadSysexEvent(br);
break;
case MidiCommandCode.MetaEvent:
try {
me = MetaEvent.ReadMetaEvent(br);
}
catch(FormatException) {
me = new MidiEvent();
}
break;
default:
me = new MidiEvent();
break;
//throw new FormatException(String.Format("Unsupported MIDI Command Code {0:X2}",(byte) commandCode));
}
me.channel = channel;
me.deltaTime = deltaTime;
me.commandCode = commandCode;
return me;
}
/// <summary>
/// Creates a MidiEvent from a raw message received using
/// the MME MIDI In APIs
/// </summary>
/// <param name="rawMessage">The short MIDI message</param>
/// <returns>A new MIDI Event</returns>
public static MidiEvent FromRawMessage(int rawMessage)
{
long absoluteTime = 0;
int b = rawMessage & 0xFF;
int data1 = (rawMessage >> 8) & 0xFF;
int data2 = (rawMessage >> 16) & 0xFF;
MidiCommandCode commandCode;
int channel = 1;
if ((b & 0xF0) == 0xF0)
{
// both bytes are used for command code in this case
commandCode = (MidiCommandCode)b;
}
else
{
commandCode = (MidiCommandCode)(b & 0xF0);
channel = (b & 0x0F) + 1;
}
MidiEvent me;
switch (commandCode)
{
case MidiCommandCode.NoteOn:
case MidiCommandCode.NoteOff:
case MidiCommandCode.KeyAfterTouch:
if (data2 > 0 && commandCode == MidiCommandCode.NoteOn)
{
me = new NoteOnEvent(absoluteTime, channel, data1, data2, 0);
}
else
{
me = new NoteEvent(absoluteTime, channel, commandCode, data1, data2);
}
break;
//case MidiCommandCode.ControlChange:
// me = new ControlChangeEvent(absoluteTime,channel,(MidiController)data1,data2);
// break;
case MidiCommandCode.PatchChange:
me = new PatchChangeEvent(absoluteTime,channel,data1);
break;
case MidiCommandCode.ChannelAfterTouch:
me = new ChannelAfterTouchEvent(absoluteTime,channel,data1);
break;
case MidiCommandCode.PitchWheelChange:
me = new PitchWheelChangeEvent(absoluteTime, channel, data1 + (data2 << 7));
break;
case MidiCommandCode.TimingClock:
case MidiCommandCode.StartSequence:
case MidiCommandCode.ContinueSequence:
case MidiCommandCode.StopSequence:
case MidiCommandCode.AutoSensing:
me = new MidiEvent(absoluteTime,channel,commandCode);
break;
case MidiCommandCode.MetaEvent:
case MidiCommandCode.Sysex:
default:
throw new FormatException(String.Format("Unsupported MIDI Command Code for Raw Message {0}", commandCode));
}
return me;
}
/// <summary>
/// Constructs a MidiEvent from a BinaryStream
/// </summary>
/// <param name="br">The binary stream of MIDI data</param>
/// <param name="previous">The previous MIDI event (pass null for first event)</param>
/// <returns>A new MidiEvent</returns>
public static MidiEvent ReadNextEvent(BinaryReader br, MidiEvent previous)
{
int deltaTime = MidiEvent.ReadVarInt(br);
MidiCommandCode commandCode;
int channel = 1;
byte b = br.ReadByte();
if ((b & 0x80) == 0)
{
// a running command - command & channel are same as previous
commandCode = previous.CommandCode;
channel = previous.Channel;
br.BaseStream.Position--; // need to push this back
}
else
{
if ((b & 0xF0) == 0xF0)
{
// both bytes are used for command code in this case
commandCode = (MidiCommandCode)b;
}
else
{
commandCode = (MidiCommandCode)(b & 0xF0);
channel = (b & 0x0F) + 1;
}
}
MidiEvent me;
switch (commandCode)
{
case MidiCommandCode.NoteOn:
me = new NoteOnEvent(br);
break;
case MidiCommandCode.NoteOff:
case MidiCommandCode.KeyAfterTouch:
me = new NoteEvent(br);
break;
case MidiCommandCode.ControlChange:
me = new ControlChangeEvent(br);
break;
case MidiCommandCode.PatchChange:
me = new PatchChangeEvent(br);
break;
case MidiCommandCode.ChannelAfterTouch:
me = new ChannelAfterTouchEvent(br);
break;
case MidiCommandCode.PitchWheelChange:
me = new PitchWheelChangeEvent(br);
break;
case MidiCommandCode.TimingClock:
case MidiCommandCode.StartSequence:
case MidiCommandCode.ContinueSequence:
case MidiCommandCode.StopSequence:
me = new MidiEvent();
break;
case MidiCommandCode.Sysex:
me = SysexEvent.ReadSysexEvent(br);
break;
case MidiCommandCode.MetaEvent:
me = MetaEvent.ReadMetaEvent(br);
break;
default:
throw new FormatException(String.Format("Unsupported MIDI Command Code {0:X2}", (byte)commandCode));
}
me.channel = channel;
me.deltaTime = deltaTime;
me.commandCode = commandCode;
return(me);
}
/// <summary>
/// Creates a MIDI event with specified parameters
/// </summary>
/// <param name="absoluteTime">Absolute time of this event</param>
/// <param name="channel">MIDI channel number</param>
/// <param name="commandCode">MIDI command code</param>
public MidiEvent(long absoluteTime, int channel, MidiCommandCode commandCode)
{
this.absoluteTime = absoluteTime;
this.Channel = channel;
this.commandCode = commandCode;
}
/// <summary>
/// Creates a MidiEvent from a raw message received using
/// the MME MIDI In APIs
/// </summary>
/// <param name="rawMessage">The short MIDI message</param>
/// <returns>A new MIDI Event</returns>
// Token: 0x060004C7 RID: 1223 RVA: 0x0000FDD8 File Offset: 0x0000DFD8
public static MidiEvent FromRawMessage(int rawMessage)
{
long num = 0L;
int num2 = rawMessage & 255;
int num3 = rawMessage >> 8 & 255;
int num4 = rawMessage >> 16 & 255;
int num5 = 1;
MidiCommandCode midiCommandCode;
if ((num2 & 240) == 240)
{
midiCommandCode = (MidiCommandCode)num2;
}
else
{
midiCommandCode = (MidiCommandCode)(num2 & 240);
num5 = (num2 & 15) + 1;
}
MidiCommandCode midiCommandCode2 = midiCommandCode;
if (midiCommandCode2 <= MidiCommandCode.ControlChange)
{
if (midiCommandCode2 <= MidiCommandCode.NoteOn)
{
if (midiCommandCode2 != MidiCommandCode.NoteOff && midiCommandCode2 != MidiCommandCode.NoteOn)
{
goto IL_177;
}
}
else if (midiCommandCode2 != MidiCommandCode.KeyAfterTouch)
{
if (midiCommandCode2 != MidiCommandCode.ControlChange)
{
goto IL_177;
}
return(new ControlChangeEvent(num, num5, (MidiController)num3, num4));
}
if (num4 > 0 && midiCommandCode == MidiCommandCode.NoteOn)
{
return(new NoteOnEvent(num, num5, num3, num4, 0));
}
return(new NoteEvent(num, num5, midiCommandCode, num3, num4));
}
else if (midiCommandCode2 <= MidiCommandCode.ChannelAfterTouch)
{
if (midiCommandCode2 == MidiCommandCode.PatchChange)
{
return(new PatchChangeEvent(num, num5, num3));
}
if (midiCommandCode2 == MidiCommandCode.ChannelAfterTouch)
{
return(new ChannelAfterTouchEvent(num, num5, num3));
}
}
else
{
if (midiCommandCode2 == MidiCommandCode.PitchWheelChange)
{
return(new PitchWheelChangeEvent(num, num5, num3 + (num4 << 7)));
}
if (midiCommandCode2 != MidiCommandCode.Sysex)
{
switch (midiCommandCode2)
{
case MidiCommandCode.TimingClock:
case MidiCommandCode.StartSequence:
case MidiCommandCode.ContinueSequence:
case MidiCommandCode.StopSequence:
case MidiCommandCode.AutoSensing:
return(new MidiEvent(num, num5, midiCommandCode));
}
}
}
IL_177:
throw new FormatException(string.Format("Unsupported MIDI Command Code for Raw Message {0}", midiCommandCode));
}
/// <summary>
/// Constructs a MidiEvent from a BinaryStream
/// </summary>
/// <param name="br">The binary stream of MIDI data</param>
/// <param name="previous">The previous MIDI event (pass null for first event)</param>
/// <returns>A new MidiEvent</returns>
// Token: 0x060004C8 RID: 1224 RVA: 0x0000FF78 File Offset: 0x0000E178
public static MidiEvent ReadNextEvent(BinaryReader br, MidiEvent previous)
{
int num = MidiEvent.ReadVarInt(br);
int num2 = 1;
byte b = br.ReadByte();
MidiCommandCode midiCommandCode;
if ((b & 128) == 0)
{
midiCommandCode = previous.CommandCode;
num2 = previous.Channel;
br.BaseStream.Position -= 1L;
}
else if ((b & 240) == 240)
{
midiCommandCode = (MidiCommandCode)b;
}
else
{
midiCommandCode = (MidiCommandCode)(b & 240);
num2 = (int)((b & 15) + 1);
}
MidiCommandCode midiCommandCode2 = midiCommandCode;
MidiEvent midiEvent;
if (midiCommandCode2 <= MidiCommandCode.ControlChange)
{
if (midiCommandCode2 <= MidiCommandCode.NoteOn)
{
if (midiCommandCode2 != MidiCommandCode.NoteOff)
{
if (midiCommandCode2 != MidiCommandCode.NoteOn)
{
goto IL_15F;
}
midiEvent = new NoteOnEvent(br);
goto IL_175;
}
}
else if (midiCommandCode2 != MidiCommandCode.KeyAfterTouch)
{
if (midiCommandCode2 != MidiCommandCode.ControlChange)
{
goto IL_15F;
}
midiEvent = new ControlChangeEvent(br);
goto IL_175;
}
midiEvent = new NoteEvent(br);
goto IL_175;
}
if (midiCommandCode2 <= MidiCommandCode.ChannelAfterTouch)
{
if (midiCommandCode2 == MidiCommandCode.PatchChange)
{
midiEvent = new PatchChangeEvent(br);
goto IL_175;
}
if (midiCommandCode2 == MidiCommandCode.ChannelAfterTouch)
{
midiEvent = new ChannelAfterTouchEvent(br);
goto IL_175;
}
}
else
{
if (midiCommandCode2 == MidiCommandCode.PitchWheelChange)
{
midiEvent = new PitchWheelChangeEvent(br);
goto IL_175;
}
if (midiCommandCode2 == MidiCommandCode.Sysex)
{
midiEvent = SysexEvent.ReadSysexEvent(br);
goto IL_175;
}
switch (midiCommandCode2)
{
case MidiCommandCode.TimingClock:
case MidiCommandCode.StartSequence:
case MidiCommandCode.ContinueSequence:
case MidiCommandCode.StopSequence:
midiEvent = new MidiEvent();
goto IL_175;
case MidiCommandCode.MetaEvent:
midiEvent = MetaEvent.ReadMetaEvent(br);
goto IL_175;
}
}
IL_15F:
throw new FormatException(string.Format("Unsupported MIDI Command Code {0:X2}", (byte)midiCommandCode));
IL_175:
midiEvent.channel = num2;
midiEvent.deltaTime = num;
midiEvent.commandCode = midiCommandCode;
return(midiEvent);
}
private void HandleMidiMessageReceived(object sender, MidiInMessageEventArgs e)
{
MidiIn source = sender as MidiIn;
if (source == null)
{
return;
}
if (e.MidiEvent == null)
{
return;
}
MidiChannel channel = (MidiChannel)e.MidiEvent.Channel;
MidiCommandCode commandCode = e.MidiEvent.CommandCode;
if (e.MidiEvent.CommandCode == MidiCommandCode.NoteOn && (e.MidiEvent as NoteEvent).Velocity == 0)
{
commandCode = MidiCommandCode.NoteOff;
}
if (commandCode == MidiCommandCode.NoteOff)
{
int noteNumber = (e.MidiEvent as NoteEvent).NoteNumber;
int velocity = (e.MidiEvent as NoteEvent).Velocity;
DelegateToListeners(listener => listener.HandleNoteOff(noteNumber, velocity, channel), channel);
}
else if (commandCode == MidiCommandCode.NoteOn)
{
int noteNumber = (e.MidiEvent as NoteEvent).NoteNumber;
int velocity = (e.MidiEvent as NoteEvent).Velocity;
DelegateToListeners(listener => listener.HandleNoteOn(noteNumber, velocity, channel), channel);
}
else if (commandCode == MidiCommandCode.KeyAfterTouch)
{
int noteNumber = (e.MidiEvent as NoteEvent).NoteNumber;
int velocity = (e.MidiEvent as NoteEvent).Velocity;
DelegateToListeners(listener => listener.HandleNotePressure(noteNumber, velocity, channel), channel);
}
else if (commandCode == MidiCommandCode.ControlChange)
{
MidiController controller = (e.MidiEvent as ControlChangeEvent).Controller;
if (controller == MidiController.AllNotesOff)
{
DelegateToListeners(listener => listener.HandleAllNotesOff(channel), channel);
}
else if (controller == MidiController.ResetAllControllers)
{
DelegateToListeners(listener => listener.HandleResetControllers(channel), channel);
}
else
{
int controllerNumber = (int)controller;
int value = (e.MidiEvent as ControlChangeEvent).ControllerValue;
DelegateToListeners(listener => listener.HandleControlChange(controllerNumber, value, channel), channel);
}
}
else if (commandCode == MidiCommandCode.ChannelAfterTouch)
{
int value = (e.MidiEvent as ChannelAfterTouchEvent).AfterTouchPressure;
DelegateToListeners(listener => listener.HandleChannelPressure(value, channel), channel);
}
else if (commandCode == MidiCommandCode.PitchWheelChange)
{
int value = (e.MidiEvent as PitchWheelChangeEvent).Pitch;
DelegateToListeners(listener => listener.HandlePitchWheel(value, channel), channel);
}
}