Changeset 252950 in webkit


Ignore:
Timestamp:
Nov 29, 2019 12:27:08 PM (4 years ago)
Author:
cturner@igalia.com
Message:

[GStreamer] MediaPlayerPrivateGStreamer style cleanups
https://bugs.webkit.org/show_bug.cgi?id=204617

Reviewed by Xabier Rodriguez-Calvar.

Follow-up commit to bug 204352 addressing style issues in the
existing player code. The main issues addressed are naming
violations, adding final to types not overridden and organizing
better the scope of names in the classes.

Covered by existing tests.

  • platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:

(WebCore::initializeDebugCategory):
(WebCore::MediaPlayerPrivateGStreamer::loadFull):
(WebCore::MediaPlayerPrivateGStreamer::prepareToPlay):
(WebCore::MediaPlayerPrivateGStreamer::play):
(WebCore::MediaPlayerPrivateGStreamer::pause):
(WebCore::MediaPlayerPrivateGStreamer::paused const):
(WebCore::MediaPlayerPrivateGStreamer::doSeek):
(WebCore::MediaPlayerPrivateGStreamer::seek):
(WebCore::MediaPlayerPrivateGStreamer::updatePlaybackRate):
(WebCore::MediaPlayerPrivateGStreamer::currentMediaTime const):
(WebCore::MediaPlayerPrivateGStreamer::setRate):
(WebCore::MediaPlayerPrivateGStreamer::setPreservesPitch):
(WebCore::MediaPlayerPrivateGStreamer::setPreload):
(WebCore::MediaPlayerPrivateGStreamer::buffered const):
(WebCore::MediaPlayerPrivateGStreamer::maxMediaTimeSeekable const):
(WebCore::MediaPlayerPrivateGStreamer::maxTimeLoaded const):
(WebCore::MediaPlayerPrivateGStreamer::didLoadingProgress const):
(WebCore::MediaPlayerPrivateGStreamer::totalBytes const):
(WebCore::MediaPlayerPrivateGStreamer::changePipelineState):
(WebCore::MediaPlayerPrivateGStreamer::notifyPlayerOfVideo):
(WebCore::MediaPlayerPrivateGStreamer::notifyPlayerOfAudio):
(WebCore::MediaPlayerPrivateGStreamer::notifyPlayerOfText):
(WebCore::MediaPlayerPrivateGStreamer::platformDuration const):
(WebCore::MediaPlayerPrivateGStreamer::isMuted const):
(WebCore::MediaPlayerPrivateGStreamer::commitLoad):
(WebCore::MediaPlayerPrivateGStreamer::fillTimerFired):
(WebCore::MediaPlayerPrivateGStreamer::loadingFailed):
(WebCore::MediaPlayerPrivateGStreamer::playbackPosition const):
(WebCore::MediaPlayerPrivateGStreamer::enableTrack):
(WebCore::MediaPlayerPrivateGStreamer::updateTracks):
(WebCore::MediaPlayerPrivateGStreamer::handleSyncMessage):
(WebCore::MediaPlayerPrivateGStreamer::naturalSize const):
(WebCore::MediaPlayerPrivateGStreamer::setMuted):
(WebCore::MediaPlayerPrivateGStreamer::handleMessage):
(WebCore::MediaPlayerPrivateGStreamer::updateBufferingStatus):
(WebCore::MediaPlayerPrivateGStreamer::processMpegTsSection):
(WebCore::MediaPlayerPrivateGStreamer::processTableOfContentsEntry):
(WebCore::MediaPlayerPrivateGStreamer::asyncStateChangeDone):
(WebCore::MediaPlayerPrivateGStreamer::updateStates):
(WebCore::MediaPlayerPrivateGStreamer::loadNextLocation):
(WebCore::MediaPlayerPrivateGStreamer::didEnd):
(WebCore::MediaPlayerPrivateGStreamer::updateDownloadBufferingFlag):
(WebCore::MediaPlayerPrivateGStreamer::createGSTPlayBin):
(WebCore::MediaPlayerPrivateGStreamer::canSaveMediaData const):
(WebCore::MediaPlayerPrivateGStreamer::acceleratedRenderingStateChanged):
(WebCore::MediaPlayerPrivateGStreamer::pushTextureToCompositor):
(WebCore::MediaPlayerPrivateGStreamer::triggerRepaint):
(WebCore::MediaPlayerPrivateGStreamer::cancelRepaint):
(WebCore::MediaPlayerPrivateGStreamer::paint):
(WebCore::MediaPlayerPrivateGStreamer::copyVideoTextureToPlatformTexture):
(WebCore::MediaPlayerPrivateGStreamer::nativeImageForCurrentTime):
(WebCore::MediaPlayerPrivateGStreamer::movieLoadType const):
(WebCore::MediaPlayerPrivateGStreamer::createVideoSink):
(WebCore::MediaPlayerPrivateGStreamer::decodedFrameCount const):
(WebCore::MediaPlayerPrivateGStreamer::droppedFrameCount const):
(WebCore::MediaPlayerPrivateGStreamer::attemptToDecryptWithLocalInstance):
(WebCore::MediaPlayerPrivateGStreamer::setWaitingForKey):
(WebCore::MediaPlayerPrivateGStreamer::initializeDebugCategory): Deleted.
(WebCore::MediaPlayerPrivateGStreamer::sizeChanged): Deleted.
(WebCore::MediaPlayerPrivateGStreamer::muted const): Deleted.

  • platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h:

(WebCore::MediaPlayerPrivateGStreamer::pipeline const):
(WebCore::MediaPlayerPrivateGStreamer::mediaPlayer const): Deleted.
(WebCore::MediaPlayerPrivateGStreamer::isLiveStream const): Deleted.

  • platform/graphics/gstreamer/mse/MediaPlayerPrivateGStreamerMSE.cpp:

(WebCore::MediaPlayerPrivateGStreamerMSE::pause):
(WebCore::MediaPlayerPrivateGStreamerMSE::durationMediaTime const):
(WebCore::MediaPlayerPrivateGStreamerMSE::seek):
(WebCore::MediaPlayerPrivateGStreamerMSE::doSeek):
(WebCore::MediaPlayerPrivateGStreamerMSE::maybeFinishSeek):
(WebCore::MediaPlayerPrivateGStreamerMSE::seeking const):
(WebCore::MediaPlayerPrivateGStreamerMSE::waitForSeekCompleted):
(WebCore::MediaPlayerPrivateGStreamerMSE::updateStates):
(WebCore::MediaPlayerPrivateGStreamerMSE::asyncStateChangeDone):
(WebCore::MediaPlayerPrivateGStreamerMSE::maxMediaTimeSeekable const):

  • platform/graphics/gstreamer/mse/MediaPlayerPrivateGStreamerMSE.h:
  • platform/graphics/gstreamer/mse/MediaSourceClientGStreamerMSE.cpp:

(WebCore::MediaSourceClientGStreamerMSE::flush):

