Attachment #426328 for bug #210840

View Details Raw Unified Return to Bug 210840

| Differences between



2021-04-17  Philippe Normand  <pnormand@igalia.com>

        [GStreamer][MediaStream] fast/mediastream/play-newly-added-audio-track.html is failing since added in r260380
        https://bugs.webkit.org/show_bug.cgi?id=210840

        Reviewed by Xabier Rodriguez-Calvar.

        The test was failing mainly because our mediastreamsrc GStreamer element wasn't creating the
        corresponding AudioTrackPrivateMediaStream object. The media player should propagate its
        volume/mute/is-playing states to the source element. And also until now our mediastreamsrc
        element was handling at most one audio track and at most one audio track, but it turns out
        multiple audio tracks can be added actually. So I refactored the element internals
        accordingly. The InternalSource is now directly observing the corresponding
        RealtimeMediaSource, which simplified some code. Observing is also now suspended/resumed
        depending on the element state.

        We don't implement a GStreamer AudioMediaStreamTrackRenderer class yet, because actual
        rendering is still performed from the WebProcess, so early returns were added in
        AudioTrackPrivateMediaStream to handle this case.

        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:
        (WebCore::MediaPlayerPrivateGStreamer::updateTracks):
        (WebCore::MediaPlayerPrivateGStreamer::configureMediaStreamAudioTracks):
        (WebCore::MediaPlayerPrivateGStreamer::setVolume):
        (WebCore::MediaPlayerPrivateGStreamer::setMuted):
        (WebCore::MediaPlayerPrivateGStreamer::updateStates):
        (WebCore::MediaPlayerPrivateGStreamer::didEnd):
        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h:
        * platform/mediastream/AudioTrackPrivateMediaStream.cpp:
        (WebCore::AudioTrackPrivateMediaStream::createRenderer):
        (WebCore::AudioTrackPrivateMediaStream::setLogger):
        (WebCore::AudioTrackPrivateMediaStream::clear):
        (WebCore::AudioTrackPrivateMediaStream::setVolume):
        (WebCore::AudioTrackPrivateMediaStream::setAudioOutputDevice):
        (WebCore::AudioTrackPrivateMediaStream::volume const):
        (WebCore::AudioTrackPrivateMediaStream::audioSamplesAvailable):
        (WebCore::AudioTrackPrivateMediaStream::startRenderer):
        (WebCore::AudioTrackPrivateMediaStream::stopRenderer):
        (WebCore::AudioTrackPrivateMediaStream::createNewRenderer):
        * platform/mediastream/gstreamer/GStreamerMediaStreamSource.cpp:
        (mediaStreamTrackPrivateGetTags):
        (WebKitMediaStreamObserver::didRemoveTrack):
        (webkitMediaStreamSrcConstructed):
        (webkitMediaStreamSrcDispose):
        (webkitMediaStreamSrcChangeState):
        (webkitMediaStreamSrcPostStreamCollection):
        (webkitMediaStreamSrcAddPad):
        (ProbeData::ProbeData):
        (webkitMediaStreamSrcPadProbeCb):
        (webkitMediaStreamSrcAddTrack):
        (webkitMediaStreamSrcSetStream):
        (webkitMediaStreamSrcTrackEnded):
        (InternalSource::trackEnded):
        (webkitMediaStreamSrcConfigureAudioTracks):
        * platform/mediastream/gstreamer/GStreamerMediaStreamSource.h:

2021-04-16  Brent Fulgham  <bfulgham@apple.com>

        Perform port blocking earlier in the load

Lines 1511-1519 void MediaPlayerPrivateGStreamer::updateTracks(const GRefPtr<GstStreamCollection a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp_sec1
- a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp -2 / +16 lines
1511		1511
1512	GST_DEBUG_OBJECT(pipeline(), "Inspecting %s track with ID %s", gst_stream_type_get_name(type), streamId.utf8().data());	1512	GST_DEBUG_OBJECT(pipeline(), "Inspecting %s track with ID %s", gst_stream_type_get_name(type), streamId.utf8().data());
1513		1513
1514	if (type & GST_STREAM_TYPE_AUDIO)	1514	if (type & GST_STREAM_TYPE_AUDIO) {
1515	CREATE_TRACK(audio, Audio);	1515	CREATE_TRACK(audio, Audio);
1516	else if (type & GST_STREAM_TYPE_VIDEO && m_player->isVideoPlayer())	1516	configureMediaStreamAudioTracks();
		1517	} else if (type & GST_STREAM_TYPE_VIDEO && m_player->isVideoPlayer())
1517	CREATE_TRACK(video, Video);	1518	CREATE_TRACK(video, Video);
1518	else if (type & GST_STREAM_TYPE_TEXT && !useMediaSource) {	1519	else if (type & GST_STREAM_TYPE_TEXT && !useMediaSource) {
1519	auto track = InbandTextTrackPrivateGStreamer::create(textTrackIndex++, stream);	1520	auto track = InbandTextTrackPrivateGStreamer::create(textTrackIndex++, stream);
Lines 1653-1658 FloatSize MediaPlayerPrivateGStreamer::naturalSize() const a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp_sec2
1653	return m_videoSize;	1654	return m_videoSize;
1654	}	1655	}
1655		1656
		1657	void MediaPlayerPrivateGStreamer::configureMediaStreamAudioTracks()
		1658	{
		1659	if (WEBKIT_IS_MEDIA_STREAM_SRC(m_source.get()))
		1660	webkitMediaStreamSrcConfigureAudioTracks(WEBKIT_MEDIA_STREAM_SRC(m_source.get()), volume(), isMuted(), !m_isPaused);
		1661	}
		1662
1656	void MediaPlayerPrivateGStreamer::setVolume(float volume)	1663	void MediaPlayerPrivateGStreamer::setVolume(float volume)
1657	{	1664	{
1658	if (!m_volumeElement)	1665	if (!m_volumeElement)
Lines 1660-1665 void MediaPlayerPrivateGStreamer::setVolume(float volume) a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp_sec3
1660		1667
1661	GST_DEBUG_OBJECT(pipeline(), "Setting volume: %f", volume);	1668	GST_DEBUG_OBJECT(pipeline(), "Setting volume: %f", volume);
1662	gst_stream_volume_set_volume(m_volumeElement.get(), GST_STREAM_VOLUME_FORMAT_LINEAR, static_cast<double>(volume));	1669	gst_stream_volume_set_volume(m_volumeElement.get(), GST_STREAM_VOLUME_FORMAT_LINEAR, static_cast<double>(volume));
		1670	configureMediaStreamAudioTracks();
1663	}	1671	}
1664		1672
1665	float MediaPlayerPrivateGStreamer::volume() const	1673	float MediaPlayerPrivateGStreamer::volume() const
Lines 1717-1722 void MediaPlayerPrivateGStreamer::setMuted(bool shouldMute) a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp_sec4
1717		1725
1718	GST_INFO_OBJECT(pipeline(), "Setting muted state to %s", boolForPrinting(shouldMute));	1726	GST_INFO_OBJECT(pipeline(), "Setting muted state to %s", boolForPrinting(shouldMute));
1719	g_object_set(m_volumeElement.get(), "mute", shouldMute, nullptr);	1727	g_object_set(m_volumeElement.get(), "mute", shouldMute, nullptr);
		1728	configureMediaStreamAudioTracks();
1720	}	1729	}
1721		1730
1722	void MediaPlayerPrivateGStreamer::notifyPlayerOfMute()	1731	void MediaPlayerPrivateGStreamer::notifyPlayerOfMute()
Lines 2258-2263 void MediaPlayerPrivateGStreamer::updateStates() a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp_sec5
2258		2267
2259	MediaPlayer::NetworkState oldNetworkState = m_networkState;	2268	MediaPlayer::NetworkState oldNetworkState = m_networkState;
2260	MediaPlayer::ReadyState oldReadyState = m_readyState;	2269	MediaPlayer::ReadyState oldReadyState = m_readyState;
		2270	bool oldIsPaused = m_isPaused;
