Обработка wav

using MathNet.Numerics.IntegralTransforms;
using MetroFramework;
using MetroFramework.Forms;
using System;
using System.Collections.Generic;
using System.Numerics;
using System.Threading;
using System.Windows.Forms;
 
namespace Fur
{
    public partial class Form1 : MetroForm
    {
        Thread outOnChartThread1;
        Thread outOnChartThread2;
 
        List<Complex[]> frames;
        List<Complex> wavBuffer;
 
        Complex[] forward;
        Complex[] inverse;
 
        WavDataReader wavReader;
 
        int index = 0;
 
        public Form1()
        {
            InitializeComponent();
        }
 
        private void OutOnChart1()
        {
            Invoke((Action)(() =>
            {
                _label1.Text = (wavBuffer.Count - 1).ToString();
            }));
 
            for (int i = 0; i < wavBuffer.Count; i++)
            {
                Invoke((Action)(() =>
                {
                    _chart1.Series[0].Points.AddXY(i - 200, wavBuffer[i].Real);
                    _chart1.Series[1].Points.AddXY(i, inverse[i].Real);
 
                    _progressBar1.Value = i;
                }));
            }
 
            Invoke((Action)(() => { _progressBar1.Value = 0; }));
            outOnChartThread1.Interrupt();
        }
 
        private void OutOnChart2()
        {
            for (int i = 0; i < wavBuffer.Count; i++)
            {
                Invoke((Action)(() =>
                {
                    _chart2.Series[0].Points.AddXY(i - 200, Math.Sqrt(
                        Math.Pow(wavBuffer[i].Real, 2) + Math.Pow(wavBuffer[i].Real, 2)));
 
                    _chart2.Series[1].Points.AddXY(i, Math.Sqrt(
                        Math.Pow(forward[i].Real, 2) + Math.Pow(forward[i].Real, 2)));
 
                    _progressBar2.Value = i;
                }));
            }
 
            Invoke((Action)(() => { _progressBar2.Value = 0; }));
            outOnChartThread2.Interrupt();
        }
 
        private List<Complex> GetWaveBody(string pathToWav)
        {
            wavReader = new WavDataReader(pathToWav);
            List<Complex> wave = new List<Complex>();
 
            byte[] temp = new byte[wavReader.blockAlign];
 
            for (int i = 0; i < wavReader.data.Length;
                i += wavReader.blockAlign * wavReader.numChannels)
            {
                if (i > wavReader.data.Length - 1) break;
 
                for (int j = 0; j < wavReader.blockAlign; j++)
                {
                    if (i + j > wavReader.data.Length - 1) break;
 
                    temp[j] = wavReader.data[i + j];
                }
                wave.Add(new Complex(BitConverter.ToInt32(temp, 0), 0));
            }
            return wave;
        }
        
