public void ThrowsExceptionIfBitDepthsDiffer()
        {
            var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 2));
            var input2 = new TestWaveProvider(new WaveFormat(32000, 24, 1));

            Assert.Throws <ArgumentException>(() => new MultiplexingWaveProvider(new IWaveProvider[] { input1, input2 }, 1));
        }
        public void HasConnectInputToOutputMethod()
        {
            var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 2));
            var mp     = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 1);

            mp.ConnectInputToOutput(1, 0);
        }
Ejemplo n.º 3
0
        public void PassesThroughSourceWaveFormat()
        {
            var testProvider         = new TestWaveProvider(new WaveFormat(44100, 16, 2));
            VolumeWaveProvider16 vwp = new VolumeWaveProvider16(testProvider);

            Assert.AreSame(testProvider.WaveFormat, vwp.WaveFormat);
        }
        public void ConnectInputToOutputThrowsExceptionForInvalidOutput()
        {
            var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 2));
            var mp     = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 1);

            Assert.Throws <ArgumentException>(() => mp.ConnectInputToOutput(1, 1));
        }
Ejemplo n.º 5
0
        public void DefaultVolumeIs1()
        {
            var testProvider         = new TestWaveProvider(new WaveFormat(44100, 16, 2));
            VolumeWaveProvider16 vwp = new VolumeWaveProvider16(testProvider);

            Assert.AreEqual(1.0f, vwp.Volume);
        }
 public void CorrectOutputFormatIsSetForIeeeFloat()
 {
     var input1 = new TestWaveProvider(WaveFormat.CreateIeeeFloatWaveFormat(32000, 1));
     byte[] expected = new byte[] { 0, 1, 2, 3, 0, 1, 2, 3, 4, 5, 6, 7, 4, 5, 6, 7, 8, 9, 10, 11, 8, 9, 10, 11, };
     var mp = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 2);
     Assert.AreEqual(WaveFormatEncoding.IeeeFloat, mp.WaveFormat.Encoding);
 }
        public void PerformanceTest()
        {
            var waveFormat = new WaveFormat(32000, 16, 1);
            var input1     = new TestWaveProvider(waveFormat);
            var input2     = new TestWaveProvider(waveFormat);
            var input3     = new TestWaveProvider(waveFormat);
            var input4     = new TestWaveProvider(waveFormat);
            var mp         = new MultiplexingWaveProvider(new IWaveProvider[] { input1, input2, input3, input4 }, 4);

            mp.ConnectInputToOutput(0, 3);
            mp.ConnectInputToOutput(1, 2);
            mp.ConnectInputToOutput(2, 1);
            mp.ConnectInputToOutput(3, 0);

            byte[]    buffer   = new byte[waveFormat.AverageBytesPerSecond];
            Stopwatch s        = new Stopwatch();
            var       duration = s.Time(() =>
            {
                // read one hour worth of audio
                for (int n = 0; n < 60 * 60; n++)
                {
                    mp.Read(buffer, 0, buffer.Length);
                }
            });

            Console.WriteLine("Performance test took {0}ms", duration);
        }
 public void InputChannelCountIsCorrect()
 {
     var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 2));
     var input2 = new TestWaveProvider(new WaveFormat(32000, 16, 1));
     var mp = new MultiplexingWaveProvider(new IWaveProvider[] { input1, input2 }, 1);
     Assert.AreEqual(3, mp.InputChannelCount);
 }
        public void OutputChannelCountIsCorrect()
        {
            var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 1));
            var mp     = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 3);

            Assert.AreEqual(3, mp.OutputChannelCount);
        }
Ejemplo n.º 10
0
 public void PassesThroughDataUnchangedAtVolume1()
 {
     var testProvider= new TestWaveProvider(new WaveFormat(44100,16,2));
     VolumeWaveProvider16 vwp = new VolumeWaveProvider16(testProvider);
     byte[] buffer = new byte[20];
     int bytesRead = vwp.Read(buffer, 0, buffer.Length);
     Assert.AreEqual(buffer.Length, bytesRead);
     Assert.AreEqual(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 }, buffer);
 }
        public void CorrectOutputFormatIsSetForIeeeFloat()
        {
            var input1 = new TestWaveProvider(WaveFormat.CreateIeeeFloatWaveFormat(32000, 1));

            byte[] expected = new byte[] { 0, 1, 2, 3, 0, 1, 2, 3, 4, 5, 6, 7, 4, 5, 6, 7, 8, 9, 10, 11, 8, 9, 10, 11, };
            var    mp       = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 2);

            Assert.AreEqual(WaveFormatEncoding.IeeeFloat, mp.WaveFormat.Encoding);
        }
