Exemplo n.º 1
0
        public void SetInstrumentPlugin(VstInstrumentPlugin plugin)
        {
            mIgnoreEvents = true;

            mActiveNotes.Clear();
            mInstrumentPlugin                = plugin;
            nudTranspose.Value               = mInstrumentPlugin.Transpose;
            rbtnControlPedalEffect.Checked   = mInstrumentPlugin.ExpressionPedalFunction == ExpressionPedalFunction.EffectControl;
            cbExpressionInvert.Checked       = mInstrumentPlugin.ExpressionPedalInvert;
            rbtnControlPedalVolume.Checked   = mInstrumentPlugin.ExpressionPedalFunction == ExpressionPedalFunction.VolumeControl;
            rbtnControlPedalNone.Checked     = mInstrumentPlugin.ExpressionPedalFunction == ExpressionPedalFunction.None;
            cbNoteDrop.Checked               = mInstrumentPlugin.NoteDrop;
            comboNoteDropDelay.Enabled       = mInstrumentPlugin.NoteDrop;
            comboNoteDropDelay.SelectedIndex = mInstrumentPlugin.NoteDropDelayIndex;
            cbSustain.Checked                = mInstrumentPlugin.SustainEnabled;

            // Set keys according to channel info
            if (mInstrumentPlugin.KeyZoneActive)
            {
                if (mInstrumentPlugin.KeyZoneLower > Piano.LowestKeyNumer)
                {
                    pianoControl1.TurnRangeKeysOff(Piano.LowestKeyNumer, mInstrumentPlugin.KeyZoneLower - 1);
                }

                pianoControl1.TurnRangeKeysOn(mInstrumentPlugin.KeyZoneLower, mInstrumentPlugin.KeyZoneUpper);

                if (mInstrumentPlugin.KeyZoneUpper < Piano.HighestKeyNumer)
                {
                    pianoControl1.TurnRangeKeysOff(mInstrumentPlugin.KeyZoneUpper + 1, Piano.HighestKeyNumer);
                }
            }
            else
            {
                pianoControl1.TurnAllKeysOff();
            }
            mIgnoreEvents = false;
        }