2261	GstState pending, state;	2271	GstState pending, state;
2262	bool stateReallyChanged = false;	2272	bool stateReallyChanged = false;
2263		2273
Lines 2424-2429 void MediaPlayerPrivateGStreamer::updateStates() a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp_sec6
2424	}	2434	}
2425	}	2435	}
2426	}	2436	}
		2437
		2438	if (oldIsPaused != m_isPaused)
		2439	configureMediaStreamAudioTracks();
2427	}	2440	}
2428		2441
2429	void MediaPlayerPrivateGStreamer::mediaLocationChanged(GstMessage* message)	2442	void MediaPlayerPrivateGStreamer::mediaLocationChanged(GstMessage* message)
Lines 2559-2564 void MediaPlayerPrivateGStreamer::didEnd() a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp_sec7
2559	m_isPaused = true;	2572	m_isPaused = true;
2560	changePipelineState(GST_STATE_READY);	2573	changePipelineState(GST_STATE_READY);
2561	m_didDownloadFinish = false;	2574	m_didDownloadFinish = false;
		2575	configureMediaStreamAudioTracks();
2562		2576
2563	#if USE(WPE_VIDEO_PLANE_DISPLAY_DMABUF)	2577	#if USE(WPE_VIDEO_PLANE_DISPLAY_DMABUF)
2564	wpe_video_plane_display_dmabuf_source_end_of_stream(m_wpeVideoPlaneDisplayDmaBuf.get());	2578	wpe_video_plane_display_dmabuf_source_end_of_stream(m_wpeVideoPlaneDisplayDmaBuf.get());

Lines 458-463 private: a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h_sec1
- a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h +2 lines
458	bool waitForCDMAttachment();	458	bool waitForCDMAttachment();
459	#endif	459	#endif
460		460
		461	void configureMediaStreamAudioTracks();
		462
461	Atomic<bool> m_isPlayerShuttingDown;	463	Atomic<bool> m_isPlayerShuttingDown;
462	GRefPtr<GstElement> m_textSink;	464	GRefPtr<GstElement> m_textSink;
463	GstStructure* m_mediaLocations { nullptr };	465	GstStructure* m_mediaLocations { nullptr };

Lines 51-56 AudioTrackPrivateMediaStream::~AudioTrackPrivateMediaStream() a/Source/WebCore/platform/mediastream/AudioTrackPrivateMediaStream.cpp_sec1
- a/Source/WebCore/platform/mediastream/AudioTrackPrivateMediaStream.cpp -9 / +21 lines
51	std::unique_ptr<AudioMediaStreamTrackRenderer> AudioTrackPrivateMediaStream::createRenderer(AudioTrackPrivateMediaStream& stream)	51	std::unique_ptr<AudioMediaStreamTrackRenderer> AudioTrackPrivateMediaStream::createRenderer(AudioTrackPrivateMediaStream& stream)
52	{	52	{
53	auto renderer = AudioMediaStreamTrackRenderer::create();	53	auto renderer = AudioMediaStreamTrackRenderer::create();
		54	if (!renderer)
		55	return nullptr;
54	renderer->setCrashCallback([stream = makeWeakPtr(stream)] {	56	renderer->setCrashCallback([stream = makeWeakPtr(stream)] {
55	if (stream)	57	if (stream)
56	stream->createNewRenderer();	58	stream->createNewRenderer();
Lines 62-68 std::unique_ptr<AudioMediaStreamTrackRenderer> AudioTrackPrivateMediaStream::cre a/Source/WebCore/platform/mediastream/AudioTrackPrivateMediaStream.cpp_sec2
62	void AudioTrackPrivateMediaStream::setLogger(const Logger& logger, const void* identifier)	64	void AudioTrackPrivateMediaStream::setLogger(const Logger& logger, const void* identifier)
63	{	65	{
64	TrackPrivateBase::setLogger(logger, identifier);	66	TrackPrivateBase::setLogger(logger, identifier);
65	m_renderer->setLogger(logger, identifier);	67	if (m_renderer)
		68	m_renderer->setLogger(logger, identifier);
66	}	69	}
67	#endif	70	#endif
68		71
Lines 77-83 void AudioTrackPrivateMediaStream::clear() a/Source/WebCore/platform/mediastream/AudioTrackPrivateMediaStream.cpp_sec3
77	m_audioSource->removeAudioSampleObserver(*this);	80	m_audioSource->removeAudioSampleObserver(*this);
78		81
79	streamTrack().removeObserver(*this);	82	streamTrack().removeObserver(*this);
80	m_renderer->clear();	83	if (m_renderer)
		84	m_renderer->clear();
81	}	85	}
82		86
83	void AudioTrackPrivateMediaStream::play()	87	void AudioTrackPrivateMediaStream::play()
Lines 103-126 void AudioTrackPrivateMediaStream::setMuted(bool muted) a/Source/WebCore/platform/mediastream/AudioTrackPrivateMediaStream.cpp_sec4
103		107
104	void AudioTrackPrivateMediaStream::setVolume(float volume)	108	void AudioTrackPrivateMediaStream::setVolume(float volume)
105	{	109	{
106	m_renderer->setVolume(volume);	110	if (m_renderer)
		111	m_renderer->setVolume(volume);
107	updateRenderer();	112	updateRenderer();
108	}	113	}
109		114
110	void AudioTrackPrivateMediaStream::setAudioOutputDevice(const String& deviceId)	115	void AudioTrackPrivateMediaStream::setAudioOutputDevice(const String& deviceId)
111	{	116	{
112	m_renderer->setAudioOutputDevice(deviceId);	117	if (m_renderer)
		118	m_renderer->setAudioOutputDevice(deviceId);
113	}	119	}
114		120
115	float AudioTrackPrivateMediaStream::volume() const	121	float AudioTrackPrivateMediaStream::volume() const
116	{	122	{
117	return m_renderer->volume();	123	if (m_renderer)
		124	return m_renderer->volume();
		125	return 1;
118	}	126	}
119		127
120	// May get called on a background thread.	128	// May get called on a background thread.
121	void AudioTrackPrivateMediaStream::audioSamplesAvailable(const MediaTime& sampleTime, const PlatformAudioData& audioData, const AudioStreamDescription& description, size_t sampleCount)	129	void AudioTrackPrivateMediaStream::audioSamplesAvailable(const MediaTime& sampleTime, const PlatformAudioData& audioData, const AudioStreamDescription& description, size_t sampleCount)
122	{	130	{
123	m_renderer->pushSamples(sampleTime, audioData, description, sampleCount);	131	if (m_renderer)
		132	m_renderer->pushSamples(sampleTime, audioData, description, sampleCount);
124	}	133	}
125		134
126	void AudioTrackPrivateMediaStream::trackMutedChanged(MediaStreamTrackPrivate&)	135	void AudioTrackPrivateMediaStream::trackMutedChanged(MediaStreamTrackPrivate&)
Lines 154-160 void AudioTrackPrivateMediaStream::startRenderer() a/Source/WebCore/platform/mediastream/AudioTrackPrivateMediaStream.cpp_sec5
154	return;	163	return;
155		164
156	m_isPlaying = true;	165	m_isPlaying = true;
157	m_renderer->start();	166	if (m_renderer)
		167	m_renderer->start();
158	m_audioSource->addAudioSampleObserver(*this);	168	m_audioSource->addAudioSampleObserver(*this);
159	}	169	}
160		170
Lines 166-172 void AudioTrackPrivateMediaStream::stopRenderer() a/Source/WebCore/platform/mediastream/AudioTrackPrivateMediaStream.cpp_sec6
166		176
167	m_isPlaying = false;	177	m_isPlaying = false;
168	m_audioSource->removeAudioSampleObserver(*this);	178	m_audioSource->removeAudioSampleObserver(*this);
169	m_renderer->stop();	179	if (m_renderer)
		180	m_renderer->stop();
170	}	181	}
171		182
172	void AudioTrackPrivateMediaStream::createNewRenderer()	183	void AudioTrackPrivateMediaStream::createNewRenderer()
Lines 176-182 void AudioTrackPrivateMediaStream::createNewRenderer() a/Source/WebCore/platform/mediastream/AudioTrackPrivateMediaStream.cpp_sec7
176		187
177	float volume = this->volume();	188	float volume = this->volume();
178	m_renderer = createRenderer(*this);	189	m_renderer = createRenderer(*this);
179	m_renderer->setVolume(volume);	190	if (m_renderer)
		191	m_renderer->setVolume(volume);
