using System;
using NAudio.Wave.SampleProviders;
namespace NAudio.Wave
{
///
/// Represents Channel for the WaveMixerStream
/// 32 bit output and 16 bit input
/// It's output is always stereo
/// The input stream can be panned
///
public class WaveChannel32 : WaveStream, ISampleNotifier
{
private WaveStream sourceStream;
private readonly WaveFormat waveFormat;
private readonly long length;
private readonly int destBytesPerSample;
private readonly int sourceBytesPerSample;
private volatile float volume;
private volatile float pan;
private long position;
private readonly ISampleChunkConverter sampleProvider;
private readonly object lockObject = new object();
///
/// Creates a new WaveChannel32
///
/// the source stream
/// stream volume (1 is 0dB)
/// pan control (-1 to 1)
public WaveChannel32(WaveStream sourceStream, float volume, float pan)
{
PadWithZeroes = true;
var providers = new ISampleChunkConverter[]
{
new Mono8SampleChunkConverter(),
new Stereo8SampleChunkConverter(),
new Mono16SampleChunkConverter(),
new Stereo16SampleChunkConverter(),
new Mono24SampleChunkConverter(),
new Stereo24SampleChunkConverter(),
new MonoFloatSampleChunkConverter(),
new StereoFloatSampleChunkConverter(),
};
foreach (var provider in providers)
{
if (provider.Supports(sourceStream.WaveFormat))
{
this.sampleProvider = provider;
break;
}
}
if (this.sampleProvider == null)
{
throw new ArgumentException("Unsupported sourceStream format");
}
// always outputs stereo 32 bit
waveFormat = WaveFormat.CreateIeeeFloatWaveFormat(sourceStream.WaveFormat.SampleRate, 2);
destBytesPerSample = 8; // includes stereo factoring
this.sourceStream = sourceStream;
this.volume = volume;
this.pan = pan;
sourceBytesPerSample = sourceStream.WaveFormat.Channels * sourceStream.WaveFormat.BitsPerSample / 8;
length = SourceToDest(sourceStream.Length);
position = 0;
}
private long SourceToDest(long sourceBytes)
{
return (sourceBytes / sourceBytesPerSample) * destBytesPerSample;
}
private long DestToSource(long destBytes)
{
return (destBytes / destBytesPerSample) * sourceBytesPerSample;
}
///
/// Creates a WaveChannel32 with default settings
///
/// The source stream
public WaveChannel32(WaveStream sourceStream)
:
this(sourceStream, 1.0f, 0.0f)
{
}
///
/// Gets the block alignment for this WaveStream
///
public override int BlockAlign => (int)SourceToDest(sourceStream.BlockAlign);
///
/// Returns the stream length
///
public override long Length => length;
///
/// Gets or sets the current position in the stream
///
public override long Position
{
get
{
return position;
}
set
{
lock (lockObject)
{
// make sure we don't get out of sync
value -= (value % BlockAlign);
if (value < 0)
{
sourceStream.Position = 0;
}
else
{
sourceStream.Position = DestToSource(value);
}
// source stream may not have accepted the reposition we gave it
position = SourceToDest(sourceStream.Position);
}
}
}
///
/// Reads bytes from this wave stream
///
/// The destination buffer
/// Offset into the destination buffer
/// Number of bytes read
/// Number of bytes read.
public override int Read(byte[] destBuffer, int offset, int numBytes)
{
lock (lockObject)
{
int bytesWritten = 0;
WaveBuffer destWaveBuffer = new WaveBuffer(destBuffer);
// 1. fill with silence
if (position < 0)
{
bytesWritten = (int) Math.Min(numBytes, 0 - position);
for (int n = 0; n < bytesWritten; n++)
destBuffer[n + offset] = 0;
}
if (bytesWritten < numBytes)
{
sampleProvider.LoadNextChunk(sourceStream, (numBytes - bytesWritten)/8);
float left, right;
int outIndex = (offset/4) + bytesWritten/4;
while (this.sampleProvider.GetNextSample(out left, out right) && bytesWritten < numBytes)
{
// implement better panning laws.
left = (pan <= 0) ? left : (left*(1 - pan)/2.0f);
right = (pan >= 0) ? right : (right*(pan + 1)/2.0f);
left *= volume;
right *= volume;
destWaveBuffer.FloatBuffer[outIndex++] = left;
destWaveBuffer.FloatBuffer[outIndex++] = right;
bytesWritten += 8;
if (Sample != null) RaiseSample(left, right);
}
}
// 3. Fill out with zeroes
if (PadWithZeroes && bytesWritten < numBytes)
{
Array.Clear(destBuffer, offset + bytesWritten, numBytes - bytesWritten);
bytesWritten = numBytes;
}
position += bytesWritten;
return bytesWritten;
}
}
///
/// If true, Read always returns the number of bytes requested
///
public bool PadWithZeroes { get; set; }
///
///
///
public override WaveFormat WaveFormat => waveFormat;
///
/// Volume of this channel. 1.0 = full scale
///
public float Volume
{
get { return volume; }
set { volume = value; }
}
///
/// Pan of this channel (from -1 to 1)
///
public float Pan
{
get { return pan; }
set { pan = value; }
}
///
/// Determines whether this channel has any data to play
/// to allow optimisation to not read, but bump position forward
///
public override bool HasData(int count)
{
// Check whether the source stream has data.
bool sourceHasData = sourceStream.HasData(count);
if (sourceHasData)
{
if (position + count < 0)
return false;
return (position < length) && (volume != 0);
}
return false;
}
///
/// Disposes this WaveStream
///
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (sourceStream != null)
{
sourceStream.Dispose();
sourceStream = null;
}
}
else
{
System.Diagnostics.Debug.Assert(false, "WaveChannel32 was not Disposed");
}
base.Dispose(disposing);
}
///
/// Sample
///
public event EventHandler Sample;
// reuse the same object every time to avoid making lots of work for the garbage collector
private SampleEventArgs sampleEventArgs = new SampleEventArgs(0,0);
///
/// Raise the sample event (no check for null because it has already been done)
///
private void RaiseSample(float left, float right)
{
sampleEventArgs.Left = left;
sampleEventArgs.Right = right;
Sample(this, sampleEventArgs);
}
}
}