Запись звука с микрофона

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using Microsoft.DirectX;
using Microsoft.DirectX.DirectSound;
using Buffer = Microsoft.DirectX.DirectSound.Buffer;
using System.IO; 
 
 
namespace DirectSound_
{
    public partial class Form1 : Form
    {
        Device device;
        Capture capture;
        Buffer buffer;
        BufferDescription bufferDesc;
        CaptureBuffer captureBuffer;
        WaveFormat waveFormat;
        CaptureBufferDescription captureBuffDesc;
        MemoryStream stream;
        byte[] streamBuffer; 
 
        public Form1()
        {
            InitializeComponent();
            
            device = new Device(); // Setup DirectSound 
 
            waveFormat = new WaveFormat();// Load the sound 
            waveFormat.BitsPerSample = 8;
            waveFormat.BlockAlign = 1;
            waveFormat.Channels = 1;
            waveFormat.AverageBytesPerSecond = 20500;
            waveFormat.SamplesPerSecond = 20500;
            waveFormat.FormatTag = WaveFormatTag.Pcm;
 
            bufferDesc = new BufferDescription();
            bufferDesc.Format = waveFormat;
            bufferDesc.BufferBytes = 100000;
            bufferDesc.ControlPositionNotify = true;
            bufferDesc.ControlFrequency = true;
            bufferDesc.ControlPan = true;
            bufferDesc.ControlVolume = true;
 
            buffer = new Buffer(bufferDesc, this.device);
 
            device.SetCooperativeLevel(this, CooperativeLevel.Priority); // Set the cooperative level 
 
            capture = new Capture();
            
            captureBuffDesc = new CaptureBufferDescription();
            captureBuffDesc.BufferBytes = 100000;
            captureBuffDesc.Format = this.waveFormat;
 
            captureBuffer = new CaptureBuffer(captureBuffDesc, capture);
            
            streamBuffer = new byte[100000];
            
            
            for (int i = 0; i < 100000; i++)
            {
                
                streamBuffer[i] = 0;
            }
            stream = new MemoryStream(streamBuffer); 
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
            this.captureBuffer.Read(0, this.stream, 100000, LockFlag.None);
            buffer.Write(0, this.stream, (int)this.stream.Length, LockFlag.EntireBuffer);
            buffer.Play(0, BufferPlayFlags.Looping); 
        }
 
        private void button2_Click(object sender, EventArgs e)
        {
            buffer.Stop(); 
        }
 
        private void button3_Click(object sender, EventArgs e)
        {
            this.captureBuffer.Start(true); 
        }
 
        private void button4_Click(object sender, EventArgs e)
        {
            this.captureBuffer.Stop(); 
        }
        
 
 
    }
}

using System;
using System.Threading;
using System.IO;
using Microsoft.DirectX.DirectSound;
using Buffer = Microsoft.DirectX.DirectSound.Buffer;
 
namespace Remi
{
    static class RecordPlay
    {
 
        private static WaveFormat _waveFormat;
        public static WaveFormat waveFormat
        {
            get
            {
                return _waveFormat;
            }
        }
        private static UInt16 sizeBufer = 44100;
        private static MemoryStream stream;
        private static MemoryStream tempStream;
        public static int Length { get { return (int)stream.Length; } }
        public static byte[] Data
        {
            get
            {
                switch (regim)
                {
                    case 0: break;
                    case 1: RecordStop(); break;
                    case 2: PlayStop(); break;
                }
                return stream.ToArray();
            }
        }
        private static byte regim = 0;
        ////////////////////////////////////////////////
        private static Capture capture;
        private static CaptureBufferDescription captureBuffDesc;
        private static CaptureBuffer recordBuff;
 
        private static AutoResetEvent autoResetEventRec;
        private static BufferPositionNotify[] positionNotifyRec;
        private static Notify notifyRec;
 
        private static Thread threadRec;
        ///////////////////////////////////////////////
        private static Device device;
        private static Buffer playBuff;
        private static BufferDescription secondBuffDesc;
 
