Обработка звука: оконное преобразование Фурье и вывод разными цветами

    public class SonogramBuilder
    {
        public List<float[]> Sonogram  { get; private set; }
        public int WindowSize { get; set; }
        public float MaxValue { get; set; }
 
        public SonogramBuilder()
        {
            WindowSize = 256;
        }
 
        public void Build(string fileName)
        {
            Sonogram = new List<float[]>();
            MaxValue = 0f;
            using (var stream = new AudioFileReader(fileName))
            foreach (var fft in GetWindowFFT(GetSamples(stream), WindowSize))
            {
                //
                Sonogram.Add(fft);
                //
                var m = fft.Max();
                if (m > MaxValue)
                    MaxValue = m;
            }
        }
 
        IEnumerable<float[]> GetWindowFFT(IEnumerable<float> samples, int windowSize)
        {
            var fft = new FFT();
            var buffer = new List<float>(windowSize + 1);
            foreach(var v in samples)
            {
                buffer.Add(v);
                if(buffer.Count == windowSize)
                {
                    yield return fft.PerformFreqFFT(buffer.ToArray()).Take(windowSize / 3).Select(f => (float)f.Norma).ToArray();
                    buffer.Clear();
                }
            }
        }
 
        IEnumerable<float> GetSamples(AudioFileReader stream)
        {
            var buffer = new float[20000];
 
            while (stream.Position < stream.Length)
            {
                var count = stream.Read(buffer, 0, buffer.Length);
                for (int i = 0; i < count; i += 2)
                    yield return buffer[i];
            }
        }
    }

    class FFT
    {
        public UInt64 ReverseBits(UInt64 r, UInt64 n)                          // преобразовывает r = ReverseBits(x - 1) в ReverseBits(x)
        {
            do { n = n >> 1; r = r ^ n; }
            while ((r & n) == 0);
            return r;
        }
 
        /// <summary>
        /// БПФ : прореживание по частоте
        /// </summary>
        /// <param name="Data">Массив исходных значений</param>
        /// <returns>Массив результатов</returns>
        Complex[] FreqFFT(Complex[] Data)
        {
            if (Data.Length > 2)
            {
                Complex[] left = new Complex[Data.Length / 2];
                Complex[] right = new Complex[Data.Length / 2];
                Complex[] X = new Complex[Data.Length];
 
                for (Int32 i = 0; i < Data.Length / 2; i++)             //операция бабочка
                {
                    Complex W = new Complex(Math.Cos((double)(2 * Math.PI * (double)i) / (double)Data.Length),
                                           -Math.Sin((double)(2 * Math.PI * (double)i) / (double)Data.Length));
 
                    X[i] = Data[i] + Data[i + Data.Length / 2];
                    X[i + Data.Length / 2] = (Data[i] - Data[i + Data.Length / 2]) * W;
                }
 
                for (Int32 i = 0; i < Data.Length / 2; i++)
                {
                    left[i] = X[i];
                    right[i] = X[i + Data.Length / 2];
                }
 
                Complex[] Xleft = FreqFFT(left);
                Complex[] Xright = FreqFFT(right);
 
                for (Int32 i = 0; i < Data.Length / 2; i++)
                {
                    X[i] = Xleft[i];
                    X[i + Data.Length / 2] = Xright[i];
                }
                return X;
            }
            else
            {
                Complex[] X = new Complex[2];
                X[0] = Data[0] + Data[1];
                X[1] = Data[0] - Data[1];
 
                return X;
            }
        }
 
        /// <summary>
        /// БПФ : прореживание по частоте
        /// </summary>
        /// <param name="Data">Массив исходных значений</param>
        /// <returns>Массив результатов</returns>
        public Complex[] PerformFreqFFT(float[] Data)
        {
            Complex[] ComplexData = new Complex[Data.Length];
 
            for (Int32 i = Data.Length - 1; i >= 0; --i)
            {
                ComplexData[i] = new Complex(Data[i]);
            }
 
            ComplexData = FreqFFT(ComplexData);
 
            UInt64 r = 0;
 
            for (UInt64 i = 1; i < (UInt64)Data.Length; i++)          //бит-реверсивная перестановка
            {
                r = ReverseBits(r, (UInt64)Data.Length);
                if (r > i)
                {
                    Complex temp = ComplexData[i];
                    ComplexData[i] = ComplexData[r];
                    ComplexData[r] = temp;
                }
            }
 
            var FreqFFTResults = new Complex[Data.Length];
 
            for (Int32 i = 0; i < Data.Length; i++)
            {
                FreqFFTResults[i] = ComplexData[i];
            }
 
            return FreqFFTResults;
        }
    }