Changeset 258977 in webkit

Timestamp:

Mar 25, 2020 6:44:17 AM (4 years ago)

Author:

youenn@apple.com

Message:

Audio fails to capture stream in WebRTC if AudioSession gets interrupted
​https://bugs.webkit.org/show_bug.cgi?id=208516
<rdar://problem/60020467>

Reviewed by Eric Carlson.

In case of page going to hidden, continue calling each capture factory to mute the corresponding sources if needed.
In case of page being visible again, reset all tracks according page muted state. This allows restarting tracks that have been
muted while page was hidden (video tracks or suspended audio tracks).

Since tracks can go to muted when visibility changes, we no longer return early when setting the muted state of a page to the same value.
Instead we apply it which ensures we comply with what UIProcess wants.

We start removing the concept of a RealtimeMediaSource be interrupted. Instead we use muting of sources.
This allows UIProcess or the page to override any muted state, for instance if page goes in foreground again.

We update the AudioSharedUnit to allow restarting capture even if suspended.
This ensures that we are able to restart capturing even if we do not receive the audio session end of interruption.
Also, this notification sometimes takes a long time to happen and we do not want to wait for it when user is interacting with the page.
A future refactoring will further remove RealtimeMediaSource interrupted-related code.

Manually tested.

• dom/Document.cpp:

(WebCore::Document::visibilityStateChanged):

• page/Page.cpp:

(WebCore::Page::setMuted):

• platform/audio/PlatformMediaSessionManager.h:

(WebCore::PlatformMediaSessionManager::isInterrupted const):

• platform/mediastream/RealtimeMediaSource.cpp:

(WebCore::RealtimeMediaSource::setInterrupted):
(WebCore::RealtimeMediaSource::setMuted):

• platform/mediastream/mac/BaseAudioSharedUnit.cpp:

(WebCore::BaseAudioSharedUnit::startProducingData):
(WebCore::BaseAudioSharedUnit::resume):
(WebCore::BaseAudioSharedUnit::suspend):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• Modules/mediastream/MediaStreamTrack.cpp (modified) (2 diffs)
• Modules/mediastream/MediaStreamTrack.h (modified) (2 diffs)
• dom/Document.cpp (modified) (1 diff)
• page/Page.cpp (modified) (1 diff)
• platform/audio/PlatformMediaSessionManager.h (modified) (1 diff)
• platform/mediastream/RealtimeMediaSource.cpp (modified) (2 diffs)
• platform/mediastream/RealtimeMediaSourceFactory.h (modified) (1 diff)
• platform/mediastream/mac/BaseAudioSharedUnit.cpp (modified) (5 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2020-03-25  Youenn Fablet  <youenn@apple.com>
+
+        Audio fails to capture stream in WebRTC if AudioSession gets interrupted
+        https://bugs.webkit.org/show_bug.cgi?id=208516
+        <rdar://problem/60020467>
+
+        Reviewed by Eric Carlson.
+
+        In case of page going to hidden, continue calling each capture factory to mute the corresponding sources if needed.
+        In case of page being visible again, reset all tracks according page muted state. This allows restarting tracks that have been
+        muted while page was hidden (video tracks or suspended audio tracks).
+
+        Since tracks can go to muted when visibility changes, we no longer return early when setting the muted state of a page to the same value.
+        Instead we apply it which ensures we comply with what UIProcess wants.
+
+        We start removing the concept of a RealtimeMediaSource be interrupted. Instead we use muting of sources.
+        This allows UIProcess or the page to override any muted state, for instance if page goes in foreground again.
+
+        We update the AudioSharedUnit to allow restarting capture even if suspended.
+        This ensures that we are able to restart capturing even if we do not receive the audio session end of interruption.
+        Also, this notification sometimes takes a long time to happen and we do not want to wait for it when user is interacting with the page.
+        A future refactoring will further remove RealtimeMediaSource interrupted-related code.
+
+        Manually tested.
+
+        * dom/Document.cpp:
+        (WebCore::Document::visibilityStateChanged):
+        * page/Page.cpp:
+        (WebCore::Page::setMuted):
+        * platform/audio/PlatformMediaSessionManager.h:
+        (WebCore::PlatformMediaSessionManager::isInterrupted const):
+        * platform/mediastream/RealtimeMediaSource.cpp:
+        (WebCore::RealtimeMediaSource::setInterrupted):
+        (WebCore::RealtimeMediaSource::setMuted):
+        * platform/mediastream/mac/BaseAudioSharedUnit.cpp:
+        (WebCore::BaseAudioSharedUnit::startProducingData):
+        (WebCore::BaseAudioSharedUnit::resume):
+        (WebCore::BaseAudioSharedUnit::suspend):
+
 2020-03-25  Charlie Turner  <cturner@igalia.com>
 

trunk/Source/WebCore/Modules/mediastream/MediaStreamTrack.cpp

@@ -468 +468 @@
 }
 
