⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 259824 in webkit


Ignore:
Timestamp:
Apr 9, 2020, 1:49:04 PM (6 years ago)
Author:
Jacob Uphoff
Message:

Unreviewed, reverting r259816.

This commit broke the webkit build for macOS and iOS

Reverted changeset:

"Introduce a RealtimeMediaSource observer dedicated to
receiving audio samples"
​https://bugs.webkit.org/show_bug.cgi?id=210180
​https://trac.webkit.org/changeset/259816

Location:
trunk/Source
Files:
35 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r259821 r259824  
     12020-04-09  Jacob Uphoff  <jacob_uphoff@apple.com>
     2
     3        Unreviewed, reverting r259816.
     4
     5        This commit broke the webkit build for macOS and iOS
     6
     7        Reverted changeset:
     8
     9        "Introduce a RealtimeMediaSource observer dedicated to
     10        receiving audio samples"
     11        https://bugs.webkit.org/show_bug.cgi?id=210180
     12        https://trac.webkit.org/changeset/259816
     13
    1142020-04-09  Daniel Bates  <dabates@apple.com>
    215

  • trunk/Source/WebCore/Modules/mediarecorder/MediaRecorder.cpp

    r259816 r259824  
    4545WTF_MAKE_ISO_ALLOCATED_IMPL(MediaRecorder);
    4646
    47 MediaRecorder::CreatorFunction MediaRecorder::m_customCreator = nullptr;
     47creatorFunction MediaRecorder::m_customCreator = nullptr;
    4848
    4949ExceptionOr<Ref<MediaRecorder>> MediaRecorder::create(Document& document, Ref<MediaStream>&& stream, Options&& options)
    … …  
    6060}
    6161
    62 void MediaRecorder::setCustomPrivateRecorderCreator(CreatorFunction creator)
     62void MediaRecorder::setCustomPrivateRecorderCreator(creatorFunction creator)
    6363{
    6464    m_customCreator = creator;
    6565}
    6666
    67 std::unique_ptr<MediaRecorderPrivate> MediaRecorder::createMediaRecorderPrivate(Document& document, MediaStreamPrivate& stream)
     67std::unique_ptr<MediaRecorderPrivate> MediaRecorder::createMediaRecorderPrivate(Document& document, const MediaStreamPrivate& stream)
    6868{
    6969    if (m_customCreator)
    70         return m_customCreator(stream);
     70        return m_customCreator();
    7171
    7272#if PLATFORM(COCOA)
    … …  
    228228}
    229229
     230void MediaRecorder::audioSamplesAvailable(MediaStreamTrackPrivate& track, const MediaTime& mediaTime, const PlatformAudioData& audioData, const AudioStreamDescription& description, size_t sampleCount)
     231{
     232    m_private->audioSamplesAvailable(track, mediaTime, audioData, description, sampleCount);
     233}
     234
    230235bool MediaRecorder::virtualHasPendingActivity() const
    231236{

  • trunk/Source/WebCore/Modules/mediarecorder/MediaRecorder.h

    r259816 r259824  
    3939class MediaRecorderPrivate;
    4040
     41typedef std::unique_ptr<MediaRecorderPrivate>(*creatorFunction)();
     42
    4143class MediaRecorder final
    4244    : public ActiveDOMObject
    … …  
    6163    static ExceptionOr<Ref<MediaRecorder>> create(Document&, Ref<MediaStream>&&, Options&& = { });
    6264   
    63     using CreatorFunction = std::unique_ptr<MediaRecorderPrivate>(*)(MediaStreamPrivate&);
    64 
    65     WEBCORE_EXPORT static void setCustomPrivateRecorderCreator(CreatorFunction);
     65    WEBCORE_EXPORT static void setCustomPrivateRecorderCreator(creatorFunction);
    6666   
    6767    RecordingState state() const { return m_state; }
    … …  
    7979    MediaRecorder(Document&, Ref<MediaStream>&&, std::unique_ptr<MediaRecorderPrivate>&&, Options&& = { });
    8080
    81     static std::unique_ptr<MediaRecorderPrivate> createMediaRecorderPrivate(Document&, MediaStreamPrivate&);
     81    static std::unique_ptr<MediaRecorderPrivate> createMediaRecorderPrivate(Document&, const MediaStreamPrivate&);
    8282   
    8383    Document* document() const;
    … …  
    108108    void trackEnabledChanged(MediaStreamTrackPrivate&) final { };
    109109    void sampleBufferUpdated(MediaStreamTrackPrivate&, MediaSample&) final;
    110 
    111     static CreatorFunction m_customCreator;
     110    void audioSamplesAvailable(MediaStreamTrackPrivate&, const MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t) final;
     111   
     112    static creatorFunction m_customCreator;
    112113   
    113114    Options m_options;

  • trunk/Source/WebCore/Modules/mediarecorder/MediaRecorderProvider.cpp

    r259816 r259824  
    3333namespace WebCore {
    3434
    35 std::unique_ptr<MediaRecorderPrivate> MediaRecorderProvider::createMediaRecorderPrivate(MediaStreamPrivate& stream)
     35std::unique_ptr<MediaRecorderPrivate> MediaRecorderProvider::createMediaRecorderPrivate(const MediaStreamPrivate& stream)
    3636{
    3737    return MediaRecorderPrivateAVFImpl::create(stream);

  • trunk/Source/WebCore/Modules/mediarecorder/MediaRecorderProvider.h

    r259816 r259824  
    3838
    3939#if ENABLE(MEDIA_STREAM) && PLATFORM(COCOA)
    40     virtual std::unique_ptr<MediaRecorderPrivate> createMediaRecorderPrivate(MediaStreamPrivate&);
     40    virtual std::unique_ptr<MediaRecorderPrivate> createMediaRecorderPrivate(const MediaStreamPrivate&);
    4141#endif
    4242

  • trunk/Source/WebCore/loader/EmptyClients.cpp

    r259816 r259824  
    583583private:
    584584#if ENABLE(MEDIA_STREAM) && PLATFORM(COCOA)
    585     std::unique_ptr<MediaRecorderPrivate> createMediaRecorderPrivate(MediaStreamPrivate&) final { return nullptr; }
     585    std::unique_ptr<MediaRecorderPrivate> createMediaRecorderPrivate(const MediaStreamPrivate&) final { return nullptr; }
    586586#endif
    587587};

  • trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.mm

    r259816 r259824  
    561561    m_volume = volume;
    562562    for (const auto& track : m_audioTrackMap.values())
    563         track->setVolume(m_volume);
     563        track->setVolume(m_muted ? 0 : m_volume);
    564564}
    565565
    … …  
    572572    m_muted = muted;
    573573    for (const auto& track : m_audioTrackMap.values())
    574         track->setMuted(m_muted);
     574        track->setVolume(m_muted ? 0 : m_volume);
    575575}
    576576

  • trunk/Source/WebCore/platform/mediarecorder/MediaRecorderPrivate.cpp

    r259816 r259824  
    3333namespace WebCore {
    3434
    35 MediaRecorderPrivate::AudioVideoSelectedTracks MediaRecorderPrivate::selectTracks(MediaStreamPrivate& stream)
     35MediaRecorderPrivate::AudioVideoSelectedTracks MediaRecorderPrivate::selectTracks(const MediaStreamPrivate& stream)
    3636{
    3737    AudioVideoSelectedTracks selectedTracks;

  • trunk/Source/WebCore/platform/mediarecorder/MediaRecorderPrivate.h

    r259816 r259824  
    2828#include <wtf/Forward.h>
    2929#include "Exception.h"
    30 #include "RealtimeMediaSource.h"
    3130
    3231#if ENABLE(MEDIA_STREAM)
    … …  
    4544class SharedBuffer;
    4645
    47 class MediaRecorderPrivate :
    48     public RealtimeMediaSource::AudioSampleObserver {
     46class MediaRecorderPrivate {
    4947public:
    50     ~MediaRecorderPrivate();
     48    virtual ~MediaRecorderPrivate() = default;
    5149
    5250    struct AudioVideoSelectedTracks {
    53         MediaStreamTrackPrivate* audioTrack { nullptr };
    54         MediaStreamTrackPrivate* videoTrack { nullptr };
     51        const MediaStreamTrackPrivate* audioTrack { nullptr };
     52        const MediaStreamTrackPrivate* videoTrack { nullptr };
    5553    };
    56     WEBCORE_EXPORT static AudioVideoSelectedTracks selectTracks(MediaStreamPrivate&);
     54    WEBCORE_EXPORT static AudioVideoSelectedTracks selectTracks(const MediaStreamPrivate&);
    5755
    5856    virtual void sampleBufferUpdated(const MediaStreamTrackPrivate&, MediaSample&) = 0;
     57    virtual void audioSamplesAvailable(const MediaStreamTrackPrivate&, const WTF::MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t) = 0;
    5958
    60     using FetchDataCallback = CompletionHandler<void(RefPtr<SharedBuffer>&&, const String& mimeType)>;
    61     virtual void fetchData(FetchDataCallback&&) = 0;
    62     virtual void stopRecording() = 0;
     59    virtual void fetchData(CompletionHandler<void(RefPtr<SharedBuffer>&&, const String& mimeType)>&&) = 0;
     60    virtual void stopRecording() { };
    6361
    6462    using ErrorCallback = Function<void(Optional<Exception>&&)>;
    … …  
    6664
    6765protected:
    68     void setAudioSource(RefPtr<RealtimeMediaSource>&&);
    69 
    70 protected:
    7166    ErrorCallback m_errorCallback;
    72 
    73 private:
    74     RefPtr<RealtimeMediaSource> m_audioSource;
    7567};
    76 
    77 inline void MediaRecorderPrivate::setAudioSource(RefPtr<RealtimeMediaSource>&& audioSource)
    78 {
    79     if (m_audioSource)
    80         m_audioSource->removeAudioSampleObserver(*this);
    81 
    82     m_audioSource = WTFMove(audioSource);
    83 
    84     if (m_audioSource)
    85         m_audioSource->addAudioSampleObserver(*this);
    86 }
    87 
    88 inline MediaRecorderPrivate::~MediaRecorderPrivate()
    89 {
    90     if (m_audioSource)
    91         m_audioSource->removeAudioSampleObserver(*this);
    92 }
    9368
    9469} // namespace WebCore

  • trunk/Source/WebCore/platform/mediarecorder/MediaRecorderPrivateAVFImpl.cpp

    r259816 r259824  
    3737namespace WebCore {
    3838
    39 std::unique_ptr<MediaRecorderPrivateAVFImpl> MediaRecorderPrivateAVFImpl::create(MediaStreamPrivate& stream)
     39std::unique_ptr<MediaRecorderPrivateAVFImpl> MediaRecorderPrivateAVFImpl::create(const MediaStreamPrivate& stream)
    4040{
    4141    // FIXME: we will need to implement support for multiple audio/video tracks
    … …  
    5252    if (selectedTracks.audioTrack)
    5353        audioTrackId = selectedTracks.audioTrack->id();
    54 
    5554    String videoTrackId;
    5655    if (selectedTracks.videoTrack)
    5756        videoTrackId = selectedTracks.videoTrack->id();
    5857
    59     auto recorder = makeUnique<MediaRecorderPrivateAVFImpl>(writer.releaseNonNull(), WTFMove(audioTrackId), WTFMove(videoTrackId));
    60     if (selectedTracks.audioTrack)
    61         recorder->setAudioSource(&selectedTracks.audioTrack->source());
    62     return recorder;
     58    return makeUnique<MediaRecorderPrivateAVFImpl>(writer.releaseNonNull(), WTFMove(audioTrackId), WTFMove(videoTrackId));
    6359}
    6460
    … …  
    7066}
    7167
    72 MediaRecorderPrivateAVFImpl::~MediaRecorderPrivateAVFImpl()
    73 {
    74     setAudioSource(nullptr);
    75 }
    76 
    7768void MediaRecorderPrivateAVFImpl::sampleBufferUpdated(const MediaStreamTrackPrivate& track, MediaSample& sampleBuffer)
    7869{
    … …  
    8273}
    8374
    84 void MediaRecorderPrivateAVFImpl::audioSamplesAvailable(const WTF::MediaTime& mediaTime, const PlatformAudioData& data, const AudioStreamDescription& description, size_t sampleCount)
     75void MediaRecorderPrivateAVFImpl::audioSamplesAvailable(const MediaStreamTrackPrivate& track, const WTF::MediaTime& mediaTime, const PlatformAudioData& data, const AudioStreamDescription& description, size_t sampleCount)
    8576{
     77    if (track.id() != m_recordedAudioTrackID)
     78        return;
    8679    ASSERT(is<WebAudioBufferList>(data));
    8780    ASSERT(description.platformDescription().type == PlatformDescription::CAAudioStreamBasicType);
    … …  
    9184void MediaRecorderPrivateAVFImpl::stopRecording()
    9285{
    93     setAudioSource(nullptr);
    9486    m_writer->stopRecording();
    9587}
    9688
    97 void MediaRecorderPrivateAVFImpl::fetchData(FetchDataCallback&& completionHandler)
     89void MediaRecorderPrivateAVFImpl::fetchData(CompletionHandler<void(RefPtr<SharedBuffer>&&, const String&)>&& completionHandler)
    9890{
    9991    m_writer->fetchData([completionHandler = WTFMove(completionHandler), mimeType = mimeType()](auto&& buffer) mutable {

  • trunk/Source/WebCore/platform/mediarecorder/MediaRecorderPrivateAVFImpl.h

    r259816 r259824  
    3434class MediaStreamPrivate;
    3535
    36 class MediaRecorderPrivateAVFImpl final
    37     : public MediaRecorderPrivate {
     36class MediaRecorderPrivateAVFImpl final : public MediaRecorderPrivate {
    3837    WTF_MAKE_FAST_ALLOCATED;
    3938public:
    40     static std::unique_ptr<MediaRecorderPrivateAVFImpl> create(MediaStreamPrivate&);
    41     ~MediaRecorderPrivateAVFImpl();
     39    static std::unique_ptr<MediaRecorderPrivateAVFImpl> create(const MediaStreamPrivate&);
    4240
    4341private:
    … …  
    4644    friend std::unique_ptr<MediaRecorderPrivateAVFImpl> std::make_unique<MediaRecorderPrivateAVFImpl>(Ref<MediaRecorderPrivateWriter>&&, String&&, String&&);
    4745
    48     // MediaRecorderPrivate
    4946    void sampleBufferUpdated(const MediaStreamTrackPrivate&, MediaSample&) final;
    50     void fetchData(FetchDataCallback&&) final;
    51     void audioSamplesAvailable(const WTF::MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t) final;
    52 
     47    void audioSamplesAvailable(const MediaStreamTrackPrivate&, const WTF::MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t) final;
     48    void fetchData(CompletionHandler<void(RefPtr<SharedBuffer>&&, const String&)>&&) final;
    5349    const String& mimeType();
    5450    void stopRecording();
    55 
     51   
    5652    Ref<MediaRecorderPrivateWriter> m_writer;
    5753    String m_recordedAudioTrackID;

  • trunk/Source/WebCore/platform/mediarecorder/MediaRecorderPrivateMock.cpp

    r259816 r259824  
    3434namespace WebCore {
    3535
    36 MediaRecorderPrivateMock::MediaRecorderPrivateMock(MediaStreamPrivate& stream)
     36void MediaRecorderPrivateMock::sampleBufferUpdated(const MediaStreamTrackPrivate& track, MediaSample&)
    3737{
    38     auto selectedTracks = MediaRecorderPrivate::selectTracks(stream);
    39     if (selectedTracks.audioTrack) {
    40         m_audioTrackID = selectedTracks.audioTrack->id();
    41         setAudioSource(&selectedTracks.audioTrack->source());
    42     }
    43     if (selectedTracks.videoTrack)
    44         m_videoTrackID = selectedTracks.videoTrack->id();
     38    generateMockString(track);
    4539}
    4640
    47 MediaRecorderPrivateMock::~MediaRecorderPrivateMock()
     41void MediaRecorderPrivateMock::audioSamplesAvailable(const MediaStreamTrackPrivate& track, const WTF::MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t)
    4842{
    49     setAudioSource(nullptr);
     43    generateMockString(track);
    5044}
    5145
    52 void MediaRecorderPrivateMock::stopRecording()
    53 {
    54     setAudioSource(nullptr);
    55 }
    56 
    57 void MediaRecorderPrivateMock::sampleBufferUpdated(const MediaStreamTrackPrivate&, MediaSample&)
     46void MediaRecorderPrivateMock::generateMockString(const MediaStreamTrackPrivate& track)
    5847{
    5948    auto locker = holdLock(m_bufferLock);
    60     m_buffer.append("Video Track ID: ");
    61     m_buffer.append(m_videoTrackID);
    62     generateMockCounterString();
    63 }
    64 
    65 void MediaRecorderPrivateMock::audioSamplesAvailable(const WTF::MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t)
    66 {
    67     auto locker = holdLock(m_bufferLock);
    68     m_buffer.append("Audio Track ID: ");
    69     m_buffer.append(m_audioTrackID);
    70     generateMockCounterString();
    71 }
    72 
    73 void MediaRecorderPrivateMock::generateMockCounterString()
    74 {
     49    if (track.type() == RealtimeMediaSource::Type::Audio)
     50        m_buffer.append("Audio Track ID: ");
     51    else
     52        m_buffer.append("Video Track ID: ");
     53    m_buffer.append(track.id());
    7554    m_buffer.append(" Counter: ");
    7655    m_buffer.appendNumber(++m_counter);
    … …  
    7857}
    7958
    80 void MediaRecorderPrivateMock::fetchData(FetchDataCallback&& completionHandler)
     59void MediaRecorderPrivateMock::fetchData(CompletionHandler<void(RefPtr<SharedBuffer>&&, const String&)>&& completionHandler)
    8160{
    8261    auto locker = holdLock(m_bufferLock);

  • trunk/Source/WebCore/platform/mediarecorder/MediaRecorderPrivateMock.h

    r259816 r259824  
    3535class MediaStreamTrackPrivate;
    3636
    37 class WEBCORE_EXPORT MediaRecorderPrivateMock final
    38     : public MediaRecorderPrivate {
    39 public:
    40     explicit MediaRecorderPrivateMock(MediaStreamPrivate&);
    41     ~MediaRecorderPrivateMock();
    42 
     37class WEBCORE_EXPORT MediaRecorderPrivateMock final : public MediaRecorderPrivate {
    4338private:
    44     // MediaRecorderPrivate
    4539    void sampleBufferUpdated(const MediaStreamTrackPrivate&, MediaSample&) final;
    46     void fetchData(FetchDataCallback&&) final;
    47     void audioSamplesAvailable(const WTF::MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t) final;
    48     void stopRecording() final;
    49 
     40    void audioSamplesAvailable(const MediaStreamTrackPrivate&, const WTF::MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t) final;
     41    void fetchData(CompletionHandler<void(RefPtr<SharedBuffer>&&, const String&)>&&) final;
    5042    const String& mimeType();
    51     void generateMockCounterString();
     43   
     44    void generateMockString(const MediaStreamTrackPrivate&);
    5245
    5346    mutable Lock m_bufferLock;
    5447    StringBuilder m_buffer;
    5548    unsigned m_counter { 0 };
    56     String m_audioTrackID;
    57     String m_videoTrackID;
    5849};
    5950

  • trunk/Source/WebCore/platform/mediastream/AudioTrackPrivateMediaStream.cpp

    r259816 r259824  
    3636AudioTrackPrivateMediaStream::AudioTrackPrivateMediaStream(MediaStreamTrackPrivate& track)
    3737    : m_streamTrack(track)
    38     , m_audioSource(track.source())
    3938    , m_id(track.id())
    4039    , m_label(track.label())
     40    , m_timelineOffset(MediaTime::invalidTime())
    4141    , m_renderer { AudioMediaStreamTrackRenderer::create() }
    4242{
    … …  
    6363
    6464    m_isCleared = true;
     65    streamTrack().removeObserver(*this);
     66
     67    m_renderer->clear();
     68}
     69
     70void AudioTrackPrivateMediaStream::playInternal()
     71{
     72    ASSERT(isMainThread());
    6573
    6674    if (m_isPlaying)
    67         m_audioSource->removeAudioSampleObserver(*this);
     75        return;
    6876
    69     streamTrack().removeObserver(*this);
    70     m_renderer->clear();
     77    m_isPlaying = true;
     78    m_autoPlay = false;
     79
     80    m_renderer->start();
    7181}
    7282
    7383void AudioTrackPrivateMediaStream::play()
    7484{
    75     m_shouldPlay = true;
    76     updateRenderer();
     85    playInternal();
    7786}
    7887
    7988void AudioTrackPrivateMediaStream::pause()
    8089{
    81     m_shouldPlay = false;
    82     updateRenderer();
    83 }
     90    ASSERT(isMainThread());
    8491
    85 void AudioTrackPrivateMediaStream::setMuted(bool muted)
    86 {
    87     m_muted = muted;
    88     updateRenderer();
     92    if (!m_isPlaying)
     93        return;
     94
     95    m_isPlaying = false;
     96    m_autoPlay = false;
     97
     98    m_renderer->stop();
    8999}
    90100
    … …  
    92102{
    93103    m_renderer->setVolume(volume);
    94     updateRenderer();
    95104}
    96105
    … …  
    101110
    102111// May get called on a background thread.
    103 void AudioTrackPrivateMediaStream::audioSamplesAvailable(const MediaTime& sampleTime, const PlatformAudioData& audioData, const AudioStreamDescription& description, size_t sampleCount)
     112void AudioTrackPrivateMediaStream::audioSamplesAvailable(MediaStreamTrackPrivate&, const MediaTime& sampleTime, const PlatformAudioData& audioData, const AudioStreamDescription& description, size_t sampleCount)
    104113{
     114    if (!m_isPlaying) {
     115        m_renderer->stop();
     116        return;
     117    }
     118
    105119    m_renderer->pushSamples(sampleTime, audioData, description, sampleCount);
     120
     121    if (m_autoPlay && !m_hasStartedAutoplay) {
     122        m_hasStartedAutoplay = true;
     123        callOnMainThread([this, protectedThis = makeRef(*this)] {
     124            if (m_autoPlay)
     125                playInternal();
     126        });
     127    }
    106128}
    107129
    108130void AudioTrackPrivateMediaStream::trackMutedChanged(MediaStreamTrackPrivate&)
    109131{
    110     updateRenderer();
     132    updateRendererMutedState();
    111133}
    112134
    113135void AudioTrackPrivateMediaStream::trackEnabledChanged(MediaStreamTrackPrivate&)
    114136{
    115     updateRenderer();
     137    updateRendererMutedState();
     138}
     139
     140void AudioTrackPrivateMediaStream::updateRendererMutedState()
     141{
     142    if (streamTrack().muted() || streamTrack().ended() || !streamTrack().enabled()) {
     143        pause();
     144        return;
     145    }
     146    play();
    116147}
    117148
    118149void AudioTrackPrivateMediaStream::trackEnded(MediaStreamTrackPrivate&)
    119150{
    120     updateRenderer();
    121 }
    122 
    123 void AudioTrackPrivateMediaStream::updateRenderer()
    124 {
    125     if (!m_shouldPlay || !volume() || m_muted || streamTrack().muted() || streamTrack().ended() || !streamTrack().enabled()) {
    126         stopRenderer();
    127         return;
    128     }
    129     startRenderer();
    130 }
    131 
    132 void AudioTrackPrivateMediaStream::startRenderer()
    133 {
    134     ASSERT(isMainThread());
    135     if (m_isPlaying)
    136         return;
    137 
    138     m_isPlaying = true;
    139     m_audioSource->addAudioSampleObserver(*this);
    140     m_renderer->start();
    141 }
    142 
    143 void AudioTrackPrivateMediaStream::stopRenderer()
    144 {
    145     ASSERT(isMainThread());
    146     if (!m_isPlaying)
    147         return;
    148 
    149     m_isPlaying = false;
    150     m_audioSource->removeAudioSampleObserver(*this);
    151     m_renderer->stop();
     151    pause();
    152152}
    153153

  • trunk/Source/WebCore/platform/mediastream/AudioTrackPrivateMediaStream.h

    r259816 r259824  
    3535class AudioMediaStreamTrackRenderer;
    3636
    37 class AudioTrackPrivateMediaStream final
    38     : public AudioTrackPrivate
    39     , private MediaStreamTrackPrivate::Observer
    40     , private RealtimeMediaSource::AudioSampleObserver {
     37class AudioTrackPrivateMediaStream final : public AudioTrackPrivate, private MediaStreamTrackPrivate::Observer {
    4138    WTF_MAKE_NONCOPYABLE(AudioTrackPrivateMediaStream)
    4239public:
    … …  
    5148    MediaStreamTrackPrivate& streamTrack() { return m_streamTrack.get(); }
    5249
     50    MediaTime timelineOffset() const { return m_timelineOffset; }
     51    void setTimelineOffset(const MediaTime& offset) { m_timelineOffset = offset; }
     52
    5353    void clear();
    5454
    … …  
    6060    float volume() const;
    6161
    62     void setMuted(bool);
     62    void setMuted(bool muted) { m_muted = muted; }
    6363    bool muted() const { return m_muted; }
    6464
    … …  
    7878
    7979    // MediaStreamTrackPrivate::Observer
     80    void audioSamplesAvailable(MediaStreamTrackPrivate&, const MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t) final;
    8081    void trackEnded(MediaStreamTrackPrivate&) final;
    8182    void trackMutedChanged(MediaStreamTrackPrivate&)  final;
    … …  
    8384    void trackSettingsChanged(MediaStreamTrackPrivate&) final { }
    8485
    85     // RealtimeMediaSource::AudioSampleObserver
    86     void audioSamplesAvailable(const MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t) final;
    87 
    88     void startRenderer();
    89     void stopRenderer();
    90     void updateRenderer();
     86    void playInternal();
     87    void updateRendererMutedState();
    9188
    9289    // Main thread writable members
    9390    bool m_isPlaying { false };
    94     bool m_shouldPlay { false };
     91    bool m_autoPlay { false };
    9592    bool m_muted { false };
    9693    bool m_isCleared { false };
    9794
    9895    Ref<MediaStreamTrackPrivate> m_streamTrack;
    99     Ref<RealtimeMediaSource> m_audioSource;
    10096    AtomString m_id;
    10197    AtomString m_label;
    10298    int m_index { 0 };
     99    MediaTime m_timelineOffset;
    103100
    104101    // Audio thread members
    105102    std::unique_ptr<AudioMediaStreamTrackRenderer> m_renderer;
     103    bool m_hasStartedAutoplay { false };
    106104};
    107105

  • trunk/Source/WebCore/platform/mediastream/MediaStreamPrivate.cpp

    r259816 r259824  
    122122}
    123123
    124 void MediaStreamPrivate::forEachTrack(const Function<void(MediaStreamTrackPrivate&)>& callback)
    125 {
    126     for (auto& track : m_trackSet.values())
    127         callback(*track);
    128 }
    129 
    130124void MediaStreamPrivate::updateActiveState(NotifyClientOption notifyClientOption)
    131125{

  • trunk/Source/WebCore/platform/mediastream/MediaStreamPrivate.h

    r259816 r259824  
    8585    bool hasTracks() const { return !m_trackSet.isEmpty(); }
    8686    void forEachTrack(const Function<void(const MediaStreamTrackPrivate&)>&) const;
    87     void forEachTrack(const Function<void(MediaStreamTrackPrivate&)>&);
    8887    MediaStreamTrackPrivate* activeVideoTrack() { return m_activeVideoTrack; }
    8988

  • trunk/Source/WebCore/platform/mediastream/MediaStreamTrackPrivate.cpp

    r259816 r259824  
    7979}
    8080
    81 void MediaStreamTrackPrivate::forEachObserver(const Function<void(Observer&)>& apply) const
    82 {
    83     ASSERT(isMainThread());
    84     for (auto* observer : copyToVector(m_observers)) {
     81void MediaStreamTrackPrivate::forEachObserver(const WTF::Function<void(Observer&)>& apply) const
     82{
     83    Vector<Observer*> observersCopy;
     84    {
     85        auto locker = holdLock(m_observersLock);
     86        observersCopy = copyToVector(m_observers);
     87    }
     88    for (auto* observer : observersCopy) {
     89        auto locker = holdLock(m_observersLock);
     90        // Make sure the observer has not been destroyed.
    8591        if (!m_observers.contains(observer))
    8692            continue;
    … …  
    9197void MediaStreamTrackPrivate::addObserver(MediaStreamTrackPrivate::Observer& observer)
    9298{
    93     ASSERT(isMainThread());
     99    auto locker = holdLock(m_observersLock);
    94100    m_observers.add(&observer);
    95101}
    … …  
    97103void MediaStreamTrackPrivate::removeObserver(MediaStreamTrackPrivate::Observer& observer)
    98104{
    99     ASSERT(isMainThread());
     105    auto locker = holdLock(m_observersLock);
    100106    m_observers.remove(&observer);
    101107}
    … …  
    256262}
    257263
    258 void MediaStreamTrackPrivate::hasStartedProducingAudioData()
    259 {
    260     if (m_haveProducedData)
    261         return;
    262     m_haveProducedData = true;
    263     updateReadyState();
     264// May get called on a background thread.
     265void MediaStreamTrackPrivate::audioSamplesAvailable(const MediaTime& mediaTime, const PlatformAudioData& data, const AudioStreamDescription& description, size_t sampleCount)
     266{
     267    if (!m_hasSentStartProducedData) {
     268        callOnMainThread([this, weakThis = makeWeakPtr(this)] {
     269            if (!weakThis)
     270                return;
     271
     272            if (!m_haveProducedData) {
     273                m_haveProducedData = true;
     274                updateReadyState();
     275            }
     276            m_hasSentStartProducedData = true;
     277        });
     278        return;
     279    }
     280
     281    forEachObserver([&](auto& observer) {
     282        observer.audioSamplesAvailable(*this, mediaTime, data, description, sampleCount);
     283    });
    264284}
    265285

  • trunk/Source/WebCore/platform/mediastream/MediaStreamTrackPrivate.h

    r259816 r259824  
    6363        virtual void sampleBufferUpdated(MediaStreamTrackPrivate&, MediaSample&) { };
    6464        virtual void readyStateChanged(MediaStreamTrackPrivate&) { };
     65
     66        // May get called on a background thread.
     67        virtual void audioSamplesAvailable(MediaStreamTrackPrivate&, const MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t) { };
    6568    };
    6669
    … …  
    98101
    99102    RealtimeMediaSource& source() { return m_source.get(); }
    100     const RealtimeMediaSource& source() const { return m_source.get(); }
    101103    WEBCORE_EXPORT RealtimeMediaSource::Type type() const;
    102104
    … …  
    131133    MediaStreamTrackPrivate(Ref<const Logger>&&, Ref<RealtimeMediaSource>&&, String&& id);
    132134
    133     // RealtimeMediaSource::Observer
     135    // RealtimeMediaSourceObserver
    134136    void sourceStarted() final;
    135137    void sourceStopped() final;
    … …  
    138140    bool preventSourceFromStopping() final;
    139141    void videoSampleAvailable(MediaSample&) final;
     142    void audioSamplesAvailable(const MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t) final;
    140143    void audioUnitWillStart() final;
    141     void hasStartedProducingAudioData() final;
    142144
    143145    void updateReadyState();

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

    r259816 r259824  
    6161}
    6262
    63 void RealtimeMediaSource::addAudioSampleObserver(RealtimeMediaSource::AudioSampleObserver& observer)
    64 {
    65     ASSERT(isMainThread());
    66     auto locker = holdLock(m_audioSampleObserversLock);
    67     m_audioSampleObservers.add(&observer);
    68 }
    69 
    70 void RealtimeMediaSource::removeAudioSampleObserver(RealtimeMediaSource::AudioSampleObserver& observer)
    71 {
    72     ASSERT(isMainThread());
    73     auto locker = holdLock(m_audioSampleObserversLock);
    74     m_audioSampleObservers.remove(&observer);
    75 }
    76 
    7763void RealtimeMediaSource::addObserver(RealtimeMediaSource::Observer& observer)
    7864{
    79     ASSERT(isMainThread());
     65    auto locker = holdLock(m_observersLock);
    8066    m_observers.add(&observer);
    8167}
    … …  
    8369void RealtimeMediaSource::removeObserver(RealtimeMediaSource::Observer& observer)
    8470{
    85     ASSERT(isMainThread());
     71    auto locker = holdLock(m_observersLock);
    8672    m_observers.remove(&observer);
    8773    if (m_observers.isEmpty())
    … …  
    131117}
    132118
    133 void RealtimeMediaSource::forEachObserver(const Function<void(Observer&)>& apply) const
    134 {
    135     ASSERT(isMainThread());
    136     for (auto* observer : copyToVector(m_observers)) {
     119void RealtimeMediaSource::forEachObserver(const WTF::Function<void(Observer&)>& apply) const
     120{
     121    Vector<Observer*> observersCopy;
     122    {
     123        auto locker = holdLock(m_observersLock);
     124        observersCopy = copyToVector(m_observers);
     125    }
     126    for (auto* observer : observersCopy) {
     127        auto locker = holdLock(m_observersLock);
     128        // Make sure the observer has not been destroyed.
    137129        if (!m_observers.contains(observer))
    138130            continue;
    … …  
    191183void RealtimeMediaSource::audioSamplesAvailable(const MediaTime& time, const PlatformAudioData& audioData, const AudioStreamDescription& description, size_t numberOfFrames)
    192184{
    193     if (!m_hasSentStartProducedAudioData) {
    194         callOnMainThread([this, weakThis = makeWeakPtr(this)] {
    195             if (!weakThis)
    196                 return;
    197             if (m_hasSentStartProducedAudioData)
    198                 return;
    199             m_hasSentStartProducedAudioData = true;
    200             forEachObserver([&](auto& observer) {
    201                 observer.hasStartedProducingAudioData();
    202             });
    203         });
    204     }
    205 
    206     auto locker = holdLock(m_audioSampleObserversLock);
    207     for (auto* observer : m_audioSampleObservers)
    208         observer->audioSamplesAvailable(time, audioData, description, numberOfFrames);
     185    forEachObserver([&](auto& observer) {
     186        observer.audioSamplesAvailable(time, audioData, description, numberOfFrames);
     187    });
    209188}
    210189

  • trunk/Source/WebCore/platform/mediastream/RealtimeMediaSource.h

    r259816 r259824  
    7070class WEBCORE_EXPORT RealtimeMediaSource
    7171    : public ThreadSafeRefCounted<RealtimeMediaSource, WTF::DestructionThread::MainRunLoop>
    72     , public CanMakeWeakPtr<RealtimeMediaSource, WeakPtrFactoryInitialization::Eager>
     72    , public CanMakeWeakPtr<RealtimeMediaSource>
    7373#if !RELEASE_LOG_DISABLED
    7474    , protected LoggerHelper
    … …  
    9393        virtual void videoSampleAvailable(MediaSample&) { }
    9494
    95         virtual void hasStartedProducingAudioData() { }
    96     };
    97     class AudioSampleObserver {
    98     public:
    99         virtual ~AudioSampleObserver() = default;
    100 
    10195        // May be called on a background thread.
    102         virtual void audioSamplesAvailable(const MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t /*numberOfFrames*/) = 0;
     96        virtual void audioSamplesAvailable(const MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t /*numberOfFrames*/) { }
    10397    };
    10498
    … …  
    137131    WEBCORE_EXPORT void addObserver(Observer&);
    138132    WEBCORE_EXPORT void removeObserver(Observer&);
    139 
    140     WEBCORE_EXPORT void addAudioSampleObserver(AudioSampleObserver&);
    141     WEBCORE_EXPORT void removeAudioSampleObserver(AudioSampleObserver&);
    142133
    143134    const IntSize size() const;
    … …  
    263254    Type m_type;
    264255    String m_name;
     256    mutable RecursiveLock m_observersLock;
    265257    HashSet<Observer*> m_observers;
    266 
    267     mutable RecursiveLock m_audioSampleObserversLock;
    268     HashSet<AudioSampleObserver*> m_audioSampleObservers;
    269 
    270258    IntSize m_size;
    271259    IntSize m_intrinsicSize;
    … …  
    285273    bool m_captureDidFailed { false };
    286274    bool m_isEnded { false };
    287     bool m_hasSentStartProducedAudioData { false };
    288275};
    289276

  • trunk/Source/WebCore/platform/mediastream/RealtimeOutgoingAudioSource.cpp

    r259816 r259824  
    4646RealtimeOutgoingAudioSource::~RealtimeOutgoingAudioSource()
    4747{
    48     ASSERT(!m_audioSource->hasObserver(*this));
     48ASSERT(!m_audioSource->hasObserver(*this));
    4949#if ASSERT_ENABLED
    5050    auto locker = holdLock(m_sinksLock);
    … …  
    5959    ASSERT(!m_audioSource->hasObserver(*this));
    6060    m_audioSource->addObserver(*this);
    61     m_audioSource->source().addAudioSampleObserver(*this);
    6261    initializeConverter();
    6362}
    … …  
    6564void RealtimeOutgoingAudioSource::unobserveSource()
    6665{
    67     m_audioSource->source().removeAudioSampleObserver(*this);
    6866    m_audioSource->removeObserver(*this);
    6967}

  • trunk/Source/WebCore/platform/mediastream/RealtimeOutgoingAudioSource.h

    r259816 r259824  
    5656    , public webrtc::AudioSourceInterface
    5757    , private MediaStreamTrackPrivate::Observer
    58     , private RealtimeMediaSource::AudioSampleObserver
    5958#if !RELEASE_LOG_DISABLED
    6059    , private LoggerHelper
    … …  
    110109    void sourceMutedChanged();
    111110    void sourceEnabledChanged();
     111    virtual void audioSamplesAvailable(const MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t) { };
    112112
    113113    virtual bool isReachingBufferedAudioDataHighLimit() { return false; };
    … …  
    119119    void trackMutedChanged(MediaStreamTrackPrivate&) final { sourceMutedChanged(); }
    120120    void trackEnabledChanged(MediaStreamTrackPrivate&) final { sourceEnabledChanged(); }
     121    void audioSamplesAvailable(MediaStreamTrackPrivate&, const MediaTime& mediaTime, const PlatformAudioData& data, const AudioStreamDescription& description, size_t sampleCount) { audioSamplesAvailable(mediaTime, data, description, sampleCount); }
    121122    void trackEnded(MediaStreamTrackPrivate&) final { }
    122123    void trackSettingsChanged(MediaStreamTrackPrivate&) final { }

  • trunk/Source/WebCore/platform/mediastream/WebAudioSourceProvider.h

    r259816 r259824  
    3333namespace WebCore {
    3434
    35 class WebAudioSourceProvider : public ThreadSafeRefCounted<WebAudioSourceProvider, WTF::DestructionThread::Main>, public AudioSourceProvider {
     35class WebAudioSourceProvider : public ThreadSafeRefCounted<WebAudioSourceProvider>, public AudioSourceProvider {
    3636};
    3737

  • trunk/Source/WebCore/platform/mediastream/gstreamer/GStreamerMediaStreamSource.cpp

    r259816 r259824  
    107107
    108108class WebKitMediaStreamTrackObserver
    109     : public MediaStreamTrackPrivate::Observer
    110     , public RealtimeMediaSource::AudioSampleObserver {
     109    : public MediaStreamTrackPrivate::Observer {
    111110    WTF_MAKE_FAST_ALLOCATED;
    112111public:
    … …  
    133132    }
    134133
    135     void audioSamplesAvailable(const MediaTime&, const PlatformAudioData& audioData, const AudioStreamDescription&, size_t) final
     134    void audioSamplesAvailable(MediaStreamTrackPrivate&, const MediaTime&, const PlatformAudioData& audioData, const AudioStreamDescription&, size_t) final
    136135    {
    137136        auto audiodata = static_cast<const GStreamerAudioData&>(audioData);
    … …  
    377376    GST_OBJECT_LOCK(self);
    378377    if (self->stream) {
    379         for (auto& track : self->stream->tracks()) {
    380             track->source().removeAudioSampleObserver(*self->mediaStreamTrackObserver.get());
     378        for (auto& track : self->stream->tracks())
    381379            track->removeObserver(*self->mediaStreamTrackObserver.get());
    382         }
     380
    383381        self->stream->removeObserver(*self->mediaStreamObserver);
    384382        self->stream = nullptr;
    … …  
    399397        GST_OBJECT_LOCK(self);
    400398        if (self->stream) {
    401             for (auto& track : self->stream->tracks()) {
    402                 track->source().removeAudioSampleObserver(*self->mediaStreamTrackObserver.get());
     399            for (auto& track : self->stream->tracks())
    403400                track->removeObserver(*self->mediaStreamTrackObserver.get());
    404             }
    405         } else if (self->track) {
    406             self->track->source().removeAudioSampleObserver(*self->mediaStreamTrackObserver.get());
     401        } else if (self->track)
    407402            self->track->removeObserver(*self->mediaStreamTrackObserver.get());
    408         }
    409403        GST_OBJECT_UNLOCK(self);
    410404    }
    … …  
    550544        webkitMediaStreamSrcAddPad(self, pad.get(), pad_template);
    551545
    552     if (observe_track) {
     546    if (observe_track)
    553547        track->addObserver(*self->mediaStreamTrackObserver.get());
    554         track->source().addAudioSampleObserver(*self->mediaStreamTrackObserver.get());
    555     }
     548
    556549    gst_element_sync_state_with_parent(element);
    557550    return TRUE;

  • trunk/Source/WebCore/platform/mediastream/mac/WebAudioSourceProviderAVFObjC.h

    r259816 r259824  
    4747class CAAudioStreamDescription;
    4848
    49 class WEBCORE_EXPORT WebAudioSourceProviderAVFObjC final
    50     : public WebAudioSourceProvider
    51     , MediaStreamTrackPrivate::Observer
    52     , RealtimeMediaSource::AudioSampleObserver {
     49class WEBCORE_EXPORT WebAudioSourceProviderAVFObjC final : public WebAudioSourceProvider, MediaStreamTrackPrivate::Observer {
    5350public:
    5451    static Ref<WebAudioSourceProviderAVFObjC> create(MediaStreamTrackPrivate&);
    … …  
    6663
    6764    // MediaStreamTrackPrivate::Observer
     65    void audioSamplesAvailable(MediaStreamTrackPrivate&, const MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t) final;
    6866    void trackEnded(MediaStreamTrackPrivate&) final { }
    6967    void trackMutedChanged(MediaStreamTrackPrivate&) final { }
    7068    void trackSettingsChanged(MediaStreamTrackPrivate&) final { }
    71     void trackEnabledChanged(MediaStreamTrackPrivate&) final;
    72 
    73     // RealtimeMediaSource::AudioSampleObserver
    74     void audioSamplesAvailable(const MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t) final;
     69    void trackEnabledChanged(MediaStreamTrackPrivate&) final { }
    7570
    7671    size_t m_listBufferSize { 0 };
    … …  
    8378    AudioSourceProviderClient* m_client { nullptr };
    8479    MediaStreamTrackPrivate* m_captureSource { nullptr };
    85     Ref<RealtimeMediaSource> m_source;
    8680    Lock m_mutex;
    8781    bool m_connected { false };
    88     bool m_enabled { true };
    8982};
    9083

  • trunk/Source/WebCore/platform/mediastream/mac/WebAudioSourceProviderAVFObjC.mm

    r259816 r259824  
    5555WebAudioSourceProviderAVFObjC::WebAudioSourceProviderAVFObjC(MediaStreamTrackPrivate& source)
    5656    : m_captureSource(&source)
    57     , m_source(source.source())
    58     , m_enabled(source.enabled())
    5957{
    60     m_source->addAudioSampleObserver(*this);
    6158}
    6259
    6360WebAudioSourceProviderAVFObjC::~WebAudioSourceProviderAVFObjC()
    6461{
    65     m_source->removeAudioSampleObserver(*this);
    66 
    6762    auto locker = holdLock(m_mutex);
    6863
    … …  
    171166}
    172167
    173 void WebAudioSourceProviderAVFObjC::trackEnabledChanged(MediaStreamTrackPrivate& track)
     168// May get called on a background thread.
     169void WebAudioSourceProviderAVFObjC::audioSamplesAvailable(MediaStreamTrackPrivate& track, const MediaTime&, const PlatformAudioData& data, const AudioStreamDescription& description, size_t frameCount)
    174170{
    175     m_enabled = track.enabled();
    176 }
    177 
    178 // May get called on a background thread.
    179 void WebAudioSourceProviderAVFObjC::audioSamplesAvailable(const MediaTime&, const PlatformAudioData& data, const AudioStreamDescription& description, size_t frameCount)
    180 {
    181     if (!m_enabled || !m_connected)
     171    if (!track.enabled())
    182172        return;
    183173

  • trunk/Source/WebCore/testing/Internals.cpp

    r259816 r259824  
    467467{
    468468#if ENABLE(MEDIA_STREAM)
    469     if (m_trackSource) {
    470         m_trackSource->removeObserver(*this);
    471         m_trackSource->removeAudioSampleObserver(*this);
    472     }
     469    if (m_track)
     470        m_track->source().removeObserver(*this);
    473471#endif
    474472}
    … …  
    16421640}
    16431641
    1644 static std::unique_ptr<MediaRecorderPrivate> createRecorderMockSource(MediaStreamPrivate& stream)
    1645 {
    1646     return std::unique_ptr<MediaRecorderPrivateMock>(new MediaRecorderPrivateMock(stream));
     1642static std::unique_ptr<MediaRecorderPrivate> createRecorderMockSource()
     1643{
     1644    return std::unique_ptr<MediaRecorderPrivateMock>(new MediaRecorderPrivateMock);
    16471645}
    16481646
    … …  
    49284926void Internals::observeMediaStreamTrack(MediaStreamTrack& track)
    49294927{
    4930     m_trackSource = &track.source();
    4931     m_trackSource->addObserver(*this);
    4932     m_trackSource->addAudioSampleObserver(*this);
     4928    m_track = &track;
     4929    m_track->source().addObserver(*this);
    49334930}
    49344931
    … …  
    49444941        return;
    49454942
    4946     auto& videoSettings = m_trackSource->settings();
     4943    auto& videoSettings = m_track->source().settings();
    49474944    if (!videoSettings.width() || !videoSettings.height())
    49484945        return;

  • trunk/Source/WebCore/testing/Internals.h

    r259816 r259824  
    124124#if ENABLE(MEDIA_STREAM)
    125125    , private RealtimeMediaSource::Observer
    126     , private RealtimeMediaSource::AudioSampleObserver
    127126#endif
    128127    {
    … …  
    971970    ExceptionOr<RenderedDocumentMarker*> markerAt(Node&, const String& markerType, unsigned index);
    972971
     972    // RealtimeMediaSource::Observer API
    973973#if ENABLE(MEDIA_STREAM)
    974     // RealtimeMediaSource::Observer API
    975974    void videoSampleAvailable(MediaSample&) final;
    976     // RealtimeMediaSource::AudioSampleObserver API
    977975    void audioSamplesAvailable(const MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t) final { m_trackAudioSampleCount++; }
    978976
    … …  
    980978    unsigned long m_trackVideoSampleCount { 0 };
    981979    unsigned long m_trackAudioSampleCount { 0 };
    982     RefPtr<RealtimeMediaSource> m_trackSource;
     980    RefPtr<MediaStreamTrack> m_track;
    983981    std::unique_ptr<TrackFramePromise> m_nextTrackFramePromise;
    984982#endif

  • trunk/Source/WebKit/ChangeLog

    r259820 r259824  
     12020-04-09  Jacob Uphoff  <jacob_uphoff@apple.com>
     2
     3        Unreviewed, reverting r259816.
     4
     5        This commit broke the webkit build for macOS and iOS
     6
     7        Reverted changeset:
     8
     9        "Introduce a RealtimeMediaSource observer dedicated to
     10        receiving audio samples"
     11        https://bugs.webkit.org/show_bug.cgi?id=210180
     12        https://trac.webkit.org/changeset/259816
     13
    1142020-04-09  Simon Fraser  <simon.fraser@apple.com>
    215

  • trunk/Source/WebKit/UIProcess/Cocoa/UserMediaCaptureManagerProxy.cpp

    r259816 r259824  
    5151class UserMediaCaptureManagerProxy::SourceProxy
    5252    : public RealtimeMediaSource::Observer
    53     , public RealtimeMediaSource::AudioSampleObserver
    5453    , public SharedRingBufferStorage::Client {
    5554    WTF_MAKE_FAST_ALLOCATED;
    … …  
    6261    {
    6362        m_source->addObserver(*this);
    64         m_source->addAudioSampleObserver(*this);
    6563    }
    6664
    … …  
    6866    {
    6967        storage().invalidate();
    70         m_source->removeAudioSampleObserver(*this);
    7168        m_source->removeObserver(*this);
    7269    }

  • trunk/Source/WebKit/WebProcess/GPU/webrtc/MediaRecorderPrivate.cpp

    r259816 r259824  
    4444using namespace WebCore;
    4545
    46 MediaRecorderPrivate::MediaRecorderPrivate(MediaStreamPrivate& stream)
     46MediaRecorderPrivate::MediaRecorderPrivate(const MediaStreamPrivate& stream)
    4747    : m_identifier(MediaRecorderIdentifier::generate())
    4848    , m_connection(WebProcess::singleton().ensureGPUProcessConnection().connection())
    … …  
    6565    }
    6666
    67     m_connection->sendWithAsyncReply(Messages::RemoteMediaRecorderManager::CreateRecorder { m_identifier, !!selectedTracks.audioTrack, width, height }, [this, weakThis = makeWeakPtr(this), audioTrack = makeRefPtr(selectedTracks.audioTrack)](auto&& exception) {
    68         if (!weakThis)
     67    m_connection->sendWithAsyncReply(Messages::RemoteMediaRecorderManager::CreateRecorder { m_identifier, !!selectedTracks.audioTrack, width, height }, [this, weakThis = makeWeakPtr(this)](auto&& exception) {
     68        if (!weakThis || !exception)
    6969            return;
    70         if (exception)
    71             return m_errorCallback(Exception { exception->code, WTFMove(exception->message) });
    72         if (audioTrack)
    73             setAudioSource(&audioTrack->source());
     70        m_errorCallback(Exception { exception->code, WTFMove(exception->message) });
    7471    }, 0);
    7572}
    … …  
    7774MediaRecorderPrivate::~MediaRecorderPrivate()
    7875{
    79     setAudioSource(nullptr);
    8076    m_connection->send(Messages::RemoteMediaRecorderManager::ReleaseRecorder { m_identifier }, 0);
    8177}
    … …  
    9389}
    9490
    95 void MediaRecorderPrivate::audioSamplesAvailable(const MediaTime& time, const PlatformAudioData& audioData, const AudioStreamDescription& description, size_t numberOfFrames)
     91void MediaRecorderPrivate::audioSamplesAvailable(const WebCore::MediaStreamTrackPrivate& track, const MediaTime& time, const PlatformAudioData& audioData, const AudioStreamDescription& description, size_t numberOfFrames)
    9692{
     93    if (track.id() != m_recordedAudioTrackID)
     94        return;
     95
    9796    if (m_description != description) {
    9897        ASSERT(description.platformDescription().type == PlatformDescription::CAAudioStreamBasicType);
    … …  
    132131void MediaRecorderPrivate::stopRecording()
    133132{
    134     setAudioSource(nullptr);
    135133    m_connection->send(Messages::RemoteMediaRecorder::StopRecording { }, m_identifier);
    136134}

  • trunk/Source/WebKit/WebProcess/GPU/webrtc/MediaRecorderPrivate.h

    r259816 r259824  
    4545namespace WebKit {
    4646
    47 class MediaRecorderPrivate final
    48     : public WebCore::MediaRecorderPrivate
    49     , public SharedRingBufferStorage::Client
    50     , public CanMakeWeakPtr<MediaRecorderPrivate> {
     47class MediaRecorderPrivate final : public WebCore::MediaRecorderPrivate, public SharedRingBufferStorage::Client, public CanMakeWeakPtr<MediaRecorderPrivate> {
    5148    WTF_MAKE_FAST_ALLOCATED;
    5249public:
    53     explicit MediaRecorderPrivate(WebCore::MediaStreamPrivate&);
     50    explicit MediaRecorderPrivate(const WebCore::MediaStreamPrivate&);
    5451    ~MediaRecorderPrivate();
    5552
    … …  
    5754    // WebCore::MediaRecorderPrivate
    5855    void sampleBufferUpdated(const WebCore::MediaStreamTrackPrivate&, WebCore::MediaSample&) final;
     56    void audioSamplesAvailable(const WebCore::MediaStreamTrackPrivate&, const WTF::MediaTime&, const WebCore::PlatformAudioData&, const WebCore::AudioStreamDescription&, size_t) final;
    5957    void fetchData(CompletionHandler<void(RefPtr<WebCore::SharedBuffer>&&, const String& mimeType)>&&) final;
    6058    void stopRecording() final;
    61     void audioSamplesAvailable(const WTF::MediaTime&, const WebCore::PlatformAudioData&, const WebCore::AudioStreamDescription&, size_t) final;
    6259
    6360    // SharedRingBufferStorage::Client

  • trunk/Source/WebKit/WebProcess/GPU/webrtc/MediaRecorderProvider.cpp

    r259816 r259824  
    3535using namespace WebCore;
    3636
    37 std::unique_ptr<WebCore::MediaRecorderPrivate> MediaRecorderProvider::createMediaRecorderPrivate(MediaStreamPrivate& stream)
     37std::unique_ptr<WebCore::MediaRecorderPrivate> MediaRecorderProvider::createMediaRecorderPrivate(const MediaStreamPrivate& stream)
    3838{
    3939#if ENABLE(GPU_PROCESS)

  • trunk/Source/WebKit/WebProcess/GPU/webrtc/MediaRecorderProvider.h

    r259816 r259824  
    3636private:
    3737#if ENABLE(MEDIA_STREAM) && PLATFORM(COCOA)
    38     std::unique_ptr<WebCore::MediaRecorderPrivate> createMediaRecorderPrivate(WebCore::MediaStreamPrivate&) final;
     38    std::unique_ptr<WebCore::MediaRecorderPrivate> createMediaRecorderPrivate(const WebCore::MediaStreamPrivate&) final;
    3939#endif
    4040};
Note: See TracChangeset for help on using the changeset viewer.