Пример #1
0
 protected void DryEventRecieved(MssEvent dryEvent)
 {
     if (!enabled) {
         return;
     }
     Debug.WriteLine("In: " + FormatEvent(dryEvent));
 }
Пример #2
0
 protected void WetEventRecieved(MssEvent wetEvent)
 {
     if (!enabled)
     {
         return;
     }
     Debug.WriteLine("Out: " + FormatEvent(wetEvent));
 }
Пример #3
0
 protected void DryEventRecieved(MssEvent dryEvent)
 {
     if (!enabled)
     {
         return;
     }
     Debug.WriteLine("In: " + FormatEvent(dryEvent));
 }
Пример #4
0
 protected void WetEventRecieved(MssEvent wetEvent)
 {
     if (!enabled)
     {
         return;
     }
     Debug.WriteLine("Out: " + FormatEvent(wetEvent));
 }
Пример #5
0
 protected string FormatEvent(MssEvent mssEvent)
 {
     return string.Format("{0} {1}, {2}, {3} at {4}",
             mssEvent.mssMsg.Type,
             Math.Round(mssEvent.mssMsg.Data1, 3),
             Math.Round(mssEvent.mssMsg.Data2, 3),
             Math.Round(mssEvent.mssMsg.Data3, 3),
             mssEvent.sampleTime);
 }
