Allgemeine Foto-, Video- und Audioaufnahme mit „MediaCapture“
Dieser Artikel zeigt die einfachste Möglichkeit, Fotos und Videos mit der Klasse MediaCapture zu erfassen. Die MediaCapture-Klasse stellt einen leistungsfähigen Satz von APIs bereit, der eine Steuerung der Aufnahmepipeline auf unterster Ebene sowie fortgeschrittene Aufnahmeszenarien ermöglicht. Dieser Artikel soll Ihnen jedoch helfen, Ihre App schnell und einfach durch grundlegende Medienaufnahmefunktionen zu erweitern. Weitere Informationen zu den Funktionen, die MediaCapture bietet, finden Sie unter Kamera.
Wenn Sie einfach nur ein Foto oder ein Video aufnehmen möchten und nicht vorhaben, zusätzliche Medienerfassungsfunktionen hinzuzufügen, oder wenn Sie keine eigene Kamera-UI erstellen möchten, können Sie die Klasse CameraCaptureUI verwenden, mit der Sie einfach die in Windows integrierte Kamera-App starten und die aufgenommene Foto- oder Videodatei empfangen können. Weitere Informationen finden Sie unter Aufnehmen von Fotos und Videos mit der in Windows integrierten Kamera-Benutzeroberfläche
Der Code in diesem Artikel wurde aus dem Camera Starter Kit Beispiel übernommen. Sie können das Beispiel herunterladen, um den verwendeten Code im Kontext zu sehen oder um das Beispiel als Ausgangspunkt für Ihre eigene Anwendung zu verwenden.
Hinzufügen von Capability-Deklarationen zum App-Manifest
Damit Ihre App auf die Kamera eines Geräts zugreifen kann, müssen Sie angeben, dass Ihre App die Gerätefunktionen webcam und microphone verwendet. Wenn Sie aufgenommene Fotos und Videos in der Bilder- oder Videobibliothek des Benutzers speichern möchten, müssen Sie auch die Funktion picturesLibrary und videosLibrary deklarieren.
So fügen Sie dem App-Manifest Funktionen hinzu
- Öffnen Sie in Microsoft Visual Studio im Projektmappen-Explorer, den Designer für das Anwendungsmanifest, indem Sie auf das Element package.appxmanifest doppelklicken.
- Wählen Sie die Registerkarte Funktionen aus.
- Aktivieren Sie das Kästchen für Webcam und das Kästchen für Mikrofon.
- Für den Zugriff auf die Bilder- und Videobibliothek markieren Sie die Kästchen für Bilderbibliothek und das Kästchen für Videobibliothek.
Initialisieren des MediaCapture-Objekts
Alle in diesem Artikel beschriebenen Aufnahmemethoden erfordern als ersten Schritt die Initialisierung des MediaCapture-Objekts durch Aufruf des Konstruktors und anschließendem Aufruf von InitializeAsync. Da auf das Objekt MediaCapture von mehreren Stellen in Ihrer Anwendung aus zugegriffen werden wird, deklarieren Sie eine Klassenvariable, die das Objekt enthält. Implementieren Sie einen Handler für das Ereignis Failed des Objekts MediaCapture, um benachrichtigt zu werden, wenn ein Aufnahmevorgang fehlschlägt.
MediaCapture mediaCapture;
bool isPreviewing;
mediaCapture = new MediaCapture();
await mediaCapture.InitializeAsync();
mediaCapture.Failed += MediaCapture_Failed;
Hinweis
Windows ermöglicht Benutzern das Gewähren oder Verweigern des Zugriffs auf die Kamera des Geräts in der Windows-Einstellungs-App unter Datenschutz und Sicherheit –> Kamera. Bei der Initialisierung des Aufnahmegeräts sollten Anwendungen prüfen, ob sie Zugriff auf die Kamera haben, und den Fall behandeln, dass der Zugriff vom Benutzer verweigert wird. Weitere Informationen finden Sie unter Behandeln der Datenschutzeinstellung der Windows-Kamera.
Einrichten der Kameravorschau
Es ist möglich, Fotos, Videos und Audio mit MediaCapture aufzunehmen, ohne die Kameravorschau anzuzeigen. Außerdem erfordern einige Funktionen von MediaCapture, dass der Vorschaustream läuft, bevor sie aktiviert werden können, darunter Autofokus, automatische Belichtung und automatischer Weißabgleich. Wie Sie die Kameravorschau einrichten, erfahren Sie unter Anzeigen der Kameravorschau.
Erfassen eines Fotos als SoftwareBitmap
Die Klasse SoftwareBitmap wurde in Windows 10 eingeführt, um eine gemeinsame Darstellung von Bildern über mehrere Funktionen hinweg zu ermöglichen. Wenn Sie ein Foto aufnehmen und das aufgenommene Bild dann sofort in Ihrer Anwendung verwenden möchten, z. B. zur Anzeige in XAML, anstatt es in eine Datei aufzunehmen, sollten Sie es in eine SoftwareBitmap aufnehmen. Sie haben immer noch die Möglichkeit, das Bild später auf der Festplatte zu speichern.
Nach der Initialisierung des MediaCapture-Objekts können Sie mit der LowLagPhotoCapture-Klasse ein Foto in eine SoftwareBitmap aufnehmen. Holen Sie sich eine Instanz dieser Klasse, indem Sie PrepareLowLagPhotoCaptureAsync aufrufen und ein ImageEncodingProperties-Objekt übergeben, in dem das gewünschte Bildformat angegeben ist. CreateUncompressed erstellt eine unkomprimierte Kodierung mit dem angegebenen Pixelformat. Nehmen Sie ein Foto auf, indem Sie CaptureAsync aufrufen, das ein CapturedPhoto-Objekt zurückgibt. Rufen Sie eine SoftwareBitmap ab, indem Sie auf die Eigenschaft Frame und dann auf die Eigenschaft SoftwareBitmap zugreifen.
Wenn Sie möchten, können Sie mehrere Fotos aufnehmen, indem Sie wiederholt CaptureAsync aufrufen. Wenn Sie mit der Aufnahme fertig sind, rufen Sie FinishAsync auf, um die Sitzung LowLagPhotoCapture zu beenden und die zugehörigen Ressourcen freizugeben. Nach dem Aufruf von FinishAsync müssen Sie PrepareLowLagPhotoCaptureAsync erneut aufrufen, um die Aufnahmesitzung neu zu initialisieren, bevor Sie CaptureAsync aufrufen, um mit der Aufnahme von Fotos zu beginnen.
// Prepare and capture photo
var lowLagCapture = await mediaCapture.PrepareLowLagPhotoCaptureAsync(ImageEncodingProperties.CreateUncompressed(MediaPixelFormat.Bgra8));
var capturedPhoto = await lowLagCapture.CaptureAsync();
var softwareBitmap = capturedPhoto.Frame.SoftwareBitmap;
await lowLagCapture.FinishAsync();
Ab Windows, Version 1803, können Sie auf die Eigenschaft BitmapProperties der Klasse CapturedFrame zugreifen, die von CaptureAsync zurückgegeben wird, um Metadaten über das aufgenommene Foto abzurufen. Sie können diese Daten an einen BitmapEncoder übergeben, um die Metadaten in einer Datei zu speichern. Bisher gab es keine Möglichkeit, auf diese Daten für unkomprimierte Bildformate zuzugreifen. Sie können auch auf die Eigenschaft ControlValues zugreifen, um ein CapturedFrameControlValues-Objekt abzurufen, das die Steuerwerte, wie z. B. Belichtung und Weißabgleich, für das aufgenommene Bild beschreibt.
Informationen zur Verwendung von BitmapEncoder und zur Arbeit mit dem SoftwareBitmap-Objekt, einschließlich der Anzeige in einer XAML-Seite, finden Sie unter Erstellen, Bearbeiten und Speichern von Bitmap-Bildern.
Weitere Informationen zum Einstellen der Werte für die Aufnahmesteuerung finden Sie unter Aufnahmesteuerung für Fotos und Videos.
Ab Windows 10, Version 1803, können Sie die Metadaten, wie z. B. EXIF-Informationen, für Fotos abrufen, die im unkomprimierten Format aufgenommen wurden, indem Sie auf die Eigenschaft BitmapProperties des CapturedFrame zugreifen, der von MediaCapture zurückgegeben wird. In früheren Versionen waren diese Daten nur in der Kopfzeile von Fotos verfügbar, die in einem komprimierten Dateiformat aufgenommen wurden. Sie können diese Daten einem BitmapEncoder zur Verfügung stellen, wenn Sie eine Bilddatei manuell schreiben. Weitere Informationen zum Codieren von Bitmaps finden Sie unter Erstellen, Bearbeiten und Speichern von Bitmap-Bildern. Über die Eigenschaft ControlValues können Sie auch auf die bei der Aufnahme des Bildes verwendeten Bildsteuerungswerte, wie z. B. Belichtungs- und Blitzeinstellungen, zugreifen. Weitere Informationen finden Sie unter Bedienelemente für Foto- und Videoaufnahmen.
Erfassen eines Fotos in einer Datei
Eine typische Fotoanwendung speichert ein aufgenommenes Foto auf der Festplatte oder in einem Cloud-Speicher und muss der Datei Metadaten hinzufügen, z. B. die Fotoausrichtung. Das folgende Beispiel zeigt, wie Sie ein Foto in einer Datei aufnehmen. Sie haben immer noch die Möglichkeit, später eine SoftwareBitmap aus der Bilddatei zu erstellen.
Die in diesem Beispiel gezeigte Technik erfasst das Foto in einem speicherinternen Stream und transcodiert das Foto anschließend aus dem Stream in eine Datei auf der Festplatte. In diesem Beispiel wird GetLibraryAsync verwendet, um die Bilderbibliothek des Benutzers abzurufen, und dann die Eigenschaft SaveFolder , um einen Referenz-Standardspeicherordner zu erhalten. Denken Sie daran, die Funktion Pictures Library zu Ihrem App-Manifest hinzuzufügen, um auf diesen Ordner zugreifen zu können. CreateFileAsync erstellt eine neue StorageFile, in der das Foto gespeichert wird.
Erstellen Sie einen InMemoryRandomAccessStream und rufen Sie dann CapturePhotoToStreamAsync auf, um ein Foto im Stream zu erfassen, wobei der Stream und ein ImageEncodingProperties-Objekt übergeben werden, das das zu verwendende Bildformat angibt. Sie können benutzerdefinierte Kodierungseigenschaften erstellen, indem Sie das Objekt selbst initialisieren, aber die Klasse bietet statische Methoden, wie ImageEncodingProperties.CreateJpeg für gängige Kodierungsformate. Als nächstes erstellen Sie einen Dateistrom zur Ausgabedatei, indem Sie OpenAsync aufrufen. Erstellen Sie einen BitmapDecoder, um das Bild aus dem In-Memory-Stream zu dekodieren, und erstellen Sie dann einen BitmapEncoder, um das Bild durch den Aufruf von CreateForTranscodingAsync in eine Datei zu kodieren.
Sie können optional ein BitmapPropertySet-Objekt erstellen und dann SetPropertiesAsync auf dem Bild-Encoder aufrufen, um Metadaten über das Foto in die Bilddatei aufzunehmen. Weitere Informationen zu Kodierungseigenschaften finden Sie unter Image metadata. Der richtige Umgang mit der Geräteausrichtung ist für die meisten Fotoanwendungen unerlässlich. Weitere Informationen finden Sie unter Handhabung der Geräteausrichtung mit MediaCapture.
Rufen Sie schließlich FlushAsync für das Encoder-Objekt auf, um das Foto aus dem speicherinternen Stream in die Datei zu übertragen.
var myPictures = await Windows.Storage.StorageLibrary.GetLibraryAsync(Windows.Storage.KnownLibraryId.Pictures);
StorageFile file = await myPictures.SaveFolder.CreateFileAsync("photo.jpg", CreationCollisionOption.GenerateUniqueName);
using (var captureStream = new InMemoryRandomAccessStream())
{
await mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), captureStream);
using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
var decoder = await BitmapDecoder.CreateAsync(captureStream);
var encoder = await BitmapEncoder.CreateForTranscodingAsync(fileStream, decoder);
var properties = new BitmapPropertySet {
{ "System.Photo.Orientation", new BitmapTypedValue(PhotoOrientation.Normal, PropertyType.UInt16) }
};
await encoder.BitmapProperties.SetPropertiesAsync(properties);
await encoder.FlushAsync();
}
}
Weitere Informationen zum Arbeiten mit Dateien und Ordnern finden Sie unter Dateien, Ordner und Bibliotheken.
Erfassen eines Videos
Mit der Klasse LowLagMediaRecording können Sie Ihrer Anwendung schnell Videoaufnahmen hinzufügen. Deklarieren Sie zunächst eine Klassenvariable für das Objekt.
LowLagMediaRecording _mediaRecording;
Erstellen Sie anschließend ein StorageFile-Objekt, in dem das Video gespeichert werden soll. Beachten Sie, dass Sie zum Speichern in der Videobibliothek des Benutzers, wie in diesem Beispiel gezeigt, die Funktion Videos Library zu Ihrem App-Manifest hinzufügen müssen. Rufen Sie PrepareLowLagRecordToStorageFileAsync auf, um die Medienaufzeichnung zu initialisieren, und übergeben Sie dabei die Speicherdatei und ein MediaEncodingProfile-Objekt, das die Codierung für das Video angibt. Die Klasse bietet statische Methoden, wie z. B. CreateMp4, zur Erstellung gängiger Videocodierungsprofile.
Rufen Sie schließlich StartAsync auf, um mit der Videoaufzeichnung zu beginnen.
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();
Um die Videoaufzeichnung zu beenden, rufen Sie StopAsync auf.
await _mediaRecording.StopAsync();
Sie können weiterhin StartAsync und StopAsync aufrufen, um weitere Videos zu erfassen. Wenn Sie mit der Videoaufzeichnung fertig sind, rufen Sie FinishAsync auf, um die Aufzeichnungssitzung zu beenden und die zugehörigen Ressourcen zu löschen. Nach diesem Aufruf müssen Sie PrepareLowLagRecordToStorageFileAsync erneut aufrufen, um die Erfassungssitzung zu reinitialisieren, bevor Sie StartAsync aufrufen.
await _mediaRecording.FinishAsync();
Bei der Videoaufzeichnung sollten Sie einen Handler für das Ereignis RecordLimitationExceeded des Objekts MediaCapture registrieren, das vom Betriebssystem ausgelöst wird, wenn Sie das Limit für eine einzelne Aufzeichnung, derzeit drei Stunden, überschreiten. Im Handler für das Ereignis sollten Sie Ihre Aufzeichnung beenden, indem Sie StopAsync aufrufen.
mediaCapture.RecordLimitationExceeded += MediaCapture_RecordLimitationExceeded;
private async void MediaCapture_RecordLimitationExceeded(MediaCapture sender)
{
await _mediaRecording.StopAsync();
System.Diagnostics.Debug.WriteLine("Record limitation exceeded.");
}
Wiedergabe und Bearbeitung aufgenommener Videodateien
Wenn Sie ein Video in eine Datei aufgenommen haben, möchten Sie die Datei vielleicht laden und in der Benutzeroberfläche Ihrer Anwendung wiedergeben. Sie können dies mit dem MediaPlayerElement-XAML-Steuerelement und einem zugehörigen MediaPlayer tun. Informationen zur Wiedergabe von Medien in einer XAML-Seite finden Sie unter Wiedergabe von Audio und Video mit MediaPlayer.
Sie können auch ein MediaClip-Objekt aus einer Videodatei erstellen, indem Sie CreateFromFileAsync aufrufen. Eine MediaComposition bietet grundlegende Videobearbeitungsfunktionen wie das Anordnen der Reihenfolge von MediaClip-Objekten, das Zuschneiden der Videolänge, das Erstellen von Ebenen, das Hinzufügen von Hintergrundmusik und das Anwenden von Videoeffekten. Weitere Informationen zur Arbeit mit Medienkompositionen finden Sie unter Medienkompositionen und Bearbeitung.
Videoaufzeichnung anhalten und fortsetzen
Sie können eine Videoaufzeichnung anhalten und dann wieder aufnehmen, ohne eine separate Ausgabedatei zu erstellen, indem Sie PauseAsync und anschließend ResumeAsync aufrufen.
await _mediaRecording.PauseAsync(Windows.Media.Devices.MediaCapturePauseBehavior.ReleaseHardwareResources);
await _mediaRecording.ResumeAsync();
Ab Windows 10, Version 1607, können Sie eine Videoaufzeichnung anhalten und das letzte Bild erhalten, das vor dem Anhalten der Aufzeichnung aufgenommen wurde. Sie können dieses Bild dann in die Kameravorschau einblenden, damit der Benutzer die Kamera auf das angehaltene Bild ausrichten kann, bevor er die Aufnahme fortsetzt. Der Aufruf von PauseWithResultAsync gibt ein MediaCapturePauseResult-Objekt zurück. Die Eigenschaft LastFrame ist ein VideoFrame-Objekt, das das letzte Bild darstellt. Um das Bild in XAML anzuzeigen, rufen Sie die SoftwareBitmap-Darstellung des Videobildes ab. Derzeit werden nur Bilder im BGRA8-Format mit vormultipliziertem oder leerem Alphakanal unterstützt. Rufen Sie daher Convert auf, um das richtige Format zu erhalten. Erstellen Sie ein neues SoftwareBitmapSource-Objekt und rufen Sie SetBitmapAsync auf, um es zu initialisieren. Legen Sie schließlich die Eigenschaft Source eines XAML-Steuerelements Image fest, um das Bild anzuzeigen. Damit dieser Trick funktioniert, muss Ihr Bild an dem Steuerelement CaptureElement ausgerichtet sein und sollte einen Deckkraftwert kleiner als eins haben. Vergessen Sie nicht, dass Sie die Benutzeroberfläche nur im UI-Thread ändern können, also machen Sie diesen Aufruf innerhalb von RunAsync.
PauseWithResultAsync gibt auch die Dauer des Videos zurück, das im vorherigen Segment aufgezeichnet wurde, falls Sie nachverfolgen müssen, wie viel Gesamtzeit aufgezeichnet wurde.
MediaCapturePauseResult result =
await _mediaRecording.PauseWithResultAsync(Windows.Media.Devices.MediaCapturePauseBehavior.RetainHardwareResources);
var pausedFrame = result.LastFrame.SoftwareBitmap;
if(pausedFrame.BitmapPixelFormat != BitmapPixelFormat.Bgra8 || pausedFrame.BitmapAlphaMode != BitmapAlphaMode.Ignore)
{
pausedFrame = SoftwareBitmap.Convert(pausedFrame, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore);
}
var source = new SoftwareBitmapSource();
await source.SetBitmapAsync(pausedFrame);
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
PauseImage.Source = source;
PauseImage.Visibility = Visibility.Visible;
});
_totalRecordedTime += result.RecordDuration;
Wenn Sie die Aufnahme fortsetzen, können Sie die Quelle des Bildes auf Null setzen und es ausblenden.
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
PauseImage.Source = null;
PauseImage.Visibility = Visibility.Collapsed;
});
await _mediaRecording.ResumeAsync();
Beachten Sie, dass Sie auch ein Ergebnisbild erhalten können, wenn Sie das Video anhalten, indem Sie StopWithResultAsync aufrufen.
Audio aufzeichnen
Sie können Ihrer Anwendung schnell eine Audioaufnahme hinzufügen, indem Sie die oben beschriebene Technik für die Videoaufnahme anwenden. Im folgenden Beispiel wird eine StorageFile im Anwendungsdatenordner erstellt. Rufen Sie PrepareLowLagRecordToStorageFileAsync auf, um die Erfassungssitzung zu initialisieren, und übergeben Sie die Datei und ein MediaEncodingProfile, das in diesem Beispiel von der statischen Methode CreateMp3 erzeugt wird. Um die Aufzeichnung zu starten, rufen Sie StartAsync auf.
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();
Rufen Sie StopAsync auf, um die Audioaufzeichnung zu beenden.
Zugehörige Themen
await _mediaRecording.StopAsync();
Sie können StartAsync und StopAsync mehrfach aufrufen, um mehrere Audiodateien aufzunehmen. Wenn Sie mit der Audioaufnahme fertig sind, rufen Sie FinishAsync auf, um die Aufnahmesitzung zu beenden und die zugehörigen Ressourcen zu löschen. Nach diesem Aufruf müssen Sie PrepareLowLagRecordToStorageFileAsync erneut aufrufen, um die Erfassungssitzung zu reinitialisieren, bevor Sie StartAsync aufrufen.
await _mediaRecording.FinishAsync();
Erkennen und Reagieren auf Audiopegeländerungen durch das System
Ab Windows 10, Version 1803, kann Ihre App erkennen, wenn das System den Audiopegel der Audio-Capture- und Audio-Render-Streams Ihrer App senkt oder stummschaltet. So kann das System beispielsweise die Streams Ihrer Anwendung stumm schalten, wenn sie in den Hintergrund geht. Mit der Klasse AudioStateMonitor können Sie sich registrieren, um ein Ereignis zu erhalten, wenn das System die Lautstärke eines Audiostroms ändert. Holen Sie sich eine Instanz von AudioStateMonitor zur Überwachung von Audio-Capture-Streams, indem Sie CreateForCaptureMonitoring aufrufen. Holen Sie sich eine Instanz für die Überwachung von Audio-Render-Streams, indem Sie CreateForRenderMonitoring aufrufen. Registrieren Sie einen Handler für das Ereignis SoundLevelChanged jedes Monitors, um benachrichtigt zu werden, wenn der Ton für die entsprechende Stream-Kategorie vom System geändert wird.
// Namespaces for monitoring audio state
using Windows.Media;
using Windows.Media.Audio;
AudioStateMonitor captureAudioStateMonitor;
AudioStateMonitor renderAudioStateMonitor;
captureAudioStateMonitor = AudioStateMonitor.CreateForCaptureMonitoring();
captureAudioStateMonitor.SoundLevelChanged += CaptureAudioStateMonitor_SoundLevelChanged; ;
renderAudioStateMonitor = AudioStateMonitor.CreateForRenderMonitoring();
renderAudioStateMonitor.SoundLevelChanged += RenderAudioStateMonitor_SoundLevelChanged; ;
Im SoundLevelChanged Handler für den Capture Stream können Sie die SoundLevel-Eigenschaft des AudioStateMonitor-Senders überprüfen, um den neuen Schallpegel zu ermitteln. Beachten Sie, dass ein Capture Stream niemals vom System abgesenkt oder „geduckt“ werden sollte. Es sollte immer nur stummgeschaltet oder auf volle Lautstärke zurückgeschaltet werden. Wenn der Audiostrom stummgeschaltet ist, können Sie eine laufende Aufnahme anhalten. Wenn die volle Lautstärke des Audiostroms wiederhergestellt ist, können Sie die Aufnahme fortsetzen. Das folgende Beispiel verwendet einige boolesche Klassenvariablen, um zu verfolgen, ob die App gerade Audio aufnimmt und ob die Aufnahme aufgrund der Änderung des Audiostatus gestoppt wurde. Diese Variablen werden verwendet, um zu bestimmen, wann es angebracht ist, die Audioaufnahme programmgesteuert zu stoppen oder zu starten.
bool isCapturingAudio = false;
bool capturingStoppedForAudioState = false;
private void CaptureAudioStateMonitor_SoundLevelChanged(AudioStateMonitor sender, object args)
{
switch (sender.SoundLevel)
{
case SoundLevel.Full:
if(capturingStoppedForAudioState)
{
StartAudioCapture();
capturingStoppedForAudioState = false;
}
break;
case SoundLevel.Muted:
if(isCapturingAudio)
{
StopAudioCapture();
capturingStoppedForAudioState = true;
}
break;
case SoundLevel.Low:
// This should never happen for capture
Debug.WriteLine("Unexpected audio state.");
break;
}
}
Das folgende Codebeispiel veranschaulicht eine Implementierung des SoundLevelChanged-Handlers für das Audio-Rendering. Je nach Anwendungsszenario und Art der wiedergegebenen Inhalte kann es sinnvoll sein, die Audiowiedergabe zu unterbrechen, wenn der Tonpegel gesenkt wird. Weitere Informationen zum Umgang mit Tonpegeländerungen bei der Medienwiedergabe finden Sie unter Wiedergabe von Audio und Video mit MediaPlayer.
private void RenderAudioStateMonitor_SoundLevelChanged(AudioStateMonitor sender, object args)
{
if ((sender.SoundLevel == SoundLevel.Full) ||
(sender.SoundLevel == SoundLevel.Low && !isPodcast))
{
mediaPlayer.Play();
}
else if ((sender.SoundLevel == SoundLevel.Muted) ||
(sender.SoundLevel == SoundLevel.Low && isPodcast))
{
// Pause playback if we’re muted or if we’re playing a podcast and are ducked
mediaPlayer.Pause();
}
}