        private static System.Windows.Forms.Control control=null;
        private static Thread threadPlay;
 
        private static AutoResetEvent autoResetEventPlay;
        private static BufferPositionNotify[] positionNotifyPlay;
        private static Notify notifyPlay;
 
        ///////////////////////////////////////////////
 
        public static void Create(System.Windows.Forms.Control _control)
        {
            control = _control;
            SetWaveFormat();
            SetTempStream();
            SetPlayBuff();
            SetRecordBuff();
            SetNotifyPlay();
            SetNotifyRecord();
        }
        private static void SetTempStream()
        {
            ushort i, n = (ushort)(sizeBufer);
            byte[] temp = new byte[n];
            if (_waveFormat.BitsPerSample == 8)
            {
                for (i = 0; i < n; i++) temp[i] = 127;
                tempStream = new MemoryStream(temp);
                return;
            }
            if (_waveFormat.BitsPerSample == 16)
            {
                for (i = 0; i < n; i++) temp[i] = 0;
                tempStream = new MemoryStream(temp);
                return;
            }
        }
        private static void SetWaveFormat()
        {
            _waveFormat = new WaveFormat();
            _waveFormat.BitsPerSample = 8;
            _waveFormat.BlockAlign = 1;
            _waveFormat.Channels = 1;
            _waveFormat.AverageBytesPerSecond = 22050;
            _waveFormat.SamplesPerSecond = 22050;
            _waveFormat.FormatTag = WaveFormatTag.Pcm;
        }
        private static void SetRecordBuff()
        {
            capture = new Capture();
            captureBuffDesc = new CaptureBufferDescription();
            captureBuffDesc.BufferBytes = sizeBufer;
            captureBuffDesc.Format = _waveFormat;
            recordBuff = new CaptureBuffer(captureBuffDesc, capture);
        }
        private static void SetNotifyRecord()
        {
            autoResetEventRec = new AutoResetEvent(false);
            positionNotifyRec = new BufferPositionNotify[2];
            positionNotifyRec[0].Offset = sizeBufer / 2 - 1;
            positionNotifyRec[0].EventNotifyHandle = autoResetEventRec.SafeWaitHandle.DangerousGetHandle();
            positionNotifyRec[1].Offset = sizeBufer - 1;
            positionNotifyRec[1].EventNotifyHandle = autoResetEventRec.SafeWaitHandle.DangerousGetHandle();
            notifyRec = new Notify(recordBuff);
            notifyRec.SetNotificationPositions(positionNotifyRec, 2);
        }
        private static void Recording()
        {
            int offset = 0;
            int a, b;
            recordBuff.GetCurrentPosition(out a, out b);
            if (a == 0) { offset = sizeBufer / 2; b = sizeBufer / 2; }
            else if (a < sizeBufer / 2) { offset = sizeBufer / 2; b = sizeBufer / 2 - a; }
            else { offset = 0; b = sizeBufer - a; }
 
 
 
            recordBuff.Start(true);
            autoResetEventRec.WaitOne(Timeout.Infinite, true);
            recordBuff.Read(a, stream, b, LockFlag.None);
            for (; ; )
            {
                autoResetEventRec.WaitOne(Timeout.Infinite, true);
                recordBuff.Read(offset, stream, sizeBufer / 2, LockFlag.None);
                offset = (offset + sizeBufer / 2) % (sizeBufer);
            }
        }
        private static void RecordStart()
        {
            switch (regim)
            {
                case 0:  break;
                case 1: RecordStop(); break;
                case 2: PlayStop(); break;
            }
            regim = 1;
            stream = new MemoryStream();
            threadRec = new Thread(new ThreadStart(Recording));
            threadRec.Start();
        }
        private static void RecordStop()
        {
            if (regim != 1) return;  
            int a, b;
            
            threadRec.Abort();
            recordBuff.Stop();
            recordBuff.GetCurrentPosition(out a, out b);
 
            if (a == sizeBufer / 2 || a == sizeBufer) { regim = 0; return; }
 
            if (a < sizeBufer / 2)
            {
                recordBuff.Read(0, stream, a, LockFlag.None);
            }
            else
            {
                recordBuff.Read(sizeBufer / 2, stream, a - sizeBufer / 2, LockFlag.None);
            }      
            regim = 0;
        }
        private static void SetPlayBuff()
        {
            device = new Device();
            device.SetCooperativeLevel(control, CooperativeLevel.Priority);
            secondBuffDesc = new BufferDescription();
            secondBuffDesc.Format = _waveFormat;
            secondBuffDesc.BufferBytes = sizeBufer;
            secondBuffDesc.LocateInSoftware = true;
            secondBuffDesc.ControlPositionNotify = true;
            secondBuffDesc.ControlFrequency = true;
            secondBuffDesc.ControlPan = true;
            secondBuffDesc.ControlVolume = true;          
            playBuff = new Buffer(secondBuffDesc, device);
 
        }
        private static void SetNotifyPlay()
        {        
                autoResetEventPlay = new AutoResetEvent(false);
                positionNotifyPlay = new BufferPositionNotify[2];
                positionNotifyPlay[0].Offset = sizeBufer / 2 - 1;
                positionNotifyPlay[0].EventNotifyHandle = autoResetEventPlay.SafeWaitHandle.DangerousGetHandle();
                positionNotifyPlay[1].Offset = sizeBufer - 1;
                positionNotifyPlay[1].EventNotifyHandle = autoResetEventPlay.SafeWaitHandle.DangerousGetHandle();
                notifyPlay = new Notify(playBuff);
                notifyPlay.SetNotificationPositions(positionNotifyPlay, 2);
        }
        private static void Playing()
        {
 
            uint i, num = (uint)(stream.Length / (sizeBufer / 2));
            int offset, ostatok = (int)stream.Length % (sizeBufer / 2);
 
            if (num < 2)
            {
                playBuff.Write(0, stream, (int)stream.Length, LockFlag.None);
                playBuff.Write((int)stream.Length, tempStream, sizeBufer - (int)stream.Length, LockFlag.None);
                playBuff.Play(0, BufferPlayFlags.Default);
                return;
            }
 
            playBuff.Write(0, stream, sizeBufer, LockFlag.None);
            playBuff.Play(0, BufferPlayFlags.Looping);
            autoResetEventPlay.WaitOne(Timeout.Infinite, true);
            for (offset = 0, i = 2; i <= num; i++)
            {   
                if (i != num)
                {
                    playBuff.Write(offset, stream, sizeBufer / 2, LockFlag.None);     
                }
                else
                {
                    playBuff.Write(offset, stream, ostatok, LockFlag.None);
                    playBuff.Write(offset + ostatok, tempStream, sizeBufer / 2 - ostatok, LockFlag.None);
                }
                offset = (offset + sizeBufer / 2) % sizeBufer;
                autoResetEventPlay.WaitOne(Timeout.Infinite, true);
            }
            autoResetEventPlay.WaitOne(Timeout.Infinite, true);
            playBuff.Stop();
            regim = 0;
        }
        private static void PlayStart()
        {
            switch (regim)
            {
                case 0: break;
                case 1: RecordStop(); break;
                case 2: PlayStop(); break;
            }
            regim = 2;
            stream.Position = 0;
            playBuff.SetCurrentPosition(0);
            tempStream.Position = 0;
            threadPlay = new Thread(new ThreadStart(Playing));
            threadPlay.Start();
        }
        private static void PlayStop()
        {
            if (regim == 2)
            {
                threadPlay.Abort();
                playBuff.Stop();         
                regim = 0;
            }
        }
        public static void Record()
        {
            RecordStart();
        }
        public static void Play()
        {
            PlayStart();
        }
        public static int Stop()
        {
            switch (regim)
            {
                case 1: RecordStop(); return 1;
                case 2: PlayStop(); return 2;
                default: return 0;
            }
        }
    }
}