Пример #6
0
 protected string FormatEvent(MssEvent mssEvent)
 {
     return(string.Format("{0} {1}, {2}, {3} at {4}",
                          mssEvent.mssMsg.Type,
                          Math.Round(mssEvent.mssMsg.Data1, 3),
                          Math.Round(mssEvent.mssMsg.Data2, 3),
                          Math.Round(mssEvent.mssMsg.Data3, 3),
                          mssEvent.sampleTime));
 }
        /// <summary>
        ///     Event handler for MssEvents coming
        /// </summary>
        /// <param name="dryMssEvent"></param>
        protected void dryMssEventOutputPort_DryMssEventRecieved(MssEvent dryMssEvent)
        {
            foreach (MssMsg mssMsg in this.mssMsgProcessor.ProcessMssMsg(dryMssEvent.mssMsg)) {
                MssEvent wetEvent = new MssEvent();
                wetEvent.mssMsg = mssMsg;
                wetEvent.sampleTime = dryMssEvent.sampleTime;

                //Send the processed MssEvent to the WetMssEventRelay
                this.wetMssEventInputPort.ReceiveWetMssEvent(wetEvent);
            }
        }
        /// <summary>
        ///     Event handler for MssEvents coming
        /// </summary>
        /// <param name="dryMssEvent"></param>
        protected void dryMssEventOutputPort_DryMssEventRecieved(MssEvent dryMssEvent)
        {
            foreach (MssMsg mssMsg in this.mssMsgProcessor.ProcessMssMsg(dryMssEvent.mssMsg))
            {
                MssEvent wetEvent = new MssEvent();
                wetEvent.mssMsg     = mssMsg;
                wetEvent.sampleTime = dryMssEvent.sampleTime;

                //Send the processed MssEvent to the WetMssEventRelay
                this.wetMssEventInputPort.ReceiveWetMssEvent(wetEvent);
            }
        }
        public void ConvertMssEventToVstMidiEvent_NoValidConversion_ReturnsNull()
        {
            MidiHandlerProtectedWrapper midiHandler = Factory_MidiHandler_Basic();

            long sampleTime = 123456;

            MssEvent internalEvent = new MssEvent();
            internalEvent.mssMsg = new MssMsg(MssMsgType.Generator, 0, 0, 0);
            internalEvent.sampleTime = sampleTime;

            VstMidiEvent convertedEvent = midiHandler.ConvertMssEventToVstMidiEventWrapper(
                internalEvent, sampleTime, this.hostInfoOutputPort.SampleRate);

            Assert.IsNull(convertedEvent);
        }
        protected void WetEventReceived(MssEvent wetEvent)
        {
            lock (MssComponentHub.criticalSectioinLock)
            {
                if (wetEvent.mssMsg.Type == MssMsgType.Parameter)
                {
                    if (Enum.IsDefined(typeof(MssParameterID), (int)wetEvent.mssMsg.Data1) == false)
                    {
                        //Unknown MssParameterId
                        Debug.Assert(false);
                        return;
                    }

                    this.mssParameters.SetParameterRelativeValue(
                        (MssParameterID)(int)wetEvent.mssMsg.Data1,
                        wetEvent.mssMsg.Data3);
                }
            }
        }
        protected void ParameterValueChanged(MssParameterID paramId, double newValue)
        {
            lock (MssComponentHub.criticalSectioinLock)
            {
                if (this.hostInfoOutput.SampleRateIsInitialized == false)
                {
                    return;
                }

                long watchOffestAtParamChanged = this.stopwatch.Elapsed.Ticks;

                MssParamInfo paramInfo = this.mssParameters.GetParameterInfoCopy(paramId);
                double       relValue  = CustomMathUtils.AbsToRelVal(paramInfo.MinValue, paramInfo.MaxValue, newValue);

                MssMsg paramMsg = new MssMsg(MssMsgType.Parameter,
                                             (int)paramId,
                                             MssMsgUtil.UNUSED_MSS_MSG_DATA,
                                             relValue);
                MssEvent paramEvent = new MssEvent();

                paramEvent.mssMsg = paramMsg;

                long   ticksSinceCycleEnd   = watchOffestAtParamChanged - this.watchOffestAtLastCycleEnd;
                double secondsSinceCycleEnd = ticksSinceCycleEnd / (double)TimeSpan.TicksPerSecond;
                long   samplesSinceCycleEnd = (long)Math.Round(secondsSinceCycleEnd * this.hostInfoOutput.SampleRate);

                //Sometimes the stopwatch may not be accurate enough to notice the difference
                //between the end of the last cycle and now. Setting samplesSinceCycleEnd to
                //1 will cause this event to happen at the very start of this processing cycle.
                if (samplesSinceCycleEnd == 0)
                {
                    samplesSinceCycleEnd = 1;
                }

                paramEvent.sampleTime = this.sampleTimeAtLastCycleEnd + samplesSinceCycleEnd;

                this.dryEventInput.ReceiveDryMssEvent(paramEvent);
            }
        }
        protected void WetEventReceived(MssEvent wetEvent)
        {
            lock (MssComponentHub.criticalSectioinLock)
            {
                if (wetEvent.mssMsg.Type == MssMsgType.Parameter)
                {
                    if (Enum.IsDefined(typeof(MssParameterID), (int)wetEvent.mssMsg.Data1) == false)
                    {
                        //Unknown MssParameterId
                        Debug.Assert(false);
                        return;
                    }

                    this.mssParameters.SetParameterRelativeValue(
                        (MssParameterID)(int)wetEvent.mssMsg.Data1,
                        wetEvent.mssMsg.Data3);
                }

            }
        }
Пример #13
0
 public void dryMssEventInputPort_DryMssEventRecieved(MssEvent dryMssEvent)
 {
     numDryEventsReceivedByRelay++;
 }