+#if PLATFORM(IOS_FAMILY)
+static MediaStreamTrack* findActiveCaptureTrackForDocument(Document& document, RealtimeMediaSource* activeSource, RealtimeMediaSource::Type type)
+{
+    MediaStreamTrack* selectedTrack = nullptr;
+    for (auto* captureTrack : allCaptureTracks()) {
+        if (captureTrack->document() != &document || captureTrack->ended())
+            continue;
+
+        if (&captureTrack->source() == activeSource)
+            return captureTrack;
+
+        // If the document has a live capture track, which is not the active one, we pick the first one.
+        // FIXME: We should probably store per page active audio/video capture tracks.
+        if (!selectedTrack && captureTrack->privateTrack().type() == type)
+            selectedTrack = captureTrack;
+    }
+    return selectedTrack;
+}
+#endif
+
 void MediaStreamTrack::updateCaptureAccordingToMutedState(Document& document)
 {
+#if PLATFORM(IOS_FAMILY)
+    auto* activeAudioSource = RealtimeMediaSourceCenter::singleton().audioCaptureFactory().activeSource();
+    if (auto* audioCaptureTrack = findActiveCaptureTrackForDocument(document, activeAudioSource, RealtimeMediaSource::Type::Audio))
+        audioCaptureTrack->setMuted(document.page()->mutedState());
+
+    auto* activeVideoSource = RealtimeMediaSourceCenter::singleton().videoCaptureFactory().activeSource();
+    if (auto* videoCaptureTrack = findActiveCaptureTrackForDocument(document, activeVideoSource, RealtimeMediaSource::Type::Video))
+        videoCaptureTrack->setMuted(document.page()->mutedState());
+#else
     for (auto* captureTrack : allCaptureTracks()) {
         if (captureTrack->document() != &document || captureTrack->ended())
@@ -475 +504 @@
         captureTrack->setMuted(document.page()->mutedState());
     }
+#endif
 }
 

trunk/Source/WebCore/Modules/mediastream/MediaStreamTrack.h

@@ -155 +155 @@
     void setIdForTesting(String&& id) { m_private->setIdForTesting(WTFMove(id)); }
 
+    Document* document() const;
+
 #if !RELEASE_LOG_DISABLED
     const Logger& logger() const final { return m_private->logger(); }
@@ -172 +174 @@
     void configureTrackRendering();
 
-    Document* document() const;
-
     // ActiveDOMObject API.
     void stop() final { stopTrack(); }

trunk/Source/WebCore/dom/Document.cpp

@@ -1745 +1745 @@
         client->visibilityStateChanged();
 
-#if ENABLE(MEDIA_STREAM)
-    if (auto* page = this->page())
-        RealtimeMediaSourceCenter::singleton().setCapturePageState(hidden(), page->isMediaCaptureMuted());
+#if PLATFORM(IOS_FAMILY)
+    if (hidden()) {
+        RealtimeMediaSourceCenter::singleton().setCapturePageState(hidden(), page()->isMediaCaptureMuted());
+        return;
+    }
+    if (!PlatformMediaSessionManager::sharedManager().isInterrupted())
+        MediaStreamTrack::updateCaptureAccordingToMutedState(*this);
 #endif
 }

trunk/Source/WebCore/page/Page.cpp

@@ -1782 +1782 @@
 void Page::setMuted(MediaProducer::MutedStateFlags muted)
 {
-    if (m_mutedState == muted)
-        return;
-
     m_mutedState = muted;
 

trunk/Source/WebCore/platform/audio/PlatformMediaSessionManager.h

@@ -141 +141 @@
     WEBCORE_EXPORT void processDidReceiveRemoteControlCommand(PlatformMediaSession::RemoteControlCommandType, const PlatformMediaSession::RemoteCommandArgument*);
 
+    bool isInterrupted() const { return m_interrupted; }
+
 protected:
     friend class PlatformMediaSession;

trunk/Source/WebCore/platform/mediastream/RealtimeMediaSource.cpp

@@ -77 +77 @@
 void RealtimeMediaSource::setInterrupted(bool interrupted, bool pageMuted)
 {
-    if (interrupted == m_interrupted)
-        return;
-
     ALWAYS_LOG_IF(m_logger, LOGIDENTIFIER, interrupted, ", page muted : ", pageMuted);
-
-    m_interrupted = interrupted;
-    if (!interrupted && pageMuted)
-        return;
-
     setMuted(interrupted);
 }
@@ -91 +83 @@
 void RealtimeMediaSource::setMuted(bool muted)
 {
-    if (!muted && interrupted()) {
-        ALWAYS_LOG_IF(m_logger, LOGIDENTIFIER, "ignoring unmute because of interruption");
-        return;
-    }
-
     ALWAYS_LOG_IF(m_logger, LOGIDENTIFIER, muted);
 

trunk/Source/WebCore/platform/mediastream/RealtimeMediaSourceFactory.h

@@ -46 +46 @@
     void unsetActiveSource(RealtimeMediaSource&);
 
-protected:
     RealtimeMediaSource* activeSource() { return m_activeSource; }
 

trunk/Source/WebCore/platform/mediastream/mac/BaseAudioSharedUnit.cpp

@@ -75 +75 @@
     ASSERT(isMainThread());
 
+    if (m_suspended)
+        resume();
+
     if (++m_producingCount != 1)
         return;
@@ -80 +83 @@
     if (isProducingData())
         return;
-
-    if (m_suspended) {
-        RELEASE_LOG_INFO(WebRTC, "BaseAudioSharedUnit::startProducingData - exiting early as suspended");
-        return;
-    }
 
     if (hasAudioUnit()) {
@@ -160 +158 @@
 {
     ASSERT(isMainThread());
-    ASSERT(m_suspended);
+    if (!m_suspended)
+        return 0;
+
     ASSERT(!isProducingData());
 
@@ -181 +181 @@
 
     forEachClient([](auto& client) {
-        client.notifyMutedChange(false);
+        client.setMuted(false);
     });
 
@@ -197 +197 @@
 
     forEachClient([](auto& client) {
-        client.notifyMutedChange(true);
+        client.setMuted(true);
     });