public async Task StartAsync()
{
m_isRecording = true;
if (m_isVideo)
{
var profile = MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Auto);
var rotationAngle = CameraRotationHelper.ConvertSimpleOrientationToClockwiseDegrees(_rotationHelper.GetCameraCaptureOrientation());
profile.Video.Properties.Add(new Guid("C380465D-2271-428C-9B83-ECEA3B4A85C1"), PropertyValue.CreateInt32(rotationAngle));
m_lowLag = await m_mediaCapture.PrepareLowLagRecordToStorageFileAsync(profile, m_file);
await m_lowLag.StartAsync();
}
else
{
var wavEncodingProfile = MediaEncodingProfile.CreateWav(AudioEncodingQuality.High);
wavEncodingProfile.Audio.BitsPerSample = 16;
wavEncodingProfile.Audio.SampleRate = 48000;
wavEncodingProfile.Audio.ChannelCount = 1;
m_opusSink = await OpusCodec.CreateMediaSinkAsync(m_file);
await m_mediaCapture.StartRecordToCustomSinkAsync(wavEncodingProfile, m_opusSink);
}
}
private async void TakeVideoAsync()
{
mediaCapture = new MediaCapture();
await mediaCapture.InitializeAsync();
if (isVideoStarted == false)
{
var myVideos = await Windows.Storage.StorageLibrary.GetLibraryAsync(Windows.Storage.KnownLibraryId.Videos);
StorageFile file = await myVideos.SaveFolder.CreateFileAsync("video.mp4", CreationCollisionOption.GenerateUniqueName);
_mediaRecording = await mediaCapture.PrepareLowLagRecordToStorageFileAsync(
MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Auto), file);
await _mediaRecording.StartAsync();
isVideoStarted = true;
}
else
{
await _mediaRecording.StopAsync();
await _mediaRecording.FinishAsync();
}
}
private async Task RecStart()
{
var myVideos = await Windows.Storage.StorageLibrary.GetLibraryAsync(Windows.Storage.KnownLibraryId.Videos);
StorageFile file = await myVideos.SaveFolder.CreateFileAsync("video.mp4", CreationCollisionOption.GenerateUniqueName);
_mediaRecording = await mediaCapture.PrepareLowLagRecordToStorageFileAsync(
MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Auto), file);
await _mediaRecording.StartAsync();
}
private async void ButtonBase_OnClick(object sender, RoutedEventArgs e)
{
mediaCapture = new MediaCapture();
await mediaCapture.InitializeAsync();
storageFolder = ApplicationData.Current.LocalFolder;
storageFile = await storageFolder.CreateFileAsync("test.mp3", CreationCollisionOption.GenerateUniqueName);
lowLagMedia = await mediaCapture.PrepareLowLagRecordToStorageFileAsync(
MediaEncodingProfile.CreateMp3(AudioEncodingQuality.High), storageFile);
await lowLagMedia.StartAsync();
}
async Task Start()
{
md = new MediaCapture();
await md.InitializeAsync();
var video = await Windows.Storage.StorageLibrary.GetLibraryAsync(Windows.Storage.KnownLibraryId.Videos);
StorageFile file = await video.SaveFolder.CreateFileAsync("video.mp4", CreationCollisionOption.GenerateUniqueName);
recorder = await md.PrepareLowLagRecordToStorageFileAsync(
MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Auto), file);
await recorder.StartAsync();
}
private async void CaptureStartButton_Click(object sender, RoutedEventArgs e)
{
if (!IsCaptureEnabled)
{
return;
}
IsCaptureEnabled = false;
await _mediaCapture.StartPreviewAsync();
_video = await ApplicationData.Current.LocalFolder.CreateFileAsync($"{Guid.NewGuid()}.mp4");
_mediaRecording = await _mediaCapture.PrepareLowLagRecordToStorageFileAsync(
MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Auto), _video);
await _mediaRecording.StartAsync();
}
private async void MediaRecordbt_Click(object sender, RoutedEventArgs e)
{
if (cameraDevice == null)
{
return;
}
var myVideos = await Windows.Storage.StorageLibrary.GetLibraryAsync(Windows.Storage.KnownLibraryId.Videos);
StorageFile file = await myVideos.SaveFolder.CreateFileAsync("video.mp4", CreationCollisionOption.GenerateUniqueName);
_mediaRecording = await _mediaCapture.PrepareLowLagRecordToStorageFileAsync(MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Auto), file);
await _mediaRecording.StartAsync();
StopBt.IsEnabled = true;
MediaRecordbt.IsEnabled = false;
}
public async Task StartAudioCapture()
{
mediaCapture = new MediaCapture();
await mediaCapture.InitializeAsync();
//<SnippetStartAudioCapture>
mediaCapture.RecordLimitationExceeded += MediaCapture_RecordLimitationExceeded;
var localFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
StorageFile file = await localFolder.CreateFileAsync("audio.mp3", CreationCollisionOption.GenerateUniqueName);
_mediaRecording = await mediaCapture.PrepareLowLagRecordToStorageFileAsync(
MediaEncodingProfile.CreateMp3(AudioEncodingQuality.High), file);
await _mediaRecording.StartAsync();
//</SnippetStartAudioCapture>
}
//</SnippetLowLagMediaRecording>
public async Task StartVideoCapture()
{
//<SnippetRecordLimitationExceeded>
mediaCapture.RecordLimitationExceeded += MediaCapture_RecordLimitationExceeded;
//</SnippetRecordLimitationExceeded>
//<SnippetStartVideoCapture>
var myVideos = await Windows.Storage.StorageLibrary.GetLibraryAsync(Windows.Storage.KnownLibraryId.Videos);
StorageFile file = await myVideos.SaveFolder.CreateFileAsync("video.mp4", CreationCollisionOption.GenerateUniqueName);
_mediaRecording = await mediaCapture.PrepareLowLagRecordToStorageFileAsync(
MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Auto), file);
await _mediaRecording.StartAsync();
//</SnippetStartVideoCapture>
}
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
if (e.Parameter.ToString() == "rec")
{
_mediaCapture = new MediaCapture();
await _mediaCapture.InitializeAsync();
_mediaCapture.Failed += _mediaCapture_Failed;
var myVideo = await Windows.Storage.StorageLibrary.GetLibraryAsync(Windows.Storage.KnownLibraryId.Videos);
StorageFile file = await myVideo.SaveFolder.CreateFileAsync("video.mp4", CreationCollisionOption.GenerateUniqueName);
_mediaRecording = await _mediaCapture.PrepareLowLagRecordToStorageFileAsync(
MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Auto), file);
await _mediaRecording.StartAsync();
}
}
internal async Task StartRecordingAsync(string projectName, int sequenceNumber)
{
bool hasCameraName = _CameraNameText != null && _CameraNameText.Length > 0;
string baseName = hasCameraName ? _CameraNameText : this.Name;
bool hasProjectName = projectName != null && projectName.Length > 0;
string project = hasProjectName ? projectName : "RecordCamsProject";
string name = project + "\\" + sequenceNumber.ToString("000") + "_" + baseName + ".mp4";
var myVideos = await StorageLibrary.GetLibraryAsync(KnownLibraryId.Videos);
savedVideoFile = await myVideos.SaveFolder.CreateFileAsync(name, CreationCollisionOption.GenerateUniqueName);
_mediaRecording = await mediaCapture.PrepareLowLagRecordToStorageFileAsync(
MediaEncodingProfile.CreateMp4(VideoEncodingQuality.HD1080p), savedVideoFile);
mediaCapture.RecordLimitationExceeded += MediaCapture_RecordLimitationExceeded;
await _mediaRecording.StartAsync();
}
private async void startVideoStreamBtn_Click(object sender, RoutedEventArgs e)
{
if (mediaCapture == null)
{
MessageDialog messageDialog = new MessageDialog("Please start camera");
await messageDialog.ShowAsync();
return;
}
var myVideos = await Windows.Storage.StorageLibrary.GetLibraryAsync(Windows.Storage.KnownLibraryId.Videos);
StorageFile file = await myVideos.SaveFolder.CreateFileAsync("video.mp4", CreationCollisionOption.GenerateUniqueName);
await mediaCapture.InitializeAsync();
mediaRecording = await mediaCapture.PrepareLowLagRecordToStorageFileAsync(
MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Auto), file);
await mediaRecording.StartAsync();
}
private async Task StartRecording()
{
int index = 0;
lock (this)
{
if (uploadingSoundFileIndexes.Count() > 0)
{
int max = uploadingSoundFileIndexes.Max();
while (index <= max)
{
if (!uploadingSoundFileIndexes.Contains(index))
{
break;
}
index++;
}
}
uploadingSoundFileIndexes.Add(index);
}
currentFileName = soundFileNamePrefix + index + soudFileNameExt;
try
{
StorageFile file = await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFileAsync(currentFileName, Windows.Storage.CreationCollisionOption.ReplaceExisting);
mediaRecording = await audioCapture.PrepareLowLagRecordToStorageFileAsync(
MediaEncodingProfile.CreateMp3(AudioEncodingQuality.High), file);
await mediaRecording.StartAsync();
Debug.WriteLine("StartR - " + currentFileName);
}
catch (Exception ex)
{
AppendPlayLog("Start Recording Exception:", ex.Message);
}
}
public async Task StartAsync()
{
m_isRecording = true;
if (m_isVideo)
{
var profile = MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Vga);
m_lowLag = await m_mediaCapture.PrepareLowLagRecordToStorageFileAsync(profile, m_file);
await m_lowLag.StartAsync();
}
else
{
var wavEncodingProfile = MediaEncodingProfile.CreateWav(AudioEncodingQuality.High);
wavEncodingProfile.Audio.BitsPerSample = 16;
wavEncodingProfile.Audio.SampleRate = 48000;
wavEncodingProfile.Audio.ChannelCount = 1;
m_opusSink = await OpusCodec.CreateMediaSinkAsync(m_file);
await m_mediaCapture.StartRecordToCustomSinkAsync(wavEncodingProfile, m_opusSink);
}
}
private async void Checked()
{
try
{
var settings = new Windows.Media.Capture.MediaCaptureInitializationSettings();
settings.StreamingCaptureMode = Windows.Media.Capture.StreamingCaptureMode.Audio;
settings.MediaCategory = Windows.Media.Capture.MediaCategory.Other;
settings.AudioProcessing = Windows.Media.AudioProcessing.Default;
await audioCapture.InitializeAsync(settings);
StorageFolder externalDevices = KnownFolders.RemovableDevices;
IReadOnlyList <StorageFolder> externalDrives = await externalDevices.GetFoldersAsync();
StorageFolder usbStorage = externalDrives[0];
//ENSURE FOLDER EXISTS
if (await usbStorage.TryGetItemAsync("Recording") == null)
{
await usbStorage.CreateFolderAsync("Recording");
}
string Folder_Pfad = "Recording\\" + DateTime.Now.Year.ToString();
if (await usbStorage.TryGetItemAsync(Folder_Pfad) == null)
{
await usbStorage.CreateFolderAsync(Folder_Pfad);
}
Folder_Pfad = Folder_Pfad + "\\" + DateTime.Now.Month.ToString();
if (await usbStorage.TryGetItemAsync(Folder_Pfad) == null)
{
await usbStorage.CreateFolderAsync(Folder_Pfad);
}
Folder_Pfad = Folder_Pfad + "\\" + DateTime.Now.Day.ToString();
if (await usbStorage.TryGetItemAsync(Folder_Pfad) == null)
{
await usbStorage.CreateFolderAsync(Folder_Pfad);
}
string Dateiname = "\\" + DateTime.Now.Year.ToString() + "-" + DateTime.Now.Month.ToString() + "-" + DateTime.Now.Day.ToString() + " "
+ DateTime.Now.Hour.ToString() + "_" + DateTime.Now.Minute.ToString() + "_" + DateTime.Now.Second.ToString() + ".mp3";
string Dateispeicher_Ort = Folder_Pfad + Dateiname;
StorageFile recordFile = await usbStorage.CreateFileAsync(Dateispeicher_Ort, Windows.Storage.CreationCollisionOption.GenerateUniqueName);
isRecording = true;
//await audioCapture.StartRecordToStorageFileAsync(MediaEncodingProfile.CreateMp3(AudioEncodingQuality.Auto), recordFile);
var audioRecording = await audioCapture.PrepareLowLagRecordToStorageFileAsync(MediaEncodingProfile.CreateM4a(AudioEncodingQuality.Medium), recordFile);
await audioRecording.StartAsync();
Task.Delay(10000).Wait();
Unchecked();
}
catch (Exception ex)
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => {
Result.Text += ex.Message;
});
}
}
private async void ToggleButton_Checked(object sender, RoutedEventArgs e)
{
var button = (ToggleButton)sender;
// get storage folder
if (storageFolder == null)
{
var msg = new MessageDialog("Please choose a folder first...");
await msg.ShowAsync();
button.IsChecked = false;
return;
}
// check storage folder permissions
try
{
var files = await storageFolder.GetFilesAsync();
}
catch
{
var dialog = new MessageDialog(
"The selected storage directory does not exist anymore or is not accessable. Please select a new directory.",
"Directory not found or not enough permissions");
await dialog.ShowAsync();
button.IsChecked = false;
return;
}
var requestSuspensionExtension = new ExtendedExecutionForegroundSession();
requestSuspensionExtension.Reason = ExtendedExecutionForegroundReason.Unspecified;
var requestExtensionResult = await requestSuspensionExtension.RequestExtensionAsync();
// get storage files
var time = DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss_");
var screenFile = await storageFolder.CreateFileAsync(time + "slides.mp4");
var webcamFile = await storageFolder.CreateFileAsync(time + "talkinghead.mp4");
var jsonFile = await storageFolder.CreateFileAsync(time + "meta.json");
// get encoder properties
var frameRate = uint.Parse(((string)FrameRateComboBox.SelectedItem).Replace("fps", ""));
var quality = (VideoEncodingQuality)Enum.Parse(typeof(VideoEncodingQuality), (string)QualityComboBox.SelectedItem, false);
var useSourceSize = UseCaptureItemSizeCheckBox.IsChecked.Value;
var temp = MediaEncodingProfile.CreateMp4(quality);
uint bitrate = 2500000;
var width = temp.Video.Width;
var height = temp.Video.Height;
// get capture item
var picker = new GraphicsCapturePicker();
captureItem = await picker.PickSingleItemAsync();
if (captureItem == null)
{
button.IsChecked = false;
return;
}
// use the capture item's size for the encoding if desired
if (useSourceSize)
{
width = (uint)captureItem.Size.Width;
height = (uint)captureItem.Size.Height;
}
// we have a screen resolution of more than 4K?
if (width > 1920)
{
var v = width / 1920;
width = 1920;
height /= v;
}
// even if we're using the capture item's real size,
// we still want to make sure the numbers are even.
width = EnsureEven(width);
height = EnsureEven(height);
// tell the user we've started recording
var originalBrush = MainTextBlock.Foreground;
MainTextBlock.Foreground = new SolidColorBrush(Colors.Red);
MainProgressBar.IsIndeterminate = true;
button.IsEnabled = false;
MainTextBlock.Text = "3";
await Task.Delay(1000);
MainTextBlock.Text = "2";
await Task.Delay(1000);
MainTextBlock.Text = "1";
await Task.Delay(1000);
button.IsEnabled = true;
MainTextBlock.Text = "● rec";
_timerCount = 0;
_timer.Start();
try
{
// start webcam recording
MediaEncodingProfile webcamEncodingProfile = null;
if (AdaptBitrateCheckBox.IsChecked.Value)
{
var selectedItem = WebcamComboBox.SelectedItem as ComboBoxItem;
var encodingProperties = (selectedItem.Tag as StreamPropertiesHelper);
if (encodingProperties.Height > 720)
{
webcamEncodingProfile = MediaEncodingProfile.CreateMp4(VideoEncodingQuality.HD1080p);
webcamEncodingProfile.Video.Bitrate = 8000000;
}
else if (encodingProperties.Height > 480)
{
webcamEncodingProfile = MediaEncodingProfile.CreateMp4(VideoEncodingQuality.HD720p);
webcamEncodingProfile.Video.Bitrate = 5000000;
}
else
{
webcamEncodingProfile = MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Auto);
}
}
else
{
webcamEncodingProfile = MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Auto);
}
mediaRecording = await mediaCapture.PrepareLowLagRecordToStorageFileAsync(webcamEncodingProfile, webcamFile);
// kick off the screen encoding parallel
using (var stream = await screenFile.OpenAsync(FileAccessMode.ReadWrite))
using (screenCapture = new Encoder(screenDevice, captureItem))
{
// webcam recording
if (mediaCapture != null)
{
await mediaRecording.StartAsync();
}
// screen recording
await screenCapture.EncodeAsync(
stream,
width, height, bitrate,
frameRate);
}
MainTextBlock.Foreground = originalBrush;
// user has finished recording, so stop webcam recording
await mediaRecording.StopAsync();
await mediaRecording.FinishAsync();
_timer.Stop();
}
catch (Exception ex)
{
_timer.Stop();
var dialog = new MessageDialog(
$"Uh-oh! Something went wrong!\n0x{ex.HResult:X8} - {ex.Message}",
"Recording failed");
await dialog.ShowAsync();
button.IsChecked = false;
MainTextBlock.Text = "failure";
MainTextBlock.Foreground = originalBrush;
MainProgressBar.IsIndeterminate = false;
captureItem = null;
if (mediaRecording != null)
{
await mediaRecording.StopAsync();
await mediaRecording.FinishAsync();
}
return;
}
// at this point the encoding has finished
MainTextBlock.Text = "saving...";
// save slide markers
var recording = new Recording()
{
Slides = screenCapture.GetTimestamps()
};
var settings = new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
var json = JsonConvert.SerializeObject(recording, Formatting.Indented, settings);
await FileIO.WriteTextAsync(jsonFile, json);
// add metadata
var recordingMetadataDialog = new RecordingMetadataDialog();
var recordingMetadataDialogResult = await recordingMetadataDialog.ShowAsync();
if (recordingMetadataDialogResult == ContentDialogResult.Primary)
{
recording.Description = recordingMetadataDialog.LectureTitle;
if (recordingMetadataDialog.LectureDate.HasValue)
{
recording.LectureDate = recordingMetadataDialog.LectureDate.Value.DateTime;
}
}
else
{
recording.Description = null;
recording.LectureDate = DateTime.Now;
}
json = JsonConvert.SerializeObject(recording, Formatting.Indented, settings);
await FileIO.WriteTextAsync(jsonFile, json);
// tell the user we're done
button.IsChecked = false;
MainTextBlock.Text = "done";
MainProgressBar.IsIndeterminate = false;
requestSuspensionExtension.Dispose();
}
