Files
UmaViewer/Assets/Scripts/Audio/NAudio/Wave/WaveStreams/WaveFileReader.cs
T
2022-09-10 16:59:44 +08:00

258 lines
9.6 KiB
C#

using System;
using System.IO;
using System.Collections.Generic;
using NAudio.FileFormats.Wav;
namespace NAudio.Wave
{
/// <summary>This class supports the reading of WAV files,
/// providing a repositionable WaveStream that returns the raw data
/// contained in the WAV file
/// </summary>
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;
/// <summary>Supports opening a WAV file</summary>
/// <remarks>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
/// </remarks>
public WaveFileReader(String waveFile) :
this(File.OpenRead(waveFile), true)
{
}
/// <summary>
/// Creates a Wave File Reader based on an input stream
/// </summary>
/// <param name="inputStream">The input stream containing a WAV file including header</param>
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;
}
/// <summary>
/// Gets a list of the additional chunks found in this file
/// </summary>
public List<RiffChunk> ExtraChunks { get; }
/// <summary>
/// Gets the data for the specified chunk
/// </summary>
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;
}
/// <summary>
/// Cleans up the resources associated with this WaveFileReader
/// </summary>
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);
}
/// <summary>
/// <see cref="WaveStream.WaveFormat"/>
/// </summary>
public override WaveFormat WaveFormat => waveFormat;
/// <summary>
/// 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)
/// <see cref="WaveStream.WaveFormat"/>
/// </summary>
public override long Length => dataChunkLength;
/// <summary>
/// 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
/// </summary>
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");
}
}
/// <summary>
/// Position in the WAV data chunk.
/// <see cref="Stream.Position"/>
/// </summary>
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;
}
}
}
/// <summary>
/// Reads bytes from the Wave File
/// <see cref="Stream.Read"/>
/// </summary>
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);
}
}
/// <summary>
/// Attempts to read the next sample or group of samples as floating point normalised into the range -1.0f to 1.0f
/// </summary>
/// <returns>An array of samples, 1 for mono, 2 for stereo etc. Null indicates end of file reached
/// </returns>
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;
}
/// <summary>
/// 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
/// </summary>
/// <returns>False if the end of the WAV data chunk was reached</returns>
[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;
}
}
}