180		192
181	if (isPlaying)	193	if (isPlaying)
182	startRenderer();	194	startRenderer();




#if ENABLE(VIDEO) && ENABLE(MEDIA_STREAM) && USE(GSTREAMER)

#include "AudioTrackPrivateMediaStream.h"
#include "GStreamerAudioData.h"
#include "GStreamerCommon.h"
#include "MediaSampleGStreamer.h"
#include "MediaStreamPrivate.h"
#include "VideoTrackPrivateMediaStream.h"
#include "VideoTrackPrivate.h"

#include <gst/app/gstappsrc.h>
#include <wtf/UUID.h>


using namespace WebCore;

static GstStaticPadTemplate videoSrcTemplate = GST_STATIC_PAD_TEMPLATE("video_src%u", GST_PAD_SRC, GST_PAD_SOMETIMES,
static void webkitMediaStreamSrcPushAudioSample(WebKitMediaStreamSrc*, const GRefPtr<GstSample>&);
static void webkitMediaStreamSrcTrackEnded(WebKitMediaStreamSrc*, MediaStreamTrackPrivate&);
static void webkitMediaStreamSrcRemoveTrackByType(WebKitMediaStreamSrc*, RealtimeMediaSource::Type);
static void webkitMediaStreamSrcRemoveTrackObserver(WebKitMediaStreamSrc*, MediaStreamTrackPrivate&);
static void webkitMediaStreamSrcPostStreamCollection(WebKitMediaStreamSrc*);
static void webkitMediaStreamSrcRemovePad(WebKitMediaStreamSrc*, const char* padName);

static GstStaticPadTemplate videoSrcTemplate = GST_STATIC_PAD_TEMPLATE("video_src", GST_PAD_SRC, GST_PAD_SOMETIMES,
    GST_STATIC_CAPS("video/x-raw;video/x-h264;video/x-vp8"));

static GstStaticPadTemplate audioSrcTemplate = GST_STATIC_PAD_TEMPLATE("audio_src%u", GST_PAD_SRC, GST_PAD_SOMETIMES,
    GST_STATIC_CAPS("audio/x-raw(ANY);"));

GST_DEBUG_CATEGORY_STATIC(webkitMediaStreamSrcDebug);
#define GST_CAT_DEFAULT webkitMediaStreamSrcDebug

GRefPtr<GstTagList> mediaStreamTrackPrivateGetTags(const MediaStreamTrackPrivate* track)
{
    auto tagList = adoptGRef(gst_tag_list_new_empty());


    return stream;
}

class WebKitMediaStreamTrackObserver
    : public MediaStreamTrackPrivate::Observer
    , public RealtimeMediaSource::AudioSampleObserver
    , public RealtimeMediaSource::VideoSampleObserver {
    WTF_MAKE_FAST_ALLOCATED;
public:
    virtual ~WebKitMediaStreamTrackObserver() { };
    WebKitMediaStreamTrackObserver(GstElement* src)
        : m_src(src) { }
    void trackStarted(MediaStreamTrackPrivate&) final { };

    void trackEnded(MediaStreamTrackPrivate& track) final
    {
        if (m_src)
            webkitMediaStreamSrcTrackEnded(WEBKIT_MEDIA_STREAM_SRC(m_src), track);
    }

    void trackEnabledChanged(MediaStreamTrackPrivate& track) final
    {
        m_enabled = track.enabled();
    }

    void trackMutedChanged(MediaStreamTrackPrivate&) final { };
    void trackSettingsChanged(MediaStreamTrackPrivate&) final { };
    void readyStateChanged(MediaStreamTrackPrivate&) final { };

    void videoSampleAvailable(MediaSample& sample) final
    {
        if (!m_enabled || !m_src)
            return;

        auto* gstSample = static_cast<MediaSampleGStreamer*>(&sample)->platformSample().sample.gstSample;
        webkitMediaStreamSrcPushVideoSample(WEBKIT_MEDIA_STREAM_SRC(m_src), gstSample);
    }

    void audioSamplesAvailable(const MediaTime&, const PlatformAudioData& audioData, const AudioStreamDescription&, size_t) final
    {
        if (!m_enabled || !m_src)
            return;

        auto data = static_cast<const GStreamerAudioData&>(audioData);
        webkitMediaStreamSrcPushAudioSample(WEBKIT_MEDIA_STREAM_SRC(m_src), data.getSample());
    }

private:
    GstElement* m_src { nullptr };
    bool m_enabled { true };
};

class WebKitMediaStreamObserver : public MediaStreamPrivate::Observer {
    WTF_MAKE_FAST_ALLOCATED;
public:

    void didAddTrack(MediaStreamTrackPrivate& track) final
    {
        if (m_src)
            webkitMediaStreamSrcAddTrack(WEBKIT_MEDIA_STREAM_SRC_CAST(m_src), &track, false);
    }

    void didRemoveTrack(MediaStreamTrackPrivate&) final;
    {
        if (!m_src)
            return;

        webkitMediaStreamSrcRemoveTrackObserver(WEBKIT_MEDIA_STREAM_SRC(m_src), track);
        webkitMediaStreamSrcRemoveTrackByType(WEBKIT_MEDIA_STREAM_SRC(m_src), track.type());
    }

private:
    GstElement* m_src;
};

class InternalSource final : public MediaStreamTrackPrivate::Observer,
    public RealtimeMediaSource::AudioSampleObserver,
    public RealtimeMediaSource::VideoSampleObserver {
    WTF_MAKE_FAST_ALLOCATED;
public:
    InternalSource(GstElement* parent, MediaStreamTrackPrivate& track, const String& padName)
        : m_parent(parent)
        , m_track(track)
        , m_padName(padName)
    {
        if (track.type() == RealtimeMediaSource::Type::Audio)
            m_audioTrack = AudioTrackPrivateMediaStream::create(track);
        else if (track.type() == RealtimeMediaSource::Type::Video)
            m_videoTrack = VideoTrackPrivateMediaStream::create(track);

        bool isCaptureTrack = track.isCaptureTrack();
        m_src = gst_element_factory_make("appsrc", nullptr);
        RELEASE_ASSERT_WITH_MESSAGE(GST_IS_APP_SRC(m_src.get()), "GStreamer appsrc element not found. Please make sure to install gst-plugins-base");


        }), this);
    }

    virtual ~InternalSource()
    {
        stopObserving();

        if (m_src)
            g_signal_handlers_disconnect_matched(m_src.get(), G_SIGNAL_MATCH_DATA, 0, 0, nullptr, nullptr, this);
            gst_element_set_locked_state(m_src.get(), true);
            gst_element_set_state(m_src.get(), GST_STATE_NULL);
            gst_bin_remove(GST_BIN_CAST(parent.get()), m_src.get());
            gst_element_set_locked_state(m_src.get(), false);
            GST_STATE_UNLOCK(GST_ELEMENT_CAST(parent.get()));

            const char* padName = m_type == RealtimeMediaSource::Type::Video ? "video_src" : "audio_src";
            webkitMediaStreamSrcRemovePad(WEBKIT_MEDIA_STREAM_SRC(parent.get()), padName);
        }
    }

    const MediaStreamTrackPrivate& track() const { return m_track; }
    const String& padName() const { return m_padName; }
    GstElement* get() const { return m_src.get(); }

    void startObserving()
    {
        if (m_isObserving)
            return;

        m_track.addObserver(*this);
        switch (m_track.type()) {
        case RealtimeMediaSource::Type::Audio:
            m_track.source().addAudioSampleObserver(*this);
            break;
        case RealtimeMediaSource::Type::Video:
            m_track.source().addVideoSampleObserver(*this);
            break;
        case RealtimeMediaSource::Type::None:
            ASSERT_NOT_REACHED();
        }
        m_isObserving = true;
    }

    void stopObserving()
    {
        if (!m_isObserving)
            return;

        m_isObserving = false;
        switch (m_track.type()) {
        case RealtimeMediaSource::Type::Audio:
            m_track.source().removeAudioSampleObserver(*this);
            break;
        case RealtimeMediaSource::Type::Video:
            m_track.source().removeVideoSampleObserver(*this);
            break;
        case RealtimeMediaSource::Type::None:
            ASSERT_NOT_REACHED();
        }
        m_track.removeObserver(*this);
    }

    void configureAudioTrack(float volume, bool isMuted, bool isPlaying)
    {
        ASSERT(m_track.type() == RealtimeMediaSource::Type::Audio);
        m_audioTrack->setVolume(volume);
        m_audioTrack->setMuted(isMuted);
        m_audioTrack->setEnabled(m_audioTrack->streamTrack().enabled() && !m_audioTrack->streamTrack().muted());
        if (isPlaying)
            m_audioTrack->play();
    }

    void pushSample(GstSample* sample)
    {
        ASSERT(m_src);

            gst_pad_set_offset(pad.get(), -m_firstBufferPts);
        }

        if (m_track.type() == RealtimeMediaSource::Type::Video && drop)
            drop = doCapsHaveType(caps, "video/x-raw") || GST_BUFFER_FLAG_IS_SET(buffer, GST_BUFFER_FLAG_DELTA_UNIT);

        if (drop) {
            m_needsDiscont = true;
            GST_INFO_OBJECT(m_src.get(), "%s queue full already... not pushing", m_track.type() == RealtimeMediaSource::Type::Video ? "Video" : "Audio");
            return;
        }


        gst_app_src_push_sample(GST_APP_SRC(m_src.get()), sample);
    }

    void trackStarted(MediaStreamTrackPrivate&) final { };
    void trackEnded(MediaStreamTrackPrivate&) final;

    void trackEnabledChanged(MediaStreamTrackPrivate& track) final
    {
        m_enabled = track.enabled();
    }

    void trackMutedChanged(MediaStreamTrackPrivate&) final { };
    void trackSettingsChanged(MediaStreamTrackPrivate&) final { };
    void readyStateChanged(MediaStreamTrackPrivate&) final { };

    void videoSampleAvailable(MediaSample& sample) final
    {
        if (!m_enabled || !m_parent)
            return;

        auto* gstSample = static_cast<MediaSampleGStreamer*>(&sample)->platformSample().sample.gstSample;
        pushSample(gstSample);
    }

    void audioSamplesAvailable(const MediaTime&, const PlatformAudioData& audioData, const AudioStreamDescription&, size_t) final
    {
        if (!m_enabled || !m_parent)
            return;

        const auto& data = static_cast<const GStreamerAudioData&>(audioData);
        auto sample = data.getSample();
        pushSample(sample.get());
    }

