private MidiInPort(string deviceId, MidiEndpoint endpoint)
{
DeviceId = deviceId;
_endpoint = endpoint;
_client = new MidiClient(Guid.NewGuid().ToString());
_port = _client.CreateInputPort(_endpoint.EndpointName);
}
//
// Creates a MidiClient which is our way of communicating with the
// CoreMidi stack
//
void SetupMidi()
{
client = new MidiClient("CoreMidiSample MIDI CLient");
client.ObjectAdded += delegate(object sender, ObjectAddedOrRemovedEventArgs e) {
};
client.ObjectAdded += delegate { ReloadDevices(); };
client.ObjectRemoved += delegate { ReloadDevices(); };
client.PropertyChanged += delegate(object sender, ObjectPropertyChangedEventArgs e) {
Console.WriteLine("Changed");
};
client.ThruConnectionsChanged += delegate {
Console.WriteLine("Thru connections changed");
};
client.SerialPortOwnerChanged += delegate {
Console.WriteLine("Serial port changed");
};
outputPort = client.CreateOutputPort("CoreMidiSample Output Port");
inputPort = client.CreateInputPort("CoreMidiSample Input Port");
inputPort.MessageReceived += delegate(object sender, MidiPacketsEventArgs e) {
Console.WriteLine("Got {0} packets", e.Packets.Length);
};
ConnectExistingDevices();
var session = MidiNetworkSession.DefaultSession;
if (session != null)
{
session.Enabled = true;
session.ConnectionPolicy = MidiNetworkConnectionPolicy.Anyone;
}
}
partial void DisposeNative()
{
_port?.Dispose();
_client?.Dispose();
_endpoint?.Dispose();
_port = null;
_client = null;
_endpoint = null;
}
public MidiPortViewModel(MidiPort midiPort, bool isSelected)
{
if (midiPort == null)
{
throw new ArgumentNullException(nameof(midiPort));
}
MidiPort = midiPort;
IsSelected = isSelected;
}
public void Dispose()
{
_port?.Disconnect(_endpoint);
_port?.Dispose();
_client?.Dispose();
_endpoint?.Dispose();
_port = null;
_client = null;
_endpoint = null;
}
/// <summary>
///
/// </summary>
unsafe public static void SendMidiSysEvent(MidiPort port, byte *data, int length)
{
List <byte> buf = new List <byte>();
for (int i = 0; i < length; i++)
{
buf.Add(data[i]);
}
var me = midiConverter.Convert(buf.ToArray());
SendMidiEvent(port, me);
}
public void WriteSysex(byte[] lpMsg, uint dwLength, uint dwCchannelGroup, int portNr)
{
MidiPort midiPort = mMidiOutPorts[portNr];
if (midiPort.IsDirectMidi)
{
mCOutPort.SendMidiMsg(lpMsg, dwLength, dwCchannelGroup);
}
else
{
// todo... mMidiOutputDevice.;
}
}
public void WriteMidiMessage(MidiMessage msg, int portNr)
{
MidiPort midiPort = mMidiOutPorts[portNr];
if (midiPort.IsDirectMidi)
{
mCOutPort.SendMidiMsg(msg.DwMsg, msg.DwChannelGroup);
}
else
{
if (mMidiOutputDevice != null)
{
// todo... mMidiOutputDevice.;
}
}
}
public void OpenInPort(int portNr)
{
if (!mOpenInPorts.Contains(portNr))
{
if (portNr < mMidiInPorts.Count)
{
mOpenInPorts.Add(portNr);
MidiPort midiPort = mMidiInPorts[portNr];
if (midiPort.IsDirectMidi)
{
try
{
INFOPORT info;
CMidiPort midiIn = (CMidiPort)mCInPort;
midiIn.GetPortInfo((uint)midiPort.Index, out info);
bool hasInPort = (HR_DMUS)midiIn.GetPortInfo((uint)midiPort.Index, out info) == HR_DMUS.HR_S_OK;
if (!hasInPort)
{
throw new Exception("Midi-in port apparently does not support midi-in. Right...");
}
else
{
mCInPort.ActivatePort(info, SYSTEM_EXCLUSIVE_MEM);
mCInPort.SetReceiver(this);
// Activates input MIDI message handling
mCInPort.ActivateNotification();
}
}
catch (CDMusicException DMEx)
{
MessageBox.Show(DMEx.GetErrorDescription() + DMEx.ToString());
}
}
else
{
mMidiInputDevice = Kernel32Midi.InputDevice.InstalledDevices[midiPort.Index];
if (mMidiInputDevice != null)
{
mMidiInputDevice.Open();
mMidiInputDevice.StartReceiving(null);
mMidiInputDevice.RawMessage += mMidiInputDevice_RawMessage;
}
}
}
}
}
public void CloseOutPort(int portNr)
{
mOpenOutPorts.Remove(portNr);
MidiPort midiPort = mMidiOutPorts[portNr];
if (midiPort.IsDirectMidi)
{
mCOutPort.ReleasePort();
}
else
{
if (mMidiOutputDevice != null)
{
mMidiOutputDevice.Close();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public static void SendMidiEvent(MidiPort port, MidiEvent e)
{
switch (port)
{
case MidiPort.PortA:
MidiEventReceivedA?.Invoke(typeof(MidiManager), e);
break;
case MidiPort.PortB:
MidiEventReceivedB?.Invoke(typeof(MidiManager), e);
break;
default:
MidiEventReceivedA?.Invoke(typeof(MidiManager), e);
MidiEventReceivedB?.Invoke(typeof(MidiManager), e);
break;
}
}
public void CloseInPort(int portNr)
{
mOpenInPorts.Remove(portNr);
MidiPort midiPort = mMidiInPorts[portNr];
if (midiPort.IsDirectMidi)
{
mCInPort.ReleasePort();
}
else
{
if (mMidiInputDevice != null)
{
mMidiInputDevice.StopReceiving();
mMidiInputDevice.Close();
mMidiInputDevice.RemoveAllEventHandlers();
}
}
}
public IList <MidiPort> GetMidiPorts()
{
var midiPorts = new List <MidiPort>();
var numberOfDevices = MidiIn.NumberOfDevices;
_logService.Verbose($"Found {numberOfDevices} MIDI input ports");
for (var i = 0; i < numberOfDevices; i++)
{
var midiPortInfo = MidiIn.DeviceInfo(i);
var midiPort = new MidiPort(i, midiPortInfo.ProductName);
midiPorts.Add(midiPort);
}
midiPorts.Sort((x, y) => string.Compare(x.Name, y.Name, StringComparison.OrdinalIgnoreCase));
return(midiPorts);
}
public void OpenOutPort(int portNr)
{
if (!mOpenOutPorts.Contains(portNr))
{
if (portNr < mMidiOutPorts.Count)
{
mOpenOutPorts.Add(portNr);
MidiPort midiPort = mMidiOutPorts[portNr];
if (midiPort.IsDirectMidi)
{
try
{
INFOPORT info;
CMidiPort midiOut = (CMidiPort)mCOutPort;
midiOut.GetPortInfo((uint)midiPort.Index, out info);
bool hasOutPort = (HR_DMUS)midiOut.GetPortInfo((uint)midiPort.Index, out info) == HR_DMUS.HR_S_OK;
if (!hasOutPort)
{
throw new Exception("Midi-out port apparently does not support midi-out. Right...");
}
else
{
mCOutPort.ActivatePort(info, SYSTEM_EXCLUSIVE_MEM);
}
}
catch (CDMusicException DMEx)
{
MessageBox.Show(DMEx.GetErrorDescription() + DMEx.ToString());
}
}
else
{
mMidiOutputDevice = Kernel32Midi.OutputDevice.InstalledDevices[midiPort.Index];
if (mMidiOutputDevice != null)
{
mMidiOutputDevice.Open();
}
}
}
}
}
public MidiNode_Channel(MidiPort p) : this(0, p)
{
}
/// <summary>Parse a meta MIDI event from the data stream.</summary>
/// <param name="deltaTime">The previously parsed delta-time for this event.</param>
/// <param name="eventType">The previously parsed type of message we're expecting to find.</param>
/// <param name="data">The data stream from which to read the event information.</param>
/// <param name="pos">The position of the start of the event information.</param>
/// <returns>The parsed meta MIDI event.</returns>
private static MidiEvent ParseMetaEvent(long deltaTime, byte eventType, byte [] data, ref long pos)
{
try
{
MidiEvent tempEvent = null;
// Create the correct meta event based on its meta event id/type
switch (eventType)
{
// Sequence number
case 0x00:
pos++; // skip past the 0x02
int number = ((data[pos] << 8) | data[pos + 1]);
tempEvent = new SequenceNumber(deltaTime, number);
pos += 2; // skip read values
break;
// Text events (copyright, lyrics, etc)
case 0x01: tempEvent = new Text(deltaTime, ReadASCIIText(data, ref pos)); break;
case 0x02: tempEvent = new Copyright(deltaTime, ReadASCIIText(data, ref pos)); break;
case 0x03: tempEvent = new SequenceTrackName(deltaTime, ReadASCIIText(data, ref pos)); break;
case 0x04: tempEvent = new Instrument(deltaTime, ReadASCIIText(data, ref pos)); break;
case 0x05: tempEvent = new Lyric(deltaTime, ReadASCIIText(data, ref pos)); break;
case 0x06: tempEvent = new Marker(deltaTime, ReadASCIIText(data, ref pos)); break;
case 0x07: tempEvent = new CuePoint(deltaTime, ReadASCIIText(data, ref pos)); break;
case 0x08: tempEvent = new ProgramName(deltaTime, ReadASCIIText(data, ref pos)); break;
case 0x09: tempEvent = new DeviceName(deltaTime, ReadASCIIText(data, ref pos)); break;
// Channel prefix
case 0x20:
pos++; // skip 0x1
tempEvent = new ChannelPrefix(deltaTime, data[pos]);
pos++; // skip read value
break;
// Port number
case 0x21:
pos++; // skip 0x1
tempEvent = new MidiPort(deltaTime, data[pos]);
pos++; // skip read value
break;
// End of track
case 0x2F:
pos++; // skip 0x0
tempEvent = new EndOfTrack(deltaTime);
break;
// Tempo
case 0x51:
pos++; // skip 0x3
int tempo = ((data[pos] << 16) | data[pos + 1] << 8 | data[pos + 2]);
tempEvent = new Tempo(deltaTime, tempo);
pos += 3;
break;
// SMPTE offset
case 0x54:
pos++; // skip 0x5
tempEvent = new SMPTEOffset(deltaTime,
data[pos], data[pos + 1], data[pos + 2], data[pos + 3], data[pos + 4]);
pos += 5;
break;
// Time signature
case 0x58:
pos++; // skip past 0x4
tempEvent = new TimeSignature(deltaTime,
data[pos], data[pos + 1], data[pos + 2], data[pos + 3]);
pos += 4;
break;
// Key signature
case 0x59:
pos++; // skip past 0x2
tempEvent = new KeySignature(deltaTime, (Key)data[pos], (Tonality)data[pos + 1]);
pos += 2;
break;
// Proprietary
case 0x7F:
// Read in the variable length and that much data, then store it
long length = ReadVariableLength(data, ref pos);
byte [] propData = new byte[length];
Array.Copy(data, (int)pos, propData, 0, (int)length);
tempEvent = new Proprietary(deltaTime, propData);
pos += length;
break;
// An unknown meta event!
default:
// Read in the variable length and that much data, then store it
length = ReadVariableLength(data, ref pos);
byte [] unknownData = new byte[length];
Array.Copy(data, (int)pos, unknownData, 0, (int)length);
tempEvent = new UnknownMetaMidiEvent(deltaTime, eventType, unknownData);
pos += length;
break;
}
return(tempEvent);
}
// Something bad happened; wrap it in a parser exception
catch (Exception exc) { throw new MidiParserException("Unable to parse meta MIDI event.", exc, pos); }
}
public MidiNode_MidiNote(int n, MidiPort p) : base(p)
{
SetNoteId(n);
}
public MidiNode_MidiNote(MidiPort p) : this(0, p)
{
}
public MidiNode(MidiPort p)
{
SetPort(p);
}
internal void Open()
{
_port = _client.CreateOutputPort(_endpoint.EndpointName);
}
public void SetPort(MidiPort p)
{
port = p;
}
/// <summary>
///
/// </summary>
/// <param name="e"></param>
public CancelMidiEventReceivedEventArgs(MidiPort port, MidiEventReceivedEventArgs e)
{
Port = port;
Event = e;
}
private static void ProcessNrpn(MidiPort port, ControlChangeEvent dataMsb, ControlChangeEvent dataLsb)
{
if (dataMsb != null)
{
switch (NrpnMsb[(int)port - 1, dataMsb.Channel])
{
case 64: // Inst Add/Del for Inst
{
break;
}
case 65: // Ch On/Off for Inst (ch 1-7)
{
foreach (var inst in InstrumentManager.GetAllInstruments())
{
if (inst.DeviceID == NrpnLsb[(int)port - 1, dataMsb.Channel]) // for Device ID
{
if (inst.UnitNumber == DataLsb[(int)port - 1, dataMsb.Channel]) // for Unit No
{
for (int i = 0; i < 6; i++)
{
inst.Channels[i] = (dataMsb.ControlValue & (1 << i)) != 0;
}
break;
}
}
}
break;
}
case 66: // Ch On/Off for Inst (ch 8-14)
{
foreach (var inst in InstrumentManager.GetAllInstruments())
{
if (inst.DeviceID == NrpnLsb[(int)port - 1, dataMsb.Channel]) // for Device ID
{
if (inst.UnitNumber == DataLsb[(int)port - 1, dataMsb.Channel]) // for Unit No
{
for (int i = 0; i < 6; i++)
{
inst.Channels[i + 6] = (dataMsb.ControlValue & (1 << i)) != 0;
}
break;
}
}
}
break;
}
case 67: // Ch On/Off for Inst (ch 15-16)
{
foreach (var inst in InstrumentManager.GetAllInstruments())
{
if (inst.DeviceID == NrpnLsb[(int)port - 1, dataMsb.Channel]) // for Device ID
{
if (inst.UnitNumber == DataLsb[(int)port - 1, dataMsb.Channel]) // for Unit No
{
for (int i = 0; i < 1; i++)
{
inst.Channels[i + 15] = (dataMsb.ControlValue & (1 << i)) != 0;
}
break;
}
}
}
break;
}
}
}
if (dataLsb != null)
{
switch (NrpnMsb[(int)port - 1, dataLsb.Channel])
{
case 65:
{
break;
}
}
}
}
public MidiNode_Channel(int c, MidiPort p) : base(p)
{
SetChannelId(c);
}
private static void ProcessSysEx(MidiPort port, MidiEvent e)
{
SysExEvent midiEvent = e as SysExEvent;
if (midiEvent != null)
{
sysExData[(int)port - 1].AddRange(midiEvent.Data);
if (midiEvent.Completed)
{
List <byte> data = sysExData[(int)port - 1];
try
{
if (data[data.Count - 1] != 0xf7) //END SysEx
{
return;
}
if (!(data.Count >= 1))
{
return;
}
switch (data[0])
{
//All device
case 0x7f:
if (data.Count <= 1)
{
break;
}
switch (data[1])
{
//All device
case 0x7f:
if (data.Count <= 2)
{
break;
}
switch (data[2])
{
//COMMON
case 0x04:
{
if (data.Count <= 3)
{
break;
}
switch (data[3])
{
//MASTER VOLUME
case 0x01:
{
if (data.Count > 6)
{
InstrumentBase.MasterGain = (float)data[5] / 127f;
}
break;
}
}
break;
}
}
break;
}
break;
//GM
case 0x7e:
if (data.Count <= 1)
{
break;
}
switch (data[1])
{
//All device
case 0x7f:
if (data.Count <= 2)
{
break;
}
switch (data[2])
{
//
case 0x09:
if (data.Count <= 3)
{
break;
}
switch (data[3])
{
//GM RESET
case 0x01:
{
Panic();
Reset();
break;
}
}
break;
}
break;
}
break;
//Roland
case 0x41:
if (data.Count <= 1)
{
break;
}
switch (data[1])
{
//All device
default:
if (data.Count <= 2)
{
break;
}
switch (data[2])
{
//
case 0x42:
if (data.Count <= 3)
{
break;
}
switch (data[3])
{
case 0x12:
{
if (data.Count <= 6)
{
break;
}
//GS RESET
if (data[4] == 0x40 && data[5] == 0x00 && data[6] == 0x7f)
{
Panic();
Reset();
}
break;
}
}
break;
}
break;
}
break;
}
}
finally
{
data.Clear();
}
}
}
}
private static void ProcessCC(MidiPort port, MidiEvent e)
{
ControlChangeEvent midiEvent = e as ControlChangeEvent;
if (midiEvent != null)
{
switch (midiEvent.ControlNumber)
{
case 6: //Data Entry MSB
DataMsb[(int)port - 1, midiEvent.Channel] = midiEvent.ControlValue;
switch (lastDateEntryType)
{
case DataEntryType.Nrpn:
ProcessNrpn(port, midiEvent, null);
break;
case DataEntryType.Rpn:
break;
}
break;
case 38: //Data Entry LSB
DataLsb[(int)port - 1, midiEvent.Channel] = midiEvent.ControlValue;
switch (lastDateEntryType)
{
case DataEntryType.Nrpn:
ProcessNrpn(port, null, midiEvent);
break;
case DataEntryType.Rpn:
break;
}
break;
case 96: //Data Increment
break;
case 97: //Data Decrement
break;
case 98: //NRPN LSB
NrpnLsb[(int)port - 1, midiEvent.Channel] = midiEvent.ControlValue;
lastDateEntryType = DataEntryType.Nrpn;
break;
case 99: //NRPN MSB
NrpnMsb[(int)port - 1, midiEvent.Channel] = midiEvent.ControlValue;
lastDateEntryType = DataEntryType.Nrpn;
break;
case 100: //RPN LSB
RpnLsb[(int)port - 1, midiEvent.Channel] = midiEvent.ControlValue;
lastDateEntryType = DataEntryType.Rpn;
break;
case 101: //RPN MSB
RpnMsb[(int)port - 1, midiEvent.Channel] = midiEvent.ControlValue;
lastDateEntryType = DataEntryType.Rpn;
break;
}
}
}
void SetupMidi()
{
client = new MidiClient("Stimulant iOS MIDI Client");
client.ObjectAdded += delegate(object sender, ObjectAddedOrRemovedEventArgs e) {
};
client.ObjectAdded += delegate {
};
client.ObjectRemoved += delegate {
};
client.PropertyChanged += delegate(object sender, ObjectPropertyChangedEventArgs e) {
Console.WriteLine("Changed");
};
client.ThruConnectionsChanged += delegate {
Console.WriteLine("Thru connections changed");
};
client.SerialPortOwnerChanged += delegate {
Console.WriteLine("Serial port changed");
};
outputPort = client.CreateOutputPort("Stimulant iOS Output Port");
inputPort = client.CreateInputPort("Stimulant iOS Input Port");
inputPort.MessageReceived += delegate(object sender, MidiPacketsEventArgs e) {
foreach (MidiPacket mPacket in e.Packets)
{
//if (myMidiModulation.ModeNumber == 1)
//{
var midiData = new byte[mPacket.Length];
Marshal.Copy(mPacket.Bytes, midiData, 0, mPacket.Length);
//The first four bits of the status byte tell MIDI what command
//The last four bits of the status byte tell MIDI what channel
byte StatusByte = midiData[0];
byte typeData = (byte)((StatusByte & 0xF0) >> 4);
byte channelData = (byte)(StatusByte & 0x0F);
//We should check to see if typeData is clock/start/continue/stop/note on/note off
//-----------defines each midi byte---------------
byte midi_start = 0xfa; // start byte
byte midi_stop = 0xfc; // stop byte
byte midi_clock = 0xf8; // clock byte
byte midi_continue = 0xfb; // continue byte
byte midi_note_on = 0x90; // note on
byte midi_note_off = 0x80; // note off
//------------------------------------------------
if ((StatusByte == midi_start) || (StatusByte == midi_continue))
{
if (!myMidiModulation.IsRunning)
{
InvokeOnMainThread(() => {
//PowerPushed();
//FlipPower();
//powerButton.SetOn();
myMidiModulation.IsRunning = powerButton.TogglePower(); // true;//powerButton.TogglePower();
Debug.WriteLine("MIDI START @ " + DateTime.Now.Millisecond.ToString());
if (myMidiModulation.IsRunning)
{
myMidiModulation.CatchClock();
}
});
}
//myMidiModulation.FireModulation = true; //I'm not sure if we should be firing one off at the start here
}
if (StatusByte == midi_clock)
{
if (myMidiModulation.ModeNumber == 1)
{
Debug.WriteLine("MIDI CLOCK @ " + DateTime.Now.Millisecond.ToString());
if (myMidiModulation.IsRunning)
{
myMidiModulation.CatchClock();
}
/*
* myMidiModulation.ClockCounter();
* if (myMidiModulation.StepComma > 1)
* {
* myMidiModulation.StepComma = 0;
* }
* else
* {
* myMidiModulation.StepComma++;
* }
* myMidiModulation.StepSizeSetter();
*/
}
}
if (StatusByte == midi_stop)
{
if (myMidiModulation.IsRunning)
{
InvokeOnMainThread(() => {
//PowerPushed();
//FlipPower();
myMidiModulation.IsRunning = powerButton.TogglePower();
});
//myMidiModulation.Reset();
}
}
if (myMidiModulation.IsTriggerOnly)
{
if (StatusByte == midi_note_on)
{
// handle note on
myMidiModulation.IsNoteOn = true;
myMidiModulation.NumOfNotesOn += 1;
// Restart first if in restart mode
if (myMidiModulation.IsRestartEachNote)
{
//myMidiModulation.CurrentCC = myMidiModulation.StartingLocation;
myMidiModulation.CurrentXVal = myMidiModulation.StartingLocation;
if (myMidiModulation.PatternNumber == 4)
{
myMidiModulation.EveryOther = false;
}
else if (myMidiModulation.PatternNumber == 5 || myMidiModulation.PatternNumber == 6)
{
myMidiModulation.EveryOther = true;
}
}
}
if (StatusByte == midi_note_off)
{
if (myMidiModulation.NumOfNotesOn > 0)
{
myMidiModulation.NumOfNotesOn -= 1;
}
if (myMidiModulation.NumOfNotesOn < 1)
{
// handle note off
myMidiModulation.IsNoteOn = false;
myMidiModulation.NumOfNotesOn = 0;
}
}
}
//}
}
};
ConnectExistingDevices();
//var session = MidiNetworkSession.DefaultSession;
var session = MidiNetworkSession.DefaultSession;
if (session != null)
{
session.Enabled = true;
session.ConnectionPolicy = MidiNetworkConnectionPolicy.Anyone;
}
}
//
// Creates a MidiClient which is our way of communicating with the
// CoreMidi stack
//
void SetupMidi ()
{
client = new MidiClient ("CoreMidiSample MIDI CLient");
client.ObjectAdded += delegate(object sender, ObjectAddedOrRemovedEventArgs e) {
};
client.ObjectAdded += delegate { ReloadDevices (); };
client.ObjectRemoved += delegate { ReloadDevices (); };
client.PropertyChanged += delegate(object sender, ObjectPropertyChangedEventArgs e) {
Console.WriteLine ("Changed");
};
client.ThruConnectionsChanged += delegate {
Console.WriteLine ("Thru connections changed");
};
client.SerialPortOwnerChanged += delegate {
Console.WriteLine ("Serial port changed");
};
outputPort = client.CreateOutputPort ("CoreMidiSample Output Port");
inputPort = client.CreateInputPort ("CoreMidiSample Input Port");
inputPort.MessageReceived += delegate(object sender, MidiPacketsEventArgs e) {
Console.WriteLine ("Got {0} packets", e.Packets.Length);
};
ConnectExistingDevices ();
var session = MidiNetworkSession.DefaultSession;
if (session != null){
session.Enabled = true;
session.ConnectionPolicy = MidiNetworkConnectionPolicy.Anyone;
}
}
/// <summary>Creates an object creation expression for an event.</summary>
/// <param name="ev">The event to create.</param>
/// <returns>The object creation expression for the event.</returns>
private static CodeObjectCreateExpression CreateMetaEvent(MidiEvent ev)
{
CodeObjectCreateExpression newEvent = null;
CodeExpression delta = new CodePrimitiveExpression(ev.DeltaTime);
// SEQUENCE NUMBER
if (ev is SequenceNumber)
{
SequenceNumber midiEvent = (SequenceNumber)ev;
newEvent = new CodeObjectCreateExpression(
typeof(SequenceNumber),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Number)
});
}
// TEXT
else if (ev is Text)
{
Text midiEvent = (Text)ev;
newEvent = new CodeObjectCreateExpression(
typeof(Text),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Text)
});
}
// Copyright
else if (ev is Copyright)
{
Copyright midiEvent = (Copyright)ev;
newEvent = new CodeObjectCreateExpression(
typeof(Copyright),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Text)
});
}
// SEQUENCE TRACK NAME
else if (ev is SequenceTrackName)
{
SequenceTrackName midiEvent = (SequenceTrackName)ev;
newEvent = new CodeObjectCreateExpression(
typeof(SequenceTrackName),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Text)
});
}
// INSTRUMENT
else if (ev is Instrument)
{
Instrument midiEvent = (Instrument)ev;
newEvent = new CodeObjectCreateExpression(
typeof(Instrument),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Text)
});
}
// Lyric
else if (ev is Lyric)
{
Lyric midiEvent = (Lyric)ev;
newEvent = new CodeObjectCreateExpression(
typeof(Lyric),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Text)
});
}
// Marker
else if (ev is Marker)
{
Marker midiEvent = (Marker)ev;
newEvent = new CodeObjectCreateExpression(
typeof(Marker),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Text)
});
}
// CuePoint
else if (ev is CuePoint)
{
CuePoint midiEvent = (CuePoint)ev;
newEvent = new CodeObjectCreateExpression(
typeof(CuePoint),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Text)
});
}
// ProgramName
else if (ev is ProgramName)
{
ProgramName midiEvent = (ProgramName)ev;
newEvent = new CodeObjectCreateExpression(
typeof(ProgramName),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Text)
});
}
// ProgramName
else if (ev is DeviceName)
{
DeviceName midiEvent = (DeviceName)ev;
newEvent = new CodeObjectCreateExpression(
typeof(DeviceName),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Text)
});
}
// ChannelPrefix
else if (ev is ChannelPrefix)
{
ChannelPrefix midiEvent = (ChannelPrefix)ev;
newEvent = new CodeObjectCreateExpression(
typeof(ChannelPrefix),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Prefix)
});
}
// MidiPort
else if (ev is MidiPort)
{
MidiPort midiEvent = (MidiPort)ev;
newEvent = new CodeObjectCreateExpression(
typeof(MidiPort),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Port)
});
}
// EndOfTrack
else if (ev is EndOfTrack)
{
EndOfTrack midiEvent = (EndOfTrack)ev;
newEvent = new CodeObjectCreateExpression(
typeof(EndOfTrack),
new CodeExpression[] {
delta
});
}
// Tempo
else if (ev is Tempo)
{
Tempo midiEvent = (Tempo)ev;
newEvent = new CodeObjectCreateExpression(
typeof(Tempo),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Value)
});
}
// SMPTEOffset
else if (ev is SMPTEOffset)
{
SMPTEOffset midiEvent = (SMPTEOffset)ev;
newEvent = new CodeObjectCreateExpression(
typeof(SMPTEOffset),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Hours),
new CodePrimitiveExpression(midiEvent.Minutes),
new CodePrimitiveExpression(midiEvent.Seconds),
new CodePrimitiveExpression(midiEvent.Frames),
new CodePrimitiveExpression(midiEvent.FractionalFrames)
});
}
// TimeSignature
else if (ev is TimeSignature)
{
TimeSignature midiEvent = (TimeSignature)ev;
newEvent = new CodeObjectCreateExpression(
typeof(TimeSignature),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Numerator),
new CodePrimitiveExpression(midiEvent.Denominator),
new CodePrimitiveExpression(midiEvent.MidiClocksPerClick),
new CodePrimitiveExpression(midiEvent.NumberOfNotated32nds)
});
}
// KeySignature
else if (ev is KeySignature)
{
KeySignature midiEvent = (KeySignature)ev;
newEvent = new CodeObjectCreateExpression(
typeof(KeySignature),
new CodeExpression[] {
delta,
new CodeCastExpression(typeof(Key), new CodePrimitiveExpression((byte)midiEvent.Key)),
new CodeCastExpression(typeof(Tonality), new CodePrimitiveExpression((byte)midiEvent.Tonality))
});
}
// Proprietary
else if (ev is Proprietary)
{
Proprietary midiEvent = (Proprietary)ev;
newEvent = new CodeObjectCreateExpression(
typeof(Proprietary),
new CodeExpression[] {
delta,
CreateDataArray(midiEvent.Data)
});
}
// UnknownMetaMidiEvent
else if (ev is UnknownMetaMidiEvent)
{
UnknownMetaMidiEvent midiEvent = (UnknownMetaMidiEvent)ev;
newEvent = new CodeObjectCreateExpression(
typeof(UnknownMetaMidiEvent),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.MetaEventID),
CreateDataArray(midiEvent.Data)
});
}
// Return the event
return(newEvent);
}
/// <summary>
///
/// </summary>
public static void SendMidiEvent(MidiPort port, byte data1, byte data2, byte data3)
{
var me = midiConverter.Convert(new byte[] { data1, data2, data3 });
SendMidiEvent(port, me);
}
public MidiNode_Process(Process <MidiMessage> pr, MidiPort p) : base(p)
{
process = pr;
}
