//------------------------------------------------------------------------------------------------------------------------
        #endregion

        #region Constructor
        //------------------------------------------------------------------------------------------------------------------------
        public Speaker()
        {
            waveout = new WaveOut();
            bufferedWaveProvider = new BufferedWaveProvider(new WaveFormat(8000, 16, 2));
            waveout.PlaybackStopped += Waveout_PlaybackStopped;
            volumeProvider = new VolumeWaveProvider16(bufferedWaveProvider);
            waveout.Init(volumeProvider);
        }

        void StartEncoding()
        {
            _startTime = DateTime.Now;
            _bytesSent = 0;
            _segmentFrames = 960;
            _encoder = new OpusEncoder(48000, 1, OpusNet.OpusApplication.Voip);
            _encoder.Bitrate = 8192;
            _decoder = new OpusDecoder(48000, 1);
            _bytesPerSegment = _encoder.FrameByteCount(_segmentFrames);

            _waveIn = new WaveIn(WaveCallbackInfo.FunctionCallback());
            _waveIn.BufferMilliseconds = 50;
            _waveIn.DeviceNumber = comboBox1.SelectedIndex;
            _waveIn.DataAvailable += _waveIn_DataAvailable;
            _waveIn.WaveFormat = new WaveFormat(48000, 16, 1);

            _playBuffer = new BufferedWaveProvider(new WaveFormat(48000, 16, 1));

            _waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback());
            _waveOut.DeviceNumber = comboBox2.SelectedIndex;
            _waveOut.Init(_playBuffer);

            _waveOut.Play();
            _waveIn.StartRecording();

            if (_timer == null)
            {
                _timer = new Timer();
                _timer.Interval = 1000;
                _timer.Tick += _timer_Tick;
            }
            _timer.Start();
        }

 /// <summary>
 /// Create an input
 /// </summary>
 /// <param name="ID">The ID of the input to be created</param>
 public Input(string ID)
 {
     // Set the device ID
     deviceID = ID;
     // Get Device from specified ID
     MMDeviceEnumerator devices = new MMDeviceEnumerator();
     device = devices.GetDevice(ID);
     // Set wave in to WASAPI capture of the specified device
     waveIn = new WasapiCapture(device);
     // Set the number of bytes used by each sample
     sampleByteSize = waveIn.WaveFormat.BitsPerSample / 8;
     // Add event handler to retrieve samples from the device
     waveIn.DataAvailable += waveIn_DataAvailable;
     // Create buffered wave provider
     bufferedWaveProvider = new BufferedWaveProvider(waveIn.WaveFormat);
     bufferedWaveProvider.DiscardOnBufferOverflow = true;
     // Create sample channel
     sampleChannel = new SampleChannel(bufferedWaveProvider);
     // Create sample provider
     sampleChannel.PreVolumeMeter += sampleProvider_StreamVolume;
     // Start recording
     try
     {
         waveIn.StartRecording();
     }
     catch
     {
         throw new ArgumentException("This input device is not supported.");
     }
 }

        private WaveFormat _waveFormat = new WaveFormat(8000, 16, 1); // The format that both the input and output audio streams will use, i.e. PCMU.

        #endregion Fields

        #region Constructors

        public AudioChannel()
        {
            // Set up the device that will play the audio from the RTP received from the remote end of the call.
            m_waveOut = new WaveOut();
            m_waveProvider = new BufferedWaveProvider(_waveFormat);
            m_waveOut.Init(m_waveProvider);
            m_waveOut.Play();

            // Set up the input device that will provide audio samples that can be encoded, packaged into RTP and sent to
            // the remote end of the call.
            m_waveInEvent = new WaveInEvent();
            m_waveInEvent.BufferMilliseconds = 20;
            m_waveInEvent.NumberOfBuffers = 1;
            m_waveInEvent.DeviceNumber = 0;
            m_waveInEvent.DataAvailable += RTPChannelSampleAvailable;
            m_waveInEvent.WaveFormat = _waveFormat;

            // Create a UDP socket to use for sending and receiving RTP packets.
            int port = FreePort.FindNextAvailableUDPPort(DEFAULT_START_RTP_PORT);
            _rtpEndPoint = new IPEndPoint(_defaultLocalAddress, port);
            m_rtpChannel = new RTPChannel(_rtpEndPoint);
            m_rtpChannel.OnFrameReady += RTPChannelSampleReceived;

            _audioLogger.Debug("RTP channel endpoint " + _rtpEndPoint.ToString());
        }

        public void Start()
        {
            if (WaveIn.DeviceCount < 1)
                throw new Exception("Insufficient input device(s)!");

            if (WaveOut.DeviceCount < 1)
                throw new Exception("Insufficient output device(s)!");

            frame_size = toxav.CodecSettings.audio_sample_rate * toxav.CodecSettings.audio_frame_duration / 1000;

            toxav.PrepareTransmission(CallIndex, false);

            WaveFormat format = new WaveFormat((int)toxav.CodecSettings.audio_sample_rate, (int)toxav.CodecSettings.audio_channels);
            wave_provider = new BufferedWaveProvider(format);
            wave_provider.DiscardOnBufferOverflow = true;

            wave_out = new WaveOut();
            //wave_out.DeviceNumber = config["device_output"];
            wave_out.Init(wave_provider);

            wave_source = new WaveIn();
            //wave_source.DeviceNumber = config["device_input"];
            wave_source.WaveFormat = format;
            wave_source.DataAvailable += wave_source_DataAvailable;
            wave_source.RecordingStopped += wave_source_RecordingStopped;
            wave_source.BufferMilliseconds = (int)toxav.CodecSettings.audio_frame_duration;
            wave_source.StartRecording();

            wave_out.Play();
        }

 public AudioPlayer(DiscordVoiceConfig __config)
 {
     config = __config;
     callbackInfo = WaveCallbackInfo.FunctionCallback();
     outputDevice = new WaveOut(callbackInfo);
     bufferedWaveProvider = new BufferedWaveProvider(new WaveFormat(48000, 16, config.Channels));
 }

        private void PlayAudioFromConnection(TcpClient client)
        {
            var inputStream = new BufferedStream(client.GetStream());

            var bufferedWaveProvider = new BufferedWaveProvider(waveFormat);
            var savingWaveProvider = new SavingWaveProvider(bufferedWaveProvider, "temp.wav");

            var player = new WaveOut();
            player.Init(savingWaveProvider);
            player.Play();

            while (client.Connected)
            {
                if (terminate)
                {
                    client.Close();
                    break;
                }

                var available = client.Available;
                if (available > 0)
                {
                    var buffer = new byte[available];
                    var bytes = inputStream.Read(buffer, 0, buffer.Length);
                    bufferedWaveProvider.AddSamples(buffer, 0, bytes);
                    Console.WriteLine("{0} \t {1} bytes", client.Client.RemoteEndPoint, bytes);
                }
            }

            player.Stop();
            savingWaveProvider.Dispose();
        }

		public DirectSoundPlayer(INetworkChatCodec c)
			: base(c)
		{
			waveProvider = new BufferedWaveProvider(codec.RecordFormat);
			wavePlayer = new DirectSoundOut();
			wavePlayer.Init(waveProvider);
		}

        public void Initialise(WaveFormat format, WaveOut driver)
        {
            if (driver == null)
            {
                throw new ArgumentNullException("driver", "Must specify a WaveIn device instance");
            }

            if (format == null)
            {
                throw new ArgumentNullException("format", "Must specify an audio format");
            }

            var caps = WaveOut.GetCapabilities(driver.DeviceNumber);

            device = new WaveOutDeviceData
            {
                Driver = driver,
                Name = caps.ProductName,
                Channels = caps.Channels,
                Buffers = new float[caps.Channels][]
            };

            Format = WaveFormat.CreateIeeeFloatWaveFormat(format.SampleRate, caps.Channels);
            OutputBuffer = new BufferedWaveProvider(Format);
            OutputBuffer.DiscardOnBufferOverflow = true;

            driver.Init(OutputBuffer);

            mapOutputs();
        }

        private void Connect(IPEndPoint endPoint, int inputDeviceNumber, INetworkChatCodec codec)
        {
            waveIn = new WaveIn();
            waveIn.BufferMilliseconds = 50;
            waveIn.DeviceNumber = inputDeviceNumber;
            waveIn.WaveFormat = codec.RecordFormat;
            waveIn.DataAvailable += waveIn_DataAvailable;
            waveIn.StartRecording();

            udpSender = new UdpClient();
            udpListener = new UdpClient();

            // To allow us to talk to ourselves for test purposes:
            // http://stackoverflow.com/questions/687868/sending-and-receiving-udp-packets-between-two-programs-on-the-same-computer
            udpListener.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
            udpListener.Client.Bind(endPoint);

            udpSender.Connect(endPoint);

            waveOut = new WaveOut();
            waveProvider = new BufferedWaveProvider(codec.RecordFormat);
            waveOut.Init(waveProvider);
            waveOut.Play();

            connected = true;
            var state = new ListenerThreadState { Codec = codec, EndPoint = endPoint };
            ThreadPool.QueueUserWorkItem(ListenerThread, state);
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            byte[] apk, ask, bpk, bsk;
            NaClClient.CreateKeys(out apk, out ask);
            NaClClient.CreateKeys(out bpk, out bsk);

            var hasher = System.Security.Cryptography.SHA256.Create();

            _clientA = NaClClient.Create(apk, ask, bpk);
            _clientB = NaClClient.Create(bpk, bsk, apk);

            _sw = new Stopwatch();
            _sw.Start();

            _wave = new WaveIn(this.Handle);
            _wave.WaveFormat = new WaveFormat(12000, 8, 1);
            _wave.BufferMilliseconds = 100;
            _wave.DataAvailable += _wave_DataAvailable;
            _wave.StartRecording();

            _playback = new BufferedWaveProvider(_wave.WaveFormat);

            _waveOut = new WaveOut();
            _waveOut.DesiredLatency = 100;
            _waveOut.Init(_playback);
            _waveOut.Play();
        }

 public AudioRecorder(int microphone)
 {
     waveIn = new WaveIn();
     waveIn.DeviceNumber = microphone;
     waveIn.WaveFormat = new WaveFormat(44100, 1);
     bufferedWaveProvider = new BufferedWaveProvider(waveIn.WaveFormat);
     writer = new WaveFileWriter(Settings.Default.tempSoundLocation, waveIn.WaveFormat);
 }

 public HaltableBufferedWaveProvider(WaveFormat waveFormat)
 {
     _bufferedWaveProvider = new BufferedWaveProvider(waveFormat)
                             {
                                 DiscardOnBufferOverflow = true,
                                 BufferDuration = new TimeSpan(0, 10, 0)
                             };
 }

 public void EmptyBufferCanReturnZeroFromRead()
 {
     var bwp = new BufferedWaveProvider(new WaveFormat());
     bwp.ReadFully = false;
     var buffer = new byte[44100];
     var read = bwp.Read(buffer, 0, buffer.Length);
     Assert.AreEqual(0, read);
 }

 public void FullReadsByDefault()
 {
     var bwp = new BufferedWaveProvider(new WaveFormat());
     var buffer = new byte[44100];
     bwp.AddSamples(buffer, 0, 2000);
     var read = bwp.Read(buffer, 0, buffer.Length);
     Assert.AreEqual(buffer.Length, read);
     Assert.AreEqual(0, bwp.BufferedBytes);
 }

 public void WhenBufferHasMoreThanNeededReadFully()
 {
     var bwp = new BufferedWaveProvider(new WaveFormat());
     var buffer = new byte[44100];
     bwp.AddSamples(buffer, 0, 5000);
     var read = bwp.Read(buffer, 0, 2000);
     Assert.AreEqual(2000, read);
     Assert.AreEqual(3000, bwp.BufferedBytes);
 }

        /// <summary>
        /// Initializes the audio render provider.
        /// </summary>
        /// <param name="renderArgs">The arguments.</param>
        public override void Initialize(AudioRenderInitializeArgs renderArgs)
        {
            WaveProvider = new BufferedWaveProvider(new WaveFormat(ClockRate, 16, Channels));
            WaveProvider.DiscardOnBufferOverflow = true;
            WaveProvider.BufferDuration = new TimeSpan(0, 0, 0, 0, 250);

            InitializeWasapi();

            Log.Info("Audio render initialized using WASAPI.");
        }

 public void PartialReadsPossibleWithReadFullyFalse()
 {
     var bwp = new BufferedWaveProvider(new WaveFormat());
     bwp.ReadFully = false;
     var buffer = new byte[44100];
     bwp.AddSamples(buffer, 0, 2000);
     var read = bwp.Read(buffer, 0, buffer.Length);
     Assert.AreEqual(2000, read);
     Assert.AreEqual(0, bwp.BufferedBytes);
 }

        public void Init()
        {
            waveIn = new WaveInEvent();
            waveIn.BufferMilliseconds = 100;
            waveIn.DeviceNumber = -1;
            waveIn.WaveFormat = new WaveFormat(8000, 1);
            waveIn.DataAvailable += WaveIn_DataAvailable;

            waveOut = new WaveOut();
            waveOutProvider = new BufferedWaveProvider(waveIn.WaveFormat);
            waveOut.Init(waveOutProvider);
            waveOut.Play();
        }

 public void BufferedBytesAreReturned()
 {
     var bytesToBuffer = 1000;
     var bwp = new BufferedWaveProvider(new WaveFormat(44100, 16, 2));
     var data = Enumerable.Range(1, bytesToBuffer).Select(n => (byte)(n % 256)).ToArray();
     bwp.AddSamples(data, 0, data.Length);
     Assert.AreEqual(bytesToBuffer, bwp.BufferedBytes);
     var readBuffer = new byte[bytesToBuffer];
     var bytesRead = bwp.Read(readBuffer, 0, bytesToBuffer);
     Assert.AreEqual(bytesRead, bytesToBuffer);
     Assert.AreEqual(readBuffer,data);
     Assert.AreEqual(0, bwp.BufferedBytes);
 }