Ejemplo n.º 12
0
 public void HalfVolumeWorks()
 {
     var testProvider = new TestWaveProvider(new WaveFormat(44100, 16, 2));
     testProvider.ConstValue = 100;
     VolumeWaveProvider16 vwp = new VolumeWaveProvider16(testProvider);
     vwp.Volume = 0.5f;
     byte[] buffer = new byte[4];
     int bytesRead = vwp.Read(buffer, 0, buffer.Length);
     Assert.AreEqual(new byte[] { 50, 50, 50, 50 }, buffer);
 }
 public void OneInOneOutShouldCopyInReadMethod()
 {
     var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 1));
     byte[] expected = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
     var mp = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 1);
     byte[] buffer = new byte[10];
     var read = mp.Read(buffer, 0, 10);
     Assert.AreEqual(10, read);
     Assert.AreEqual(expected, buffer);
 }
 public void CorrectlyHandlesIeeeFloat()
 {
     var input1 = new TestWaveProvider(WaveFormat.CreateIeeeFloatWaveFormat(32000, 1));
     byte[] expected = new byte[] { 0, 1, 2, 3, 0, 1, 2, 3, 4, 5, 6, 7, 4, 5, 6, 7, 8, 9, 10, 11, 8, 9, 10, 11, };
     var mp = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 2);
     byte[] buffer = new byte[expected.Length];
     var read = mp.Read(buffer, 0, expected.Length);
     Assert.AreEqual(expected.Length, read);
     Assert.AreEqual(expected, buffer);
 }
 public void OneInTwoOutShouldConvertMonoToStereo()
 {
     var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 1));
     // 16 bit so left right pairs
     byte[] expected = new byte[] { 0, 1, 0, 1, 2, 3, 2, 3, 4, 5, 4, 5, 6, 7, 6, 7, 8, 9, 8, 9 };
     var mp = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 2);
     byte[] buffer = new byte[20];
     var read = mp.Read(buffer, 0, 20);
     Assert.AreEqual(20, read);
     Assert.AreEqual(expected, buffer);
 }
Ejemplo n.º 16
0
        public void PassesThroughDataUnchangedAtVolume1()
        {
            var testProvider         = new TestWaveProvider(new WaveFormat(44100, 16, 2));
            VolumeWaveProvider16 vwp = new VolumeWaveProvider16(testProvider);

            byte[] buffer    = new byte[20];
            int    bytesRead = vwp.Read(buffer, 0, buffer.Length);

            Assert.AreEqual(buffer.Length, bytesRead);
            Assert.AreEqual(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 }, buffer);
        }
        public void ReadReturnsZeroIfSingleInputHasReachedEnd()
        {
            var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 1), 0);

            byte[] expected = new byte[] { };
            var    mp       = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 1);

            byte[] buffer = new byte[10];
            var    read   = mp.Read(buffer, 0, 10);

            Assert.AreEqual(0, read);
        }
Ejemplo n.º 18
0
        public void ZeroVolumeWorks()
        {
            var testProvider = new TestWaveProvider(new WaveFormat(44100, 16, 2));

            testProvider.ConstValue = 100;
            VolumeWaveProvider16 vwp = new VolumeWaveProvider16(testProvider);

            vwp.Volume = 0f;
            byte[] buffer    = new byte[4];
            int    bytesRead = vwp.Read(buffer, 0, buffer.Length);

            Assert.AreEqual(new byte[] { 0, 0, 0, 0 }, buffer);
        }
Ejemplo n.º 19
0
        public void DoubleVolumeWorks()
        {
            var testProvider = new TestWaveProvider(new WaveFormat(44100, 16, 1));
            testProvider.ConstValue = 2;
            short sampleValue = BitConverter.ToInt16(new byte[] { 2, 2 }, 0);
            sampleValue = (short)(sampleValue * 2);

            VolumeWaveProvider16 vwp = new VolumeWaveProvider16(testProvider);
            vwp.Volume = 2f;
            byte[] buffer = new byte[2];
            int bytesRead = vwp.Read(buffer, 0, buffer.Length);
            Assert.AreEqual(BitConverter.GetBytes(sampleValue), buffer);
        }
        public void OneInOneOutShouldCopyInReadMethod()
        {
            var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 1));

            byte[] expected = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            var    mp       = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 1);

            byte[] buffer = new byte[10];
            var    read   = mp.Read(buffer, 0, 10);

            Assert.AreEqual(10, read);
            Assert.AreEqual(expected, buffer);
        }
