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;
}
}
}