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; }