Example - Loading Audio Buffer

[h1cks]

NOTE: Please use the Soundstream class now to load samples. This workaround is no longer needed and has some issues with certain sample types such as Windows PCM Extended.

I've cracked the loading, using the NAudio library to parse the Waveformat header.

AS such, the code is below for future reference.

I use the WaveFileReader class to read in the header, plus the audio data. I then populate your Waveheader with the data, and then stream the rest of the buffer into a byte array, then create the audiobuffer.

The WaveFileReader Length takes into account the size of the header and deducts from the Audiobuffer, ensuring its only playing the buffer.

Sound now working in game.

using NAudio.Wave;

.....

public bool LoadSample(string filePath, string fileName, string soundName, bool loopForever)
{
    using (Stream fileStream_ = Helper.GetFileStream(fileName, filePath))
    {
        try
        {
            WaveFileReader reader_;

            byte[] arry_;

            using (reader_ = new WaveFileReader(fileStream_))
            {
                arry_ = new byte[reader_.Length];

                reader_.Read(arry_, 0, arry_.Length);

                _targetBuffer = new AudioBuffer(arry_, BufferFlags.None);

                int encodng_ = (int)reader_.WaveFormat.Encoding;

                _waveFormat = Vortice.Multimedia.WaveFormat.CreateCustomFormat((Vortice.Multimedia.WaveFormatEncoding)encodng_,
                    reader_.WaveFormat.SampleRate,
                    reader_.WaveFormat.Channels,
                    reader_.WaveFormat.AverageBytesPerSecond,
                    reader_.WaveFormat.BlockAlign,
                    reader_.WaveFormat.BitsPerSample);
            }
        }
        catch (Exception ex)
        {
            Trace.WriteLine(ex.Message);
            Trace.WriteLine(ex.Source);
            Trace.WriteLine(ex.StackTrace);
            return false;
        }

        if (loopForever)
        {
            _targetBuffer.LoopCount = IXAudio2.LoopInfinite;
        }
    }

    _soundID = soundName;

    return true;
}

[manuelxmarquez]

I wish I had seen this before I wrote a parser. For anyone dealing in wave files, here is some quick code to load a PCM wave file.

private static void ParseWaveFile(byte[] data, out WaveFormat format, out byte[] audioData)
{
    var headerRiff = Encoding.ASCII.GetString(data, 0, 4);

    if (headerRiff != "RIFF")
        throw new ArgumentException("RIFF header not found.");

    var fileSize = BitConverter.ToInt32(data, 4);

    if (fileSize != data.Length - 8)
        throw new ArgumentException("Invalid file size.");

    var headerFormat = Encoding.ASCII.GetString(data, 8, 4);

    if (headerFormat != "WAVE")
        throw new ArgumentException("File is not a WAVE file.");

    var subChunkId = Encoding.ASCII.GetString(data, 12, 4);

    if (subChunkId != "fmt ")
        throw new ArgumentException("Sub chunk 'fmt' not found.");

    var subChunkSize = BitConverter.ToInt32(data, 16);

    if (subChunkSize != 16)
        throw new ArgumentException("Invalid sub chunk size.");

    var audioFormat = data[20];

    if (audioFormat != PcmFormat)
        throw new ArgumentException("Only PCM audio files are supported.");

    var channels = BitConverter.ToInt16(data, 22);
    var sampleRate = BitConverter.ToInt32(data, 24);
    var byteRate = BitConverter.ToInt32(data, 28);
    var blockAlign = BitConverter.ToInt16(data, 32);
    var bitsPerSample = BitConverter.ToInt16(data, 34);

    var dataChunkId = Encoding.ASCII.GetString(data, 36, 4);

    if (dataChunkId != "data")
        throw new ArgumentException("Sub chunk 'data' not found.");

    var dataSize = BitConverter.ToInt32(data, 40);

    if (dataSize + 44 != data.Length)
        throw new ArgumentException("Invalid data chunk size.");

    format = WaveFormat.CreateCustomFormat(WaveFormatEncoding.Pcm, sampleRate, channels, byteRate, blockAlign, bitsPerSample);

    audioData = data.Skip(44).ToArray();
}

[h1cks]

The code I supplied will take care of the myriad of formats,. even for PCM. its a bit scarey! But good work on PCM. Parsing files is painful, especially binary!

[h1cks]

With Soundstream now available, this thread should be closed. Maybe a sample created and added to the repo.