private:
    GstElement* m_parent { nullptr };
    MediaStreamTrackPrivate& m_track;
    GRefPtr<GstElement> m_src;
    bool m_enabled { true };
    GstClockTime m_firstBufferPts { GST_CLOCK_TIME_NONE };
    bool m_enoughData { false };
    bool m_needsDiscont { false };
    String m_padName;
    bool m_isObserving { false };
    RefPtr<AudioTrackPrivateMediaStream> m_audioTrack;
    RefPtr<VideoTrackPrivateMediaStream> m_videoTrack;
};

struct _WebKitMediaStreamSrcPrivate {
    CString uri;
    Vector<std::unique_ptr<InternalSource>> sources;
    Optional<InternalSource> videoSrc;
    std::unique_ptr<WebKitMediaStreamTrackObserver> mediaStreamTrackObserver;
    std::unique_ptr<WebKitMediaStreamObserver> mediaStreamObserver;
    RefPtr<MediaStreamPrivate> stream;
    Vector<RefPtr<MediaStreamTrackPrivate>> tracks;
    GUniquePtr<GstFlowCombiner> flowCombiner;
    GRefPtr<GstStreamCollection> streamCollection;
    Atomic<unsigned> audioPadCounter;
    Atomic<unsigned> videoPadCounter;
};

enum {

    PROP_LAST
};

void WebKitMediaStreamObserver::didRemoveTrack(MediaStreamTrackPrivate& track)
{
    if (!m_src)
        return;

    auto* element = WEBKIT_MEDIA_STREAM_SRC_CAST(m_src);
    element->priv->sources.removeFirstMatching([&](auto& item) {
        return item->track().id() == track.id();
    });
}

