Changeset 245039 in webkit


Ignore:
Timestamp:
May 7, 2019 3:00:32 PM (5 years ago)
Author:
eric.carlson@apple.com
Message:

Define media buffering policy
​https://bugs.webkit.org/show_bug.cgi?id=196979
<rdar://problem/28383861>

Reviewed by Jer Noble.

Source/WebCore:

Test: MediaBufferingPolicy API test.

  • html/HTMLMediaElement.cpp:

(WebCore::HTMLMediaElement::HTMLMediaElement):
(WebCore::HTMLMediaElement::suspend):
(WebCore::HTMLMediaElement::resume):
(WebCore::HTMLMediaElement::createMediaPlayer):
(WebCore::HTMLMediaElement::setBufferingPolicy):
(WebCore::HTMLMediaElement::purgeBufferedDataIfPossible):
(WebCore::HTMLMediaElement::bufferingPolicy const):
(WebCore::HTMLMediaElement::setShouldBufferData): Deleted.

  • html/HTMLMediaElement.h:

(WebCore::HTMLMediaElement::shouldBufferData const): Deleted.

  • html/MediaElementSession.cpp:

(WebCore::MediaElementSession::updateClientDataBuffering):
(WebCore::MediaElementSession::preferredBufferingPolicy const):
(WebCore::MediaElementSession::dataBufferingPermitted const): Deleted.

  • html/MediaElementSession.h:
  • platform/graphics/MediaPlayer.cpp:

(WebCore::MediaPlayer::setBufferingPolicy):
(WebCore::convertEnumerationToString):
(WebCore::MediaPlayer::setShouldBufferData): Deleted.

  • platform/graphics/MediaPlayer.h:
  • platform/graphics/MediaPlayerEnums.h:

(WTF::LogArgument<WebCore::MediaPlayerEnums::BufferingPolicy>::toString):

  • platform/graphics/MediaPlayerPrivate.h:

(WebCore::MediaPlayerPrivateInterface::setBufferingPolicy):
(WebCore::MediaPlayerPrivateInterface::setShouldBufferData): Deleted.

  • platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.h:
  • platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm:

(WebCore::MediaPlayerPrivateAVFoundationObjC::MediaPlayerPrivateAVFoundationObjC):
(WebCore::MediaPlayerPrivateAVFoundationObjC::setBufferingPolicy):
(WebCore::MediaPlayerPrivateAVFoundationObjC::setShouldBufferData): Deleted.

  • platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.h:
  • platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.mm:

(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::setBufferingPolicy):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::flushAndRemoveVideoSampleBuffers): Deleted.
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::setShouldBufferData): Deleted.

  • testing/Internals.cpp:

(WebCore::Internals::elementShouldBufferData):
(WebCore::Internals::elementBufferingPolicy):

  • testing/Internals.h:
  • testing/Internals.idl:

Source/WebCore/PAL:

  • pal/spi/mac/AVFoundationSPI.h:

Source/WTF:

  • wtf/Platform.h:

Tools:

  • TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj:
  • TestWebKitAPI/Tests/WebKitCocoa/MediaBufferingPolicy.mm: Added.

(waitUntilBufferingPolicyIsEqualTo):
(TEST):

