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;
        }

 public void StopCapture()
 {
     try
     {
         if (_microphone != null)
         {
             _baBuffer = new byte[0];
             _microphone.BufferReady -= MicrophoneBufferReady;
             _microphone.Stop();
             _microphone = null;
         }
     }
     catch (Exception)
     {
     }
 }

        public bool RecordAudio()
        {
            try
            {
                StopRequested = false;
                if (microphone == null)
                {
                    microphone = Microphone.Default;
                }
                sampleRate = microphone.SampleRate;
                microphone.BufferDuration = TimeSpan.FromMilliseconds(100);
                buffer = new byte[microphone.GetSampleSizeInBytes(microphone.BufferDuration)];

                microphone.BufferReady += new EventHandler<EventArgs>(Microphone_BufferReady);
                stream = new MemoryStream(1048576);
                stream.SetLength(0);
                WriteWavHeader(microphone.SampleRate);

                dispatcherTimer = new System.Windows.Threading.DispatcherTimer();
                dispatcherTimer.Interval = TimeSpan.FromMilliseconds(33);
                dispatcherTimer.Tick += delegate
                {
                    try
                    {
                        Microsoft.Xna.Framework.FrameworkDispatcher.Update();
                    }
                    catch (System.Exception ex)
                    {
                        System.Diagnostics.Debug.WriteLine("FrameworkDispatcher :" + ex.Message);
                    }
                };

                dispatcherTimer.Start();
                Microsoft.Xna.Framework.FrameworkDispatcher.Update();
                microphone.Start();

                System.Diagnostics.Debug.WriteLine("Started Recording");
                return true;
            }
            catch (System.Exception ex)
            {
                System.Diagnostics.Debug.WriteLine("RecordAudio :" + ex.Message);
                return false;
            }
        }

 public void StartCapture()
 {
     try
     {
         if (_microphone == null)
         {
             _microphone = Microphone.Default;
             _microphone.BufferDuration = TimeSpan.FromMilliseconds(100);
             var sampleSize = _microphone.GetSampleSizeInBytes(_microphone.BufferDuration);
             _baBuffer = new byte[sampleSize];
             _microphone.BufferReady += MicrophoneBufferReady;
             _microphone.Start();
         }
     }
     catch (Exception)
     {
     }
 }

        public MicRecorder()
        {
            worker.WorkerReportsProgress = true;
            worker.DoWork += new DoWorkEventHandler(worker_DoWork);

            _microphone = Microphone.Default;

            /*
             * The duration of the capture buffer must be between 100ms and 1000ms. Additionally, the capture buffer must be 10ms aligned (BufferDuration % 10 == 0).
             * Silverlight applications must ensure that FrameworkDispatcher.Update is called regularly in order for "fire and forget" sounds to work correctly.
             * BufferDuration throws an InvalidOperationException if FrameworkDispatcher.Update has not been called at least once before making this call.
             * For more information, see Enable XNA Framework Events in Windows Phone Applications.
             */
            _microphone.BufferDuration = TimeSpan.FromMilliseconds(100);
            _duration = _microphone.BufferDuration;
            _bufferSize = _microphone.GetSampleSizeInBytes(_microphone.BufferDuration);

            _microphone.BufferReady += new EventHandler<EventArgs>(MicrophoneBufferReady);
        }

        private MicrophoneButton(Microphone microphone)
        {
            FrameworkDispatcher.Update();
                        
            var minSupportedBufferDurationMs = 100;
            var duration = TimeSpan.FromMilliseconds(minSupportedBufferDurationMs);

            Microphone = microphone;
            Microphone.BufferDuration = duration;

            Buffer = new byte[Microphone.GetSampleSizeInBytes(duration)];
            Buffer2D = new Color[TexWidth * byte.MaxValue];

            Texture2D = Texture2D ?? Program.Renderer.LeaseFor<Gray, byte>(TexWidth, byte.MaxValue);
            Texture2D.SetData(Buffer2D);

            Microphone.BufferReady += OnBufferReady;

            Microphone.Start();            
        }