Exemplo n.º 2
0
        private VstEvent[] filterMidiInMessages(int midiInCount, VstInstrumentPlugin plugin)
        {
            //bool active, int lowerNote, int upperNote, int transpose, ControlPedalAction pedal)
            //, ch.KeyZoneLower, ch.KeyZoneUpper, ch.Transpose, ch.ControlPedalAction
            int pitch;

            mFilteredMidiEvents.Clear();

            bool wrongChannel = false;

            for (int i = 0; i < midiInCount; i++)
            {
                MidiMessage msg = mMidiInMessages[i];

                wrongChannel = ((msg.Channel + 1) != (int)plugin.MidiChannel) && (plugin.MidiChannel != MidiChannel.ChannelAll);

                // Add note to selection
                // Copy event
                byte[] data = new byte[4];
                msg.Data.CopyTo(data, 0);
                VstMidiEvent newEv = new VstMidiEvent(
                    /*DeltaFrames*/ 0,
                    /*NoteLength*/ 0,
                    /*NoteOffset*/ 0,
                    data,
                    /*Detune*/ 0,
                    /*NoteOffVelocity*/ 127);

                // Force to midi channel 1 = 0xn0
                data[0] = (byte)(data[0] & 0xf0);

                if (data[0] == 176 && data[1] == 11)
                {
                    switch (plugin.ExpressionPedalFunction)
                    {
                    case ExpressionPedalFunction.EffectControl:
                        // Re-route foot control to wheel!
                        data[1] = 1;

                        if (plugin.UseExtendedEffectRange)
                        {
                            int wheel = data[2] * 2;
                            if (wheel > 255)
                            {
                                wheel = 255;
                            }
                            // Most plugins use an inverted direction. So default is to invert.
                            // If ExpressionPedalInvert; do not invert data
                            if (plugin.ExpressionPedalInvert)
                            {
                                data[2] = (byte)wheel;
                            }
                            else
                            {
                                data[2] = (byte)(255 - wheel);
                            }
                        }
                        else
                        {
                            // Most plugins use an inverted direction. So default is to invert.
                            // If ExpressionPedalInvert; do not invert data
                            if (!plugin.ExpressionPedalInvert)
                            {
                                data[2] = (byte)(127 - data[2]);
                            }
                        }
                        break;

                    case ExpressionPedalFunction.VolumeControl:
                        // Do nothing;
                        break;

                    case ExpressionPedalFunction.None:
                        // Next for; do not handle this midi command
                        continue;

                    default:
                        // Do nothing
                        break;
                    }
                }

                if (msg.IsNoteOn(out pitch))
                {
                    // Note-on event
                    if (wrongChannel || (plugin.State != PluginState.Activated || plugin.KeyZoneActive && (pitch < plugin.KeyZoneLower || pitch > plugin.KeyZoneUpper)))
                    {
                        // Ignore note-on
                        continue;
                    }
                    plugin.Notes[pitch].Pressed  = true;
                    plugin.Notes[pitch].Velocity = data[2];
                    newEv.Data[1] += (byte)plugin.Transpose;
                    mFilteredMidiEvents.Add(newEv);
                }
                else if (msg.IsNoteOff(out pitch))
                {
                    // Note-off event
                    if (wrongChannel || (plugin.KeyZoneActive && (pitch < plugin.KeyZoneLower || pitch > plugin.KeyZoneUpper)))
                    {
                        // Ignore note-off
                        continue;
                    }
                    newEv.Data[1] += (byte)plugin.Transpose;
                    if (plugin.Notes[pitch].PressedTime >= plugin.NoteDropDelay)
                    {
                        // Also send note-off message for note-dropped note
                        byte[] noteOffData = new byte[4];
                        noteOffData[0] = 128;
                        noteOffData[1] = (byte)(pitch - 12);
                        noteOffData[2] = plugin.Notes[pitch].Velocity;
                        noteOffData[3] = 112;
                        VstMidiEvent noteOffEvent = new VstMidiEvent(
                            /*DeltaFrames*/ 0,
                            /*NoteLength*/ 0,
                            /*NoteOffset*/ 0,
                            noteOffData,
                            /*Detune*/ 0,
                            /*NoteOffVelocity*/ 127);
                        mFilteredMidiEvents.Add(noteOffEvent);
                    }
                    plugin.Notes[pitch].Pressed = false;
                    mFilteredMidiEvents.Add(newEv);
                }
                else if (msg.IsSustain())
                {
                    if (plugin.SustainEnabled)
                    {
                        mFilteredMidiEvents.Add(newEv);
                    }
                    continue;
                }
                else
                {
                    // All other events
                    mFilteredMidiEvents.Add(newEv);
                }
            }


            // Process note on times; for now only required when NoteDrop = true
            if (plugin.NoteDrop)
            {
                for (int i = 0; i < 255; i++)
                {
                    if (plugin.Notes[i].Pressed)
                    {
                        plugin.Notes[i].PressedTime++;
                        if (plugin.Notes[i].PressedTime == plugin.NoteDropDelay)
                        {
                            byte[] noteDropData = new byte[4];
                            noteDropData[0] = 144;
                            noteDropData[1] = (byte)(i - 12);
                            noteDropData[2] = plugin.Notes[i].Velocity;
                            noteDropData[3] = 112;
                            VstMidiEvent newEv = new VstMidiEvent(
                                /*DeltaFrames*/ 0,
                                /*NoteLength*/ 0,
                                /*NoteOffset*/ 0,
                                noteDropData,
                                /*Detune*/ 0,
                                /*NoteOffVelocity*/ 127);
                            mFilteredMidiEvents.Add(newEv);
                        }
                    }
                }
            }

            return(mFilteredMidiEvents.ToArray());
        }