public static FilterProfile Profile(ISoundObj impulse, SmoothingType type, double resolution)
{
uint nSR = impulse.SampleRate;
uint nSR2 = nSR / 2;
ushort nChannels = impulse.NumChannels;
for (ushort c = 0; c < nChannels; c++)
{
// Read channel into a buffer
SingleChannel channel = impulse.Channel(c);
SoundBuffer buff = new SoundBuffer(channel);
buff.ReadAll();
// And then double in length to prevent wraparound
buff.PadTo(buff.Count * 2);
// Pad to next higher power of two
buff.PadToPowerOfTwo();
// Read out into array of complex
Complex[][] data = buff.ToComplexArray();
Complex[] cdata = data[0];
// Then we're done with the buffer for this channel
buff = null;
GC.Collect();
// FFT in place
Fourier.FFT(cdata.Length, cdata);
int n = cdata.Length / 2;
// Now we have an array of complex, from 0Hz to Nyquist and back again.
// We really only care about the first half of the cdata buffer, but
// treat it as circular anyway (i.e. wrap around for negative values).
//
// We're only working with magnitudes from here on,
// so we can save some space by computing mags right away and storing them in the
// real part of the complex array; then we can use the imaginary portion for the
// smoothed data.
for (int j = 0; j < cdata.Length; j++)
{
cdata[j].Re = cdata[j].Magnitude;
cdata[j].Im = 0;
}
// Take a rectangular window of width (resolution)*(octave or ERB band)
// Add up all magnitudes falling within this window
//
// Move the window forward by one thingummajig
//double wMid = 0; // center of the window
//double wLen = 0;
}
return(new FilterProfile()); // temp
}
private ISoundObj _buff()
{
if (double.IsNaN(_normalization))
{
return(_input);
}
// We've been asked to normalize
SoundBuffer b = new SoundBuffer(_input);
b.ReadAll();
_gain = b.Normalize(_normalization, false);
return(b);
}
/// <summary>
/// Calculate the weighted volume of a *single channel* sound source.
/// NB: this consumes lots of memory for long sources.
/// </summary>
/// <param name="src"></param>
/// <param name="dbSPL"></param>
/// <returns>Volume (units, not dB)</returns>
public static double WeightedVolume1(ISoundObj src, double dbSPL, double dbSPLBase)
{
if (src.NumChannels != 1)
{
throw new ArgumentException("Requires single-channel");
}
// Read channel into a buffer
SoundBuffer buff = new SoundBuffer(src);
buff.ReadAll();
// And then double in length to prevent wraparound
buff.PadTo(buff.Count * 2);
// Pad to next higher power of two
buff.PadToPowerOfTwo();
int n = buff.Count;
double wvImpulse = WeightedVolume2(buff, dbSPL, dbSPLBase);
// compare with a Dirac pulse the same length
CallbackSource dirac = new CallbackSource(1, src.SampleRate, delegate(long j)
{
if (j >= n)
{
return(null);
}
double v = 0;
if (j == n / 2)
{
v = 1;
}
return(new Sample(v));
});
buff = new SoundBuffer(dirac);
buff.ReadAll();
double wvDirac = WeightedVolume2(buff, dbSPL, dbSPLBase);
buff = null;
GC.Collect();
return(wvImpulse / wvDirac);
}
/// <summary>
/// Calculate the weighted volume of a *single channel* sound source.
/// NB: this consumes lots of memory for long sources.
/// </summary>
/// <param name="src"></param>
/// <param name="dbSPL"></param>
/// <returns>Volume (units, not dB)</returns>
public static double WeightedVolume1(ISoundObj src, double dbSPL, double dbSPLBase)
{
if (src.NumChannels != 1)
{
throw new ArgumentException("Requires single-channel");
}
// Read channel into a buffer
SoundBuffer buff = new SoundBuffer(src);
buff.ReadAll();
// And then double in length to prevent wraparound
buff.PadTo(buff.Count * 2);
// Pad to next higher power of two
buff.PadToPowerOfTwo();
int n = buff.Count;
double wvImpulse = WeightedVolume2(buff, dbSPL, dbSPLBase);
// compare with a Dirac pulse the same length
CallbackSource dirac = new CallbackSource(1, src.SampleRate, delegate(long j)
{
if (j >= n)
{
return null;
}
double v = 0;
if (j == n / 2)
{
v = 1;
}
return new Sample(v);
});
buff = new SoundBuffer(dirac);
buff.ReadAll();
double wvDirac = WeightedVolume2(buff, dbSPL, dbSPLBase);
buff = null;
GC.Collect();
return wvImpulse / wvDirac;
}
public static FilterProfile Profile(ISoundObj impulse, SmoothingType type, double resolution)
{
uint nSR = impulse.SampleRate;
uint nSR2 = nSR / 2;
ushort nChannels = impulse.NumChannels;
for (ushort c = 0; c < nChannels; c++)
{
// Read channel into a buffer
SingleChannel channel = impulse.Channel(c);
SoundBuffer buff = new SoundBuffer(channel);
buff.ReadAll();
// And then double in length to prevent wraparound
buff.PadTo(buff.Count * 2);
// Pad to next higher power of two
buff.PadToPowerOfTwo();
// Read out into array of complex
Complex[][] data = buff.ToComplexArray();
Complex[] cdata = data[0];
// Then we're done with the buffer for this channel
buff = null;
GC.Collect();
// FFT in place
Fourier.FFT(cdata.Length, cdata);
int n = cdata.Length / 2;
// Now we have an array of complex, from 0Hz to Nyquist and back again.
// We really only care about the first half of the cdata buffer, but
// treat it as circular anyway (i.e. wrap around for negative values).
//
// We're only working with magnitudes from here on,
// so we can save some space by computing mags right away and storing them in the
// real part of the complex array; then we can use the imaginary portion for the
// smoothed data.
for (int j = 0; j < cdata.Length; j++)
{
cdata[j].Re = cdata[j].Magnitude;
cdata[j].Im = 0;
}
// Take a rectangular window of width (resolution)*(octave or ERB band)
// Add up all magnitudes falling within this window
//
// Move the window forward by one thingummajig
//double wMid = 0; // center of the window
//double wLen = 0;
}
return new FilterProfile(); // temp
}
static SoundObj Deconvolve(string infile, out Complex[] impulseFFT, out int peakpos)
{
WaveReader reader = new WaveReader(infile);
ushort nChannels = reader.NumChannels;
uint sampleRate = reader.SampleRate;
CallbackSource cs;
SingleChannel[] channels = new SingleChannel[2];
Complex[][][] data = new Complex[2][][];
double[] stdDev = new double[2];
double[] maxLogs = new double[2];
double[] maxs = new double[2];
double[] avgLog = new double[2];
Complex[] swp_data = null;
Complex[] mea_data = null;
if (_fmax == int.MaxValue)
{
_fmax = (int)sampleRate / 2;
}
bool isEstimatedSweepRange = false;
if (nChannels != 2)
{
throw new Exception("Input must have two channels.");
}
peakpos = 0;
int cSwp = 0;
int cMea = 1;
int L = 0;
int Nh = 0;
double mx;
double max = 0;
double maxLog = 0;
double stdev = 0;
double avg = 0;
for (int iteration = 1; iteration <= 2; iteration++)
{
// Read and FFT all the data
// one channel at a time
for (ushort c = 0; c < 2; c++)
{
SingleChannel channel = reader.Channel(c);
Complex[] cdata;
SoundBuffer buff = new SoundBuffer(channel);
buff.ReadAll();
if (iteration==2 && _split)
{
// Split up the input file
string infile2 = Path.ChangeExtension(Path.GetFileName(infile), ".PCM");
if (c == cSwp)
{
WaveWriter wri = new WaveWriter("refchannel_" + infile2, 1, channel.SampleRate, 32, DitherType.NONE, WaveFormat.IEEE_FLOAT);
wri.Input = buff;
wri.Run(); wri.Close();
}
if (c == cMea)
{
WaveWriter wri = new WaveWriter("sweep_" + infile2, 1, channel.SampleRate, 32, DitherType.NONE, WaveFormat.IEEE_FLOAT);
wri.Input = buff;
wri.Run(); wri.Close();
}
}
// And then double in length to prevent wraparound
buff.PadTo(buff.Count * 2);
// Pad to next higher power of two
buff.PadToPowerOfTwo();
// Read out into array of complex
data[c] = buff.ToComplexArray();
// Then we're done with the buffer for this channel
buff = null;
GC.Collect();
cdata = data[c][0];
if (iteration==2 && c==cSwp && _power > 0)
{
// Deconvolve against a power of the sweep,
// for distortion measurement of harmonic _power
Complex p = new Complex((double)_power,0);
for (int j = 0; j < cdata.Length; j++)
{
cdata[j].Pow(p);
}
}
// FFT in place
Fourier.FFT(cdata.Length, cdata);
if (false && iteration==1)
{
// write the fft magnitudes to disk
cs = new CallbackSource(1, sampleRate, delegate(long j)
{
if (j >= cdata.Length)
{
return null;
}
Complex si = cdata[j];
Sample s = new Sample(1);
double f = (double)j * sampleRate / cdata.Length;
s[0] = mag(sampleRate, f, si.Magnitude);
return s;
});
// cs.SampleRate = sampleRate;
// cs.NumChannels = 1;
WaveWriter writer = new WaveWriter("fft_" + c + "_" + infile);
writer.Format = WaveFormat.IEEE_FLOAT;
writer.BitsPerSample = 32;
writer.SampleRate = _sampleRate;
writer.Input = cs;
writer.Normalization = -3;
writer.Run();
writer.Close();
}
// Take a slice of the FFT, std dev of log(|fft|),
// the lower value should be the sweep
int n3 = cdata.Length / 4;
int n1 = n3 / 2;
int n2 = n1 + n3;
get_stddev(sampleRate, n1, n2, cdata, out max, out maxLog, out stdev, out avg);
maxs[c] = max;
maxLogs[c] = maxLog;
stdDev[c] = stdev;
avgLog[c] = avg;
// Trace.WriteLine("Channel {0} standard deviation {1}", c, stdDev[c]);
}
GC.Collect();
if (iteration == 1)
{
if (stdDev[1] < stdDev[0])
{
if (_refchannel == -1)
{
cSwp = 1;
cMea = 0;
stderr.WriteLine(" Right channel seems to be the sweep");
}
else
{
stderr.WriteLine(" Right channel seems to be the sweep");
stderr.WriteLine(" But you said use refchannel {0}, so using that.", _refchannel);
cSwp = _refchannel;
cMea = (_nInFiles - 1) - _refchannel;
}
}
else
{
if (_refchannel == -1)
{
stderr.WriteLine(" Left channel seems to be the sweep");
}
else
{
stderr.WriteLine(" Left channel seems to be the sweep");
stderr.WriteLine(" But you said use refchannel {0}, so using that.", _refchannel);
cSwp = _refchannel;
cMea = (_nInFiles - 1) - _refchannel;
}
}
}
swp_data = data[cSwp][0];
mea_data = data[cMea][0];
L = swp_data.Length;
Nh = L / 2;
// stderr.WriteLine("avgLog=" + avgLog[cSwp] + " maxLog=" + maxLogs[cSwp]);
double hz1 = L / sampleRate;
if (false && _fmin == 0)
{
isEstimatedSweepRange = true;
// Working back from 100Hz,
// Look for the first range where average of a 1Hz window
// is less than 0.7* average for the sweep itself
int kmin = (int)(hz1 * 100);
_fmin = 100;
while (kmin > 0)
{
get_stddev(sampleRate, kmin, (int)(kmin + hz1), swp_data, out max, out maxLog, out stdev, out avg);
if (avg < avgLog[cSwp] * 0.5)
{
break;
}
kmin -= (int)hz1;
_fmin--;
}
// stderr.WriteLine("avg/2: kmin=" + kmin + ", _fmin=" + _fmin);
}
if (false && _fmax == sampleRate / 2)
{
isEstimatedSweepRange = true;
// Working forward from (say) 15kHz,
// Look for the first range where average of a 100Hz window
// is less than 0.7* average for the sweep itself
int kmax = (int)(hz1 * 10000);
_fmax = 10000;
get_stddev(sampleRate, kmax, (int)(kmax + 100 * hz1), swp_data, out max, out maxLog, out stdev, out avg);
double stdTest = stdev;
while (kmax < L / 2)
{
get_stddev(sampleRate, kmax, (int)(kmax + 100 * hz1), swp_data, out max, out maxLog, out stdev, out avg);
if (avg < avgLog[cSwp] * 0.5)
{
break;
}
kmax += (int)(100 * hz1);
_fmax += 100;
}
// stderr.WriteLine("StdDev Peak: kmax=" + kmax + ", _fmax=" + _fmax + ", sdev=" + stdev + " ref " + stdTest + " (1Hz=" + hz1 + "), avgLog=" + avg);
}
if (!_noSubsonicFilter)
{
// Filter LF from the measurement data
// to avoid spurious stuff below 15Hz
int s1 = (int)(7 * hz1);
int s2 = (int)(15 * hz1);
for (int j = 0; j < s1; j++)
{
mea_data[j].Set(0, 0);
mea_data[swp_data.Length - j - 1].Set(0, 0);
}
for (int j = s1; j < s2; j++)
{
double n = (double)(j - s1) / (s2 - s1);
double m = 0.5 * (1 + Math.Cos(Math.PI * (1 + n)));
mea_data[j].mul(m);
mea_data[swp_data.Length - j - 1].mul(m);
}
}
// Divide in complex domain
for (int j = 0; j < swp_data.Length; j++)
{
swp_data[j].idiv(mea_data[j]);
// Make a copy in mea_data, we'll need it later
mea_data[j] = swp_data[j];
}
// IFFT to get the impulse response
Fourier.IFFT(swp_data.Length, swp_data);
// Scan the imp to find maximum
mx = 0;
int mp = 0;
for (int j = 0; j < sampleRate; j++)
{
Complex si = swp_data[j];
double mg = Math.Abs(si.Magnitude);
if (mg > mx) { mx = mg; mp = j; }
}
// Look one sample backwards from max position
// to find the likely "pulse peak" if within 30% of max
peakpos = mp;
if (mp>0 && swp_data[mp - 1].Magnitude / mx > 0.7)
{
peakpos = mp - 1;
}
}
// stderr.WriteLine(" {0} range {1}Hz to {2}Hz", isEstimatedSweepRange ? "Estimated sweep" : "Sweep", _fmin, _fmax);
if (_fmaxSpecified && _fminSpecified)
{
HackSweep(swp_data, mea_data, peakpos, L, sampleRate);
}
else
{
Fourier.FFT(swp_data.Length, swp_data);
}
// Window the extremities of the whole response, finally?
if (true)
{
// Make a copy in mea_data, we'll need it later
for (int j = 0; j < swp_data.Length; j++)
{
mea_data[j] = swp_data[j];
}
// Return FFT of impulse
impulseFFT = mea_data;
}
// IFFT to get the impulse response
Fourier.IFFT(swp_data.Length, swp_data);
// Scan the imp to find maximum
mx = 0;
for (int j = 0; j < sampleRate; j++)
{
Complex si = swp_data[j];
double mg = Math.Abs(si.Magnitude);
if (mg > mx) mx = mg;
}
if (_noNorm)
{
mx = 1.0;
}
// Yield the first half (normalized) as result
cs = new CallbackSource(1, sampleRate, delegate(long j)
{
if (j > (_returnAll ? L-1 : L / 2))
{
return null;
}
Complex si = swp_data[j];
Sample s = new Sample(si.Re / mx);
return s;
});
cs.SampleRate = sampleRate;
cs.NumChannels = 1;
return cs;
}
static ISoundObj Splice(string infileL, int peakPosL, string infileR, int peakPosR, string outfile)
{
//int tmp1;
//bool tmp2;
WaveReader reader1 = new WaveReader(infileL, WaveFormat.IEEE_FLOAT, 32, 1);
// reader1.Skip(peakPosL, out tmp1, out tmp2);
SoundBuffer buff1 = new SoundBuffer(reader1);
buff1.ReadAll();
// Normalize loudness for each channel
double g = Loudness.WeightedVolume(buff1);
buff1.ApplyGain(1/g);
WaveReader reader2 = new WaveReader(infileR, WaveFormat.IEEE_FLOAT, 32, 1);
// reader2.Skip(peakPosR, out tmp1, out tmp2);
SoundBuffer buff2 = new SoundBuffer(reader2);
buff2.ReadAll();
g = Loudness.WeightedVolume(buff2);
buff2.ApplyGain(1/g);
ChannelSplicer splicer = new ChannelSplicer();
splicer.Add(buff1);
splicer.Add(buff2);
// General-purpose:
// Find the extremities of the DRC impulse,
// window asymmetrically.
//
// But, since we specifically used linear-phase filters on target and mic,
// we know that the impulse is centered.
// We want an impulse length (_filterLen)
// so window the 2048 samples at each end (which are pretty low to begin with - less than -100dB)
ISoundObj output;
int nCount = (int)(buff1.Count / 2);
if (nCount > _filterLen/2)
{
BlackmanHarris bhw = new BlackmanHarris(nCount, 2048, (nCount / 2) - 2048);
bhw.Input = splicer;
SampleBuffer sb = new SampleBuffer(bhw);
output = sb.Subset(_filterLen/2, _filterLen);
}
else
{
output = splicer;
}
ISoundObj result = output;
if (!_noSkew)
{
// Apply skew to compensate for time alignment in the impulse responses
Skewer skewer = new Skewer(true);
skewer.Input = output;
skewer.Skew = peakPosL - peakPosR;
result = skewer;
}
WaveWriter writer = new WaveWriter(outfile);
writer.Input = result;
writer.Dither = DitherType.NONE;
writer.Format = WaveFormat.IEEE_FLOAT;
writer.BitsPerSample = 32;
writer.SampleRate = _sampleRate;
writer.NumChannels = splicer.NumChannels;
if (Double.IsNaN(_gain))
{
writer.Normalization = 0;
}
else
{
writer.Gain = MathUtil.gain(_gain);
}
writer.Run();
writer.Close();
reader1.Close();
reader2.Close();
return result;
}
static void Prep(string infileL, string infileR, string stereoImpulseFile, string outFile)
{
// Input files are complex
// 0=mag, 1=phase/pi (so it looks OK in a wave editor!)
// FFTs of the room impulse response
// Take two half-FFT-of-impulse WAV files
// Average them, into an array
int n;
SoundBuffer buff;
WaveWriter wri;
// NoiseGenerator noise;
FastConvolver conv;
/*
// Convolve noise with the in-room impulse
noise = new NoiseGenerator(NoiseType.WHITE_FLAT, 2, (int)131072, stereoImpulse.SampleRate, 1.0);
conv = new FastConvolver();
conv.impulse = stereoImpulse;
conv.Input = noise;
wri = new WaveWriter("ImpulseResponse_InRoom.wav");
wri.Input = conv;
wri.Format = WaveFormat.IEEE_FLOAT;
wri.BitsPerSample = 32;
wri.Normalization = 0;
wri.Run();
wri.Close();
wri = null;
conv = null;
*/
WaveReader rdrL = new WaveReader(infileL);
buff = new SoundBuffer(rdrL);
n = (int)buff.ReadAll();
uint sampleRate = buff.SampleRate;
uint nyquist = sampleRate / 2;
double binw = (nyquist / (double)n);
WaveReader rdrR = new WaveReader(infileR);
IEnumerator<ISample> enumL = buff.Samples;
IEnumerator<ISample> enumR = rdrR.Samples;
// For easier processing and visualisation
// read this in to an ERB-scale (not quite log-scale) array
// then we can smooth by convolving with a single half-cosine.
//
int nn = (int)ERB.f2bin(nyquist, sampleRate) + 1;
double[] muff = new double[nn];
int prevbin = 0;
int nbin = 0;
double v = 0;
int j = 0;
while (true)
{
double f = (double)j * binw; // equiv freq, Hz
int bin = (int)ERB.f2bin(f, sampleRate); // the bin we drop this sample in
if (bin > nn)
{
// One of the channels has more, but we're overrun so stop now
break;
}
j++;
bool more = false;
more |= enumL.MoveNext();
more |= enumR.MoveNext();
if (!more)
{
muff[prevbin] = v / nbin;
break;
}
v += enumL.Current[0]; // magnitude
v += enumR.Current[0]; // magnitude
nbin++;
if (bin > prevbin)
{
muff[prevbin] = v / nbin;
v = 0;
nbin = 0;
prevbin = bin;
}
}
double[] smoo = ERB.smooth(muff, 38);
// Pull out the freq response at ERB centers
FilterProfile lfg = ERB.profile(smoo, sampleRate);
// Write this response as a 'target' file
/*
FileStream fs = new FileStream("target_full.txt", FileMode.Create);
StreamWriter sw = new StreamWriter(fs, Encoding.ASCII);
foreach (FreqGain fg in lfg)
{
sw.WriteLine("{0} {1:f4}", Math.Round(fg.Freq), fg.Gain);
}
sw.Close();
*/
/*
fs = new FileStream("target_half.txt", FileMode.Create);
sw = new StreamWriter(fs, Encoding.ASCII);
foreach (FreqGain fg in lfg)
{
sw.WriteLine("{0} {1:f4}", Math.Round(fg.Freq), fg.Gain/2);
}
sw.Close();
*/
// Create a filter to invert this response
FilterProfile ifg = new FilterProfile();
foreach (FreqGain fg in lfg)
{
ifg.Add(new FreqGain(fg.Freq, -fg.Gain));
}
ISoundObj filterImpulse = new FilterImpulse(0, ifg, FilterInterpolation.COSINE, sampleRate);
filterImpulse.SampleRate = sampleRate;
// Write the filter impulse to disk
string sNoCorr = outFile + ".wav";
wri = new WaveWriter(sNoCorr);
wri.Input = filterImpulse; // invertor;
wri.Format = WaveFormat.IEEE_FLOAT;
wri.BitsPerSample = 32;
wri.SampleRate = _sampleRate;
wri.Normalization = -1;
wri.Run();
wri.Close();
_filterFiles.Add(sNoCorr);
/*
// Convolve noise with the NoCorrection filter
noise = new NoiseGenerator(NoiseType.WHITE_FLAT, 2, (int)131072, stereoImpulse.SampleRate, 1.0);
conv = new FastConvolver();
conv.impulse = invertor;
conv.Input = noise;
wri = new WaveWriter("NoCorrection_Test.wav");
wri.Input = conv;
wri.Format = WaveFormat.IEEE_FLOAT;
wri.BitsPerSample = 32;
wri.SampleRate = _sampleRate;
wri.Normalization = 0;
wri.Run();
wri.Close();
wri = null;
conv = null;
*/
// Convolve this with the in-room impulse response
WaveReader rea = new WaveReader(outFile + ".wav");
conv = new FastConvolver();
conv.impulse = rea;
conv.Input = new WaveReader(stereoImpulseFile);
wri = new WaveWriter(outFile + "_TestConvolution.wav");
wri.Input = conv;
wri.Format = WaveFormat.PCM;
wri.Dither = DitherType.TRIANGULAR;
wri.BitsPerSample = 16;
wri.SampleRate = _sampleRate;
wri.Normalization = -1;
wri.Run();
wri.Close();
rea.Close();
wri = null;
conv = null;
}
static SoundObj GetMainImpulse(out string actualPath)
{
DateTime dtStart = DateTime.Now;
if (_impulsePath == "") _impulsePath = null;
if (_impulsePath == "-") _impulsePath = null;
if (_matrixFilter == "") _matrixFilter = null;
if (_matrixFilter == "-") _matrixFilter = null;
if (_bformatFilter == "") _bformatFilter = null;
if (_bformatFilter == "-") _bformatFilter = null;
Trace.WriteLine("Impulse {0}, matrix {1}", CleanPath(_dataFolder, _impulsePath), CleanPath(_dataFolder, _matrixFilter));
// note: we window the room correction impulse if it's too long
WaveReader impulseReader = null;
SoundObj impulseObj = null;
actualPath = null;
if (!String.IsNullOrEmpty(_impulsePath))
{
impulseReader = GetAppropriateImpulseReader(_impulsePath, out actualPath);
}
if (impulseReader != null)
{
if (impulseReader.Iterations > _maxImpulseLength)
{
// This impulse is too long.
// Trim it to length.
int hwid = _maxImpulseLength / 2;
int qwid = _maxImpulseLength / 4;
SoundBuffer buff = new SoundBuffer(impulseReader);
buff.ReadAll();
int center = buff.MaxPos();
BlackmanHarris wind;
int startpos;
if (center < hwid)
{
wind = new BlackmanHarris(center, qwid, qwid);
startpos = 0;
}
else
{
wind = new BlackmanHarris(hwid, qwid, qwid);
startpos = center - hwid;
}
// int startpos = center < hwid ? 0 : (center - hwid);
wind.Input = buff.Subset(startpos, _maxImpulseLength);
impulseObj = wind;
}
else
{
impulseObj = impulseReader;
}
}
if (_debug)
{
TimeSpan ts = DateTime.Now.Subtract(dtStart);
Trace.WriteLine("GetMainImpulse " + ts.TotalMilliseconds);
}
return impulseObj;
}
private static double[] magbands(ISoundObj impulse, double bins)
{
uint nSR = impulse.SampleRate;
uint nSR2 = nSR / 2;
int nn = (int)bins + 1;
double[] muff = new double[nn];
ushort nChannels = impulse.NumChannels;
for (ushort c = 0; c < nChannels; c++)
{
// Read channel into a buffer
SingleChannel channel = impulse.Channel(c);
SoundBuffer buff = new SoundBuffer(channel);
buff.ReadAll();
// And then double in length to prevent wraparound
buff.PadTo(buff.Count * 2);
// Pad to next higher power of two
buff.PadToPowerOfTwo();
// Read out into array of complex
Complex[][] data = buff.ToComplexArray();
Complex[] cdata = data[0];
// Then we're done with the buffer for this channel
buff = null;
GC.Collect();
// FFT in place
Fourier.FFT(cdata.Length, cdata);
int n = cdata.Length / 2;
// Drop the FFT magnitudes into the 'muff' array
// according to an ERB-based scale (near-logarithmic).
// Then smoothing is easy.
double binw = (nSR2 / (double)n);
int prevbin = 0;
int nbin = 0;
double v = 0;
for (int j = 0; j < n; j++)
{
double f = (double)j * binw; // equiv freq, Hz
int bin = (int)ERB.f2bin(f, nSR, bins); // the bin we drop this sample in
v += cdata[j].Magnitude;
nbin++;
if ((bin > prevbin) || (j == n - 1))
{
muff[prevbin] += (v / nbin);
v = 0;
nbin = 0;
prevbin = bin;
}
}
}
// Now muff is sum(all channels) of average-magnitude-per-bin.
// Divide it all by the number of channels, so our gains are averaged...
for (int j = 0; j < muff.Length; j++)
{
muff[j] = muff[j] / nChannels;
}
return(muff);
}
private ISoundObj _buff()
{
if (double.IsNaN(_normalization))
{
return _input;
}
// We've been asked to normalize
SoundBuffer b = new SoundBuffer(_input);
b.ReadAll();
_gain = b.Normalize(_normalization, false);
return b;
}