static GstURIType webkitMediaStreamSrcUriGetType(GType)
{
    return GST_URI_SRC;


static char* webkitMediaStreamSrcUriGetUri(GstURIHandler* handler)
{
    WebKitMediaStreamSrc* self = WEBKIT_MEDIA_STREAM_SRC_CAST(handler);
    return g_strdup(self->priv->uri.data());
}

static gboolean webkitMediaStreamSrcUriSetUri(GstURIHandler* handler, const char* uri, GError**)
{
    WebKitMediaStreamSrc* self = WEBKIT_MEDIA_STREAM_SRC_CAST(handler);
    self->priv->uri = CString(uri);
    return TRUE;
}

static void webkitMediaStreamSrcConstructed(GObject* object)
{
    GST_CALL_PARENT(G_OBJECT_CLASS, constructed, (object));
    WebKitMediaStreamSrc* self = WEBKIT_MEDIA_STREAM_SRC_CAST(object);
    auto* priv = self->priv;

    priv->mediaStreamTrackObserver = makeUnique<WebKitMediaStreamTrackObserver>(GST_ELEMENT_CAST(self));
    priv->mediaStreamObserver = makeUnique<WebKitMediaStreamObserver>(GST_ELEMENT_CAST(self));
    priv->flowCombiner = GUniquePtr<GstFlowCombiner>(gst_flow_combiner_new());


    ASSERT(g_object_is_floating(self));
}

static void webkitMediaStreamSrcRemoveTrackObserver(WebKitMediaStreamSrc* self, MediaStreamTrackPrivate& track)
{
    auto* priv = self->priv;
    switch (track.type()) {
    case RealtimeMediaSource::Type::Video:
        track.source().removeVideoSampleObserver(*priv->mediaStreamTrackObserver);
        break;
    case RealtimeMediaSource::Type::Audio:
        track.source().removeAudioSampleObserver(*priv->mediaStreamTrackObserver);
        break;
    case RealtimeMediaSource::Type::None:
        ASSERT_NOT_REACHED();
    }
    track.removeObserver(*priv->mediaStreamTrackObserver);
}

static void stopObservingTracks(WebKitMediaStreamSrc* self)
{
    GST_OBJECT_LOCK(self);
    auto* priv = self->priv;
    for (auto& track : priv->tracks)
        webkitMediaStreamSrcRemoveTrackObserver(self, *track);
    GST_OBJECT_UNLOCK(self);
}

static void webkitMediaStreamSrcDispose(GObject* object)
{
    WebKitMediaStreamSrc* self = WEBKIT_MEDIA_STREAM_SRC_CAST(object);

    stopObservingTracks(self);

    GST_OBJECT_LOCK(self);
    auto* priv = self->priv;

static GstStateChangeReturn webkitMediaStreamSrcChangeState(GstElement* element, GstStateChange transition)
{
    GST_DEBUG_OBJECT(element, "%s", gst_state_change_get_name(transition));
    WebKitMediaStreamSrc* self = WEBKIT_MEDIA_STREAM_SRC_CAST(element);

    if (transition == GST_STATE_CHANGE_PAUSED_TO_READY) {
        GST_OBJECT_LOCK(self);
        for (auto& item : self->priv->sources)
            item->stopObserving();
        GST_OBJECT_UNLOCK(self);
    }

    GstStateChangeReturn result = GST_ELEMENT_CLASS(webkit_media_stream_src_parent_class)->change_state(element, transition);

    if (transition == GST_STATE_CHANGE_READY_TO_PAUSED) {
        GST_OBJECT_LOCK(self);
        for (auto& item : self->priv->sources)
            item->startObserving();
        GST_OBJECT_UNLOCK(self);
        result = GST_STATE_CHANGE_NO_PREROLL;
    }

    return result;
}

{
    GRefPtr<GstElement> element = adoptGRef(GST_ELEMENT_CAST(gst_object_get_parent(parent)));
    GstFlowReturn chainResult = gst_proxy_pad_chain_default(pad, GST_OBJECT_CAST(element.get()), buffer);
    auto* self = WEBKIT_MEDIA_STREAM_SRC_CAST(element.get());
    GstFlowReturn result = gst_flow_combiner_update_pad_flow(self->priv->flowCombiner.get(), pad, chainResult);

    if (result == GST_FLOW_FLUSHING)

    return result;
}

static void webkitMediaStreamSrcPostStreamCollection(WebKitMediaStreamSrc* self)
{
    auto* priv = self->priv;

    GST_OBJECT_LOCK(self);
    if (priv->stream && (!priv->stream->active() || !priv->stream->hasTracks())) {
        GST_OBJECT_UNLOCK(self);
        return;
    }

    auto upstreamId = priv->stream ? priv->stream->id() : createCanonicalUUIDString();
    priv->streamCollection = adoptGRef(gst_stream_collection_new(upstreamId.ascii().data()));
    for (auto& track : priv->tracks) {
        if (!track->isActive())
            continue;
        gst_stream_collection_add_stream(priv->streamCollection.get(), webkitMediaStreamNew(track.get()));
    }

    GST_OBJECT_UNLOCK(self);

    GST_DEBUG_OBJECT(self, "Posting stream collection");
    gst_element_post_message(GST_ELEMENT_CAST(self), gst_message_new_stream_collection(GST_OBJECT_CAST(self), priv->streamCollection.get()));
}

static void webkitMediaStreamSrcAddPad(WebKitMediaStreamSrc* self, GstPad* target, GstStaticPadTemplate* padTemplate, GRefPtr<GstTagList>&& tags, RealtimeMediaSource::Type sourceType, const String& padName)
{
    ASSERT(sourceType != RealtimeMediaSource::Type::None);
    if (sourceType == RealtimeMediaSource::Type::None)
        return;

    GST_DEBUG_OBJECT(self, "%s Ghosting %" GST_PTR_FORMAT, gst_object_get_path_string(GST_OBJECT_CAST(self)), target);

    auto* ghostPad = webkitGstGhostPadFromStaticTemplate(padTemplate, padName.ascii().data(), target);
    auto* ghostPad = webkitGstGhostPadFromStaticTemplate(padTemplate, padName, target);
    gst_pad_set_active(ghostPad, TRUE);
    gst_element_add_pad(GST_ELEMENT_CAST(self), ghostPad);


    gst_pad_push_event(target, gst_event_new_tag(tags.leakRef()));
}

static void webkitMediaStreamSrcRemovePad(WebKitMediaStreamSrc* self, const char* padName)
{
    auto pad = adoptGRef(gst_element_get_static_pad(GST_ELEMENT_CAST(self), padName));
    if (!pad)
        return;

    auto proxyPad = adoptGRef(GST_PAD_CAST(gst_proxy_pad_get_internal(GST_PROXY_PAD(pad.get()))));
    if (proxyPad)
        gst_flow_combiner_remove_pad(self->priv->flowCombiner.get(), proxyPad.get());

    gst_pad_set_active(pad.get(), FALSE);
    gst_element_remove_pad(GST_ELEMENT_CAST(self), pad.get());
}

struct ProbeData {
    ProbeData(GstElement* element, GstStaticPadTemplate* padTemplate, GRefPtr<GstTagList>&& tags, const char* trackId, RealtimeMediaSource::Type sourceType, const String& padName)
        : element(element)
        , padTemplate(padTemplate)
        , tags(WTFMove(tags))
        , trackId(g_strdup(trackId))
        , sourceType(sourceType)
        , padName(padName)
    {
    }


    GRefPtr<GstTagList> tags;
    GUniquePtr<char> trackId;
    RealtimeMediaSource::Type sourceType;
    String padName;
};

static GstPadProbeReturn webkitMediaStreamSrcPadProbeCb(GstPad* pad, GstPadProbeInfo* info, ProbeData* data)
{
    GstEvent* event = GST_PAD_PROBE_INFO_EVENT(info);
    WebKitMediaStreamSrc* self = WEBKIT_MEDIA_STREAM_SRC_CAST(data->element.get());

    GST_DEBUG_OBJECT(self, "Event %" GST_PTR_FORMAT, event);
    switch (GST_EVENT_TYPE(event)) {

        gst_event_set_group_id(streamStart, 1);
        gst_pad_push_event(pad, streamStart);

        webkitMediaStreamSrcAddPad(self, pad, data->padTemplate, WTFMove(data->tags), data->sourceType, data->padName);
        callOnMainThreadAndWait([element = data->element] {
            webkitMediaStreamSrcPostStreamCollection(WEBKIT_MEDIA_STREAM_SRC_CAST(element.get()));
        });
        return GST_PAD_PROBE_REMOVE;
    }

    return GST_PAD_PROBE_OK;
}

void webkitMediaStreamSrcAddTrack(WebKitMediaStreamSrc* self, MediaStreamTrackPrivate* track, bool onlyTrack)
{
    const char* sourceType = "unknown";
    unsigned counter = 0;
    GstStaticPadTemplate* padTemplate = nullptr;
    if (track->type() == RealtimeMediaSource::Type::Audio) {
        padTemplate = &audioSrcTemplate;
        sourceType = "audio";
        counter = self->priv->audioPadCounter.exchangeAdd(1);
    } else if (track->type() == RealtimeMediaSource::Type::Video) {
        padTemplate = &videoSrcTemplate;
        sourceType = "video";
        counter = self->priv->videoPadCounter.exchangeAdd(1);
    } else {
        GST_WARNING_OBJECT(self, "Unsupported track type: %d", static_cast<int>(track->type()));
        return;
    }

    StringBuilder padName;
    padName.append(sourceType);
    padName.append("_src");
    padName.append(counter);

    GST_DEBUG_OBJECT(self, "Setup %s source for track %s, only track: %s", sourceType, track->id().utf8().data(), boolForPrinting(onlyTrack));

    auto source = makeUnique<InternalSource>(GST_ELEMENT_CAST(self), *track, padName.toString());
    auto* element = source->get();
    gst_bin_add(GST_BIN_CAST(self), element);

    auto pad = adoptGRef(gst_element_get_static_pad(element, "src"));
    auto tags = mediaStreamTrackPrivateGetTags(track);
    if (!onlyTrack) {
        auto* data = new ProbeData(GST_ELEMENT_CAST(self), padTemplate, WTFMove(tags), track->id().utf8().data(), track->source().type(), source->padName());
        gst_pad_add_probe(pad.get(), GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM, reinterpret_cast<GstPadProbeCallback>(webkitMediaStreamSrcPadProbeCb), data, [](gpointer data) {
            delete reinterpret_cast<ProbeData*>(data);
        });
    } else {
        gst_pad_set_active(pad.get(), TRUE);
        webkitMediaStreamSrcAddPad(self, pad.get(), padTemplate, WTFMove(tags), track->source().type(), source->padName());
    }

    auto* priv = self->priv;
    track->addObserver(*priv->mediaStreamTrackObserver);
    switch (track->type()) {
    case RealtimeMediaSource::Type::Audio:
        track->source().addAudioSampleObserver(*priv->mediaStreamTrackObserver);
        break;
    case RealtimeMediaSource::Type::Video:
        track->source().addVideoSampleObserver(*priv->mediaStreamTrackObserver);
        break;
    case RealtimeMediaSource::Type::None:
        ASSERT_NOT_REACHED();
    }

    gst_element_sync_state_with_parent(element);
}

static void webkitMediaStreamSrcPostStreamCollection(WebKitMediaStreamSrc* self)
{
    auto* priv = self->priv;

    GST_OBJECT_LOCK(self);
    if (priv->stream && (!priv->stream->active() || !priv->stream->hasTracks())) {
        GST_OBJECT_UNLOCK(self);
        return;
    }

    auto upstreamId = priv->stream ? priv->stream->id() : createCanonicalUUIDString();
    priv->streamCollection = adoptGRef(gst_stream_collection_new(upstreamId.ascii().data()));
    for (auto& track : priv->tracks) {
        if (!track->isActive())
            continue;
        gst_stream_collection_add_stream(priv->streamCollection.get(), webkitMediaStreamNew(track.get()));
    }

    GST_OBJECT_UNLOCK(self);

    GST_DEBUG_OBJECT(self, "Posting stream collection");
    gst_element_post_message(GST_ELEMENT_CAST(self), gst_message_new_stream_collection(GST_OBJECT_CAST(self), priv->streamCollection.get()));
}

void webkitMediaStreamSrcAddTrack(WebKitMediaStreamSrc* self, MediaStreamTrackPrivate* track, bool onlyTrack)
{
    auto* priv = self->priv;
    if (track->type() == RealtimeMediaSource::Type::Audio) {
        priv->audioSrc.emplace(track->isCaptureTrack(), track->type());
        webkitMediaStreamSrcSetupSrc(self, track, priv->audioSrc->get(), &audioSrcTemplate, onlyTrack);
    } else if (track->type() == RealtimeMediaSource::Type::Video) {
        priv->videoSrc.emplace(track->isCaptureTrack(), track->type());
        webkitMediaStreamSrcSetupSrc(self, track, priv->videoSrc->get(), &videoSrcTemplate, onlyTrack);
    } else
        GST_INFO_OBJECT(self, "Unsupported track type: %d", static_cast<int>(track->type()));

    source->startObserving();
    self->priv->sources.append(WTFMove(source));
    self->priv->tracks.append(track);
}

static void webkitMediaStreamSrcRemoveTrackByType(WebKitMediaStreamSrc* self, RealtimeMediaSource::Type trackType)
{
    if (trackType == RealtimeMediaSource::Type::Audio)
        self->priv->audioSrc.reset();
    else if (trackType == RealtimeMediaSource::Type::Video)
        self->priv->videoSrc.reset();
    else
        GST_INFO_OBJECT(self, "Unsupported track type: %d", static_cast<int>(trackType));
}

void webkitMediaStreamSrcSetStream(WebKitMediaStreamSrc* self, MediaStreamPrivate* stream, bool isVideoPlayer)
{
    ASSERT(WEBKIT_IS_MEDIA_STREAM_SRC(self));

        webkitMediaStreamSrcAddTrack(self, track.get(), onlyTrack);
    }
    webkitMediaStreamSrcPostStreamCollection(self);
    gst_element_no_more_pads(GST_ELEMENT_CAST(self));
}

static void webkitMediaStreamSrcPushVideoSample(WebKitMediaStreamSrc* self, GstSample* sample)
{
    if (self->priv->videoSrc)
        self->priv->videoSrc->pushSample(sample);
}

static void webkitMediaStreamSrcPushAudioSample(WebKitMediaStreamSrc* self, const GRefPtr<GstSample>& sample)
{
    if (self->priv->audioSrc)
        self->priv->audioSrc->pushSample(sample.get());
}

static void webkitMediaStreamSrcTrackEnded(WebKitMediaStreamSrc* self, InternalSource& source)
{
    GRefPtr<GstPad> pad;

    auto& track = source.track();
    GST_DEBUG_OBJECT(self, "Track %s ended", track.label().utf8().data());
    GST_OBJECT_LOCK(self);
    GstElement* element = GST_ELEMENT_CAST(self);

    auto tags = mediaStreamTrackPrivateGetTags(&track);
    gst_pad_push_event(pad.get(), gst_event_new_tag(tags.leakRef()));
    gst_pad_push_event(pad.get(), gst_event_new_eos());

    GST_STATE_LOCK(GST_ELEMENT_CAST(self));
    gst_element_set_locked_state(source.get(), true);
    gst_element_set_state(source.get(), GST_STATE_NULL);
    gst_bin_remove(GST_BIN_CAST(self), source.get());
    gst_element_set_locked_state(source.get(), false);
    GST_STATE_UNLOCK(GST_ELEMENT_CAST(self));

    auto proxyPad = adoptGRef(GST_PAD_CAST(gst_proxy_pad_get_internal(GST_PROXY_PAD(pad.get()))));
    if (proxyPad)
        gst_flow_combiner_remove_pad(self->priv->flowCombiner.get(), proxyPad.get());

    gst_pad_set_active(pad.get(), FALSE);
    gst_element_remove_pad(GST_ELEMENT_CAST(self), pad.get());
}

void InternalSource::trackEnded(MediaStreamTrackPrivate&)
{
    if (m_parent)
        webkitMediaStreamSrcTrackEnded(WEBKIT_MEDIA_STREAM_SRC_CAST(m_parent), *this);

    stopObserving();
}

void webkitMediaStreamSrcConfigureAudioTracks(WebKitMediaStreamSrc* self, float volume, bool isMuted, bool isPlaying)
{
    for (auto& source : self->priv->sources) {
        if (source->track().type() == RealtimeMediaSource::Type::Audio)
            source->configureAudioTrack(volume, isMuted, isPlaying);
    }
}

GstElement* webkitMediaStreamSrcNew()



class MediaStreamTrackPrivate;
}