Ejemplo n.º 21
0
        public void CorrectlyHandles24BitAudio()
        {
            var input1 = new TestWaveProvider(new WaveFormat(32000, 24, 1));

            byte[] expected = { 0, 1, 2, 0, 1, 2, 3, 4, 5, 3, 4, 5, 6, 7, 8, 6, 7, 8, 9, 10, 11, 9, 10, 11 };
            var    mp       = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 2);

            byte[] buffer = new byte[expected.Length];
            var    read   = mp.Read(buffer, 0, expected.Length);

            Assert.AreEqual(expected.Length, read);
            Assert.AreEqual(expected, buffer);
        }
        public void ReadReturnsCountIfOneInputHasEndedButTheOtherHasnt()
        {
            var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 1), 0);
            var input2 = new TestWaveProvider(new WaveFormat(32000, 16, 1));

            byte[] expected = new byte[] { };
            var    mp       = new MultiplexingWaveProvider(new IWaveProvider[] { input1, input2 }, 1);

            byte[] buffer = new byte[10];
            var    read   = mp.Read(buffer, 0, 10);

            Assert.AreEqual(10, read);
        }
        public void CorrectlyHandlesIeeeFloat()
        {
            var input1 = new TestWaveProvider(WaveFormat.CreateIeeeFloatWaveFormat(32000, 1));

            byte[] expected = new byte[] { 0, 1, 2, 3, 0, 1, 2, 3, 4, 5, 6, 7, 4, 5, 6, 7, 8, 9, 10, 11, 8, 9, 10, 11, };
            var    mp       = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 2);

            byte[] buffer = new byte[expected.Length];
            var    read   = mp.Read(buffer, 0, expected.Length);

            Assert.AreEqual(expected.Length, read);
            Assert.AreEqual(expected, buffer);
        }
        public void OneInTwoOutShouldConvertMonoToStereo()
        {
            var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 1));

            // 16 bit so left right pairs
            byte[] expected = new byte[] { 0, 1, 0, 1, 2, 3, 2, 3, 4, 5, 4, 5, 6, 7, 6, 7, 8, 9, 8, 9 };
            var    mp       = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 2);

            byte[] buffer = new byte[20];
            var    read   = mp.Read(buffer, 0, 20);

            Assert.AreEqual(20, read);
            Assert.AreEqual(expected, buffer);
        }
        public void TwoInOneOutShouldSelectLeftChannel()
        {
            var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 2));

            // 16 bit so left right pairs
            byte[] expected = new byte[] { 0, 1, 4, 5, 8, 9, 12, 13, 16, 17 };
            var    mp       = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 1);

            byte[] buffer = new byte[10];
            var    read   = mp.Read(buffer, 0, 10);

            Assert.AreEqual(10, read);
            Assert.AreEqual(expected, buffer);
        }
        public void StereoInTwoOutShouldCopyStereo()
        {
            var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 2));

            // 4 bytes per pair of samples
            byte[] expected = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
            var    mp       = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 2);

            byte[] buffer = new byte[12];
            var    read   = mp.Read(buffer, 0, 12);

            Assert.AreEqual(12, read);
            Assert.AreEqual(expected, buffer);
        }
        public void TwoInOneOutShouldCanBeConfiguredToSelectRightChannel()
        {
            var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 2));

            // 16 bit so left right pairs
            byte[] expected = new byte[] { 2, 3, 6, 7, 10, 11, 14, 15, 18, 19 };
            var    mp       = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 1);

            mp.ConnectInputToOutput(1, 0);
            byte[] buffer = new byte[10];
            var    read   = mp.Read(buffer, 0, 10);

            Assert.AreEqual(10, read);
            Assert.AreEqual(expected, buffer);
        }
Ejemplo n.º 28
0
        public void SingleInputConstructorUsesTotalOfInputChannels()
        {
            var input1 = new TestWaveProvider(new WaveFormat(32000, 8, 2));
            var input2 = new TestWaveProvider(new WaveFormat(32000, 8, 1));

            byte[] expected = { 0, 1, 0, 2, 3, 1, 4, 5, 2 };
            var    mp       = new MultiplexingWaveProvider(new IWaveProvider[] { input1, input2 });

            Assert.AreEqual(3, mp.WaveFormat.Channels);
            byte[] buffer = new byte[9];
            var    read   = mp.Read(buffer, 0, 9);

            Assert.AreEqual(9, read);
            Assert.AreEqual(buffer, expected);
        }
        public void StereoInTwoOutCanBeConfiguredToSwapLeftAndRight()
        {
            var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 2));

            // 4 bytes per pair of samples
            byte[] expected = new byte[] { 2, 3, 0, 1, 6, 7, 4, 5, 10, 11, 8, 9, };
            var    mp       = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 2);

            mp.ConnectInputToOutput(0, 1);
            mp.ConnectInputToOutput(1, 0);
            byte[] buffer = new byte[12];
            var    read   = mp.Read(buffer, 0, 12);

            Assert.AreEqual(12, read);
            Assert.AreEqual(expected, buffer);
        }
