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;
}
}
public async void CaptureAudio()
{
AudioGraphSettings audioGraphSettings = new AudioGraphSettings(Windows.Media.Render.AudioRenderCategory.Speech);
var result = await AudioGraph.CreateAsync(audioGraphSettings);
if (result.Status != AudioGraphCreationStatus.Success)
{
return;
}
_audioGraph = result.Graph;
var deviceInputNodeResult = await _audioGraph.CreateDeviceInputNodeAsync(Windows.Media.Capture.MediaCategory.Speech);
if (deviceInputNodeResult.Status != AudioDeviceNodeCreationStatus.Success)
{
return;
}
var deviceInputNode = deviceInputNodeResult.DeviceInputNode;
_audioFile = await Windows.Storage.ApplicationData.Current.TemporaryFolder
.CreateFileAsync("speech", CreationCollisionOption.ReplaceExisting);
var mediaEncodingProfile = MediaEncodingProfile.CreateMp3(AudioEncodingQuality.High);
var fileOutputNodeResult = await _audioGraph.CreateFileOutputNodeAsync(_audioFile, mediaEncodingProfile);
if (fileOutputNodeResult.Status != AudioFileNodeCreationStatus.Success)
{
return;
}
var fileOutputNode = fileOutputNodeResult.FileOutputNode;
deviceInputNode.AddOutgoingConnection(fileOutputNode);
_audioGraph.Start();
}
public async void StartRecord(string label, uint quality)
{
try
{
if (mode == RecordMode.AUDIO)
{
StorageFile file = await videoStore.CreateFileAsync($"{label}.mp3", CreationCollisionOption.GenerateUniqueName);
await MediaCap.StartRecordToStorageFileAsync(MediaEncodingProfile.CreateMp3(AudioEncodingQuality.Auto), file);
}
else if (mode == RecordMode.VIDEO || mode == RecordMode.VIDEOAUDIO)
{
// Choose quality based recording
MediaCap.SetEncoderProperty(MediaStreamType.VideoRecord, new Guid(0x1c0608e9, 0x370c, 0x4710, 0x8a, 0x58, 0xcb, 0x61, 0x81, 0xc4, 0x24, 0x23), PropertyValue.CreateUInt32(3));
// Set quality level
MediaCap.SetEncoderProperty(MediaStreamType.VideoRecord, new Guid(0xfcbf57a3, 0x7ea5, 0x4b0c, 0x96, 0x44, 0x69, 0xb4, 0x0c, 0x39, 0xc3, 0x91), PropertyValue.CreateUInt32(quality));
StorageFile file = await videoStore.CreateFileAsync($"{label}.mp4", CreationCollisionOption.GenerateUniqueName);
await MediaCap.StartRecordToStorageFileAsync(MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Auto), file);
}
else
{
IsRecording = false;
}
IsRecording = true;
Log.Error("Began Recording");
}
catch (Exception ex)
{
Log.Error($"Failed to record:\t{ex}");
}
}
private async void StartRecord()
{
if (BtnColVis)
{
LogoBack.Visibility = Visibility.Visible;
LogoBack.Opacity = 1;
LogoBackOpacitySmall.Visibility = Visibility.Visible;
LogoBackOpacityBig.Visibility = Visibility.Visible;
Logo.Visibility = Visibility.Collapsed;
StopLogo.Visibility = Visibility.Visible;
BtnColVis = false;
sb1.Begin();
//开始录音
//micphoneStorageFile = await KnownFolders.MusicLibrary.CreateFileAsync(DateTime.Now.ToString("yyyy-MM-dd hh-mm-ss") + ".mp3", CreationCollisionOption.GenerateUniqueName);
//micphoneStorageFile = await KnownFolders.RemovableDevices.CreateFileAsync(DateTime.Now.ToString("yyyy-MM-dd hh-mm-ss") + ".mp3", CreationCollisionOption.GenerateUniqueName);
StorageFolder folder2 = await KnownFolders.MusicLibrary.CreateFolderAsync(DateTime.Now.ToString("yyyy-MM-dd"), CreationCollisionOption.OpenIfExists);
micphoneStorageFile = await folder2.CreateFileAsync(DateTime.Now.ToString("yyyy=MM=dd hh=mm=ss") + ".mp3", CreationCollisionOption.GenerateUniqueName);
await micphone.StartRecordToStorageFileAsync(MediaEncodingProfile.CreateMp3(AudioEncodingQuality.Auto), this.micphoneStorageFile);
}
}
private async void RecordButton_Click(object sender, RoutedEventArgs e)
{
MediaEncodingProfile encodingProfile = null;
switch (_selectedFormat)
{
case AudioEncodingFormat.Mp3:
encodingProfile = MediaEncodingProfile.CreateMp3(_encodingQuality);
break;
case AudioEncodingFormat.Mp4:
encodingProfile = MediaEncodingProfile.CreateM4a(_encodingQuality);
break;
case AudioEncodingFormat.Wma:
encodingProfile = MediaEncodingProfile.CreateWma(_encodingQuality);
break;
default:
throw new ArgumentOutOfRangeException();
}
_audioStream = new InMemoryRandomAccessStream();
await _mediaCapture.StartRecordToStreamAsync(encodingProfile, _audioStream);
UpdateRecordingControls(RecordingMode.Recording);
_timer.Start();
}
//void logo_PointerExited(object sender, PointerRoutedEventArgs e)
//{
// logo.PointerExit();
//}
//void logo_PointerEntered(object sender, PointerRoutedEventArgs e)
//{
// logo.PointerEnter();
//}
async void logo_Tapped(object sender, TappedRoutedEventArgs e)
{
if (!b)
{
//StartRecord();
file = await folder.CreateFileAsync(DateTime.Now.ToString("yyyy-MM-dd hh-mm-ss") + ".mp3", CreationCollisionOption.GenerateUniqueName);
await micphone.StartRecordToStorageFileAsync(MediaEncodingProfile.CreateMp3(AudioEncodingQuality.Auto), file);
b = true;
logo.StartFlash();
}
else
{
//StopRecord();
await micphone.StopRecordAsync();
var stream = await file.OpenAsync(FileAccessMode.Read);
mediaElement.SetSource(stream, file.FileType);
mediaElement.AutoPlay = false;
b = false;
logo.StopFlash();
obs.Add(file.Name);
}
}
public ConvertToMp3Manager(StorageFile sourceAudio, StorageFile destinationAudio, AudioFormat AudioType = AudioFormat.MP3, AudioEncodingQuality audioEncodingQuality = AudioEncodingQuality.High)
{
if (sourceAudio == null || destinationAudio == null)
{
throw new ArgumentNullException("sourceAudio and destinationAudio cannot be null");
}
switch (AudioType)
{
case AudioFormat.AAC:
case AudioFormat.M4A:
profile = MediaEncodingProfile.CreateM4a(audioEncodingQuality);
break;
case AudioFormat.MP3:
profile = MediaEncodingProfile.CreateMp3(audioEncodingQuality);
break;
case AudioFormat.WMA:
profile = MediaEncodingProfile.CreateWma(audioEncodingQuality);
break;
}
this.SourceAudio = sourceAudio;
this.DestinationAudio = destinationAudio;
this.AudioFormat = AudioType;
this.AudioQuality = audioEncodingQuality;
this.TransCoder = new MediaTranscoder();
}
private async void Record_click(object sender, RoutedEventArgs e)
{
MediaEncodingProfile encodingProfile = null;
switch (selectedFormat)
{
case AudioEncodingFormat.Mp3:
encodingProfile = MediaEncodingProfile.CreateMp3(SelectedQuality);
break;
case AudioEncodingFormat.Mp4:
encodingProfile = MediaEncodingProfile.CreateMp3(SelectedQuality);
break;
case AudioEncodingFormat.Wma:
encodingProfile = MediaEncodingProfile.CreateWav(SelectedQuality);
break;
case AudioEncodingFormat.Avi:
encodingProfile = MediaEncodingProfile.CreateMp3(SelectedQuality);
break;
default:
throw new ArgumentOutOfRangeException();
}
AudioStream = new InMemoryRandomAccessStream();
await CaptureMedia.StartRecordToStreamAsync(encodingProfile, AudioStream);
UpdateRecordingControls(RecordingMode.Recording);
DishTImer.Start();
}
private async void RecordButtonClickHandler(object sender, RoutedEventArgs e)
{
await dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
if (isRecording)
{
return;
}
recordButton.Visibility = Visibility.Collapsed;
stopRecordButton.Visibility = Visibility.Visible;
playButton.IsEnabled = false;
StartRecordTimerCount();
if (await SetupRecordProcess())
{
if (UIHelper.GetDeviceFamily() != "Windows.Mobile")
{
await capture.StartRecordToStreamAsync(MediaEncodingProfile.CreateMp3(AudioEncodingQuality.Auto), buffer);
}
else
{ //No mp3 or wma on win mobile so we use mp4 instead, still give better compressed size than using raw format
await capture.StartRecordToStreamAsync(MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Auto), buffer);
}
if (isRecording)
{
ThrowInvalidOperantionException();
return;
}
isRecording = true;
}
});
}
private async void StartRecord()
{
if (BtnColVis)
{
LogoBack.Visibility = Visibility.Visible;
LogoBack.Opacity = 1;
LogoBackOpacitySmall.Visibility = Visibility.Visible;
LogoBackOpacityBig.Visibility = Visibility.Visible;
Logo.Visibility = Visibility.Collapsed;
StopLogo.Visibility = Visibility.Visible;
BtnColVis = false;
sb1.Begin();
//开始录音
//StorageFolder folder = await StorageFolder.GetFolderFromPathAsync(Package.Current.InstalledLocation.Path + @"\AudioFile");
//micphoneStorageFile = await folder.CreateFileAsync(DateTime.Now.ToString("yyyy-MM-dd hh-mm-ss") + ".mp3");
StorageFolder folder2 = await KnownFolders.MusicLibrary.CreateFolderAsync(DateTime.Now.ToString("yyyy-MM-dd"), CreationCollisionOption.OpenIfExists);
micphoneStorageFile = await folder2.CreateFileAsync(DateTime.Now.ToString("yyyy=MM=dd hh=mm=ss") + ".mp3", CreationCollisionOption.GenerateUniqueName);
await micphone.StartRecordToStorageFileAsync(MediaEncodingProfile.CreateMp3(AudioEncodingQuality.Auto), this.micphoneStorageFile);
}
else
{
LogoBack.Visibility = Visibility.Collapsed;
LogoBack.Opacity = 0.4;
LogoBackOpacitySmall.Visibility = Visibility.Collapsed;
LogoBackOpacityBig.Visibility = Visibility.Collapsed;
Logo.Visibility = Visibility.Visible;
StopLogo.Visibility = Visibility.Collapsed;
BtnColVis = true;
sb1.Stop();
micPlay.Stop();
//停止录音
await micphone.StopRecordAsync();
var stream = await micphoneStorageFile.OpenAsync(FileAccessMode.Read);
micPlay.SetSource(stream, this.micphoneStorageFile.FileType);
obs.Add(micphoneStorageFile.Name);
listView.ItemsSource = obs;
// lists.Add(micphoneStorageFile.Name );
// allAudio.List = new List<Audio>();
// allAudio.List.Add(new Audio() { FileName = micphoneStorageFile.Name });
// listView.ItemsSource = allAudio.List;
}
}
//</SnippetCreateFileInputNode>
//<SnippetCreateFileOutputNode>
private async Task CreateFileOutputNode()
{
FileSavePicker saveFilePicker = new FileSavePicker();
saveFilePicker.FileTypeChoices.Add("Pulse Code Modulation", new List <string>()
{
".wav"
});
saveFilePicker.FileTypeChoices.Add("Windows Media Audio", new List <string>()
{
".wma"
});
saveFilePicker.FileTypeChoices.Add("MPEG Audio Layer-3", new List <string>()
{
".mp3"
});
saveFilePicker.SuggestedFileName = "New Audio Track";
StorageFile file = await saveFilePicker.PickSaveFileAsync();
// File can be null if cancel is hit in the file picker
if (file == null)
{
return;
}
Windows.Media.MediaProperties.MediaEncodingProfile mediaEncodingProfile;
switch (file.FileType.ToString().ToLowerInvariant())
{
case ".wma":
mediaEncodingProfile = MediaEncodingProfile.CreateWma(AudioEncodingQuality.High);
break;
case ".mp3":
mediaEncodingProfile = MediaEncodingProfile.CreateMp3(AudioEncodingQuality.High);
break;
case ".wav":
mediaEncodingProfile = MediaEncodingProfile.CreateWav(AudioEncodingQuality.High);
break;
default:
throw new ArgumentException();
}
// Operate node at the graph format, but save file at the specified format
CreateAudioFileOutputNodeResult result = await audioGraph.CreateFileOutputNodeAsync(file, mediaEncodingProfile);
if (result.Status != AudioFileNodeCreationStatus.Success)
{
// FileOutputNode creation failed
ShowErrorMessage(result.Status.ToString());
return;
}
fileOutputNode = result.FileOutputNode;
}
public async void PickMedia()
{
var openPicker = new Windows.Storage.Pickers.FileOpenPicker();
openPicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.VideosLibrary;
openPicker.FileTypeFilter.Add(".wmv");
openPicker.FileTypeFilter.Add(".mp4");
StorageFile source = await openPicker.PickSingleFileAsync();
var savePicker = new Windows.Storage.Pickers.FileSavePicker();
savePicker.SuggestedStartLocation =
Windows.Storage.Pickers.PickerLocationId.VideosLibrary;
savePicker.DefaultFileExtension = ".mp3";
savePicker.SuggestedFileName = "New Video";
savePicker.FileTypeChoices.Add("MPEG3", new string[] { ".mp3" });
StorageFile destination = await savePicker.PickSaveFileAsync();
MediaEncodingProfile profile =
MediaEncodingProfile.CreateMp3(AudioEncodingQuality.High);
MediaTranscoder transcoder = new MediaTranscoder();
PrepareTranscodeResult prepareOp = await
transcoder.PrepareFileTranscodeAsync(source, destination, profile);
if (prepareOp.CanTranscode)
{
var transcodeOp = prepareOp.TranscodeAsync();
transcodeOp.Progress +=
new AsyncActionProgressHandler <double>(TranscodeProgress);
transcodeOp.Completed +=
new AsyncActionWithProgressCompletedHandler <double>(TranscodeComplete);
}
else
{
switch (prepareOp.FailureReason)
{
case TranscodeFailureReason.CodecNotFound:
System.Diagnostics.Debug.WriteLine("Codec not found.");
break;
case TranscodeFailureReason.InvalidProfile:
System.Diagnostics.Debug.WriteLine("Invalid profile.");
break;
default:
System.Diagnostics.Debug.WriteLine("Unknown failure.");
break;
}
}
}
//点击开始录音后调用麦克风开始录音
private async void Start_Click(object sender, RoutedEventArgs e)
{
micphoneStorageFile = await KnownFolders.VideosLibrary.CreateFileAsync(DateTime.Now.ToString("yyyy-MM-dd hh-mm-ss") + ".mp3", CreationCollisionOption.GenerateUniqueName);
MediaEncodingProfile recordProfile = null;
recordProfile = MediaEncodingProfile.CreateM4a(AudioEncodingQuality.Auto);
recordProfile = MediaEncodingProfile.CreateMp3(AudioEncodingQuality.Auto);
await micphone.InitializeAsync();
await micphone.StartRecordToStorageFileAsync(MediaEncodingProfile.CreateMp3(AudioEncodingQuality.Auto), this.micphoneStorageFile);
}
public async void Record()
{
await init();
await capture.StartRecordToStreamAsync(MediaEncodingProfile.CreateMp3(AudioEncodingQuality.Auto), buffer);
if (Recording)
{
throw new InvalidOperationException("cannot excute two records at the same time");
}
Recording = true;
}
/*
* Method for writing the video and audio files
*/
private async void WriteFileAsync(YouTubeVideo video)
{
StorageFile mp4StorageFile = await _storageFolder.CreateFileAsync(video.FullName, CreationCollisionOption.ReplaceExisting); // Store the video as a MP4
await FileIO.WriteBytesAsync(mp4StorageFile, video.GetBytes());
_mp3FileName = mp4StorageFile.Name.Substring(0, mp4StorageFile.Name.Length - 14);
StorageFile mp3StorageFile = await _storageFolder.CreateFileAsync(_mp3FileName + ".mp3", CreationCollisionOption.ReplaceExisting);
var profile = MediaEncodingProfile.CreateMp3(AudioEncodingQuality.High);
await ToAudioAsync(mp4StorageFile, mp3StorageFile, profile);
}
MediaEncodingProfile CreateMediaEncodingProfile(StorageFile file)
{
switch (file.FileType.ToString().ToLowerInvariant())
{
case ".wma": return(MediaEncodingProfile.CreateWma(AudioEncodingQuality.High));
case ".mp3": return(MediaEncodingProfile.CreateMp3(AudioEncodingQuality.High));
case ".wav": return(MediaEncodingProfile.CreateWav(AudioEncodingQuality.High));
default: throw new ArgumentException();
}
}
private async void ButtonBase_OnClick(object sender, RoutedEventArgs e)
{
mediaCapture = new MediaCapture();
await mediaCapture.InitializeAsync();
storageFolder = ApplicationData.Current.LocalFolder;
storageFile = await storageFolder.CreateFileAsync("test.mp3", CreationCollisionOption.GenerateUniqueName);
lowLagMedia = await mediaCapture.PrepareLowLagRecordToStorageFileAsync(
MediaEncodingProfile.CreateMp3(AudioEncodingQuality.High), storageFile);
await lowLagMedia.StartAsync();
}
public static Task <bool> TryTranscodeAudioAsync(IStorageFile input, IStorageFile output, bool hq, IProgress <double?> progress, CancellationToken token = default)
{
try
{
Analytics.TrackEvent("MediaTranscoding_AudioTranscodeRequested");
var profile = MediaEncodingProfile.CreateMp3(hq ? AudioEncodingQuality.High : AudioEncodingQuality.Medium);
return(TryTranscodeMediaAsync(input, output, profile, progress, token));
}
finally
{
Analytics.TrackEvent("MediaTranscoding_AudioTranscodeComplete");
}
}
public async void ExtractAudio(string artist, string title, StorageFile videoFile, StorageFile audioFile)
{
if (this.transcoder == null)
{
this.transcoder = new MediaTranscoder();
this.encodingProfile = MediaEncodingProfile.CreateMp3(AudioEncodingQuality.High);
}
var preparedTranscodeResult = await this.transcoder.PrepareFileTranscodeAsync(videoFile, audioFile, this.encodingProfile);
await preparedTranscodeResult.TranscodeAsync();
await TagStorageFile(artist, title, audioFile);
}
async void Start()
{
if (!IsWorking)
{
try
{
if (mediaCapture != null)
{
try
{
mediaCapture.Failed -= MediaCapture_Failed;
mediaCapture.RecordLimitationExceeded -= MediaCapture_RecordLimitationExceeded;
}
catch { }
try
{
mediaCapture.Dispose();
mediaCapture = null;
}
catch { }
}
Duration = 0;
mediaCapture = new MediaCapture();
await mediaCapture.InitializeAsync();
mediaCapture.Failed += MediaCapture_Failed;
mediaCapture.RecordLimitationExceeded += MediaCapture_RecordLimitationExceeded;
if (file != null)
{
try
{
await file.DeleteAsync(StorageDeleteOption.PermanentDelete);
}
catch { }
}
var name = Helper.GenerateRandomString();
file = await localFolder.CreateFileAsync($"{name}.m4a", CreationCollisionOption.GenerateUniqueName);
await mediaCapture.StartRecordToStorageFileAsync(
MediaEncodingProfile.CreateMp3(AudioEncodingQuality.Low), file);
IsWorking = true;
StopGrid.Visibility = Visibility.Visible;
RecordGrid.Visibility = Visibility.Collapsed;
RootTimer.Start();
}
catch (Exception ex) { ex.PrintException("Start"); }
}
}
async private void ToggleRecord2(object sender, RoutedEventArgs e)
{
var btn_record_audio = sender as ToggleButton;
if (btn_record_audio.IsChecked == false)
{
_graph_record.Stop();
_graph_record.Dispose();
await PlayAudio(_target_file);
//using the media element to play the sound
//var raf_stream = await _target_file.OpenReadAsync();
//media.SetSource(raf_stream, "");
//media.Play();
}
else
{
//initialize the audio graph for recording and then start recording
AudioGraphSettings settings = new AudioGraphSettings(AudioRenderCategory.Media);
settings.QuantumSizeSelectionMode = QuantumSizeSelectionMode.LowestLatency;
CreateAudioGraphResult result = await AudioGraph.CreateAsync(settings);
if (result.Status == AudioGraphCreationStatus.Success)
{
_graph_record = result.Graph;
//setup the input
var input_node = (await _graph_record.CreateDeviceInputNodeAsync(Windows.Media.Capture.MediaCategory.Other)).DeviceInputNode;
//setup the output (place where audio will be recorded to)
var feedback_folder = await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFolderAsync("AudioFeedback", CreationCollisionOption.OpenIfExists);
_target_file = await feedback_folder.CreateFileAsync("audio message.mp3", CreationCollisionOption.GenerateUniqueName);
var profile = MediaEncodingProfile.CreateMp3(AudioEncodingQuality.High);
var file_output_node = (await _graph_record.CreateFileOutputNodeAsync(_target_file, profile)).FileOutputNode;
//direct the input to the output
input_node.AddOutgoingConnection(file_output_node);
media.Stop(); //stop playback since we are recording
_graph_record.Start();
}
else
{
await new MessageDialog("Could not initialize recorder").ShowAsync();
}
}
}
private async void StartRecord()
{
if (!b)
{
file = await folder.CreateFileAsync(DateTime.Now.ToString("yyyy-MM-dd hh-mm-ss") + ".mp3", CreationCollisionOption.GenerateUniqueName);
await micphone.StartRecordToStorageFileAsync(MediaEncodingProfile.CreateMp3(AudioEncodingQuality.Auto), file);
b = true;
logo.StartFlash();
}
else
{
await new MessageDialog("已经开始了好不好?").ShowAsync();
}
}
async private Task RecordAsync(ToggleButton btn_record_audio)
{
MediaCaptureInitializationSettings settings = new MediaCaptureInitializationSettings();
settings.StreamingCaptureMode = StreamingCaptureMode.Audio;
_capture = new MediaCapture();
await _capture.InitializeAsync(settings);
var profile = MediaEncodingProfile.CreateMp3(AudioEncodingQuality.High);
var feedback_folder = await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFolderAsync("AudioFeedback", CreationCollisionOption.OpenIfExists);
_target_file = await feedback_folder.CreateFileAsync("audio message.mp3", CreationCollisionOption.GenerateUniqueName);
await _capture.StartRecordToStorageFileAsync(profile, _target_file);
}
/// <summary>
/// Starts recording, data is stored in memory
/// </summary>
/// <param name="filePath"></param>
public async void startRecording(string filePath)
{
if (this.player != null)
{
this.handler.InvokeCustomScript(new ScriptCallback(CallbackFunction, this.id, MediaError, MediaErrorPlayModeSet), false);
}
else
{
try
{
var mediaCaputreSettings = new MediaCaptureInitializationSettings();
mediaCaputreSettings.StreamingCaptureMode = StreamingCaptureMode.Audio;
audioCaptureTask = new MediaCapture();
await audioCaptureTask.InitializeAsync(mediaCaputreSettings);
var mediaEncodingProfile = MediaEncodingProfile.CreateMp3(AudioEncodingQuality.Auto);
var storageFile = await KnownFolders.MusicLibrary.CreateFolderAsync("folder", CreationCollisionOption.OpenIfExists);
var storageFile1 = await storageFile.CreateFileAsync("1.wav", CreationCollisionOption.ReplaceExisting);
var timer = new Windows.UI.Xaml.DispatcherTimer();
timer.Tick += async delegate(object sender, object e)
{
timer.Stop();
await audioCaptureTask.StopRecordAsync();
this.handler.InvokeCustomScript(new ScriptCallback(CallbackFunction, this.id, MediaState, PlayerState_Stopped), false);
if (storageFile != null)
{
}
};
timer.Interval = TimeSpan.FromMilliseconds(captureAudioDuration * 1000);
await audioCaptureTask.StartRecordToStorageFileAsync(mediaEncodingProfile, storageFile1);
timer.Start();
this.SetState(PlayerState_Running);
}
catch (Exception)
{
this.handler.InvokeCustomScript(new ScriptCallback(CallbackFunction, this.id, MediaError, MediaErrorStartingRecording), false);
}
}
}
private async Task RecordStartAsync(string filePath, MediaFormat format)
{
if (_Stream != null)
{
_Stream.Dispose();
}
_Stream = new InMemoryRandomAccessStream();
// TODO: Audio Formats - Note that Apple does not support MP3 recording, only playback.
if (format == MediaFormat.WAV)
{
await _Capture.StartRecordToStreamAsync(MediaEncodingProfile.CreateWav(AudioEncodingQuality.High), _Stream);
}
else if (format == MediaFormat.MP3)
{
await _Capture.StartRecordToStreamAsync(MediaEncodingProfile.CreateMp3(AudioEncodingQuality.High), _Stream);
}
}
public async Task StartAudioCapture()
{
mediaCapture = new MediaCapture();
await mediaCapture.InitializeAsync();
//<SnippetStartAudioCapture>
mediaCapture.RecordLimitationExceeded += MediaCapture_RecordLimitationExceeded;
var localFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
StorageFile file = await localFolder.CreateFileAsync("audio.mp3", CreationCollisionOption.GenerateUniqueName);
_mediaRecording = await mediaCapture.PrepareLowLagRecordToStorageFileAsync(
MediaEncodingProfile.CreateMp3(AudioEncodingQuality.High), file);
await _mediaRecording.StartAsync();
//</SnippetStartAudioCapture>
}
private async void recordBtn_Click(object sender, RoutedEventArgs e)
{
if (record)
{
//already recored process
}
else
{
await RecordProcess();
await capture.StartRecordToStreamAsync(MediaEncodingProfile.CreateMp3(AudioEncodingQuality.Auto), buffer);
if (record)
{
throw new InvalidOperationException();
}
record = true;
}
}
public async Task StartAsync()
{
if (IsRecording)
{
return;
}
Stream = new InMemoryRandomAccessStream();
mediaCapture = new MediaCapture();
var settings = new MediaCaptureInitializationSettings()
{
StreamingCaptureMode = StreamingCaptureMode.Audio,
AudioProcessing = Windows.Media.AudioProcessing.Raw
};
await mediaCapture.InitializeAsync(settings);
await mediaCapture.StartRecordToStreamAsync(MediaEncodingProfile.CreateMp3(AudioEncodingQuality.Auto), Stream);
IsRecording = true;
}
private async void CaptureAudio(object sender, RoutedEventArgs e)
{
//Wave.Visibility = Visibility.Visible;
//voice.Visibility = Visibility.Collapsed;
Stop.Visibility = Visibility.Visible;
try
{
String fileName = _audioFileName;
_recordStorageFile = await KnownFolders.MusicLibrary.CreateFileAsync(fileName, CreationCollisionOption.GenerateUniqueName);
MediaEncodingProfile recordProfile = MediaEncodingProfile.CreateMp3(AudioEncodingQuality.Auto);
await _mediaCaptureManager.StartRecordToStorageFileAsync(recordProfile, this._recordStorageFile);
}
catch (Exception)
{
Debug.WriteLine("Failed to capture audio");
}
}
public async void Record()
{
try
{
if (this.IsRecording)
{
throw new InvalidOperationException("Recording already in progress!");
}
this.MemoryBuffer = new InMemoryRandomAccessStream();
this.DisposeMedia();
MediaCaptureInitializationSettings settings =
new MediaCaptureInitializationSettings
{
StreamingCaptureMode = StreamingCaptureMode.Audio
};
this.MediaCapture = new MediaCapture();
await this.MediaCapture.InitializeAsync(settings);
await this.MediaCapture.StartRecordToStreamAsync(
MediaEncodingProfile.CreateMp3(AudioEncodingQuality.Auto), this.MemoryBuffer);
this.IsRecording = true;
}
catch (Exception)
{
this.IsRecording = false;
// show a message to the user
if (this.playbackMediaElement != null)
{
TextToSpeechEngine.SpeakText(this.playbackMediaElement, "Sorry, but there was an issue with recording your voice. Try to make sure your machine has a microphone, and that microphone access is enabled for this app.");
}
else
{
// create a new media element
TextToSpeechEngine.SpeakText(new MediaElement(), "Sorry, but there was an issue with recording your voice. Try to make sure your machine has a microphone, and that microphone access is enabled for this app.");
}
}
}