G_BEGIN_DECLS

#define WEBKIT_MEDIA_TRACK_TAG_WIDTH "webkit-media-stream-width"
#define WEBKIT_MEDIA_TRACK_TAG_HEIGHT "webkit-media-stream-height"
#define WEBKIT_MEDIA_TRACK_TAG_KIND "webkit-media-stream-kind"

#define WEBKIT_MEDIA_STREAM_SRC(o) (G_TYPE_CHECK_INSTANCE_CAST((o), WEBKIT_TYPE_MEDIA_STREAM_SRC, WebKitMediaStreamSrc))
#define WEBKIT_IS_MEDIA_STREAM_SRC(o) (G_TYPE_CHECK_INSTANCE_TYPE((o), WEBKIT_TYPE_MEDIA_STREAM_SRC))
#define WEBKIT_MEDIA_STREAM_SRC_CAST(o) ((WebKitMediaStreamSrc*) o)

#define WEBKIT_TYPE_MEDIA_STREAM_SRC (webkit_media_stream_src_get_type())
GType webkit_media_stream_src_get_type(void);


    GstBinClass parentClass;
};

GstElement* webkitMediaStreamSrcNew();
void webkitMediaStreamSrcSetStream(WebKitMediaStreamSrc*, WebCore::MediaStreamPrivate*, bool isVideoPlayer);
void webkitMediaStreamSrcAddTrack(WebKitMediaStreamSrc*, WebCore::MediaStreamTrackPrivate*, bool onlyTrack);
void webkitMediaStreamSrcConfigureAudioTracks(WebKitMediaStreamSrc*, float volume, bool isMuted, bool isPlaying);