Location:
trunk
Files:
1 added
22 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WTF/ChangeLog

    r245030 r245039  
     12019-05-07  Eric Carlson  <eric.carlson@apple.com>
     2
     3        Define media buffering policy
     4        https://bugs.webkit.org/show_bug.cgi?id=196979
     5        <rdar://problem/28383861>
     6
     7        Reviewed by Jer Noble.
     8
     9        * wtf/Platform.h:
     10
    1112019-05-07  Robin Morisset  <rmorisset@apple.com>
    212

  • trunk/Source/WTF/wtf/Platform.h

    r244994 r245039  
    15281528#define HAVE_ROUTE_SHARING_POLICY_LONG_FORM_VIDEO 1
    15291529#endif
     1530
     1531#if (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500) || (PLATFORM(IOS) && __IPHONE_OS_VERSION_MIN_REQUIRED >= 130000) || (PLATFORM(WATCHOS) && __WATCH_OS_VERSION_MIN_REQUIRED >= 60000) || (PLATFORM(APPLETV) && __TV_OS_VERSION_MIN_REQUIRED >= 130000)
     1532#define HAVE_AVPLAYER_RESOURCE_CONSERVATION_LEVEL 1
     1533#endif
     1534

  • trunk/Source/WebCore/ChangeLog

    r245038 r245039  
     12019-05-07  Eric Carlson  <eric.carlson@apple.com>
     2
     3        Define media buffering policy
     4        https://bugs.webkit.org/show_bug.cgi?id=196979
     5        <rdar://problem/28383861>
     6
     7        Reviewed by Jer Noble.
     8
     9        Test: MediaBufferingPolicy API test.
     10
     11        * html/HTMLMediaElement.cpp:
     12        (WebCore::HTMLMediaElement::HTMLMediaElement):
     13        (WebCore::HTMLMediaElement::suspend):
     14        (WebCore::HTMLMediaElement::resume):
     15        (WebCore::HTMLMediaElement::createMediaPlayer):
     16        (WebCore::HTMLMediaElement::setBufferingPolicy):
     17        (WebCore::HTMLMediaElement::purgeBufferedDataIfPossible):
     18        (WebCore::HTMLMediaElement::bufferingPolicy const):
     19        (WebCore::HTMLMediaElement::setShouldBufferData): Deleted.
     20        * html/HTMLMediaElement.h:
     21        (WebCore::HTMLMediaElement::shouldBufferData const): Deleted.
     22        * html/MediaElementSession.cpp:
     23        (WebCore::MediaElementSession::updateClientDataBuffering):
     24        (WebCore::MediaElementSession::preferredBufferingPolicy const):
     25        (WebCore::MediaElementSession::dataBufferingPermitted const): Deleted.
     26        * html/MediaElementSession.h:
     27        * platform/graphics/MediaPlayer.cpp:
     28        (WebCore::MediaPlayer::setBufferingPolicy):
     29        (WebCore::convertEnumerationToString):
     30        (WebCore::MediaPlayer::setShouldBufferData): Deleted.
     31        * platform/graphics/MediaPlayer.h:
     32        * platform/graphics/MediaPlayerEnums.h:
     33        (WTF::LogArgument<WebCore::MediaPlayerEnums::BufferingPolicy>::toString):
     34        * platform/graphics/MediaPlayerPrivate.h:
     35        (WebCore::MediaPlayerPrivateInterface::setBufferingPolicy):
     36        (WebCore::MediaPlayerPrivateInterface::setShouldBufferData): Deleted.
     37        * platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.h:
     38        * platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm:
     39        (WebCore::MediaPlayerPrivateAVFoundationObjC::MediaPlayerPrivateAVFoundationObjC):
     40        (WebCore::MediaPlayerPrivateAVFoundationObjC::setBufferingPolicy):
     41        (WebCore::MediaPlayerPrivateAVFoundationObjC::setShouldBufferData): Deleted.
     42        * platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.h:
     43        * platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.mm:
     44        (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::setBufferingPolicy):
     45        (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::flushAndRemoveVideoSampleBuffers): Deleted.
     46        (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::setShouldBufferData): Deleted.
     47        * testing/Internals.cpp:
     48        (WebCore::Internals::elementShouldBufferData):
     49        (WebCore::Internals::elementBufferingPolicy):
     50        * testing/Internals.h:
     51        * testing/Internals.idl:
     52
    1532019-05-07  Alex Christensen  <achristensen@webkit.org>
    254

  • trunk/Source/WebCore/PAL/ChangeLog

    r244955 r245039  
     12019-05-07  Eric Carlson  <eric.carlson@apple.com>
     2
     3        Define media buffering policy
     4        https://bugs.webkit.org/show_bug.cgi?id=196979
     5        <rdar://problem/28383861>
     6
     7        Reviewed by Jer Noble.
     8
     9        * pal/spi/mac/AVFoundationSPI.h:
     10
    1112019-05-04  Alex Christensen  <achristensen@webkit.org>
    212

  • trunk/Source/WebCore/PAL/pal/spi/mac/AVFoundationSPI.h

    r240592 r245039  
    325325#endif
    326326
     327#if !USE(APPLE_INTERNAL_SDK) && HAVE(AVPLAYER_RESOURCE_CONSERVATION_LEVEL)
     328@interface AVPlayer (AVPlayerPrivate)
     329
     330@property (nonatomic) AVPlayerResourceConservationLevel resourceConservationLevelWhilePaused;
     331
     332typedef NS_ENUM(NSInteger, AVPlayerResourceConservationLevel) {
     333    AVPlayerResourceConservationLevelNone                                 = 0,
     334    AVPlayerResourceConservationLevelReduceReadAhead                      = 1,
     335    AVPlayerResourceConservationLevelReuseActivePlayerResources           = 2,
     336    AVPlayerResourceConservationLevelRecycleBuffer                        = 3,
     337};
     338@end
     339#endif

  • trunk/Source/WebCore/html/HTMLMediaElement.cpp

    r244815 r245039  
    450450    , m_havePreparedToPlay(false)
    451451    , m_parsingInProgress(createdByParser)
    452     , m_shouldBufferData(true)
    453452    , m_elementIsHidden(document.hidden())
    454453    , m_creatingControls(false)
    … …  
    57805779        stopWithoutDestroyingMediaPlayer();
    57815780        m_asyncEventQueue.suspend();
    5782         setShouldBufferData(false);
     5781        setBufferingPolicy(BufferingPolicy::MakeResourcesPurgeable);
    57835782        m_mediaSession->addBehaviorRestriction(MediaElementSession::RequirePageConsentToResumeMedia);
    57845783        break;
    … …  
    57995798    m_asyncEventQueue.resume();
    58005799
    5801     setShouldBufferData(true);
    5802 
    58035800    if (!m_mediaSession->pageAllowsPlaybackAfterResuming())
    58045801        document().addMediaCanStartListener(*this);
    … …  
    58075804
    58085805    m_mediaSession->removeBehaviorRestriction(MediaElementSession::RequirePageConsentToResumeMedia);
     5806    m_mediaSession->updateBufferingPolicy();
    58095807
    58105808    if (m_error && m_error->code() == MediaError::MEDIA_ERR_ABORTED && !m_resumeTaskQueue.hasPendingTask()) {
    … …  
    67066704
    67076705    m_player = MediaPlayer::create(*this);
    6708     m_player->setShouldBufferData(m_shouldBufferData);
     6706    m_player->setBufferingPolicy(m_bufferingPolicy);
    67096707    schedulePlaybackControlsManagerUpdate();
    67106708
    … …  
    78837881}
    78847882
    7885 void HTMLMediaElement::setShouldBufferData(bool shouldBuffer)
    7886 {
    7887     if (shouldBuffer == m_shouldBufferData)
    7888         return;
    7889 
    7890     m_shouldBufferData = shouldBuffer;
     7883void HTMLMediaElement::setBufferingPolicy(BufferingPolicy policy)
     7884{
     7885    if (policy == m_bufferingPolicy)
     7886        return;
     7887
     7888    INFO_LOG(LOGIDENTIFIER, policy);
     7889
     7890    m_bufferingPolicy = policy;
    78917891    if (m_player)
    7892         m_player->setShouldBufferData(shouldBuffer);
     7892        m_player->setBufferingPolicy(policy);
    78937893}
    78947894
    78957895void HTMLMediaElement::purgeBufferedDataIfPossible()
    78967896{
    7897 #if PLATFORM(IOS_FAMILY)
    7898     if (!MemoryPressureHandler::singleton().isUnderMemoryPressure() && m_mediaSession->dataBufferingPermitted())
     7897    INFO_LOG(LOGIDENTIFIER);
     7898
     7899    if (!MemoryPressureHandler::singleton().isUnderMemoryPressure() && m_mediaSession->preferredBufferingPolicy() == BufferingPolicy::Default)
    78997900        return;
    79007901
    … …  
    79047905    }
    79057906
    7906     // This is called to relieve memory pressure. Turning off buffering causes the media playback
    7907     // daemon to release memory associated with queued-up video frames.
    7908     // We turn it back on right away, but new frames won't get loaded unless playback is resumed.
    7909     INFO_LOG(LOGIDENTIFIER, "toggling data buffering");
    7910     setShouldBufferData(false);
    7911     setShouldBufferData(true);
    7912 #endif
     7907    setBufferingPolicy(BufferingPolicy::PurgeResources);
    79137908}
    79147909
    … …  
    81328127}
    81338128
    8134 }
    8135 
    8136 #endif
     8129HTMLMediaElementEnums::BufferingPolicy HTMLMediaElement::bufferingPolicy() const
     8130{
     8131    return m_bufferingPolicy;   
     8132}
     8133
     8134}
     8135
     8136#endif

  • trunk/Source/WebCore/html/HTMLMediaElement.h

    r244815 r245039  
    269269    WEBCORE_EXPORT void play() override;
    270270    WEBCORE_EXPORT void pause() override;
    271     void setShouldBufferData(bool);
    272     WEBCORE_EXPORT bool shouldBufferData() const { return m_shouldBufferData; }
    273271    WEBCORE_EXPORT void fastSeek(double);
    274272    double minFastReverseRate() const;
    275273    double maxFastForwardRate() const;
    276274
    277     void purgeBufferedDataIfPossible();
     275    using HTMLMediaElementEnums::BufferingPolicy;
     276    void setBufferingPolicy(BufferingPolicy);
     277    WEBCORE_EXPORT BufferingPolicy bufferingPolicy() const;
     278    WEBCORE_EXPORT void purgeBufferedDataIfPossible();
    278279
    279280// captions
    … …  
    10731074    ScanDirection m_scanDirection { Forward };
    10741075
     1076    BufferingPolicy m_bufferingPolicy { BufferingPolicy::Default };
     1077
    10751078    bool m_firstTimePlaying : 1;
    10761079    bool m_playing : 1;
    … …  
    11001103    bool m_havePreparedToPlay : 1;
    11011104    bool m_parsingInProgress : 1;
    1102     bool m_shouldBufferData : 1;
    11031105    bool m_elementIsHidden : 1;
    11041106    bool m_elementWasRemovedFromDOM : 1;

  • trunk/Source/WebCore/html/MediaElementSession.cpp

    r244440 r245039  
    217217        m_clientDataBufferingTimer.stop();
    218218
    219     m_element.setShouldBufferData(dataBufferingPermitted());
     219    m_element.setBufferingPolicy(preferredBufferingPolicy());
    220220}
    221221
    … …  
    357357}
    358358
    359 bool MediaElementSession::dataBufferingPermitted() const
     359MediaPlayer::BufferingPolicy MediaElementSession::preferredBufferingPolicy() const
    360360{
    361361    if (isSuspended())
    362         return false;
     362        return MediaPlayer::BufferingPolicy::MakeResourcesPurgeable;
    363363
    364364    if (bufferingSuspended())
    365         return false;
     365        return MediaPlayer::BufferingPolicy::LimitReadAhead;
    366366
    367367    if (state() == PlatformMediaSession::Playing)
    368         return true;
     368        return MediaPlayer::BufferingPolicy::Default;
    369369
    370370    if (shouldOverrideBackgroundLoadingRestriction())
    371         return true;
     371        return MediaPlayer::BufferingPolicy::Default;
    372372
    373373#if ENABLE(WIRELESS_PLAYBACK_TARGET)
    374374    if (m_shouldPlayToPlaybackTarget)
    375         return true;
     375        return MediaPlayer::BufferingPolicy::Default;
    376376#endif
    377377
    378378    if (m_elementIsHiddenUntilVisibleInViewport || m_elementIsHiddenBecauseItWasRemovedFromDOM || m_element.elementIsHidden())
    379         return false;
    380 
    381     return true;
     379        return MediaPlayer::BufferingPolicy::MakeResourcesPurgeable;
     380
     381    return MediaPlayer::BufferingPolicy::Default;
    382382}
    383383

  • trunk/Source/WebCore/html/MediaElementSession.h

    r243451 r245039  
    7474    bool autoplayPermitted() const;
    7575    bool dataLoadingPermitted() const;
    76     bool dataBufferingPermitted() const;
     76    MediaPlayer::BufferingPolicy preferredBufferingPolicy() const;
    7777    bool fullscreenPermitted() const;
    7878    bool pageAllowsDataLoading() const;
    … …  
    105105    void resumeBuffering() override;
    106106    bool bufferingSuspended() const;
     107    void updateBufferingPolicy() { scheduleClientDataBufferingCheck(); }
    107108
    108109    // Restrictions to modify default behaviors.

  • trunk/Source/WebCore/platform/graphics/MediaPlayer.cpp

    r242033 r245039  
    564564}
    565565
    566 void MediaPlayer::setShouldBufferData(bool shouldBuffer)
    567 {
    568     m_private->setShouldBufferData(shouldBuffer);
     566void MediaPlayer::setBufferingPolicy(BufferingPolicy policy)
     567{
     568    m_private->setBufferingPolicy(policy);
    569569}
    570570
    … …  
    16411641}
    16421642
    1643 }
    1644 
    1645 #endif
     1643String convertEnumerationToString(MediaPlayerEnums::BufferingPolicy enumerationValue)
     1644{
     1645    static const NeverDestroyed<String> values[] = {
     1646        MAKE_STATIC_STRING_IMPL("Default"),
     1647        MAKE_STATIC_STRING_IMPL("LimitReadAhead"),
     1648        MAKE_STATIC_STRING_IMPL("MakeResourcesPurgeable"),
     1649        MAKE_STATIC_STRING_IMPL("PurgeResources"),
     1650    };
     1651    static_assert(!static_cast<size_t>(MediaPlayerEnums::BufferingPolicy::Default), "MediaPlayerEnums::Default is not 0 as expected");
     1652    static_assert(static_cast<size_t>(MediaPlayerEnums::BufferingPolicy::LimitReadAhead) == 1, "MediaPlayerEnums::LimitReadAhead is not 1 as expected");
     1653    static_assert(static_cast<size_t>(MediaPlayerEnums::BufferingPolicy::MakeResourcesPurgeable) == 2, "MediaPlayerEnums::MakeResourcesPurgeable is not 2 as expected");
     1654    static_assert(static_cast<size_t>(MediaPlayerEnums::BufferingPolicy::PurgeResources) == 3, "MediaPlayerEnums::PurgeResources is not 3 as expected");
     1655    ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
     1656    return values[static_cast<size_t>(enumerationValue)];
     1657}
     1658
     1659}
     1660
     1661#endif

  • trunk/Source/WebCore/platform/graphics/MediaPlayer.h

    r241585 r245039  
    313313    void play();
    314314    void pause();
    315     void setShouldBufferData(bool);
     315
     316    using MediaPlayerEnums::BufferingPolicy;
     317    void setBufferingPolicy(BufferingPolicy);
    316318
    317319#if ENABLE(LEGACY_ENCRYPTED_MEDIA)

  • trunk/Source/WebCore/platform/graphics/MediaPlayerEnums.h

    r241585 r245039  
    4444    };
    4545    typedef uint32_t VideoFullscreenMode;
     46
     47    enum class BufferingPolicy {
     48        Default,
     49        LimitReadAhead,
     50        MakeResourcesPurgeable,
     51        PurgeResources,
     52    };
    4653};
    4754
    … …  
    5057WTF::String convertEnumerationToString(MediaPlayerEnums::Preload);
    5158WTF::String convertEnumerationToString(MediaPlayerEnums::SupportsType);
     59WTF::String convertEnumerationToString(MediaPlayerEnums::BufferingPolicy);
    5260
    5361} // namespace WebCore
    … …  
    7583};
    7684
     85template <>
     86struct LogArgument<WebCore::MediaPlayerEnums::BufferingPolicy> {
     87    static WTF::String toString(const WebCore::MediaPlayerEnums::BufferingPolicy policy)
     88    {
     89        return convertEnumerationToString(policy);
     90    }
     91};
     92
    7793}; // namespace WTF

  • trunk/Source/WebCore/platform/graphics/MediaPlayerPrivate.h

    r241120 r245039  
    6969    virtual void play() = 0;
    7070    virtual void pause() = 0;   
    71     virtual void setShouldBufferData(bool) { }
     71    virtual void setBufferingPolicy(MediaPlayer::BufferingPolicy) { }
    7272
    7373    virtual bool supportsPictureInPicture() const { return false; }

  • trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.h

    r240401 r245039  
    122122    void canPlayFastForwardDidChange(bool);
    123123
    124     void setShouldBufferData(bool) override;
     124    void setBufferingPolicy(MediaPlayerEnums::BufferingPolicy) override;
    125125
    126126#if HAVE(AVFOUNDATION_VIDEO_OUTPUT)
    … …  
    425425    unsigned m_pendingStatusChanges;
    426426    int m_cachedItemStatus;
     427    MediaPlayer::BufferingPolicy m_bufferingPolicy { MediaPlayer::BufferingPolicy::Default };
    427428    bool m_cachedLikelyToKeepUp;
    428429    bool m_cachedBufferEmpty;
    429430    bool m_cachedBufferFull;
    430431    bool m_cachedHasEnabledAudio;
    431     bool m_shouldBufferData;
    432432    bool m_cachedIsReadyForDisplay;
    433433    bool m_haveBeenAskedToCreateLayer;

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

    r244980 r245039  
    349349    , m_cachedBufferFull(false)
    350350    , m_cachedHasEnabledAudio(false)
    351     , m_shouldBufferData(true)
    352351    , m_cachedIsReadyForDisplay(false)
    353352    , m_haveBeenAskedToCreateLayer(false)
    … …  
    380379void MediaPlayerPrivateAVFoundationObjC::cancelLoad()
    381380{
    382     INFO_LOG(LOGIDENTIFIER);
     381    ALWAYS_LOG(LOGIDENTIFIER);
    383382    tearDownVideoRendering();
    384383
    … …  
    544543    [m_videoLayer setContentsScale:player()->client().mediaPlayerContentsScale()];
    545544    IntSize defaultSize = snappedIntRect(player()->client().mediaPlayerContentBoxRect()).size();
    546     INFO_LOG(LOGIDENTIFIER);
     545    ALWAYS_LOG(LOGIDENTIFIER);
    547546
    548547    m_videoFullscreenLayerManager->setVideoLayer(m_videoLayer.get(), defaultSize);
    … …  
    559558        return;
    560559
    561     INFO_LOG(LOGIDENTIFIER);
     560    ALWAYS_LOG(LOGIDENTIFIER);
    562561
    563562    [m_videoLayer removeObserver:m_objcObserver.get() forKeyPath:@"readyForDisplay"];
    … …  
    699698        return;
    700699
    701     INFO_LOG(LOGIDENTIFIER);
     700    ALWAYS_LOG(LOGIDENTIFIER);
    702701
    703702    setDelayCallbacks(true);
    … …  
    836835        return;
    837836
    838     INFO_LOG(LOGIDENTIFIER);
     837    ALWAYS_LOG(LOGIDENTIFIER);
    839838
    840839    setDelayCallbacks(true);
    … …  
    885884        return;
    886885
    887     INFO_LOG(LOGIDENTIFIER);
     886    ALWAYS_LOG(LOGIDENTIFIER);
    888887
    889888    setDelayCallbacks(true);
    … …  
    11131112void MediaPlayerPrivateAVFoundationObjC::platformPlay()
    11141113{
    1115     INFO_LOG(LOGIDENTIFIER);
    11161114    if (!metaDataAvailable())
    11171115        return;
     1116
     1117    ALWAYS_LOG(LOGIDENTIFIER);
    11181118
    11191119    m_requestedPlaying = true;
    … …  
    11231123void MediaPlayerPrivateAVFoundationObjC::platformPause()
    11241124{
    1125     INFO_LOG(LOGIDENTIFIER);
    11261125    if (!metaDataAvailable())
    11271126        return;
     1127
     1128    ALWAYS_LOG(LOGIDENTIFIER);
    11281129
    11291130    m_requestedPlaying = false;
    … …  
    12161217        return;
    12171218
     1219    ALWAYS_LOG(LOGIDENTIFIER, volume);
     1220
    12181221    [m_avPlayer.get() setVolume:volume];
    12191222#endif
    … …  
    12251228        return;
    12261229
    1227     INFO_LOG(LOGIDENTIFIER, muted);
     1230    ALWAYS_LOG(LOGIDENTIFIER, muted);
    12281231
    12291232    m_muted = muted;
    … …  
    12421245        return;
    12431246
    1244     INFO_LOG(LOGIDENTIFIER, closedCaptionsVisible);
     1247    ALWAYS_LOG(LOGIDENTIFIER, closedCaptionsVisible);
    12451248}
    12461249
    … …  
    28602863}
    28612864
    2862 void MediaPlayerPrivateAVFoundationObjC::setShouldBufferData(bool shouldBuffer)
    2863 {
    2864     INFO_LOG(LOGIDENTIFIER, shouldBuffer);
    2865 
    2866     if (m_shouldBufferData == shouldBuffer)
    2867         return;
    2868 
    2869     m_shouldBufferData = shouldBuffer;
     2865void MediaPlayerPrivateAVFoundationObjC::setBufferingPolicy(MediaPlayer::BufferingPolicy policy)
     2866{
     2867    ALWAYS_LOG(LOGIDENTIFIER, policy);
     2868
     2869    if (m_bufferingPolicy == policy)
     2870        return;
     2871
     2872    m_bufferingPolicy = policy;
    28702873   
    28712874    if (!m_avPlayer)
    28722875        return;
    28732876
    2874     setAVPlayerItem(shouldBuffer ? m_avPlayerItem.get() : nil);
     2877#if HAVE(AVPLAYER_RESOURCE_CONSERVATION_LEVEL)
     2878    static_assert(static_cast<size_t>(MediaPlayer::BufferingPolicy::Default) == AVPlayerResourceConservationLevelNone, "MediaPlayer::BufferingPolicy::Default is not AVPlayerResourceConservationLevelNone as expected");
     2879    static_assert(static_cast<size_t>(MediaPlayer::BufferingPolicy::LimitReadAhead) == AVPlayerResourceConservationLevelReduceReadAhead, "MediaPlayer::BufferingPolicy::LimitReadAhead is not AVPlayerResourceConservationLevelReduceReadAhead as expected");
     2880    static_assert(static_cast<size_t>(MediaPlayer::BufferingPolicy::MakeResourcesPurgeable) == AVPlayerResourceConservationLevelReuseActivePlayerResources, "MediaPlayer::BufferingPolicy::MakeResourcesPurgeable is not AVPlayerResourceConservationLevelReuseActivePlayerResources as expected");
     2881    static_assert(static_cast<size_t>(MediaPlayer::BufferingPolicy::PurgeResources) == AVPlayerResourceConservationLevelRecycleBuffer, "MediaPlayer::BufferingPolicy::PurgeResources is not AVPlayerResourceConservationLevelRecycleBuffer as expected");
     2882
     2883    if ([m_avPlayer respondsToSelector:@selector(setResourceConservationLevelWhilePaused:)]) {
     2884        m_avPlayer.get().resourceConservationLevelWhilePaused = static_cast<AVPlayerResourceConservationLevel>(policy);
     2885        updateStates();
     2886        return;
     2887    }
     2888#endif
     2889
     2890    switch (policy) {
     2891    case MediaPlayer::BufferingPolicy::Default:
     2892        setAVPlayerItem(m_avPlayerItem.get());
     2893        break;
     2894    case MediaPlayer::BufferingPolicy::LimitReadAhead:
     2895    case MediaPlayer::BufferingPolicy::MakeResourcesPurgeable:
     2896        setAVPlayerItem(nil);
     2897        break;
     2898    case MediaPlayer::BufferingPolicy::PurgeResources:
     2899        setAVPlayerItem(nil);
     2900        setAVPlayerItem(m_avPlayerItem.get());
     2901        break;
     2902    }
     2903
    28752904    updateStates();
    28762905}

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

    r239319 r245039  
    155155    void enqueueVideoSample(MediaStreamTrackPrivate&, MediaSample&);
    156156    void enqueueCorrectedVideoSample(MediaSample&);
    157     void flushAndRemoveVideoSampleBuffers();
    158157    void requestNotificationWhenReadyForVideoData();
    159158
    … …  
    175174    bool ended() const override { return m_ended; }
    176175
    177     void setShouldBufferData(bool) override;
     176    void setBufferingPolicy(MediaPlayer::BufferingPolicy) override;
    178177
    179178    MediaPlayer::ReadyState currentReadyState();

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

    r244922 r245039  
    458458}
    459459
    460 void MediaPlayerPrivateMediaStreamAVFObjC::flushAndRemoveVideoSampleBuffers()
    461 {
    462     [m_sampleBufferDisplayLayer flushAndRemoveImage];
    463 }
    464 
    465460void MediaPlayerPrivateMediaStreamAVFObjC::ensureLayers()
    466461{
    … …  
    11501145}
    11511146
    1152 void MediaPlayerPrivateMediaStreamAVFObjC::setShouldBufferData(bool shouldBuffer)
    1153 {
    1154     if (!shouldBuffer)
    1155         flushAndRemoveVideoSampleBuffers();
     1147void MediaPlayerPrivateMediaStreamAVFObjC::setBufferingPolicy(MediaPlayer::BufferingPolicy policy)
     1148{
     1149    if (policy != MediaPlayer::BufferingPolicy::Default)
     1150        [m_sampleBufferDisplayLayer flushAndRemoveImage];
    11561151}
    11571152

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

    r245025 r245039  
    35023502bool Internals::elementShouldBufferData(HTMLMediaElement& element)
    35033503{
    3504     return element.shouldBufferData();
    3505 }
    3506 
     3504    return element.bufferingPolicy() < MediaPlayer::BufferingPolicy::LimitReadAhead;
     3505}
     3506
     3507String Internals::elementBufferingPolicy(HTMLMediaElement& element)
     3508{
     3509    switch (element.bufferingPolicy()) {
     3510    case MediaPlayer::BufferingPolicy::Default:
     3511        return "Default";
     3512    case MediaPlayer::BufferingPolicy::LimitReadAhead:
     3513        return "LimitReadAhead";
     3514    case MediaPlayer::BufferingPolicy::MakeResourcesPurgeable:
     3515        return "MakeResourcesPurgeable";
     3516    case MediaPlayer::BufferingPolicy::PurgeResources:
     3517        return "PurgeResources";
     3518    }
     3519
     3520    ASSERT_NOT_REACHED();
     3521    return "UNKNOWN";
     3522}
    35073523#endif
    35083524

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

    r245025 r245039  
    541541
    542542    bool elementShouldBufferData(HTMLMediaElement&);
     543    String elementBufferingPolicy(HTMLMediaElement&);
    543544#endif
    544545

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

    r245025 r245039  
    529529
    530530    [Conditional=VIDEO] boolean elementShouldBufferData(HTMLMediaElement media);
     531    [Conditional=VIDEO] DOMString elementBufferingPolicy(HTMLMediaElement media);
    531532
    532533    [Conditional=LEGACY_ENCRYPTED_MEDIA] void initializeMockCDM();

  • trunk/Tools/ChangeLog

    r245038 r245039  
     12019-05-07  Eric Carlson  <eric.carlson@apple.com>
     2
     3        Define media buffering policy
     4        https://bugs.webkit.org/show_bug.cgi?id=196979
     5        <rdar://problem/28383861>
     6
     7        Reviewed by Jer Noble.
     8
     9        * TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj:
     10        * TestWebKitAPI/Tests/WebKitCocoa/MediaBufferingPolicy.mm: Added.
     11        (waitUntilBufferingPolicyIsEqualTo):
     12        (TEST):
     13
    1142019-05-07  Alex Christensen  <achristensen@webkit.org>
    215

  • trunk/Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj

    r244955 r245039  
    3333                0799C34B1EBA3301003B7532 /* disableGetUserMedia.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = 0799C34A1EBA32F4003B7532 /* disableGetUserMedia.html */; };
    3434                07C046CA1E4262A8007201E7 /* CARingBuffer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 07C046C91E42573E007201E7 /* CARingBuffer.cpp */; };
     35                07CC7DFE2266330900E39181 /* MediaBufferingPolicy.mm in Sources */ = {isa = PBXBuildFile; fileRef = 07CC7DFD2266330800E39181 /* MediaBufferingPolicy.mm */; };
    3536                07CD32F62065B5430064A4BE /* AVFoundationPreference.mm in Sources */ = {isa = PBXBuildFile; fileRef = 07CD32F52065B5420064A4BE /* AVFoundationPreference.mm */; };
    3637                07CE1CF31F06A7E000BF89F5 /* GetUserMediaNavigation.mm in Sources */ = {isa = PBXBuildFile; fileRef = 07CE1CF21F06A7E000BF89F5 /* GetUserMediaNavigation.mm */; };
    … …  
    13501351                0799C34A1EBA32F4003B7532 /* disableGetUserMedia.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = disableGetUserMedia.html; sourceTree = "<group>"; };
    13511352                07C046C91E42573E007201E7 /* CARingBuffer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CARingBuffer.cpp; sourceTree = "<group>"; };
     1353                07CC7DFD2266330800E39181 /* MediaBufferingPolicy.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MediaBufferingPolicy.mm; sourceTree = "<group>"; };
    13521354                07CD32F52065B5420064A4BE /* AVFoundationPreference.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = AVFoundationPreference.mm; sourceTree = "<group>"; };
    13531355                07CD32F72065B72A0064A4BE /* video.html */ = {isa = PBXFileReference; lastKnownFileType = text.html; path = video.html; sourceTree = "<group>"; };
    … …  
    26242626                                8C10AF96206467770018FD90 /* LocalStoragePersistence.mm */,
    26252627                                7A6A2C6F1DCCF87B00C0D085 /* LocalStorageQuirkTest.mm */,
     2628                                07CC7DFD2266330800E39181 /* MediaBufferingPolicy.mm */,
    26262629                                5165FE03201EE617009F7EC3 /* MessagePortProviders.mm */,
    26272630                                51CD1C6A1B38CE3600142CA5 /* ModalAlerts.mm */,
    … …  
    42374240                                076E507F1F4513D6006E9F5A /* Logging.cpp in Sources */,
    42384241                                CE1866491F72E8F100A0CAB6 /* MarkedText.cpp in Sources */,
     4242                                07CC7DFE2266330900E39181 /* MediaBufferingPolicy.mm in Sources */,
    42394243                                CDA315981ED53651009F60D3 /* MediaPlaybackSleepAssertion.mm in Sources */,
    42404244                                CDC9442E1EF1FC080059C3C4 /* MediaStreamTrackDetached.mm in Sources */,
Note: See TracChangeset for help on using the changeset viewer.