Пример #14
0
        //*******************************Helpers*******************************
        //if testMssToMidi is true then this method tests ConvertMssEventToVstMidiEvent. Otherwise this method tests ConvertVstMidiEventToMssEvent
        protected void Test_MsgConversion(MssMsgType msgType, int midiChannel, int midiParam1, int midiParam2, bool testMssToMidi)
        {
            long sampleTimeAtStartOfCycle = 12345;
            int deltaFrames = 789;

            MidiHandlerProtectedWrapper midiHandler = Factory_MidiHandler_Basic();

            MssEvent mssEvent = new MssEvent();

            if (msgType == MssMsgType.PitchBend)
            {
                mssEvent.mssMsg = new MssMsg(msgType, midiChannel, MssMsgUtil.UNUSED_MSS_MSG_DATA, (midiParam2 << 7) + midiParam1);
            }
            else
            {
                mssEvent.mssMsg = new MssMsg(msgType, midiChannel, midiParam1, midiParam2);
            }
            mssEvent.sampleTime = sampleTimeAtStartOfCycle + deltaFrames;

            byte[] midiData = MidiUtil.CreateMidiData(msgType, midiChannel, (byte)midiParam1, (byte)midiParam2);
            VstMidiEvent midiEvent = new VstMidiEvent(deltaFrames, 0, 0, midiData, 0, 0x00);

            if (testMssToMidi == true)
            {
                MssEvent convertedMssEvent = midiHandler.ConvertVstMidiEventToMssEventWrapper(
                    midiEvent, sampleTimeAtStartOfCycle, this.hostInfoOutputPort.SampleRate);
                Assert.AreEqual(mssEvent, convertedMssEvent);
            }
            else
            {
                VstMidiEvent ConvertedMidiEvent = midiHandler.ConvertMssEventToVstMidiEventWrapper(
                    mssEvent, sampleTimeAtStartOfCycle, this.hostInfoOutputPort.SampleRate);
                Assert.AreEqual(midiEvent.Data, ConvertedMidiEvent.Data);
                Assert.AreEqual(midiEvent.DeltaFrames, ConvertedMidiEvent.DeltaFrames);
            }
        }
 public VstMidiEvent ConvertMssEventToVstMidiEventWrapper(MssEvent mssEvent,
     long processingCycleStartTime,
     double sampleRate)
 {
     return ConvertMssEventToVstMidiEvent(mssEvent, processingCycleStartTime, sampleRate);
 }
Пример #16
0
        public override bool Equals(object o)
        {
            MssEvent compareToEvent = (MssEvent)o;

            return(this.mssMsg.Equals(compareToEvent.mssMsg) && this.sampleTime == compareToEvent.sampleTime);
        }
        protected void ParameterValueChanged(MssParameterID paramId, double newValue)
        {
            lock (MssComponentHub.criticalSectioinLock)
            {
                if (this.hostInfoOutput.SampleRateIsInitialized == false)
                {
                    return;
                }

                long watchOffestAtParamChanged = this.stopwatch.Elapsed.Ticks;

                MssParamInfo paramInfo = this.mssParameters.GetParameterInfoCopy(paramId);
                double relValue = CustomMathUtils.AbsToRelVal(paramInfo.MinValue, paramInfo.MaxValue, newValue);

                MssMsg paramMsg = new MssMsg(MssMsgType.Parameter,
                                             (int)paramId,
                                             MssMsgUtil.UNUSED_MSS_MSG_DATA,
                                             relValue);
                MssEvent paramEvent = new MssEvent();

                paramEvent.mssMsg = paramMsg;

                long ticksSinceCycleEnd = watchOffestAtParamChanged - this.watchOffestAtLastCycleEnd;
                double secondsSinceCycleEnd = ticksSinceCycleEnd / (double)TimeSpan.TicksPerSecond;
                long samplesSinceCycleEnd = (long)Math.Round(secondsSinceCycleEnd * this.hostInfoOutput.SampleRate);

                //Sometimes the stopwatch may not be accurate enough to notice the difference
                //between the end of the last cycle and now. Setting samplesSinceCycleEnd to
                //1 will cause this event to happen at the very start of this processing cycle.
                if (samplesSinceCycleEnd == 0)
                {
                    samplesSinceCycleEnd = 1;
                }

                paramEvent.sampleTime = this.sampleTimeAtLastCycleEnd + samplesSinceCycleEnd;

                this.dryEventInput.ReceiveDryMssEvent(paramEvent);
            }
        }
