Bdtjtk

I am a novice audio programmer and I use FFT for the first time. I want to sample audio from my audio output. After that I want to compute this data with a FFT algorithm. I am using Naudio.dll.

Requirements for sampling:

• Sample from audio output


• The sample frequency must be adjustable on the GUI


• The buffer size must be adjustable on the GUI


• The amplitude values must be raw (no logarithmic filter/no sqrt() filter...)

How can I solve this problem? Which dll to use?

I tried to use NAudio's sample aggregator. But I don't know how.

Thanks in advance

public class SampleAggregator : ISampleProvider

{

    public event EventHandler<MaxSampleEventArgs> MaximumCalculated;

    private float maxValue;

    private float minValue;

    public int NotificationCount { get; set; }

    int count;



    public event EventHandler<FftEventArgs> FftCalculated;

    public bool PerformFFT { get; set; }

    private readonly Complex fftBuffer;

    private readonly FftEventArgs fftArgs;

    private int fftPos;

    private readonly int fftLength;

    private readonly int m;

    private readonly ISampleProvider source;



    private readonly int channels;



    public SampleAggregator(ISampleProvider source, int fftLength = 1024)

    {

        channels = source.WaveFormat.Channels;

        if (!IsPowerOfTwo(fftLength))

        {

            throw new ArgumentException("FFT Length must be a power of two");

        }

        m = (int)Math.Log(fftLength, 2.0);

        this.fftLength = fftLength;

        fftBuffer = new Complex[fftLength];

        fftArgs = new FftEventArgs(fftBuffer);

        this.source = source;

    }



    static bool IsPowerOfTwo(int x)

    {

        return (x & (x - 1)) == 0;

    }





    public void Reset()

    {

        count = 0;

        maxValue = minValue = 0;

    }



    private void Add(float value)

    {

        if (PerformFFT && FftCalculated != null)

        {

            fftBuffer[fftPos].X = (float)(value * FastFourierTransform.HammingWindow(fftPos, fftLength));

            fftBuffer[fftPos].Y = 0;

            fftPos++;

            if (fftPos >= fftBuffer.Length)

            {

                fftPos = 0;

                // 1024 = 2^10

                FastFourierTransform.FFT(true, m, fftBuffer);

                FftCalculated(this, fftArgs);

            }

        }



        maxValue = Math.Max(maxValue, value);

        minValue = Math.Min(minValue, value);

        count++;

        if (count >= NotificationCount && NotificationCount > 0)

        {

            MaximumCalculated?.Invoke(this, new MaxSampleEventArgs(minValue, maxValue));

            Reset();

        }

    }



    public WaveFormat WaveFormat => source.WaveFormat;



    public int Read(float buffer, int offset, int count)

    {

        var samplesRead = source.Read(buffer, offset, count);



        for (int n = 0; n < samplesRead; n+=channels)

        {

            Add(buffer[n+offset]);

        }

        return samplesRead;

    }

}



public class MaxSampleEventArgs : EventArgs

{

    [DebuggerStepThrough]

    public MaxSampleEventArgs(float minValue, float maxValue)

    {

        MaxSample = maxValue;

        MinSample = minValue;

    }

    public float MaxSample { get; private set; }

    public float MinSample { get; private set; }

}



public class FftEventArgs : EventArgs

{

    [DebuggerStepThrough]

    public FftEventArgs(Complex result)

    {

        Result = result;

    }

    public Complex Result { get; private set; }

}

The NAudio github repository contains the NAudioWpfDemo project which also includes an implementation of a spectrum analyzer. I try to explain the most important parts below. I paste the relevant code in this answer but you need to take a look at the original source code to understand it completely.

The demo project uses the WPF Polyline element (see SpectrumAnalyser.xaml) to visualize the FFT data.

<UserControl x:Class="NAudioWpfDemo.SpectrumAnalyser">

    <Canvas Background="Black">

        <Polyline x:Name="polyline1" Stroke="Yellow" StrokeThickness="1"/>

    </Canvas>

</UserControl>

In SpectrumAnalyser.xaml.cs you find the code which updates the Polyline element. The method Update(Complex fftResults) receives the FFT data and then loops over all the data points in the FFT data (fftResults array) ...

for (int n = 0; n < fftResults.Length / 2; n+= binsPerPoint)

{

    // averaging out bins

    double yPos = 0;

    for (int b = 0; b < binsPerPoint; b++)

    {

        yPos += GetYPosLog(fftResults[n+b]);

    }

    AddResult(n / binsPerPoint, yPos / binsPerPoint);

}

... to call GetYPosLog(Complex c) to calculate the dB value of each FFT data point ...

double intensityDB = 10 * Math.Log10(Math.Sqrt(c.X * c.X + c.Y * c.Y));

... and to add the converted data point to the polyline1 element in the method AddResult(int index, double power)

Point p = new Point(CalculateXPos(index), power);

polyline1.Points.Add(p);