private async void Merge_OnClick(object sender, RoutedEventArgs e)
{
var pickerSave = new FileSavePicker
{
SuggestedStartLocation = PickerLocationId.VideosLibrary
};
pickerSave.FileTypeChoices.Add("MP4 files", new List <string>()
{
".mp4"
});
pickerSave.SuggestedFileName = "merged clips.mp4";
var saveFile = await pickerSave.PickSaveFileAsync();
if (saveFile == null)
{
return;
}
var saveOperation = composition.RenderToFileAsync(saveFile, MediaTrimmingPreference.Precise);
saveOperation.Progress = async(info, progress) =>
{
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, new DispatchedHandler(() =>
{
TextBlock.Text = $"Rendering... Progress: {progress:F0}%";
}));
};
}
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
private void RenderCompositionToFile(Windows.Storage.StorageFile file)
{
var mp4Profile = MediaEncodingProfile.CreateMp4(VideoEncodingQuality.HD720p);
var saveOperation = _mediaComposition.RenderToFileAsync(file, MediaTrimmingPreference.Fast, mp4Profile);
saveOperation.Progress = new AsyncOperationProgressHandler <TranscodeFailureReason, double>((info, progress) =>
{
Helper.UIUtility.RunAsync(() =>
{
ProgressVM.Progress = progress;
});
});
saveOperation.Completed = new AsyncOperationWithProgressCompletedHandler <TranscodeFailureReason, double>((info, status) =>
{
var results = info.GetResults();
if (results != TranscodeFailureReason.None || status != AsyncStatus.Completed)
{
Helper.UIUtility.RunAsync(() =>
{
ProgressVM.Status = ProgressStatus.Failed;
});
}
else
{
Helper.UIUtility.RunAsync(() =>
{
ProgressVM.Status = ProgressStatus.Success;
});
}
});
}
private async void Button_ClickAsync(object sender, RoutedEventArgs e)
{
var tempFile = await ApplicationData.Current.LocalFolder.CreateFileAsync("tempFile.mp4", CreationCollisionOption.ReplaceExisting);
//create temp file
await compositor.RenderToFileAsync(tempFile);//render to file to envoke VideoEffect..
}
public async Task <IAsyncOperationWithProgress <TranscodeFailureReason, double> > StartCompositionDashMedia(IList <StorageFile> inputFiles, StorageFile outFile, MediaEncodingProfile profile = null)
{
MediaComposition composition = new MediaComposition();
var clip = await MediaClip.CreateFromFileAsync(inputFiles.FirstOrDefault(x => x.Name == "video.m4s"));
composition.Clips.Add(clip);
var backgroundTrack = await BackgroundAudioTrack.CreateFromFileAsync(inputFiles.FirstOrDefault(x => x.Name == "audio.m4s"));
composition.BackgroundAudioTracks.Add(backgroundTrack);
IAsyncOperationWithProgress <TranscodeFailureReason, double> saveOperation = null;
if (profile != null)
{
saveOperation = composition.RenderToFileAsync(outFile, MediaTrimmingPreference.Fast, profile);
}
else
{
saveOperation = composition.RenderToFileAsync(outFile, MediaTrimmingPreference.Fast);
}
saveOperation.Progress = new AsyncOperationProgressHandler <TranscodeFailureReason, double>((info, progress) =>
{
ProcessingProgressChanged?.Invoke(this, progress);
});
saveOperation.Completed = new AsyncOperationWithProgressCompletedHandler <TranscodeFailureReason, double>((info, status) =>
{
if (status == AsyncStatus.Canceled)
{
ProcessingCanceled?.Invoke(this, new EventArgs());
return;
}
var results = info.GetResults();
if (results != TranscodeFailureReason.None || status != AsyncStatus.Completed)
{
ProcessingError?.Invoke(this, "合并失败:未知错误");
}
else
{
ProcessingCompleted?.Invoke(this, new EventArgs());
}
});
return(saveOperation);
}
public void RenderCompositionToFile(StorageFile file, MediaComposition composition, SaveProgressCallback showErrorMessage, Window window, MediaEncodingProfile encodingProfile, CancellationToken token, object selectedResolution)
{
var saveOperation = composition.RenderToFileAsync(file, MediaTrimmingPreference.Precise, encodingProfile);
saveOperation.Progress = async(info, progress) =>
{
await window.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
showErrorMessage(progress);
try
{
if (token.IsCancellationRequested)
{
saveOperation.Cancel();
showErrorMessage(100.0);
}
}
catch (OperationCanceledException)
{
}
});
};
saveOperation.Completed = async(info, status) =>
{
await window.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
if (saveOperation.Status != AsyncStatus.Canceled)
{
try
{
var results = info.GetResults();
if (results != TranscodeFailureReason.None || status != AsyncStatus.Completed)
{
//ShowErrorMessage("Saving was unsuccessful");
}
else
{
//ShowErrorMessage("Trimmed clip saved to file");
await Launcher.LaunchFileAsync(file);
}
}
catch (Exception e)
{
Debug.WriteLine("Saving exception: " + e.Message);
var dialog = new MessageDialog("Saving exception: " + e.Message);
dialog.Title = "Error";
dialog.Commands.Add(new UICommand {
Label = "OK", Id = 0
});
await dialog.ShowAsync();
showErrorMessage(100.0);
}
}
});
};
}
private async void Save_Click(object sender, RoutedEventArgs e)
{
EnableButtons(false);
rootPage.NotifyUser("Requesting file to save to", NotifyType.StatusMessage);
var picker = new Windows.Storage.Pickers.FileSavePicker();
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.VideosLibrary;
picker.FileTypeChoices.Add("MP4 files", new List <string>()
{
".mp4"
});
picker.SuggestedFileName = "TrimmedClip.mp4";
StorageFile file = await picker.PickSaveFileAsync();
if (file != null)
{
var saveOperation = composition.RenderToFileAsync(file, MediaTrimmingPreference.Precise);
saveOperation.Progress = new AsyncOperationProgressHandler <TranscodeFailureReason, double>(async(info, progress) =>
{
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, new DispatchedHandler(() =>
{
rootPage.NotifyUser(string.Format("Saving file... Progress: {0:F0}%", progress), NotifyType.StatusMessage);
}));
});
saveOperation.Completed = new AsyncOperationWithProgressCompletedHandler <TranscodeFailureReason, double>(async(info, status) =>
{
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, new DispatchedHandler(() =>
{
try
{
var results = info.GetResults();
if (results != TranscodeFailureReason.None || status != AsyncStatus.Completed)
{
rootPage.NotifyUser("Saving was unsuccessful", NotifyType.ErrorMessage);
}
else
{
rootPage.NotifyUser("Trimmed clip saved to file", NotifyType.StatusMessage);
}
}
finally
{
// Remember to re-enable controls on both success and failure
EnableButtons(true);
}
}));
});
}
else
{
rootPage.NotifyUser("User cancelled the file selection", NotifyType.StatusMessage);
EnableButtons(true);
}
}
private async void SaveCompositionToFile(MediaComposition composition, string suggestedFileName, uint vidX, uint vidY)
{
var savePicker = new FileSavePicker
{
SuggestedStartLocation = PickerLocationId.DocumentsLibrary
};
// Dropdown of file types the user can save the file as
savePicker.FileTypeChoices.Add("MP4", new List <string>()
{
".mp4"
});
// Default file name if the user does not type one in or select a file to replace
savePicker.SuggestedFileName = suggestedFileName;
// Get name and location for saved video file
StorageFile sampleFile = await savePicker.PickSaveFileAsync();
if (sampleFile == null)
{
backgroundTint.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
showLoading.IsActive = false;
return;
}
await composition.SaveAsync(sampleFile);
composition = await MediaComposition.LoadAsync(sampleFile);
// Get a generic encoding profile and match the width and height to the camera's width and height
MediaEncodingProfile _MediaEncodingProfile = MediaEncodingProfile.CreateMp4(VideoEncodingQuality.HD720p);
_MediaEncodingProfile.Video.Width = vidX;
_MediaEncodingProfile.Video.Height = vidY;
var saveOperation = composition.RenderToFileAsync(sampleFile, MediaTrimmingPreference.Precise, _MediaEncodingProfile);
//mediaSimple.Source = new Uri("ms-appx:///WBVideo.mp4");
saveOperation.Progress = new AsyncOperationProgressHandler <TranscodeFailureReason, double>(async(info, progress) =>
{
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, new DispatchedHandler(() =>
{
Debug.WriteLine(progress);
//ShowErrorMessage(string.Format("Saving file... Progress: {0:F0}%", progress));
}));
});
saveOperation.Completed = new AsyncOperationWithProgressCompletedHandler <TranscodeFailureReason, double>(async(info, status) =>
{
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, new DispatchedHandler(async() =>
{
backgroundTint.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
showLoading.IsActive = false;
await videoExportCompleteDialog.ShowAsync();
}));
});
}
private async void Save_Click(object sender, RoutedEventArgs e)
{
EnableButtons(false);
StatusTextBlock.Text = "Creating new file...";
var file = await ApplicationData.Current.LocalFolder.CreateFileAsync($"Edited Video {DateTime.Now:D}.mp4");
if (file != null)
{
var saveOperation = composition.RenderToFileAsync(file, MediaTrimmingPreference.Precise);
// This will show progress as video is rendered and saved
saveOperation.Progress = async(info, progress) =>
{
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
StatusTextBlock.Text = string.Format("Saving file... Progress: {0:F0}%", progress);
});
};
// This fires when the operation is complete
saveOperation.Completed = async(info, status) =>
{
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
try
{
var results = info.GetResults();
if (results != TranscodeFailureReason.None || status != AsyncStatus.Completed)
{
StatusTextBlock.Foreground = new SolidColorBrush(Colors.Red);
StatusTextBlock.Text = "Saving was unsuccessful";
}
else
{
// Successful save, go back to main page.
if (Frame.CanGoBack)
{
Frame.GoBack();
}
}
}
finally
{
// Remember to re-enable controls on both success and failure
EnableButtons(true);
}
});
};
}
else
{
EnableButtons(true);
}
}
private async void OnSaveAs(object sender, TappedRoutedEventArgs e)
{
var picker = new Windows.Storage.Pickers.FileSavePicker();
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.VideosLibrary;
picker.FileTypeChoices.Add("MP4 files", new List <string>()
{
".mp4"
});
picker.SuggestedFileName = "RenderedComposition.mp4";
Windows.Storage.StorageFile file = await picker.PickSaveFileAsync();
if (file != null)
{
// Call RenderToFileAsync
var saveOperation = mComposition.RenderToFileAsync(file, MediaTrimmingPreference.Precise);
saveOperation.Progress = new AsyncOperationProgressHandler <TranscodeFailureReason, double>(async(info, progress) =>
{
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, new DispatchedHandler(() =>
{
Debug.WriteLine(string.Format("Saving file... Progress: {0:F0}%", progress));
}));
});
saveOperation.Completed = new AsyncOperationWithProgressCompletedHandler <TranscodeFailureReason, double>(async(info, status) =>
{
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, new DispatchedHandler(() =>
{
try
{
var results = info.GetResults();
if (results != TranscodeFailureReason.None || status != AsyncStatus.Completed)
{
Debug.WriteLine("Saving was unsuccessful");
}
else
{
Debug.WriteLine("Trimmed clip saved to file");
}
}
finally
{
// Update UI whether the operation succeeded or not
}
}));
});
}
else
{
Debug.WriteLine("User cancelled the file selection");
}
}
private async void Save_Click(object sender, RoutedEventArgs e)
{
save.IsEnabled = false;
chooseFile.IsEnabled = false;
trimClip.IsEnabled = false;
var picker = new Windows.Storage.Pickers.FileSavePicker();
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.VideosLibrary;
picker.FileTypeChoices.Add("MOV files", new List <string>()
{
".mov"
});
picker.SuggestedFileName = "TrimmedClip.mov";
StorageFile file = await picker.PickSaveFileAsync();
if (file != null)
{
var saveOperation = composition.RenderToFileAsync(file, MediaTrimmingPreference.Precise);
saveOperation.Progress = new AsyncOperationProgressHandler <TranscodeFailureReason, double>(async(info, progress) =>
{
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, new DispatchedHandler(() =>
{
ResultMessage.Text = string.Format("Saving file... Progress: {0:F0}%", progress);
}));
});
saveOperation.Completed = new AsyncOperationWithProgressCompletedHandler <TranscodeFailureReason, double>(async(info, status) =>
{
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, new DispatchedHandler(() =>
{
try
{
var results = info.GetResults();
if (results != TranscodeFailureReason.None || status != AsyncStatus.Completed)
{
ResultMessage.Text = "saving error";
}
else
{
ResultMessage.Text = "saving success";
}
}
finally
{
save.IsEnabled = true;
chooseFile.IsEnabled = true;
trimClip.IsEnabled = true;
}
}));
});
}
}
public async Task Export(Video video, Flight flight, StorageFile output, Action <Status> onNewStatus)
{
var composition = new MediaComposition();
var baseClip = await MediaClip.CreateFromFileAsync(video.Source);
composition.Clips.Add(baseClip);
var encProps = baseClip.GetVideoEncodingProperties();
var layer = await CreateOverlay2(video.RecordedInterval.Value, flight, TimeSpan.FromSeconds(0.3),
onNewStatus, new Rect(0, 0, encProps.Width, encProps.Height));
composition.OverlayLayers.Add(layer);
await composition.RenderToFileAsync(output, MediaTrimmingPreference.Fast);
}
async Task CS_WP_MC_Basic(EffectType effectType)
{
StorageFile source = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Input/Car.mp4"));
StorageFile destination = await KnownFolders.VideosLibrary.CreateFileAsync("CS_WP_MC_Basic_" + effectType + ".mp4", CreationCollisionOption.ReplaceExisting);
var definition = await Utils.CreateEffectDefinitionAsync(effectType);
var clip = await MediaClip.CreateFromFileAsync(source);
clip.VideoEffectDefinitions.Add(definition);
var composition = new MediaComposition();
composition.Clips.Add(clip);
await composition.RenderToFileAsync(destination);
}
private async Task <MediaOverlay> CreateOverlay(Interval videoInterval, Flight flight, TimeSpan period,
Action <Status> onNewStatus)
{
var count = videoInterval.Duration.ToTimeSpan().Divide(period);
var composition = new MediaComposition();
var bmps = new List <StorageFile>();
for (var i = 0; i < count; i++)
{
var offset = i * period;
var videoTime = videoInterval.Start.Plus(offset.ToDuration());
var flightTime = videoTime.Minus(flight.Date.ToInstant());
var status = flight.Statuses.FirstOrDefault(x => x.TimeElapsed >= flightTime.ToTimeSpan());
if (status != null)
{
onNewStatus(status);
}
var bmp = await CaptureBitmap();
bmps.Add(bmp);
composition.Clips.Add(await MediaClip.CreateFromImageFileAsync(bmp, offset));
}
var storageFile = await CreateFile();
await composition.RenderToFileAsync(storageFile, MediaTrimmingPreference.Fast);
foreach (var bmp in bmps)
{
await bmp.DeleteAsync();
}
var mediaClip = await MediaClip.CreateFromFileAsync(storageFile);
await storageFile.DeleteAsync();
var mediaOverlay = new MediaOverlay(mediaClip)
{
Position = new Rect(0, 0, 200, 200),
Delay = TimeSpan.Zero
};
return(mediaOverlay);
}
/**
* トリミング結果をファイルに保存（Async版）
*/
public async Task <bool> SaveAsAsync(StorageFile toFile)
{
if (mComposition.Clips.Count == 0 || Error.HasError)
{
return(false);
}
bool result = false;
IsPlaying = false;
Encoding = true;
try
{
mComposition.Clips[0].TrimTimeFromStart = TimeSpan.FromMilliseconds(mTrimmingSlider.TrimStart);
mComposition.Clips[0].TrimTimeFromEnd = TimeSpan.FromMilliseconds(mTrimmingSlider.TrimEnd);
var props = getFeelSoGoodEncodingProperty();
mTrimmingTask = mComposition.RenderToFileAsync(toFile, MediaTrimmingPreference.Precise, props);
mTrimmingTask.Progress = async(ai, pi) =>
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
EncodingProgress = (int)Math.Ceiling(pi);
});
};
var err = await mTrimmingTask;
if (err == TranscodeFailureReason.None)
{
result = true;
}
else
{
Error.SetError(err.ToString());
}
mTrimmingTask = null;
Encoding = false;
Debug.WriteLine("Transcode result={0}", err.ToString());
return(result);
}
catch (Exception e)
{
Error.SetError(e);
Debug.WriteLine(e);
return(false);
}
}
private async void SaveClip_Click(object sender, RoutedEventArgs e)
{
Windows.Storage.Pickers.FileSavePicker fileSavePicker = new Windows.Storage.Pickers.FileSavePicker();
fileSavePicker.FileTypeChoices.Add("MP4 files", new List <string>()
{
".mp4"
});
fileSavePicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.VideosLibrary;
var file = await fileSavePicker.PickSaveFileAsync();
if (file == null)
{
return;
}
btnSave.Visibility = Visibility.Collapsed;
progressRing.Visibility = Visibility.Visible;
tbProgress.Visibility = Visibility.Visible;
var render = mediaComposition.RenderToFileAsync(file, MediaTrimmingPreference.Precise);
render.Progress = new AsyncOperationProgressHandler <Windows.Media.Transcoding.TranscodeFailureReason, double>((reson, value) =>
{
SynchronizationContext.Post((param) =>
{
tbProgress.Text = value.ToString("0.00") + "%";
}, null);
});
render.Completed = new AsyncOperationWithProgressCompletedHandler <Windows.Media.Transcoding.TranscodeFailureReason, double>((reason, status) =>
{
string msg = "Successful";
var re = reason.GetResults();
if (re != Windows.Media.Transcoding.TranscodeFailureReason.None || status != AsyncStatus.Completed)
{
msg = "Unsuccessful";
}
SynchronizationContext.Post((param) =>
{
btnSave.Visibility = Visibility.Visible;
progressRing.Visibility = Visibility.Collapsed;
tbProgress.Visibility = Visibility.Collapsed;
tbProgress.Text = msg;
}, null);
});
}
//This can work
private async void CreateVideoByConvertRenderBitmapToFile()
{
var folder = await ApplicationData.Current.LocalFolder.CreateFolderAsync("Test",
CreationCollisionOption.ReplaceExisting);
var composition = new MediaComposition();
for (int i = 0; i < 5; i++)
{
RenderTargetBitmap render = new RenderTargetBitmap();
await render.RenderAsync(RenderGrid);
MyImage.Source = render;
var pixel = await render.GetPixelsAsync();
var file = await folder.CreateFileAsync("test.png", CreationCollisionOption.GenerateUniqueName);
using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
var logicalDpi = DisplayInformation.GetForCurrentView().LogicalDpi;
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, stream);
encoder.SetPixelData(
BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Ignore,
(uint)render.PixelWidth,
(uint)render.PixelHeight,
logicalDpi,
logicalDpi,
pixel.ToArray());
await encoder.FlushAsync();
stream.Dispose();
MediaClip clip = await MediaClip.CreateFromImageFileAsync(file, TimeSpan.FromSeconds(3));
composition.Clips.Add(clip);
MyText.Text = "First frame >>>" + i;
}
}
var video = await ApplicationData.Current.LocalFolder.CreateFileAsync("test.mp4",
CreationCollisionOption.ReplaceExisting);
var action = await composition.RenderToFileAsync(video, MediaTrimmingPreference.Precise);
await folder.DeleteAsync();
}
private async void savebtn_Click(object sender, RoutedEventArgs e)
{
var picker = new Windows.Storage.Pickers.FileSavePicker();
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.VideosLibrary;
picker.FileTypeChoices.Add("MP4 files", new List <string>()
{
".mp4"
});
picker.SuggestedFileName = "RenderedComposition.mp4";
Windows.Storage.StorageFile pickedFile = await picker.PickSaveFileAsync();
if (pickedFile != null)
{
// Call RenderToFileAsync
var saveOperation = composition.RenderToFileAsync(pickedFile, MediaTrimmingPreference.Precise);
saveOperation.Completed = new AsyncOperationWithProgressCompletedHandler <TranscodeFailureReason, double>(async(info, status) =>
{
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, new DispatchedHandler(() =>
{
try
{
var results = info.GetResults();
if (results != TranscodeFailureReason.None || status != AsyncStatus.Completed)
{
//ShowErrorMessage("Saving was unsuccessful");
}
else
{
// ShowErrorMessage("Trimmed clip saved to file");
mediaElement.Source = null;
savebtn.IsEnabled = false;
}
}
finally
{
}
}));
});
}
}
async Task CS_WP_MC_Basic(EffectType effectType)
{
StorageFile source = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Input/Car.mp4"));
StorageFile destination = await KnownFolders.VideosLibrary.CreateFileAsync("CS_WP_MC_Basic_" + effectType + ".mp4", CreationCollisionOption.ReplaceExisting);
var definition = await Utils.CreateEffectDefinitionAsync(effectType);
var clip = await MediaClip.CreateFromFileAsync(source);
clip.VideoEffectDefinitions.Add(definition);
var composition = new MediaComposition();
composition.Clips.Add(clip);
await composition.RenderToFileAsync(destination);
}
public async void StopRec(object sender, RoutedEventArgs e)
{
//Wave.Visibility = Visibility.Collapsed;
//voice.Visibility = Visibility.Visible;
piano.Visibility = Visibility.Visible;
Stop.Visibility = Visibility.Collapsed;
timer.Stop();
timerP.Visibility = Visibility.Collapsed;
Seconds.Text = "00";
Minute.Text = "00";
string name = ((AppBarButton)sender).Name;
if (name.Equals("voice"))
{
StopCapture(sender, e);
}
else
{
try
{
end = DateTime.Now;
totalRecordingTime = end - begin;
mediacomposition.Clips.Add(await MediaClip.CreateFromImageFileAsync
(await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Assets/Logo.scale-100.png")), totalRecordingTime));
var storageFile = await KnownFolders.MusicLibrary.CreateFileAsync(fileName, CreationCollisionOption.GenerateUniqueName);
await mediacomposition.RenderToFileAsync(storageFile);
diff = new TimeSpan();
begin = new DateTime();
now = new DateTime();
record = 0;
mediacomposition = new MediaComposition();
//this.Frame.Navigate(typeof(RecordingsPage));
}
catch (Exception)
{
await(new MessageDialog("You Need To Start A Recording First!").ShowAsync());
}
}
}
private async Task SaveVideo(MediaComposition video_com)
{
StorageFolder myfolder = await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFolderAsync("Videos", CreationCollisionOption.OpenIfExists);
string filename_vid = "video" + video_count + ".mp4";
video_count++;
StorageFile videoFile = await myfolder.CreateFileAsync(filename_vid, CreationCollisionOption.ReplaceExisting);
var saveOperation = video_com.RenderToFileAsync(videoFile, MediaTrimmingPreference.Precise);
System.Diagnostics.Debug.WriteLine("Now saving: {0}", filename_vid);
saveOperation.Progress = new AsyncOperationProgressHandler <TranscodeFailureReason, double>(async(info, progress) =>
{
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, new DispatchedHandler(() =>
{
System.Diagnostics.Debug.WriteLine(string.Format("Saving file... Progress: {0:F0}%", progress));
}));
});
saveOperation.Completed = new AsyncOperationWithProgressCompletedHandler <TranscodeFailureReason, double>(async(info, status) =>
{
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, new DispatchedHandler(() =>
{
try
{
var results = info.GetResults();
if (results != TranscodeFailureReason.None || status != AsyncStatus.Completed)
{
video_saved = true;
System.Diagnostics.Debug.WriteLine("Saving was unsuccessful");
}
else
{
System.Diagnostics.Debug.WriteLine("Trimmed clip saved to file");
}
}
finally
{
// Update UI whether the operation succeeded or not
}
}));
});
}
//This works
private async void CreateVideoFromIDX3D()
{
for (int i = 0; i < 5; i++)
{
try
{
var folder = ApplicationData.Current.LocalFolder;
RenderTargetBitmap renderTargetBitmap = new RenderTargetBitmap();
await renderTargetBitmap.RenderAsync(RenderGrid);
IBuffer pixels = await renderTargetBitmap.GetPixelsAsync();
CanvasBitmap bitmap = null;
var videoClip = new MediaComposition();
//SoftwareBitmap softwareBitmap = new SoftwareBitmap(BitmapPixelFormat.Bgra8, renderTargetBitmap.PixelWidth,
// renderTargetBitmap.PixelHeight);
//bitmap = CanvasBitmap.CreateFromSoftwareBitmap(CanvasDevice.GetSharedDevice(), softwareBitmap);
bitmap = CanvasBitmap.CreateFromBytes(CanvasDevice.GetSharedDevice(), pixels,
renderTargetBitmap.PixelWidth, renderTargetBitmap.PixelHeight, DirectXPixelFormat.B8G8R8A8UIntNormalized);
StorageFile video2 = await folder.CreateFileAsync("video2" + ".mp4", CreationCollisionOption.ReplaceExisting);
MediaClip d = MediaClip.CreateFromSurface(bitmap, TimeSpan.FromSeconds(3));
videoClip.Clips.Add(d);
//Use these code to work
await videoClip.SaveAsync(video2);
videoClip = await MediaComposition.LoadAsync(video2);
var result = await videoClip.RenderToFileAsync(video2);
Debug.WriteLine(result.ToString());
break;
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
}
private async Task SetVideo(MediaComposition mediaComposition, CancellationToken cancellationToken)
{
StorageFile temporaryFile = await CreateFile("Video", "temp (1)", "mp4", cancellationToken);
IAsyncOperationWithProgress <TranscodeFailureReason, double> progress = mediaComposition.RenderToFileAsync(temporaryFile, MediaTrimmingPreference.Precise);
CancelTask(cancellationToken);
progress.Progress = new AsyncOperationProgressHandler <TranscodeFailureReason, double>(async(reason, progressInfo) =>
{
if (cancellationToken.IsCancellationRequested)
{
reason.Cancel();
await ClearTempData();
}
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, new DispatchedHandler(async() =>
{
ReportProgress(Stage6, Stage5ProgressBar, TextProgress5, progressInfo);
if (progressInfo == 100)
{
Open.Content = "Browse File";
ItemSource = await GetProperties(temporaryFile, cancellationToken);
Save.IsEnabled = true;
}
}));
});
CancelTask(cancellationToken);
MediaStreamSource mediaStreamSource = mediaComposition.GeneratePreviewMediaStreamSource(0, 0);
MediaElement1.SetMediaStreamSource(mediaStreamSource);
MediaElement1.Play();
await progress;
CancelTask(cancellationToken);
audioVideo.Add(temporaryFile);
}
private async void CreateVideoFromWritableBitmapAsync(List <WriteableBitmap> WBs)
{
var mediaComposition = new MediaComposition();
foreach (WriteableBitmap WB in WBs)
{
var pixels = WB.PixelBuffer.ToArray();
CanvasBitmap bitmap = CanvasBitmap.CreateFromBytes(CanvasDevice.GetSharedDevice(), pixels,
800, 600, DirectXPixelFormat.B8G8R8A8UIntNormalized);
MediaClip mediaClip = MediaClip.CreateFromSurface(bitmap, TimeSpan.FromSeconds(1));
mediaComposition.Clips.Add(mediaClip);
}
//Save the video
var file = await ApplicationData.Current.LocalFolder.CreateFileAsync("WBVideo.mp4");
await mediaComposition.SaveAsync(file);
mediaComposition = await MediaComposition.LoadAsync(file);
await mediaComposition.RenderToFileAsync(file);
}
private async void StartMediaCompositionRender_Click(object sender, RoutedEventArgs e)
{
StartMediaCompositionRender.IsEnabled = false;
StorageFile source = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Assets/Car.mp4"));
StorageFile destination = await KnownFolders.VideosLibrary.CreateFileAsync("VideoEffectsTestApp.MediaComposition.mp4", CreationCollisionOption.ReplaceExisting);
var encodingProfile = await MediaEncodingProfile.CreateFromFileAsync(source);
var definition = await CreateEffectDefinitionAsync(encodingProfile.Video);
var clip = await MediaClip.CreateFromFileAsync(source);
clip.VideoEffectDefinitions.Add(definition);
var composition = new MediaComposition();
composition.Clips.Add(clip);
await composition.RenderToFileAsync(destination);
StartMediaCompositionRender.IsEnabled = true;
}
public async Task MergeAudioVideo(StorageFile audioFile, StorageFile videoFile, StorageFile outputFile)
{
if (audioFile == null)
{
if (parent != null)
{
parent.StartWritingOutput("Audio File is null", 1);
}
return;
}
if (videoFile == null)
{
if (parent != null)
{
parent.StartWritingOutput("Video File is null", 1);
}
return;
}
if (outputFile == null)
{
if (parent != null)
{
parent.StartWritingOutput("Output File is null (not specified)", 1);
}
return;
}
if (!audioFile.IsAvailable)
{
if (parent != null)
{
parent.StartWritingOutput("Audio File is not available", 1);
}
return;
}
if (!videoFile.IsAvailable)
{
if (parent != null)
{
parent.StartWritingOutput("Video File is not available", 1);
}
return;
}
if (parent != null)
{
parent.StartWritingOutput("Merging temporary video and audio files..", 1);
}
MediaClip mediaClip = await MediaClip.CreateFromFileAsync(videoFile);
BackgroundAudioTrack backgroundAudioTrack = await BackgroundAudioTrack.CreateFromFileAsync(audioFile);
MediaComposition mediaComposition = new MediaComposition();
mediaComposition.Clips.Add(mediaClip);
mediaComposition.BackgroundAudioTracks.Add(backgroundAudioTrack);
if (outputFile != null)
{
var mergeOperation = mediaComposition.RenderToFileAsync(outputFile, MediaTrimmingPreference.Precise);
mergeOperation.Progress += mergeProgress;
mergeOperation.Completed += mergeCompleted;
}
}
/// <summary>
/// Invoked when this page is about to be displayed in a Frame.
/// </summary>
/// <param name="e">Event data that describes how this page was reached.
/// This parameter is typically used to configure the page.</param>
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
StorageFile source = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Input/Car.mp4"));
// Select the largest centered square area in the input video
var inputProfile = await MediaEncodingProfile.CreateFromFileAsync(source);
uint inputWidth = inputProfile.Video.Width;
uint inputHeight = inputProfile.Video.Height;
uint outputLength = Math.Min(inputWidth, inputHeight);
Rect cropArea = new Rect(
(float)((inputWidth - outputLength) / 2),
(float)((inputHeight - outputLength) / 2),
(float)outputLength,
(float)outputLength
);
// Create the output encoding profile
var outputProfile = MediaEncodingProfile.CreateMp4(VideoEncodingQuality.HD720p);
outputProfile.Video.Bitrate = inputProfile.Video.Bitrate;
outputProfile.Video.FrameRate.Numerator = inputProfile.Video.FrameRate.Numerator;
outputProfile.Video.FrameRate.Denominator = inputProfile.Video.FrameRate.Denominator;
outputProfile.Video.Width = outputLength;
outputProfile.Video.Height = outputLength;
var definition = new LumiaEffectDefinition(new FilterChainFactory(() =>
{
var filters = new List<IFilter>();
filters.Add(new CropFilter(cropArea));
return filters;
}));
definition.InputWidth = inputWidth;
definition.InputHeight = inputHeight;
definition.OutputWidth = outputLength;
definition.OutputHeight = outputLength;
var clip = await MediaClip.CreateFromFileAsync(source);
clip.VideoEffectDefinitions.Add(definition);
var composition = new MediaComposition();
composition.Clips.Add(clip);
TextLog.Text = "Encoding using MediaComposition";
StorageFile destination1 = await KnownFolders.VideosLibrary.CreateFileAsync("Square_MC.mp4", CreationCollisionOption.ReplaceExisting);
await composition.RenderToFileAsync(destination1, MediaTrimmingPreference.Fast, outputProfile);
TextLog.Text = "Encoding using MediaTranscoder";
StorageFile destination2 = await KnownFolders.VideosLibrary.CreateFileAsync("Square_MT.mp4", CreationCollisionOption.ReplaceExisting);
var transcoder = new MediaTranscoder();
transcoder.AddVideoEffect(definition.ActivatableClassId, true, definition.Properties);
var transcode = await transcoder.PrepareFileTranscodeAsync(source, destination2, outputProfile);
await transcode.TranscodeAsync();
TextLog.Text = "Starting MediaComposition preview";
PreviewMC.SetMediaStreamSource(
composition.GeneratePreviewMediaStreamSource((int)outputLength, (int)outputLength)
);
TextLog.Text = "Starting MediaElement preview";
PreviewME.AddVideoEffect(definition.ActivatableClassId, false, definition.Properties);
PreviewME.Source = new Uri("ms-appx:///Input/Car.mp4");
PreviewME.Play();
TextLog.Text = "Done";
}
private async void StartMediaCompositionRender_Click(object sender, RoutedEventArgs e)
{
StartMediaCompositionRender.IsEnabled = false;
StorageFile source = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Assets/Car.mp4"));
StorageFile destination = await KnownFolders.VideosLibrary.CreateFileAsync("VideoEffectsTestApp.MediaComposition.mp4", CreationCollisionOption.ReplaceExisting);
var encodingProfile = await MediaEncodingProfile.CreateFromFileAsync(source);
var definition = await CreateEffectDefinitionAsync(encodingProfile.Video);
var clip = await MediaClip.CreateFromFileAsync(source);
clip.VideoEffectDefinitions.Add(definition);
var composition = new MediaComposition();
composition.Clips.Add(clip);
await composition.RenderToFileAsync(destination);
StartMediaCompositionRender.IsEnabled = true;
}
private async void Save_Click(object sender, RoutedEventArgs e)
{
EnableButtons(false);
StatusTextBlock.Text = "Creating new file...";
var file = await ApplicationData.Current.LocalFolder.CreateFileAsync($"Edited Video.mp4", CreationCollisionOption.GenerateUniqueName);
if (file != null)
{
// Show the overlay that contains the ProgressBar
BusyOverlay.Visibility = Visibility.Visible;
// You can also use a faster option with MediaTrimmingPreference.Fast, but will have a lower quality trim
var saveOperation = composition.RenderToFileAsync(file, MediaTrimmingPreference.Precise);
// This will show progress as video is rendered and saved
saveOperation.Progress = async(info, progress) =>
{
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
EncodingProgressBar.Value = progress;
EncodingProgressTextBlock.Text = $"Saving file: {progress:F0}%";
});
};
// This fires when the operation is complete
saveOperation.Completed = async(info, status) =>
{
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
try
{
var results = info.GetResults();
if (results != TranscodeFailureReason.None || status != AsyncStatus.Completed)
{
StatusTextBlock.Foreground = new SolidColorBrush(Colors.Red);
StatusTextBlock.Text = "Saving was unsuccessful";
}
else
{
// Successful save, go back to main page.
if (Frame.CanGoBack)
{
Frame.GoBack();
}
}
}
finally
{
// Remember to re-enable controls on both success and failure
EnableButtons(true);
BusyOverlay.Visibility = Visibility.Collapsed;
EncodingProgressTextBlock.Text = "";
}
});
};
}
else
{
EnableButtons(true);
BusyOverlay.Visibility = Visibility.Collapsed;
EncodingProgressTextBlock.Text = "";
}
}
public async Task MergeAudioVideoWebcam(StorageFile webcamFile, StorageFile videoFile, StorageFile outputFile)
{
if (webcamFile == null)
{
if (parent != null)
{
parent.StartWritingOutput("Webcam File is null", 1);
}
return;
}
if (videoFile == null)
{
if (parent != null)
{
parent.StartWritingOutput("Video File is null", 1);
}
return;
}
if (outputFile == null)
{
if (parent != null)
{
parent.StartWritingOutput("Output File is null (not specified)", 1);
}
return;
}
if (!webcamFile.IsAvailable)
{
if (parent != null)
{
parent.StartWritingOutput("Webcam File is not available", 1);
}
return;
}
if (!videoFile.IsAvailable)
{
if (parent != null)
{
parent.StartWritingOutput("Video File is not available", 1);
}
return;
}
if (parent != null)
{
parent.StartWritingOutput("Merging temporary video and webcam files..", 1);
}
try
{
MediaClip mediaClip = await MediaClip.CreateFromFileAsync(videoFile);
MediaClip webcamClip = await MediaClip.CreateFromFileAsync(webcamFile);
//the BorderVideoEffects need to be in a separate Windows Component Runtime
webcamClip.VideoEffectDefinitions.Add(new VideoEffectDefinition(typeof(BorderVideoEffect).FullName));
int xoffset = 20;
int yoffset = 30;
double overlayOpacity = 1.0;
double overlayHeight = 150;
Rect overlayRect;
VideoEncodingProperties webcamEncodingProperties = webcamClip.GetVideoEncodingProperties();
overlayRect.Height = overlayHeight;
double widthToHeightAspectRatio = ((double)webcamEncodingProperties.Width / (double)webcamEncodingProperties.Height);
overlayRect.Width = widthToHeightAspectRatio * overlayHeight;
overlayRect.X = xoffset;
overlayRect.Y = yoffset;
MediaOverlay mediaOverlay = new MediaOverlay(webcamClip);
mediaOverlay.Position = overlayRect;
mediaOverlay.Opacity = overlayOpacity;
mediaOverlay.AudioEnabled = true;
MediaOverlayLayer mediaOverlayLayer = new MediaOverlayLayer();
mediaOverlayLayer.Overlays.Add(mediaOverlay);
MediaComposition mediaComposition = new MediaComposition();
mediaComposition.Clips.Add(mediaClip);
mediaComposition.OverlayLayers.Add(mediaOverlayLayer);
if (outputFile != null)
{
var mergeOperation = mediaComposition.RenderToFileAsync(outputFile, MediaTrimmingPreference.Precise);
mergeOperation.Progress += mergeWebcamProgress;
mergeOperation.Completed += mergeWebcamCompleted;
}
}
catch (Exception e)
{
if (parent != null)
{
parent.StartWritingOutput("Merge Error :" + e.Message, 1);
}
}
}
/// <summary>
/// Invoked when this page is about to be displayed in a Frame.
/// </summary>
/// <param name="e">Event data that describes how this page was reached.
/// This parameter is typically used to configure the page.</param>
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
StorageFile source = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Input/Car.mp4"));
// Select the largest centered square area in the input video
var inputProfile = await MediaEncodingProfile.CreateFromFileAsync(source);
uint inputWidth = inputProfile.Video.Width;
uint inputHeight = inputProfile.Video.Height;
uint outputLength = Math.Min(inputWidth, inputHeight);
Rect cropArea = new Rect(
(float)((inputWidth - outputLength) / 2),
(float)((inputHeight - outputLength) / 2),
(float)outputLength,
(float)outputLength
);
// Create the output encoding profile
var outputProfile = MediaEncodingProfile.CreateMp4(VideoEncodingQuality.HD720p);
outputProfile.Video.Bitrate = inputProfile.Video.Bitrate;
outputProfile.Video.FrameRate.Numerator = inputProfile.Video.FrameRate.Numerator;
outputProfile.Video.FrameRate.Denominator = inputProfile.Video.FrameRate.Denominator;
outputProfile.Video.Width = outputLength;
outputProfile.Video.Height = outputLength;
var definition = new LumiaEffectDefinition(new FilterChainFactory(() =>
{
var filters = new List <IFilter>();
filters.Add(new CropFilter(cropArea));
return(filters);
}));
definition.InputWidth = inputWidth;
definition.InputHeight = inputHeight;
definition.OutputWidth = outputLength;
definition.OutputHeight = outputLength;
var clip = await MediaClip.CreateFromFileAsync(source);
clip.VideoEffectDefinitions.Add(definition);
var composition = new MediaComposition();
composition.Clips.Add(clip);
TextLog.Text = "Encoding using MediaComposition";
StorageFile destination1 = await KnownFolders.VideosLibrary.CreateFileAsync("Square_MC.mp4", CreationCollisionOption.ReplaceExisting);
await composition.RenderToFileAsync(destination1, MediaTrimmingPreference.Fast, outputProfile);
TextLog.Text = "Encoding using MediaTranscoder";
StorageFile destination2 = await KnownFolders.VideosLibrary.CreateFileAsync("Square_MT.mp4", CreationCollisionOption.ReplaceExisting);
var transcoder = new MediaTranscoder();
transcoder.AddVideoEffect(definition.ActivatableClassId, true, definition.Properties);
var transcode = await transcoder.PrepareFileTranscodeAsync(source, destination2, outputProfile);
await transcode.TranscodeAsync();
TextLog.Text = "Starting MediaComposition preview";
PreviewMC.SetMediaStreamSource(
composition.GeneratePreviewMediaStreamSource((int)outputLength, (int)outputLength)
);
TextLog.Text = "Starting MediaElement preview";
PreviewME.AddVideoEffect(definition.ActivatableClassId, false, definition.Properties);
PreviewME.Source = new Uri("ms-appx:///Input/Car.mp4");
PreviewME.Play();
TextLog.Text = "Done";
}
public async void TranscodeVideo()
{
bool succeeded = false;
StatusBar statusBar = StatusBar.GetForCurrentView();
// Transcoding cannot be used if there is a MediaElement playing; unset it
MediaSource = null;
// Create a StorageFile to hold the result
StorageFile outputFile = await KnownFolders.SavedPictures.CreateFileAsync(fileName + fileNameAppend, CreationCollisionOption.GenerateUniqueName);
try
{
// Set up the progress bar
statusBar.ProgressIndicator.ProgressValue = 0.0f;
await statusBar.ProgressIndicator.ShowAsync();
// Begin rendering
var renderOperation = m_composition.RenderToFileAsync(outputFile);
renderOperation.Progress = async(_, progress) =>
{
// Update the progress bar
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,
() =>
{
statusBar.ProgressIndicator.ProgressValue = progress / 100.0;
});
};
await renderOperation;
succeeded = true;
}
catch (Exception ex)
{
Utilities.MessageBox(ex.Message);
}
await statusBar.ProgressIndicator.HideAsync();
// Transcode completed, show result
if (succeeded)
{
ContentDialog complete = new ContentDialog();
complete.Content = "Transcode complete.";
complete.PrimaryButtonText = "Play";
complete.SecondaryButtonText = "Cancel";
var result = await complete.ShowAsync();
if (result == ContentDialogResult.Primary)
{
Uri savedUri = new Uri(outputFile.Path);
// TODO: navigate to second page and put a mediaplayer control there
//Frame.Navigate(typeof(Preview), savedUri);
}
}
// Reinitialize the MediaElement now that we are done
// TODO: use low res here too
MediaSource = m_composition.GenerateMediaStreamSource();
}
private async void Save_Click(object sender, RoutedEventArgs e)
{
Video.Stop();
Video.Source = null;
Video.RemoveAllEffects();
if (CurrentVideo == null || CurrentEffect == null || SecondVideo == null || ThirdVideo == null)
{
return;
}
MediaComposition comp = new MediaComposition();
StorageFile VideoFile1 = await StorageFile.GetFileFromApplicationUriAsync(new Uri(CurrentVideo));
StorageFile VideoFile2 = await StorageFile.GetFileFromApplicationUriAsync(new Uri(SecondVideo));
StorageFile VideoFile3 = await StorageFile.GetFileFromApplicationUriAsync(new Uri(ThirdVideo));
MediaClip mediaClip1 = await MediaClip.CreateFromFileAsync(VideoFile1);
MediaClip mediaClip2 = await MediaClip.CreateFromFileAsync(VideoFile2);
MediaClip mediaClip3 = await MediaClip.CreateFromFileAsync(VideoFile3);
TransitionEffectParameter transitionEffectParameter1 = new TransitionEffectParameter();
TransitionEffectParameter transitionEffectParameter2 = new TransitionEffectParameter();
TransitionEffectParameter transitionEffectParameter3 = new TransitionEffectParameter();
transitionEffectParameter1.SetStartEffect(TransitionEffectType.TRANSITION_NONE, 0);
transitionEffectParameter1.SetEndEffect(CurrentEffect.EffectType, 1);
transitionEffectParameter1.SetVideoDuration((float)mediaClip1.OriginalDuration.TotalSeconds);
transitionEffectParameter2.SetStartEffect(CurrentEffect.EffectType, 1);
transitionEffectParameter2.SetEndEffect(CurrentEffect.EffectType, 1);
transitionEffectParameter2.SetVideoDuration((float)mediaClip2.OriginalDuration.TotalSeconds);
transitionEffectParameter3.SetStartEffect(CurrentEffect.EffectType, 1);
transitionEffectParameter3.SetEndEffect(TransitionEffectType.TRANSITION_NONE, 0);
transitionEffectParameter3.SetVideoDuration((float)mediaClip3.OriginalDuration.TotalSeconds);
PropertySet configuration1 = new PropertySet();
configuration1.Add("TransitionEffectParameter", transitionEffectParameter1);
mediaClip1.VideoEffectDefinitions.Add(new VideoEffectDefinition("TransitionEffectTransform.TransitionEffect", configuration1)); //change it to EffectTransform
PropertySet configuration2 = new PropertySet();
configuration2.Add("TransitionEffectParameter", transitionEffectParameter2);
mediaClip2.VideoEffectDefinitions.Add(new VideoEffectDefinition("TransitionEffectTransform.TransitionEffect", configuration2)); //change it to EffectTransform
PropertySet configuration3 = new PropertySet();
configuration3.Add("TransitionEffectParameter", transitionEffectParameter3);
mediaClip3.VideoEffectDefinitions.Add(new VideoEffectDefinition("TransitionEffectTransform.TransitionEffect", configuration3)); //change it to EffectTransform
comp.Clips.Add(mediaClip1);
comp.Clips.Add(mediaClip2);
comp.Clips.Add(mediaClip3);
StorageFile destination = await ApplicationData.Current.LocalFolder.CreateFileAsync("transition_result.mp4", CreationCollisionOption.ReplaceExisting);
Save.IsEnabled = false;
var a = comp.RenderToFileAsync(destination);
a.Progress = new AsyncOperationProgressHandler <Windows.Media.Transcoding.TranscodeFailureReason, double>(tempProgress);
a.Completed = new AsyncOperationWithProgressCompletedHandler <Windows.Media.Transcoding.TranscodeFailureReason, double>(tempCOmpleted);
}
public async Task UnpackToMp4()
{
MediaComposition mediacomposition = new MediaComposition();
StorageFolder pictureFolder = KnownFolders.SavedPictures;
{
int len = simpleRecorder.unpackList.Count;
for (int i = 0; i < len; i++)
{
UnpackItem unpackItem = simpleRecorder.unpackList[i];
Windows.Storage.Streams.Buffer buffer = unpackItem.compressedBuffer;
InMemoryRandomAccessStream inMemoryRandomAccessStream = null;
using (inMemoryRandomAccessStream = new InMemoryRandomAccessStream())
{
await inMemoryRandomAccessStream.WriteAsync(buffer);
await inMemoryRandomAccessStream.FlushAsync();
inMemoryRandomAccessStream.Seek(0);
CanvasBitmap tempBitmap = await CanvasBitmap.LoadAsync(CanvasDevice.GetSharedDevice(), inMemoryRandomAccessStream);
if (tempBitmap != null)
{
CanvasRenderTarget canvasRenderTarget = new CanvasRenderTarget(CanvasDevice.GetSharedDevice(), tempBitmap.SizeInPixels.Width, tempBitmap.SizeInPixels.Height, 96);
using (CanvasDrawingSession session = canvasRenderTarget.CreateDrawingSession())
{
session.Clear(Colors.Black);
session.DrawImage(tempBitmap);
TimeSpan frameTime30Mil = TimeSpan.FromMilliseconds(30f);
TimeSpan frameTime = unpackItem.frameTime;
//if (frameTime < frameTime30Mil)
// frameTime = frameTime30Mil;
MediaClip mediaclip = MediaClip.CreateFromSurface(canvasRenderTarget, frameTime);
mediacomposition.Clips.Add(mediaclip);
}
string str = "Adding Clips " + (i + 1).ToString() + " / " + len.ToString();
if (i == len - 1)
{
str += " ... Please wait for file rendering ...";
}
TextOutput.Text = str;
}
}
//free up memory recources as each frame is unpacked
if (unpackItem.compressedBuffer != null)
{
unpackItem.compressedBuffer = null;
}
} //for
}
StorageFile mp4file = null;
if (simpleRecorder.savefile != null)
{
mp4file = simpleRecorder.savefile;
}
else
{
string mp4filename = "SavedVideo" + ".mp4";
mp4file = await pictureFolder.CreateFileAsync(
mp4filename,
CreationCollisionOption.ReplaceExisting);
}
//await mediacomposition.RenderToFileAsync(mp4file, MediaTrimmingPreference.Precise, MediaEncodingProfile.CreateMp4(VideoEncodingQuality.HD720p));
var rendering = mediacomposition.RenderToFileAsync(mp4file, MediaTrimmingPreference.Precise, MediaEncodingProfile.CreateMp4(VideoEncodingQuality.HD720p));
rendering.Progress += ProgressReport;
rendering.Completed += CompletedReport;
}
