private async void encodeImages_Click(object sender, RoutedEventArgs e)
{
FileOpenPicker openPicker = new FileOpenPicker();
foreach (string extension in FileExtensions.Image)
{
openPicker.FileTypeFilter.Add(extension);
}
IReadOnlyList <StorageFile> files = await openPicker.PickMultipleFilesAsync();
composition = new MediaComposition();
foreach (StorageFile file in files)
{
m_files.Add(file);
var clip = await MediaClip.CreateFromImageFileAsync(file, TimeSpan.FromMilliseconds(1000));
composition.Clips.Add(clip);
}
Debug.WriteLine(composition.Clips.Count);
//StorageFile fileSave = await openPicker.PickSaveFileAsync();
//if (file != null)
//{
// var saveOperation = composition.RenderToFileAsync(file, MediaTrimmingPreference.Precise);
// await composition.RenderToFileAsync("C://Mike");
//}
}
private static async Task <MediaClip> AddClipAsync(StorageFile pickedFile, PanelElement element)
{
MediaClip clip;
if (element.FileType == FileType.Picture)
{
using (StorageItemThumbnail thumbnail = await pickedFile.GetThumbnailAsync(ThumbnailMode.PicturesView))
{
if (thumbnail != null)
{
BitmapImage bitmapImage = new BitmapImage();
bitmapImage.SetSource(thumbnail);
element.Thumbnail = bitmapImage;
}
}
clip = await MediaClip.CreateFromImageFileAsync(pickedFile, TimeSpan.FromSeconds(5));
}
else
{
using (StorageItemThumbnail thumbnail = await pickedFile.GetThumbnailAsync(ThumbnailMode.VideosView))
{
if (thumbnail != null)
{
BitmapImage bitmapImage = new BitmapImage();
bitmapImage.SetSource(thumbnail);
element.Thumbnail = bitmapImage;
}
}
clip = await MediaClip.CreateFromFileAsync(pickedFile);
}
return(clip);
}
private async void AddPicturesButton_Tapped(object sender, TappedRoutedEventArgs e)
{
FileOpenPicker filePicker = new FileOpenPicker {
SuggestedStartLocation = PickerLocationId.PicturesLibrary
};
filePicker.FileTypeFilter.Add(".jpg");
filePicker.FileTypeFilter.Add(".jpeg");
filePicker.FileTypeFilter.Add(".png");
filePicker.FileTypeFilter.Add(".bmp");
filePicker.FileTypeFilter.Add(".gif");
filePicker.FileTypeFilter.Add(".tiff");
filePicker.ViewMode = PickerViewMode.Thumbnail;
StorageFile file = await filePicker.PickSingleFileAsync();
if (file != null)
{
try
{
StorageItemAccessList storageItemAccessList = StorageApplicationPermissions.FutureAccessList;
storageItemAccessList.Add(file);
//新建媒体
Media media = new Media();
//缩略图
using (StorageItemThumbnail thumbnail = await file.GetThumbnailAsync(ThumbnailMode.PicturesView))
{
if (thumbnail != null)
{
BitmapImage bitmapImage = new BitmapImage();
bitmapImage.SetSource(thumbnail);
media.Bitmap = bitmapImage;
}
}
//从文件创建媒体剪辑
MediaClip clip = await MediaClip.CreateFromImageFileAsync(file, new TimeSpan(24, 1, 0));
clip.TrimTimeFromEnd = clip.TrimTimeFromStart = new TimeSpan(12, 0, 0);
media.Clip = clip;
//从颜色创建名称
media.Name = file.Name;
MediaClipList.Add(media);
SplitShowMethod();// SplitView：侧栏
}
catch (Exception)
{
App.Tip("file err");
}
}
else
{
App.Tip("file 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);
}
public async Task CreateClipFromImageFile()
{
for (int i = 0; i < count; i++)
{
string FileName = $"capture{i}.";
FileName += "jpg";
var file = await Windows.Storage.ApplicationData.Current.TemporaryFolder.GetFileAsync(FileName);
mediaComposition.Clips.Add(await MediaClip.CreateFromImageFileAsync(file, timeSpans[i]));
}
}
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);
}
//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();
}
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 LoadFile(StorageFile file)
{
fileName = Path.GetFileNameWithoutExtension(file.Name);
Debug.WriteLine("Picked video: " + fileName + " with full name: " + file.Name);
if (handledExtensions.Contains(Path.GetExtension(file.Path)))
{
MediaClip newClip;
if (imageExtensions.Contains(Path.GetExtension(file.Path)))
{
newClip = await MediaClip.CreateFromImageFileAsync(file, TimeSpan.FromSeconds(DEFAULT_DURATION));
}
else // if (videoExtensions.Contains(Path.GetExtension(file.Path)))
{
newClip = await MediaClip.CreateFromFileAsync(file);
}
m_composition.Clips.Add(newClip);
// Render a thumbnail from the center of the clip's duration
ImageStream x = await m_composition.GetThumbnailAsync(TimeSpan.FromMilliseconds(newClip.StartTimeInComposition.TotalMilliseconds + newClip.TrimmedDuration.TotalMilliseconds / 2d), HEIGHT, 0, VideoFramePrecision.NearestKeyFrame);
StorageFolder localFolder = ApplicationData.Current.LocalFolder;
// Write data to a file
StorageFile imageFile = await localFolder.CreateFileAsync(newClip.GetHashCode() + imageExtensions[0], CreationCollisionOption.ReplaceExisting);
//BitmapImage bitmap = new BitmapImage();
//bitmap.SetSource(x);
//wBitmap.SetSource(x);
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(x);
WriteableBitmap wBitmap = new WriteableBitmap((int)decoder.PixelWidth, (int)decoder.PixelHeight);
// Scale image to appropriate size
BitmapTransform transform = new BitmapTransform()
{
ScaledWidth = Convert.ToUInt32(decoder.PixelWidth),
ScaledHeight = Convert.ToUInt32(decoder.PixelHeight)
};
PixelDataProvider pixelData = await decoder.GetPixelDataAsync(
BitmapPixelFormat.Bgra8, // WriteableBitmap uses BGRA format
BitmapAlphaMode.Straight,
transform,
ExifOrientationMode.IgnoreExifOrientation, // This sample ignores Exif orientation
ColorManagementMode.DoNotColorManage
);
// An array containing the decoded image data, which could be modified before being displayed
byte[] sourcePixels = pixelData.DetachPixelData();
// Open a stream to copy the image contents to the WriteableBitmap's pixel buffer
using (Stream stream = wBitmap.PixelBuffer.AsStream())
{
await stream.WriteAsync(sourcePixels, 0, sourcePixels.Length);
}
await wBitmap.SaveToFile(imageFile, BitmapEncoder.JpegEncoderId);
//var fs = await imageFile.OpenAsync(FileAccessMode.ReadWrite);
//DataWriter writer = new DataWriter(fs.GetOutputStreamAt(0));
//writer.WriteBytes(await x.ReadAsync());
//await writer.StoreAsync();
//writer.DetachStream();
//await fs.FlushAsync();
//StorageFile imgFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(newClip.GetHashCode() + imageExtensions[0], CreationCollisionOption.ReplaceExisting);
//byte[] pixels = new byte[4 * bitmap.PixelWidth * bitmap.PixelHeight];
//Stream pixelStream = wBitmap.PixelBuffer.AsStream();
//pixelStream.Seek(0, SeekOrigin.Begin);
//pixelStream.Write(pixels, 0, pixels.Length);
////BitmapToWriteableBitmap(imgFile);
//await Utilities.SaveToFile(wBitmap, imgFile, new Guid());
////using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite))
////{
//// var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, stream);
//// encoder.SetPixelData(
//// BitmapPixelFormat.Bgra8,
//// BitmapAlphaMode.Ignore,
//// (uint)bitmap.PixelWidth,
//// (uint)bitmap.PixelHeight,
//// 96d,
//// 96d,
//// bitmap.
//// );
////// await encoder.FlushAsync();
//////}
////if (bitmap != null)
////{
//// IRandomAccessStream stream = await bitmap.OpenAsync(FileAccessMode.Read);
//// bmp.SetSource(stream);
//// imageGrid.Source = bmp;
////}
newClip.UserData.Add("thumb", imageFile.Path);
Clips.Add(newClip);
RaisePropertyChanged(Utilities.GetMemberName(() => Clips));
MyUri = new Uri(imageFile.Path);
}
}
private async void FrameCapture()
{
RenderComplete.Visibility = Visibility.Collapsed;
composition = new MediaComposition();
List <string> fileTypeFilter = new List <string>();
fileTypeFilter.Add("*");
QueryOptions queryOptions = new QueryOptions(CommonFileQuery.DefaultQuery, fileTypeFilter);
queryOptions.UserSearchFilter = "Lapses";
StorageFileQueryResult z = PictureLapsesFolder.CreateFileQueryWithOptions(queryOptions);
IReadOnlyList <StorageFile> files = await z.GetFilesAsync();
if (files.Count == 0)
{
NoFiles.Visibility = Visibility.Visible;
return;
}
files.OrderBy(x => x.DateCreated);
String framesPS = (FramesPerSecond.SelectedIndex + 1).ToString("D2");
string desiredName = "Rendered-" + framesPS + "-FPS.mp4";
StorageFolder localFolder = ProjectFolder;
Windows.Storage.StorageFile pickedVidFile = await localFolder.CreateFileAsync(desiredName, CreationCollisionOption.GenerateUniqueName);
DarnSeconds q = (DarnSeconds)((ComboBoxItem)FramesPerSecond.SelectedItem).Tag;
foreach (StorageFile j in files)
{
if (j == null)
{
//ShowErrorMessage("File picking cancelled");
return;
}
// These files could be picked from a location that we won't have access to later
var storageItemAccessList = Windows.Storage.AccessCache.StorageApplicationPermissions.FutureAccessList;
//torageItemAccessList.Add(pickedFile);
var clip = await MediaClip.CreateFromImageFileAsync(j, TimeSpan.FromMilliseconds(q.HowManyDarnSeconds));
composition.Clips.Add(clip);
}
await composition.RenderToFileAsync(pickedVidFile);
RenderComplete.Visibility = Visibility.Visible;
//await composition.SaveAsync(MediaStreamSample);
}
public async Task MergeMedias(List<Media> medias, MediaGroup currentMediaGroup = null)
{
// Use Profile for output vid/cmp? file
try
{
List<StorageFile> mediaFiles = new List<StorageFile>();
MediaGroup mediaGroup = new MediaGroup();
StorageFolder localFolder = ApplicationData.Current.LocalFolder;
MediaComposition composition = new MediaComposition();
List<MediaClip> mediaClips = new List<MediaClip>();
StorageFile timelineVidOutputFile;
StorageFile timelineCMPOutputFile;
bool deleteExistingFile = (currentMediaGroup != null) ? false : true;
#region EmotionsMeanTemp
double tmpAngerScoreMean = 0;
double tmpContemptScoreMean = 0;
double tmpDisgustScoreMean = 0;
double tmpFearScoreMean = 0;
double tmpHappinessScoreMean = 0;
double tmpNeutralScoreMean = 0;
double tmpSadnessScoreMean = 0;
double tmpSurpriseScoreMean = 0;
string tmpHighestEmotionMean = string.Empty;
#endregion
foreach (var media in medias)
{
mediaFiles.Add(await StorageFile.GetFileFromApplicationUriAsync(new Uri(
string.Format("ms-appdata:///local/{0}", media.MediaName))));
tmpAngerScoreMean += media.AngerScore;
tmpContemptScoreMean += media.ContemptScore;
tmpDisgustScoreMean += media.DisgustScore;
tmpFearScoreMean += media.FearScore;
tmpHappinessScoreMean += media.HappinessScore;
tmpNeutralScoreMean += media.NeutralScore;
tmpSadnessScoreMean += media.SadnessScore;
tmpSurpriseScoreMean += media.SurpriseScore;
}
tmpAngerScoreMean = tmpAngerScoreMean / medias.Count;
tmpContemptScoreMean = tmpContemptScoreMean / medias.Count;
tmpDisgustScoreMean = tmpDisgustScoreMean / medias.Count;
tmpFearScoreMean = tmpFearScoreMean / medias.Count;
tmpHappinessScoreMean = tmpHappinessScoreMean / medias.Count;
tmpNeutralScoreMean = tmpNeutralScoreMean / medias.Count;
tmpSadnessScoreMean = tmpSadnessScoreMean / medias.Count;
tmpSurpriseScoreMean = tmpSurpriseScoreMean / medias.Count;
SortedList<string, double> tempForSortingScores = new SortedList<string, double>();
tempForSortingScores.Add("AngerScoreMean", tmpAngerScoreMean);
tempForSortingScores.Add("ContemptScoreMean", tmpContemptScoreMean);
tempForSortingScores.Add("DisgustScoreMean", tmpDisgustScoreMean);
tempForSortingScores.Add("FearScoreMean", tmpFearScoreMean);
tempForSortingScores.Add("HappinessScoreMean", tmpHappinessScoreMean);
tempForSortingScores.Add("NeutralScoreMean", tmpNeutralScoreMean);
tempForSortingScores.Add("SadnessScoreMean", tmpSadnessScoreMean);
tempForSortingScores.Add("SurpriseScoreMean", tmpSurpriseScoreMean);
// TODO: check this.
tmpHighestEmotionMean = tempForSortingScores.OrderByDescending(x => x.Value).FirstOrDefault().Key;
if (currentMediaGroup == null)
{
timelineVidOutputFile = await localFolder.CreateFileAsync(
"timelineMeOutput.mp4", CreationCollisionOption.GenerateUniqueName);
string CMPFileName = string.Format(timelineVidOutputFile.DisplayName + ".cmp");
timelineCMPOutputFile = await localFolder.CreateFileAsync(
CMPFileName, CreationCollisionOption.OpenIfExists);
for (int i = 0; i < mediaFiles.Count; i++)
{
mediaClips.Add(await MediaClip.CreateFromImageFileAsync(mediaFiles[i], TimeSpan.FromSeconds(int.Parse(localSettings.Values["DurationInSecForEachImage"].ToString()))));
composition.Clips.Add(mediaClips[i]);
}
using (var db = new MediaContext())
{
mediaGroup = new MediaGroup()
{
CompostionFileName = timelineVidOutputFile.DisplayName,
LastEditDate = DateTime.Now,
AngerScoreMean = tmpAngerScoreMean,
ContemptScoreMean = tmpContemptScoreMean,
DisgustScoreMean = tmpDisgustScoreMean,
FearScoreMean = tmpFearScoreMean,
HappinessScoreMean = tmpHappinessScoreMean,
NeutralScoreMean = tmpNeutralScoreMean,
SadnessScoreMean = tmpSadnessScoreMean,
SurpriseScoreMean = tmpSurpriseScoreMean,
HighestEmotionMean = tmpHighestEmotionMean
};
db.MediaGroups.Add(mediaGroup);
db.SaveChanges();
}
var action = composition.SaveAsync(timelineCMPOutputFile);
action.Completed = (info, status) =>
{
if (status != AsyncStatus.Completed)
{
//ShowErrorMessage("Error saving composition");
}
};
}
else
{
using (var db = new MediaContext())
{
mediaGroup =
db.MediaGroups.Where(
x => x.CompostionFileName == currentMediaGroup.CompostionFileName).
FirstOrDefault();
// TODO Check this
mediaGroup.LastEditDate = DateTime.Now;
mediaGroup.AngerScoreMean = mediaGroup.AngerScoreMean + tmpAngerScoreMean / 2;
mediaGroup.ContemptScoreMean = mediaGroup.ContemptScoreMean + tmpContemptScoreMean / 2;
mediaGroup.DisgustScoreMean = mediaGroup.DisgustScoreMean + tmpDisgustScoreMean / 2;
mediaGroup.FearScoreMean = mediaGroup.FearScoreMean + tmpFearScoreMean / 2;
mediaGroup.HappinessScoreMean = mediaGroup.HappinessScoreMean + tmpHappinessScoreMean / 2;
mediaGroup.NeutralScoreMean = mediaGroup.NeutralScoreMean + tmpNeutralScoreMean / 2;
mediaGroup.SadnessScoreMean = mediaGroup.SadnessScoreMean + tmpSadnessScoreMean / 2;
mediaGroup.SurpriseScoreMean = mediaGroup.SurpriseScoreMean + tmpSurpriseScoreMean / 2;
SortedList<string, double> temptempForSortingScores = new SortedList<string, double>();
temptempForSortingScores.Add("AngerScoreMean", mediaGroup.AngerScoreMean);
temptempForSortingScores.Add("ContemptScoreMean", mediaGroup.ContemptScoreMean);
temptempForSortingScores.Add("DisgustScoreMean", mediaGroup.DisgustScoreMean);
temptempForSortingScores.Add("FearScoreMean", mediaGroup.FearScoreMean);
temptempForSortingScores.Add("HappinessScoreMean", mediaGroup.HappinessScoreMean);
temptempForSortingScores.Add("NeutralScoreMean", mediaGroup.NeutralScoreMean);
temptempForSortingScores.Add("SadnessScoreMean", mediaGroup.SadnessScoreMean);
temptempForSortingScores.Add("SurpriseScoreMean", mediaGroup.SurpriseScoreMean);
// TODO: check this.
mediaGroup.HighestEmotionMean = temptempForSortingScores.OrderByDescending(x => x.Value).FirstOrDefault().Key;
db.MediaGroups.Update(mediaGroup);
db.SaveChanges();
}
timelineVidOutputFile = await localFolder.GetFileAsync(currentMediaGroup.CompostionFileName + ".mp4");
timelineCMPOutputFile = await localFolder.GetFileAsync(currentMediaGroup.CompostionFileName + ".cmp");
composition = await MediaComposition.LoadAsync(timelineCMPOutputFile);
//TODO: make sure this works.
for (int i = 0; i < mediaFiles.Count; i++)
{
// TODO Fix this
mediaClips.Add(await MediaClip.CreateFromImageFileAsync(mediaFiles[i], TimeSpan.FromSeconds(int.Parse(localSettings.Values["DurationInSecForEachImage"].ToString()))));
composition.Clips.Add(mediaClips[i]);
}
var action = composition.SaveAsync(timelineCMPOutputFile);
action.Completed = (info, status) =>
{
if (status != AsyncStatus.Completed)
{
//ShowErrorMessage("Error saving composition");
}
};
}
}
catch (Exception)
{
}
}