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