private void SetParameterEnv(ModuleId module, int parameter, object value) { var env = (Ahdsr)Modules[module]; var para = (EnvParams)parameter; double val = Convert.ToDouble(value); if (para != EnvParams.Sustain) // 2ms - 20sec range { val = ValueTables.Get(val, ValueTables.Response4Dec) * 20000; } switch (para) { case EnvParams.Attack: env.SetParameter(Ahdsr.StageAttack, val); break; case EnvParams.Hold: env.SetParameter(Ahdsr.StageHold, val); break; case EnvParams.Decay: env.SetParameter(Ahdsr.StageDecay, val); break; case EnvParams.Sustain: env.SetParameter(Ahdsr.StageSustain, val); break; case EnvParams.Release: env.SetParameter(Ahdsr.StageRelease, val); break; } }
public void SetParam(int param, double value) { ParameterInfo[param].Value = value; string str = $"{value:0.00}"; if (param == P_GAIN) { gain = ValueTables.Get(value, ValueTables.Pow2) * 300; str = $"{gain:0.0}x"; } if (param == P_FEEDBACK) { feedback = value; } if (param == P_BIAS) { bias = value; } if (param == P_CUTOFF) { cutoff = ValueTables.Get(value, ValueTables.Pow2) * 2000; str = $"{cutoff:0.0}hz"; } ParameterInfo[param].Display = str; UpdateAll(); }
private void UpdateCoefficients() { var cutoffAVal = cutoffKnob + cutoffModulation + cutoffModulationEnv; if (cutoffAVal > 1) { cutoffAVal = 1; } else if (cutoffAVal < 0) { cutoffAVal = 0; } var cutoffBVal = cutoffKnob + cutoffModulation + cutoffModulationEnv + cutoffOffset; if (cutoffBVal > 1) { cutoffBVal = 1; } else if (cutoffBVal < 0) { cutoffBVal = 0; } var resoA = resonanceKnob + resonanceModulation; if (resoA > 1) { resoA = 1; } else if (resoA < 0.01) { resoA = 0.01; } var resoB = resonanceKnob + resonanceModulation + resonanceOffset; if (resoB > 1) { resoB = 1; } else if (resoB < 0.01) { resoB = 0.01; } var cutoffA = 10 + ValueTables.Get(cutoffAVal, ValueTables.Response3Dec) * 21000; var cutoffB = 10 + ValueTables.Get(cutoffBVal, ValueTables.Response3Dec) * 21000; filterA.Fc = cutoffA; filterB.Fc = cutoffB; filterA.Q = 0.5 + (ValueTables.Get(resoA, ValueTables.Response2Oct) - 0.25) * 10; filterB.Q = 0.5 + (ValueTables.Get(resoB, ValueTables.Response2Oct) - 0.25) * 10; filterA.Update(); filterB.Update(); coefficientsDirty = false; }
public override void Process() { var gain = Utils.DB2gain(-30 + 48 * Parameters[0]); var volume = Utils.DB2gain(-60 + 66 * Parameters[1]); var decay = (1 - ValueTables.Get(1 - Parameters[2], ValueTables.Response3Oct)) * 1.14; var basePitch = 60 + (int)((Parameters[3] - 0.5) * 24.01); var p1 = basePitch; var p2 = basePitch + (int)((Parameters[4] - 0.5) * 24.01); var p3 = basePitch + (int)((Parameters[5] - 0.5) * 24.01); var p4 = basePitch + (int)((Parameters[6] - 0.5) * 24.01); var p5 = basePitch + (int)((Parameters[7] - 0.5) * 24.01); var vol1 = Utils.DB2gain(-30 + 36 * Parameters[8]); var vol2 = Utils.DB2gain(-30 + 36 * Parameters[9]); var vol3 = Utils.DB2gain(-30 + 36 * Parameters[10]); var vol4 = Utils.DB2gain(-30 + 36 * Parameters[11]); var vol5 = Utils.DB2gain(-30 + 36 * Parameters[12]); var wet = Parameters[13]; var dry = 1 - wet; var cutoff = ValueTables.Get(Parameters[14], ValueTables.Response4Dec) * 22000; var mode = Parameters[15] < 0.5; var delay1 = GetSamplesPerNote(p1); var delay2 = GetSamplesPerNote(p2); var delay3 = GetSamplesPerNote(p3); var delay4 = GetSamplesPerNote(p4); var delay5 = GetSamplesPerNote(p5); Filter.Frequency = cutoff; Filter.Q = 0.7; Filter.Type = mode ? Biquad.FilterType.LowPass : Biquad.FilterType.HighPass; Filter.Update(); for (int i = 0; i < Inputs[0].Length; i++) { var input = Filter.Process(Inputs[0][i]) * gain; var d1 = Buf1.Read(-delay1) * decay; var d2 = Buf2.Read(-delay2) * decay; var d3 = Buf3.Read(-delay3) * decay; var d4 = Buf4.Read(-delay4) * decay; var d5 = Buf5.Read(-delay5) * decay; var signal = d1 * vol1 + d2 * vol2 + d3 * vol3 + d4 * vol4 + d5 * vol5; Outputs[0][i] = (dry * Inputs[0][i] + wet * signal * 0.2) * volume; Outputs[1][i] = Outputs[0][i]; Buf1.Write(Math.Tanh(input + d1)); Buf2.Write(Math.Tanh(input + d2)); Buf3.Write(Math.Tanh(input + d3)); Buf4.Write(Math.Tanh(input + d4)); Buf5.Write(Math.Tanh(input + d5)); } }
private void SetParameter(int index, double value) { if (index == P_TYPE) { FilterType = (int)(value * 6.99); BiquadL.Type = (Biquad.FilterType)FilterType; BiquadR.Type = (Biquad.FilterType)FilterType; ParameterInfo[index].Display = BiquadL.Type.ToString(); } else if (index == P_FREQ) { Frequency = ValueTables.Get(value, ValueTables.Response3Dec) * 22000; BiquadL.Frequency = Frequency; BiquadR.Frequency = Frequency; ParameterInfo[index].Display = String.Format("{0:0.00}", Frequency); } else if (index == P_SLOPE) { Slope = value; BiquadL.Slope = Slope; BiquadR.Slope = Slope; ParameterInfo[index].Display = String.Format("{0:0.00}", Slope); } else if (index == P_Q) { if (value < 0.5) { Q = 0.1 + 0.9 * 2 * value; } else { Q = 1 + (value - 0.5) * 12; } BiquadL.Q = Q; BiquadR.Q = Q; ParameterInfo[index].Display = String.Format("{0:0.00}", Q); } else if (index == P_GAIN) { GainDB = (2 * value - 1) * 20; BiquadL.GainDB = GainDB; BiquadR.GainDB = GainDB; ParameterInfo[index].Display = String.Format("{0:0.0}", GainDB); } ParameterInfo[index].Value = value; BiquadL.Update(); BiquadR.Update(); }
private void SetParameterModulator(ModuleId module, int parameter, object value) { var mod = (Modulator)Modules[module]; var para = (ModulatorParams)parameter; if (para == ModulatorParams.Attack || para == ModulatorParams.Hold || para == ModulatorParams.Decay || para == ModulatorParams.Release || para == ModulatorParams.Delay) // 2ms - 20sec range { value = ValueTables.Get((double)value, ValueTables.Response4Dec) * 20000; } mod.SetParameter(para, value); mod.UpdateStepsize(); }
public void SetParam(int param, double value) { ParameterInfo[param].Value = value; string str = $"{value:0.00}"; if (param == P_MIX) { GrainDelay.Config.Mix = value; str = $"{GrainDelay.Config.Mix*100:0.0}%"; } else if (param == P_COUNT) { GrainDelay.Config.ActiveGrains = 1 + (int)(value * (GrainDelay.MaxGrains - 0.01)); str = $"{GrainDelay.Config.ActiveGrains:0}"; } else if (param == P_PREDELAY) { var seconds = ValueTables.Get(value, ValueTables.Response2Dec) * 0.2; GrainDelay.Config.PreDelay = seconds * Samplerate; str = $"{seconds*1000:0}ms"; } else if (param == P_DELAY) { var seconds = ValueTables.Get(value, ValueTables.Response2Dec) * 0.5; GrainDelay.Config.Delay = seconds * Samplerate; str = $"{seconds * 1000:0}ms"; } else if (param == P_DELAY_SCATTER) { var scatter = 1 + value * 9; GrainDelay.Config.DelayScatter = scatter; str = $"{scatter:0.00}x"; } else if (param == P_PITCH_SCATTER) { var scatter = value; GrainDelay.Config.PitchScatter = scatter; str = $"{scatter:0.00}x"; } else if (param == P_SEED) { var seed = (int)(value * 1000); GrainDelay.Config.Seed = seed; str = $"{seed:0}"; } GrainDelay.Config.Length = 0.2 * Samplerate; GrainDelay.Config.LengthScatter = 3.0; GrainDelay.Configure(); ParameterInfo[param].Display = str; }
private void UpdateCoefficients() { var value = cutoffKnob + cutoffModulation + cutoffModulationEnv; if (value > 1) { value = 1; } else if (value < 0) { value = 0; } var cutoff = 10 + ValueTables.Get(value, ValueTables.Response3Dec) * 21000; p = (1 - 2 * cutoff * fsinv) * (1 - 2 * cutoff * fsinv); coefficientsDirty = false; }
public static string FormatEnvelope(double val) { var value = ValueTables.Get(val, ValueTables.Response4Dec) * 20000; if (value < 10) { return(String.Format(CultureInfo.InvariantCulture, "{0:0.00} ms", value)); } else if (value < 100) { return(String.Format(CultureInfo.InvariantCulture, "{0:0.0} ms", value)); } else if (value < 1000) { return(String.Format(CultureInfo.InvariantCulture, "{0:0} ms", value)); } else { return(String.Format(CultureInfo.InvariantCulture, "{0:0.00} sec", value * 0.001)); } }
//double[] Sinc; public override void Process() { Note note = new Note(0, 0); if (Notes.Count == 0) { for (int i = 0; i < Inputs[0].Length; i++) { Outputs[0][i] = 0; Outputs[1][i] = 0; } return; } note = Notes[Notes.Count - 1]; Increment = CalculateIncrement(note.Pitch); var f = Parameters[0]; try { for (int i = 0; i < Inputs[0].Length; i++) { var lookup = (1 - f) * Pos + f * ValueTables.Get(Pos / Wave.Length, ValueTables.Pow3) * Wave.Length; var sample = LinInterp(Wave, lookup); Pos += Increment; if (Pos >= Wave.Length) { Pos -= Wave.Length; } Outputs[0][i] = sample * note.Velocity * 0.007874; Outputs[1][i] = sample * note.Velocity * 0.007874; } } catch (Exception) { } }
public void Configure() { rand = new Random(Config.Seed); for (int grainId = 0; grainId < Config.ActiveGrains; grainId++) { double len = (int)Random(Config.Length, Config.Length * Config.LengthScatter); var pitchScatter = 0.05 * ValueTables.Get(Config.PitchScatter, ValueTables.Pow2); var delay = Random(Config.Delay, Config.Delay * Config.DelayScatter); var gain = Math.Pow(1.6, -delay / Config.Delay); DelaySamples[grainId] = Config.PreDelay + delay; IncrementOffset[grainId] = Random(-pitchScatter, pitchScatter); Gain[grainId] = gain; // prevent reading the future by increasing the delay for heavily positively modulated grains if (IncrementOffset[grainId] * LenSamples[grainId] > DelaySamples[grainId]) { DelaySamples[grainId] = IncrementOffset[grainId] * LenSamples[grainId] + 5; } if (grainId % 2 == 0) { LenSamples[grainId] = len; PhaseSamples[grainId] = (grainId / (double)Config.ActiveGrains) * LenSamples[grainId]; InputPan[grainId] = rand.Next(0, 2); OutputPan[grainId] = rand.Next(0, 2); } else { len = LenSamples[grainId - 1]; LenSamples[grainId] = len; PhaseSamples[grainId] = (PhaseSamples[grainId - 1] + len / 2) % len; InputPan[grainId] = InputPan[grainId - 1]; OutputPan[grainId] = OutputPan[grainId - 1]; } } }
public void AddValueTable(string name, Dictionary <uint, string> valTblDess) { ValueTables.Add(name, valTblDess); }
/// <summary> /// warps the 0...1 parameter range into a meaningful value /// </summary> /// <param name="param"></param> /// <returns></returns> public double GetScaledParameter(Parameter param) { switch (param) { // Input case Parameter.InputMix: return(P(Parameter.InputMix)); case Parameter.PreDelay: return((int)(P(Parameter.PreDelay) * 500)); case Parameter.HighPass: return(20 + ValueTables.Get(P(Parameter.HighPass), ValueTables.Response4Oct) * 980); case Parameter.LowPass: return(400 + ValueTables.Get(P(Parameter.LowPass), ValueTables.Response4Oct) * 19600); // Early case Parameter.TapCount: return(1 + (int)(P(Parameter.TapCount) * 49.0)); case Parameter.TapLength: return((int)(P(Parameter.TapLength) * 500)); case Parameter.TapGain: return(ValueTables.Get(P(Parameter.TapGain), ValueTables.Response2Dec)); case Parameter.TapDecay: return(P(Parameter.TapDecay)); case Parameter.DiffusionEnabled: return(P(Parameter.DiffusionEnabled)); case Parameter.DiffusionStages: return(1 + (int)(P(Parameter.DiffusionStages) * (AllpassDiffuser.MaxStageCount - 0.001))); case Parameter.DiffusionDelay: return((int)(P(Parameter.DiffusionDelay) * 50)); case Parameter.DiffusionFeedback: return(P(Parameter.DiffusionFeedback)); // Late case Parameter.LineCount: return(1 + (int)(P(Parameter.LineCount) * 11.999)); case Parameter.LineDelay: return((int)(P(Parameter.LineDelay) * 500)); case Parameter.LineDecay: return(P(Parameter.LineDecay)); case Parameter.LateDiffusionEnabled: return(P(Parameter.LateDiffusionEnabled)); case Parameter.LateDiffusionStages: return(1 + (int)(P(Parameter.LateDiffusionStages) * (AllpassDiffuser.MaxStageCount - 0.001))); case Parameter.LateDiffusionDelay: return((int)(P(Parameter.LateDiffusionDelay) * 50)); case Parameter.LateDiffusionFeedback: return(P(Parameter.LateDiffusionFeedback)); // Frequency Response case Parameter.PostLowShelfGain: return(ValueTables.Get(P(Parameter.PostLowShelfGain), ValueTables.Response2Dec)); case Parameter.PostLowShelfFrequency: return(20 + ValueTables.Get(P(Parameter.PostLowShelfFrequency), ValueTables.Response4Oct) * 980); case Parameter.PostHighShelfGain: return(ValueTables.Get(P(Parameter.PostHighShelfGain), ValueTables.Response2Dec)); case Parameter.PostHighShelfFrequency: return(400 + ValueTables.Get(P(Parameter.PostHighShelfFrequency), ValueTables.Response4Oct) * 19600); case Parameter.PostCutoffFrequency: return(400 + ValueTables.Get(P(Parameter.PostCutoffFrequency), ValueTables.Response4Oct) * 19600); // Modulation case Parameter.EarlyDiffusionModAmount: return(P(Parameter.EarlyDiffusionModAmount) * 2.5); case Parameter.EarlyDiffusionModRate: return(ValueTables.Get(P(Parameter.EarlyDiffusionModRate), ValueTables.Response2Dec) * 5); case Parameter.LineModAmount: return(P(Parameter.LineModAmount) * 2.5); case Parameter.LineModRate: return(ValueTables.Get(P(Parameter.LineModRate), ValueTables.Response2Dec) * 5); case Parameter.LateDiffusionModAmount: return(P(Parameter.LateDiffusionModAmount) * 2.5); case Parameter.LateDiffusionModRate: return(ValueTables.Get(P(Parameter.LateDiffusionModRate), ValueTables.Response2Dec) * 5); // Seeds case Parameter.TapSeed: return((int)(P(Parameter.TapSeed) * 1000000)); case Parameter.DiffusionSeed: return((int)(P(Parameter.DiffusionSeed) * 1000000)); case Parameter.DelaySeed: return((int)(P(Parameter.DelaySeed) * 1000000)); case Parameter.PostDiffusionSeed: return((int)(P(Parameter.PostDiffusionSeed) * 1000000)); // Output case Parameter.CrossSeed: return(P(Parameter.CrossSeed)); case Parameter.DryOut: return(ValueTables.Get(P(Parameter.DryOut), ValueTables.Response2Dec)); case Parameter.PredelayOut: return(ValueTables.Get(P(Parameter.PredelayOut), ValueTables.Response2Dec)); case Parameter.EarlyOut: return(ValueTables.Get(P(Parameter.EarlyOut), ValueTables.Response2Dec)); case Parameter.MainOut: return(ValueTables.Get(P(Parameter.MainOut), ValueTables.Response2Dec)); // Switches case Parameter.HiPassEnabled: return(P(Parameter.HiPassEnabled)); case Parameter.LowPassEnabled: return(P(Parameter.LowPassEnabled)); case Parameter.LowShelfEnabled: return(P(Parameter.LowShelfEnabled)); case Parameter.HighShelfEnabled: return(P(Parameter.HighShelfEnabled)); case Parameter.CutoffEnabled: return(P(Parameter.CutoffEnabled)); default: return(0.0); } }
private static string FreqFormatter(double val) { var value = ValueTables.Get(val, ValueTables.Response3Dec) * 50; return(String.Format(CultureInfo.InvariantCulture, "{0:0.00} Hz", value)); }