Ejemplo n.º 30
0
        public void DoubleVolumeClips()
        {
            var testProvider = new TestWaveProvider(new WaveFormat(44100, 16, 1));

            testProvider.ConstValue = 100;
            short sampleValue = BitConverter.ToInt16(new byte[] { 100, 100 }, 0);

            sampleValue = Int16.MaxValue;

            VolumeWaveProvider16 vwp = new VolumeWaveProvider16(testProvider);

            vwp.Volume = 2f;
            byte[] buffer    = new byte[2];
            int    bytesRead = vwp.Read(buffer, 0, buffer.Length);

            Assert.AreEqual(BitConverter.GetBytes(sampleValue), buffer);
        }
        public void ShouldZeroOutBufferIfInputStopsShort()
        {
            var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 1), 6);

            byte[] expected = new byte[] { 0, 1, 2, 3, 4, 5, 0, 0, 0, 0 };
            var    mp       = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 1);

            byte[] buffer = new byte[10];
            for (int n = 0; n < buffer.Length; n++)
            {
                buffer[n] = 0xFF;
            }
            var read = mp.Read(buffer, 0, buffer.Length);

            Assert.AreEqual(6, read);
            Assert.AreEqual(expected, buffer);
        }
        public void TwoMonoInTwoOutShouldCreateStereo()
        {
            var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 1));
            var input2 = new TestWaveProvider(new WaveFormat(32000, 16, 1))
            {
                Position = 100
            };

            // 4 bytes per pair of samples
            byte[] expected = new byte[] { 0, 1, 100, 101, 2, 3, 102, 103, 4, 5, 104, 105, };
            var    mp       = new MultiplexingWaveProvider(new IWaveProvider[] { input1, input2 }, 2);

            byte[] buffer = new byte[expected.Length];
            var    read   = mp.Read(buffer, 0, expected.Length);

            Assert.AreEqual(expected.Length, read);
            Assert.AreEqual(expected, buffer);
        }
 public void ThrowsExceptionIfBitDepthsDiffer()
 {
     var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 2));
     var input2 = new TestWaveProvider(new WaveFormat(32000, 24, 1));
     Assert.Throws<ArgumentException>(() => new MultiplexingWaveProvider(new IWaveProvider[] { input1, input2 }, 1));
 }
 public void TwoInOneOutShouldCanBeConfiguredToSelectRightChannel()
 {
     var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 2));
     // 16 bit so left right pairs
     byte[] expected = new byte[] { 2, 3, 6, 7, 10, 11, 14, 15, 18, 19 };
     var mp = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 1);
     mp.ConnectInputToOutput(1, 0);
     byte[] buffer = new byte[10];
     var read = mp.Read(buffer, 0, 10);
     Assert.AreEqual(10, read);
     Assert.AreEqual(expected, buffer);
 }
 public void StereoInTwoOutShouldCopyStereo()
 {
     var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 2));
     // 4 bytes per pair of samples
     byte[] expected = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
     var mp = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 2);
     byte[] buffer = new byte[12];
     var read = mp.Read(buffer, 0, 12);
     Assert.AreEqual(12, read);
     Assert.AreEqual(expected, buffer);
 }
 public void TwoMonoInTwoOutShouldCreateStereo()
 {
     var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 1));
     var input2 = new TestWaveProvider(new WaveFormat(32000, 16, 1)) { Position = 100 };
     // 4 bytes per pair of samples
     byte[] expected = new byte[] { 0, 1, 100, 101, 2, 3, 102, 103, 4, 5, 104, 105, };
     var mp = new MultiplexingWaveProvider(new IWaveProvider[] { input1, input2 }, 2);
     byte[] buffer = new byte[expected.Length];
     var read = mp.Read(buffer, 0, expected.Length);
     Assert.AreEqual(expected.Length, read);
     Assert.AreEqual(expected, buffer);
 }
 public void StereoInTwoOutCanBeConfiguredToSwapLeftAndRight()
 {
     var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 2));
     // 4 bytes per pair of samples
     byte[] expected = new byte[] { 2, 3, 0, 1, 6, 7, 4, 5, 10, 11, 8, 9, };
     var mp = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 2);
     mp.ConnectInputToOutput(0, 1);
     mp.ConnectInputToOutput(1, 0);
     byte[] buffer = new byte[12];
     var read = mp.Read(buffer, 0, 12);
     Assert.AreEqual(12, read);
     Assert.AreEqual(expected, buffer);
 }