Location:
trunk/Source/WebCore
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r252947 r252950  
     12019-11-29  Charlie Turner  <cturner@igalia.com>
     2
     3        [GStreamer] MediaPlayerPrivateGStreamer style cleanups
     4        https://bugs.webkit.org/show_bug.cgi?id=204617
     5
     6        Reviewed by Xabier Rodriguez-Calvar.
     7
     8        Follow-up commit to bug 204352 addressing style issues in the
     9        existing player code. The main issues addressed are naming
     10        violations, adding final to types not overridden and organizing
     11        better the scope of names in the classes.
     12
     13        Covered by existing tests.
     14
     15        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:
     16        (WebCore::initializeDebugCategory):
     17        (WebCore::MediaPlayerPrivateGStreamer::loadFull):
     18        (WebCore::MediaPlayerPrivateGStreamer::prepareToPlay):
     19        (WebCore::MediaPlayerPrivateGStreamer::play):
     20        (WebCore::MediaPlayerPrivateGStreamer::pause):
     21        (WebCore::MediaPlayerPrivateGStreamer::paused const):
     22        (WebCore::MediaPlayerPrivateGStreamer::doSeek):
     23        (WebCore::MediaPlayerPrivateGStreamer::seek):
     24        (WebCore::MediaPlayerPrivateGStreamer::updatePlaybackRate):
     25        (WebCore::MediaPlayerPrivateGStreamer::currentMediaTime const):
     26        (WebCore::MediaPlayerPrivateGStreamer::setRate):
     27        (WebCore::MediaPlayerPrivateGStreamer::setPreservesPitch):
     28        (WebCore::MediaPlayerPrivateGStreamer::setPreload):
     29        (WebCore::MediaPlayerPrivateGStreamer::buffered const):
     30        (WebCore::MediaPlayerPrivateGStreamer::maxMediaTimeSeekable const):
     31        (WebCore::MediaPlayerPrivateGStreamer::maxTimeLoaded const):
     32        (WebCore::MediaPlayerPrivateGStreamer::didLoadingProgress const):
     33        (WebCore::MediaPlayerPrivateGStreamer::totalBytes const):
     34        (WebCore::MediaPlayerPrivateGStreamer::changePipelineState):
     35        (WebCore::MediaPlayerPrivateGStreamer::notifyPlayerOfVideo):
     36        (WebCore::MediaPlayerPrivateGStreamer::notifyPlayerOfAudio):
     37        (WebCore::MediaPlayerPrivateGStreamer::notifyPlayerOfText):
     38        (WebCore::MediaPlayerPrivateGStreamer::platformDuration const):
     39        (WebCore::MediaPlayerPrivateGStreamer::isMuted const):
     40        (WebCore::MediaPlayerPrivateGStreamer::commitLoad):
     41        (WebCore::MediaPlayerPrivateGStreamer::fillTimerFired):
     42        (WebCore::MediaPlayerPrivateGStreamer::loadingFailed):
     43        (WebCore::MediaPlayerPrivateGStreamer::playbackPosition const):
     44        (WebCore::MediaPlayerPrivateGStreamer::enableTrack):
     45        (WebCore::MediaPlayerPrivateGStreamer::updateTracks):
     46        (WebCore::MediaPlayerPrivateGStreamer::handleSyncMessage):
     47        (WebCore::MediaPlayerPrivateGStreamer::naturalSize const):
     48        (WebCore::MediaPlayerPrivateGStreamer::setMuted):
     49        (WebCore::MediaPlayerPrivateGStreamer::handleMessage):
     50        (WebCore::MediaPlayerPrivateGStreamer::updateBufferingStatus):
     51        (WebCore::MediaPlayerPrivateGStreamer::processMpegTsSection):
     52        (WebCore::MediaPlayerPrivateGStreamer::processTableOfContentsEntry):
     53        (WebCore::MediaPlayerPrivateGStreamer::asyncStateChangeDone):
     54        (WebCore::MediaPlayerPrivateGStreamer::updateStates):
     55        (WebCore::MediaPlayerPrivateGStreamer::loadNextLocation):
     56        (WebCore::MediaPlayerPrivateGStreamer::didEnd):
     57        (WebCore::MediaPlayerPrivateGStreamer::updateDownloadBufferingFlag):
     58        (WebCore::MediaPlayerPrivateGStreamer::createGSTPlayBin):
     59        (WebCore::MediaPlayerPrivateGStreamer::canSaveMediaData const):
     60        (WebCore::MediaPlayerPrivateGStreamer::acceleratedRenderingStateChanged):
     61        (WebCore::MediaPlayerPrivateGStreamer::pushTextureToCompositor):
     62        (WebCore::MediaPlayerPrivateGStreamer::triggerRepaint):
     63        (WebCore::MediaPlayerPrivateGStreamer::cancelRepaint):
     64        (WebCore::MediaPlayerPrivateGStreamer::paint):
     65        (WebCore::MediaPlayerPrivateGStreamer::copyVideoTextureToPlatformTexture):
     66        (WebCore::MediaPlayerPrivateGStreamer::nativeImageForCurrentTime):
     67        (WebCore::MediaPlayerPrivateGStreamer::movieLoadType const):
     68        (WebCore::MediaPlayerPrivateGStreamer::createVideoSink):
     69        (WebCore::MediaPlayerPrivateGStreamer::decodedFrameCount const):
     70        (WebCore::MediaPlayerPrivateGStreamer::droppedFrameCount const):
     71        (WebCore::MediaPlayerPrivateGStreamer::attemptToDecryptWithLocalInstance):
     72        (WebCore::MediaPlayerPrivateGStreamer::setWaitingForKey):
     73        (WebCore::MediaPlayerPrivateGStreamer::initializeDebugCategory): Deleted.
     74        (WebCore::MediaPlayerPrivateGStreamer::sizeChanged): Deleted.
     75        (WebCore::MediaPlayerPrivateGStreamer::muted const): Deleted.
     76        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h:
     77        (WebCore::MediaPlayerPrivateGStreamer::pipeline const):
     78        (WebCore::MediaPlayerPrivateGStreamer::mediaPlayer const): Deleted.
     79        (WebCore::MediaPlayerPrivateGStreamer::isLiveStream const): Deleted.
     80        * platform/graphics/gstreamer/mse/MediaPlayerPrivateGStreamerMSE.cpp:
     81        (WebCore::MediaPlayerPrivateGStreamerMSE::pause):
     82        (WebCore::MediaPlayerPrivateGStreamerMSE::durationMediaTime const):
     83        (WebCore::MediaPlayerPrivateGStreamerMSE::seek):
     84        (WebCore::MediaPlayerPrivateGStreamerMSE::doSeek):
     85        (WebCore::MediaPlayerPrivateGStreamerMSE::maybeFinishSeek):
     86        (WebCore::MediaPlayerPrivateGStreamerMSE::seeking const):
     87        (WebCore::MediaPlayerPrivateGStreamerMSE::waitForSeekCompleted):
     88        (WebCore::MediaPlayerPrivateGStreamerMSE::updateStates):
     89        (WebCore::MediaPlayerPrivateGStreamerMSE::asyncStateChangeDone):
     90        (WebCore::MediaPlayerPrivateGStreamerMSE::maxMediaTimeSeekable const):
     91        * platform/graphics/gstreamer/mse/MediaPlayerPrivateGStreamerMSE.h:
     92        * platform/graphics/gstreamer/mse/MediaSourceClientGStreamerMSE.cpp:
     93        (WebCore::MediaSourceClientGStreamerMSE::flush):
     94
    1952019-11-29  Zalan Bujtas  <zalan@apple.com>
    296
  • trunk/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp

    r252938 r252950  
    337337#endif
    338338
    339 void MediaPlayerPrivateGStreamer::initializeDebugCategory()
    340 {
    341     GST_DEBUG_CATEGORY_INIT(webkit_media_player_debug, "webkitmediaplayer", 0, "WebKit media player");
     339static void initializeDebugCategory()
     340{
     341    static std::once_flag onceFlag;
     342    std::call_once(onceFlag, [] {
     343        GST_DEBUG_CATEGORY_INIT(webkit_media_player_debug, "webkitmediaplayer", 0, "WebKit media player");
     344    });
    342345}
    343346
     
    498501    if (m_preload == MediaPlayer::None) {
    499502        GST_INFO_OBJECT(pipeline(), "Delaying load.");
    500         m_delayingLoad = true;
     503        m_isDelayingLoad = true;
    501504    }
    502505
     
    507510    m_readyState = MediaPlayer::HaveNothing;
    508511    m_player->readyStateChanged();
    509     m_volumeAndMuteInitialized = false;
     512    m_areVolumeAndMuteInitialized = false;
    510513    m_hasTaintedOrigin = WTF::nullopt;
    511514
    512     if (!m_delayingLoad)
     515    if (!m_isDelayingLoad)
    513516        commitLoad();
    514517}
     
    542545#endif
    543546
    544 void MediaPlayerPrivateGStreamer::commitLoad()
    545 {
    546     ASSERT(!m_delayingLoad);
    547     GST_DEBUG_OBJECT(pipeline(), "Committing load.");
    548 
    549     // GStreamer needs to have the pipeline set to a paused state to
    550     // start providing anything useful.
    551     changePipelineState(GST_STATE_PAUSED);
    552 
    553     updateDownloadBufferingFlag();
    554     updateStates();
    555 }
    556 
    557547void MediaPlayerPrivateGStreamer::cancelLoad()
    558548{
     
    568558    GST_DEBUG_OBJECT(pipeline(), "Prepare to play");
    569559    m_preload = MediaPlayer::Auto;
    570     if (m_delayingLoad) {
    571         m_delayingLoad = false;
     560    if (m_isDelayingLoad) {
     561        m_isDelayingLoad = false;
    572562        commitLoad();
    573563    }
     
    577567{
    578568    if (!m_playbackRate) {
    579         m_playbackRatePause = true;
     569        m_isPlaybackRatePaused = true;
    580570        return;
    581571    }
     
    583573    if (changePipelineState(GST_STATE_PLAYING)) {
    584574        m_isEndReached = false;
    585         m_delayingLoad = false;
     575        m_isDelayingLoad = false;
    586576        m_preload = MediaPlayer::Auto;
    587577        updateDownloadBufferingFlag();
     
    593583void MediaPlayerPrivateGStreamer::pause()
    594584{
    595     m_playbackRatePause = false;
     585    m_isPlaybackRatePaused = false;
    596586    GstState currentState, pendingState;
    597587    gst_element_get_state(m_pipeline.get(), &currentState, &pendingState, 0);
     
    615605    }
    616606
    617     if (m_playbackRatePause) {
     607    if (m_isPlaybackRatePaused) {
    618608        GST_DEBUG_OBJECT(pipeline(), "Playback rate is 0, simulating PAUSED state");
    619609        return false;
     
    634624    if (rate < 0) {
    635625        startTime = MediaTime::zeroTime();
    636         // If we are at beginning of media, start from the end to
    637         // avoid immediate EOS.
    638         if (position < MediaTime::zeroTime())
    639             endTime = durationMediaTime();
    640         else
    641             endTime = position;
     626        // If we are at beginning of media, start from the end to avoid immediate EOS.
     627        endTime = position < MediaTime::zeroTime() ? durationMediaTime() : position;
    642628    }
    643629
     
    651637void MediaPlayerPrivateGStreamer::seek(const MediaTime& mediaTime)
    652638{
    653     if (!m_pipeline)
    654         return;
    655 
    656     if (m_errorOccured)
     639    if (!m_pipeline || m_didErrorOccur)
    657640        return;
    658641
     
    667650    MediaTime time = std::min(mediaTime, durationMediaTime());
    668651
    669     if (isLiveStream()) {
     652    if (m_isLiveStream) {
    670653        GST_DEBUG_OBJECT(pipeline(), "[Seek] Live stream seek unhandled");
    671654        return;
     
    674657    GST_INFO_OBJECT(pipeline(), "[Seek] seeking to %s", toString(time).utf8().data());
    675658
    676     if (m_seeking) {
     659    if (m_isSeeking) {
    677660        m_timeOfOverlappingSeek = time;
    678         if (m_seekIsPending) {
     661        if (m_isSeekPending) {
    679662            m_seekTime = time;
    680663            return;
     
    689672    }
    690673    if (getStateResult == GST_STATE_CHANGE_ASYNC || state < GST_STATE_PAUSED || m_isEndReached) {
    691         m_seekIsPending = true;
     674        m_isSeekPending = true;
    692675        if (m_isEndReached) {
    693676            GST_DEBUG_OBJECT(pipeline(), "[Seek] reset pipeline");
    694             m_resetPipeline = true;
     677            m_shouldResetPipeline = true;
    695678            if (!changePipelineState(GST_STATE_PAUSED))
    696679                loadingFailed(MediaPlayer::Empty);
     
    704687    }
    705688
    706     m_seeking = true;
     689    m_isSeeking = true;
    707690    m_seekTime = time;
    708691    m_isEndReached = false;
     
    711694void MediaPlayerPrivateGStreamer::updatePlaybackRate()
    712695{
    713     if (!m_changingRate)
     696    if (!m_isChangingRate)
    714697        return;
    715698
     
    717700
    718701    // Mute the sound if the playback rate is negative or too extreme and audio pitch is not adjusted.
    719     bool mute = m_playbackRate <= 0 || (!m_preservesPitch && (m_playbackRate < 0.8 || m_playbackRate > 2));
     702    bool mute = m_playbackRate <= 0 || (!m_shouldPreservePitch && (m_playbackRate < 0.8 || m_playbackRate > 2));
    720703
    721704    GST_INFO_OBJECT(pipeline(), mute ? "Need to mute audio" : "Do not need to mute audio");
     
    729712    }
    730713
    731     if (m_playbackRatePause) {
    732         GstState state;
    733         GstState pending;
     714    if (m_isPlaybackRatePaused) {
     715        GstState state, pending;
    734716
    735717        gst_element_get_state(m_pipeline.get(), &state, &pending, 0);
    736718        if (state != GST_STATE_PLAYING && pending != GST_STATE_PLAYING)
    737719            changePipelineState(GST_STATE_PLAYING);
    738         m_playbackRatePause = false;
    739     }
    740 
    741     m_changingRate = false;
     720        m_isPlaybackRatePaused = false;
     721    }
     722
     723    m_isChangingRate = false;
    742724    m_player->rateChanged();
    743 }
    744 
    745 MediaTime MediaPlayerPrivateGStreamer::platformDuration() const
    746 {
    747     if (!m_pipeline)
    748         return MediaTime::invalidTime();
    749 
    750     GST_TRACE_OBJECT(pipeline(), "errorOccured: %s, pipeline state: %s", boolForPrinting(m_errorOccured), gst_element_state_get_name(GST_STATE(m_pipeline.get())));
    751     if (m_errorOccured)
    752         return MediaTime::invalidTime();
    753 
    754     // The duration query would fail on a not-prerolled pipeline.
    755     if (GST_STATE(m_pipeline.get()) < GST_STATE_PAUSED)
    756         return MediaTime::invalidTime();
    757 
    758     int64_t duration = 0;
    759     if (!gst_element_query_duration(m_pipeline.get(), GST_FORMAT_TIME, &duration) || !GST_CLOCK_TIME_IS_VALID(duration)) {
    760         GST_DEBUG_OBJECT(pipeline(), "Time duration query failed for %s", m_url.string().utf8().data());
    761         return MediaTime::positiveInfiniteTime();
    762     }
    763 
    764     GST_LOG_OBJECT(pipeline(), "Duration: %" GST_TIME_FORMAT, GST_TIME_ARGS(duration));
    765     return MediaTime(duration, GST_SECOND);
    766725}
    767726
     
    783742MediaTime MediaPlayerPrivateGStreamer::currentMediaTime() const
    784743{
    785     if (!m_pipeline || m_errorOccured)
     744    if (!m_pipeline || m_didErrorOccur)
    786745        return MediaTime::invalidTime();
    787746
    788     GST_TRACE_OBJECT(pipeline(), "seeking: %s, seekTime: %s", boolForPrinting(m_seeking), m_seekTime.toString().utf8().data());
    789     if (m_seeking)
     747    GST_TRACE_OBJECT(pipeline(), "seeking: %s, seekTime: %s", boolForPrinting(m_isSeeking), m_seekTime.toString().utf8().data());
     748    if (m_isSeeking)
    790749        return m_seekTime;
    791750
     
    795754void MediaPlayerPrivateGStreamer::setRate(float rate)
    796755{
    797     // Higher rate causes crash.
    798     rate = clampTo(rate, -20.0, 20.0);
     756    float rateClamped = clampTo(rate, -20.0, 20.0);
     757    if (rateClamped != rate)
     758        GST_WARNING("Clamping original rate (%f) to [-20, 20] (%f), higher rates cause crashes", rate, rateClamped);
    799759
    800760    // Avoid useless playback rate update.
    801     if (m_playbackRate == rate) {
    802         // and make sure that upper layers were notified if rate was set
    803 
    804         if (!m_changingRate && m_player->rate() != m_playbackRate)
     761    if (m_playbackRate == rateClamped) {
     762        // And make sure that upper layers were notified if rate was set.
     763
     764        if (!m_isChangingRate && m_player->rate() != m_playbackRate)
    805765            m_player->rateChanged();
    806766        return;
    807767    }
    808768
    809     if (isLiveStream()) {
    810         // notify upper layers that we cannot handle passed rate.
    811         m_changingRate = false;
     769    if (m_isLiveStream) {
     770        // Notify upper layers that we cannot handle passed rate.
     771        m_isChangingRate = false;
    812772        m_player->rateChanged();
    813773        return;
    814774    }
    815775
    816     GstState state;
    817     GstState pending;
    818 
    819     m_playbackRate = rate;
    820     m_changingRate = true;
     776    GstState state, pending;
     777
     778    m_playbackRate = rateClamped;
     779    m_isChangingRate = true;
    821780
    822781    gst_element_get_state(m_pipeline.get(), &state, &pending, 0);
    823782
    824     if (!rate) {
    825         m_changingRate = false;
    826         m_playbackRatePause = true;
     783    if (!rateClamped) {
     784        m_isChangingRate = false;
     785        m_isPlaybackRatePaused = true;
    827786        if (state != GST_STATE_PAUSED && pending != GST_STATE_PAUSED)
    828787            changePipelineState(GST_STATE_PAUSED);
     
    844803void MediaPlayerPrivateGStreamer::setPreservesPitch(bool preservesPitch)
    845804{
    846     m_preservesPitch = preservesPitch;
     805    m_shouldPreservePitch = preservesPitch;
    847806}
    848807
     
    850809{
    851810    GST_DEBUG_OBJECT(pipeline(), "Setting preload to %s", convertEnumerationToString(preload).utf8().data());
    852     if (preload == MediaPlayer::Auto && isLiveStream())
     811    if (preload == MediaPlayer::Auto && m_isLiveStream)
    853812        return;
    854813
     
    856815    updateDownloadBufferingFlag();
    857816
    858     if (m_delayingLoad && m_preload != MediaPlayer::None) {
    859         m_delayingLoad = false;
     817    if (m_isDelayingLoad && m_preload != MediaPlayer::None) {
     818        m_isDelayingLoad = false;
    860819        commitLoad();
    861820    }
     
    865824{
    866825    auto timeRanges = makeUnique<PlatformTimeRanges>();
    867     if (m_errorOccured || isLiveStream())
     826    if (m_didErrorOccur || m_isLiveStream)
    868827        return timeRanges;
    869828
     
    877836        return timeRanges;
    878837
    879     guint numBufferingRanges = gst_query_get_n_buffering_ranges(query.get());
    880     for (guint index = 0; index < numBufferingRanges; index++) {
     838    unsigned numBufferingRanges = gst_query_get_n_buffering_ranges(query.get());
     839    for (unsigned index = 0; index < numBufferingRanges; index++) {
    881840        gint64 rangeStart = 0, rangeStop = 0;
    882841        if (gst_query_parse_nth_buffering_range(query.get(), index, &rangeStart, &rangeStop)) {
     
    887846    }
    888847
    889     // Fallback to the more general maxTimeLoaded() if no range has
    890     // been found.
     848    // Fallback to the more general maxTimeLoaded() if no range has been found.
    891849    if (!timeRanges->length()) {
    892850        MediaTime loaded = maxTimeLoaded();
     
    900858MediaTime MediaPlayerPrivateGStreamer::maxMediaTimeSeekable() const
    901859{
    902     GST_TRACE_OBJECT(pipeline(), "errorOccured: %s, isLiveStream: %s", boolForPrinting(m_errorOccured), boolForPrinting(isLiveStream()));
    903     if (m_errorOccured)
     860    GST_TRACE_OBJECT(pipeline(), "errorOccured: %s, isLiveStream: %s", boolForPrinting(m_didErrorOccur), boolForPrinting(m_isLiveStream));
     861    if (m_didErrorOccur)
    904862        return MediaTime::zeroTime();
    905863
    906     if (isLiveStream())
     864    if (m_isLiveStream)
    907865        return MediaTime::zeroTime();
    908866
    909867    MediaTime duration = durationMediaTime();
    910868    GST_DEBUG_OBJECT(pipeline(), "maxMediaTimeSeekable, duration: %s", toString(duration).utf8().data());
    911     // infinite duration means live stream
     869    // Infinite duration means live stream.
    912870    if (duration.isPositiveInfinite())
    913871        return MediaTime::zeroTime();
     
    918876MediaTime MediaPlayerPrivateGStreamer::maxTimeLoaded() const
    919877{
    920     if (m_errorOccured)
     878    if (m_didErrorOccur)
    921879        return MediaTime::zeroTime();
    922880
     
    930888bool MediaPlayerPrivateGStreamer::didLoadingProgress() const
    931889{
    932     if (m_errorOccured || m_loadingStalled)
     890    if (m_didErrorOccur || m_loadingStalled)
    933891        return false;
    934892
     
    953911unsigned long long MediaPlayerPrivateGStreamer::totalBytes() const
    954912{
    955     if (m_errorOccured)
     913    if (m_didErrorOccur || !m_source || m_isLiveStream)
    956914        return 0;
    957915
    958916    if (m_totalBytes)
    959917        return m_totalBytes;
    960 
    961     if (!m_source)
    962         return 0;
    963 
    964     if (isLiveStream())
    965         return 0;
    966918
    967919    GstFormat fmt = GST_FORMAT_BYTES;
     
    970922        GST_INFO_OBJECT(pipeline(), "totalBytes %" G_GINT64_FORMAT, length);
    971923        m_totalBytes = static_cast<unsigned long long>(length);
    972         m_isStreaming = !length;
     924        m_isLiveStream = !length;
    973925        return m_totalBytes;
    974926    }
    975927
    976     // Fall back to querying the source pads manually.
    977     // See also https://bugzilla.gnome.org/show_bug.cgi?id=638749
     928    // Fall back to querying the source pads manually. See also https://bugzilla.gnome.org/show_bug.cgi?id=638749
    978929    GstIterator* iter = gst_element_iterate_src_pads(m_source.get());
    979930    bool done = false;
     
    1005956    GST_INFO_OBJECT(pipeline(), "totalBytes %" G_GINT64_FORMAT, length);
    1006957    m_totalBytes = static_cast<unsigned long long>(length);
    1007     m_isStreaming = !length;
     958    m_isLiveStream = !length;
    1008959    return m_totalBytes;
    1009960}
     
    11301081    ASSERT(m_pipeline);
    11311082
    1132     GstState currentState;
    1133     GstState pending;
     1083    GstState currentState, pending;
    11341084
    11351085    gst_element_get_state(m_pipeline.get(), &currentState, &pending, 0);
     
    11481098        return false;
    11491099
    1150     // Create a timer when entering the READY state so that we can free resources
    1151     // if we stay for too long on READY.
    1152     // Also lets remove the timer if we request a state change for any state other than READY.
    1153     // See also https://bugs.webkit.org/show_bug.cgi?id=117354
     1100    // Create a timer when entering the READY state so that we can free resources if we stay for too long on READY.
     1101    // Also lets remove the timer if we request a state change for any state other than READY. See also https://bugs.webkit.org/show_bug.cgi?id=117354
    11541102    if (newState == GST_STATE_READY && !m_readyTimerHandler.isActive()) {
    1155         // Max interval in seconds to stay in the READY state on manual
    1156         // state change requests.
     1103        // Max interval in seconds to stay in the READY state on manual state change requests.
    11571104        static const Seconds readyStateTimerDelay { 1_min };
    11581105        m_readyTimerHandler.startOneShot(readyStateTimerDelay);
     
    12051152    ASSERT(m_isLegacyPlaybin || isMediaSource());
    12061153
    1207     gint numTracks = 0;
     1154    unsigned numTracks = 0;
    12081155    bool useMediaSource = isMediaSource();
    12091156    GstElement* element = useMediaSource ? m_source.get() : m_pipeline.get();
     
    12281175#if ENABLE(VIDEO_TRACK)
    12291176    Vector<String> validVideoStreams;
    1230     for (gint i = 0; i < numTracks; ++i) {
     1177    for (unsigned i = 0; i < numTracks; ++i) {
    12311178        GRefPtr<GstPad> pad;
    12321179        g_signal_emit_by_name(m_pipeline.get(), "get-video-pad", i, &pad.outPtr(), nullptr);
     
    12351182        String streamId = "V" + String::number(i);
    12361183        validVideoStreams.append(streamId);
    1237         if (i < static_cast<gint>(m_videoTracks.size())) {
     1184        if (i < m_videoTracks.size()) {
    12381185            RefPtr<VideoTrackPrivateGStreamer> existingTrack = m_videoTracks.get(streamId);
    12391186            if (existingTrack) {
     
    12831230    ASSERT(m_isLegacyPlaybin || isMediaSource());
    12841231
    1285     gint numTracks = 0;
     1232    unsigned numTracks = 0;
    12861233    bool useMediaSource = isMediaSource();
    12871234    GstElement* element = useMediaSource ? m_source.get() : m_pipeline.get();
     
    13021249#if ENABLE(VIDEO_TRACK)
    13031250    Vector<String> validAudioStreams;
    1304     for (gint i = 0; i < numTracks; ++i) {
     1251    for (unsigned i = 0; i < numTracks; ++i) {
    13051252        GRefPtr<GstPad> pad;
    13061253        g_signal_emit_by_name(m_pipeline.get(), "get-audio-pad", i, &pad.outPtr(), nullptr);
     
    13091256        String streamId = "A" + String::number(i);
    13101257        validAudioStreams.append(streamId);
    1311         if (i < static_cast<gint>(m_audioTracks.size())) {
     1258        if (i < m_audioTracks.size()) {
    13121259            RefPtr<AudioTrackPrivateGStreamer> existingTrack = m_audioTracks.get(streamId);
    13131260            if (existingTrack) {
     
    13451292    ASSERT(m_isLegacyPlaybin || isMediaSource());
    13461293
    1347     gint numTracks = 0;
     1294    unsigned numTracks = 0;
    13481295    bool useMediaSource = isMediaSource();
    13491296    GstElement* element = useMediaSource ? m_source.get() : m_pipeline.get();
     
    13581305
    13591306    Vector<String> validTextStreams;
    1360     for (gint i = 0; i < numTracks; ++i) {
     1307    for (unsigned i = 0; i < numTracks; ++i) {
    13611308        GRefPtr<GstPad> pad;
    13621309        g_signal_emit_by_name(m_pipeline.get(), "get-text-pad", i, &pad.outPtr(), nullptr);
     
    13701317
    13711318        validTextStreams.append(streamId);
    1372         if (i < static_cast<gint>(m_textTracks.size())) {
     1319        if (i < m_textTracks.size()) {
    13731320            RefPtr<InbandTextTrackPrivateGStreamer> existingTrack = m_textTracks.get(streamId);
    13741321            if (existingTrack) {
     
    14231370#endif
    14241371
     1372MediaTime MediaPlayerPrivateGStreamer::platformDuration() const
     1373{
     1374    if (!m_pipeline)
     1375        return MediaTime::invalidTime();
     1376
     1377    GST_TRACE_OBJECT(pipeline(), "errorOccured: %s, pipeline state: %s", boolForPrinting(m_didErrorOccur), gst_element_state_get_name(GST_STATE(m_pipeline.get())));
     1378    if (m_didErrorOccur)
     1379        return MediaTime::invalidTime();
     1380
     1381    // The duration query would fail on a not-prerolled pipeline.
     1382    if (GST_STATE(m_pipeline.get()) < GST_STATE_PAUSED)
     1383        return MediaTime::invalidTime();
     1384
     1385    int64_t duration = 0;
     1386    if (!gst_element_query_duration(m_pipeline.get(), GST_FORMAT_TIME, &duration) || !GST_CLOCK_TIME_IS_VALID(duration)) {
     1387        GST_DEBUG_OBJECT(pipeline(), "Time duration query failed for %s", m_url.string().utf8().data());
     1388        return MediaTime::positiveInfiniteTime();
     1389    }
     1390
     1391    GST_LOG_OBJECT(pipeline(), "Duration: %" GST_TIME_FORMAT, GST_TIME_ARGS(duration));
     1392    return MediaTime(duration, GST_SECOND);
     1393}
     1394
     1395bool MediaPlayerPrivateGStreamer::isMuted() const
     1396{
     1397    if (!m_volumeElement)
     1398        return false;
     1399
     1400    gboolean isMuted;
     1401    g_object_get(m_volumeElement.get(), "mute", &isMuted, nullptr);
     1402    GST_INFO_OBJECT(pipeline(), "Player is muted: %s", boolForPrinting(!!isMuted));
     1403    return isMuted;
     1404}
     1405
     1406void MediaPlayerPrivateGStreamer::commitLoad()
     1407{
     1408    ASSERT(!m_isDelayingLoad);
     1409    GST_DEBUG_OBJECT(pipeline(), "Committing load.");
     1410
     1411    // GStreamer needs to have the pipeline set to a paused state to
     1412    // start providing anything useful.
     1413    changePipelineState(GST_STATE_PAUSED);
     1414
     1415    updateDownloadBufferingFlag();
     1416    updateStates();
     1417}
     1418
    14251419void MediaPlayerPrivateGStreamer::fillTimerFired()
    14261420{
    1427     if (m_errorOccured) {
     1421    if (m_didErrorOccur) {
    14281422        GST_DEBUG_OBJECT(pipeline(), "[Buffering] An error occurred, disabling the fill timer");
    14291423        m_fillTimer.stop();
     
    14671461    GST_WARNING("Loading failed, error: %s", convertEnumerationToString(networkError).utf8().data());
    14681462
    1469     m_errorOccured = true;
     1463    m_didErrorOccur = true;
    14701464    if (forceNotifications || m_networkState != networkError) {
    14711465        m_networkState = networkError;
     
    15101504MediaTime MediaPlayerPrivateGStreamer::playbackPosition() const
    15111505{
    1512     GST_TRACE_OBJECT(pipeline(), "isEndReached: %s, seeking: %s, seekTime: %s", boolForPrinting(m_isEndReached), boolForPrinting(m_seeking), m_seekTime.toString().utf8().data());
    1513     if (m_isEndReached && m_seeking)
     1506    GST_TRACE_OBJECT(pipeline(), "isEndReached: %s, seeking: %s, seekTime: %s", boolForPrinting(m_isEndReached), boolForPrinting(m_isSeeking), m_seekTime.toString().utf8().data());
     1507    if (m_isEndReached && m_isSeeking)
    15141508        return m_seekTime;
    15151509
     
    15311525    gst_query_unref(query);
    15321526
    1533     GST_TRACE_OBJECT(pipeline(), "Position %" GST_TIME_FORMAT ", canFallBackToLastFinishedSeekPosition: %s", GST_TIME_ARGS(position), boolForPrinting(m_canFallBackToLastFinishedSeekPosition));
     1527    GstClockTime gstreamerPosition = static_cast<GstClockTime>(position);
     1528    GST_TRACE_OBJECT(pipeline(), "Position %" GST_TIME_FORMAT ", canFallBackToLastFinishedSeekPosition: %s", GST_TIME_ARGS(gstreamerPosition), boolForPrinting(m_canFallBackToLastFinishedSeekPosition));
    15341529
    15351530    MediaTime playbackPosition = MediaTime::zeroTime();
    1536     GstClockTime gstreamerPosition = static_cast<GstClockTime>(position);
     1531
    15371532    if (GST_CLOCK_TIME_IS_VALID(gstreamerPosition))
    15381533        playbackPosition = MediaTime(gstreamerPosition, GST_SECOND);
     
    16101605        break;
    16111606    case TrackPrivateBaseGStreamer::TrackType::Unknown:
     1607        FALLTHROUGH;
    16121608    default:
    16131609        ASSERT_NOT_REACHED();
     
    16611657    }
    16621658
    1663     if ((oldHasVideo != m_hasVideo) || (oldHasAudio != m_hasAudio))
     1659    if (oldHasVideo != m_hasVideo || oldHasAudio != m_hasAudio)
    16641660        m_player->characteristicChanged();
    16651661
     
    17211717
    17221718    const gchar* contextType;
    1723     gst_message_parse_context_type(message, &contextType);
     1719    if (!gst_message_parse_context_type(message, &contextType))
     1720        return false;
     1721
    17241722    GST_DEBUG_OBJECT(pipeline(), "Handling %s need-context message for %s", contextType, GST_MESSAGE_SRC_NAME(message));
    17251723
     
    17721770            gst_element_set_context(GST_ELEMENT(GST_MESSAGE_SRC(message)), context.get());
    17731771        } else
    1774             GST_WARNING("CDM instance not initializaed");
     1772            GST_WARNING("CDM instance not initialized");
    17751773
    17761774        return true;
     
    17821780}
    17831781
    1784 // Returns the size of the video
     1782// Returns the size of the video.
    17851783FloatSize MediaPlayerPrivateGStreamer::naturalSize() const
    17861784{
     
    18201818        return FloatSize();
    18211819
    1822     // TODO: handle possible clean aperture data. See
    1823     // https://bugzilla.gnome.org/show_bug.cgi?id=596571
    1824     // TODO: handle possible transformation matrix. See
    1825     // https://bugzilla.gnome.org/show_bug.cgi?id=596326
     1820    // TODO: handle possible clean aperture data. See https://bugzilla.gnome.org/show_bug.cgi?id=596571
     1821    // TODO: handle possible transformation matrix. See https://bugzilla.gnome.org/show_bug.cgi?id=596326
    18261822
    18271823    // Get the video PAR and original size, if this fails the
     
    18351831#if USE(TEXTURE_MAPPER_GL)
    18361832    // When using accelerated compositing, if the video is tagged as rotated 90 or 270 degrees, swap width and height.
    1837     if (m_renderingCanBeAccelerated) {
     1833    if (m_canRenderingBeAccelerated) {
    18381834        if (m_videoSourceOrientation.usesWidthAsHeight())
    18391835            originalSize = originalSize.transposedSize();
     
    18541850
    18551851    // Apply DAR to original video size. This is the same behavior as in xvimagesink's setcaps function.
    1856     guint64 width = 0, height = 0;
     1852    uint64_t width = 0, height = 0;
    18571853    if (!(originalSize.height() % displayHeight)) {
    18581854        GST_DEBUG_OBJECT(pipeline(), "Keeping video original height");
    18591855        width = gst_util_uint64_scale_int(originalSize.height(), displayWidth, displayHeight);
    1860         height = static_cast<guint64>(originalSize.height());
     1856        height = originalSize.height();
    18611857    } else if (!(originalSize.width() % displayWidth)) {
    18621858        GST_DEBUG_OBJECT(pipeline(), "Keeping video original width");
    18631859        height = gst_util_uint64_scale_int(originalSize.width(), displayHeight, displayWidth);
    1864         width = static_cast<guint64>(originalSize.width());
     1860        width = originalSize.width();
    18651861    } else {
    18661862        GST_DEBUG_OBJECT(pipeline(), "Approximating while keeping original video height");
    18671863        width = gst_util_uint64_scale_int(originalSize.height(), displayWidth, displayHeight);
    1868         height = static_cast<guint64>(originalSize.height());
     1864        height = originalSize.height();
    18691865    }
    18701866
     
    19241920}
    19251921
    1926 void MediaPlayerPrivateGStreamer::sizeChanged()
    1927 {
    1928     notImplemented();
    1929 }
    1930 
    1931 void MediaPlayerPrivateGStreamer::setMuted(bool mute)
    1932 {
    1933     if (!m_volumeElement)
    1934         return;
    1935 
    1936     bool currentValue = muted();
    1937     if (currentValue == mute)
    1938         return;
    1939 
    1940     GST_INFO_OBJECT(pipeline(), "Set muted to %s", toString(mute).utf8().data());
    1941     g_object_set(m_volumeElement.get(), "mute", mute, nullptr);
    1942 }
    1943 
    1944 bool MediaPlayerPrivateGStreamer::muted() const
    1945 {
    1946     if (!m_volumeElement)
    1947         return false;
    1948 
    1949     gboolean muted;
    1950     g_object_get(m_volumeElement.get(), "mute", &muted, nullptr);
    1951     GST_INFO_OBJECT(pipeline(), "Player is muted: %s", toString(static_cast<bool>(muted)).utf8().data());
    1952     return muted;
     1922void MediaPlayerPrivateGStreamer::setMuted(bool shouldMute)
     1923{
     1924    if (!m_volumeElement || shouldMute == isMuted())
     1925        return;
     1926
     1927    GST_INFO_OBJECT(pipeline(), "Muted? %s", boolForPrinting(shouldMute));
     1928    g_object_set(m_volumeElement.get(), "mute", shouldMute, nullptr);
    19531929}
    19541930
     
    20001976    switch (GST_MESSAGE_TYPE(message)) {
    20011977    case GST_MESSAGE_ERROR:
    2002         if (m_resetPipeline || !m_missingPluginCallbacks.isEmpty() || m_errorOccured)
     1978        if (m_shouldResetPipeline || !m_missingPluginCallbacks.isEmpty() || m_didErrorOccur)
    20031979            break;
    20041980        gst_message_parse_error(message, &err.outPtr(), &debug.outPtr());
     
    20151991            error = MediaPlayer::FormatError;
    20161992        else if (g_error_matches(err.get(), GST_STREAM_ERROR, GST_STREAM_ERROR_TYPE_NOT_FOUND)) {
    2017             // Let the mediaPlayerClient handle the stream error, in
    2018             // this case the HTMLMediaElement will emit a stalled
    2019             // event.
     1993            // Let the mediaPlayerClient handle the stream error, in this case the HTMLMediaElement will emit a stalled event.
    20201994            GST_ERROR("Decode error, let the Media element emit a stalled event.");
    20211995            m_loadingStalled = true;
     
    20302004            issueError = !loadNextLocation();
    20312005        if (issueError) {
    2032             m_errorOccured = true;
     2006            m_didErrorOccur = true;
    20332007            if (m_networkState != error) {
    20342008                m_networkState = error;
     
    20412015        break;
    20422016    case GST_MESSAGE_ASYNC_DONE:
    2043         if (!messageSourceIsPlaybin || m_delayingLoad)
     2017        if (!messageSourceIsPlaybin || m_isDelayingLoad)
    20442018            break;
    20452019        asyncStateChangeDone();
    20462020        break;
    20472021    case GST_MESSAGE_STATE_CHANGED: {
    2048         if (!messageSourceIsPlaybin || m_delayingLoad)
     2022        if (!messageSourceIsPlaybin || m_isDelayingLoad)
    20492023            break;
    20502024        updateStates();
     
    21772151                }
    21782152                if (!isRangeRequest) {
    2179                     m_isStreaming = !contentLength;
    2180                     GST_INFO_OBJECT(pipeline(), "%s stream detected", m_isStreaming ? "Live" : "Non-live");
     2153                    m_isLiveStream = !contentLength;
     2154                    GST_INFO_OBJECT(pipeline(), "%s stream detected", m_isLiveStream ? "Live" : "Non-live");
    21812155                    updateDownloadBufferingFlag();
    21822156                }
     
    22862260    GST_DEBUG_OBJECT(pipeline(), "[Buffering] mode: %s, status: %f%%", enumToString(GST_TYPE_BUFFERING_MODE, mode).data(), percentage);
    22872261
    2288     m_downloadFinished = percentage == 100;
    2289     m_buffering = !m_downloadFinished;
     2262    m_didDownloadFinish = percentage == 100;
     2263    m_isBuffering = !m_didDownloadFinish;
    22902264
    22912265    switch (mode) {
     
    22942268
    22952269        m_bufferingPercentage = percentage;
    2296         if (m_downloadFinished)
     2270        if (m_didDownloadFinish)
    22972271            updateStates();
    22982272
     
    23042278        // Media is now fully loaded. It will play even if network connection is
    23052279        // cut. Buffering is done, remove the fill source from the main loop.
    2306         if (m_downloadFinished)
     2280        if (m_didDownloadFinish)
    23072281            m_fillTimer.stop();
    23082282
     
    23242298        const GstMpegtsPMT* pmt = gst_mpegts_section_get_pmt(section);
    23252299        m_metadataTracks.clear();
    2326         for (guint i = 0; i < pmt->streams->len; ++i) {
     2300        for (unsigned i = 0; i < pmt->streams->len; ++i) {
    23272301            const GstMpegtsPMTStream* stream = static_cast<const GstMpegtsPMTStream*>(g_ptr_array_index(pmt->streams, i));
    23282302            if (stream->stream_type == 0x05 || stream->stream_type >= 0x80) {
     
    23432317                String inbandMetadataTrackDispatchType;
    23442318                appendUnsignedAsHexFixedSize(stream->stream_type, inbandMetadataTrackDispatchType, 2);
    2345                 for (guint j = 0; j < stream->descriptors->len; ++j) {
     2319                for (unsigned j = 0; j < stream->descriptors->len; ++j) {
    23462320                    const GstMpegtsDescriptor* descriptor = static_cast<const GstMpegtsDescriptor*>(g_ptr_array_index(stream->descriptors, j));
    2347                     for (guint k = 0; k < descriptor->length; ++k)
     2321                    for (unsigned k = 0; k < descriptor->length; ++k)
    23482322                        appendByteAsHex(descriptor->data[k], inbandMetadataTrackDispatchType);
    23492323                }
     
    23952369    gint64 start = -1, stop = -1;
    23962370    gst_toc_entry_get_start_stop_times(entry, &start, &stop);
     2371
     2372    uint32_t truncatedGstSecond = static_cast<uint32_t>(GST_SECOND);
    23972373    if (start != -1)
    2398         cue->setStartTime(MediaTime(start, GST_SECOND));
     2374        cue->setStartTime(MediaTime(static_cast<int64_t>(start), truncatedGstSecond));
    23992375    if (stop != -1)
    2400         cue->setEndTime(MediaTime(stop, GST_SECOND));
     2376        cue->setEndTime(MediaTime(static_cast<int64_t>(stop), truncatedGstSecond));
    24012377
    24022378    GstTagList* tags = gst_toc_entry_get_tags(entry);
     
    24962472void MediaPlayerPrivateGStreamer::asyncStateChangeDone()
    24972473{
    2498     if (!m_pipeline || m_errorOccured)
    2499         return;
    2500 
    2501     if (m_seeking) {
    2502         if (m_seekIsPending)
     2474    if (!m_pipeline || m_didErrorOccur)
     2475        return;
     2476
     2477    if (m_isSeeking) {
     2478        if (m_isSeekPending)
    25032479            updateStates();
    25042480        else {
    25052481            GST_DEBUG_OBJECT(pipeline(), "[Seek] seeked to %s", toString(m_seekTime).utf8().data());
    2506             m_seeking = false;
     2482            m_isSeeking = false;
    25072483            m_cachedPosition = MediaTime::invalidTime();
    25082484            if (m_timeOfOverlappingSeek != m_seekTime && m_timeOfOverlappingSeek.isValid()) {
     
    25242500void MediaPlayerPrivateGStreamer::updateStates()
    25252501{
    2526     if (!m_pipeline)
    2527         return;
    2528 
    2529     if (m_errorOccured)
     2502    if (!m_pipeline || m_didErrorOccur)
    25302503        return;
    25312504
    25322505    MediaPlayer::NetworkState oldNetworkState = m_networkState;
    25332506    MediaPlayer::ReadyState oldReadyState = m_readyState;
    2534     GstState pending;
    2535     GstState state;
     2507    GstState pending, state;
    25362508    bool stateReallyChanged = false;
    25372509
     
    25532525            break;
    25542526
    2555         m_resetPipeline = m_currentState <= GST_STATE_READY;
    2556 
    2557         bool didBuffering = m_buffering;
     2527        m_shouldResetPipeline = m_currentState <= GST_STATE_READY;
     2528
     2529        bool didBuffering = m_isBuffering;
    25582530
    25592531        // Update ready and network states.
     
    25692541        case GST_STATE_PAUSED:
    25702542        case GST_STATE_PLAYING:
    2571             if (m_buffering) {
     2543            if (m_isBuffering) {
    25722544                if (m_bufferingPercentage == 100) {
    25732545                    GST_DEBUG_OBJECT(pipeline(), "[Buffering] Complete.");
    2574                     m_buffering = false;
     2546                    m_isBuffering = false;
    25752547                    m_readyState = MediaPlayer::HaveEnoughData;
    2576                     m_networkState = m_downloadFinished ? MediaPlayer::Idle : MediaPlayer::Loading;
     2548                    m_networkState = m_didDownloadFinish ? MediaPlayer::Idle : MediaPlayer::Loading;
    25772549                } else {
    25782550                    m_readyState = MediaPlayer::HaveCurrentData;
    25792551                    m_networkState = MediaPlayer::Loading;
    25802552                }
    2581             } else if (m_downloadFinished) {
     2553            } else if (m_didDownloadFinish) {
    25822554                m_readyState = MediaPlayer::HaveEnoughData;
    25832555                m_networkState = MediaPlayer::Loaded;
     
    25952567        // Sync states where needed.
    25962568        if (m_currentState == GST_STATE_PAUSED) {
    2597             if (!m_volumeAndMuteInitialized) {
     2569            if (!m_areVolumeAndMuteInitialized) {
    25982570                notifyPlayerOfVolumeChange();
    25992571                notifyPlayerOfMute();
    2600                 m_volumeAndMuteInitialized = true;
     2572                m_areVolumeAndMuteInitialized = true;
    26012573            }
    26022574
    2603             if (didBuffering && !m_buffering && !m_paused && m_playbackRate) {
     2575            if (didBuffering && !m_isBuffering && !m_isPaused && m_playbackRate) {
    26042576                GST_DEBUG_OBJECT(pipeline(), "[Buffering] Restarting playback.");
    26052577                changePipelineState(GST_STATE_PLAYING);
    26062578            }
    26072579        } else if (m_currentState == GST_STATE_PLAYING) {
    2608             m_paused = false;
    2609 
    2610             if ((m_buffering && !isLiveStream()) || !m_playbackRate) {
     2580            m_isPaused = false;
     2581
     2582            if ((m_isBuffering && m_isLiveStream) || !m_playbackRate) {
    26112583                GST_DEBUG_OBJECT(pipeline(), "[Buffering] Pausing stream for buffering.");
    26122584                changePipelineState(GST_STATE_PAUSED);
    26132585            }
    26142586        } else
    2615             m_paused = true;
     2587            m_isPaused = true;
    26162588
    26172589        GST_DEBUG_OBJECT(pipeline(), "Old state: %s, new state: %s (requested: %s)", gst_element_state_get_name(m_oldState), gst_element_state_get_name(m_currentState), gst_element_state_get_name(m_requestedState));
     
    26382610    case GST_STATE_CHANGE_FAILURE:
    26392611        GST_DEBUG_OBJECT(pipeline(), "Failure: State: %s, pending: %s", gst_element_state_get_name(m_currentState), gst_element_state_get_name(pending));
    2640         // Change failed
     2612        // Change failed.
    26412613        return;
    26422614    case GST_STATE_CHANGE_NO_PREROLL:
     
    26442616
    26452617        // Live pipelines go in PAUSED without prerolling.
    2646         m_isStreaming = true;
     2618        m_isLiveStream = true;
    26472619        updateDownloadBufferingFlag();
    26482620
     
    26512623        else if (m_currentState == GST_STATE_PAUSED) {
    26522624            m_readyState = MediaPlayer::HaveEnoughData;
    2653             m_paused = true;
     2625            m_isPaused = true;
    26542626        } else if (m_currentState == GST_STATE_PLAYING)
    2655             m_paused = false;
    2656 
    2657         if (!m_paused && m_playbackRate)
     2627            m_isPaused = false;
     2628
     2629        if (!m_isPaused && m_playbackRate)
    26582630            changePipelineState(GST_STATE_PLAYING);
    26592631
     
    26812653    if (getStateResult == GST_STATE_CHANGE_SUCCESS && m_currentState >= GST_STATE_PAUSED) {
    26822654        updatePlaybackRate();
    2683         if (m_seekIsPending) {
     2655        if (m_isSeekPending) {
    26842656            GST_DEBUG_OBJECT(pipeline(), "[Seek] committing pending seek to %s", toString(m_seekTime).utf8().data());
    2685             m_seekIsPending = false;
    2686             m_seeking = doSeek(m_seekTime, m_player->rate(), static_cast<GstSeekFlags>(GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE));
    2687             if (!m_seeking) {
     2657            m_isSeekPending = false;
     2658            m_isSeeking = doSeek(m_seekTime, m_player->rate(), static_cast<GstSeekFlags>(GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE));
     2659            if (!m_isSeeking) {
    26882660                m_cachedPosition = MediaTime::invalidTime();
    26892661                GST_DEBUG_OBJECT(pipeline(), "[Seek] seeking to %s failed", toString(m_seekTime).utf8().data());
     
    27192691
    27202692    const GValue* locations = gst_structure_get_value(m_mediaLocations, "locations");
    2721     const gchar* newLocation = nullptr;
     2693    const char* newLocation = nullptr;
    27222694
    27232695    if (!locations) {
     
    27762748
    27772749            // Reset pipeline state.
    2778             m_resetPipeline = true;
     2750            m_shouldResetPipeline = true;
    27792751
    27802752            GstState state;
     
    28022774    m_cachedPosition = MediaTime::invalidTime();
    28032775    MediaTime now = currentMediaTime();
    2804     if (now > MediaTime::zeroTime() && !m_seeking) {
     2776    if (now > MediaTime::zeroTime() && !m_isSeeking) {
    28052777        m_cachedDuration = now;
    28062778        m_player->durationChanged();
     
    28102782
    28112783    if (!m_player->client().mediaPlayerIsLooping()) {
    2812         m_paused = true;
     2784        m_isPaused = true;
    28132785        changePipelineState(GST_STATE_READY);
    2814         m_downloadFinished = false;
     2786        m_didDownloadFinish = false;
    28152787    }
    28162788    timeChanged();
     
    28652837
    28662838    // We don't want to stop downloading if we already started it.
    2867     if (flags & flagDownload && m_readyState > MediaPlayer::HaveNothing && !m_resetPipeline) {
     2839    if (flags & flagDownload && m_readyState > MediaPlayer::HaveNothing && !m_shouldResetPipeline) {
    28682840        GST_DEBUG_OBJECT(pipeline(), "Download already started, not starting again");
    28692841        return;
    28702842    }
    28712843
    2872     bool shouldDownload = !isLiveStream() && m_preload == MediaPlayer::Auto;
     2844    bool shouldDownload = !m_isLiveStream && m_preload == MediaPlayer::Auto;
    28732845    if (shouldDownload) {
    28742846        GST_INFO_OBJECT(pipeline(), "Enabling on-disk buffering");
     
    28842856void MediaPlayerPrivateGStreamer::createGSTPlayBin(const URL& url, const String& pipelineName)
    28852857{
    2886     const gchar* playbinName = "playbin";
     2858    const char* playbinName = "playbin";
    28872859
    28882860    // MSE doesn't support playbin3. Mediastream requires playbin3. Regular
     
    29072879    m_isLegacyPlaybin = !g_strcmp0(playbinName, "playbin");
    29082880
    2909     // gst_element_factory_make() returns a floating reference so
    2910     // we should not adopt.
    29112881    static Atomic<uint32_t> pipelineId;
    29122882    setPipeline(gst_element_factory_make(playbinName,
     
    29742944    configurePlaySink();
    29752945
    2976     if (m_preservesPitch) {
     2946    if (m_shouldPreservePitch) {
    29772947        GstElement* scale = gst_element_factory_make("scaletempo", nullptr);
    29782948
     
    29832953    }
    29842954
    2985     if (!m_renderingCanBeAccelerated) {
     2955    if (!m_canRenderingBeAccelerated) {
    29862956        // If not using accelerated compositing, let GStreamer handle
    29872957        // the image-orientation tag.
     
    30082978bool MediaPlayerPrivateGStreamer::canSaveMediaData() const
    30092979{
    3010     if (isLiveStream())
     2980    if (m_isLiveStream)
    30112981        return false;
    30122982
     
    30282998void MediaPlayerPrivateGStreamer::acceleratedRenderingStateChanged()
    30292999{
    3030     m_renderingCanBeAccelerated = m_player && m_player->client().mediaPlayerAcceleratedCompositingEnabled();
     3000    m_canRenderingBeAccelerated = m_player && m_player->client().mediaPlayerAcceleratedCompositingEnabled();
    30313001}
    30323002
     
    30763046                return;
    30773047
    3078             std::unique_ptr<GstVideoFrameHolder> frameHolder = makeUnique<GstVideoFrameHolder>(m_sample.get(), m_videoDecoderPlatform, m_textureMapperFlags, !m_usingFallbackVideoSink);
     3048            std::unique_ptr<GstVideoFrameHolder> frameHolder = makeUnique<GstVideoFrameHolder>(m_sample.get(), m_videoDecoderPlatform, m_textureMapperFlags, !m_isUsingFallbackVideoSink);
    30793049
    30803050            std::unique_ptr<TextureMapperPlatformLayerBuffer> layerBuffer;
     
    31183088void MediaPlayerPrivateGStreamer::triggerRepaint(GstSample* sample)
    31193089{
    3120     bool triggerResize;
     3090    bool shouldTriggerResize;
    31213091    {
    31223092        auto sampleLocker = holdLock(m_sampleMutex);
    3123         triggerResize = !m_sample;
     3093        shouldTriggerResize = !m_sample;
    31243094        m_sample = sample;
    31253095    }
    31263096
    3127     if (triggerResize) {
     3097    if (shouldTriggerResize) {
    31283098        GST_DEBUG_OBJECT(pipeline(), "First sample reached the sink, triggering video dimensions update");
    31293099        m_notifier->notify(MainThreadNotification::SizeChanged, [this] {
     
    31323102    }
    31333103
    3134     if (!m_renderingCanBeAccelerated) {
     3104    if (!m_canRenderingBeAccelerated) {
    31353105        LockHolder locker(m_drawMutex);
    3136         if (m_destroying)
     3106        if (m_isBeingDestroyed)
    31373107            return;
    31383108        m_drawTimer.startOneShot(0_s);
     
    31423112
    31433113#if USE(TEXTURE_MAPPER_GL)
    3144     if (m_usingFallbackVideoSink) {
     3114    if (m_isUsingFallbackVideoSink) {
    31453115        LockHolder lock(m_drawMutex);
    31463116        auto proxyOperation =
     
    31783148    // This function is also used when destroying the player (destroying parameter is true), to release the gstreamer thread from
    31793149    // m_drawCondition and to ensure that new triggerRepaint calls won't wait on m_drawCondition.
    3180     if (!m_renderingCanBeAccelerated) {
     3150    if (!m_canRenderingBeAccelerated) {
    31813151        LockHolder locker(m_drawMutex);
    31823152        m_drawTimer.stop();
    3183         m_destroying = destroying;
     3153        m_isBeingDestroyed = destroying;
    31843154        m_drawCondition.notifyOne();
    31853155    }
     
    32633233            m_colorConvertOutputCaps = adoptGRef(gst_caps_copy(caps));
    32643234#if G_BYTE_ORDER == G_LITTLE_ENDIAN
    3265             const gchar* formatString = GST_VIDEO_INFO_HAS_ALPHA(&videoInfo) ? "RGBA" : "BGRx";
     3235            const char* formatString = GST_VIDEO_INFO_HAS_ALPHA(&videoInfo) ? "RGBA" : "BGRx";
    32663236#else
    3267             const gchar* formatString = GST_VIDEO_INFO_HAS_ALPHA(&videoInfo) ? "RGBA" : "RGBx";
     3237            const char* formatString = GST_VIDEO_INFO_HAS_ALPHA(&videoInfo) ? "RGBA" : "RGBx";
    32683238#endif
    32693239            gst_caps_set_simple(m_colorConvertOutputCaps.get(), "format", G_TYPE_STRING, formatString, nullptr);
     
    32863256        return;
    32873257
    3288     context.drawImage(gstImage->image(), rect, gstImage->rect(), { CompositeCopy, m_renderingCanBeAccelerated ? m_videoSourceOrientation : ImageOrientation() });
     3258    context.drawImage(gstImage->image(), rect, gstImage->rect(), { CompositeCopy, m_canRenderingBeAccelerated ? m_videoSourceOrientation : ImageOrientation() });
    32893259}
    32903260
     
    32943264    UNUSED_PARAM(context);
    32953265
    3296     if (m_usingFallbackVideoSink)
     3266    if (m_isUsingFallbackVideoSink)
    32973267        return false;
    32983268
     
    33263296{
    33273297#if USE(CAIRO) && ENABLE(ACCELERATED_2D_CANVAS)
    3328     if (m_usingFallbackVideoSink)
     3298    if (m_isUsingFallbackVideoSink)
    33293299        return nullptr;
    33303300
     
    34073377        return MediaPlayer::Unknown;
    34083378
    3409     if (isLiveStream())
     3379    if (m_isLiveStream)
    34103380        return MediaPlayer::LiveStream;
    34113381
     
    34853455
    34863456#if USE(GSTREAMER_GL)
    3487     if (m_renderingCanBeAccelerated)
     3457    if (m_canRenderingBeAccelerated)
    34883458        m_videoSink = createVideoSinkGL();
    34893459#endif
    34903460
    34913461    if (!m_videoSink) {
    3492         m_usingFallbackVideoSink = true;
     3462        m_isUsingFallbackVideoSink = true;
    34933463        m_videoSink = webkitVideoSinkNew();
    34943464        g_signal_connect_swapped(m_videoSink.get(), "repaint-requested", G_CALLBACK(repaintCallback), this);
     
    35443514unsigned MediaPlayerPrivateGStreamer::decodedFrameCount() const
    35453515{
    3546     guint64 decodedFrames = 0;
     3516    uint64_t decodedFrames = 0;
    35473517    if (m_fpsSink)
    35483518        g_object_get(m_fpsSink.get(), "frames-rendered", &decodedFrames, nullptr);
     
    35523522unsigned MediaPlayerPrivateGStreamer::droppedFrameCount() const
    35533523{
    3554     guint64 framesDropped = 0;
     3524    uint64_t framesDropped = 0;
    35553525    if (m_fpsSink)
    35563526        g_object_get(m_fpsSink.get(), "frames-dropped", &framesDropped, nullptr);
     
    36503620void MediaPlayerPrivateGStreamer::attemptToDecryptWithLocalInstance()
    36513621{
    3652     bool eventHandled = gst_element_send_event(pipeline(), gst_event_new_custom(GST_EVENT_CUSTOM_DOWNSTREAM_OOB, gst_structure_new_empty("attempt-to-decrypt")));
    3653     GST_DEBUG("attempting to decrypt, event handled %s", boolForPrinting(eventHandled));
     3622    bool wasEventHandled = gst_element_send_event(pipeline(), gst_event_new_custom(GST_EVENT_CUSTOM_DOWNSTREAM_OOB, gst_structure_new_empty("attempt-to-decrypt")));
     3623    GST_DEBUG("attempting to decrypt, event handled %s", boolForPrinting(wasEventHandled));
    36543624}
    36553625
     
    36703640}
    36713641
    3672 void MediaPlayerPrivateGStreamer::setWaitingForKey(bool waitingForKey)
     3642void MediaPlayerPrivateGStreamer::setWaitingForKey(bool isWaitingForKey)
    36733643{
    36743644    // We bail out if values did not change or if we are requested to not wait anymore but there are still waiting decryptors.
    3675     GST_TRACE("waitingForKey %s, m_waitingForKey %s", boolForPrinting(waitingForKey), boolForPrinting(m_waitingForKey));
    3676     if (waitingForKey == m_waitingForKey || (!waitingForKey && this->waitingForKey()))
    3677         return;
    3678 
    3679     m_waitingForKey = waitingForKey;
    3680     GST_DEBUG("waiting for key changed %s", boolForPrinting(m_waitingForKey));
     3645    GST_TRACE("isWaitingForKey %s, m_isWaitingForKey %s", boolForPrinting(isWaitingForKey), boolForPrinting(m_isWaitingForKey));
     3646    if (isWaitingForKey == m_isWaitingForKey || (!isWaitingForKey && this->waitingForKey()))
     3647        return;
     3648
     3649    m_isWaitingForKey = isWaitingForKey;
     3650    GST_DEBUG("waiting for key changed %s", boolForPrinting(m_isWaitingForKey));
    36813651    m_player->waitingForKeyChanged();
    36823652}
  • trunk/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h

    r252938 r252950  
    121121    WTF_MAKE_FAST_ALLOCATED;
    122122public:
    123     static void initializeDebugCategory();
    124 
    125123    MediaPlayerPrivateGStreamer(MediaPlayer*);
    126124    virtual ~MediaPlayerPrivateGStreamer();
    127125
    128     static bool isAvailable();
    129126    static void registerMediaEngine(MediaEngineRegistrar);
    130 
    131     bool hasVideo() const override { return m_hasVideo; }
    132     bool hasAudio() const override { return m_hasAudio; }
    133 
     127    static MediaPlayer::SupportsType extendedSupportsType(const MediaEngineSupportParameters&, MediaPlayer::SupportsType);
     128
     129    bool hasVideo() const final { return m_hasVideo; }
     130    bool hasAudio() const final { return m_hasAudio; }
    134131    void load(const String &url) override;
    135132#if ENABLE(MEDIA_SOURCE)
     
    139136    void load(MediaStreamPrivate&) override;
    140137#endif
    141     void commitLoad();
    142     void cancelLoad() override;
    143 
    144     void prepareToPlay() override;
    145     void play() override;
     138    void cancelLoad() final;
     139    void prepareToPlay() final;
     140    void play() final;
    146141    void pause() override;
    147     bool paused() const override;
    148     bool seeking() const override { return m_seeking; }
     142    bool paused() const final;
     143    bool seeking() const override { return m_isSeeking; }
    149144    void seek(const MediaTime&) override;
    150 
    151     MediaTime platformDuration() const;
    152 
    153145    void setRate(float) override;
    154     double rate() const override;
    155     void setPreservesPitch(bool) override;
    156     void setPreload(MediaPlayer::Preload) override;
    157 
     146    double rate() const final;
     147    void setPreservesPitch(bool) final;
     148    void setPreload(MediaPlayer::Preload) final;
    158149    FloatSize naturalSize() const final;
    159 
    160     void setVolume(float) override;
    161     float volume() const override;
    162 
    163     void setMuted(bool) override;
    164     bool muted() const;
    165 
    166     MediaPlayer::NetworkState networkState() const override;
    167     MediaPlayer::ReadyState readyState() const override;
    168 
    169     void setVisible(bool) override { }
    170     void setSize(const IntSize&) override;
    171     void sizeChanged();
    172 
     150    void setVolume(float) final;
     151    float volume() const final;
     152    void setMuted(bool) final;
     153    MediaPlayer::NetworkState networkState() const final;
     154    MediaPlayer::ReadyState readyState() const final;
     155    void setVisible(bool) final { }
     156    void setSize(const IntSize&) final;
    173157    // Prefer MediaTime based methods over float based.
    174 
    175     float duration() const override { return durationMediaTime().toFloat(); }
    176     double durationDouble() const override { return durationMediaTime().toDouble(); }
    177     MediaTime durationMediaTime() const override;
    178     float currentTime() const override { return currentMediaTime().toFloat(); }
    179     double currentTimeDouble() const override { return currentMediaTime().toDouble(); }
     158    float duration() const final { return durationMediaTime().toFloat(); }
     159    double durationDouble() const final { return durationMediaTime().toDouble(); }
     160    MediaTime durationMediaTime() const;
     161    float currentTime() const final { return currentMediaTime().toFloat(); }
     162    double currentTimeDouble() const final { return currentMediaTime().toDouble(); }
    180163    MediaTime currentMediaTime() const override;
    181164    std::unique_ptr<PlatformTimeRanges> buffered() const override;
    182     void seek(float time) override { seek(MediaTime::createWithFloat(time)); }
    183     void seekDouble(double time) override { seek(MediaTime::createWithDouble(time)); }
    184 
    185     float maxTimeSeekable() const override { return maxMediaTimeSeekable().toFloat(); }
     165    void seek(float time) final { seek(MediaTime::createWithFloat(time)); }
     166    void seekDouble(double time) final { seek(MediaTime::createWithDouble(time)); }
     167    float maxTimeSeekable() const final { return maxMediaTimeSeekable().toFloat(); }
    186168    MediaTime maxMediaTimeSeekable() const override;
    187     double minTimeSeekable() const override { return minMediaTimeSeekable().toFloat(); }
    188     MediaTime minMediaTimeSeekable() const override { return MediaTime::zeroTime(); }
    189 
    190     bool didLoadingProgress() const override;
    191     unsigned long long totalBytes() const override;
    192 
    193     bool hasSingleSecurityOrigin() const override;
    194     Optional<bool> wouldTaintOrigin(const SecurityOrigin&) const override;
    195 
    196     void simulateAudioInterruption() override;
    197 
     169    double minTimeSeekable() const final { return minMediaTimeSeekable().toFloat(); }
     170    MediaTime minMediaTimeSeekable() const final { return MediaTime::zeroTime(); }
     171    bool didLoadingProgress() const final;
     172    unsigned long long totalBytes() const final;
     173    bool hasSingleSecurityOrigin() const final;
     174    Optional<bool> wouldTaintOrigin(const SecurityOrigin&) const final;
     175    void simulateAudioInterruption() final;
    198176#if ENABLE(WEB_AUDIO)
    199     AudioSourceProvider* audioSourceProvider() override;
    200 #endif
    201 
    202     void paint(GraphicsContext&, const FloatRect&) override;
    203 
    204     bool supportsFullscreen() const override;
    205 
    206     MediaPlayer::MovieLoadType movieLoadType() const override;
    207 
    208     MediaPlayer* mediaPlayer() const { return m_player; }
    209 
    210     unsigned decodedFrameCount() const override;
    211     unsigned droppedFrameCount() const override;
    212     unsigned audioDecodedByteCount() const override;
    213     unsigned videoDecodedByteCount() const override;
    214 
    215     void acceleratedRenderingStateChanged() override;
     177    AudioSourceProvider* audioSourceProvider() final;
     178#endif
     179    void paint(GraphicsContext&, const FloatRect&) final;
     180    bool supportsFullscreen() const final;
     181    MediaPlayer::MovieLoadType movieLoadType() const final;
     182
     183    unsigned decodedFrameCount() const final;
     184    unsigned droppedFrameCount() const final;
     185    unsigned audioDecodedByteCount() const final;
     186    unsigned videoDecodedByteCount() const final;
     187
     188    void acceleratedRenderingStateChanged() final;
    216189
    217190#if USE(TEXTURE_MAPPER_GL)
     
    226199
    227200#if ENABLE(ENCRYPTED_MEDIA)
    228     void cdmInstanceAttached(CDMInstance&) override;
    229     void cdmInstanceDetached(CDMInstance&) override;
     201    void cdmInstanceAttached(CDMInstance&) final;
     202    void cdmInstanceDetached(CDMInstance&) final;
     203    void attemptToDecryptWithInstance(CDMInstance&) final;
     204    bool waitingForKey() const final;
     205
    230206    void handleProtectionEvent(GstEvent*);
    231     virtual void attemptToDecryptWithLocalInstance();
    232     void attemptToDecryptWithInstance(CDMInstance&) final;
    233     void initializationDataEncountered(InitData&&);
    234     void setWaitingForKey(bool);
    235     bool waitingForKey() const override;
    236 #endif
    237 
    238     static bool supportsKeySystem(const String& keySystem, const String& mimeType);
    239     static MediaPlayer::SupportsType extendedSupportsType(const MediaEngineSupportParameters&, MediaPlayer::SupportsType);
     207#endif
    240208
    241209#if USE(GSTREAMER_GL)
     
    244212#endif
    245213
    246     void setVideoSourceOrientation(ImageOrientation);
    247     GstElement* pipeline() const { return m_pipeline.get(); }
    248214    void enableTrack(TrackPrivateBaseGStreamer::TrackType, unsigned index);
    249215
    250216    // Append pipeline interface
     217    // FIXME: Use the client interface pattern, AppendPipeline does not need the full interface to this class just for these two functions.
    251218    bool handleSyncMessage(GstMessage*);
    252219    void handleMessage(GstMessage*);
     
    271238    };
    272239
    273     virtual bool isLiveStream() const { return m_isStreaming; }
    274     MediaTime maxTimeLoaded() const;
     240    static bool isAvailable();
     241#if ENABLE(ENCRYPTED_MEDIA)
     242    static bool supportsKeySystem(const String& keySystem, const String& mimeType);
     243#endif
    275244
    276245    virtual void durationChanged();
     
    279248    virtual bool changePipelineState(GstState);
    280249
    281 
    282250#if USE(GSTREAMER_HOLEPUNCH)
    283251    GstElement* createHolePunchVideoSink();
     
    293261    void pushTextureToCompositor();
    294262#if USE(NICOSIA)
    295     void swapBuffersIfNeeded() override;
     263    void swapBuffersIfNeeded() final;
    296264#else
    297     RefPtr<TextureMapperPlatformLayerProxy> proxy() const override;
    298     void swapBuffersIfNeeded() override;
     265    RefPtr<TextureMapperPlatformLayerProxy> proxy() const final;
     266    void swapBuffersIfNeeded() final;
    299267#endif
    300268#endif
     
    317285    static void volumeChangedCallback(MediaPlayerPrivateGStreamer*);
    318286    static void muteChangedCallback(MediaPlayerPrivateGStreamer*);
    319 
    320     // FIXME: Where is this used?
    321     void handlePluginInstallerResult(GstInstallPluginsReturn);
    322287
    323288    void readyTimerFired();
     
    359324    mutable MediaTime m_cachedDuration;
    360325    bool m_canFallBackToLastFinishedSeekPosition { false };
    361     bool m_changingRate { false };
    362     bool m_downloadFinished { false };
    363     bool m_errorOccured { false };
     326    bool m_isChangingRate { false };
     327    bool m_didDownloadFinish { false };
     328    bool m_didErrorOccur { false };
    364329    mutable bool m_isEndReached { false };
    365     mutable bool m_isStreaming { false };
    366     bool m_paused { true };
     330    mutable bool m_isLiveStream { false };
     331    bool m_isPaused { true };
    367332    float m_playbackRate { 1 };
    368333    GstState m_currentState;
    369334    GstState m_oldState;
    370335    GstState m_requestedState { GST_STATE_VOID_PENDING };
    371     bool m_resetPipeline { false };
    372     bool m_seeking { false };
    373     bool m_seekIsPending { false };
     336    bool m_shouldResetPipeline { false };
     337    bool m_isSeeking { false };
     338    bool m_isSeekPending { false };
    374339    MediaTime m_seekTime;
    375340    GRefPtr<GstElement> m_source { nullptr };
    376     bool m_volumeAndMuteInitialized { false };
     341    bool m_areVolumeAndMuteInitialized { false };
    377342
    378343#if USE(TEXTURE_MAPPER_GL)
     
    392357
    393358    mutable FloatSize m_videoSize;
    394     bool m_usingFallbackVideoSink { false };
    395     bool m_renderingCanBeAccelerated { false };
    396 
    397     bool m_destroying { false };
     359    bool m_isUsingFallbackVideoSink { false };
     360    bool m_canRenderingBeAccelerated { false };
     361
     362    bool m_isBeingDestroyed { false };
    398363
    399364#if USE(GSTREAMER_GL)
     
    413378    HashSet<uint32_t> m_handledProtectionEvents;
    414379
    415     bool m_waitingForKey { false };
     380    bool m_isWaitingForKey { false };
    416381#endif
    417382
     
    419384
    420385private:
     386    MediaTime maxTimeLoaded() const;
     387    GstElement* pipeline() const { return m_pipeline.get(); }
     388    void setVideoSourceOrientation(ImageOrientation);
     389    MediaTime platformDuration() const;
     390    bool isMuted() const;
     391    void commitLoad();
    421392    void fillTimerFired();
    422 
    423393    void didEnd();
    424 
    425394
    426395    GstElement* createVideoSink();
     
    476445    void clearTracks();
    477446
     447#if ENABLE(ENCRYPTED_MEDIA)
     448    void attemptToDecryptWithLocalInstance();
     449    void initializationDataEncountered(InitData&&);
     450    void setWaitingForKey(bool);
     451#endif
     452
    478453#if ENABLE(VIDEO_TRACK)
    479454    GRefPtr<GstElement> m_textAppSink;
     
    482457    GstStructure* m_mediaLocations { nullptr };
    483458    int m_mediaLocationCurrentIndex { 0 };
    484     bool m_playbackRatePause { false };
     459    bool m_isPlaybackRatePaused { false };
    485460    MediaTime m_timeOfOverlappingSeek;
    486461    float m_lastPlaybackRate { 1 };
     
    489464    bool m_loadingStalled { false };
    490465    MediaPlayer::Preload m_preload;
    491     bool m_delayingLoad { false };
     466    bool m_isDelayingLoad { false };
    492467    mutable MediaTime m_maxTimeLoadedAtLastDidLoadingProgress;
    493468    bool m_hasVideo { false };
     
    504479#endif
    505480#endif
    506     bool m_buffering { false };
     481    bool m_isBuffering { false };
    507482    int m_bufferingPercentage { 0 };
    508483    mutable unsigned long long m_totalBytes { 0 };
    509484    URL m_url;
    510     bool m_preservesPitch { false };
     485    bool m_shouldPreservePitch { false };
    511486    mutable Optional<Seconds> m_lastQueryTime;
    512487    bool m_isLegacyPlaybin;
  • trunk/Source/WebCore/platform/graphics/gstreamer/mse/MediaPlayerPrivateGStreamerMSE.cpp

    r252938 r252950  
    133133void MediaPlayerPrivateGStreamerMSE::pause()
    134134{
    135     m_paused = true;
     135    // FIXME: Should not need direct access to this member. This override is probably not needed.
     136    m_isPaused = true;
    136137    MediaPlayerPrivateGStreamer::pause();
    137138}
     
    139140MediaTime MediaPlayerPrivateGStreamerMSE::durationMediaTime() const
    140141{
    141     if (UNLIKELY(!m_pipeline || m_errorOccured))
     142    if (UNLIKELY(!m_pipeline || m_didErrorOccur))
    142143        return MediaTime();
    143144
     
    147148void MediaPlayerPrivateGStreamerMSE::seek(const MediaTime& time)
    148149{
    149     if (UNLIKELY(!m_pipeline || m_errorOccured))
     150    if (UNLIKELY(!m_pipeline || m_didErrorOccur))
    150151        return;
    151152
     
    155156    MediaTime current = currentMediaTime();
    156157    if (time == current) {
    157         if (!m_seeking)
     158        if (!m_isSeeking)
    158159            timeChanged();
    159160        return;
    160161    }
    161162
    162     if (isLiveStream())
    163         return;
    164 
    165     if (m_seeking && m_seekIsPending) {
     163    if (m_isLiveStream)
     164        return;
     165
     166    if (m_isSeeking && m_isSeekPending) {
    166167        m_seekTime = time;
    167168        return;
     
    180181
    181182    m_isEndReached = false;
    182     GST_DEBUG("m_seeking=%s, m_seekTime=%s", boolForPrinting(m_seeking), toString(m_seekTime).utf8().data());
     183    GST_DEBUG("m_isSeeking=%s, m_seekTime=%s", boolForPrinting(m_isSeeking), toString(m_seekTime).utf8().data());
    183184}
    184185
     
    233234
    234235    // Always move to seeking state to report correct 'currentTime' while pending for actual seek to complete.
    235     m_seeking = true;
     236    m_isSeeking = true;
    236237
    237238    // Check if playback pipeline is ready for seek.
     
    241242        GST_DEBUG("[Seek] cannot seek, current state change is %s", gst_element_state_change_return_get_name(getStateResult));
    242243        webKitMediaSrcSetReadyForSamples(WEBKIT_MEDIA_SRC(m_source.get()), true);
    243         m_seeking = false;
     244        m_isSeeking = false;
    244245        return false;
    245246    }
     
    263264        GST_DEBUG("[Seek] Delaying the seek: %s", reason.data());
    264265
    265         m_seekIsPending = true;
     266        m_isSeekPending = true;
    266267
    267268        if (m_isEndReached) {
    268269            GST_DEBUG("[Seek] reset pipeline");
    269             m_resetPipeline = true;
    270             m_seeking = false;
     270            m_shouldResetPipeline = true;
     271            m_isSeeking = false;
    271272            if (!changePipelineState(GST_STATE_PAUSED))
    272273                loadingFailed(MediaPlayer::Empty);
    273274            else
    274                 m_seeking = true;
     275                m_isSeeking = true;
    275276        }
    276277
    277         return m_seeking;
     278        return m_isSeeking;
    278279    }
    279280
     
    301302            GST_DEBUG("[Seek] Cannot seek, failed to pause playback pipeline.");
    302303            webKitMediaSrcSetReadyForSamples(WEBKIT_MEDIA_SRC(m_source.get()), true);
    303             m_seeking = false;
     304            m_isSeeking = false;
    304305            return false;
    305306        }
     
    315316        ASSERT(m_mseSeekCompleted);
    316317        // Note: seekCompleted will recursively call us.
    317         return m_seeking;
     318        return m_isSeeking;
    318319    }
    319320
     
    338339    if (!gst_element_seek(m_pipeline.get(), rate, GST_FORMAT_TIME, seekType, GST_SEEK_TYPE_SET, toGstClockTime(startTime), GST_SEEK_TYPE_SET, toGstClockTime(endTime))) {
    339340        webKitMediaSrcSetReadyForSamples(WEBKIT_MEDIA_SRC(m_source.get()), true);
    340         m_seeking = false;
     341        m_isSeeking = false;
    341342        m_gstSeekCompleted = true;
    342343        GST_DEBUG("doSeek(): gst_element_seek() failed, returning false");
     
    351352void MediaPlayerPrivateGStreamerMSE::maybeFinishSeek()
    352353{
    353     if (!m_seeking || !m_mseSeekCompleted || !m_gstSeekCompleted)
     354    if (!m_isSeeking || !m_mseSeekCompleted || !m_gstSeekCompleted)
    354355        return;
    355356
     
    363364    }
    364365
    365     if (m_seekIsPending) {
     366    if (m_isSeekPending) {
    366367        GST_DEBUG("[Seek] Committing pending seek to %s", toString(m_seekTime).utf8().data());
    367         m_seekIsPending = false;
     368        m_isSeekPending = false;
    368369        if (!doSeek()) {
    369370            GST_WARNING("[Seek] Seeking to %s failed", toString(m_seekTime).utf8().data());
     
    376377
    377378    webKitMediaSrcSetReadyForSamples(WEBKIT_MEDIA_SRC(m_source.get()), true);
    378     m_seeking = false;
     379    m_isSeeking = false;
    379380    m_cachedPosition = MediaTime::invalidTime();
    380381    // The pipeline can still have a pending state. In this case a position query will fail.
     
    391392bool MediaPlayerPrivateGStreamerMSE::seeking() const
    392393{
    393     return m_seeking;
     394    return m_isSeeking;
    394395}
    395396
     
    429430void MediaPlayerPrivateGStreamerMSE::waitForSeekCompleted()
    430431{
    431     if (!m_seeking)
     432    if (!m_isSeeking)
    432433        return;
    433434
     
    480481void MediaPlayerPrivateGStreamerMSE::updateStates()
    481482{
    482     if (UNLIKELY(!m_pipeline || m_errorOccured))
     483    if (UNLIKELY(!m_pipeline || m_didErrorOccur))
    483484        return;
    484485
     
    499500            break;
    500501
    501         m_resetPipeline = (state <= GST_STATE_READY);
    502         if (m_resetPipeline)
     502        m_shouldResetPipeline = (state <= GST_STATE_READY);
     503        if (m_shouldResetPipeline)
    503504            m_mediaTimeDuration = MediaTime::zeroTime();
    504505
     
    539540        // Sync states where needed.
    540541        if (state == GST_STATE_PAUSED) {
    541             if (!m_volumeAndMuteInitialized) {
     542            if (!m_areVolumeAndMuteInitialized) {
    542543                notifyPlayerOfVolumeChange();
    543544                notifyPlayerOfMute();
    544                 m_volumeAndMuteInitialized = true;
     545                m_areVolumeAndMuteInitialized = true;
    545546            }
    546547
    547             if (!seeking() && !m_paused && m_playbackRate) {
     548            if (!seeking() && !m_isPaused && m_playbackRate) {
    548549                GST_DEBUG("[Buffering] Restarting playback.");
    549550                changePipelineState(GST_STATE_PLAYING);
    550551            }
    551552        } else if (state == GST_STATE_PLAYING) {
    552             m_paused = false;
     553            m_isPaused = false;
    553554
    554555            if (!m_playbackRate) {
     
    557558            }
    558559        } else
    559             m_paused = true;
     560            m_isPaused = true;
    560561
    561562        if (m_requestedState == GST_STATE_PAUSED && state == GST_STATE_PAUSED) {
     
    578579
    579580        // Live pipelines go in PAUSED without prerolling.
    580         m_isStreaming = true;
     581        m_isLiveStream = true;
    581582
    582583        if (state == GST_STATE_READY) {
     
    586587            m_readyState = MediaPlayer::HaveEnoughData;
    587588            GST_DEBUG("m_readyState=%s", dumpReadyState(m_readyState));
    588             m_paused = true;
     589            m_isPaused = true;
    589590        } else if (state == GST_STATE_PLAYING)
    590             m_paused = false;
    591 
    592         if (!m_paused && m_playbackRate)
     591            m_isPaused = false;
     592
     593        if (!m_isPaused && m_playbackRate)
    593594            changePipelineState(GST_STATE_PLAYING);
    594595
     
    621622void MediaPlayerPrivateGStreamerMSE::asyncStateChangeDone()
    622623{
    623     if (UNLIKELY(!m_pipeline || m_errorOccured))
    624         return;
    625 
    626     if (m_seeking)
     624    if (UNLIKELY(!m_pipeline || m_didErrorOccur))
     625        return;
     626
     627    if (m_isSeeking)
    627628        maybeFinishSeek();
    628629    else
     
    775776MediaTime MediaPlayerPrivateGStreamerMSE::maxMediaTimeSeekable() const
    776777{
    777     if (UNLIKELY(m_errorOccured))
     778    if (UNLIKELY(m_didErrorOccur))
    778779        return MediaTime::zeroTime();
    779780
  • trunk/Source/WebCore/platform/graphics/gstreamer/mse/MediaPlayerPrivateGStreamerMSE.h

    r252938 r252950  
    5555    void updateDownloadBufferingFlag() override { };
    5656
    57     bool isLiveStream() const override { return false; }
    5857    MediaTime currentMediaTime() const override;
    5958
  • trunk/Source/WebCore/platform/graphics/gstreamer/mse/MediaSourceClientGStreamerMSE.cpp

    r252938 r252950  
    164164
    165165    // This is only for on-the-fly reenqueues after appends. When seeking, the seek will do its own flush.
    166     if (!m_playerPrivate.m_seeking)
     166    // FIXME: Should not be touching private parts.
     167    if (!m_playerPrivate.m_isSeeking)
    167168        m_playerPrivate.m_playbackPipeline->flush(trackId);
    168169}
Note: See TracChangeset for help on using the changeset viewer.