/// <summary>
/// 'Start Audio Record' button click action function
/// Button name is changes to 'Stop Audio Record' once recording is started
/// Records audio to a file in the default account video folder
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void recordAudio_Click(object sender, RoutedEventArgs e)
{
recordAudio.IsEnabled = false;
playbackElement3.Source = null;
try
{
if (recordAudio.Content.ToString() == "Start Audio Record")
{
audioFile = await Windows.Storage.KnownFolders.VideosLibrary.CreateFileAsync(AUDIO_FILE_NAME, Windows.Storage.CreationCollisionOption.GenerateUniqueName);
status.Text = "Audio storage file preparation successful";
MediaEncodingProfile recordProfile = null;
recordProfile = MediaEncodingProfile.CreateM4a(Windows.Media.MediaProperties.AudioEncodingQuality.Auto);
await mediaCapture.StartRecordToStorageFileAsync(recordProfile, audioFile);
isRecording = true;
recordAudio.IsEnabled = true;
recordAudio.Content = "Stop Audio Record";
status.Text = "Audio recording in progress... press \'Stop Audio Record\' to stop";
}
else
{
status.Text = "Stopping audio recording...";
await mediaCapture.StopRecordAsync();
isRecording = false;
recordAudio.IsEnabled = true;
recordAudio.Content = "Start Audio Record";
var stream = await audioFile.OpenAsync(Windows.Storage.FileAccessMode.Read);
status.Text = "Playback recorded audio: " + audioFile.Path;
playbackElement3.AutoPlay = true;
playbackElement3.SetSource(stream, audioFile.FileType);
playbackElement3.Play();
}
}
catch (Exception ex)
{
status.Text = ex.Message;
Cleanup();
}
finally
{
recordAudio.IsEnabled = true;
}
}
public async void Record()
{
//Wait for init method to complet
await Init();
//Wait for capture
await capture.StartRecordToStreamAsync(MediaEncodingProfile.CreateM4a(AudioEncodingQuality.Auto), buffer);
if (Recording)
{
throw new InvalidOperationException("cannot excute two records at the same time");
}
Recording = true;
}
internal async void btnStartStopRecord_Click(Object sender, Windows.UI.Xaml.RoutedEventArgs e)
{
try
{
String fileName;
EnableButton(false, "StartStopRecord");
if (!m_bRecording)
{
ShowStatusMessage("Starting Record");
fileName = AUDIO_FILE_NAME;
m_recordStorageFile = await Windows.Storage.KnownFolders.VideosLibrary.CreateFileAsync(fileName, Windows.Storage.CreationCollisionOption.GenerateUniqueName);
ShowStatusMessage("Create record file successful");
MediaEncodingProfile recordProfile = null;
recordProfile = MediaEncodingProfile.CreateM4a(Windows.Media.MediaProperties.AudioEncodingQuality.Auto);
await m_mediaCaptureMgr.StartRecordToStorageFileAsync(recordProfile, this.m_recordStorageFile);
m_bRecording = true;
SwitchRecordButtonContent();
EnableButton(true, "StartStopRecord");
ShowStatusMessage("Start Record successful");
}
else
{
stopRack.Visibility = Visibility.Collapsed;
ShowStatusMessage("Stopping Record");
await m_mediaCaptureMgr.StopRecordAsync();
m_bRecording = false;
EnableButton(true, "StartStopRecord");
SwitchRecordButtonContent();
ShowStatusMessage("Stop record successful");
}
}
catch (Exception exception)
{
EnableButton(true, "StartStopRecord");
ShowExceptionMessage(exception);
m_bRecording = false;
}
}
public async Task <bool> Start(int sampleRate)
{
if (!await Init(sampleRate))
{
return(false);
}
await _capture.StartRecordToStreamAsync(MediaEncodingProfile.CreateM4a(AudioEncodingQuality.Auto), _buffer);
if (Recording)
{
throw new InvalidOperationException("cannot excute two records at the same time");
}
Recording = true;
return(Recording);
}
//ToDo-Make it public via an interface
internal async Task <bool> Record()
{
if (isRecording)
{
loggingChannel.LogMessage("\nCurrent recording is not yet finished,so skip this cycle");
NumberOfMissedRecordings++;
return(isRecording);
}
DateTime currentDate = DateTime.UtcNow;
var audioFileName = AudioFilePrefix + "_" + currentDate.ToString("yyyyMMddHHmmssfff") + ".m4a";
try
{
//FindCodecsOnThisDevice();//ToDo-enable in debug
var stopwatch = Stopwatch.StartNew();
loggingChannel.LogMessage("\nStarted audio recording");
var audioFile = await KnownFolders.VideosLibrary.CreateFileAsync(audioFileName, CreationCollisionOption.GenerateUniqueName);
var recordProfileM4a = MediaEncodingProfile.CreateM4a(AudioEncodingQuality.Low);
recordProfileM4a.Audio = AudioEncodingProperties.CreatePcm(8000, 1, 16);
loggingChannel.LogMessage("\nAudio storage file preparation successful");
await mediaCapture.StartRecordToStorageFileAsync(recordProfileM4a, audioFile);
isRecording = true;
loggingChannel.LogMessage("\nAudio recording in progress...");
Thread.Sleep(recordingTimeInMilliSeconds);
await StopRecording();
stopwatch.Stop();
loggingChannel.LogMessage("Recording logic took " + stopwatch.Elapsed.Seconds.ToString() + " seconds");
SendToIotHub(currentDate, audioFile);
return(isRecording);
}
catch (Exception ex)
{
loggingChannel.LogMessage("\n" + ex.Message);
Cleanup();
return(isRecording);
}
}
public async Task <bool> Record()
{
try
{
await init();
await capture.StartRecordToStreamAsync(MediaEncodingProfile.CreateM4a(AudioEncodingQuality.Auto), buffer);
if (running)
{
throw new InvalidOperationException("cannot excute two records at the same time");
}
running = true;
}
catch (Exception e)
{
throw e;
}
return(true); //HACK!
}
private async void Button_Click(object sender, RoutedEventArgs e)//开始录音
{
try
{
//控制控件状态和动画
storyboard.Begin();
record.IsEnabled = false;
stop.IsEnabled = true;
String fileName = "1.aac";
//创建文件
_recordStorageFile = await KnownFolders.VideosLibrary.CreateFileAsync(fileName, CreationCollisionOption.GenerateUniqueName);
//关键就是这俩句
MediaEncodingProfile recordProfile = MediaEncodingProfile.CreateM4a(AudioEncodingQuality.Auto); //录音
await _mediaCaptureManager.StartRecordToStorageFileAsync(recordProfile, this._recordStorageFile); //将录音保存到视频库
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message.ToString());
}
}
async Task AudioTest()
{
var initSettings = new MediaCaptureInitializationSettings();
var mediaCapture = new MediaCapture();
await mediaCapture.InitializeAsync();
var storageFile = await KnownFolders.VideosLibrary.CreateFileAsync("audioOut.mp3", CreationCollisionOption.GenerateUniqueName);
var profile = MediaEncodingProfile.CreateM4a(AudioEncodingQuality.Auto);
await mediaCapture.StartRecordToStorageFileAsync(profile, storageFile);
await Task.Delay(TimeSpan.FromSeconds(5));
await mediaCapture.StopRecordAsync();
var stream = await storageFile.OpenAsync(FileAccessMode.Read);
if (stream != null)
{
mediaElement.SetSource(stream, storageFile.ContentType);
mediaElement.Play();
}
}
//녹음 버튼 클릭
private async void CaptureAudio()
{
try
{
Debug.WriteLine("Starting record");
String fileName = "record.m4a";
_recordStorageFile = await KnownFolders.VideosLibrary.CreateFileAsync(fileName, CreationCollisionOption.GenerateUniqueName);
Debug.WriteLine("Create record file successfully");
MediaEncodingProfile recordProfile = MediaEncodingProfile.CreateM4a(AudioEncodingQuality.Auto);
await _mediaCaptureManager.StartRecordToStorageFileAsync(recordProfile, this._recordStorageFile);
Debug.WriteLine("Start Record successful");
_recording = true;
}
catch (Exception e)
{
Debug.WriteLine("Failed to capture audio");
}
}
private async Task CaptureAudio()
{
try
{
Debug.WriteLine("Starting record");
var fileName = "audio.wav";
_recordStorageFile =
await
KnownFolders.VideosLibrary.CreateFileAsync(fileName, CreationCollisionOption.GenerateUniqueName);
Debug.WriteLine("Create record file successfully");
var recordProfile = MediaEncodingProfile.CreateM4a(AudioEncodingQuality.Auto);
await _mediaCaptureManager.StartRecordToStorageFileAsync(recordProfile, _recordStorageFile);
Debug.WriteLine("Start Record successful");
}
catch (Exception e)
{
Debug.WriteLine("Failed to capture audio:" + e.Message);
}
}
private async void Checked()
{
try
{
var settings = new Windows.Media.Capture.MediaCaptureInitializationSettings();
settings.StreamingCaptureMode = Windows.Media.Capture.StreamingCaptureMode.Audio;
settings.MediaCategory = Windows.Media.Capture.MediaCategory.Other;
settings.AudioProcessing = Windows.Media.AudioProcessing.Default;
await audioCapture.InitializeAsync(settings);
StorageFolder externalDevices = KnownFolders.RemovableDevices;
IReadOnlyList <StorageFolder> externalDrives = await externalDevices.GetFoldersAsync();
StorageFolder usbStorage = externalDrives[0];
//ENSURE FOLDER EXISTS
if (await usbStorage.TryGetItemAsync("Recording") == null)
{
await usbStorage.CreateFolderAsync("Recording");
}
string Folder_Pfad = "Recording\\" + DateTime.Now.Year.ToString();
if (await usbStorage.TryGetItemAsync(Folder_Pfad) == null)
{
await usbStorage.CreateFolderAsync(Folder_Pfad);
}
Folder_Pfad = Folder_Pfad + "\\" + DateTime.Now.Month.ToString();
if (await usbStorage.TryGetItemAsync(Folder_Pfad) == null)
{
await usbStorage.CreateFolderAsync(Folder_Pfad);
}
Folder_Pfad = Folder_Pfad + "\\" + DateTime.Now.Day.ToString();
if (await usbStorage.TryGetItemAsync(Folder_Pfad) == null)
{
await usbStorage.CreateFolderAsync(Folder_Pfad);
}
string Dateiname = "\\" + DateTime.Now.Year.ToString() + "-" + DateTime.Now.Month.ToString() + "-" + DateTime.Now.Day.ToString() + " "
+ DateTime.Now.Hour.ToString() + "_" + DateTime.Now.Minute.ToString() + "_" + DateTime.Now.Second.ToString() + ".mp3";
string Dateispeicher_Ort = Folder_Pfad + Dateiname;
StorageFile recordFile = await usbStorage.CreateFileAsync(Dateispeicher_Ort, Windows.Storage.CreationCollisionOption.GenerateUniqueName);
isRecording = true;
//await audioCapture.StartRecordToStorageFileAsync(MediaEncodingProfile.CreateMp3(AudioEncodingQuality.Auto), recordFile);
var audioRecording = await audioCapture.PrepareLowLagRecordToStorageFileAsync(MediaEncodingProfile.CreateM4a(AudioEncodingQuality.Medium), recordFile);
await audioRecording.StartAsync();
Task.Delay(10000).Wait();
Unchecked();
}
catch (Exception ex)
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => {
Result.Text += ex.Message;
});
}
}
private async Task Text2Audio(string text, StorageFile audio)
{
if (audio != null && !string.IsNullOrEmpty(text))
{
if (synth == null)
{
synth = new SpeechSynthesizer();
}
var voice = SpeechSynthesizer.AllVoices.Where(o => o.DisplayName == (string)cbVoice.SelectedItem);
synth.Voice = voice.First();
synth.Options.AudioPitch = sliderPitch.Value;
synth.Options.AudioVolume = sliderVolume.Value / 100.0;
synth.Options.SpeakingRate = sliderSpeed.Value;
//var options = new SpeechSynthesizerOptions();
SpeechSynthesisStream stream = await synth.SynthesizeTextToStreamAsync(text);
trans = new MediaTranscoder()
{
HardwareAccelerationEnabled = true,
AlwaysReencode = true,
//VideoProcessingAlgorithm = MediaVideoProcessingAlgorithm.MrfCrf444;
};
MediaEncodingProfile profile = MediaEncodingProfile.CreateMp3(AudioEncodingQuality.Medium);
if (audio.ContentType.EndsWith("wav", StringComparison.CurrentCultureIgnoreCase))
{
profile = MediaEncodingProfile.CreateWav(AudioEncodingQuality.Medium);
}
else if (audio.ContentType.EndsWith("aac", StringComparison.CurrentCultureIgnoreCase))
{
profile = MediaEncodingProfile.CreateM4a(AudioEncodingQuality.Medium);
}
else if (audio.ContentType.EndsWith("m4a", StringComparison.CurrentCultureIgnoreCase))
{
profile = MediaEncodingProfile.CreateM4a(AudioEncodingQuality.Medium);
}
else if (audio.FileType.EndsWith("alac", StringComparison.CurrentCultureIgnoreCase))
{
profile = MediaEncodingProfile.CreateAlac(AudioEncodingQuality.Medium);
}
else if (audio.ContentType.EndsWith("flac", StringComparison.CurrentCultureIgnoreCase))
{
profile = MediaEncodingProfile.CreateFlac(AudioEncodingQuality.Medium);
}
else if (audio.ContentType.EndsWith("mp4", StringComparison.CurrentCultureIgnoreCase))
{
profile = MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Pal);
}
using (IRandomAccessStream fso = await audio.OpenAsync(FileAccessMode.ReadWrite))
{
//var trans_result = await trans.PrepareFileTranscodeAsync(InFile, OutFile, profile_mp3);
var trans_result = await trans.PrepareStreamTranscodeAsync(stream, fso, profile);
if (trans_result.CanTranscode)
{
if (canceltsrc != null)
{
canceltsrc.Dispose();
canceltsrc = null;
}
canceltsrc = new CancellationTokenSource();
var progress = new Progress <double>(ps =>
{
edHearState.Text = $"{AppResources.GetString("ProcessingState")} {ps:N0}%";
//edHearState.Text = AppResources.GetString("ProcessingState");
});
await trans_result.TranscodeAsync().AsTask(canceltsrc.Token, progress);
edHearState.Text = AppResources.GetString("ProcessFinished");
}
else
{
edHearState.Text = AppResources.GetString("CanNotTrans");
}
}
}
}
/// <summary>
/// 提供音视频转码
/// </summary>
/// <param name="SourceFile">源文件</param>
/// <param name="DestinationFile">目标文件</param>
/// <param name="MediaTranscodeEncodingProfile">转码编码</param>
/// <param name="MediaTranscodeQuality">转码质量</param>
/// <param name="SpeedUp">是否启用硬件加速</param>
/// <returns></returns>
public static Task TranscodeFromAudioOrVideoAsync(StorageFile SourceFile, StorageFile DestinationFile, string MediaTranscodeEncodingProfile, string MediaTranscodeQuality, bool SpeedUp)
{
return(Task.Factory.StartNew((obj) =>
{
if (obj is ValueTuple <StorageFile, StorageFile, string, string, bool> Para)
{
using (ExtendedExecutionController ExtExecution = ExtendedExecutionController.TryCreateExtendedExecution().Result)
{
IsAnyTransformTaskRunning = true;
AVTranscodeCancellation = new CancellationTokenSource();
MediaTranscoder Transcoder = new MediaTranscoder
{
HardwareAccelerationEnabled = true,
VideoProcessingAlgorithm = Para.Item5 ? MediaVideoProcessingAlgorithm.Default : MediaVideoProcessingAlgorithm.MrfCrf444
};
try
{
MediaEncodingProfile Profile = null;
VideoEncodingQuality VideoQuality = default;
AudioEncodingQuality AudioQuality = default;
switch (Para.Item4)
{
case "UHD2160p":
VideoQuality = VideoEncodingQuality.Uhd2160p;
break;
case "QVGA":
VideoQuality = VideoEncodingQuality.Qvga;
break;
case "HD1080p":
VideoQuality = VideoEncodingQuality.HD1080p;
break;
case "HD720p":
VideoQuality = VideoEncodingQuality.HD720p;
break;
case "WVGA":
VideoQuality = VideoEncodingQuality.Wvga;
break;
case "VGA":
VideoQuality = VideoEncodingQuality.Vga;
break;
case "High":
AudioQuality = AudioEncodingQuality.High;
break;
case "Medium":
AudioQuality = AudioEncodingQuality.Medium;
break;
case "Low":
AudioQuality = AudioEncodingQuality.Low;
break;
}
switch (Para.Item3)
{
case "MKV":
Profile = MediaEncodingProfile.CreateHevc(VideoQuality);
break;
case "MP4":
Profile = MediaEncodingProfile.CreateMp4(VideoQuality);
break;
case "WMV":
Profile = MediaEncodingProfile.CreateWmv(VideoQuality);
break;
case "AVI":
Profile = MediaEncodingProfile.CreateAvi(VideoQuality);
break;
case "MP3":
Profile = MediaEncodingProfile.CreateMp3(AudioQuality);
break;
case "ALAC":
Profile = MediaEncodingProfile.CreateAlac(AudioQuality);
break;
case "WMA":
Profile = MediaEncodingProfile.CreateWma(AudioQuality);
break;
case "M4A":
Profile = MediaEncodingProfile.CreateM4a(AudioQuality);
break;
}
PrepareTranscodeResult Result = Transcoder.PrepareFileTranscodeAsync(Para.Item1, Para.Item2, Profile).AsTask().Result;
if (Result.CanTranscode)
{
SendUpdatableToastWithProgressForTranscode(Para.Item1, Para.Item2);
Progress <double> TranscodeProgress = new Progress <double>((CurrentValue) =>
{
try
{
NotificationData Data = new NotificationData
{
SequenceNumber = 0
};
Data.Values["ProgressValue"] = (Math.Ceiling(CurrentValue) / 100).ToString();
Data.Values["ProgressValueString"] = Convert.ToInt32(CurrentValue) + "%";
ToastNotificationManager.CreateToastNotifier().Update(Data, "TranscodeNotification");
}
catch (Exception ex)
{
LogTracer.Log(ex, "Toast notification could not be sent");
}
});
Result.TranscodeAsync().AsTask(AVTranscodeCancellation.Token, TranscodeProgress).Wait();
CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
ShowTranscodeCompleteNotification(Para.Item1, Para.Item2);
}).AsTask().Wait();
}
else
{
LogTracer.Log("Transcode format is not supported");
Para.Item2.DeleteAsync(StorageDeleteOption.PermanentDelete).AsTask().Wait();
}
}
catch (AggregateException)
{
Para.Item2.DeleteAsync(StorageDeleteOption.PermanentDelete).AsTask().Wait();
}
catch (Exception ex)
{
LogTracer.Log(ex, "Transcode failed");
Para.Item2.DeleteAsync(StorageDeleteOption.PermanentDelete).AsTask().Wait();
}
finally
{
AVTranscodeCancellation.Dispose();
AVTranscodeCancellation = null;
IsAnyTransformTaskRunning = false;
}
}
}
}, (SourceFile, DestinationFile, MediaTranscodeEncodingProfile, MediaTranscodeQuality, SpeedUp), TaskCreationOptions.LongRunning));
}
private async Task TranscodeMediaAsync()
{
MediaVideoProcessingAlgorithm Algorithm = default;
if (ApplicationData.Current.LocalSettings.Values["MediaTranscodeAlgorithm"] is string TranscodeAlgorithm)
{
if (TranscodeAlgorithm == "MrfCrf444")
{
Algorithm = MediaVideoProcessingAlgorithm.MrfCrf444;
}
else if (TranscodeAlgorithm == "Default")
{
Algorithm = MediaVideoProcessingAlgorithm.Default;
}
MediaTranscoder Transcoder = new MediaTranscoder
{
HardwareAccelerationEnabled = true,
VideoProcessingAlgorithm = Algorithm
};
if (ApplicationData.Current.LocalSettings.Values["MediaTranscodeInputFileToken"] is string InputFileToken &&
ApplicationData.Current.LocalSettings.Values["MediaTranscodeOutputFileToken"] is string OutputFileToken)
{
try
{
var FutureItemAccessList = StorageApplicationPermissions.FutureAccessList;
InputFile = await FutureItemAccessList.GetFileAsync(InputFileToken);
OutputFile = await FutureItemAccessList.GetFileAsync(OutputFileToken);
if (ApplicationData.Current.LocalSettings.Values["MediaTranscodeEncodingProfile"] is string EncodingKind &&
ApplicationData.Current.LocalSettings.Values["MediaTranscodeQuality"] is string Quality)
{
MediaEncodingProfile Profile = null;
VideoEncodingQuality VideoQuality = default;
AudioEncodingQuality AudioQuality = default;
switch (Quality)
{
case "UHD2160p":
VideoQuality = VideoEncodingQuality.Uhd2160p;
break;
case "QVGA":
VideoQuality = VideoEncodingQuality.Qvga;
break;
case "HD1080p":
VideoQuality = VideoEncodingQuality.HD1080p;
break;
case "HD720p":
VideoQuality = VideoEncodingQuality.HD720p;
break;
case "WVGA":
VideoQuality = VideoEncodingQuality.Wvga;
break;
case "VGA":
VideoQuality = VideoEncodingQuality.Vga;
break;
case "High":
AudioQuality = AudioEncodingQuality.High;
break;
case "Medium":
AudioQuality = AudioEncodingQuality.Medium;
break;
case "Low":
AudioQuality = AudioEncodingQuality.Low;
break;
}
switch (EncodingKind)
{
case "MKV":
Profile = MediaEncodingProfile.CreateHevc(VideoQuality);
break;
case "MP4":
Profile = MediaEncodingProfile.CreateMp4(VideoQuality);
break;
case "WMV":
Profile = MediaEncodingProfile.CreateWmv(VideoQuality);
break;
case "AVI":
Profile = MediaEncodingProfile.CreateAvi(VideoQuality);
break;
case "MP3":
Profile = MediaEncodingProfile.CreateMp3(AudioQuality);
break;
case "ALAC":
Profile = MediaEncodingProfile.CreateAlac(AudioQuality);
break;
case "WMA":
Profile = MediaEncodingProfile.CreateWma(AudioQuality);
break;
case "M4A":
Profile = MediaEncodingProfile.CreateM4a(AudioQuality);
break;
}
PrepareTranscodeResult Result = await Transcoder.PrepareFileTranscodeAsync(InputFile, OutputFile, Profile);
if (Result.CanTranscode)
{
SendUpdatableToastWithProgress();
Progress <double> TranscodeProgress = new Progress <double>(ProgressHandler);
await Result.TranscodeAsync().AsTask(Cancellation.Token, TranscodeProgress);
ApplicationData.Current.LocalSettings.Values["MediaTranscodeStatus"] = "Success";
}
else
{
ApplicationData.Current.LocalSettings.Values["MediaTranscodeStatus"] = "转码格式不支持";
await OutputFile.DeleteAsync(StorageDeleteOption.PermanentDelete);
}
}
else
{
ApplicationData.Current.LocalSettings.Values["MediaTranscodeStatus"] = "SettingError: Miss MediaTranscodeEncodingProfile Or MediaTranscodeQuality";
await OutputFile.DeleteAsync(StorageDeleteOption.PermanentDelete);
}
}
public async Task <StorageFile> ConvertToMP3()
{
bool SuccessFlag = true;
try
{
StorageFolder folder = await ApplicationData.Current.TemporaryFolder.CreateFolderAsync("Conversion", CreationCollisionOption.OpenIfExists);
StorageFile destinationFile = await folder.CreateFileAsync(destination, CreationCollisionOption.GenerateUniqueName);
if (SuccessFlag)
{
mediatranscoder = new MediaTranscoder();
PrepareTranscodeResult transcoderesult = await mediatranscoder.PrepareFileTranscodeAsync(file, destinationFile, isM4A?MediaEncodingProfile.CreateM4a(quality) : MediaEncodingProfile.CreateMp3(quality));
if (transcoderesult.CanTranscode)
{
canceltoken = new CancellationToken();
await transcoderesult.TranscodeAsync();
SuccessFlag = true;
}
else
{
SuccessFlag = false;
}
}
if (SuccessFlag)
{
return(destinationFile);
}
else
{
return(null);
}
}
catch (Exception ee)
{
Debug.WriteLine(ee.ToString());
}
return(null);
}
async private void StartRadioButton_Click(object sender, RoutedEventArgs e)
{
if (_InputFile == null)
{
await new Windows.UI.Popups.MessageDialog("Please import a video or music file to convert").ShowAsync();
return;
}
VideoEncodingQuality videoQuallity = VideoEncodingQuality.Wvga;
if (CS.Width == 1920 && CS.Height == 1080)
{
videoQuallity = VideoEncodingQuality.HD1080p;
}
else if (CS.Width == 1280 && CS.Height == 720)
{
videoQuallity = VideoEncodingQuality.HD720p;
}
else if (CS.Width == 800 && CS.Height == 480)
{
videoQuallity = VideoEncodingQuality.Wvga;
}
else if (CS.Width == 720 && CS.Height == 480)
{
videoQuallity = VideoEncodingQuality.Ntsc;
}
else if (CS.Width == 720 && CS.Height == 576)
{
videoQuallity = VideoEncodingQuality.Pal;
}
else if (CS.Width == 640 && CS.Height == 480)
{
videoQuallity = VideoEncodingQuality.Vga;
}
else if (CS.Width == 320 && CS.Height == 240)
{
videoQuallity = VideoEncodingQuality.Qvga;
}
if (CS.Extension.ToLower().Equals("mp4"))
{
_Profile = MediaEncodingProfile.CreateMp4(videoQuallity);
}
else if (CS.Extension.ToLower().Equals("avi"))
{
_Profile = MediaEncodingProfile.CreateAvi(videoQuallity);
}
else if (CS.Extension.ToLower().Equals("wmv"))
{
_Profile = MediaEncodingProfile.CreateWmv(videoQuallity);
}
else if (CS.Extension.ToLower().Equals("wma"))
{
_Profile = MediaEncodingProfile.CreateWma(AudioEncodingQuality.High);
}
else if (CS.Extension.ToLower().Equals("wav"))
{
_Profile = MediaEncodingProfile.CreateWav(AudioEncodingQuality.High);
}
else if (CS.Extension.ToLower().Equals("mp3"))
{
_Profile = MediaEncodingProfile.CreateMp3(AudioEncodingQuality.High);
}
else if (CS.Extension.ToLower().Equals("m4a"))
{
_Profile = MediaEncodingProfile.CreateM4a(AudioEncodingQuality.High);
}
try
{
if (CS.Extension.ToLower().Equals("mp4") ||
CS.Extension.ToLower().Equals("avi") ||
CS.Extension.ToLower().Equals("wmv"))
{
_Profile.Video.Width = CS.Width;
_Profile.Video.Height = CS.Height;
_Profile.Video.Bitrate = CS.VideoBitRate;
}
_Profile.Audio.Bitrate = CS.AudioBitRate;
_Profile.Audio.SampleRate = CS.SampleRate;
}
catch (Exception exception)
{
vars.Output("StartRadioButton_Click ex: " + exception.Message);
_Profile = null;
return;
}
_cts = new CancellationTokenSource();
try
{
if (_InputFile != null && _Profile != null)
{
_OutputFileName = System.IO.Path.GetFileNameWithoutExtension(_InputFile.Path);
string extension = CS.Extension;
_OutputFileName = string.Format("[MC] {0}.{1}", _OutputFileName, extension);
_OutputFile = await KnownFolders.VideosLibrary.CreateFileAsync(_OutputFileName, CreationCollisionOption.GenerateUniqueName);
var preparedTranscodeResult = await _Transcoder.PrepareFileTranscodeAsync(_InputFile, _OutputFile, _Profile);
_Transcoder.VideoProcessingAlgorithm = MediaVideoProcessingAlgorithm.Default;
if (preparedTranscodeResult.CanTranscode)
{
var progress = new Progress <double>(TranscodeProgress);
stopwatch.Reset();
stopwatch.Start();
MASettings.GPVisibility = Visibility.Visible;
StopRadioButton.Visibility = Visibility.Visible;
await preparedTranscodeResult.TranscodeAsync().AsTask(_cts.Token, progress);
}
else
{
vars.Output(preparedTranscodeResult.FailureReason);
MASettings.GPVisibility = Visibility.Collapsed;
await new Windows.UI.Popups.MessageDialog("Failed to start.\r\nError: " + preparedTranscodeResult.FailureReason).ShowAsync();
StopRadioButton.Visibility = Visibility.Collapsed;
}
}
}
catch (TaskCanceledException)
{
MASettings.GPVisibility = Visibility.Collapsed;
StopRadioButton.Visibility = Visibility.Collapsed;
vars.Output("Transcode Canceled");
}
catch (Exception exception)
{
MASettings.GPVisibility = Visibility.Collapsed;
StopRadioButton.Visibility = Visibility.Collapsed;
await new Windows.UI.Popups.MessageDialog("Failed to convert.\r\nError: " + exception.Message).ShowAsync();
vars.Output(exception.Message);
}
}
private async Task Covert_music(string audio, string type)
{
using (SQLiteConnection db = new SQLiteConnection(App.DB_PATH))
{
MediaEncodingProfile profile = new MediaEncodingProfile();
if (type == ".mp3")
{
var Quality = Load_options(Json.Json_mp3);
profile = MediaEncodingProfile.CreateMp3(Quality);
}
else if (type == ".alac")
{
var Quality = Load_options(Json.Json_alac);
profile = MediaEncodingProfile.CreateAlac(Quality);
type = ".m4a";
}
else if (type == ".flac")
{
var Quality = Load_options(Json.Json_flac);
profile = MediaEncodingProfile.CreateFlac(Quality);
}
else if (type == ".aac")
{
var Quality = Load_options(Json.Json_aac);
profile = MediaEncodingProfile.CreateM4a(Quality);
type = ".m4a";
}
convert_type = type.Substring(1);
var songs = db.Query <Song>("Select * from Song");
foreach (var song in songs)
{
var format = db.Find <MusicFormat>(c => c.Id == song.FormatId);
var import_name = song.Path + song.NameSong + "." + format.NameFormat;
string new_name = song.Path + song.NameSong + type;
Main_folder = await Windows.Storage.AccessCache.StorageApplicationPermissions
.FutureAccessList.GetFolderAsync("Audio");
StorageFile oldfile = await Main_folder.GetFileAsync(import_name);
MusicProperties musicProperties = await oldfile.Properties.GetMusicPropertiesAsync();
if (oldfile.FileType != ".mp3" && oldfile.FileType != type &&
musicProperties.Bitrate > 500000)
{
StorageFile newfile = await Main_folder.CreateFileAsync(new_name, CreationCollisionOption.ReplaceExisting);
if (oldfile != null && newfile != null)
{
try
{
current_song = song;
all_convert_song++;
SongDeleteAfterConvert.Add(current_song);
MediaTranscoder transcoder = new MediaTranscoder();
PrepareTranscodeResult prepareOp = await transcoder.PrepareFileTranscodeAsync(oldfile, newfile, profile);
if (prepareOp.CanTranscode)
{
var transcodeOp = prepareOp.TranscodeAsync();
transcodeOp.Completed += async(IAsyncActionWithProgress <double> asyncInfo, AsyncStatus status) =>
{
asyncInfo.GetResults();
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
current_convert_song++;
});
};
}
}
catch (Exception exc)
{
var dialog = new MessageDialog(exc.ToString());
await dialog.ShowAsync();
}
}
}
}
do
{
await Task.Delay(TimeSpan.FromSeconds(3));
}while (all_convert_song != current_convert_song);
Delete_oldfile();
}
}
private async void OnTransCode(object sender, RoutedEventArgs e)
{
Button btn = sender as Button;
btn.IsEnabled = false;
// 從專案目錄中取得待轉碼的MP3檔案
Uri sourceFileUri = new Uri("ms-appx:///1.mp3");
StorageFile srcFile = await StorageFile.GetFileFromApplicationUriAsync(sourceFileUri);
// 取得“音樂”檔案目錄
StorageFolder musicFd = KnownFolders.MusicLibrary;
// 新檔名
string newFileName = "new_file.m4a";
// 建立新檔案
StorageFile disFile = await musicFd.CreateFileAsync(newFileName, CreationCollisionOption.ReplaceExisting);
// 響應轉碼處理進度
IProgress <double> progress = new Progress <double>((p) =>
{
// 更新進度
this.pb.Value = p;
});
// 案例化MediaTranscoder物件
MediaTranscoder transcoder = new MediaTranscoder();
PrepareTranscodeResult result = await transcoder.PrepareFileTranscodeAsync(srcFile, disFile, MediaEncodingProfile.CreateM4a(AudioEncodingQuality.High));
// 開始轉碼
if (result.CanTranscode)
{
await result.TranscodeAsync().AsTask(progress);
}
btn.IsEnabled = true;
}
public async Task WriteToStream(Stream output, HttpContent content, TransportContext context)
{
try
{
//
// Create a PCM audio source
//
var generator = new AudioSampleGenerator();
var source = new MediaStreamSource(
new AudioStreamDescriptor(
generator.EncodingProperties
)
);
source.CanSeek = false;
source.MusicProperties.Title = "CS_D_MediaStreamSource_EncodeAudio";
source.SampleRequested += (MediaStreamSource sender, MediaStreamSourceSampleRequestedEventArgs args) =>
{
try
{
Console.WriteLine("SampleRequested Time: {0}", generator.Time);
// Generate 5s of data
if (generator.Time.TotalSeconds < 5)
{
args.Request.Sample = generator.GenerateSample();
}
}
catch (Exception e)
{
Debug.WriteLine("Sample exception");
}
};
//
// Encode PCM to ADTS
//
var profile = MediaEncodingProfile.CreateM4a(AudioEncodingQuality.Medium);
profile.Container.Subtype = "ADTS";
var output2 = new PseudoSeekableStream(output); // Pretend the stream is seekable so .AsRandomAccessStream() works
var transcoder = new MediaTranscoder();
var result = await transcoder.PrepareMediaStreamSourceTranscodeAsync(
source,
output2.AsRandomAccessStream(),
profile
);
await result.TranscodeAsync();
}
catch (Exception e)
{
Debug.WriteLine("Transcode exception");
}
output.Close();
}
private async Task <bool> ExportToMusicFormat(StorageFile fileTarget, SpeechSynthesisStream synthStream)
{
bool success = false;
Debug.WriteLine(fileTarget.FileType + " selected");
// Set encoding profiles
_profile = null;
AudioEncodingQuality audioEncodingProfile = AudioEncodingQuality.High;
if (fileTarget.FileType == ".wma")
{
_profile = MediaEncodingProfile.CreateWma(audioEncodingProfile);
}
else if (fileTarget.FileType == ".mp3")
{
_profile = MediaEncodingProfile.CreateMp3(audioEncodingProfile);
}
else if (fileTarget.FileType == ".m4a")
{
_profile = MediaEncodingProfile.CreateM4a(audioEncodingProfile);
}
else
{
Debug.WriteLine("Can't select a media encoding profile");
return(success);
}
// Write temporary Wav to Temp-storage
ApplicationData appData = ApplicationData.Current;
StorageFile source = await appData.TemporaryFolder.CreateFileAsync("temporary.wav", CreationCollisionOption.ReplaceExisting);
try
{
using (var reader = new DataReader(synthStream))
{
await reader.LoadAsync((uint)synthStream.Size);
IBuffer buffer = reader.ReadBuffer((uint)synthStream.Size);
await FileIO.WriteBufferAsync(source, buffer);
}
}
catch (Exception ex)
{
Debug.WriteLine("Couldn't prepare wav for transcoding");
Debug.WriteLine(ex);
}
// Prepare transcoding files
var preparedTranscoderResult = await _transcoder.PrepareFileTranscodeAsync(source, fileTarget, _profile);
if (preparedTranscoderResult.CanTranscode)
{
// Set task for transcoding
await preparedTranscoderResult.TranscodeAsync().AsTask(_cts.Token);
// Set Music-properties
MusicProperties fileProperties = await fileTarget.Properties.GetMusicPropertiesAsync();
fileProperties.Title = fileTarget.DisplayName;
fileProperties.Artist = "Talkinator";
await fileProperties.SavePropertiesAsync();
// Prepare notification
// Add the file to app MRU and possibly system MRU
//RecentStorageItemVisibility visibility = SystemMRUCheckBox.IsChecked.Value ? RecentStorageItemVisibility.AppAndSystem : RecentStorageItemVisibility.AppOnly;
//rootPage.mruToken = StorageApplicationPermissions.MostRecentlyUsedList.Add(file, file.Name, visibility);
//RecentStorageItemVisibility visibility = RecentStorageItemVisibility.AppOnly;
//StorageApplicationPermissions.FutureAccessList.Add(fileTarget, fileTarget.DisplayName);
StorageFolder parentFolder = await fileTarget.GetParentAsync();
FolderLauncherOptions launcherOptions = new FolderLauncherOptions();
launcherOptions.ItemsToSelect.Add(fileTarget);
await Launcher.LaunchFolderAsync(parentFolder, launcherOptions);
// Report completed
success = true;
Debug.WriteLine(fileTarget.FileType + " export completed");
}
else
{
Debug.WriteLine(preparedTranscoderResult.FailureReason);
}
return(success);
}
private async Task OnSave(CancellationToken cancellationToken)
{
FileSavePicker fileSavePicker = new FileSavePicker();
fileSavePicker.FileTypeChoices.Add("Auto", new List <string>()
{
".mp4"
});
fileSavePicker.FileTypeChoices.Add("Avi_HD1080p", new List <string>()
{
".avi_HD1080p"
});
fileSavePicker.FileTypeChoices.Add("Avi_HD720p", new List <string>()
{
".avi_HD720p"
});
fileSavePicker.FileTypeChoices.Add("Avi_Ntsc", new List <string>()
{
".avi_Ntsc"
});
fileSavePicker.FileTypeChoices.Add("Avi_Pal", new List <string>()
{
".avi_Pal"
});
fileSavePicker.FileTypeChoices.Add("Avi_Qvga", new List <string>()
{
".avi_Qvga"
});
fileSavePicker.FileTypeChoices.Add("Avi_Vga", new List <string>()
{
".avi_Vga"
});
fileSavePicker.FileTypeChoices.Add("Avi_Wvga", new List <string>()
{
".avi_Wvga"
});
fileSavePicker.FileTypeChoices.Add("M4a_High", new List <string>()
{
".m4a_High"
});
fileSavePicker.FileTypeChoices.Add("M4a_Low", new List <string>()
{
".m4a_Low"
});
fileSavePicker.FileTypeChoices.Add("M4a_Medium", new List <string>()
{
".m4a_Medium"
});
fileSavePicker.FileTypeChoices.Add("Mp3_High", new List <string>()
{
".mp3_High"
});
fileSavePicker.FileTypeChoices.Add("Mp3_Low", new List <string>()
{
".mp3_Low"
});
fileSavePicker.FileTypeChoices.Add("Mp3_Medium", new List <string>()
{
".mp3_Medium"
});
fileSavePicker.FileTypeChoices.Add("Mp4_HD1080p", new List <string>()
{
".mp4_HD1080p"
});
fileSavePicker.FileTypeChoices.Add("Mp4_HD720p", new List <string>()
{
".mp4_HD720p"
});
fileSavePicker.FileTypeChoices.Add("Mp4_Ntsc", new List <string>()
{
".mp4_Ntsc"
});
fileSavePicker.FileTypeChoices.Add("Mp4_Pal", new List <string>()
{
".mp4_Pal"
});
fileSavePicker.FileTypeChoices.Add("Mp4_Qvga", new List <string>()
{
".mp4_Qvga"
});
fileSavePicker.FileTypeChoices.Add("Mp4_Vga", new List <string>()
{
".mp4_Vga"
});
fileSavePicker.FileTypeChoices.Add("Mp4_Wvga", new List <string>()
{
".mp4_Wvga"
});
fileSavePicker.FileTypeChoices.Add("Wav_High", new List <string>()
{
".wav_High"
});
fileSavePicker.FileTypeChoices.Add("Wav_Low", new List <string>()
{
".wav_Low"
});
fileSavePicker.FileTypeChoices.Add("Wav_Medium", new List <string>()
{
".wav_Medium"
});
fileSavePicker.FileTypeChoices.Add("Wma_High", new List <string>()
{
".wma_High"
});
fileSavePicker.FileTypeChoices.Add("Wma_Low", new List <string>()
{
".wma_Low"
});
fileSavePicker.FileTypeChoices.Add("Wma_Medium", new List <string>()
{
".wma_Medium"
});
fileSavePicker.FileTypeChoices.Add("Wmv_HD1080p", new List <string>()
{
".wmv_HD1080p"
});
fileSavePicker.FileTypeChoices.Add("Wmv_HD720p", new List <string>()
{
".wmv_HD720p"
});
fileSavePicker.FileTypeChoices.Add("Wmv_Ntsc", new List <string>()
{
".wmv_Ntsc"
});
fileSavePicker.FileTypeChoices.Add("Wmv_Pal", new List <string>()
{
".wmv_Pal"
});
fileSavePicker.FileTypeChoices.Add("Wmv_Qvga", new List <string>()
{
".wmv_Qvga"
});
fileSavePicker.FileTypeChoices.Add("Wmv_Vga", new List <string>()
{
".wmv_Vga"
});
fileSavePicker.FileTypeChoices.Add("Wmv_Wvga", new List <string>()
{
".wmv_Wvga"
});
fileSavePicker.SuggestedFileName = FileName ?? "output";
StorageFile outputFile = await fileSavePicker.PickSaveFileAsync();
if (outputFile == null)
{
throw new Exception();
}
ResetStages(solidColorBrush, 100, "100% done.");
Save.Content = "Cancel";
StorageFile temporaryFile = await GetFile("Video", "temp (1).mp4", cancellationToken);
if (temporaryFile == null)
{
return;
}
MediaEncodingProfile mediaEncodingProfile = null;
string fileType = outputFile.FileType.Replace(".", "");
if (fileType.ToLower() == "mp4")
{
using (Stream stream = await temporaryFile.OpenStreamForReadAsync())
{
buffer = new byte[stream.Length];
CancelTask(cancellationToken);
stream.Read(buffer, 0, buffer.Length);
ReportProgress(Stage7, Stage6ProgressBar, TextProgress6, 45);
using (Stream writeStream = await outputFile.OpenStreamForWriteAsync())
{
CancelTask(cancellationToken);
writeStream.Write(buffer, 0, buffer.Length);
};
ReportProgress(Stage7, Stage6ProgressBar, TextProgress6, 90);
};
ReportProgress(Stage7, Stage6ProgressBar, TextProgress6, 100);
Save.Content = "Convert/Save";
return;
}
else
{
try
{
await outputFile.RenameAsync(outputFile.DisplayName + "." + fileType.Split('_')[0], NameCollisionOption.GenerateUniqueName);
}
catch (Exception ex)
{
await MessageBox(ex.Message);
}
}
CancelTask(cancellationToken);
MediaFileType mediaFileType = default(MediaFileType);
VideoEncodingQuality videoEncodingQuality = default(VideoEncodingQuality);
AudioEncodingQuality audioEncodingQuality = default(AudioEncodingQuality);
Enum.TryParse <MediaFileType>(fileType.Split('_')[0], true, out mediaFileType);
Enum.TryParse <VideoEncodingQuality>(fileType.Split('_')[1], true, out videoEncodingQuality);
Enum.TryParse <AudioEncodingQuality>(fileType.Split('_')[1], true, out audioEncodingQuality);
switch (mediaFileType)
{
case MediaFileType.avi:
{
mediaEncodingProfile = MediaEncodingProfile.CreateAvi(videoEncodingQuality);
break;
}
case MediaFileType.m4a:
{
mediaEncodingProfile = MediaEncodingProfile.CreateM4a(audioEncodingQuality);
break;
}
case MediaFileType.mp3:
{
mediaEncodingProfile = MediaEncodingProfile.CreateMp3(audioEncodingQuality);
break;
}
case MediaFileType.mp4:
{
mediaEncodingProfile = MediaEncodingProfile.CreateMp4(videoEncodingQuality);
break;
}
case MediaFileType.wav:
{
mediaEncodingProfile = MediaEncodingProfile.CreateWav(audioEncodingQuality);
break;
}
case MediaFileType.wma:
{
mediaEncodingProfile = MediaEncodingProfile.CreateWma(audioEncodingQuality);
break;
}
case MediaFileType.wmv:
{
mediaEncodingProfile = MediaEncodingProfile.CreateWmv(videoEncodingQuality);
break;
}
}
CancelTask(cancellationToken);
await SetTranscoder(temporaryFile, outputFile, mediaEncodingProfile, cancellationToken);
}
/// <summary>
///
/// </summary>
/// <param name="fileTarget">File to write to</param>
/// <param name="synthStream">The SpeechSynthesisStream with the actual sound</param>
/// <param name="voice">The VoiceInformation for setting the correct voice in the artist</param>
/// <returns></returns>
private static async Task <bool> SaveAndEncodeFile(StorageFile fileTarget, SpeechSynthesisStream synthStream, VoiceInformation voice)
{
bool success = false;
// Initialise some stuff
MediaEncodingProfile _profile;
MediaTranscoder _transcoder = new MediaTranscoder();
CoreDispatcher _dispatcher = Window.Current.Dispatcher;
CancellationTokenSource _cts = new CancellationTokenSource();
Debug.WriteLine(fileTarget.FileType + " selected");
// Set encoding profiles
_profile = null;
AudioEncodingQuality audioEncodingProfile = AudioEncodingQuality.High;
if (fileTarget.FileType == ".wma")
{
_profile = MediaEncodingProfile.CreateWma(audioEncodingProfile);
}
else if (fileTarget.FileType == ".mp3")
{
_profile = MediaEncodingProfile.CreateMp3(audioEncodingProfile);
}
else if (fileTarget.FileType == ".m4a")
{
_profile = MediaEncodingProfile.CreateM4a(audioEncodingProfile);
}
else
{
Debug.WriteLine("Can't select a media encoding profile");
return(success);
}
// Write temporary Wav to Temp-storage
ApplicationData appData = ApplicationData.Current;
StorageFile source = await appData.TemporaryFolder.CreateFileAsync("temporary.wav", CreationCollisionOption.ReplaceExisting);
try
{
using (var reader = new DataReader(synthStream))
{
await reader.LoadAsync((uint)synthStream.Size);
IBuffer buffer = reader.ReadBuffer((uint)synthStream.Size);
await FileIO.WriteBufferAsync(source, buffer);
}
}
catch (Exception ex)
{
Debug.WriteLine("Couldn't prepare wav for transcoding");
Debug.WriteLine(ex);
}
// Prepare transcoding files
var preparedTranscoderResult = await _transcoder.PrepareFileTranscodeAsync(source, fileTarget, _profile);
if (preparedTranscoderResult.CanTranscode)
{
// Set task for transcoding
await preparedTranscoderResult.TranscodeAsync().AsTask(_cts.Token);
// Set Music-properties
MusicProperties fileProperties = await fileTarget.Properties.GetMusicPropertiesAsync();
fileProperties.Title = fileTarget.DisplayName;
fileProperties.Artist = ("Talkinator " + ResourceExtensions.GetLocalized("VoicedBy") + " " + voice.DisplayName);
await fileProperties.SavePropertiesAsync();
// #TODO: Add the newly created file to the systems MRU?
// Add the file to app MRU and possibly system MRU
//RecentStorageItemVisibility visibility = SystemMRUCheckBox.IsChecked.Value ? RecentStorageItemVisibility.AppAndSystem : RecentStorageItemVisibility.AppOnly;
//rootPage.mruToken = StorageApplicationPermissions.MostRecentlyUsedList.Add(file, file.Name, visibility);
//RecentStorageItemVisibility visibility = RecentStorageItemVisibility.AppOnly;
//StorageApplicationPermissions.FutureAccessList.Add(fileTarget, fileTarget.DisplayName);
// Report completed
success = true;
Debug.WriteLine(fileTarget.FileType + " export completed");
}
else
{
Debug.WriteLine(preparedTranscoderResult.FailureReason);
}
return(success);
}
/// <summary>
/// 提供音视频转码
/// </summary>
/// <param name="SourceFile">源文件</param>
/// <param name="DestinationFile">目标文件</param>
/// <param name="MediaTranscodeEncodingProfile">转码编码</param>
/// <param name="MediaTranscodeQuality">转码质量</param>
/// <param name="SpeedUp">是否启用硬件加速</param>
/// <returns></returns>
public static Task TranscodeFromAudioOrVideoAsync(StorageFile SourceFile, StorageFile DestinationFile, string MediaTranscodeEncodingProfile, string MediaTranscodeQuality, bool SpeedUp)
{
return Task.Factory.StartNew((ob) =>
{
IsAnyTransformTaskRunning = true;
AVTranscodeCancellation = new CancellationTokenSource();
var Para = (ValueTuple<StorageFile, StorageFile, string, string, bool>)ob;
MediaTranscoder Transcoder = new MediaTranscoder
{
HardwareAccelerationEnabled = true,
VideoProcessingAlgorithm = Para.Item5 ? MediaVideoProcessingAlgorithm.Default : MediaVideoProcessingAlgorithm.MrfCrf444
};
try
{
MediaEncodingProfile Profile = null;
VideoEncodingQuality VideoQuality = default;
AudioEncodingQuality AudioQuality = default;
switch (Para.Item4)
{
case "UHD2160p":
VideoQuality = VideoEncodingQuality.Uhd2160p;
break;
case "QVGA":
VideoQuality = VideoEncodingQuality.Qvga;
break;
case "HD1080p":
VideoQuality = VideoEncodingQuality.HD1080p;
break;
case "HD720p":
VideoQuality = VideoEncodingQuality.HD720p;
break;
case "WVGA":
VideoQuality = VideoEncodingQuality.Wvga;
break;
case "VGA":
VideoQuality = VideoEncodingQuality.Vga;
break;
case "High":
AudioQuality = AudioEncodingQuality.High;
break;
case "Medium":
AudioQuality = AudioEncodingQuality.Medium;
break;
case "Low":
AudioQuality = AudioEncodingQuality.Low;
break;
}
switch (Para.Item3)
{
case "MKV":
Profile = MediaEncodingProfile.CreateHevc(VideoQuality);
break;
case "MP4":
Profile = MediaEncodingProfile.CreateMp4(VideoQuality);
break;
case "WMV":
Profile = MediaEncodingProfile.CreateWmv(VideoQuality);
break;
case "AVI":
Profile = MediaEncodingProfile.CreateAvi(VideoQuality);
break;
case "MP3":
Profile = MediaEncodingProfile.CreateMp3(AudioQuality);
break;
case "ALAC":
Profile = MediaEncodingProfile.CreateAlac(AudioQuality);
break;
case "WMA":
Profile = MediaEncodingProfile.CreateWma(AudioQuality);
break;
case "M4A":
Profile = MediaEncodingProfile.CreateM4a(AudioQuality);
break;
}
PrepareTranscodeResult Result = Transcoder.PrepareFileTranscodeAsync(Para.Item1, Para.Item2, Profile).AsTask().Result;
if (Result.CanTranscode)
{
SendUpdatableToastWithProgressForTranscode(Para.Item1, Para.Item2);
Progress<double> TranscodeProgress = new Progress<double>((CurrentValue) =>
{
NotificationData Data = new NotificationData();
Data.SequenceNumber = 0;
Data.Values["ProgressValue"] = (Math.Ceiling(CurrentValue) / 100).ToString();
Data.Values["ProgressValueString"] = Convert.ToInt32(CurrentValue) + "%";
ToastNotificationManager.CreateToastNotifier().Update(Data, "TranscodeNotification");
});
Result.TranscodeAsync().AsTask(AVTranscodeCancellation.Token, TranscodeProgress).Wait();
ApplicationData.Current.LocalSettings.Values["MediaTranscodeStatus"] = "Success";
}
else
{
ApplicationData.Current.LocalSettings.Values["MediaTranscodeStatus"] = "NotSupport";
Para.Item2.DeleteAsync(StorageDeleteOption.PermanentDelete).AsTask().Wait();
}
}
catch (AggregateException)
{
ApplicationData.Current.LocalSettings.Values["MediaTranscodeStatus"] = "Cancel";
Para.Item2.DeleteAsync(StorageDeleteOption.PermanentDelete).AsTask().Wait();
}
catch (Exception e)
{
ApplicationData.Current.LocalSettings.Values["MediaTranscodeStatus"] = e.Message;
Para.Item2.DeleteAsync(StorageDeleteOption.PermanentDelete).AsTask().Wait();
}
}, (SourceFile, DestinationFile, MediaTranscodeEncodingProfile, MediaTranscodeQuality, SpeedUp), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Current).ContinueWith((task, ob) =>
{
AVTranscodeCancellation.Dispose();
AVTranscodeCancellation = null;
var Para = (ValueTuple<StorageFile, StorageFile>)ob;
if (ApplicationData.Current.LocalSettings.Values["MediaTranscodeStatus"] is string ExcuteStatus)
{
CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
switch (ExcuteStatus)
{
case "Success":
TabViewContainer.ThisPage.Notification.Show(Globalization.GetString("GeneralTransformer_Transcode_Success"), 5000);
ShowTranscodeCompleteNotification(Para.Item1, Para.Item2);
break;
case "Cancel":
TabViewContainer.ThisPage.Notification.Show(Globalization.GetString("GeneralTransformer_Transcode_Cancel"), 5000);
ShowTranscodeCancelNotification();
break;
case "NotSupport":
TabViewContainer.ThisPage.Notification.Show(Globalization.GetString("GeneralTransformer_Transcode_NotSupport"), 5000);
break;
default:
TabViewContainer.ThisPage.Notification.Show(Globalization.GetString("GeneralTransformer_Transcode_Failure") + ExcuteStatus, 5000);
break;
}
}).AsTask().Wait();
}
IsAnyTransformTaskRunning = false;
}, (SourceFile, DestinationFile), TaskScheduler.Current);
}
public MainPageViewModel()
{
_musicFiles = new ObservableCollection <StorageFile>();
CurrentFile = new GroorineFileViewModel(null);
//_player = new Player();
InitializeAsync();
DeleteCommand = new DelegateCommand(async(o) =>
{
if (!(o is StorageFile))
{
return;
}
var sf = o as StorageFile;
MusicFiles.Remove(sf);
await sf.DeleteAsync();
});
ExportCommand = new DelegateCommand(async(o) =>
{
if (!(o is StorageFile))
{
return;
}
var sf = o as StorageFile;
var fsp = new FileSavePicker();
fsp.FileTypeChoices.Add("Wave Audio", new List <string> {
".wav"
});
fsp.FileTypeChoices.Add("Windows Media Audio", new List <string> {
".wma"
});
fsp.FileTypeChoices.Add("MPEG 3 Audio", new List <string> {
".mp3"
});
fsp.FileTypeChoices.Add("MPEG 4 Audio", new List <string> {
".m4a"
});
fsp.SuggestedFileName = sf.DisplayName;
fsp.CommitButtonText = "Bounce";
StorageFile file = await fsp.PickSaveFileAsync();
if (file == null)
{
return;
}
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;
case ".m4a":
mediaEncodingProfile = MediaEncodingProfile.CreateM4a(AudioEncodingQuality.High);
break;
default:
throw new ArgumentException();
}
CreateAudioFileOutputNodeResult result = await _graph.CreateFileOutputNodeAsync(file, mediaEncodingProfile);
if (result.Status != AudioFileNodeCreationStatus.Success)
{
// FileOutputNode creation failed
await new MessageDialog("We couldn't create FileOutputNode, so we failed to bounce.").ShowAsync();
return;
}
AudioFileOutputNode node = result.FileOutputNode;
_graph.Stop();
_frameInputNode.AddOutgoingConnection(node);
Stop();
_player.Load(SmfParser.Parse(await sf.OpenStreamForReadAsync()));
Play();
_graph.Start();
var a = new BouncingDialog();
#pragma warning disable CS4014 // この呼び出しを待たないため、現在のメソッドの実行は、呼び出しが完了する前に続行します
a.ShowAsync();
#pragma warning restore CS4014 // この呼び出しを待たないため、現在のメソッドの実行は、呼び出しが完了する前に続行します
while (_player.IsPlaying)
{
await Task.Delay(1);
}
_graph.Stop();
await node.FinalizeAsync();
_graph.Start();
a.Hide();
await new MessageDialog("Bouncing has successfully finished!").ShowAsync();
});
}
