Как прочитать данные из файла WAV в массив

Предполагая, что ваш WAV-файл содержит 16-битную PCM (что является наиболее распространенным), вы можете использовать NAudio , чтобы считать его в байтовый массив, а затем скопировать его в массив из 16-битных целых чисел для удобство. Если это стерео, сэмплы будут чередоваться влево, вправо.

using (WaveFileReader reader = new WaveFileReader("myfile.wav"))
{
    Assert.AreEqual(16, reader.WaveFormat.BitsPerSample, "Only works with 16 bit audio");
    byte[] buffer = new byte[reader.Length];
    int read = reader.Read(buffer, 0, buffer.Length);
    short[] sampleBuffer = new short[read / 2];
    Buffer.BlockCopy(buffer, 0, sampleBuffer, 0, read);
}

Я знаю, что вы хотели избежать сторонних библиотек, но если вы хотите быть уверенными в том, что справитесь с файлами WAV с помощью дополнительных блоков, я предлагаю избегать таких подходов, как поиск 44 байтов в файле.

http://hourlyapps.blogspot.com/2008/07/open-source-wave-graph-c-net-control.html
Вот элемент управления, отображающий Спектр WAV-файла, который также обслуживает байт [] декодированного Wav-файла, в котором вы можете воспроизводить и / или изменять их значения.

Просто скачайте Control, и это довольно хорошо для манипулирования WAV-файлом.

Попробуйте Воспроизвести аудиоданные из массива

PlayerEx pl = new PlayerEx();

private static void PlayArray(PlayerEx pl)
{
    double fs = 8000; // sample freq
    double freq = 1000; // desired tone
    short[] mySound = new short[4000];
    for (int i = 0; i < 4000; i++)
    {
        double t = (double)i / fs; // current time
        mySound[i] = (short)(Math.Cos(t * freq) * (short.MaxValue));
    }
    IntPtr format = AudioCompressionManager.GetPcmFormat(1, 16, (int)fs);
    pl.OpenPlayer(format);
    byte[] mySoundByte = new byte[mySound.Length * 2];
    Buffer.BlockCopy(mySound, 0, mySoundByte, 0, mySoundByte.Length);
    pl.AddData(mySoundByte);
    pl.StartPlay();
}

На момент написания статьи никто не обращался к 32-битным или 64-битным кодированным WAV.

Следующий код обрабатывает 16/32/64 бит и моно / стерео:

static bool readWav( string filename, out float[] L, out float[] R )
{
    L = R = null;
    //float [] left = new float[1];

    //float [] right;
    try {
        using (FileStream fs = File.Open(filename,FileMode.Open))
        {
            BinaryReader reader = new BinaryReader(fs);

            // chunk 0
            int chunkID       = reader.ReadInt32();
            int fileSize      = reader.ReadInt32();
            int riffType      = reader.ReadInt32();


            // chunk 1
            int fmtID         = reader.ReadInt32();
            int fmtSize       = reader.ReadInt32(); // bytes for this chunk
            int fmtCode       = reader.ReadInt16();
            int channels      = reader.ReadInt16();
            int sampleRate    = reader.ReadInt32();
            int byteRate      = reader.ReadInt32();
            int fmtBlockAlign = reader.ReadInt16();
            int bitDepth      = reader.ReadInt16();

            if (fmtSize == 18)
            {
                // Read any extra values
                int fmtExtraSize = reader.ReadInt16();
                reader.ReadBytes(fmtExtraSize);
            }

            // chunk 2
            int dataID = reader.ReadInt32();
            int bytes = reader.ReadInt32();

            // DATA!
            byte[] byteArray = reader.ReadBytes(bytes);

            int bytesForSamp = bitDepth/8;
            int samps = bytes / bytesForSamp;


            float[] asFloat = null;
            switch( bitDepth ) {
                case 64:
                    double[] 
                    asDouble          = new double[samps];  
                    Buffer.BlockCopy(byteArray, 0, asDouble, 0, bytes);
                    asFloat = Array.ConvertAll( asDouble, e => (float)e );
                    break;
                case 32:
                    asFloat           = new float[samps];   
                    Buffer.BlockCopy(byteArray, 0, asFloat, 0, bytes);
                    break;
                case 16:
                    Int16 [] 
                    asInt16           = new Int16[samps];   
                    Buffer.BlockCopy(byteArray, 0, asInt16, 0, bytes);
                    asFloat = Array.ConvertAll( asInt16, e => e / (float)Int16.MaxValue );
                    break;
                default:
                    return false;
            }

            switch( channels ) {
            case 1:
                L = asFloat;
                R = null;
                return true;
            case 2:
                L = new float[samps];
                R = new float[samps];
                for( int i=0, s=0; i<samps; i++ ) {
                    L[i] = asFloat[s++];
                    R[i] = asFloat[s++];
                }
                return true;
            default:
                return false;
            }
        }
    }
    catch {
            Debug.Log( "...Failed to load note: " + filename );
            return false;
            //left = new float[ 1 ]{ 0f };
    }

    return false;
}