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

249 lines
8.6 KiB
C#

using System;
using System.Collections.Generic;
namespace NAudio.Wave
{
/// <summary>
/// WaveStream that can mix together multiple 32 bit input streams
/// (Normally used with stereo input channels)
/// All channels must have the same number of inputs
/// </summary>
public class WaveMixerStream32 : WaveStream
{
private readonly List<WaveStream> inputStreams;
private readonly object inputsLock;
private WaveFormat waveFormat;
private long length;
private long position;
private readonly int bytesPerSample;
/// <summary>
/// Creates a new 32 bit WaveMixerStream
/// </summary>
public WaveMixerStream32()
{
AutoStop = true;
waveFormat = WaveFormat.CreateIeeeFloatWaveFormat(44100, 2);
bytesPerSample = 4;
inputStreams = new List<WaveStream>();
inputsLock = new object();
}
/// <summary>
/// Creates a new 32 bit WaveMixerStream
/// </summary>
/// <param name="inputStreams">An Array of WaveStreams - must all have the same format.
/// Use WaveChannel is designed for this purpose.</param>
/// <param name="autoStop">Automatically stop when all inputs have been read</param>
/// <exception cref="ArgumentException">Thrown if the input streams are not 32 bit floating point,
/// or if they have different formats to each other</exception>
public WaveMixerStream32(IEnumerable<WaveStream> inputStreams, bool autoStop)
: this()
{
AutoStop = autoStop;
foreach (var inputStream in inputStreams)
{
AddInputStream(inputStream);
}
}
/// <summary>
/// Add a new input to the mixer
/// </summary>
/// <param name="waveStream">The wave input to add</param>
public void AddInputStream(WaveStream waveStream)
{
if (waveStream.WaveFormat.Encoding != WaveFormatEncoding.IeeeFloat)
throw new ArgumentException("Must be IEEE floating point", "waveStream");
if (waveStream.WaveFormat.BitsPerSample != 32)
throw new ArgumentException("Only 32 bit audio currently supported", "waveStream");
if (inputStreams.Count == 0)
{
// first one - set the format
int sampleRate = waveStream.WaveFormat.SampleRate;
int channels = waveStream.WaveFormat.Channels;
waveFormat = WaveFormat.CreateIeeeFloatWaveFormat(sampleRate, channels);
}
else
{
if (!waveStream.WaveFormat.Equals(waveFormat))
throw new ArgumentException("All incoming channels must have the same format", "waveStream");
}
lock (inputsLock)
{
inputStreams.Add(waveStream);
length = Math.Max(length, waveStream.Length);
// get to the right point in this input file
waveStream.Position = Position;
}
}
/// <summary>
/// Remove a WaveStream from the mixer
/// </summary>
/// <param name="waveStream">waveStream to remove</param>
public void RemoveInputStream(WaveStream waveStream)
{
lock (inputsLock)
{
if (inputStreams.Remove(waveStream))
{
// recalculate the length
long newLength = 0;
foreach (var inputStream in inputStreams)
{
newLength = Math.Max(newLength, inputStream.Length);
}
length = newLength;
}
}
}
/// <summary>
/// The number of inputs to this mixer
/// </summary>
public int InputCount => inputStreams.Count;
/// <summary>
/// Automatically stop when all inputs have been read
/// </summary>
public bool AutoStop { get; set; }
/// <summary>
/// Reads bytes from this wave stream
/// </summary>
/// <param name="buffer">buffer to read into</param>
/// <param name="offset">offset into buffer</param>
/// <param name="count">number of bytes required</param>
/// <returns>Number of bytes read.</returns>
/// <exception cref="ArgumentException">Thrown if an invalid number of bytes requested</exception>
public override int Read(byte[] buffer, int offset, int count)
{
if (AutoStop)
{
if (position + count > length)
count = (int)(length - position);
// was a bug here, should be fixed now
System.Diagnostics.Debug.Assert(count >= 0, "length and position mismatch");
}
if (count % bytesPerSample != 0)
throw new ArgumentException("Must read an whole number of samples", "count");
// blank the buffer
Array.Clear(buffer, offset, count);
int bytesRead = 0;
// sum the channels in
var readBuffer = new byte[count];
lock (inputsLock)
{
foreach (var inputStream in inputStreams)
{
if (inputStream.HasData(count))
{
int readFromThisStream = inputStream.Read(readBuffer, 0, count);
// don't worry if input stream returns less than we requested - may indicate we have got to the end
bytesRead = Math.Max(bytesRead, readFromThisStream);
if (readFromThisStream > 0)
Sum32BitAudio(buffer, offset, readBuffer, readFromThisStream);
}
else
{
bytesRead = Math.Max(bytesRead, count);
inputStream.Position += count;
}
}
}
position += count;
return count;
}
/// <summary>
/// Actually performs the mixing
/// </summary>
static unsafe void Sum32BitAudio(byte[] destBuffer, int offset, byte[] sourceBuffer, int bytesRead)
{
fixed (byte* pDestBuffer = &destBuffer[offset],
pSourceBuffer = &sourceBuffer[0])
{
float* pfDestBuffer = (float*)pDestBuffer;
float* pfReadBuffer = (float*)pSourceBuffer;
int samplesRead = bytesRead / 4;
for (int n = 0; n < samplesRead; n++)
{
pfDestBuffer[n] += pfReadBuffer[n];
}
}
}
/// <summary>
/// <see cref="WaveStream.BlockAlign"/>
/// </summary>
public override int BlockAlign => waveFormat.BlockAlign;
/// <summary>
/// Length of this Wave Stream (in bytes)
/// <see cref="System.IO.Stream.Length"/>
/// </summary>
public override long Length => length;
/// <summary>
/// Position within this Wave Stream (in bytes)
/// <see cref="System.IO.Stream.Position"/>
/// </summary>
public override long Position
{
get
{
// all streams are at the same position
return position;
}
set
{
lock (inputsLock)
{
value = Math.Min(value, Length);
foreach (WaveStream inputStream in inputStreams)
{
inputStream.Position = Math.Min(value, inputStream.Length);
}
position = value;
}
}
}
/// <summary>
/// <see cref="WaveStream.WaveFormat"/>
/// </summary>
public override WaveFormat WaveFormat => waveFormat;
/// <summary>
/// Disposes this WaveStream
/// </summary>
protected override void Dispose(bool disposing)
{
if (disposing)
{
lock (inputsLock)
{
foreach (WaveStream inputStream in inputStreams)
{
inputStream.Dispose();
}
}
}
else
{
System.Diagnostics.Debug.Assert(false, "WaveMixerStream32 was not disposed");
}
base.Dispose(disposing);
}
}
}