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