C# Audio.Microphone类代码示例

        private void Initialize()
        {

            InitializeComponent();

            recordButton = ApplicationBar.Buttons[0] as ApplicationBarIconButton;
            playButton = ApplicationBar.Buttons[1] as ApplicationBarIconButton;
            saveButton = ApplicationBar.Buttons[2] as ApplicationBarIconButton;
            

   
            stream = new MemoryStream();
            microphone = Microphone.Default;
            soundIsPlaying = false;

            DispatcherTimer dt = new DispatcherTimer();
            dt.Interval = TimeSpan.FromMilliseconds(33);
            dt.Tick += new EventHandler(dt_Tick);
            dt.Start();


            microphone.BufferReady +=
                new EventHandler<EventArgs>(microphone_BufferReady);

           blankImage = new BitmapImage(new Uri("Images/blank.png", UriKind.RelativeOrAbsolute));
           microphoneImage = new BitmapImage(new Uri("Images/microphone.png", UriKind.RelativeOrAbsolute));
           speakerImage = new BitmapImage(new Uri("Images/speaker.png", UriKind.RelativeOrAbsolute));
        }

        /// <summary>
        /// Initializes new instance of WitMic
        /// </summary>
        /// <param name="witPipedStream">Stream to write audio to</param>
        /// <param name="detectSpeechStop">Voice activity detection feature</param>
        public WitMic(WitPipedStream witPipedStream, bool detectSpeechStop)
        {
            this.witPipedStream = witPipedStream;
            this.detectSpeechStop = detectSpeechStop;

            microphone = Microphone.Default;

            if (microphone == null)
            {
                WitLog.Log("Did you enabled ID_CAP_MICROPHONE in WMAppManifest.xml?");

                return;
            }

            witDetectTalking = new WitVadWrapper(8.0, 16000, 60);

            microphone.BufferDuration = TimeSpan.FromMilliseconds(100);

            speech = new byte[microphone.GetSampleSizeInBytes(microphone.BufferDuration)];

            microphone.BufferReady += microphone_BufferReady;

            updateTimer = new DispatcherTimer()
            {
                Interval = TimeSpan.FromMilliseconds(1)
            };
            updateTimer.Tick += (s, e) =>
            {
                FrameworkDispatcher.Update();
            };
        }

 /// <summary>
 ///     Initializes a new instance of the <see cref="PhoneRecorder" /> class.
 /// </summary>
 /// <param name="microphone">The microphone.</param>
 public PhoneRecorder(Microphone microphone)
 {
     _mic = microphone;
     var timer = new DispatcherTimer {Interval = TimeSpan.FromMilliseconds(33)};
     timer.Tick += timer_Tick;
     timer.Start();
     _mic.BufferReady += microphone_BufferReady;
 }

        public NewButtonPage()
        {
            InitializeComponent();

            // Create new Microphone and set event handler
            buttonMic = Microphone.Default;
            buttonMic.BufferReady += OnMicrophoneBufferReady;
            buttonPlayback = new DynamicSoundEffectInstance(buttonMic.SampleRate, AudioChannels.Mono);
        }

 byte[] msBuffer; //读取数据的缓冲区
 public RecPage()
 {
     InitializeComponent();
     // Microphone.Default静态属性获得默认麦克风的引用
     myMicrophone = Microphone.Default;
    // myMicrophone.BufferDuration = TimeSpan.FromMilliseconds(1000);
     msBuffer = new byte[myMicrophone.GetSampleSizeInBytes(myMicrophone.BufferDuration)];
     //FrameworkDispatcher.Update();
 }

        // コンストラクター
        public MainPage()
        {
            InitializeComponent();

            microphone = Microphone.Default;
            microphone.BufferReady += OnMicrophoneBufferReady;

            playback = new DynamicSoundEffectInstance(microphone.SampleRate, AudioChannels.Mono);
            playback.BufferNeeded += OnPlaybackBufferNeeded;
        }

        public XnaMicrophone()
        {
            this.microphone = Microphone.Default;

            this.timer = new DispatcherTimer()
            {
                Interval = TimeSpan.FromMilliseconds(50)
            };

            this.timer.Tick += (s, e) => FrameworkDispatcher.Update();
        }

        public UDPAudioSink(bool ALaw)
        {
            _Sending = false;
            ALAW = ALaw;

            dt = new DispatcherTimer();
            microphone = Microphone.Default;
            stream = new MemoryStream();
            FrameworkDispatcher.Update();

            microphone.BufferReady += new EventHandler<EventArgs>(microphone_BufferReady);
        }

        public NetworkTestPageViewModel()
        {
            _Sending = false;

            microphone = Microphone.Default;
            stream = new MemoryStream();

            InputBytes = new ObservableCollection<ByteHolder>();
            G711Bytes = new ObservableCollection<ByteHolder>();
            StartTimer();

            microphone.BufferReady += new EventHandler<EventArgs>(microphone_BufferReady);
        }

        public MicHelper()
        {
            //Setup mic
            mic = Microphone.Default;

            //Setup timers
            recordingTimer = new DispatcherTimer();
            recordingTimer.Interval = TimeSpan.FromSeconds(Utils.maxRecordingDuration);
            recordingTimer.Tick += new EventHandler(recordingTimer_Tick);

            playbackTimer = new DispatcherTimer();
            playbackTimer.Tick += new EventHandler(playbackTimer_Tick);
        }

        public XnaMicrophone()
        {
            this.microphone = Microphone.Default;
            this.microphone.BufferReady += microphone_BufferReady;

            this.Start = new RelayCommand<int>(
                (rate) => this.microphone.Start(),
                (rate) => this.SupportedSampleRates.Contains(rate) && this.microphone != null && this.microphone.State == MicrophoneState.Stopped);

            this.Stop = new Command(
                () => this.microphone.Stop(),
                () => this.microphone != null && this.microphone.State == MicrophoneState.Started);
        }

        /// <summary>
        /// Creates new instance of the AudioRecorder class.
        /// </summary>
        public AudioRecorder()
        {
            this.microphone = Microphone.Default;
            this.microphone.BufferDuration = TimeSpan.FromMilliseconds(500);

            this.buffer = new byte[microphone.GetSampleSizeInBytes(this.microphone.BufferDuration)];

            this.microphone.BufferReady += new EventHandler<EventArgs>(MicrophoneBufferReady);

            this.InitializeXnaGameLoop();

            // microphone requires special XNA initialization to work
            InitializeComponent();
        }

        public override void Initialize(AudioCaptureInitializeArgs captureArgs)
        {
            Microphone = Microphone.Default;
            Microphone.BufferDuration = TimeSpan.FromMilliseconds(100); // 100 minimum
            Microphone.BufferReady += Microphone_BufferReady;

            Resampler = new Resampler(DesiredClockRate / 16000);

            RunOnUIThread(() =>
            {
                XnaTimer = new DispatcherTimer();
                XnaTimer.Interval = TimeSpan.FromMilliseconds(50);
                XnaTimer.Tick += delegate { try { FrameworkDispatcher.Update(); } catch { } };
                XnaTimer.Start();
            });
        }

        public Recorder()
        {
            //Microphone config
            _microphone = Microphone.Default;
            _microphone.BufferDuration = TimeSpan.FromMilliseconds(100);
            _duration = _microphone.BufferDuration;
            numBytes = _microphone.GetSampleSizeInBytes(_microphone.BufferDuration);
            TimeSpan sample = TimeSpan.FromSeconds(1.0 / _microphone.SampleRate);
            int numBytesPerSample = _microphone.GetSampleSizeInBytes(sample);
            _buffer = new byte[numBytes];
            _microphone.BufferReady += new EventHandler<EventArgs>(MicrophoneBufferReady);

            stream = new MemoryStream();

            totalNumBytes = 0;
        }

        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";

            // Frame rate is 30 fps by default for Windows Phone.
            TargetElapsedTime = TimeSpan.FromTicks(333333);

            // Extend battery life under lock.
            InactiveSleepTime = TimeSpan.FromSeconds(1);

            mic = Microphone.Default;
            mic.BufferDuration = TimeSpan.FromSeconds(1);
            audioBuffer = new byte[mic.GetSampleSizeInBytes(mic.BufferDuration)];
            mic.BufferReady += BufferIsReady;
        }