        private void _buttonStart_Click(object sender, EventArgs e)
        {
            _chart1.Series[0].Points.Clear();
            _chart2.Series[0].Points.Clear();
            _chart2.Series[1].Points.Clear();
            _chart3.Series[0].Points.Clear();
 
            string pathToWav = null;
 
            OpenFileDialog fileDialog = new OpenFileDialog();
 
            if (fileDialog.ShowDialog() == DialogResult.OK)
            {
                pathToWav = fileDialog.FileName;
            }
 
            if (pathToWav != null)
            {
                try
                {
                    wavBuffer = GetWaveBody(pathToWav);
 
                    outOnChartThread1 = new Thread(OutOnChart1);
                    outOnChartThread2 = new Thread(OutOnChart2);
 
                    forward = wavBuffer.ToArray();
                    Fourier.Forward(forward);
                    inverse = forward;
 
                    Frame objFrame = new Frame(wavReader.sampleRate);
                    MessageBox.Show(wavReader.sampleRate.ToString());
                    frames = objFrame.GetFrames(forward);
                    OutFrame();
 
                    Fourier.Inverse(inverse);
 
                    _progressBar1.Maximum = wavBuffer.Count - 1;
                    _progressBar2.Maximum = forward.Length - 1;
                    
                    outOnChartThread1.Start();
                    outOnChartThread2.Start();
                }
                catch (Exception ex)
                {
                    MetroMessageBox.Show(this, ex.ToString(), "Error",
                        MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
        }
 
        private void OutFrame()
        {
            _chart3.Series[0].Points.Clear();
            _label2.Text = (index + 1) + "/" + frames.Count;
 
            for (int i = 0; i < frames[index].Length; i++)
            {
                _chart3.Series[0].Points.AddXY(i, frames[index][i].Real);
            }
        }
 
        private void _buttonPrev_Click(object sender, EventArgs e)
        {
            if (index == 0)
            {
                index = frames.Count - 1;
                OutFrame();
            }
            else
            {
                index--;
                OutFrame();
            }
        }
 
        private void _buttonNext_Click(object sender, EventArgs e)
        {
            if (index == frames.Count - 1)
            {
                index = 0;
                OutFrame();
            }
            else
            {
                index++;
                OutFrame();
            }
        }
    }
}
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Numerics;
using System.Windows.Forms;
using MathNet.Numerics.IntegralTransforms;
 
namespace Fur
{
    class Frame
    {
        public int sampleRate;
 
        public Frame()
        {
            sampleRate = 0;
        }
 
        public Frame(int sampleRate)
        {
            this.sampleRate = sampleRate;
        }
 
        private int Formula()
        {
            double c = 0.0f;
            int count = 0;
 
            for (int i = 5; i < 100; i++)
            {
                if (c >= 0.01f && c <= 0.03f) { count = i; break; }
                else { c = 1.0f / sampleRate * Math.Pow(2, i); }
            }
 
            return (int)Math.Pow(2, count);
        }
 
        public List<Complex[]> GetFrames(Complex[] wave)
        {
            List<Complex[]> frames = new List<Complex[]>();
            List<Complex> frame = new List<Complex>();
 
            int prev = 0;
            int count = Formula();
 
            for (int i = 0; i < wave.Length; i++)
            {
                if (i < count + prev)
                {
                    frame.Add(wave[i]);
                }
                if (i >= count + prev)
                {
                    frame.Add(wave[i]);
 
                    Complex[] forward = frame.ToArray();
                    Fourier.Forward(forward);
 
                    frames.Add(frame.ToArray());
                    prev = i;
 
                    frame = new List<Complex>();
                }
            }
 
            return frames;
        }
    }
}
 
 
using System.IO;
 
namespace Fur
{
    class WavDataReader
    {
        public int chunkID = 0;
        public int chunkSize = 0;
        public int format = 0;
        public int subchunk1ID = 0;
        public int subchunk1Size = 0;
        public int audioFormat = 0;
        public int numChannels = 0;
        public int sampleRate = 0;
        public int byteRate = 0;
        public int blockAlign = 0;
        public int bitsPerSample = 0;
        public int subchunk2ID = 0;
        public int subchunk2Size = 0;
        public byte[] data = null;
 
        public WavDataReader()
        {
 
        }
 
        public WavDataReader(string pathToWav)
        {
            GetData(pathToWav);
        }
 
        public string GetData(string pathToWav)
        {
            if (pathToWav != null && pathToWav.Substring(pathToWav.LastIndexOf('.')) == ".wav")
            {
                BinaryReader reader = new BinaryReader(new FileStream(pathToWav, FileMode.Open));
 
                chunkID = reader.ReadInt32();
                chunkSize = reader.ReadInt32();
                format = reader.ReadInt32();
                subchunk1ID = reader.ReadInt32();
                subchunk1Size = reader.ReadInt32();
                audioFormat = reader.ReadInt16();
                numChannels = reader.ReadInt16();
                sampleRate = reader.ReadInt32();
                byteRate = reader.ReadInt32();
                blockAlign = reader.ReadInt16();
                bitsPerSample = reader.ReadInt16();
                subchunk2ID = reader.ReadInt32();
                subchunk2Size = reader.ReadInt32();
 
                data = reader.ReadBytes((int)reader.BaseStream.Length);
 
                reader.Close();
 
                return "Data was read.";
            }
 
            return "Error.\nCheck the path to the file.\nThe file must be wav";
        }
    }
}