G_END_DECLS

#endif // ENABLE(VIDEO) && ENABLE(MEDIA_STREAM) && USE(GSTREAMER)



2021-04-17  Philippe Normand  <pnormand@igalia.com>

        [GStreamer][MediaStream] fast/mediastream/play-newly-added-audio-track.html is failing since added in r260380
        https://bugs.webkit.org/show_bug.cgi?id=210840

        Reviewed by Xabier Rodriguez-Calvar.

        Remove flakyness from test and unflag it on GTK.

        * fast/mediastream/play-newly-added-audio-track.html: addTrack might have asynchronous
        effects, so it's better to rely on the trackadded event when testing its result.
        * platform/gtk/TestExpectations:

2021-04-16  Diego Pino Garcia  <dpino@igalia.com>

        [GLIB] Unreviewed test gardening. Update focus-visible tests baselines after r276127.

Lines 11-21 promise_test(async () => { a/LayoutTests/fast/mediastream/play-newly-added-audio-track.html_sec1
- a/LayoutTests/fast/mediastream/play-newly-added-audio-track.html -5 / +11 lines
11		11
12	await video.play();	12	await video.play();
13		13
		14	video.srcObject.ontrackadded = () => {
		15	if (window.internals)
		16	assert_true(internals.shouldAudioTrackPlay(video.audioTracks[0]));
		17	};
		18
14	let stream2 = await navigator.mediaDevices.getUserMedia({ audio : true });	19	let stream2 = await navigator.mediaDevices.getUserMedia({ audio : true });
15	video.srcObject.addTrack(stream2.getAudioTracks()[0]);	20	video.srcObject.addTrack(stream2.getAudioTracks()[0]);
16		21	await new Promise(resolve => setTimeout(resolve, 50));
17	if (window.internals)
18	assert_true(internals.shouldAudioTrackPlay(video.audioTracks[0]));
19	}, "Add an audio track while playing video");	22	}, "Add an audio track while playing video");
20		23
21	promise_test(async () => {	24	promise_test(async () => {
Lines 24-33 promise_test(async () => { a/LayoutTests/fast/mediastream/play-newly-added-audio-track.html_sec2
24		27
25	await video.play();	28	await video.play();
26		29
		30	video.srcObject.ontrackadded = () => {
		31	if (window.internals)
		32	assert_true(internals.shouldAudioTrackPlay(video.audioTracks[1]));
		33	};
		34
27	video.srcObject.addTrack(stream.getAudioTracks()[0]);	35	video.srcObject.addTrack(stream.getAudioTracks()[0]);
28	await new Promise(resolve => setTimeout(resolve, 50));	36	await new Promise(resolve => setTimeout(resolve, 50));
29	if (window.internals)
30	assert_true(internals.shouldAudioTrackPlay(video.audioTracks[1]));
31	}, "Add an audio track while playing audio");	37	}, "Add an audio track while playing audio");
32	</script>	38	</script>
33	</head>	39	</head>

Lines 161-167 webkit.org/b/219530 fast/dom/HTMLAnchorElement/anchor-nodownload-set.html [ Fail a/LayoutTests/platform/gtk/TestExpectations_sec1
- a/LayoutTests/platform/gtk/TestExpectations -1 lines
161		161
162	# GStreamer - GTK-Only. Most GStreamer issues probably will go in the glib expectations	162	# GStreamer - GTK-Only. Most GStreamer issues probably will go in the glib expectations
163	webkit.org/b/210528 media/video-supports-fullscreen.html [ Pass ]	163	webkit.org/b/210528 media/video-supports-fullscreen.html [ Pass ]
164	webkit.org/b/210840 fast/mediastream/play-newly-added-audio-track.html [ Failure ]
165		164
166	# Layout	165	# Layout
167	webkit.org/b/218510 fast/dom/Range/getBoundingClientRect.html [ Failure ]	166	webkit.org/b/218510 fast/dom/Range/getBoundingClientRect.html [ Failure ]

Return to Bug 210840

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +56 lines
		1	2021-04-17 Philippe Normand <pnormand@igalia.com>
		2
		3	[GStreamer][MediaStream] fast/mediastream/play-newly-added-audio-track.html is failing since added in r260380
		4	https://bugs.webkit.org/show_bug.cgi?id=210840
		5
		6	Reviewed by Xabier Rodriguez-Calvar.
		7
		8	The test was failing mainly because our mediastreamsrc GStreamer element wasn't creating the
		9	corresponding AudioTrackPrivateMediaStream object. The media player should propagate its
		10	volume/mute/is-playing states to the source element. And also until now our mediastreamsrc
		11	element was handling at most one audio track and at most one audio track, but it turns out
		12	multiple audio tracks can be added actually. So I refactored the element internals
		13	accordingly. The InternalSource is now directly observing the corresponding
		14	RealtimeMediaSource, which simplified some code. Observing is also now suspended/resumed
		15	depending on the element state.
		16
		17	We don't implement a GStreamer AudioMediaStreamTrackRenderer class yet, because actual
		18	rendering is still performed from the WebProcess, so early returns were added in
		19	AudioTrackPrivateMediaStream to handle this case.
		20
		21	* platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:
		22	(WebCore::MediaPlayerPrivateGStreamer::updateTracks):
		23	(WebCore::MediaPlayerPrivateGStreamer::configureMediaStreamAudioTracks):
		24	(WebCore::MediaPlayerPrivateGStreamer::setVolume):
		25	(WebCore::MediaPlayerPrivateGStreamer::setMuted):
		26	(WebCore::MediaPlayerPrivateGStreamer::updateStates):
		27	(WebCore::MediaPlayerPrivateGStreamer::didEnd):
		28	* platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h:
		29	* platform/mediastream/AudioTrackPrivateMediaStream.cpp:
		30	(WebCore::AudioTrackPrivateMediaStream::createRenderer):
		31	(WebCore::AudioTrackPrivateMediaStream::setLogger):
		32	(WebCore::AudioTrackPrivateMediaStream::clear):
		33	(WebCore::AudioTrackPrivateMediaStream::setVolume):
		34	(WebCore::AudioTrackPrivateMediaStream::setAudioOutputDevice):
		35	(WebCore::AudioTrackPrivateMediaStream::volume const):
		36	(WebCore::AudioTrackPrivateMediaStream::audioSamplesAvailable):
		37	(WebCore::AudioTrackPrivateMediaStream::startRenderer):
		38	(WebCore::AudioTrackPrivateMediaStream::stopRenderer):
		39	(WebCore::AudioTrackPrivateMediaStream::createNewRenderer):
		40	* platform/mediastream/gstreamer/GStreamerMediaStreamSource.cpp:
		41	(mediaStreamTrackPrivateGetTags):
		42	(WebKitMediaStreamObserver::didRemoveTrack):
		43	(webkitMediaStreamSrcConstructed):
		44	(webkitMediaStreamSrcDispose):
		45	(webkitMediaStreamSrcChangeState):
		46	(webkitMediaStreamSrcPostStreamCollection):
		47	(webkitMediaStreamSrcAddPad):
		48	(ProbeData::ProbeData):
		49	(webkitMediaStreamSrcPadProbeCb):
		50	(webkitMediaStreamSrcAddTrack):
		51	(webkitMediaStreamSrcSetStream):
		52	(webkitMediaStreamSrcTrackEnded):
		53	(InternalSource::trackEnded):
		54	(webkitMediaStreamSrcConfigureAudioTracks):
		55	* platform/mediastream/gstreamer/GStreamerMediaStreamSource.h:
		56
1	2021-04-16 Brent Fulgham <bfulgham@apple.com>	57	2021-04-16 Brent Fulgham <bfulgham@apple.com>
2		58
3	Perform port blocking earlier in the load	59	Perform port blocking earlier in the load

Lines 30-43 class MediaStreamPrivate; a/Source/WebCore/platform/mediastream/gstreamer/GStreamerMediaStreamSource.h_sec1
- a/Source/WebCore/platform/mediastream/gstreamer/GStreamerMediaStreamSource.h -5 / +4 lines
30	class MediaStreamTrackPrivate;	30	class MediaStreamTrackPrivate;
31	}	31	}
32		32
33	G_BEGIN_DECLS
34
35	#define WEBKIT_MEDIA_TRACK_TAG_WIDTH "webkit-media-stream-width"	33	#define WEBKIT_MEDIA_TRACK_TAG_WIDTH "webkit-media-stream-width"
36	#define WEBKIT_MEDIA_TRACK_TAG_HEIGHT "webkit-media-stream-height"	34	#define WEBKIT_MEDIA_TRACK_TAG_HEIGHT "webkit-media-stream-height"
37	#define WEBKIT_MEDIA_TRACK_TAG_KIND "webkit-media-stream-kind"	35	#define WEBKIT_MEDIA_TRACK_TAG_KIND "webkit-media-stream-kind"
38		36
39	#define WEBKIT_MEDIA_STREAM_SRC(o) (G_TYPE_CHECK_INSTANCE_CAST((o), WEBKIT_TYPE_MEDIA_STREAM_SRC, WebKitMediaStreamSrc))	37	#define WEBKIT_MEDIA_STREAM_SRC(o) (G_TYPE_CHECK_INSTANCE_CAST((o), WEBKIT_TYPE_MEDIA_STREAM_SRC, WebKitMediaStreamSrc))
40	#define WEBKIT_IS_MEDIA_STREAM_SRC(o) (G_TYPE_CHECK_INSTANCE_TYPE((o), WEBKIT_TYPE_MEDIA_STREAM_SRC))	38	#define WEBKIT_IS_MEDIA_STREAM_SRC(o) (G_TYPE_CHECK_INSTANCE_TYPE((o), WEBKIT_TYPE_MEDIA_STREAM_SRC))
		39	#define WEBKIT_MEDIA_STREAM_SRC_CAST(o) ((WebKitMediaStreamSrc*) o)
		40
41	#define WEBKIT_TYPE_MEDIA_STREAM_SRC (webkit_media_stream_src_get_type())	41	#define WEBKIT_TYPE_MEDIA_STREAM_SRC (webkit_media_stream_src_get_type())
42	GType webkit_media_stream_src_get_type(void);	42	GType webkit_media_stream_src_get_type(void);
43		43
Lines 54-63 struct _WebKitMediaStreamSrcClass { a/Source/WebCore/platform/mediastream/gstreamer/GStreamerMediaStreamSource.h_sec2
54	GstBinClass parentClass;	54	GstBinClass parentClass;
55	};	55	};
56		56
		57	GstElement* webkitMediaStreamSrcNew();
