Воспроизведение аудио-потока (массива байтов)

    class SoundStream : Stream
    {
        private long length;
        private long position;
        private ConcurrentQueue<byte> sampleQueue;
        private AutoResetEvent dataAvailableSignaler = new AutoResetEvent(false);
        private int preloadSize = 2000;
 
        public SoundStream(int sampleRate = 8000)
        {
            length = int.MaxValue / 2 - 36;
            position = 0;
 
            //add wav header with too big length (near 70 hours for sample rate 8000)
            sampleQueue = new ConcurrentQueue<byte>(BuildWavHeader((int)length, sampleRate));
        }
 
        /// <summary>
        /// Write audio samples into stream
        /// </summary>
        public void Write(IEnumerable<short> samples)
        {
            //write samples to sample queue
            foreach (var sample in samples)
            {
                sampleQueue.Enqueue((byte)(sample & 0xFF));
                sampleQueue.Enqueue((byte)(sample >> 8));
            }
 
            //send signal to Read method
            if (sampleQueue.Count >= preloadSize)
                dataAvailableSignaler.Set();
        }
 
        /// <summary>
        /// Count of unread bytes in buffer
        /// </summary>
        public int Buffered
        {
            get { return sampleQueue.Count; }
        }
 
        /// <summary>
        /// Read
        /// </summary>
        public override int Read(byte[] buffer, int offset, int count)
        {
            if (position >= length)
                return 0;
 
            //wait while data will be available
            if (sampleQueue.Count < preloadSize)
                dataAvailableSignaler.WaitOne();
 
            var res = 0;
 
            //copy data from incoming queue to output buffer
            while (count > 0 && sampleQueue.Count > 0)
            {
                byte b;
                if (!sampleQueue.TryDequeue(out b)) return 0;
                buffer[offset + res] = b;
                count--;
                res++;
                position++;
            }
 
            return res;
        }
 
        #region WAV header
 
        public static byte[] BuildWavHeader(int samplesCount, int sampleRate = 8000)
        {
            using (var stream = new MemoryStream())
            {
                var writer = new BinaryWriter(stream);
                short frameSize = (short)(16 / 8);
                writer.Write(0x46464952);
                writer.Write(36 + samplesCount * frameSize);
                writer.Write(0x45564157);
                writer.Write(0x20746D66);
                writer.Write(16);
                writer.Write((short)1);
                writer.Write((short)1);
                writer.Write(sampleRate);
                writer.Write(sampleRate * frameSize);
                writer.Write(frameSize);
                writer.Write((short)16);
                writer.Write(0x61746164);
                writer.Write(samplesCount * frameSize);
                return stream.ToArray();
            }
        }
 
        #endregion
 
        #region Stream impl
 
        public override bool CanRead
        {
            get { return true; }
        }
 
        public override bool CanSeek
        {
            get { return false; }
        }
 
        public override bool CanWrite
        {
            get { return false; }
        }
 
        public override void Flush()
        {
            throw new NotImplementedException();
        }
 
        public override long Length
        {
            get { return length; }
        }
 
        public override long Position
        {
            get { return position; }
            set { ;}
        }
 
        public override long Seek(long offset, SeekOrigin origin)
        {
            throw new NotImplementedException();
        }
 
        public override void SetLength(long value)
        {
            throw new NotImplementedException();
        }
 
        public override void Write(byte[] buffer, int offset, int count)
        {
            throw new NotImplementedException();
        }
        #endregion
    }

    public class StreamPlayer : IDisposable
    {
        private SoundStream stream;
        private WaveOutEvent waveOut;
        private WaveFileReader reader;
 
        public StreamPlayer(int sampleRate = 8000)
        {
            stream = new SoundStream(sampleRate);
            waveOut = new WaveOutEvent();
        }
 
        /// <summary>
        /// Write audio samples into stream
        /// </summary>
        public void Write(params short[] samples)
        {
            stream.Write(samples);
        }
 
        /// <summary>
        /// Write audio samples into stream
        /// </summary>
        public void Write(IEnumerable<short> samples)
        {
            stream.Write(samples);
        }
 
        /// <summary>
        /// Plays sound
        /// </summary>
        public void PlayAsync()
        {
            ThreadPool.QueueUserWorkItem((_) =>
            {
                reader = new WaveFileReader(stream);
                waveOut.Init(reader);
                waveOut.Play();
            });
        }
 
        /// <summary>
        /// Stop playing
        /// </summary>
        public void Stop()
        {
            waveOut.Stop();
        }
 
        /// <summary>
        /// Volume
        /// </summary>
        public float Volume
        {
            get { return waveOut.Volume; }
            set { waveOut.Volume = value; }
        }
 
        /// <summary>
        /// Count of unread bytes in buffer
        /// </summary>
        public int Buffered
        {
            get { return stream.Buffered; }
        }
 
        public void Dispose()
        {
            waveOut.Dispose();
            reader.Dispose();
            stream.Dispose();
        }
    }

        static void Main(string[] args)
        {
            Random rnd = new Random();
 
            //создаем плеер и начинаем воспроизведение
            var player = new StreamPlayer();
            player.PlayAsync();
 
            //бесконечно пишем звук
            while (true)
            {
                //случайная частота
                var freq = 0.01*rnd.Next(10);
                //пишем синусоидальный звук в плеер
                for (int i = 0; i < 8000; i++)
                {
                    var v = (short) (Math.Sin(freq * i * Math.PI * 2)*short.MaxValue);
                    player.Write(v);
                }
                Console.WriteLine("freq {0:0.00}", freq);
                //отдыхаем секунду
                Thread.Sleep(990);
            };
        }

        private BinaryWriter sw;
        private BinaryReader sr;
        public WaveInEvent waveSource;
        private MemoryStream memstr;
        private int testoffset = 0;
 
        private StreamPlayer player;
 
        public void BeginTranslation() //Выполняется один раз при установлении связи с абонентом
        {
            waveSource = new WaveInEvent();
            waveSource.WaveFormat = new WaveFormat(8000, 16, 1);
 
            memstr = new MemoryStream();
            sw = new BinaryWriter(memstr);
            sr = new BinaryReader(memstr);
            
            waveSource.DataAvailable += new EventHandler<WaveInEventArgs>(waveSource_DataAvailable);
            waveSource.RecordingStopped += new EventHandler<StoppedEventArgs>(waveSource_RecordingStopped); //Его расписывать не буду, там все понятно.
 
            waveSource.StartRecording();
            
            player = new StreamPlayer();
            player.PlayAsync();
        }
 
        void waveSource_DataAvailable(object sender, WaveInEventArgs e)
        {
            //Пишем голос с микрофона в поток
            sw.Write(e.Buffer);
            sw.Flush();
        }
 
        //Метод выполняется автоматически для передачи голоса абонента с которым установлена связь
        public void PortVoiceRecieced(object sender, SerialDataReceivedEventArgs serialDataReceivedEventArgs)
        {
            //Получаем данные
            int x = connector.port.BytesToRead;
            buffer = new byte[x];
            connector.port.Read(buffer, 0, x);
 
            //Проиграть входящий звук в колонки (наушники)
            player.Write(buffer.AsEnumerable());
 
            //Двигаем позицию
            memstr.Position = testoffset;
 
            //Передать блок исходящего голоса
            byte[] bt = new byte[320];
            bt = sr.ReadBytes(320);
            if (bt.Length != 0)
            {
                connector.port.Write(bt, 0, bt.Length);
                testoffset += bt.Length;
            }
        }

        public void BeginTranslationWaveFile()
        {
            FileStream strm = new FileStream(@"Test0001.wav", System.IO.FileMode.Open); //Вместе с заголовком? Странно, но работает! 
            BinaryReader rdr = new BinaryReader(strm);
            while (true)
            {
                byte[] bt = new byte[320];
                bt = rdr.ReadBytes(320);
                if (bt.Length == 0)
                {
                    break;
                }
                connector.port.Write(bt, 0, bt.Length);
                Thread.Sleep(20);
            }
            strm.Close();
            strm.Dispose();
 
            MessageBox.Show("Воспроизведение голоса окончено!");
        }