public async Task <MediaComposition> TimeBasedReconstruction(Stream aedatFile, CameraParameters cam, EventColor onColor, EventColor offColor, int frameTime, int maxFrames, float playback_frametime)
{
byte[] aedatBytes = new byte[5 * Convert.ToInt32(Math.Pow(10, 8))]; // Read 0.5 GB at a time
MediaComposition composition = new MediaComposition();
int lastTime = -999999;
int timeStamp;
int frameCount = 0;
Stream pixelStream = InitBitMap(cam);
byte[] currentFrame = new byte[pixelStream.Length];
int bytesRead = aedatFile.Read(aedatBytes, 0, aedatBytes.Length);
while (bytesRead != 0 && frameCount < maxFrames)
{
// Read through AEDAT file
for (int i = 0, length = bytesRead; i < length; i += AedatUtilities.dataEntrySize) // iterate through file, 8 bytes at a time.
{
AEDATEvent currentEvent = new AEDATEvent(aedatBytes, i, cam);
AedatUtilities.SetPixel(ref currentFrame, currentEvent.x, currentEvent.y, (currentEvent.onOff ? onColor.Color : offColor.Color), cam.cameraX);
timeStamp = currentEvent.time;
if (lastTime == -999999)
{
lastTime = timeStamp;
}
else
{
if (lastTime + frameTime <= timeStamp) // Collected events within specified timeframe, add frame to video
{
WriteableBitmap b = new WriteableBitmap(cam.cameraX, cam.cameraY);
using (Stream stream = b.PixelBuffer.AsStream())
{
await stream.WriteAsync(currentFrame, 0, currentFrame.Length);
}
SoftwareBitmap outputBitmap = SoftwareBitmap.CreateCopyFromBuffer(b.PixelBuffer, BitmapPixelFormat.Bgra8, b.PixelWidth, b.PixelHeight, BitmapAlphaMode.Ignore);
CanvasBitmap bitmap2 = CanvasBitmap.CreateFromSoftwareBitmap(CanvasDevice.GetSharedDevice(), outputBitmap);
// Set playback framerate
MediaClip mediaClip = MediaClip.CreateFromSurface(bitmap2, TimeSpan.FromSeconds(playback_frametime));
composition.Clips.Add(mediaClip);
frameCount++;
// Stop adding frames to video if max frames has been reached
if (frameCount >= maxFrames)
{
break;
}
currentFrame = new byte[pixelStream.Length];
lastTime = timeStamp;
}
}
}
bytesRead = aedatFile.Read(aedatBytes, 0, aedatBytes.Length);
}
return(composition);
}
private async void specialVideo_Click(object sender, RoutedEventArgs e)
{
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.VideosLibrary;
picker.FileTypeFilter.Add(".mov");
picker.FileTypeFilter.Add(".mp4");
StorageFile pickedFilespecial = await picker.PickSingleFileAsync();
if (pickedFilespecial == null)
{
return;
}
var clip = await MediaClip.CreateFromFileAsync(pickedFilespecial);
composition = new MediaComposition();
composition.Clips.Add(clip);
var videoEffectDefinition = new VideoEffectDefinition("VideoEffectComponent.ExampleVideoEffect", new PropertySet()
{
{ "FadeValue", .9 }
});
clip.VideoEffectDefinitions.Add(videoEffectDefinition);
MediaStreamSource mediaStreamSource = composition.GenerateMediaStreamSource();
mediaElement.SetMediaStreamSource(mediaStreamSource);
}
private async void CreateOverlays()
{
var baseVideoClip = await MediaClip.CreateFromFileAsync(baseVideoFile);
composition = new MediaComposition();
composition.Clips.Add(baseVideoClip);
var overlayVideoClip = await MediaClip.CreateFromFileAsync(overlayVideoFile);
// Overlay video in upper left corner, retain its native aspect ratio
Rect videoOverlayPosition;
var encodingProperties = overlayVideoClip.GetVideoEncodingProperties();
videoOverlayPosition.Height = mediaElement.ActualHeight / 3;
videoOverlayPosition.Width = (double)encodingProperties.Width / (double)encodingProperties.Height * videoOverlayPosition.Height;
videoOverlayPosition.X = 0;
videoOverlayPosition.Y = 0;
var videoOverlay = new MediaOverlay(overlayVideoClip);
videoOverlay.Position = videoOverlayPosition;
videoOverlay.Opacity = 0.75;
var overlayLayer = new MediaOverlayLayer();
overlayLayer.Overlays.Add(videoOverlay);
composition.OverlayLayers.Add(overlayLayer);
// Render to MediaElement
mediaElement.Position = TimeSpan.Zero;
mediaStreamSource = composition.GeneratePreviewMediaStreamSource((int)mediaElement.ActualWidth, (int)mediaElement.ActualHeight);
mediaElement.SetMediaStreamSource(mediaStreamSource);
rootPage.NotifyUser("Overlays created", NotifyType.StatusMessage);
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
var videoFile = e.Parameter as StorageFile;
if (videoFile != null)
{
StatusTextBlock.Text = videoFile.DisplayName;
// Create a MediaClip from the file
var clip = await MediaClip.CreateFromFileAsync(videoFile);
// Set the End Trim slider's maximum value so that the user can trim from the end
// You can also do this from the start
EndTrimSlider.Maximum = clip.OriginalDuration.Milliseconds;
// Create a MediaComposition containing the clip and set it on the MediaElement.
composition = new MediaComposition();
composition.Clips.Add(clip);
// start the MediaElement at the beginning
EditorMediaElement.Position = TimeSpan.Zero;
// Create the media source and assign it to the media player
mediaStreamSource = composition.GeneratePreviewMediaStreamSource((int)EditorMediaElement.ActualWidth, (int)EditorMediaElement.ActualHeight);
// Set the MediaElement's source
EditorMediaElement.SetMediaStreamSource(mediaStreamSource);
TrimClipButton.IsEnabled = true;
}
}
private async Task StartVideoAsync(StorageFile file)
{
try
{
if (this.videoPlayer.CurrentState == MediaElementState.Playing)
{
this.videoPlayer.Stop();
}
FrameRelayVideoEffect.ResetState();
this.currentVideoId = Guid.NewGuid();
await this.ResetStateAsync();
MediaClip clip = await MediaClip.CreateFromFileAsync(file);
clip.VideoEffectDefinitions.Add(new VideoEffectDefinition(typeof(FrameRelayVideoEffect).FullName));
MediaComposition compositor = new MediaComposition();
compositor.Clips.Add(clip);
this.videoPlayer.SetMediaStreamSource(compositor.GenerateMediaStreamSource());
}
catch (Exception ex)
{
await Util.GenericApiCallExceptionHandler(ex, "Error starting playback.");
}
}
public async Task <BitmapImage> GetThumbnailAsync(string mediaGroupName)
{
BitmapImage image = null;
StorageFile mediaGroupCMPFile = null;
MediaComposition mediaComposition = null;
var dispatcher = Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher;
try
{
await dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
image = new BitmapImage();
image.CreateOptions = BitmapCreateOptions.IgnoreImageCache;
mediaGroupCMPFile = await localFolder.GetFileAsync(mediaGroupName + ".cmp");
mediaComposition = await MediaComposition.LoadAsync(mediaGroupCMPFile);
await image.SetSourceAsync(await mediaComposition.GetThumbnailAsync(
TimeSpan.Zero, 0, 0, VideoFramePrecision.NearestFrame));
});
return(image);
}
catch (Exception e)
{
return(null);
}
}
private async void AddAudio_Click(object sender, RoutedEventArgs e)
{
// Create the original MediaComposition
var clip = await MediaClip.CreateFromFileAsync(pickedFile);
composition = new MediaComposition();
composition.Clips.Add(clip);
// Add background audio
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.MusicLibrary;
picker.FileTypeFilter.Add(".mp3");
picker.FileTypeFilter.Add(".wav");
picker.FileTypeFilter.Add(".flac");
var audioFile = await picker.PickSingleFileAsync();
if (audioFile == null)
{
rootPage.NotifyUser("File picking cancelled", NotifyType.ErrorMessage);
return;
}
var backgroundTrack = await BackgroundAudioTrack.CreateFromFileAsync(audioFile);
composition.BackgroundAudioTracks.Add(backgroundTrack);
// Render to MediaElement
mediaElement.Position = TimeSpan.Zero;
mediaStreamSource = composition.GeneratePreviewMediaStreamSource((int)mediaElement.ActualWidth, (int)mediaElement.ActualHeight);
mediaElement.SetMediaStreamSource(mediaStreamSource);
rootPage.NotifyUser("Background audio added", NotifyType.StatusMessage);
}
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
_composition = new MediaComposition();
_overlayLayer = new MediaOverlayLayer(new VideoCompositorDefinition(typeof(SimpleCompositor).FullName));
_composition.OverlayLayers.Add(_overlayLayer);
}
//从文件加载组合
//可以从文件中反序列化媒体组合, 以允许用户查看和修改组合。选择一个组合文件, 然后调用 MediaComposition 方法 LoadAsync 以加载该组合。
private async Task OpenComposition()
{
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.VideosLibrary;
picker.FileTypeFilter.Add(".cmp");
StorageFile compositionFile = await picker.PickSingleFileAsync();
if (compositionFile == null)
{
//w文件选择失败
}
else
{
App.Model.MediaComposition = await MediaComposition.LoadAsync(compositionFile);
if (App.Model.MediaComposition != null)
{
}
else
{
//无法打开组合
}
}
}
/// <summary>
/// Handle the returned files from file picker
/// This method is triggered by ContinuationManager based on ActivationKind
/// </summary>
/// <param name="args">File open picker continuation activation argment. It cantains the list of files user selected with file open picker </param>
public async void ContinueFileOpenPicker(FileOpenPickerContinuationEventArgs args)
{
if (args.Files.Count > 0)
{
Debug.WriteLine("Picked video: " + args.Files[0].Name);
MediaLoaded = true;
m_clip = await MediaClip.CreateFromFileAsync(args.Files[0]);
m_composition = new MediaComposition();
m_composition.Clips.Add(m_clip);
// Update the sliders to represent the duration in milliseconds
// TODO: move this databinding
TrimStart.Maximum = m_clip.OriginalDuration.TotalMilliseconds;
TrimEnd.Maximum = m_clip.OriginalDuration.TotalMilliseconds;
TrimEnd.Value = TrimEnd.Maximum;
//// Set up the MediaElement for preview
// TODO: pass in the preview streamsource and grab the screensize to determine this in addition to the aspect ratio of the video
MediaElement.SetMediaStreamSource(m_composition.GenerateMediaStreamSource());
}
else
{
Debug.WriteLine("Operation cancelled.");
}
}
public static async Task <ImageSource> GetPreviewBitmapAsync(StorageFile sourceFile, int requestedMinSide = 1280)
{
try
{
if (sourceFile.ContentType.Equals("video/mp4"))
{
var props = await sourceFile.Properties.GetVideoPropertiesAsync();
var composition = new MediaComposition();
var clip = await MediaClip.CreateFromFileAsync(sourceFile);
composition.Clips.Add(clip);
using (var imageStream = await composition.GetThumbnailAsync(TimeSpan.Zero, (int)props.GetWidth(), (int)props.GetHeight(), VideoFramePrecision.NearestKeyFrame))
{
return(await GetPreviewBitmapAsync(imageStream, requestedMinSide));
}
}
using (var imageStream = await sourceFile.OpenReadAsync())
{
return(await GetPreviewBitmapAsync(imageStream, requestedMinSide));
}
}
catch
{
return(null);
}
}
private async Task SetComp(StorageFile backgroundAudio, Dictionary <StorageFile, TimeSpan> imageFiles, CancellationToken cancellationToken)
{
StorageFile temporaryFile = await CreateFile("Media Composition", "temp (1)", "cmp", cancellationToken);
BackgroundAudioTrack backgroundAudioTrack = await BackgroundAudioTrack.CreateFromFileAsync(backgroundAudio);
AudioEncodingProperties audioEncodingProperties = backgroundAudioTrack.GetAudioEncodingProperties();
TimeSpan duration = backgroundAudioTrack.OriginalDuration;
MediaComposition composition = new MediaComposition();
composition.BackgroundAudioTracks.Add(backgroundAudioTrack);
CancelTask(cancellationToken);
MediaClip clip;
foreach (var item in imageFiles)
{
CancelTask(cancellationToken);
clip = await MediaClip.CreateFromImageFileAsync(item.Key, item.Value);
composition.Clips.Add(clip);
}
composition.CreateDefaultEncodingProfile();
await composition.SaveAsync(temporaryFile);
ReportProgress(Stage5, Stage4ProgressBar, TextProgress4, 100);
CancelTask(cancellationToken);
}
private async void CreateOverlays()
{
var baseVideoClip = await MediaClip.CreateFromFileAsync(baseVideoFile);
composition = new MediaComposition();
composition.Clips.Add(baseVideoClip);
var overlayVideoClip = await MediaClip.CreateFromFileAsync(overlayVideoFile);
// Overlay video in upper left corner, retain its native aspect ratio
Rect videoOverlayPosition;
var encodingProperties = overlayVideoClip.GetVideoEncodingProperties();
videoOverlayPosition.Height = mediaElement.ActualHeight / 3;
videoOverlayPosition.Width = (double)encodingProperties.Width / (double)encodingProperties.Height * videoOverlayPosition.Height;
videoOverlayPosition.X = 0;
videoOverlayPosition.Y = 0;
var videoOverlay = new MediaOverlay(overlayVideoClip);
videoOverlay.Position = videoOverlayPosition;
videoOverlay.Opacity = 0.75;
var overlayLayer = new MediaOverlayLayer();
overlayLayer.Overlays.Add(videoOverlay);
composition.OverlayLayers.Add(overlayLayer);
// Render to MediaElement
mediaElement.Position = TimeSpan.Zero;
mediaStreamSource = composition.GeneratePreviewMediaStreamSource((int)mediaElement.ActualWidth, (int)mediaElement.ActualHeight);
mediaElement.SetMediaStreamSource(mediaStreamSource);
}
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
_composition = new MediaComposition();
_overlayLayer = new MediaOverlayLayer(new VideoCompositorDefinition(typeof(SimpleCompositor).FullName));
_composition.OverlayLayers.Add(_overlayLayer);
}
// <SnippetOpenComposition>
private async Task OpenComposition()
{
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.VideosLibrary;
picker.FileTypeFilter.Add(".cmp");
Windows.Storage.StorageFile compositionFile = await picker.PickSingleFileAsync();
if (compositionFile == null)
{
ShowErrorMessage("File picking cancelled");
}
else
{
composition = null;
composition = await MediaComposition.LoadAsync(compositionFile);
if (composition != null)
{
UpdateMediaElementSource();
}
else
{
ShowErrorMessage("Unable to open composition");
}
}
}
async Task <MediaStreamSource> OpenVideo()
{
this.progressText.Text = "Downloading video...";
var thumbnailFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Assets/Logo.scale-100.png"));
var thumbnail = RandomAccessStreamReference.CreateFromFile(thumbnailFile);
var url = "http://video.ch9.ms/ch9/4597/8db5a656-b173-4897-b2aa-e2075fb24597/windows10recap.mp4";
var file = await StorageFile.CreateStreamedFileFromUriAsync(
"windows10recap.mp4",
new Uri(url),
thumbnail);
this.progressText.Text = "Creating clip...";
var clip = await MediaClip.CreateFromFileAsync(file);
clip.VideoEffectDefinitions.Add(new VideoEffectDefinition(typeof(ExampleVideoEffect).FullName));
var composition = new MediaComposition();
composition.Clips.Add(clip);
if (ThumbnailGenerator.IsDrawingThumbnail)
{
customThumbnail = await composition.GetThumbnailAsync(TimeSpan.FromSeconds(10), 1280, 720, VideoFramePrecision.NearestFrame);
}
return(composition.GenerateMediaStreamSource());
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.VideosLibrary;
picker.FileTypeFilter.Add(".mp4");
pickedFile = await picker.PickSingleFileAsync();
var storageItemAccessList = Windows.Storage.AccessCache.StorageApplicationPermissions.FutureAccessList;
storageItemAccessList.Add(pickedFile);
var clip = await MediaClip.CreateFromFileAsync(pickedFile);
if (pickedFile == null)
{
return;
}
else
{
composition = new MediaComposition();
composition.Clips.Add(clip);
mediaElement1.Position = TimeSpan.Zero;
mediaStreamSource = composition.GeneratePreviewMediaStreamSource(500, 200);
mediaElement1.SetMediaStreamSource(mediaStreamSource);
import_btn.IsEnabled = false;
}
}
public async Task CS_WP_MC_PreviewTranscode(EffectType effectType)
{
StorageFile source = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Input/Car.mp4"));
StorageFile destination = await KnownFolders.VideosLibrary.CreateFileAsync("CS_WP_MC_PreviewTranscode_" + 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);
MediaStreamSource sourceStreamSource = composition.GenerateMediaStreamSource();
using (IRandomAccessStream destinationStream = await destination.OpenAsync(FileAccessMode.ReadWrite))
{
var transcoder = new MediaTranscoder();
var transcode = await transcoder.PrepareMediaStreamSourceTranscodeAsync(sourceStreamSource, destinationStream, MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Qvga));
await transcode.TranscodeAsync();
}
}
public static async Task <SoftwareBitmap> GetFrameFromTime(MediaComposition composition, TimeSpan time)
{
var frame = await composition.GetThumbnailAsync(
time,
400,
300,
VideoFramePrecision.NearestFrame
);
SoftwareBitmap bitmap;
using (var stream = new InMemoryRandomAccessStream())
{
await RandomAccessStream.CopyAsync(frame, stream);
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
stream.Seek(0);
bitmap = SoftwareBitmap.Convert(
await decoder.GetSoftwareBitmapAsync(),
BitmapPixelFormat.Rgba16,
BitmapAlphaMode.Premultiplied);
return(bitmap);
}
}
async Task<MediaStreamSource> OpenVideo()
{
this.progressText.Text = "Downloading video...";
var thumbnailFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Assets/Logo.scale-100.png"));
var thumbnail = RandomAccessStreamReference.CreateFromFile(thumbnailFile);
var url = "http://video.ch9.ms/ch9/4597/8db5a656-b173-4897-b2aa-e2075fb24597/windows10recap.mp4";
var file = await StorageFile.CreateStreamedFileFromUriAsync(
"windows10recap.mp4",
new Uri(url),
thumbnail);
this.progressText.Text = "Creating clip...";
var clip = await MediaClip.CreateFromFileAsync(file);
clip.VideoEffectDefinitions.Add(new VideoEffectDefinition(typeof(ExampleVideoEffect).FullName));
var composition = new MediaComposition();
composition.Clips.Add(clip);
if (ThumbnailGenerator.IsDrawingThumbnail)
{
customThumbnail = await composition.GetThumbnailAsync(TimeSpan.FromSeconds(10), 1280, 720, VideoFramePrecision.NearestFrame);
}
return composition.GenerateMediaStreamSource();
}
private async void AddAudio_Click(object sender, RoutedEventArgs e)
{
// Create the original MediaComposition
var clip = await MediaClip.CreateFromFileAsync(pickedFile);
composition = new MediaComposition();
composition.Clips.Add(clip);
// Add background audio
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.MusicLibrary;
picker.FileTypeFilter.Add(".mp3");
picker.FileTypeFilter.Add(".wav");
picker.FileTypeFilter.Add(".flac");
var audioFile = await picker.PickSingleFileAsync();
if (audioFile == null)
{
rootPage.NotifyUser("File picking cancelled", NotifyType.ErrorMessage);
return;
}
var backgroundTrack = await BackgroundAudioTrack.CreateFromFileAsync(audioFile);
composition.BackgroundAudioTracks.Add(backgroundTrack);
// Render to MediaElement
mediaElement.Position = TimeSpan.Zero;
mediaStreamSource = composition.GeneratePreviewMediaStreamSource((int)mediaElement.ActualWidth, (int)mediaElement.ActualHeight);
mediaElement.SetMediaStreamSource(mediaStreamSource);
rootPage.NotifyUser("Background audio added", NotifyType.StatusMessage);
}
public async Task SetupMediaComposition(MediaComposition mediaComposition)
{
var captureVideoFile = await StorageFile.GetFileFromPathAsync(_captureVideoFilePath);
var clip = await MediaClip.CreateFromFileAsync(captureVideoFile);
mediaComposition.Clips.Add(clip);
}
private VideoTrimmer(MediaClip clip)
{
this.clip = clip;
// Create a composition with the clip
this.composition = new MediaComposition();
composition.Clips.Add(clip);
}
// </SnippetDeclareMediaComposition>
public MainPage()
{
this.InitializeComponent();
// <SnippetInitComposition>
mediaComposition = new MediaComposition();
// </SnippetInitComposition>
}
protected override void OnNavigatedFrom(NavigationEventArgs e)
{
// Clean up
EditorMediaElement.Source = null;
composition = null;
mediaStreamSource = null;
base.OnNavigatedFrom(e);
}
/**
* コンストラクタ
*/
public WvvTrimmingView()
{
this.DataContext = this;
this.InitializeComponent();
mSource = null;
mComposition = new MediaComposition();
mExtractor = new WvvFrameExtractor2(ThumbnailHeight, ThumbnailCount);
}
private async Task <Dictionary <TimeSpan, Face[]> > DetectFace_Video(StorageFile fileData)
{
// Process configs
const int frameJumpSize = 15;
const int frameQuota = 20;
const int frameTimeout = 60_000;
// Video
var videoProperties = await fileData.Properties.GetVideoPropertiesAsync();
var videoTime = TimeSpan.FromSeconds(0);
var videoFrame = 0;
// DetectedFaces
var detectedFaces = new Dictionary <TimeSpan, Face[]>();
// Process every frame
while (videoTime < videoProperties.Duration)
{
// Frame cut
var mediaClip = await MediaClip.CreateFromFileAsync(fileData);
var mediaComposition = new MediaComposition();
mediaComposition.Clips.Add(mediaClip);
var frame = await mediaComposition.GetThumbnailAsync(
videoTime,
0,
0,
VideoFramePrecision.NearestFrame
);
// Stream conversion
var randomAccessStream = new InMemoryRandomAccessStream();
await RandomAccessStream.CopyAsync(frame, randomAccessStream);
randomAccessStream.Seek(0);
// Process and add image
var detectedFace = await DetectFace_Image(randomAccessStream.AsStreamForRead());
if (detectedFace != null)
{
detectedFaces.Add(videoTime, detectedFace);
}
// Quota overflow
if (videoFrame != 0 && videoFrame % frameQuota == 0)
{
await Task.Delay(frameTimeout);
}
// Frame and time incrementation
videoTime += TimeSpan.FromSeconds(frameJumpSize);
videoFrame += 1;
}
return(detectedFaces);
}
public async Task <IInputStream> GetThumbnailAsync(StorageFile file, int milliseconds)
{
var mediaClip = await MediaClip.CreateFromFileAsync(file);
var mediaComposition = new MediaComposition();
mediaComposition.Clips.Add(mediaClip);
return(await mediaComposition.GetThumbnailAsync(TimeSpan.FromMilliseconds(milliseconds), 200, 200, VideoFramePrecision.NearestFrame));
}
public MainPage()
{
this.InitializeComponent();
if (mediaComposition == null)
{
mediaComposition = new MediaComposition();
}
}
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 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();
}));
});
}
/**
* フレームの抽出処理を開始
*
* @param clip ソースを保持したMediaClip
* @param extracted 取得したフレーム画像をコールバックするハンドラ
*/
public async Task <bool> ExtractAsync(MediaClip clip, OnThumbnailExtractedHandler extracted, OnBlankThumbnailHandler blank)
{
int doing = ++mDoing;
Error = null;
// Debug.WriteLine("Logical-DPI = {0}", DisplayInformation.GetForCurrentView().LogicalDpi);
var composer = new MediaComposition();
composer.Clips.Add(clip);
try
{
var totalRange = clip.OriginalDuration.TotalMilliseconds;
var span = totalRange / FrameCount;
var offset = span / 2;
for (int n = 0; n < FrameCount; n++)
{
using (var imageStream = await composer.GetThumbnailAsync(TimeSpan.FromMilliseconds(offset + span * n), 0, ThumbnailHeight, VideoFramePrecision.NearestFrame))
{
if (doing != mDoing)
{
// cancelling
return(false);
}
var bmp = new BitmapImage();
bmp.SetSource(imageStream); // bmp.SetSourceしたら、imageStreamはすぐDisposeしても大丈夫っぽい。
if (null != blank && n == 0)
{
var source = await CreateBlankBitmap(bmp.PixelWidth, bmp.PixelHeight);
#if false
var bb = new SoftwareBitmap(BitmapPixelFormat.Bgra8, bmp.PixelWidth, bmp.PixelHeight, BitmapAlphaMode.Ignore);
var source = new SoftwareBitmapSource();
await source.SetBitmapAsync(bb);
#endif
blank(this, source);
}
extracted(this, n, bmp);
}
}
return(true);
}
catch (Exception e)
{
CmLog.error("WvvFrameExtractor2.ExtractAsync", e);
Error = e;
return(false);
}
finally
{
composer.Clips.Clear();
}
}
//public bool IsCropEnabled
//{
// get { return this.Cropper.IsCropEnabled; }
// set { this.Cropper.IsCropEnabled = value; }
//}
//public Rect CropRectangle
//{
// get { return this.Cropper.CropRectangle; }
//}
private async void InitializeVideo(StorageFile file)
{
Media.Source = MediaSource.CreateFromStorageFile(file);
Media.MediaPlayer.AutoPlay = true;
Media.MediaPlayer.IsMuted = true;
Media.MediaPlayer.IsLoopingEnabled = true;
Media.MediaPlayer.PlaybackSession.PositionChanged += MediaPlayer_PositionChanged;
var clip = await MediaClip.CreateFromFileAsync(file);
var composition = new MediaComposition();
composition.Clips.Add(clip);
var props = clip.GetVideoEncodingProperties();
double ratioX = (double)40 / props.Width;
double ratioY = (double)40 / props.Height;
double ratio = Math.Max(ratioY, ratioY);
var width = (int)(props.Width * ratio);
var height = (int)(props.Height * ratio);
var count = Math.Ceiling(280d / width);
var times = new List <TimeSpan>();
for (int i = 0; i < count; i++)
{
times.Add(TimeSpan.FromMilliseconds(clip.OriginalDuration.TotalMilliseconds / count * i)); // TimeSpan.FromMilliseconds for older Frameworks (instead of Divide)
}
TrimThumbnails.Children.Clear();
#if MOBILE
var lumiaScaleFactor = 4; // prevents Catastrophic failure on Lumia 640 & probably others
var thumbnails = await composition.GetThumbnailsAsync(times, width *lumiaScaleFactor, height *lumiaScaleFactor, VideoFramePrecision.NearestKeyFrame);
#else
var thumbnails = await composition.GetThumbnailsAsync(times, width, height, VideoFramePrecision.NearestKeyFrame);
#endif
foreach (var thumb in thumbnails)
{
var bitmap = new BitmapImage();
await bitmap.SetSourceAsync(thumb);
var image = new Image();
image.Width = width;
image.Height = height;
image.Stretch = Windows.UI.Xaml.Media.Stretch.UniformToFill;
image.Source = bitmap;
TrimThumbnails.Children.Add(image);
}
TrimRange.SetOriginalDuration(clip.OriginalDuration);
}
public void PanelElementChanged()
{
if (SelectedPanelElement != null)
{
var clip = SelectedPanelElement.Clip.Clone();
var mediaComposition = new MediaComposition();
mediaComposition.Clips.Add(clip);
MediaSource = MediaSource.CreateFromMediaStreamSource(mediaComposition.GenerateMediaStreamSource());
}
}
public MainPage()
{
this.InitializeComponent();
diff = new TimeSpan();
begin = new DateTime();
now = new DateTime();
InitializeAudioRecording();
mediacomposition = new MediaComposition();
timer.Interval = new TimeSpan(0, 0, 1);
timer.Tick += DispatcherTimerEventHandler;
}
public PreviewCompostionPage()
{
try
{
this.InitializeComponent();
mediaComposition = new MediaComposition();
}
catch (Exception)
{
}
}
public MainPage()
{
this.InitializeComponent();
diff = new TimeSpan();
begin = new DateTime();
now = new DateTime();
InitializeAudioRecording();
mediacomposition = new MediaComposition();
timer.Interval = new TimeSpan(0, 0, 1);
timer.Tick += DispatcherTimerEventHandler;
}
async void OnLoaded(object sender, RoutedEventArgs e)
{
this.mediaElement.Visibility = Visibility.Collapsed;
this.progressInfo.Visibility = Visibility.Visible;
this.progressRing.IsActive = true;
this.progressText.Text = "Downloading video...";
var thumbnailFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Assets/Logo.scale-100.png"));
var thumbnail = RandomAccessStreamReference.CreateFromFile(thumbnailFile);
var url = "http://video.ch9.ms/ch9/4597/8db5a656-b173-4897-b2aa-e2075fb24597/windows10recap.mp4";
// TODO: replace TemporaryFolder and HttpClient with StorageFile.CreateStreamedFileFromUriAsync once TH:2458060 is fixed
//var file = await StorageFile.CreateStreamedFileFromUriAsync(
// "windows10recap.mp4",
// new Uri(url),
// thumbnail);
var file = await ApplicationData.Current.TemporaryFolder.CreateFileAsync("windows10recap.mp4", CreationCollisionOption.ReplaceExisting);
using (var httpClient = new HttpClient())
{
byte[] videoData = await httpClient.GetByteArrayAsync(url);
using (var writer = await file.OpenAsync(FileAccessMode.ReadWrite))
{
await writer.WriteAsync(videoData.AsBuffer());
}
}
this.progressText.Text = "Creating clip...";
var clip = await MediaClip.CreateFromFileAsync(file);
clip.VideoEffectDefinitions.Add(new VideoEffectDefinition(typeof(ExampleVideoEffect).FullName));
var composition = new MediaComposition();
composition.Clips.Add(clip);
if (ThumbnailGenerator.IsDrawingThumbnail)
{
customThumbnail = await composition.GetThumbnailAsync(TimeSpan.FromSeconds(10), 1280, 720, VideoFramePrecision.NearestFrame);
}
mediaElement.SetMediaStreamSource(composition.GenerateMediaStreamSource());
mediaElement.IsLooping = true;
this.mediaElement.Visibility = Visibility.Visible;
this.progressInfo.Visibility = Visibility.Collapsed;
this.progressRing.IsActive = false;
}
private async void button1_Click(object sender, RoutedEventArgs e)
{
CameraCaptureUI cc = new CameraCaptureUI();
cc.VideoSettings.Format = CameraCaptureUIVideoFormat.Mp4;
cc.VideoSettings.MaxResolution = CameraCaptureUIMaxVideoResolution.HighDefinition;
StorageFile sf = await cc.CaptureFileAsync(CameraCaptureUIMode.Video);
if (sf != null)
{
MediaClip mc = await MediaClip.CreateFromFileAsync(sf);
MediaComposition mcomp = new MediaComposition();
mcomp.Clips.Add(mc);
MediaStreamSource mss = mcomp.GeneratePreviewMediaStreamSource((int)mediaElement.ActualWidth, (int)mediaElement.ActualHeight);
mediaElement.SetMediaStreamSource(mss);
}
}
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 void VideoPlayer_Loaded(object sender, RoutedEventArgs e)
{
// Load video file
var videoFile = await Package.Current.InstalledLocation.GetFileAsync("big_buck_bunny.mp4");
// Create a MediaClip from the video file and apply our video effect
MediaClip clip = await MediaClip.CreateFromFileAsync(videoFile);
clip.VideoEffectDefinitions.Add(new VideoEffectDefinition(typeof(GrayscaleVideoEffect).FullName));
// Create a MediaComposition object that will allow us to generate a stream source
MediaComposition compositor = new MediaComposition();
compositor.Clips.Add(clip);
// Set the stream source to the MediaElement control
this.VideoPlayer.SetMediaStreamSource(compositor.GenerateMediaStreamSource());
}
private async void Capture_button_Click(object sender, RoutedEventArgs e)
{
// Declaring CameraCaptureUI to call the default Video capturing tool in the system
CameraCaptureUI cc = new CameraCaptureUI();
cc.VideoSettings.Format = CameraCaptureUIVideoFormat.Mp4;
cc.VideoSettings.MaxResolution = CameraCaptureUIMaxVideoResolution.HighDefinition;
/* saving the video temporarily in the storage file object
and setting the streaming source for our media element to show the information*/
sf = await cc.CaptureFileAsync(CameraCaptureUIMode.Video);
if (sf != null)
{
rs = await sf.OpenAsync(FileAccessMode.Read);
MediaClip mc = await MediaClip.CreateFromFileAsync(sf);
MediaComposition mcomp = new MediaComposition();
mcomp.Clips.Add(mc);
MediaStreamSource mss = mcomp.GeneratePreviewMediaStreamSource((int) video.ActualWidth, (int)video.ActualHeight);
video.SetMediaStreamSource(mss);
}
}
public async Task CS_WP_MC_PreviewTranscode(EffectType effectType)
{
StorageFile source = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Input/Car.mp4"));
StorageFile destination = await KnownFolders.VideosLibrary.CreateFileAsync("CS_WP_MC_PreviewTranscode_" + 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);
MediaStreamSource sourceStreamSource = composition.GenerateMediaStreamSource();
using (IRandomAccessStream destinationStream = await destination.OpenAsync(FileAccessMode.ReadWrite))
{
var transcoder = new MediaTranscoder();
var transcode = await transcoder.PrepareMediaStreamSourceTranscodeAsync(sourceStreamSource, destinationStream, MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Qvga));
await transcode.TranscodeAsync();
}
}
async void OnLoaded(object sender, RoutedEventArgs e)
{
this.mediaElement.Visibility = Visibility.Collapsed;
this.progressInfo.Visibility = Visibility.Visible;
this.progressRing.IsActive = true;
this.progressText.Text = "Downloading video...";
var thumbnailFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Assets/Logo.scale-100.png"));
var thumbnail = RandomAccessStreamReference.CreateFromFile(thumbnailFile);
var url = "http://video.ch9.ms/ch9/4597/8db5a656-b173-4897-b2aa-e2075fb24597/windows10recap.mp4";
var file = await StorageFile.CreateStreamedFileFromUriAsync(
"windows10recap.mp4",
new Uri(url),
thumbnail);
this.progressText.Text = "Creating clip...";
var clip = await MediaClip.CreateFromFileAsync(file);
clip.VideoEffectDefinitions.Add(new VideoEffectDefinition(typeof(ExampleVideoEffect).FullName));
var composition = new MediaComposition();
composition.Clips.Add(clip);
if (ThumbnailGenerator.IsDrawingThumbnail)
{
customThumbnail = await composition.GetThumbnailAsync(TimeSpan.FromSeconds(10), 1280, 720, VideoFramePrecision.NearestFrame);
}
mediaElement.SetMediaStreamSource(composition.GenerateMediaStreamSource());
mediaElement.IsLooping = true;
this.mediaElement.Visibility = Visibility.Visible;
this.progressInfo.Visibility = Visibility.Collapsed;
this.progressRing.IsActive = false;
}
public async Task CS_WP_MC_LumiaCropSquare()
{
StorageFile source = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Input/Car.mp4"));
StorageFile destination = await KnownFolders.VideosLibrary.CreateFileAsync("CS_W_MT_CropSquare.mp4", CreationCollisionOption.ReplaceExisting);
// Select the largest centered square area in the input video
var encodingProfile = await MediaEncodingProfile.CreateFromFileAsync(source);
uint inputWidth = encodingProfile.Video.Width;
uint inputHeight = encodingProfile.Video.Height;
uint outputLength = Math.Min(inputWidth, inputHeight);
Rect cropArea = new Rect(
(float)((inputWidth - outputLength) / 2),
(float)((inputHeight - outputLength) / 2),
(float)outputLength,
(float)outputLength
);
encodingProfile.Video.Width = outputLength;
encodingProfile.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);
MediaStreamSource sourceStreamSource = composition.GenerateMediaStreamSource();
using (IRandomAccessStream destinationStream = await destination.OpenAsync(FileAccessMode.ReadWrite))
{
var transcoder = new MediaTranscoder();
var transcode = await transcoder.PrepareMediaStreamSourceTranscodeAsync(sourceStreamSource, destinationStream, MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Qvga));
await transcode.TranscodeAsync();
}
}
/// <summary>
/// Initializes a new instance of the MainViewModel class.
/// </summary>
public MainViewModel(
IDataService dataService,
INavigationService navigationService)
{
_dataService = dataService;
_navigationService = navigationService;
OpenFileCommand = new RelayCommand(OpenFile);
SaveFileCommand = new RelayCommand(TranscodeVideo);
handledExtensions = new List<string>();
handledExtensions.AddRange(imageExtensions);
handledExtensions.AddRange(videoExtensions);
m_composition = new MediaComposition();
clips = new ObservableCollection<MediaClip>();
Initialize();
}
/// <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 TrimClip_Click(object sender, RoutedEventArgs e)
{
// Trim the front and back 25% from the clip
var clip = await MediaClip.CreateFromFileAsync(pickedFile);
clip.TrimTimeFromStart = new TimeSpan((long)(clip.OriginalDuration.Ticks * 0.25));
clip.TrimTimeFromEnd = new TimeSpan((long)(clip.OriginalDuration.Ticks * 0.25));
// Create a MediaComposition containing the clip and set it on the MediaElement.
composition = new MediaComposition();
composition.Clips.Add(clip);
mediaElement.Position = TimeSpan.Zero;
mediaStreamSource = composition.GeneratePreviewMediaStreamSource((int)mediaElement.ActualWidth, (int)mediaElement.ActualHeight);
mediaElement.SetMediaStreamSource(mediaStreamSource);
rootPage.NotifyUser("Clip trimmed", NotifyType.StatusMessage);
save.IsEnabled = true;
}
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 void StartMediaCompositionPreview_Click(object sender, RoutedEventArgs e)
{
StartMediaCompositionPreview.IsEnabled = false;
StorageFile source = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Assets/Car.mp4"));
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);
MediaCompositionPreview.SetMediaStreamSource(composition.GenerateMediaStreamSource());
StartMediaCompositionPreview.IsEnabled = true;
}
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 LoadAsync(StorageFile source, int timeStretchRate)
{
composition = new MediaComposition();
MediaClip clip = await MediaClip.CreateFromFileAsync(source);
//No slow motion
if (offsets.Count == 0)
{
composition.Clips.Add(clip);
return;
}
int last = offsets.Count - 1;
for (int i = 0; i < last; i++)
{
offsets.Add(new VideoRange()
{
StartOffset = offsets[i].EndOffset,
EndOffset = offsets[i + 1].StartOffset,
IsSlowMo = false
});
}
//At the beginning
offsets.Insert(0, new VideoRange()
{
StartOffset = 0,
EndOffset = offsets[0].StartOffset,
IsSlowMo = false
});
double maxEndOffset = offsets.Max(x => x.EndOffset);
//At the end
offsets.Add(new VideoRange()
{
StartOffset = maxEndOffset,
EndOffset = clip.OriginalDuration.TotalMilliseconds,
IsSlowMo = false
});
var slowMoEffect = new SlowMotionEffectDefinition()
{
TimeStretchRate = timeStretchRate
};
foreach (VideoRange videoOffset in offsets.OrderBy(x => x.StartOffset))
{
MediaClip piece = await MediaClip.CreateFromFileAsync(source);
TimeSpan startOffset = TimeSpan.FromMilliseconds(videoOffset.StartOffset);
TimeSpan endOffset = TimeSpan.FromMilliseconds(clip.OriginalDuration.TotalMilliseconds - videoOffset.EndOffset);
piece.TrimTimeFromStart = startOffset;
piece.TrimTimeFromEnd = endOffset > TimeSpan.Zero ? endOffset : TimeSpan.Zero;
composition.Clips.Add(piece);
if (videoOffset.IsSlowMo)
{
piece.VideoEffectDefinitions.Add(slowMoEffect);
}
}
Tracing.Trace("SlowMotionProcessor. OriginalDuration: {0}", clip.OriginalDuration);
//Debug
foreach (MediaClip each in composition.Clips)
{
Tracing.Trace("SlowMotionProcessor. MediaClip. StartTimeInComposition: {0}, TrimTimeFromStart: {1}, TrimTimeFromEnd: {2}, TrimmedDuration: {3}",
each.StartTimeInComposition, each.TrimTimeFromStart, each.TrimTimeFromEnd, each.TrimmedDuration);
}
}
private async void AppendVideos_Click(object sender, RoutedEventArgs e)
{
// Combine two video files together into one
var firstClip = await MediaClip.CreateFromFileAsync(firstVideoFile);
var secondClip = await MediaClip.CreateFromFileAsync(secondVideoFile);
composition = new MediaComposition();
composition.Clips.Add(firstClip);
composition.Clips.Add(secondClip);
// Render to MediaElement.
mediaElement.Position = TimeSpan.Zero;
mediaStreamSource = composition.GeneratePreviewMediaStreamSource((int)mediaElement.ActualWidth, (int)mediaElement.ActualHeight);
mediaElement.SetMediaStreamSource(mediaStreamSource);
rootPage.NotifyUser("Clips appended", NotifyType.StatusMessage);
}
