using System; using System.IO; using System.Collections.Generic; using NAudio.FileFormats.Wav; namespace NAudio.Wave { /// This class supports the reading of WAV files, /// providing a repositionable WaveStream that returns the raw data /// contained in the WAV file /// public class WaveFileReader : WaveStream { private readonly WaveFormat waveFormat; private readonly bool ownInput; private readonly long dataPosition; private readonly long dataChunkLength; private readonly object lockObject = new object(); private Stream waveStream; /// Supports opening a WAV file /// The WAV file format is a real mess, but we will only /// support the basic WAV file format which actually covers the vast /// majority of WAV files out there. For more WAV file format information /// visit www.wotsit.org. If you have a WAV file that can't be read by /// this class, email it to the NAudio project and we will probably /// fix this reader to support it /// public WaveFileReader(String waveFile) : this(File.OpenRead(waveFile), true) { } /// /// Creates a Wave File Reader based on an input stream /// /// The input stream containing a WAV file including header public WaveFileReader(Stream inputStream) : this(inputStream, false) { } private WaveFileReader(Stream inputStream, bool ownInput) { this.waveStream = inputStream; var chunkReader = new WaveFileChunkReader(); try { chunkReader.ReadWaveHeader(inputStream); waveFormat = chunkReader.WaveFormat; dataPosition = chunkReader.DataChunkPosition; dataChunkLength = chunkReader.DataChunkLength; ExtraChunks = chunkReader.RiffChunks; } catch { if (ownInput) { inputStream.Dispose(); } throw; } Position = 0; this.ownInput = ownInput; } /// /// Gets a list of the additional chunks found in this file /// public List ExtraChunks { get; } /// /// Gets the data for the specified chunk /// public byte[] GetChunkData(RiffChunk chunk) { long oldPosition = waveStream.Position; waveStream.Position = chunk.StreamPosition; byte[] data = new byte[chunk.Length]; waveStream.Read(data, 0, data.Length); waveStream.Position = oldPosition; return data; } /// /// Cleans up the resources associated with this WaveFileReader /// protected override void Dispose(bool disposing) { if (disposing) { // Release managed resources. if (waveStream != null) { // only dispose our source if we created it if (ownInput) { waveStream.Dispose(); } waveStream = null; } } else { System.Diagnostics.Debug.Assert(false, "WaveFileReader was not disposed"); } // Release unmanaged resources. // Set large fields to null. // Call Dispose on your base class. base.Dispose(disposing); } /// /// /// public override WaveFormat WaveFormat => waveFormat; /// /// This is the length of audio data contained in this WAV file, in bytes /// (i.e. the byte length of the data chunk, not the length of the WAV file itself) /// /// public override long Length => dataChunkLength; /// /// Number of Sample Frames (if possible to calculate) /// This currently does not take into account number of channels /// Multiply number of channels if you want the total number of samples /// public long SampleCount { get { if (waveFormat.Encoding == WaveFormatEncoding.Pcm || waveFormat.Encoding == WaveFormatEncoding.Extensible || waveFormat.Encoding == WaveFormatEncoding.IeeeFloat) { return dataChunkLength / BlockAlign; } // n.b. if there is a fact chunk, you can use that to get the number of samples throw new InvalidOperationException("Sample count is calculated only for the standard encodings"); } } /// /// Position in the WAV data chunk. /// /// public override long Position { get { return waveStream.Position - dataPosition; } set { lock (lockObject) { value = Math.Min(value, Length); // make sure we don't get out of sync value -= (value % waveFormat.BlockAlign); waveStream.Position = value + dataPosition; } } } /// /// Reads bytes from the Wave File /// /// public override int Read(byte[] array, int offset, int count) { if (count % waveFormat.BlockAlign != 0) { throw new ArgumentException( $"Must read complete blocks: requested {count}, block align is {WaveFormat.BlockAlign}"); } lock (lockObject) { // sometimes there is more junk at the end of the file past the data chunk if (Position + count > dataChunkLength) { count = (int) (dataChunkLength - Position); } return waveStream.Read(array, offset, count); } } /// /// Attempts to read the next sample or group of samples as floating point normalised into the range -1.0f to 1.0f /// /// An array of samples, 1 for mono, 2 for stereo etc. Null indicates end of file reached /// public float[] ReadNextSampleFrame() { switch (waveFormat.Encoding) { case WaveFormatEncoding.Pcm: case WaveFormatEncoding.IeeeFloat: case WaveFormatEncoding.Extensible: // n.b. not necessarily PCM, should probably write more code to handle this case break; default: throw new InvalidOperationException("Only 16, 24 or 32 bit PCM or IEEE float audio data supported"); } var sampleFrame = new float[waveFormat.Channels]; int bytesToRead = waveFormat.Channels*(waveFormat.BitsPerSample/8); byte[] raw = new byte[bytesToRead]; int bytesRead = Read(raw, 0, bytesToRead); if (bytesRead == 0) return null; // end of file if (bytesRead < bytesToRead) throw new InvalidDataException("Unexpected end of file"); int offset = 0; for (int channel = 0; channel < waveFormat.Channels; channel++) { if (waveFormat.BitsPerSample == 16) { sampleFrame[channel] = BitConverter.ToInt16(raw, offset)/32768f; offset += 2; } else if (waveFormat.BitsPerSample == 24) { sampleFrame[channel] = (((sbyte)raw[offset + 2] << 16) | (raw[offset + 1] << 8) | raw[offset]) / 8388608f; offset += 3; } else if (waveFormat.BitsPerSample == 32 && waveFormat.Encoding == WaveFormatEncoding.IeeeFloat) { sampleFrame[channel] = BitConverter.ToSingle(raw, offset); offset += 4; } else if (waveFormat.BitsPerSample == 32) { sampleFrame[channel] = BitConverter.ToInt32(raw, offset) / (Int32.MaxValue + 1f); offset += 4; } else { throw new InvalidOperationException("Unsupported bit depth"); } } return sampleFrame; } /// /// Attempts to read a sample into a float. n.b. only applicable for uncompressed formats /// Will normalise the value read into the range -1.0f to 1.0f if it comes from a PCM encoding /// /// False if the end of the WAV data chunk was reached [Obsolete("Use ReadNextSampleFrame instead (this version does not support stereo properly)")] public bool TryReadFloat(out float sampleValue) { var sf = ReadNextSampleFrame(); sampleValue = sf != null ? sf[0] : 0; return sf != null; } } }