public VideoMP3Transcoder(string _destination, IStorageFile _file, AudioEncodingQuality _quality, bool _isM4A)
{
destination = _destination;
file = _file;
quality = _quality;
isM4A = _isM4A;
}
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();
}
/// <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);
}
/// <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((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));
}
public static void ChangeQuality(AudioEncodingQuality quality)
{
ApplicationData.Current.LocalSettings.Values["outQuality"] = (int) quality;
}
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);
}
}
private async Task HandleDownloadAsync(DownloadOperation download, bool start)
{
try
{
Debug.WriteLine("Running: " + download.Guid);
// Store the download so we can pause/resume.
activeDownloads.Add(download);
Progress <DownloadOperation> progressCallback = new Progress <DownloadOperation>(DownloadProgress);
if (start) // Start the download and attach a progress handler.
{
await download.StartAsync().AsTask(cts.Token, progressCallback);
}
else // The download was already running when the application started, re-attach the progress handler.
{
await download.AttachAsync().AsTask(cts.Token, progressCallback);
}
ResponseInformation response = download.GetResponseInformation();
Debug.WriteLine(String.Format(CultureInfo.CurrentCulture, "Completed: {0}, Status Code: {1}", download.Guid, response.StatusCode));
// Move the downloaded file from Temporary folder to the selected folder
if (StorageFileDictionary.ContainsKey(download.ResultFile.Name))
{
StorageFile file_selectedLocation = StorageFileDictionary[download.ResultFile.Name];
// convert item to mp3 first
if (IsMusicDictionary[download.ResultFile.Name])
{
Debug.WriteLine("Converting video to mp3: " + download.Guid);
// Others in [File]
string OriginalFileName = download.ResultFile.Name;
AudioEncodingQuality audioQuality = AudioQualityDictionary[download.ResultFile.Name];
bool ism4a = IsisM4ADictionary[download.ResultFile.Name];
IStorageFile result = null;
VideoMP3Transcoder extractor = new VideoMP3Transcoder(OriginalFileName, download.ResultFile, audioQuality, ism4a);
result = await Task.Run(async() =>
await extractor.ConvertToMP3()
);
Debug.WriteLine("Result: " + result != null);
try
{
await result.MoveAndReplaceAsync(file_selectedLocation);
}
catch (Exception e)
{
Debug.WriteLine(e.Message.ToString());
}
if (result != null)
{
Debug.WriteLine("Done converting to mp3: " + download.Guid);
}
else
{
Debug.WriteLine("Error converting to mp3: " + download.Guid);
}
}
else
{
await download.ResultFile.MoveAndReplaceAsync(StorageFileDictionary[download.ResultFile.Name]);
}
}
}
catch (TaskCanceledException)
{
Debug.WriteLine("Canceled: " + download.Guid);
}
catch (Exception ex)
{
if (!IsExceptionHandled("Execution error", ex, download))
{
throw;
}
}
finally
{
activeDownloads.Remove(download);
// Event calling for status msg
DownloadStatusMessageChanged?.Invoke("Download complete", download.ResultFile.Name);
}
}
public async void Download(string DownloadURL, string DestinationFileName, StorageFile destinationFile, AudioEncodingQuality AudioQuality, bool IsVideo, bool IsM4A)
{
try
{
// Temporary destination folder
StorageFile tempDestinationFile = await ApplicationData.Current.TemporaryFolder.CreateFileAsync(DestinationFileName, CreationCollisionOption.GenerateUniqueName);
// Add the place where the user wants to save to a dictionary first. Our file will first be saved to a temp folder
if (StorageFileDictionary.ContainsKey(tempDestinationFile.Name))
{
StorageFileDictionary.Remove(tempDestinationFile.Name);
}
StorageFileDictionary.Add(tempDestinationFile.Name, destinationFile);
// Add to audio encoding quality
if (!IsVideo)
{
if (AudioQualityDictionary.ContainsKey(tempDestinationFile.Name))
{
AudioQualityDictionary.Remove(tempDestinationFile.Name);
}
AudioQualityDictionary.Add(tempDestinationFile.Name, AudioQuality);
}
// Add to isMusicDictionary
if (IsMusicDictionary.ContainsKey(tempDestinationFile.Name))
{
IsMusicDictionary.Remove(tempDestinationFile.Name);
}
IsMusicDictionary.Add(tempDestinationFile.Name, !IsVideo);
// Add to M4A dictionary, since Windows Phone doesnt support mp3
if (IsisM4ADictionary.ContainsKey(tempDestinationFile.Name))
{
IsisM4ADictionary.Remove(tempDestinationFile.Name);
}
IsisM4ADictionary.Add(tempDestinationFile.Name, IsM4A);
// Create a new instance of background downloader
BackgroundDownloader downloader = new BackgroundDownloader();
Uri fileDownloadUri = new Uri(DownloadURL, UriKind.Absolute);
DownloadOperation download = downloader.CreateDownload(fileDownloadUri, tempDestinationFile);
download.Priority = BackgroundTransferPriority.High;
Debug.WriteLine(String.Format(CultureInfo.CurrentCulture, "Downloading {0} to {1} with {2} priority, {3}", fileDownloadUri.AbsoluteUri, DestinationFileName, download.Priority, download.Guid));
List <DownloadOperation> requestOperations = new List <DownloadOperation>();
requestOperations.Add(download);
// If the app isn't actively being used, at some point the system may slow down or pause long running
// downloads. The purpose of this behavior is to increase the device's battery life.
// By requesting unconstrained downloads, the app can request the system to not suspend any of the
// downloads in the list for power saving reasons.
// Use this API with caution since it not only may reduce battery life, but it may show a prompt to
// the user.
UnconstrainedTransferRequestResult result;
try
{
result = await BackgroundDownloader.RequestUnconstrainedDownloadsAsync(requestOperations);
}
catch (NotImplementedException)
{
Debug.WriteLine("BackgroundDownloader.RequestUnconstrainedDownloadsAsync is not supported in Windows Phone.");
return;
}
Debug.WriteLine(String.Format(CultureInfo.CurrentCulture, "Request for unconstrained downloads has been {0}",
(result.IsUnconstrained ? "granted" : "denied")));
await HandleDownloadAsync(download, true);
}
catch (Exception ex)
{
IsExceptionHandled("Download Error", ex);
}
}
private void AudioQuality_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
SelectedQuality = (AudioEncodingQuality)AudioQuality.SelectedItem;
}
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);
}
private void AudioQuality_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
_encodingQuality = (AudioEncodingQuality)AudioQuality.SelectedItem;
}
public static async Task <bool> ConvertAudioAsync(StorageFile sourceAudio, StorageFile destinationAudio, AudioFormat AudioType = AudioFormat.MP3, AudioEncodingQuality audioEncodingQuality = AudioEncodingQuality.High)
{
ConvertToMp3Manager convertToMp3Manager = new ConvertToMp3Manager(sourceAudio, destinationAudio, AudioType, audioEncodingQuality);
var success = await convertToMp3Manager.ConvertAudioAsync();
return(success);
}