Пример #18
0
        /// <summary>
        ///     Attempts to create an MssEvent representation of <paramref name="midiEvent"/>.
        /// </summary>
        /// <returns>The MssEvent representation of midiEvent or null of there is no valid conversion.</returns>
        protected static MssEvent ConvertVstMidiEventToMssEvent(VstMidiEvent midiEvent, 
            long sampleTimeAtStartOfProcessingCycle,
            double sampleRate)
        {
            MssEvent mssEvent = new MssEvent();

            //Sets the sample time for mssEvent.
            mssEvent.sampleTime = sampleTimeAtStartOfProcessingCycle + midiEvent.DeltaFrames;

            MssMsgType msgType = MidiUtil.GetMssTypeFromMidiData(midiEvent.Data);
            mssEvent.mssMsg.Type = msgType;

            //If msgType is "Unsupported" then midiEvent cannot be represented as an MssEvent
            if (msgType == MssMsgType.Unsupported)
            {
                return null;
            }

            //Sets mssEvent's Data1 (midi channel).
            //Adds one because channels in an MssMsg start at 1 but channels in a VstMidiEvent start at 0
            mssEvent.mssMsg.Data1 = (midiEvent.Data[0] & 0x0F) + 1;

            //Sets mssEvent's Data2 and Data3 (the midi message's data bytes).
            if (msgType == MssMsgType.PitchBend)
            {
                //The two data bytes for pitch bend are used to store one 14-bit number so this number is stored in
                //mssEvent.Data3 and mssEvent.Data2 is not used.
                mssEvent.mssMsg.Data2 = MssMsgUtil.UNUSED_MSS_MSG_DATA;

                //data1 contains the least significant 7 bits of the pitch bend value and data2 contains the most
                //significant 7 bits
                mssEvent.mssMsg.Data3 = (midiEvent.Data[2] << 7) + midiEvent.Data[1];
            }
            else if (msgType == MssMsgType.ChanAftertouch)
            {
                mssEvent.mssMsg.Data2 = MssMsgUtil.UNUSED_MSS_MSG_DATA;
                mssEvent.mssMsg.Data3 = midiEvent.Data[1];
            }
            else
            {
                mssEvent.mssMsg.Data2 = midiEvent.Data[1];
                mssEvent.mssMsg.Data3 = midiEvent.Data[2];
            }

            return mssEvent;
        }
Пример #19
0
        /// <summary>
        ///     Attempts to create a VstMidiEvent representation of <paramref name="mssEvent"/>.
        /// </summary>
        /// <returns>The VstMidiEvent representation of mssEvent or null of there is no valid conversion.</returns>
        protected static VstMidiEvent ConvertMssEventToVstMidiEvent(MssEvent mssEvent,
            long sampleTimeAtStartOfProcessingCycle,
            double sampleRate)
        {
            Debug.Assert(mssEvent.sampleTime >= sampleTimeAtStartOfProcessingCycle);

            //Calculate delta frames
            int deltaFrames = (int)(mssEvent.sampleTime - sampleTimeAtStartOfProcessingCycle);

            byte[] midiData = new byte[3];

            //Get status half of first byte.
            byte statusByte;

            if (MidiUtil.GetStatusFromMssMsgType(mssEvent.mssMsg.Type, out statusByte) == false)
            {
                return null;
            }

            //subtract 1 becasue channels are 0 based in midi but 1 based in mss
            byte channelByte = (byte)(mssEvent.mssMsg.Data1AsInt - 1);

            midiData[0] = (byte) (statusByte | channelByte);

            if (mssEvent.mssMsg.Type == MssMsgType.PitchBend) {
                //most significant bits
                int MsbVal = (mssEvent.mssMsg.Data3AsInt) >> 7;
                midiData[2] = (byte)MsbVal;
                midiData[1] = (byte)((mssEvent.mssMsg.Data3AsInt) - (MsbVal << 7));
            }
            else if (mssEvent.mssMsg.Type == MssMsgType.ChanAftertouch)
            {
                midiData[1] = (byte)mssEvent.mssMsg.Data3AsInt;
                midiData[2] = 0;
            }
            else
            {
                midiData[1] = (byte)mssEvent.mssMsg.Data2AsInt;
                midiData[2] = (byte)mssEvent.mssMsg.Data3AsInt;
            }
            VstMidiEvent midiEvent = new VstMidiEvent(deltaFrames, 0, 0, midiData, 0, 0);

            return midiEvent;
        }