Ejemplo n.º 38
0
 public void PassesThroughSourceWaveFormat()
 {
     var testProvider = new TestWaveProvider(new WaveFormat(44100, 16, 2));
     VolumeWaveProvider16 vwp = new VolumeWaveProvider16(testProvider);
     Assert.AreSame(testProvider.WaveFormat, vwp.WaveFormat);
 }
 public void HasConnectInputToOutputMethod()
 {
     var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 2));
     var mp = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 1);
     mp.ConnectInputToOutput(1, 0);
 }
 public void ConnectInputToOutputThrowsExceptionForInvalidOutput()
 {
     var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 2));
     var mp = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 1);
     Assert.Throws<ArgumentException>(() => mp.ConnectInputToOutput(1, 1));
 }
Ejemplo n.º 41
0
 public void DefaultVolumeIs1()
 {
     var testProvider = new TestWaveProvider(new WaveFormat(44100, 16, 2));
     VolumeWaveProvider16 vwp = new VolumeWaveProvider16(testProvider);
     Assert.AreEqual(1.0f, vwp.Volume);
 }
 public void ReadReturnsZeroIfSingleInputHasReachedEnd()
 {
     var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 1), 0);
     byte[] expected = new byte[] { };
     var mp = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 1);
     byte[] buffer = new byte[10];
     var read = mp.Read(buffer, 0, 10);
     Assert.AreEqual(0, read);
 }
 public void ReadReturnsCountIfOneInputHasEndedButTheOtherHasnt()
 {
     var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 1), 0);
     var input2 = new TestWaveProvider(new WaveFormat(32000, 16, 1));
     byte[] expected = new byte[] { };
     var mp = new MultiplexingWaveProvider(new IWaveProvider[] { input1, input2 }, 1);
     byte[] buffer = new byte[10];
     var read = mp.Read(buffer, 0, 10);
     Assert.AreEqual(10, read);
 }
 public void ShouldZeroOutBufferIfInputStopsShort()
 {
     var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 1), 6);
     byte[] expected = new byte[] { 0, 1, 2, 3, 4, 5, 0, 0, 0, 0 };
     var mp = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 1);
     byte[] buffer = new byte[10];
     for (int n = 0; n < buffer.Length; n++)
     {
         buffer[n] = 0xFF;
     }
     var read = mp.Read(buffer, 0, buffer.Length);
     Assert.AreEqual(6, read);
     Assert.AreEqual(expected, buffer);
 }
        public void PerformanceTest()
        {
            var waveFormat = new WaveFormat(32000, 16, 1);
            var input1 = new TestWaveProvider(waveFormat);
            var input2 = new TestWaveProvider(waveFormat);
            var input3 = new TestWaveProvider(waveFormat);
            var input4 = new TestWaveProvider(waveFormat);
            var mp = new MultiplexingWaveProvider(new IWaveProvider[] { input1, input2, input3, input4 }, 4);
            mp.ConnectInputToOutput(0, 3);
            mp.ConnectInputToOutput(1, 2);
            mp.ConnectInputToOutput(2, 1);
            mp.ConnectInputToOutput(3, 0);

            byte[] buffer = new byte[waveFormat.AverageBytesPerSecond];
            Stopwatch s = new Stopwatch();
            var duration = s.Time(() =>
            {
                // read one hour worth of audio
                for (int n = 0; n < 60 * 60; n++)
                {
                    mp.Read(buffer, 0, buffer.Length);
                }
            });
            Console.WriteLine("Performance test took {0}ms", duration);
        }
 public void TwoInOneOutShouldSelectLeftChannel()
 {
     var input1 = new TestWaveProvider(new WaveFormat(32000, 16, 2));
     // 16 bit so left right pairs
     byte[] expected = new byte[] { 0, 1, 4, 5, 8, 9, 12, 13, 16, 17 };
     var mp = new MultiplexingWaveProvider(new IWaveProvider[] { input1 }, 1);
     byte[] buffer = new byte[10];
     var read = mp.Read(buffer, 0, 10);
     Assert.AreEqual(10, read);
     Assert.AreEqual(expected, buffer);
 }