Files
UmaViewer/Assets/Plugins/Lame-For-Unity/Lame/NAudio/WaveFileReader.cs
T
Evans Jahja 956bbdb6d2 Added .mp3 export (#92)
* Update to larger bitrate

* Add support for sub-voice export

---------

Co-authored-by: katboi01 <59540382+katboi01@users.noreply.github.com>
2025-07-20 07:18:58 +02:00

323 lines
12 KiB
C#

using System;
using System.IO;
using System.Text;
using System.Collections.Generic;
using System.Diagnostics;
namespace NAudio.Wave.WZT
{
/// <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 WaveFormat waveFormat;
private Stream waveStream;
private bool ownInput;
private long dataPosition;
private int dataChunkLength;
private List<RiffChunk> chunks = new List<RiffChunk>();
/// <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))
{
ownInput = 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.waveStream = inputStream;
ReadWaveHeader(waveStream, out waveFormat, out dataPosition, out dataChunkLength, chunks);
Position = 0;
}
/// <summary>
/// Reads the header part of a WAV file from a stream
/// </summary>
/// <param name="stream">The stream, positioned at the start of audio data</param>
/// <param name="format">The format found</param>
/// <param name="dataChunkPosition">The position of the data chunk</param>
/// <param name="dataChunkLength">The length of the data chunk</param>
/// <param name="chunks">Additional chunks found</param>
public static void ReadWaveHeader(Stream stream, out WaveFormat format, out long dataChunkPosition, out int dataChunkLength, List<RiffChunk> chunks)
{
dataChunkPosition = -1;
format = null;
BinaryReader br = new BinaryReader(stream);
if (Encoding.ASCII.GetString(br.ReadBytes(4)) != "RIFF")//WaveInterop.mmioStringToFOURCC("RIFF", 0)
{
throw new FormatException("Not a WAVE file - no RIFF header");
}
uint fileSize = br.ReadUInt32(); // read the file size (minus 8 bytes)
if (Encoding.ASCII.GetString(br.ReadBytes(4)) != "WAVE")//WaveInterop.mmioStringToFOURCC("WAVE", 0)
{
throw new FormatException("Not a WAVE file - no WAVE header");
}
int dataChunkID = BitConverter.ToInt32(Encoding.UTF8.GetBytes("data"), 0); ;//WaveInterop.mmioStringToFOURCC("data", 0)
int formatChunkId = BitConverter.ToInt32(Encoding.UTF8.GetBytes("fmt "), 0); ;//WaveInterop.mmioStringToFOURCC("fmt ", 0)
dataChunkLength = 0;
// sometimes a file has more data than is specified after the RIFF header
long stopPosition = Math.Min(fileSize + 8, stream.Length);
// this -8 is so we can be sure that there are at least 8 bytes for a chunk id and length
while (stream.Position <= stopPosition - 8)
{
Int32 chunkIdentifier = br.ReadInt32();
Int32 chunkLength = br.ReadInt32();
if (chunkIdentifier == dataChunkID)
{
dataChunkPosition = stream.Position;
dataChunkLength = chunkLength;
stream.Position += chunkLength;
}
else if (chunkIdentifier == formatChunkId)
{
format = WaveFormat.FromFormatChunk(br, chunkLength);
}
else
{
// check for invalid chunk length
if (chunkLength < 0 || chunkLength > stream.Length - stream.Position)
{
Debug.Assert(false, String.Format("Invalid chunk length {0}, pos: {1}. length: {2}",
chunkLength, stream.Position, stream.Length));
// an exception will be thrown further down if we haven't got a format and data chunk yet,
// otherwise we will tolerate this file despite it having corrupt data at the end
break;
}
if (chunks != null)
{
chunks.Add(new RiffChunk(chunkIdentifier, chunkLength, stream.Position));
}
stream.Position += chunkLength;
}
}
if (format == null)
{
throw new FormatException("Invalid WAV file - No fmt chunk found");
}
if (dataChunkPosition == -1)
{
throw new FormatException("Invalid WAV file - No data chunk found");
}
}
/// <summary>
/// Gets a list of the additional chunks found in this file
/// </summary>
public List<RiffChunk> ExtraChunks
{
get
{
return chunks;
}
}
/// <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.Close();
}
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
{
get
{
return 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
{
get
{
return dataChunkLength;
}
}
/// <summary>
/// Number of Samples (if possible to calculate)
/// This currently does not take into account number of channels, so
/// divide again by number of channels if you want the number of
/// audio 'frames'
/// </summary>
public long SampleCount
{
get
{
if (waveFormat.Encoding == WaveFormatEncoding.Pcm ||
waveFormat.Encoding == WaveFormatEncoding.Extensible ||
waveFormat.Encoding == WaveFormatEncoding.IeeeFloat)
{
return dataChunkLength / BlockAlign;
}
else
{
// 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 (this)
{
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(String.Format("Must read complete blocks: requested {0}, block align is {1}", count, this.WaveFormat.BlockAlign));
}
// sometimes there is more junk at the end of the file past the data chunk
if (Position + count > dataChunkLength)
{
count = dataChunkLength - (int)Position;
}
return waveStream.Read(array, offset, count);
}
/// <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>
public bool TryReadFloat(out float sampleValue)
{
sampleValue = 0.0f;
// 16 bit PCM data
if (waveFormat.BitsPerSample == 16)
{
byte[] value = new byte[2];
int read = Read(value, 0, 2);
if (read < 2)
return false;
sampleValue = (float)BitConverter.ToInt16(value, 0) / 32768f;
return true;
}
// 24 bit PCM data
else if (waveFormat.BitsPerSample == 24)
{
byte[] value = new byte[4];
int read = Read(value, 0, 3);
if (read < 3)
return false;
if (value[2] > 0x7f)
{
value[3] = 0xff;
}
else
{
value[3] = 0x00;
}
sampleValue = (float)BitConverter.ToInt32(value, 0) / (float)(0x800000);
return true;
}
// 32 bit PCM data
if (waveFormat.BitsPerSample == 32 && waveFormat.Encoding == WaveFormatEncoding.Extensible)
{
byte[] value = new byte[4];
int read = Read(value, 0, 4);
if (read < 4)
return false;
sampleValue = (float)BitConverter.ToInt32(value, 0) / ((float)(Int32.MaxValue) + 1f);
return true;
}
// IEEE float data
if (waveFormat.BitsPerSample == 32 && waveFormat.Encoding == WaveFormatEncoding.IeeeFloat)
{
byte[] value = new byte[4];
int read = Read(value, 0, 4);
if (read < 4)
return false;
sampleValue = BitConverter.ToSingle(value, 0);
return true;
}
else
{
throw new ApplicationException("Only 16, 24 or 32 bit PCM or IEEE float audio data supported");
}
}
}
}