public void Base_Read_OneChannelToTwo()
{
var inputFormat = new AudioFormat();
var outputFormat = new AudioFormat(channels: 2);
var resampler = new ResampleFilter(inputFormat, outputFormat);
var inboundFrame = new short[inputFormat.SamplesPerFrame];
var outboundFrame = new short[outputFormat.SamplesPerFrame];
// Populate one channel
for (short i = 0; i < inputFormat.SamplesPerFrame; i++)
{
inboundFrame[i] = i;
}
var temp = new byte[Buffer.ByteLength(inboundFrame)];
Buffer.BlockCopy(inboundFrame, 0, temp, 0, temp.Length);
resampler.Write(temp);
bool moreFrames;
bool successful = resampler.Read(outboundFrame, out moreFrames);
Assert.IsTrue(successful);
Assert.IsFalse(moreFrames);
// We should have two channels worth of data back. Because we interpolate and smooth, it isn't a simple
// doubling of the original data, but some patterns can still be tested.
for (int i = 0; i < (inputFormat.SamplesPerFrame * 2) - 4; i++)
{
Assert.IsTrue(outboundFrame[i] <= outboundFrame[i + 4]);
}
}
public void Base_Read_TwoChannelsToOne()
{
var inputFormat = new AudioFormat(channels: 2);
var outputFormat = new AudioFormat();
var resampler = new ResampleFilter(inputFormat, outputFormat);
var inboundFrame = new short[inputFormat.SamplesPerFrame];
var outboundFrame = new short[outputFormat.SamplesPerFrame];
// Give both channels the same values.
int index = 0;
for (short i = 0; i < outputFormat.SamplesPerFrame; i++)
{
inboundFrame[index++] = i;
inboundFrame[index++] = i;
}
var temp = new byte[Buffer.ByteLength(inboundFrame)];
Buffer.BlockCopy(inboundFrame, 0, temp, 0, temp.Length);
resampler.Write(temp);
bool moreFrames;
bool successful = resampler.Read(outboundFrame, out moreFrames);
Assert.IsTrue(successful);
Assert.IsFalse(moreFrames);
// We should get just one channel's values back.
for (int i = 0; i < outputFormat.SamplesPerFrame; i++)
{
Assert.AreEqual(i, outboundFrame[i]);
}
}
public void Base_Read_96KhzTo16Khz_And_TwoChannelsToOne()
{
var inputFormat = new AudioFormat(96000, channels: 2);
var outputFormat = new AudioFormat();
var resampler = new ResampleFilter(inputFormat, outputFormat);
var inboundFrame = new short[inputFormat.SamplesPerFrame];
var outboundFrame = new short[outputFormat.SamplesPerFrame];
int index = 0;
for (short i = 0; i < inputFormat.SamplesPerFrame / inputFormat.Channels; i++)
{
inboundFrame[index++] = i;
inboundFrame[index++] = i;
}
var temp = new byte[Buffer.ByteLength(inboundFrame)];
Buffer.BlockCopy(inboundFrame, 0, temp, 0, temp.Length);
resampler.Write(temp);
bool moreFrames;
bool successful = resampler.Read(outboundFrame, out moreFrames);
Assert.IsTrue(successful);
Assert.IsFalse(moreFrames);
for (int i = 0; i < outputFormat.SamplesPerFrame; i++)
{
Assert.AreEqual(i * 6, outboundFrame[i]);
}
}
public void Base_Read_32KhzTo8Khz()
{
var inputFormat = new AudioFormat(32000);
var outputFormat = new AudioFormat(8000);
var resampler = new ResampleFilter(inputFormat, outputFormat);
var inboundFrame = new short[inputFormat.SamplesPerFrame];
var outboundFrame = new short[outputFormat.SamplesPerFrame];
for (short i = 0; i < inputFormat.SamplesPerFrame; i++)
{
inboundFrame[i] = i;
}
var temp = new byte[Buffer.ByteLength(inboundFrame)];
Buffer.BlockCopy(inboundFrame, 0, temp, 0, temp.Length);
resampler.Write(temp);
bool moreFrames;
bool successful = resampler.Read(outboundFrame, out moreFrames);
Assert.IsTrue(successful);
Assert.IsFalse(moreFrames);
for (int i = 0; i < outputFormat.SamplesPerFrame; i++)
{
Assert.AreEqual(i * 4, outboundFrame[i]);
}
}
public void Base_Read_44KhzTo16Khz_And_2048To640()
{
// This tests the scenario we run into on some Macs, where the amount of data submitted is always on 2048 byte boundaries.
// 44100 / 16000 = 2.75625
const int writeFrameSize = 1024; // in shorts
const int readFrameSize = 320; // in shorts
const int inboundFrameSize = (int)(readFrameSize * 2.75625); // = 882
const int frameCount = 100;
var inputFormat = new AudioFormat(44100);
var outputFormat = new AudioFormat();
var resampler = new ResampleFilter(inputFormat, outputFormat);
var inboundFrames = new short[inboundFrameSize * frameCount];
var outboundFrame = new byte[readFrameSize * sizeof(short)];
// Fill the inbound buffer.
for (short frame = 0; frame < frameCount; frame++)
{
for (int i = 0; i < inboundFrameSize; i++)
{
inboundFrames[frame * inboundFrameSize + i] = frame;
}
}
int index = 0;
short readFrame = 0;
while (index + writeFrameSize < inboundFrames.Length)
{
// Write data to the frame in 1024 sample/2048 byte chunks (we'll be reading from it in 320 sample chunks).
var tmpWrite = new byte[writeFrameSize * sizeof(short)];
Buffer.BlockCopy(inboundFrames, index * sizeof(short), tmpWrite, 0, writeFrameSize * sizeof(short));
resampler.Write(tmpWrite);
index += writeFrameSize;
bool moreFrames;
do
{
if (resampler.Read(outboundFrame, out moreFrames))
{
// Copy the byte array to a short array so we can check the values.
var tmpRead = new short[readFrameSize];
Buffer.BlockCopy(outboundFrame, 0, tmpRead, 0, readFrameSize * sizeof(short));
// There's some expected leakage around the ends of the buffers,
// so ignore the values there.
for (int i = 0; i < tmpRead.Length - (readFrame / 2); i++)
{
Assert.AreEqual(readFrame, tmpRead[i]);
}
readFrame++;
}
} while (moreFrames);
}
}
public void Base_Read_NoChanges()
{
var resampler = new ResampleFilter(AudioFormat.Default, AudioFormat.Default);
var inboundFrame = new byte[AudioFormat.Default.BytesPerFrame];
var outboundFrame = new byte[AudioFormat.Default.BytesPerFrame];
for (int i = 0; i < inboundFrame.Length; i++)
{
inboundFrame[i] = (byte)i;
}
resampler.Write(inboundFrame);
bool moreFrames;
bool successful = resampler.Read(outboundFrame, out moreFrames);
Assert.IsTrue(successful);
Assert.IsFalse(moreFrames);
for (int i = 0; i < AudioFormat.Default.BytesPerFrame; i++)
{
Assert.AreEqual(inboundFrame[i], outboundFrame[i]);
}
}