private async Task <bool> SetupRecordProcess() { if (buffer != null) { buffer.Dispose(); } buffer = new InMemoryRandomAccessStream(); if (capture != null) { capture.Dispose(); } try { MediaCaptureInitializationSettings settings = new MediaCaptureInitializationSettings { StreamingCaptureMode = StreamingCaptureMode.Audio }; capture = new MediaCapture(); await capture.InitializeAsync(settings); capture.RecordLimitationExceeded += RecordLimitExceedEventHandler; capture.Failed += CaptureFailedEventHandler; } catch (Exception ex) { ThrowException(ex); return(false); } return(true); }
/** * カレント位置のサムネイルを作成する。 */ private async void createThumbnailCore() { if (mDoneOnce) { return; } mDoneOnce = true; await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() => { CanvasDevice canvasDevice = CanvasDevice.GetSharedDevice(); // Debug.WriteLine(mPlayerElement.MediaPlayer.PlaybackSession.Position); double mw = mPlayerElement.MediaPlayer.PlaybackSession.NaturalVideoWidth, mh = mPlayerElement.MediaPlayer.PlaybackSession.NaturalVideoHeight; var limit = Math.Min(Math.Max(mh, mw), 1024); var playerSize = calcFittingSize(mw, mh, limit, limit); var canvasImageSource = new CanvasImageSource(canvasDevice, (int)playerSize.Width, (int)playerSize.Height, DisplayInformation.GetForCurrentView().LogicalDpi);//96); using (var frameServerDest = new SoftwareBitmap(BitmapPixelFormat.Rgba8, (int)playerSize.Width, (int)playerSize.Height, BitmapAlphaMode.Ignore)) using (CanvasBitmap canvasBitmap = CanvasBitmap.CreateFromSoftwareBitmap(canvasDevice, frameServerDest)) { mPlayerElement.MediaPlayer.CopyFrameToVideoSurface(canvasBitmap); // ↑これで、frameServerDest に描画されるのかと思ったが、このframeServerDestは、単に、空のCanvasBitmapを作るための金型であって、 // 実際の描画は、CanvasBitmap(IDirect3DSurface)に対してのみ行われ、frameServerDestはからBitmapを作っても、黒い画像しか取り出せない。 // このため、有効な画像を取り出すには、CangasBitmapから softwareBitmapを生成してエンコードする必要がある。 using (var softwareBitmap = await SoftwareBitmap.CreateCopyFromSurfaceAsync(canvasBitmap)) { var stream = new InMemoryRandomAccessStream(); BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, stream); encoder.SetSoftwareBitmap(softwareBitmap); try { await encoder.FlushAsync(); } catch (Exception e) { Debug.WriteLine(e); stream.Dispose(); stream = null; } if (null != mOnSelected) { mOnSelected(this, mPlayerElement.MediaPlayer.PlaybackSession.Position.TotalMilliseconds, stream); closeDialog(); } else { stream.Dispose(); } } } }); }
/// <summary> /// Register face to Cognitive Face API /// </summary> /// <param name="stream"></param> /// <returns></returns> private async Task <Person> RegisterAsync(InMemoryRandomAccessStream stream) { if (SelectedRSVP == null) { Message = "Select your RSVP."; } while (SelectedRSVP == null) { await Task.Delay(1000); } // All the members should be registered when initialized. var registeredPerson = registeredPersons.First(x => x.Name == SelectedRSVP.Member.Name); // Register face information and discard image. var addPersistedFaceResult = await faceClient.AddPersonFaceAsync( Settings.PersonGroupId, registeredPerson.PersonId, ImageConverter.ConvertImage(stream)); stream.Dispose(); await faceClient.TrainPersonGroupAsync(Settings.PersonGroupId); return(await faceClient.GetPersonAsync(Settings.PersonGroupId, registeredPerson.PersonId)); }
private async Task <Result> GetCameraImage(CancellationToken cancelToken) { if (cancelToken.IsCancellationRequested) { throw new OperationCanceledException(cancelToken); } imageStream = new InMemoryRandomAccessStream(); await capture.CapturePhotoToStreamAsync(encodingProps, imageStream); await imageStream.FlushAsync(); var decoder = await BitmapDecoder.CreateAsync(imageStream); byte[] pixels = (await decoder.GetPixelDataAsync(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Ignore, new BitmapTransform(), ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.DoNotColorManage)).DetachPixelData(); const BitmapFormat format = BitmapFormat.RGB32; imageStream.Dispose(); var result = await Task.Run( () => barcodeReader.Decode(pixels, (int)decoder.PixelWidth, (int)decoder.PixelHeight, format), cancelToken); return(result); }
public static async Task <string> ExtractTextAsync(Image img, string lang) { MemoryStream memoryStream = new MemoryStream(); InMemoryRandomAccessStream randStream = new InMemoryRandomAccessStream(); string result = ""; try { img.Save(memoryStream, ImageFormat.Bmp); await randStream.WriteAsync(memoryStream.ToArray().AsBuffer()); if (!OcrEngine.IsLanguageSupported(new Language(lang))) { Console.Write("This language is not supported!"); } OcrEngine ocrEngine = OcrEngine.TryCreateFromLanguage(new Language(lang)); if (ocrEngine == null) { ocrEngine = OcrEngine.TryCreateFromUserProfileLanguages(); } var decoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(randStream); OcrResult ocrResult = await ocrEngine.RecognizeAsync(await decoder.GetSoftwareBitmapAsync()); result = ocrResult.Text; return(result); } finally { memoryStream.Dispose(); randStream.Dispose(); GC.Collect(0); } }
private async Task <bool> init() { if (stream != null) { stream.Dispose(); } if (capture != null) { capture.Dispose(); } try { stream = new InMemoryRandomAccessStream(); MediaCaptureInitializationSettings settings = new MediaCaptureInitializationSettings { StreamingCaptureMode = StreamingCaptureMode.Audio, }; capture = new MediaCapture(); await capture.InitializeAsync(settings); } catch (Exception ex) { if (ex.InnerException != null && ex.InnerException.GetType() == typeof(UnauthorizedAccessException)) { throw ex.InnerException; } throw; } return(true); }
public void DisposeMemoryBuffer() { if (_memoryBuffer != null) { _memoryBuffer.Dispose(); } }
public static async Task <string> SendImage() { try { if (MainPage.oldImg == null) { return(""); } var stream = new InMemoryRandomAccessStream(); BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, stream); encoder.SetSoftwareBitmap(MainPage.oldImg); await encoder.FlushAsync(); var ms = new MemoryStream(); stream.AsStream().CopyTo(ms); var tdata = ms.ToArray(); var x = Convert.ToBase64String(tdata); ms.Dispose(); stream.Dispose(); return(x); } catch (Exception e) { Debug.WriteLine(e.Message); return(""); } }
public async void Record(object sender, RoutedEventArgs e) { // begin recording if (StartRecording == false) { //await Initialize(); //await DeleteExistingFile(); if (record_buffer != null) { record_buffer.Dispose(); } record_buffer = new InMemoryRandomAccessStream(); MediaCaptureInitializationSettings settings = new MediaCaptureInitializationSettings { StreamingCaptureMode = StreamingCaptureMode.Audio }; captureManager_record = new MediaCapture(); await captureManager_record.InitializeAsync(settings); await captureManager_record.StartRecordToStreamAsync( MediaEncodingProfile.CreateMp3(AudioEncodingQuality.Auto), record_buffer); StartRecording = true; } // stop recording else { await captureManager_record.StopRecordAsync(); //SaveAudioToFile(); //SaveToFile(record_buffer, false); StartRecording = false; } }
private void CaptureCameraSnapshot() { var task = Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { animCameraTimer.Stop(); animCameraTimer.Begin(); }); if (_mediaCapture.CameraStreamState != Windows.Media.Devices.CameraStreamState.Streaming) { return; } IRandomAccessStream stream = new InMemoryRandomAccessStream(); try { IAsyncAction action = _mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), stream); action.Completed = (result, status) => { if (status == AsyncStatus.Completed) { OnCapturePhotoCompleted(stream, result, status); } }; } catch (Exception) { if (stream != null) { stream.Dispose(); stream = null; } } }
public void Dispose() { if (can == null) { GC.SuppressFinalize(this); return; } can.Children.Clear(); GC.SuppressFinalize(can); GC.SuppressFinalize(img); GC.SuppressFinalize(rta); GC.SuppressFinalize(SA); GC.SuppressFinalize(SR); GC.SuppressFinalize(SG); GC.SuppressFinalize(SB); GC.SuppressFinalize(TA); GC.SuppressFinalize(TR); GC.SuppressFinalize(TG); GC.SuppressFinalize(TB); GC.SuppressFinalize(cancel); GC.SuppressFinalize(ok); GC.SuppressFinalize(bor); memoryStream.Dispose(); memoryStreamA.Dispose(); GC.SuppressFinalize(this); }
/// <inheritdoc/> public override async Task <(Stream stream, Exception error)> OpenEntryAsync(string entry) { var(irs, error) = await this.OpenEntryAsRandomAccessStreamAsync(entry); if (error != null) { return(null, error); } var decoder = await BitmapDecoder.CreateAsync(irs); var bitmap = decoder.GetSoftwareBitmapAsync(); var outputIrs = new InMemoryRandomAccessStream(); var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, outputIrs); encoder.SetSoftwareBitmap(await bitmap); await encoder.FlushAsync(); var outputStream = new MemoryStream(); outputIrs.Seek(0); outputIrs.AsStreamForRead().CopyTo(outputStream); outputIrs.Dispose(); outputStream.Seek(0, SeekOrigin.Begin); return(outputStream, null); }
/// <summary> /// Compresses the content and returns it as an input stream. /// </summary> /// <returns>A <see cref="IInputStream"/> implementation containing the compresssed data.</returns> public IAsyncOperationWithProgress <IInputStream, ulong> ReadAsInputStreamAsync() { return(AsyncInfo.Run <IInputStream, ulong>(async(cancellationToken, progress) => { await BufferAllAsync().AsTask().ConfigureAwait(false); var randomAccessStream = new InMemoryRandomAccessStream(); try { using (var writer = new DataWriter(randomAccessStream)) { writer.WriteBuffer(bufferedData); uint bytesStored = await writer.StoreAsync().AsTask(cancellationToken); // Make sure that the DataWriter destructor does not close the stream. writer.DetachStream(); // Report progress. progress.Report(randomAccessStream.Size); return randomAccessStream.GetInputStreamAt(0); } } catch { randomAccessStream?.Dispose(); throw; } })); }
private async Task SaveAsync() { var stream = new InMemoryRandomAccessStream(); await ImageCropper.SaveAsync(stream, BitmapFileFormat.Png); App.ViewModel.IsLoading = true; var dispatcherQueue = Windows.System.DispatcherQueue.GetForCurrentThread(); var data = await App.Repository.User.UploadAvatarAsync(stream, async res => { await dispatcherQueue.EnqueueAsync(() => { App.ViewModel.IsLoading = false; _ = new MessageDialog(res.Message ?? Constants.GetString("unknow_error")).ShowAsync(); }); }); stream.Dispose(); await dispatcherQueue.EnqueueAsync(() => { App.ViewModel.IsLoading = false; if (data == null) { return; } App.ViewModel.User = data; Frame.GoBack(); }); }
private async Task <bool> RecordProcess() { if (buffer != null) { buffer.Dispose(); } buffer = new InMemoryRandomAccessStream(); if (capture != null) { capture.Dispose(); } try { MediaCaptureInitializationSettings settings = new MediaCaptureInitializationSettings { StreamingCaptureMode = StreamingCaptureMode.Audio }; capture = new MediaCapture(); await capture.InitializeAsync(settings); capture.RecordLimitationExceeded += (MediaCapture sender) => { throw new Exception("Record Limitation Exceeded "); }; capture.Failed += (MediaCapture sender, MediaCaptureFailedEventArgs errorEventArgs) => { throw new Exception(string.Format("Code: {0}. {1}", errorEventArgs.Code, errorEventArgs.Message)); }; } catch (Exception ex) { throw; } return(true); }
private async void DisplayRecord(string hexInput) { try { InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream(); using (DataWriter writer = new DataWriter(stream.GetOutputStreamAt(0))) { writer.WriteBytes(HexStringToByteArray(hexInput)); await writer.StoreAsync(); var iSC = new InkStrokeContainer(); await SampleInkCanvas.InkPresenter.StrokeContainer.LoadAsync(stream); SampleInkCanvas.Width = SampleInkCanvas.InkPresenter.StrokeContainer.BoundingRect.Right; SampleInkCanvas.Height = SampleInkCanvas.InkPresenter.StrokeContainer.BoundingRect.Bottom; StrokeTextBlock.Text = "Number of Strokes: " + SampleInkCanvas.InkPresenter.StrokeContainer.GetStrokes().Count.ToString(); } stream.Dispose(); } catch (Exception ex) { ErrorDisplay.ShowErrorMessage(ex.Message); } }
private static async void AddStrokeCountToRecords(List <InkSample> records) { foreach (InkSample record in records) { string hexInput = record.ISF; try { InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream(); using (DataWriter writer = new DataWriter(stream.GetOutputStreamAt(0))) { writer.WriteBytes(HexStringToByteArray(hexInput)); await writer.StoreAsync(); var iSC = new InkStrokeContainer(); await iSC.LoadAsync(stream); record.StrokeCount = iSC.GetStrokes().Count; } stream.Dispose(); } catch (Exception ex) { Console.WriteLine("Error parsing ISF!"); } } }
private async void Run() { await _HubConnection.Start(); var cam = new MediaCapture(); await cam.InitializeAsync(new MediaCaptureInitializationSettings() { MediaCategory = MediaCategory.Media, StreamingCaptureMode = StreamingCaptureMode.Video }); _Sensor.MotionDetected += async(int pinNum) => { var stream = new InMemoryRandomAccessStream(); Stream imageStream = null; try { await Task.Factory.StartNew(async() => { _Sensor.IsActive = false; await cam.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), stream); stream.Seek(0); imageStream = stream.AsStream(); imageStream.Seek(0, SeekOrigin.Begin); string imageUrl = await NotificationHelper.UploadImageAsync(imageStream); switch (await OxfordHelper.IdentifyAsync(imageUrl)) { case AuthenticationResult.IsOwner: // open the door MotorController.PWM(26); break; case AuthenticationResult.Unkown: // send notification to the owner NotificationHelper.NotifyOwnerAsync(imageUrl); break; case AuthenticationResult.None: default: break; } _Sensor.IsActive = true; }); } finally { if (stream != null) { stream.Dispose(); } if (imageStream != null) { imageStream.Dispose(); } } }; }
public async Task <StorageFile> CapturePhotoAsync() { if (_mediaCapture == null) { return(null); } var stream = new InMemoryRandomAccessStream(); await _mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), stream); try { var filename = "adventure_" + DateTime.Now.ToString("HHmmss_MMddyyyy") + ".jpg"; var file = await(await AdventureObjectStorageHelper.GetDataSaveFolder()).CreateFileAsync(filename, CreationCollisionOption.GenerateUniqueName); using (var outputStream = await file.OpenAsync(FileAccessMode.ReadWrite)) { var decoder = await BitmapDecoder.CreateAsync(stream); var encoder = await BitmapEncoder.CreateForTranscodingAsync(outputStream, decoder); var photoOrientation = ConvertOrientationToPhotoOrientation(GetCameraOrientation()); var properties = new BitmapPropertySet { { "System.Photo.Orientation", new BitmapTypedValue(photoOrientation, Windows.Foundation.PropertyType.UInt16) } }; await encoder.BitmapProperties.SetPropertiesAsync(properties); await encoder.FlushAsync(); } stream.Dispose(); PictureCaptured?.Invoke(this, new PictureCapturedEventArgs() { File = file }); return(file); } catch (Exception ex) { stream.Dispose(); return(null); } }
protected override void SubclassDispose() { bufferTaskCancelTokenSource.Cancel(); bufferTaskCancelTokenSource.Dispose(); clonedBufferStream.Dispose(); bufferStream.Dispose(); }
private async Task LoadImageFromHttpResponse(HttpResponseMessage response, BitmapImage bitmap, string cacheKey) { if (response.IsSuccessStatusCode) { var stream = new InMemoryRandomAccessStream(); using (var content = response.Content) { await content.WriteToStreamAsync(stream); } await stream.FlushAsync(); stream.Seek(0); await bitmap.Dispatcher.RunAsync(CoreDispatcherPriority.Low, async() => { try { await bitmap.SetSourceAsync(stream); // cache image asynchronously, after successful decoding var task = Task.Run(async() => { var buffer = new Windows.Storage.Streams.Buffer((uint)stream.Size); stream.Seek(0); await stream.ReadAsync(buffer, buffer.Capacity, InputStreamOptions.None); stream.Dispose(); await Cache.SetAsync(cacheKey, buffer); }); } catch (Exception ex) { Debug.WriteLine("{0}: {1}", response.RequestMessage.RequestUri, ex.Message); stream.Dispose(); } }); } else { Debug.WriteLine("{0}: {1}", response.RequestMessage.RequestUri, response.StatusCode); } }
private async void OnButtonClicked(object sender, RoutedEventArgs e) { if (!_recording) { MediaCaptureInitializationSettings settings = new MediaCaptureInitializationSettings { StreamingCaptureMode = StreamingCaptureMode.Audio }; _capture = new MediaCapture(); await _capture.InitializeAsync(settings); _capture.RecordLimitationExceeded += async(MediaCapture s) => { await new MessageDialog("Record limtation exceeded", "Error").ShowAsync(); }; _capture.Failed += async(MediaCapture s, MediaCaptureFailedEventArgs args) => { await new MessageDialog("Media capture failed: " + args.Message, "Error").ShowAsync(); }; _buffer = new InMemoryRandomAccessStream(); var profile = MediaEncodingProfile.CreateWav(AudioEncodingQuality.Auto); profile.Audio = AudioEncodingProperties.CreatePcm(16000, 1, 16); // Must be mono (1 channel) await _capture.StartRecordToStreamAsync(profile, _buffer); TheButton.Content = "Verify"; _recording = true; } else // Recording { if (_capture != null && _buffer != null && _id != null && _id != Guid.Empty) { await _capture.StopRecordAsync(); IRandomAccessStream stream = _buffer.CloneStream(); var client = new SpeakerVerificationServiceClient(_key); var response = await client.VerifyAsync(stream.AsStream(), _id); string message = String.Format("Result: {0}, Confidence: {1}", response.Result, response.Confidence); await new MessageDialog(message).ShowAsync(); _capture.Dispose(); _capture = null; _buffer.Dispose(); _buffer = null; } TheButton.Content = "Start"; _recording = false; } }
async private void openCamera(object sender, RoutedEventArgs e) { if (StartVideo == false) { //camera.Icon = IconElement. if (video_buffer != null) { video_buffer.Dispose(); } video_buffer = new InMemoryRandomAccessStream(); showVideo.Visibility = Visibility.Collapsed; capturePreview.Visibility = Visibility.Visible; //ProfilePic.Visibility = Visibility.Collapsed; captureManager_video = new MediaCapture(); //选择后置摄像头 var cameraDevice = await FindCameraDeviceByPanelAsync(Windows.Devices.Enumeration.Panel.Back); if (cameraDevice == null) { System.Diagnostics.Debug.WriteLine("No camera device found!"); return; } var settings = new MediaCaptureInitializationSettings { StreamingCaptureMode = StreamingCaptureMode.Video, //MediaCategory = MediaCategory.Other, //AudioProcessing = AudioProcessing.Default, //PhotoCaptureSource = PhotoCaptureSource.Photo, AudioDeviceId = string.Empty, VideoDeviceId = cameraDevice.Id }; await captureManager_video.InitializeAsync(settings); //摄像头旋转90度 //captureManager.SetPreviewRotation(VideoRotation.Clockwise90Degrees); capturePreview.Source = captureManager_video; // await captureManager_video.StartRecordToStreamAsync(MediaEncodingProfile.CreateMp3(AudioEncodingQuality.Auto), video_buffer); await captureManager_video.StartRecordToStreamAsync(MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Auto), video_buffer); await captureManager_video.StartPreviewAsync(); //await captureManager_video.StartPreviewAsync(); StartVideo = true; } else { await captureManager_video.StopRecordAsync(); //SavaVideoToFile(); SaveToFile(video_buffer, false); StartVideo = false; } }
/// <summary> /// Record a fragment of the given duration. /// </summary> /// <param name="duration">The desired duration in milliseconds.</param> /// <returns>The recorded fragmet as a RandomAccessStream object.</returns> public async Task <IRandomAccessStream> Record(int duration) { buffer?.Dispose(); buffer = new InMemoryRandomAccessStream(); await mediaCapture.StartRecordToStreamAsync(wavEncodingProfile, buffer); await Task.Delay(duration); await mediaCapture.StopRecordAsync(); return(buffer.CloneStream()); }
public async Task SendStreamAsync(MessageType messageType, InMemoryRandomAccessStream bits) { await this.SendAsync( messageType, (int)bits.Size, async() => { await RandomAccessStream.CopyAsync(bits, this.socket.OutputStream); } ); bits.Dispose(); }
/// /// Name ClearAudioFiles /// /// <summary> Clears the audio file after saving. /// </summary> /// <returns></returns> public async void ClearAudioFiles() { try { await _buffer.FlushAsync(); _buffer.Dispose(); } catch (Exception ex) { LogTracking.LogTrace(ex.ToString()); } }
/// ------------------------------------------------------------------------------------------------ /// ------------------------------------------------------------------------------------------------- #region Private Functions /// /// Name RecordProcess /// ///<summary> ///</summary> private async Task <bool> RecordProcess() { _buffer?.Dispose(); _buffer = new InMemoryRandomAccessStream(); _capture?.Dispose(); _playaudio?.Dispose(); try { MediaCaptureInitializationSettings settings = new MediaCaptureInitializationSettings { StreamingCaptureMode = StreamingCaptureMode.Audio }; _capture = new MediaCapture(); await _capture.InitializeAsync(settings); _capture.RecordLimitationExceeded += sender => { _record = false; throw new Exception("Record Limitation Exceeded "); }; _capture.Failed += (sender, errorEventArgs) => { _record = false; throw new Exception(string.Format("Code: {0}. {1}", errorEventArgs.Code, errorEventArgs.Message)); }; _playaudio = new MediaCapture(); await _playaudio.InitializeAsync(settings); _playaudio.RecordLimitationExceeded += sender => { _record = false; throw new Exception("Record Limitation Exceeded "); }; _playaudio.Failed += (sender, errorEventArgs) => { _record = false; throw new Exception(string.Format("Code: {0}. {1}", errorEventArgs.Code, errorEventArgs.Message)); }; } catch (Exception ex) { LogTracking.LogTrace(ex.ToString()); if (ex.InnerException != null && ex.InnerException.GetType() == typeof(UnauthorizedAccessException)) { throw ex.InnerException; } } return(true); }
private async Task <byte[]> GetInkBytes() { IRandomAccessStream stream = new InMemoryRandomAccessStream(); await InkCanvas.InkPresenter.StrokeContainer.SaveAsync(stream); byte[] buffer = new byte[stream.Size]; using (DataReader reader = new DataReader(stream.GetInputStreamAt(0UL))) { await reader.LoadAsync((uint)stream.Size); reader.ReadBytes(buffer); } stream.Dispose(); return(buffer); }
private void Initialized() { if (_memoryBuffer != null) { _memoryBuffer.Dispose(); } _memoryBuffer = new InMemoryRandomAccessStream(); if (_mediaCapture != null) { _mediaCapture.Dispose(); } this._fileName = DEFAULT_AUDIO_FILENAME + DateTime.Now + ".wav"; }
private void Initialize() { if (_memoryBuffer != null) { _memoryBuffer.Dispose(); } _memoryBuffer = new InMemoryRandomAccessStream(); if (_mediaCapture != null) { _mediaCapture.Dispose(); } _fileName = DEFAULT_AUDIO_FILENAME; UdpService.startup(ipAddress); }