using System;
using NAudio.Dsp;
namespace NAudio.Wave
{
///
/// A simple compressor
///
public class SimpleCompressorStream : WaveStream
{
private WaveStream sourceStream;
private readonly SimpleCompressor simpleCompressor;
private byte[] sourceBuffer; // buffer used by Read function
private readonly int channels;
private readonly int bytesPerSample;
private readonly object lockObject = new object();
///
/// Create a new simple compressor stream
///
/// Source stream
public SimpleCompressorStream(WaveStream sourceStream)
{
this.sourceStream = sourceStream;
channels = sourceStream.WaveFormat.Channels;
bytesPerSample = sourceStream.WaveFormat.BitsPerSample / 8;
simpleCompressor = new SimpleCompressor(5.0, 10.0, sourceStream.WaveFormat.SampleRate);
simpleCompressor.Threshold = 16;
simpleCompressor.Ratio = 6;
simpleCompressor.MakeUpGain = 16;
}
///
/// Make-up Gain
///
public double MakeUpGain
{
get
{
return simpleCompressor.MakeUpGain;
}
set
{
lock (lockObject)
{
simpleCompressor.MakeUpGain = value;
}
}
}
///
/// Threshold
///
public double Threshold
{
get
{
return simpleCompressor.Threshold;
}
set
{
lock (lockObject)
{
simpleCompressor.Threshold = value;
}
}
}
///
/// Ratio
///
public double Ratio
{
get
{
return simpleCompressor.Ratio;
}
set
{
lock (lockObject)
{
simpleCompressor.Ratio = value;
}
}
}
///
/// Attack time
///
public double Attack
{
get
{
return simpleCompressor.Attack;
}
set
{
lock (lockObject)
{
simpleCompressor.Attack = value;
}
}
}
///
/// Release time
///
public double Release
{
get
{
return simpleCompressor.Release;
}
set
{
lock (lockObject)
{
simpleCompressor.Release = value;
}
}
}
///
/// Determine whether the stream has the required amount of data.
///
/// Number of bytes of data required from the stream.
/// Flag indicating whether the required amount of data is avialable.
public override bool HasData(int count)
{
return sourceStream.HasData(count);
}
///
/// Turns gain on or off
///
public bool Enabled { get; set; }
///
/// Returns the stream length
///
public override long Length => sourceStream.Length;
///
/// Gets or sets the current position in the stream
///
public override long Position
{
get
{
return sourceStream.Position;
}
set
{
lock (lockObject)
{
sourceStream.Position = value;
}
}
}
///
/// Gets the WaveFormat of this stream
///
public override WaveFormat WaveFormat => sourceStream.WaveFormat;
private void ReadSamples(byte[] buffer, int start, out double left, out double right)
{
if (bytesPerSample == 4)
{
left = BitConverter.ToSingle(buffer, start);
if (channels > 1)
{
right = BitConverter.ToSingle(buffer, start + bytesPerSample);
}
else
{
right = left;
}
}
else if (bytesPerSample == 2)
{
left = BitConverter.ToInt16(buffer, start) / 32768.0;
if (channels > 1)
{
right = BitConverter.ToInt16(buffer, start + bytesPerSample) / 32768.0;
}
else
{
right = left;
}
}
else
{
throw new InvalidOperationException(String.Format("Unsupported bytes per sample: {0}", bytesPerSample));
}
}
private void WriteSamples(byte[] buffer, int start, double left, double right)
{
if (bytesPerSample == 4)
{
Array.Copy(BitConverter.GetBytes((float)left), 0, buffer, start, bytesPerSample);
if (channels > 1)
{
Array.Copy(BitConverter.GetBytes((float)right), 0, buffer, start + bytesPerSample, bytesPerSample);
}
}
else if (bytesPerSample == 2)
{
Array.Copy(BitConverter.GetBytes((short)(left * 32768.0)), 0, buffer, start, bytesPerSample);
if (channels > 1)
{
Array.Copy(BitConverter.GetBytes((short)(right * 32768.0)), 0, buffer, start + bytesPerSample, bytesPerSample);
}
}
}
///
/// Reads bytes from this stream
///
/// Buffer to read into
/// Offset in array to read into
/// Number of bytes to read
/// Number of bytes read
public override int Read(byte[] array, int offset, int count)
{
lock (lockObject)
{
if (Enabled)
{
if (sourceBuffer == null || sourceBuffer.Length < count)
sourceBuffer = new byte[count];
int sourceBytesRead = sourceStream.Read(sourceBuffer, 0, count);
int sampleCount = sourceBytesRead / (bytesPerSample * channels);
for (int sample = 0; sample < sampleCount; sample++)
{
int start = sample * bytesPerSample * channels;
double in1;
double in2;
ReadSamples(sourceBuffer, start, out in1, out in2);
simpleCompressor.Process(ref in1, ref in2);
WriteSamples(array, offset + start, in1, in2);
}
return count;
}
else
{
return sourceStream.Read(array, offset, count);
}
}
}
///
/// Disposes this stream
///
/// true if the user called this
protected override void Dispose(bool disposing)
{
if (disposing)
{
// Release managed resources.
if (sourceStream != null)
{
sourceStream.Dispose();
sourceStream = null;
}
}
// Release unmanaged resources.
// Set large fields to null.
// Call Dispose on your base class.
base.Dispose(disposing);
}
///
/// Gets the block alignment for this stream
///
public override int BlockAlign
{
get
{
// TODO: investigate forcing 20ms
return sourceStream.BlockAlign;
}
}
}
}