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

325 lines
12 KiB
C#

using System;
using System.IO;
using System.Collections.Generic;
using NAudio.Utils;
// ReSharper disable once CheckNamespace
namespace NAudio.Wave
{
/// <summary>A read-only stream of AIFF data based on an aiff file
/// with an associated WaveFormat
/// originally contributed to NAudio by Giawa
/// </summary>
public class AiffFileReader : WaveStream
{
private readonly WaveFormat waveFormat;
private readonly bool ownInput;
private readonly long dataPosition;
private readonly int dataChunkLength;
private readonly List<AiffChunk> chunks = new List<AiffChunk>();
private Stream waveStream;
private readonly object lockObject = new object();
/// <summary>Supports opening a AIF file</summary>
/// <remarks>The AIF is of similar nastiness to the WAV format.
/// This supports basic reading of uncompressed PCM AIF files,
/// with 8, 16, 24 and 32 bit PCM data.
/// </remarks>
public AiffFileReader(String aiffFile) :
this(File.OpenRead(aiffFile))
{
ownInput = true;
}
/// <summary>
/// Creates an Aiff File Reader based on an input stream
/// </summary>
/// <param name="inputStream">The input stream containing a AIF file including header</param>
public AiffFileReader(Stream inputStream)
{
waveStream = inputStream;
ReadAiffHeader(waveStream, out waveFormat, out dataPosition, out dataChunkLength, chunks);
Position = 0;
}
/// <summary>
/// Ensures valid AIFF header and then finds data offset.
/// </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 ReadAiffHeader(Stream stream, out WaveFormat format, out long dataChunkPosition, out int dataChunkLength, List<AiffChunk> chunks)
{
dataChunkPosition = -1;
format = null;
BinaryReader br = new BinaryReader(stream);
if (ReadChunkName(br) != "FORM")
{
throw new FormatException("Not an AIFF file - no FORM header.");
}
uint fileSize = ConvertInt(br.ReadBytes(4));
string formType = ReadChunkName(br);
if (formType != "AIFC" && formType != "AIFF")
{
throw new FormatException("Not an AIFF file - no AIFF/AIFC header.");
}
dataChunkLength = 0;
while (br.BaseStream.Position < br.BaseStream.Length)
{
AiffChunk nextChunk = ReadChunkHeader(br);
if (nextChunk.ChunkName == "\0\0\0\0") break;
if (br.BaseStream.Position + nextChunk.ChunkLength > br.BaseStream.Length)
{
break;
}
if (nextChunk.ChunkName == "COMM")
{
short numChannels = ConvertShort(br.ReadBytes(2));
uint numSampleFrames = ConvertInt(br.ReadBytes(4));
short sampleSize = ConvertShort(br.ReadBytes(2));
double sampleRate = IEEE.ConvertFromIeeeExtended(br.ReadBytes(10));
format = new WaveFormat((int)sampleRate, (int)sampleSize, (int)numChannels);
if (nextChunk.ChunkLength > 18 && formType == "AIFC")
{
// In an AIFC file, the compression format is tacked on to the COMM chunk
string compress = new string(br.ReadChars(4)).ToLower();
if (compress != "none") throw new FormatException("Compressed AIFC is not supported.");
br.ReadBytes((int)nextChunk.ChunkLength - 22);
}
else br.ReadBytes((int)nextChunk.ChunkLength - 18);
}
else if (nextChunk.ChunkName == "SSND")
{
uint offset = ConvertInt(br.ReadBytes(4));
uint blockSize = ConvertInt(br.ReadBytes(4));
dataChunkPosition = nextChunk.ChunkStart + 16 + offset;
dataChunkLength = (int)nextChunk.ChunkLength - 8;
br.BaseStream.Position += (nextChunk.ChunkLength - 8);
}
else
{
if (chunks != null)
{
chunks.Add(nextChunk);
}
br.BaseStream.Position += nextChunk.ChunkLength;
}
}
if (format == null)
{
throw new FormatException("Invalid AIFF file - No COMM chunk found.");
}
if (dataChunkPosition == -1)
{
throw new FormatException("Invalid AIFF file - No SSND chunk found.");
}
}
/// <summary>
/// Cleans up the resources associated with this AiffFileReader
/// </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, "AiffFileReader 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>
/// <see cref="WaveStream.WaveFormat"/>
/// </summary>
public override long Length => dataChunkLength;
/// <summary>
/// Number of Samples (if possible to calculate)
/// </summary>
public long SampleCount
{
get
{
if (waveFormat.Encoding == WaveFormatEncoding.Pcm ||
waveFormat.Encoding == WaveFormatEncoding.Extensible ||
waveFormat.Encoding == WaveFormatEncoding.IeeeFloat)
{
return dataChunkLength / BlockAlign;
}
else
{
throw new FormatException("Sample count is calculated only for the standard encodings");
}
}
}
/// <summary>
/// Position in the AIFF file
/// <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 AIFF 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 = dataChunkLength - (int) Position;
}
// Need to fix the endianness since intel expect little endian, and apple is big endian.
byte[] buffer = new byte[count];
int length = waveStream.Read(buffer, offset, count);
int bytesPerSample = WaveFormat.BitsPerSample/8;
for (int i = 0; i < length; i += bytesPerSample)
{
if (WaveFormat.BitsPerSample == 8)
{
array[i] = buffer[i];
}
else if (WaveFormat.BitsPerSample == 16)
{
array[i + 0] = buffer[i + 1];
array[i + 1] = buffer[i];
}
else if (WaveFormat.BitsPerSample == 24)
{
array[i + 0] = buffer[i + 2];
array[i + 1] = buffer[i + 1];
array[i + 2] = buffer[i + 0];
}
else if (WaveFormat.BitsPerSample == 32)
{
array[i + 0] = buffer[i + 3];
array[i + 1] = buffer[i + 2];
array[i + 2] = buffer[i + 1];
array[i + 3] = buffer[i + 0];
}
else throw new FormatException("Unsupported PCM format.");
}
return length;
}
}
#region Endian Helpers
private static uint ConvertInt(byte[] buffer)
{
if (buffer.Length != 4) throw new Exception("Incorrect length for long.");
return (uint)((buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | buffer[3]);
}
private static short ConvertShort(byte[] buffer)
{
if (buffer.Length != 2) throw new Exception("Incorrect length for int.");
return (short)((buffer[0] << 8) | buffer[1]);
}
#endregion
#region AiffChunk
/// <summary>
/// AIFF Chunk
/// </summary>
public struct AiffChunk
{
/// <summary>
/// Chunk Name
/// </summary>
public string ChunkName;
/// <summary>
/// Chunk Length
/// </summary>
public uint ChunkLength;
/// <summary>
/// Chunk start
/// </summary>
public uint ChunkStart;
/// <summary>
/// Creates a new AIFF Chunk
/// </summary>
public AiffChunk(uint start, string name, uint length)
{
ChunkStart = start;
ChunkName = name;
ChunkLength = length + (uint)(length % 2 == 1 ? 1 : 0);
}
}
private static AiffChunk ReadChunkHeader(BinaryReader br)
{
var chunk = new AiffChunk((uint)br.BaseStream.Position, ReadChunkName(br), ConvertInt(br.ReadBytes(4)));
return chunk;
}
private static string ReadChunkName(BinaryReader br)
{
return new string(br.ReadChars(4));
}
#endregion
}
}