public bool RemoveStream(IAnalyticStream stream)
{
bool success = streams.Remove(stream);
UpdateStats();
return(success);
}
public static IAnalyticStream Center(
this IAnalyticStream stream,
int preDelaySamples,
int postDelaySamples)
{
return(new AnalyticStreamCenterer(stream, preDelaySamples, postDelaySamples));
}
/// <summary> Slowest Backup Alternative for calculating RMS </summary>
public static double CalculateRMS(this IAnalyticStream stream)
{
if (stream.Samples == 0)
{
return(0.0);
}
if (stream.Samples == int.MaxValue)
{
return(double.NaN);
}
double rms = 0.0;
int readSamples;
const int BUFFER_SIZE = 512;
Complex64[] buffer = new Complex64[BUFFER_SIZE];
stream.Reset();
do
{
readSamples = stream.Read(buffer, 0, BUFFER_SIZE);
for (int i = 0; i < readSamples; i++)
{
rms += buffer[i].Real * buffer[i].Real;
}
}while (readSamples > 0);
stream.Reset();
return(Math.Sqrt(rms / stream.Samples));
}
/// <summary>Returns the AnalyticStream augmented with a FrequencyModulationFilter</summary>
public static IAnalyticStream FrequencyModulation(
this IAnalyticStream stream,
double modulationRate,
double modulationDepth)
{
return(new AnalyticFrequencyModulationFilter(stream, modulationRate, modulationDepth));
}
public AnalyticADSREnvelope(
IAnalyticStream stream,
double timeToPeak,
double timeToSustain,
double sustainAmplitude,
double sustainDecayTime,
double releaseDecayTime)
: base(stream)
{
this.sustainAmplitude = sustainAmplitude;
sustainDecaySamples = (int)(SamplingRate * sustainDecayTime);
releaseDecaySamples = (int)(SamplingRate * releaseDecayTime);
attackUpSamples = (int)(SamplingRate * timeToPeak);
attackUpEndSample = attackUpSamples;
attackDownSamples = (int)(SamplingRate * timeToSustain);
attackDownEndSample = attackUpEndSample + attackDownSamples;
sustainEndSample = int.MaxValue;
attackUpGrowthRate = Math.Pow(1.0 / ENVELOPE_CUTOFF, 1.0 / attackUpSamples);
attackDownDecayRate = Math.Pow(sustainAmplitude, 1.0 / attackDownSamples);
sustainDecayRate = Math.Exp(-1.0 / sustainDecaySamples);
releaseDecayRate = Math.Exp(-1.0 / releaseDecaySamples);
immediateDecayRate = Math.Pow(ENVELOPE_CUTOFF, 1 / (SamplingRate * 0.01));
//Start at a small envelope for exponential growth
currentEnvelope = ENVELOPE_CUTOFF;
envelopeState = EnvelopeState.AttackUp;
}
public AnalyticStreamFrequencyShifter(
IAnalyticStream stream,
double frequencyShift)
: base(stream)
{
this.frequencyShift = frequencyShift;
double sampleCount = SamplingRate / this.frequencyShift;
int intSampleCount = (int)Ceiling(sampleCount) - 1;
cyclePartial = (2 * PI * this.frequencyShift / SamplingRate) * (intSampleCount - sampleCount);
cycles = 0;
partial = Complex64.FromPolarCoordinates(
magnitude: 1.0,
phase: cycles * cyclePartial);
shifterSamples = new Complex64[intSampleCount];
for (int i = 0; i < shifterSamples.Length; i++)
{
shifterSamples[i] = Complex64.FromPolarCoordinates(
magnitude: 1.0,
phase: 2 * PI * i / sampleCount);
}
}
public static IAnalyticStream Window(
this IAnalyticStream stream,
Windowing.Function function = Windowing.Function.Hamming,
int smoothingSamples = 1000)
{
return(new AnalyticStreamWindower(stream, function,
smoothingSamples: smoothingSamples));
}
public AnalyticStreamCenterer(IAnalyticStream stream, int preDelaySamples, int postDelaySamples)
: base(stream)
{
this.postDelaySamples = postDelaySamples;
this.preDelaySamples = preDelaySamples;
postDelayStart = preDelaySamples + stream.Samples;
totalSamples = postDelayStart + postDelaySamples;
}
public static IAnalyticStream Add(
this IAnalyticStream stream,
params IAnalyticStream[] others)
{
AnalyticStreamAdder adder = new AnalyticStreamAdder(stream);
adder.AddStreams(others);
return(adder);
}
public AnalyticStreamCenterer(IAnalyticStream stream, double totalDuration)
: base(stream)
{
totalSamples = (int)Math.Ceiling(totalDuration * SamplingRate);
int delaySamples = totalSamples - stream.Samples;
postDelaySamples = delaySamples / 2;
preDelaySamples = delaySamples - postDelaySamples;
postDelayStart = preDelaySamples + stream.Samples;
}
public static IAnalyticStream ADSR(
this IAnalyticStream stream,
double timeToPeak,
double timeToSustain,
double sustainAmplitude,
double sustainDecayTime)
{
return(new AnalyticADSREnvelope(
stream: stream,
timeToPeak: timeToPeak,
timeToSustain: timeToSustain,
sustainAmplitude: sustainAmplitude,
sustainDecayTime: sustainDecayTime,
releaseDecayTime: sustainDecayTime));
}
public AnalyticFrequencyModulationFilter(
IAnalyticStream stream,
double modRate,
double modDepth)
: base(stream)
{
modulatorPeriodSamples = (int)Abs(Round(SamplingRate / modRate));
modRate = Sign(modRate) * SamplingRate / modulatorPeriodSamples;
modulator = new Complex64[modulatorPeriodSamples];
for (int i = 0; i < modulatorPeriodSamples; i++)
{
modulator[i] = Complex64.FromPolarCoordinates(
magnitude: 1.0,
phase: (modDepth / modRate) * Sin(2.0 * PI * i / modulatorPeriodSamples));
}
}
public AnalyticStreamWindower(
IAnalyticStream stream,
Windowing.Function function,
double totalDuration = double.NaN,
int smoothingSamples = 1000,
int sampleOffset = 0,
TransformRMSBehavior rmsBehavior = TransformRMSBehavior.Passthrough)
: base(stream)
{
if (sampleOffset > stream.Samples)
{
Debug.LogError("Requested a sampleOffset larger than clip length");
sampleOffset = 0;
}
this.sampleOffset = sampleOffset;
if (!double.IsNaN(totalDuration))
{
Samples = Math.Min(
(int)(totalDuration * SamplingRate),
stream.Samples - sampleOffset);
}
else
{
Samples = stream.Samples - sampleOffset;
}
this.rmsBehavior = rmsBehavior;
smoothingSamples = Math.Min(smoothingSamples, Samples / 2);
window = Windowing.GetHalfWindow64(function, smoothingSamples);
endOpeningWindow = smoothingSamples;
startClosingWindow = Samples - smoothingSamples;
Reset();
}
/// <summary>Returns the AnalyticStream augmented with an BGCStreamConverter</summary> public static IBGCStream ToBGCStream(this IAnalyticStream stream) => new BGCStreamConverter(stream);
public static IAnalyticStream Fork(
this IAnalyticStream stream,
out IAnalyticStream forkedStream)
{
return(new AnalyticStreamFork(stream, out forkedStream));
}
public static IAnalyticStream Add(
this IAnalyticStream stream,
IAnalyticStream other)
{
return(new AnalyticStreamAdder(stream, other));
}
public SimpleAnalyticFilter(IAnalyticStream stream)
{
this.stream = stream;
}
public static IAnalyticStream FrequencyShift(
this IAnalyticStream stream,
double frequencyShift)
{
return(new AnalyticStreamFrequencyShifter(stream, frequencyShift));
}
public BGCStreamConverter(IAnalyticStream stream)
{
this.stream = stream;
}
/// <summary>Returns the BGCStream equivalent of the AnalyticStream's Envelope</summary> public static IBGCStream ToEnvelopeStream(this IAnalyticStream stream) => new AnalyticStreamEnvelopeConverter(stream);
/// <summary>
/// Returns an AnalyticStream at least <paramref name="minimumDuration"/> in duration, with the clip
/// centered in it
/// </summary>
public static IAnalyticStream Center(
this IAnalyticStream stream,
double minimumDuration = 0.0)
{
return(new AnalyticStreamCenterer(stream, Math.Max(stream.Duration(), minimumDuration)));
}
public void AddStream(IAnalyticStream stream)
{
streams.Add(stream);
UpdateStats();
}
public AnalyticStreamFork(IAnalyticStream stream, out IAnalyticStream forkedStream)
: base(stream)
{
this.forkedStream = new InternalStreamFork(this);
forkedStream = this.forkedStream;
}
public AnalyticStreamEnvelopeConverter(IAnalyticStream stream)
{
this.stream = stream;
}
/// <summary> Calculates the effective Duration of the AnalyticStream </summary> public static double Duration(this IAnalyticStream stream) => stream.Samples / stream.SamplingRate;
public AnalyticStreamFork(IAnalyticStream stream)
: base(stream)
{
forkedStream = new InternalStreamFork(this);
}
