Нужно получить данные из wav-файла в массив.

[sazca]

Здравствуйте уважаемые!
Есть интересная проблема,которую из-за банальной нехватки знаний,я не могу решить.
Нужно получить данные из wav-файла в массив.

Использую NAudio.Можно другими средствами.Просто уже третий день лазию по гуглу.

Нашел один простенький код, но так как я работаю с большими файлами (50-100mB 44Hz), то после загрузки 3-4 файлов получаю ошибку о том, что память полная. А задание простенькое, мне надо аудио-файлы откалибрировать и сохранить в особом формате, под которий у меня уже есть готовие библиотеки для дальнейшей обработки.


Заранее спасибо!

[sazca]

namespace TonIEC
{
    public class WaveFile:IDisposable
    {
        int FileSize; 
        string Format; 
        int FmtChunkSize; 
        int AudioFormat; 
        int NumChannels; 
        int SampleRate; 

        public int SampleRate1
        {
            get { return SampleRate; }
            set { SampleRate = value; }
        }
        int ByteRate;
        int BlockAlign; 
        int BitsPerSample;
        int DataSize; 
        int[][] Data; 
        public int[][] Data1
        {
            get { return Data; }
            set { Data = value; }
        }
        private bool _isDisposed;
        public WaveFile ()     {}

        ~WaveFile()
        {
            this.Dispose(false);
        }

        public void Dispose(bool isDisposeByUser)
        {
            GC.SuppressFinalize(this);

            
            this._isDisposed = true;
        }
        public void Dispose()
        {
            
            if (this._isDisposed)
            {
                throw new ObjectDisposedException(
                    this.ToString());            }

            
            this.Dispose(true);
        }
        public int getSampleRate()
        {
            return SampleRate;
        }

        public void LoadWave(string path)
        {
            System.IO.FileStream fs = System.IO.File.OpenRead(path); // zu lesende Wave Datei öffnen
            LoadChunk(fs); // RIFF Chunk einlesen
            LoadChunk(fs); // fmt Chunk einlesen
            LoadChunk(fs); // data Chunk einlesen

            fs.Close();
        }

        private void LoadChunk(System.IO.FileStream fs)
        {
            System.Text.ASCIIEncoding Encoder = new ASCIIEncoding();

            byte[] bChunkID = new byte[4];
            
            
            fs.Read(bChunkID, 0, 4);
            string sChunkID = Encoder.GetString(bChunkID); 

            byte[] ChunkSize = new byte[4];
            
            fs.Read(ChunkSize, 0, 4);

            string s = sChunkID;


            if (sChunkID.Equals("RIFF"))
            {
                
                FileSize = System.BitConverter.ToInt32(ChunkSize, 0);
                
                byte[] Format = new byte[4];
                fs.Read(Format, 0, 4);
               
                this.Format = Encoder.GetString(Format);
            }

            if (sChunkID.Equals("fmt "))
            {
                
                FmtChunkSize = System.BitConverter.ToInt32(ChunkSize, 0);
                
                byte[] AudioFormat = new byte[2];
                fs.Read(AudioFormat, 0, 2);
                this.AudioFormat = System.BitConverter.ToInt16(AudioFormat, 0);
                byte[] NumChannels = new byte[2];
                fs.Read(NumChannels, 0, 2);
                this.NumChannels = System.BitConverter.ToInt16(NumChannels, 0);
                byte[] SampleRate = new byte[4];
                fs.Read(SampleRate, 0, 4);
                this.SampleRate = System.BitConverter.ToInt32(SampleRate, 0);
                byte[] ByteRate = new byte[4];
                fs.Read(ByteRate, 0, 4);
                this.ByteRate = System.BitConverter.ToInt32(ByteRate, 0);
                byte[] BlockAlign = new byte[2];
                fs.Read(BlockAlign, 0, 2);
                this.BlockAlign = System.BitConverter.ToInt16(BlockAlign, 0);
                byte[] BitsPerSample = new byte[2];
                fs.Read(BitsPerSample, 0, 2);
                this.BitsPerSample = System.BitConverter.ToInt16(BitsPerSample, 0);
            }
            if (sChunkID == "data")
            {
                
                DataSize = System.BitConverter.ToInt32(ChunkSize, 0);

                Data = new int[this.NumChannels][];
                
                byte[] temp = new byte[BlockAlign / NumChannels];
                
                for (int i = 0; i < this.NumChannels; i++)
                {
                    Data[i] = new int[this.DataSize / (NumChannels * BitsPerSample / 8)];
                }

                
                for (int i = 0; i < Data[0].Length; i++)
                {
                    
                    for (int j = 0; j < NumChannels; j++)
                    {
                        
                        if (fs.Read(temp, 0, BlockAlign / NumChannels) > 0)
                        {   
                            
                            if (BlockAlign / NumChannels == 2)
                                Data[j][i] = System.BitConverter.ToInt16(temp, 0);
                            else
                                Data[j][i] = System.BitConverter.ToInt32(temp, 0);
                        }
                        
                    }
                }
            }
        }

        
    }


}