57	void webkitMediaStreamSrcSetStream(WebKitMediaStreamSrc, WebCore::MediaStreamPrivate, bool isVideoPlayer);	58	void webkitMediaStreamSrcSetStream(WebKitMediaStreamSrc, WebCore::MediaStreamPrivate, bool isVideoPlayer);
58	void webkitMediaStreamSrcAddTrack(WebKitMediaStreamSrc, WebCore::MediaStreamTrackPrivate, bool onlyTrack);	59	void webkitMediaStreamSrcAddTrack(WebKitMediaStreamSrc, WebCore::MediaStreamTrackPrivate, bool onlyTrack);
59	GstElement* webkitMediaStreamSrcNew();	60	void webkitMediaStreamSrcConfigureAudioTracks(WebKitMediaStreamSrc*, float volume, bool isMuted, bool isPlaying);
60
61	G_END_DECLS
62		61
63	#endif // ENABLE(VIDEO) && ENABLE(MEDIA_STREAM) && USE(GSTREAMER)	62	#endif // ENABLE(VIDEO) && ENABLE(MEDIA_STREAM) && USE(GSTREAMER)

Lines 1-3 a/LayoutTests/ChangeLog_sec1
- a/LayoutTests/ChangeLog +13 lines
		1	2021-04-17 Philippe Normand <pnormand@igalia.com>
		2
		3	[GStreamer][MediaStream] fast/mediastream/play-newly-added-audio-track.html is failing since added in r260380
		4	https://bugs.webkit.org/show_bug.cgi?id=210840
		5
		6	Reviewed by Xabier Rodriguez-Calvar.
		7
		8	Remove flakyness from test and unflag it on GTK.
		9
		10	* fast/mediastream/play-newly-added-audio-track.html: addTrack might have asynchronous
		11	effects, so it's better to rely on the trackadded event when testing its result.
		12	* platform/gtk/TestExpectations:
		13
1	2021-04-16 Diego Pino Garcia <dpino@igalia.com>	14	2021-04-16 Diego Pino Garcia <dpino@igalia.com>
2		15
3	[GLIB] Unreviewed test gardening. Update focus-visible tests baselines after r276127.	16	[GLIB] Unreviewed test gardening. Update focus-visible tests baselines after r276127.