public void TestNoiseVocodedSpeech()
{
Calibration.Initialize();
string speechFile = DataManagement.PathForDataFile("Test", "000000.wav");
if (!File.Exists(speechFile))
{
throw new Exception($"Test utilizes CRM missing sentence: {speechFile}");
}
WaveEncoding.LoadBGCStream(
filepath: speechFile,
stream: out IBGCStream speechStream);
bool success = WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", "06BandVocoding.wav"),
stream: speechStream.NoiseVocode(bandCount: 6).Cache().SlowRangeFitter(),
overwrite: true);
success |= WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", "11BandVocoding.wav"),
stream: speechStream.NoiseVocode(bandCount: 11).Cache().SlowRangeFitter(),
overwrite: true);
success |= WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", "22BandVocoding.wav"),
stream: speechStream.NoiseVocode(bandCount: 22).Cache().SlowRangeFitter(),
overwrite: true);
Assert.IsTrue(success);
}
public void TestHiHat()
{
string closedFile = DataManagement.PathForDataFile("Test", "ClosedHiHat.wav");
Assert.IsTrue(WaveEncoding.SaveStream(
filepath: closedFile,
stream: InstrumentLookup.GetPercussion(PercussionMap.ClosedHiHat, 0xF7)
.SafeCache()
.SlowRangeFitter(),
overwrite: true));
string pedalFile = DataManagement.PathForDataFile("Test", "PedalHiHat.wav");
Assert.IsTrue(WaveEncoding.SaveStream(
filepath: pedalFile,
stream: InstrumentLookup.GetPercussion(PercussionMap.PedalHiHat, 0xF7)
.SafeCache()
.SlowRangeFitter(),
overwrite: true));
string openFile = DataManagement.PathForDataFile("Test", "OpenHiHat.wav");
Assert.IsTrue(WaveEncoding.SaveStream(
filepath: openFile,
stream: InstrumentLookup.GetPercussion(PercussionMap.OpenHiHat, 0xF7)
.SafeCache()
.SlowRangeFitter(),
overwrite: true));
}
public void TestSnare()
{
string saveFile = DataManagement.PathForDataFile("Test", "SnareTest.wav");
Assert.IsTrue(WaveEncoding.SaveStream(
filepath: saveFile,
stream: InstrumentLookup.GetPercussion(PercussionMap.AcousticSnare, 0xF7)
.Normalize(80f)
.Window(1f)
.Center(1.5f),
overwrite: true));
}
public void TestNewSpatialization()
{
string baseFile = "000000";
WaveEncoding.LoadBGCStream(
filepath: DataManagement.PathForDataFile("Test", $"{baseFile}.wav"),
stream: out IBGCStream stream);
Debug.Log($"Pre RMS: {string.Join(", ", stream.CalculateRMS().Select(x => x.ToString()).ToArray())}");
{
IBGCStream spatialized = stream.Spatialize(0f);
string rms = string.Join(", ", spatialized.CalculateRMS().Select(x => x.ToString()).ToArray());
Debug.Log($"Post RMS: {rms}");
//Write to File
WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", $"{baseFile}_Spatialized_0.wav"),
stream: spatialized,
overwrite: true);
}
{
IBGCStream spatialized = stream.Spatialize(25f);
string rms = string.Join(", ", spatialized.CalculateRMS().Select(x => x.ToString()).ToArray());
Debug.Log($"Post RMS: {rms}");
//Write to File
WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", $"{baseFile}_Spatialized_25.wav"),
stream: spatialized,
overwrite: true);
}
{
IBGCStream spatialized = stream.Spatialize(-25f);
string rms = string.Join(", ", spatialized.CalculateRMS().Select(x => x.ToString()).ToArray());
Debug.Log($"Post RMS: {rms}");
//Write to File
WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", $"{baseFile}_Spatialized_n25.wav"),
stream: spatialized,
overwrite: true);
}
}
public void TestCarrierModifiedFakeVoices()
{
Calibration.Initialize();
// F2: 500
// F3: 1000
// F4: 2000
double qFactor = 200;
Func <IBGCStream> makeCarrierA = () =>
new AnalyticNoiseStream(
rms: 1.0,
freqLB: 20,
freqUB: 10000,
frequencyCount: 10000,
distribution: AnalyticNoiseStream.AmplitudeDistribution.Brown)
.ToBGCStream();
Func <IBGCStream> makeCarrierB = () =>
new SawtoothWave(
amplitude: 1.0,
frequency: 120);
Func <IBGCStream>[] carrierFuncs = new Func <IBGCStream>[]
{
makeCarrierA,
makeCarrierB
};
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 2; j++)
{
WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", $"testVoice{i}{j}.wav"),
stream: new StreamAdder(
carrierFuncs[i]()
.BiQuadBandpassFilter(
centralFrequency: 500,
qFactor: qFactor),
carrierFuncs[j]()
.BiQuadBandpassFilter(
centralFrequency: 1500,
qFactor: qFactor))
.Window(0.5)
.SlowRangeFitter(),
overwrite: true);
}
}
}
public void TestTriangleWave()
{
Calibration.Initialize();
IBGCStream stream =
new TriangleWave(1f, 440f)
.Window(DURATION)
.Normalize(LEVEL);
bool success = WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", "triangleWave.wav"),
stream: stream,
overwrite: true);
Assert.IsTrue(success);
}
public void UpScalingTest()
{
float[] singleChannelSamples = CreateSineWave(1, 22050f);
string upscaledFile = DataManagement.PathForDataFile("Test", "upscaled.wav");
IBGCStream stream = new SimpleAudioClip(
samples: LinearInterpolation.FactorUpscaler(
samples: singleChannelSamples,
factor: 2,
channels: 1),
channels: 1);
Assert.IsTrue(WaveEncoding.SaveStream(
filepath: upscaledFile,
stream: stream,
overwrite: true));
}
public void TestPulses()
{
Calibration.Initialize();
double[] dutyCycles = new double[] { 0.1, 0.25, 0.5, 0.75, 0.9 };
foreach (double dutyCycle in dutyCycles)
{
string saveFile = DataManagement.PathForDataFile("Test", $"squareWave({dutyCycle}).wav");
Assert.IsTrue(WaveEncoding.SaveStream(
filepath: saveFile,
stream: new SquareWave(1.0, 400, dutyCycle)
.Window(3.0),
overwrite: true));
}
}
public void TestGuitar()
{
Calibration.Initialize();
for (int octave = 2; octave <= 4; octave++)
{
string guitarFile = DataManagement.PathForDataFile("Test", $"guitarE{octave}.wav");
Assert.IsTrue(WaveEncoding.SaveStream(
filepath: guitarFile,
stream: InstrumentLookup.GetNote(
set: ReservedSoundSet.ElectricGuitar_Jazz,
note: (byte)(12 * octave + 4),
velocity: 0xF7)
.SafeCache()
.SlowRangeFitter(),
overwrite: true));
}
}
public void TestRenderToccataMidi()
{
Calibration.Initialize();
string loadFile = DataManagement.PathForDataFile("Test", "toccata1.mid");
string saveFile = DataManagement.PathForDataFile("Test", "toccata1.wav");
Assert.IsTrue(MidiEncoding.LoadFile(
filePath: loadFile,
midiFile: out MidiFile midiFile,
retainAll: true));
Assert.IsTrue(WaveEncoding.SaveStream(
filepath: saveFile,
stream: new SlowRangeFitterFilter(new MidiFileStream(midiFile).SafeCache()),
overwrite: true));
Assert.IsTrue(File.Exists(saveFile));
}
public void TestBiQuadFilters()
{
Calibration.Initialize();
{
//Bandpass Filtered Sine Wave, Matched Frequency
IBGCStream stream =
new SquareWave(1f, 400f)
.BiQuadBandpassFilter(400f)
.Window(DURATION)
.Normalize(LEVEL);
bool success = WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", "BiQuadMostThroughBandWave.wav"),
stream: stream,
overwrite: true);
Assert.IsTrue(success);
}
{
//Bandpass Filtered Sine Wave, 2x Frequency
IBGCStream stream =
new SquareWave(1f, 400f)
.BiQuadBandpassFilter(800f)
.Window(DURATION)
.Normalize(LEVEL);
bool success = WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", "BiQuadTooHighBandWave.wav"),
stream: stream,
overwrite: true);
Assert.IsTrue(success);
}
{
//Bandpass Filtered Sine Wave, Half Frequency
IBGCStream stream =
new SquareWave(1f, 400f)
.BiQuadBandpassFilter(200f)
.Window(DURATION)
.Normalize(LEVEL);
bool success = WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", "BiQuadTooLowBandWave.wav"),
stream: stream,
overwrite: true);
Assert.IsTrue(success);
}
{
//Notch Filtered Square Wave, Matched Frequency
IBGCStream stream =
new SquareWave(1f, 400f)
.BiQuadNotchFilter(400f)
.Window(DURATION)
.Normalize(LEVEL);
bool success = WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", "BiQuadNotchFilteredSquareWave.wav"),
stream: stream,
overwrite: true);
Assert.IsTrue(success);
}
{
//Notch Filtered Sine Wave, Matched Frequency
IBGCStream stream =
new SineWave(1f, 400f)
.BiQuadNotchFilter(400f)
.Window(DURATION)
.Normalize(LEVEL);
bool success = WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", "BiQuadNotchFilteredSineWave.wav"),
stream: stream,
overwrite: true);
Assert.IsTrue(success);
}
{
//Notch Filtered Sine Wave, +10 Hz Mismatch
IBGCStream stream =
new SineWave(1f, 400f)
.BiQuadNotchFilter(410f)
.Window(DURATION)
.Normalize(LEVEL);
bool success = WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", "BiQuadNotchFiltered410SineWave.wav"),
stream: stream,
overwrite: true);
Assert.IsTrue(success);
}
}
public void TestFakeVoice()
{
Calibration.Initialize();
// F2: 500
// F3: 1000
// F4: 2000
double qFactor = 100;
//IBGCStream f2 = new AnalyticNoiseStream(
// rms: 1.0,
// freqLB: 20,
// freqUB: 10000,
// frequencyCount: 10000,
// distribution: AnalyticNoiseStream.AmplitudeDistribution.Pink)
// .ToBGCStream()
// .ContinuousFilter(
// envelopeStream: new Audio.Envelopes.SigmoidEnvelope(2.0),
// filterType: ContinuousFilter.FilterType.BandPass,
// freqLB: 500,
// freqUB: 540,
// qFactor: 100.0);
//Func<IBGCStream> makeCarrier = () =>
//new AnalyticNoiseStream(
// rms: 1.0,
// freqLB: 20,
// freqUB: 10000,
// frequencyCount: 10000,
// distribution: AnalyticNoiseStream.AmplitudeDistribution.Brown)
// .ToBGCStream();
//Func<IBGCStream> makeCarrier = () =>
// new SawtoothWave(
// amplitude: 1.0,
// frequency: 120);
Func <IBGCStream> makeCarrier = () =>
new StreamAdder(
new SawtoothWave(
amplitude: 1.0,
frequency: 120),
new AnalyticNoiseStream(
rms: 0.2,
freqLB: 20,
freqUB: 10000,
frequencyCount: 10000,
distribution: AnalyticNoiseStream.AmplitudeDistribution.Brown)
.ToBGCStream());
//Func<IBGCStream> makeCarrier = () =>
// new SquareWave(
// 1.0,
// 280.0,
// 0.1);
IBGCStream f2 = makeCarrier()
.ContinuousFilter(
envelopeStream: new Audio.Envelopes.EnvelopeConcatenator(
new Audio.Envelopes.SigmoidEnvelope(0.1),
new Audio.Envelopes.ConstantEnvelope(1.0, 0.1)),
filterType: ContinuousFilter.FilterType.BandPass,
freqLB: 400,
freqUB: 700,
qFactor: qFactor);
IBGCStream f3 = makeCarrier()
.ContinuousFilter(
envelopeStream: new Audio.Envelopes.LinearEnvelope(0.05, 0.15),
filterType: ContinuousFilter.FilterType.BandPass,
freqLB: 1500,
freqUB: 1000,
qFactor: qFactor);
IBGCStream f4 = makeCarrier()
.ContinuousFilter(
envelopeStream: new Audio.Envelopes.ConstantEnvelope(1.0, 0.2),
filterType: ContinuousFilter.FilterType.BandPass,
freqLB: 2000,
freqUB: 2000,
qFactor: qFactor);
IBGCStream fakeVoice = new StreamAdder(f2, f3, f4)
.Window(.2)
.Center(1)
.SlowRangeFitter();
WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", "testVoice.wav"),
stream: fakeVoice);
}
public void TestFunFakeVoice()
{
Calibration.Initialize();
// F2: 500
// F3: 1000
// F4: 2000
double qFactor = 200;
//IBGCStream f2 = new AnalyticNoiseStream(
// rms: 1.0,
// freqLB: 20,
// freqUB: 10000,
// frequencyCount: 10000,
// distribution: AnalyticNoiseStream.AmplitudeDistribution.Pink)
// .ToBGCStream()
// .ContinuousFilter(
// envelopeStream: new Audio.Envelopes.SigmoidEnvelope(2.0),
// filterType: ContinuousFilter.FilterType.BandPass,
// freqLB: 500,
// freqUB: 540,
// qFactor: 100.0);
//Func<IBGCStream> makeCarrier = () =>
//new AnalyticNoiseStream(
// rms: 1.0,
// freqLB: 20,
// freqUB: 10000,
// frequencyCount: 10000,
// distribution: AnalyticNoiseStream.AmplitudeDistribution.Brown)
// .ToBGCStream();
//Func<IBGCStream> makeCarrier = () =>
// new SawtoothWave(
// amplitude: 1.0,
// frequency: 120);
Func <IBGCStream> makeCarrier = () =>
new StreamAdder(
new SawtoothWave(
amplitude: 1.0,
frequency: 120),
new AnalyticNoiseStream(
rms: 0.2,
freqLB: 20,
freqUB: 10000,
frequencyCount: 10000,
distribution: AnalyticNoiseStream.AmplitudeDistribution.Brown)
.ToBGCStream());
//Func<IBGCStream> makeCarrier = () =>
// new SquareWave(
// 1.0,
// 280.0,
// 0.1);
//IBGCStream f2 = makeCarrier()
// .ContinuousFilter(
// envelopeStream: new SineWave(1.0, 4),
// filterType: ContinuousFilter.FilterType.BandPass,
// freqLB: 1500,
// freqUB: 1000,
// qFactor: qFactor);
{
IBGCStream f1 = makeCarrier()
.BiQuadBandpassFilter(
centralFrequency: 500,
qFactor: qFactor);
IBGCStream f2 = makeCarrier()
.BiQuadBandpassFilter(
centralFrequency: 1500,
qFactor: qFactor);
IBGCStream fakeVoice = new StreamAdder(f1, f2)
.Window(0.2)
.Center(0.5)
.SlowRangeFitter();
WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", "testVoiceA.wav"),
stream: fakeVoice,
overwrite: true);
}
{
IBGCStream f1 = makeCarrier()
.BiQuadBandpassFilter(
centralFrequency: 750,
qFactor: qFactor);
IBGCStream f2 = makeCarrier()
.BiQuadBandpassFilter(
centralFrequency: 2000,
qFactor: qFactor);
IBGCStream fakeVoice = new StreamAdder(f1, f2)
.Window(0.2)
.Center(0.5)
.SlowRangeFitter();
WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", "testVoiceB.wav"),
stream: fakeVoice,
overwrite: true);
}
}
public void TestContinuousFilter()
{
Calibration.Initialize();
IBGCStream noiseStream = new NoiseAudioClip(
duration: 4,
rms: 1.0,
freqLB: 20.0,
freqUB: 10000.0,
frequencyCount: 10000,
distribution: NoiseAudioClip.AmplitudeDistribution.Pink);
for (ContinuousFilter.FilterType filter = 0; filter < ContinuousFilter.FilterType.MAX; filter++)
{
WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", $"Sigmoid{filter}FilteredNoise.wav"),
stream: new ContinuousFilter(
stream: noiseStream,
filterEnvelope: new SigmoidEnvelope(4.0, 1.0),
filterType: filter,
freqLB: 20,
freqUB: 10000)
.Normalize(80),
overwrite: true);
WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", $"Linear{filter}FilteredNoise.wav"),
stream: new ContinuousFilter(
stream: noiseStream,
filterEnvelope: new LinearEnvelope(4.0),
filterType: filter,
freqLB: 20,
freqUB: 10000)
.Normalize(80),
overwrite: true);
WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", $"SlowSine{filter}FilteredNoise.wav"),
stream: new ContinuousFilter(
stream: noiseStream,
filterEnvelope: new SineWave(1.0, 1.0),
filterType: filter,
freqLB: 20,
freqUB: 10000)
.Normalize(80),
overwrite: true);
WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", $"FastSine{filter}FilteredNoise.wav"),
stream: new ContinuousFilter(
stream: noiseStream,
filterEnvelope: new SineWave(1.0, 50.0),
filterType: filter,
freqLB: 20,
freqUB: 10000)
.Normalize(80),
overwrite: true);
WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", $"SlowTriangle{filter}FilteredNoise.wav"),
stream: new ContinuousFilter(
stream: noiseStream,
filterEnvelope: new TriangleWave(1.0, 1.0),
filterType: filter,
freqLB: 20,
freqUB: 10000)
.Normalize(80),
overwrite: true);
WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", $"FastTriangle{filter}FilteredNoise.wav"),
stream: new ContinuousFilter(
stream: noiseStream,
filterEnvelope: new TriangleWave(1.0, 50.0),
filterType: filter,
freqLB: 20,
freqUB: 10000)
.Normalize(80),
overwrite: true);
}
}
public void TestNewConvolution()
{
string baseFile = "000000";
WaveEncoding.LoadBGCStream(
filepath: DataManagement.PathForDataFile("Test", $"{baseFile}.wav"),
stream: out IBGCStream stream);
Debug.Log($"Pre RMS: {string.Join(", ", stream.CalculateRMS().Select(x => x.ToString()).ToArray())}");
{
float[] filter1 = new float[150];
filter1[25] = 1f;
float[] filter2 = new float[150];
for (int i = 0; i < 150; i++)
{
filter2[i] = 1f / (float)Math.Sqrt(150);
}
IBGCStream convolved = stream.MultiConvolve(filter1, filter2);
string rms = string.Join(", ", convolved.CalculateRMS().Select(x => x.ToString()).ToArray());
Debug.Log($"Post RMS: {rms}");
//Write to File
WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", $"{baseFile}_Convolved.wav"),
stream: convolved,
overwrite: true);
}
{
float[] filter1 = new float[150];
filter1[25] = 1f / (float)Math.Sqrt(2);
filter1[26] = 1f / (float)Math.Sqrt(2);
float[] filter2 = new float[150];
for (int i = 0; i < 150; i++)
{
filter2[i] = 1f / 150f;
}
IBGCStream convolved = stream.MultiConvolve(filter1, filter2);
string rms = string.Join(", ", convolved.CalculateRMS().Select(x => x.ToString()).ToArray());
Debug.Log($"Post RMS: {rms}");
//Write to File
WaveEncoding.SaveStream(
filepath: DataManagement.PathForDataFile("Test", $"{baseFile}_Convolved2.wav"),
stream: convolved,
overwrite: true);
}
}