Changeset 85518 in webkit


Ignore:
Timestamp:
May 2, 2011 2:04:42 PM (13 years ago)
Author:
commit-queue@webkit.org
Message:

2011-05-02 Sheriff Bot <​webkit.review.bot@gmail.com>

Unreviewed, rolling out r85483.
​http://trac.webkit.org/changeset/85483
​https://bugs.webkit.org/show_bug.cgi?id=59958

Causes media test failures. (Requested by eric_carlson on
#webkit).

  • html/HTMLMediaElement.cpp: (WebCore::HTMLMediaElement::HTMLMediaElement): (WebCore::HTMLMediaElement::prepareForLoad): (WebCore::HTMLMediaElement::seek): (WebCore::HTMLMediaElement::updatePlayState):
  • html/HTMLMediaElement.h:
  • platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.cpp: (WebCore::MediaPlayerPrivateAVFoundation::MediaPlayerPrivateAVFoundation): (WebCore::MediaPlayerPrivateAVFoundation::resumeLoad): (WebCore::MediaPlayerPrivateAVFoundation::load): (WebCore::MediaPlayerPrivateAVFoundation::prepareToPlay): (WebCore::MediaPlayerPrivateAVFoundation::paint): (WebCore::MediaPlayerPrivateAVFoundation::duration): (WebCore::MediaPlayerPrivateAVFoundation::seeking): (WebCore::MediaPlayerPrivateAVFoundation::updateStates): (WebCore::MediaPlayerPrivateAVFoundation::hasAvailableVideoFrame): (WebCore::MediaPlayerPrivateAVFoundation::metadataLoaded): (WebCore::MediaPlayerPrivateAVFoundation::loadedTimeRangesChanged): (WebCore::MediaPlayerPrivateAVFoundation::timeChanged): (WebCore::MediaPlayerPrivateAVFoundation::seekCompleted): (WebCore::MediaPlayerPrivateAVFoundation::repaint): (WebCore::MediaPlayerPrivateAVFoundation::setPreload):
  • platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.h:
  • platform/graphics/avfoundation/MediaPlayerPrivateAVFoundationObjC.h:
  • platform/graphics/avfoundation/MediaPlayerPrivateAVFoundationObjC.mm: (WebCore::MediaPlayerPrivateAVFoundationObjC::MediaPlayerPrivateAVFoundationObjC): (WebCore::MediaPlayerPrivateAVFoundationObjC::videoLayerIsReadyToDisplay): (WebCore::MediaPlayerPrivateAVFoundationObjC::createAVPlayerForURL): (WebCore::MediaPlayerPrivateAVFoundationObjC::createAVPlayerForCacheResource): (WebCore::MediaPlayerPrivateAVFoundationObjC::createAVPlayer): (WebCore::MediaPlayerPrivateAVFoundationObjC::beginLoadingMetadata): (WebCore::MediaPlayerPrivateAVFoundationObjC::playerItemStatus): (WebCore::MediaPlayerPrivateAVFoundationObjC::platformDuration): (WebCore::MediaPlayerPrivateAVFoundationObjC::assetStatus): (WebCore::MediaPlayerPrivateAVFoundationObjC::paint): (WebCore::MediaPlayerPrivateAVFoundationObjC::tracksChanged): (WebCore::MediaPlayerPrivateAVFoundationObjC::sizeChanged):
Location:
trunk/Source/WebCore
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r85515 r85518  
     12011-05-02  Sheriff Bot  <webkit.review.bot@gmail.com>
     2
     3        Unreviewed, rolling out r85483.
     4        http://trac.webkit.org/changeset/85483
     5        https://bugs.webkit.org/show_bug.cgi?id=59958
     6
     7        Causes media test failures. (Requested by eric_carlson on
     8        #webkit).
     9
     10        * html/HTMLMediaElement.cpp:
     11        (WebCore::HTMLMediaElement::HTMLMediaElement):
     12        (WebCore::HTMLMediaElement::prepareForLoad):
     13        (WebCore::HTMLMediaElement::seek):
     14        (WebCore::HTMLMediaElement::updatePlayState):
     15        * html/HTMLMediaElement.h:
     16        * platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.cpp:
     17        (WebCore::MediaPlayerPrivateAVFoundation::MediaPlayerPrivateAVFoundation):
     18        (WebCore::MediaPlayerPrivateAVFoundation::resumeLoad):
     19        (WebCore::MediaPlayerPrivateAVFoundation::load):
     20        (WebCore::MediaPlayerPrivateAVFoundation::prepareToPlay):
     21        (WebCore::MediaPlayerPrivateAVFoundation::paint):
     22        (WebCore::MediaPlayerPrivateAVFoundation::duration):
     23        (WebCore::MediaPlayerPrivateAVFoundation::seeking):
     24        (WebCore::MediaPlayerPrivateAVFoundation::updateStates):
     25        (WebCore::MediaPlayerPrivateAVFoundation::hasAvailableVideoFrame):
     26        (WebCore::MediaPlayerPrivateAVFoundation::metadataLoaded):
     27        (WebCore::MediaPlayerPrivateAVFoundation::loadedTimeRangesChanged):
     28        (WebCore::MediaPlayerPrivateAVFoundation::timeChanged):
     29        (WebCore::MediaPlayerPrivateAVFoundation::seekCompleted):
     30        (WebCore::MediaPlayerPrivateAVFoundation::repaint):
     31        (WebCore::MediaPlayerPrivateAVFoundation::setPreload):
     32        * platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.h:
     33        * platform/graphics/avfoundation/MediaPlayerPrivateAVFoundationObjC.h:
     34        * platform/graphics/avfoundation/MediaPlayerPrivateAVFoundationObjC.mm:
     35        (WebCore::MediaPlayerPrivateAVFoundationObjC::MediaPlayerPrivateAVFoundationObjC):
     36        (WebCore::MediaPlayerPrivateAVFoundationObjC::videoLayerIsReadyToDisplay):
     37        (WebCore::MediaPlayerPrivateAVFoundationObjC::createAVPlayerForURL):
     38        (WebCore::MediaPlayerPrivateAVFoundationObjC::createAVPlayerForCacheResource):
     39        (WebCore::MediaPlayerPrivateAVFoundationObjC::createAVPlayer):
     40        (WebCore::MediaPlayerPrivateAVFoundationObjC::beginLoadingMetadata):
     41        (WebCore::MediaPlayerPrivateAVFoundationObjC::playerItemStatus):
     42        (WebCore::MediaPlayerPrivateAVFoundationObjC::platformDuration):
     43        (WebCore::MediaPlayerPrivateAVFoundationObjC::assetStatus):
     44        (WebCore::MediaPlayerPrivateAVFoundationObjC::paint):
     45        (WebCore::MediaPlayerPrivateAVFoundationObjC::tracksChanged):
     46        (WebCore::MediaPlayerPrivateAVFoundationObjC::sizeChanged):
     47
    1482011-05-02  Adam Barth  <abarth@webkit.org>
    249

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

    r85488 r85518  
    172172    , m_loadInitiatedByUserGesture(false)
    173173    , m_completelyLoaded(false)
    174     , m_havePreparedToPlay(false)
    175174{
    176175    LOG(Media, "HTMLMediaElement::HTMLMediaElement");
    … …  
    519518    m_haveFiredLoadedData = false;
    520519    m_completelyLoaded = false;
    521     m_havePreparedToPlay = false;
    522520    m_displayMode = Unknown;
    523521
    … …  
    10851083    return m_player ? m_player->supportsSave() : false;
    10861084}
    1087 
    1088 void HTMLMediaElement::prepareToPlay()
    1089 {
    1090     if (m_havePreparedToPlay)
    1091         return;
    1092     m_havePreparedToPlay = true;
    1093     m_player->prepareToPlay();
    1094 }
    1095 
     1085   
    10961086void HTMLMediaElement::seek(float time, ExceptionCode& ec)
    10971087{
    … …  
    11051095        return;
    11061096    }
    1107 
    1108     // If the media engine has been told to postpone loading data, let it go ahead now.
    1109     if (m_preload < MediaPlayer::Auto && m_readyState < HAVE_FUTURE_DATA)
    1110         prepareToPlay();
    11111097
    11121098    // Get the current time before setting m_seeking, m_lastSeekTime is returned once it is set.
    … …  
    22112197
    22122198        if (couldPlayIfEnoughData())
    2213             prepareToPlay();
     2199            m_player->prepareToPlay();
    22142200
    22152201        if (hasMediaControls())

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

    r85483 r85518  
    287287    void cancelPendingEventsAndCallbacks();
    288288    void waitForSourceChange();
    289     void prepareToPlay();
    290289
    291290    enum InvalidSourceAction { DoNothing, Complain };
    … …  
    419418    bool m_loadInitiatedByUserGesture : 1;
    420419    bool m_completelyLoaded : 1;
    421     bool m_havePreparedToPlay : 1;
    422420};
    423421

  • trunk/Source/WebCore/platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.cpp

    r85483 r85518  
    3131
    3232#include "ApplicationCacheHost.h"
    33 #include "ApplicationCacheResource.h"
    3433#include "DocumentLoader.h"
    3534#include "FrameView.h"
    … …  
    4746namespace WebCore {
    4847
     48static const float invalidTime = -1.0f;
     49
    4950MediaPlayerPrivateAVFoundation::MediaPlayerPrivateAVFoundation(MediaPlayer* player)
    5051    : m_player(player)
    5152    , m_queuedNotifications()
    5253    , m_queueMutex()
     54    , m_mainThreadCallPending(false)
    5355    , m_networkState(MediaPlayer::Empty)
    5456    , m_readyState(MediaPlayer::HaveNothing)
    … …  
    5759    , m_cachedMaxTimeLoaded(0)
    5860    , m_cachedMaxTimeSeekable(0)
    59     , m_cachedDuration(invalidTime())
    60     , m_reportedDuration(invalidTime())
    61     , m_seekTo(invalidTime())
     61    , m_cachedDuration(invalidTime)
     62    , m_reportedDuration(invalidTime)
     63    , m_seekTo(invalidTime)
    6264    , m_requestedRate(1)
    63     , m_delayCallbacks(0)
    64     , m_mainThreadCallPending(false)
     65    , m_delayCallbacks(false)
     66    , m_havePreparedToPlay(false)
    6567    , m_assetIsPlayable(false)
    6668    , m_visible(false)
     69    , m_videoFrameHasDrawn(false)
    6770    , m_loadingMetadata(false)
     71    , m_delayingLoad(false)
    6872    , m_isAllowedToRender(false)
    6973    , m_cachedHasAudio(false)
    … …  
    164168}
    165169
     170void MediaPlayerPrivateAVFoundation::resumeLoad()
     171{
     172    LOG(Media, "MediaPlayerPrivateAVFoundation::resumeLoad(%p)", this);
     173
     174    ASSERT(m_delayingLoad);
     175    m_delayingLoad = false;
     176
     177    if (m_assetURL.length())
     178        prepareToPlay();
     179}
     180
    166181void MediaPlayerPrivateAVFoundation::load(const String& url)
    167182{
    … …  
    177192    }
    178193
     194    m_videoFrameHasDrawn = false;
    179195    m_assetURL = url;
    180196
    … …  
    183199        return;
    184200
    185     setPreload(m_preload);
     201    if (m_preload == MediaPlayer::None) {
     202        LOG(Media, "MediaPlayerPrivateAVFoundation::load(%p) - preload==none so returning", this);
     203        m_delayingLoad = true;
     204        return;
     205    }
     206
     207    prepareToPlay();
    186208}
    187209
    … …  
    211233    LOG(Media, "MediaPlayerPrivateAVFoundation::prepareToPlay(%p)", this);
    212234
    213     setPreload(MediaPlayer::Auto);
     235    m_preload = MediaPlayer::Auto;
     236    if (m_havePreparedToPlay)
     237        return;
     238    m_havePreparedToPlay = true;
     239
     240    m_delayingLoad = false;
     241#if ENABLE(OFFLINE_WEB_APPLICATIONS)
     242    Frame* frame = m_player->frameView() ? m_player->frameView()->frame() : 0;
     243    ApplicationCacheHost* cacheHost = frame ? frame->loader()->documentLoader()->applicationCacheHost() : 0;
     244    ApplicationCacheResource* resource = 0;
     245    if (cacheHost && cacheHost->shouldLoadResourceFromApplicationCache(ResourceRequest(m_assetURL), resource) && resource)
     246        createAVPlayerForCacheResource(resource);
     247    else
     248#endif   
     249    createAVPlayerForURL(m_assetURL);
     250    checkPlayability();
    214251}
    215252
    … …  
    233270}
    234271
     272void MediaPlayerPrivateAVFoundation::paint(GraphicsContext*, const IntRect&)
     273{
     274    // This is the base class, only need to remember that a frame has been drawn.
     275    m_videoFrameHasDrawn = true;
     276}
     277
    235278float MediaPlayerPrivateAVFoundation::duration() const
    236279{
    237     if (m_cachedDuration != invalidTime())
    238         return m_cachedDuration;
    239 
    240280    if (!metaDataAvailable())
    241281        return 0;
    242282
    243     float duration = platformDuration();
    244     if (!duration || duration == invalidTime())
    245         return 0;
    246 
    247     m_cachedDuration = duration;
    248     LOG(Media, "MediaPlayerPrivateAVFMac::duration(%p) - caching %f", this, m_cachedDuration);
     283    if (m_cachedDuration == invalidTime) {
     284        m_cachedDuration = platformDuration();
     285        LOG(Media, "MediaPlayerPrivateAVFMac::duration(%p) - caching %f", this, m_cachedDuration);
     286    }
     287
    249288    return m_cachedDuration;
    250289}
    … …  
    288327        return false;
    289328
    290     return m_seekTo != invalidTime();
     329    return m_seekTo != invalidTime;
    291330}
    292331
    … …  
    394433    else {
    395434        // -loadValuesAsynchronouslyForKeys:completionHandler: has invoked its handler; test status of keys and determine state.
    396         AssetStatus avAssetStatus = assetStatus();
     435        AVAssetStatus avAssetStatus = assetStatus();
    397436        ItemStatus itemStatus = playerItemStatus();
    398437       
    … …  
    400439        if (m_readyState < MediaPlayer::HaveMetadata && avAssetStatus > MediaPlayerAVAssetStatusLoading) {
    401440            if (m_assetIsPlayable) {
    402                 if (itemStatus <= MediaPlayerAVPlayerItemStatusUnknown) {
     441                if (itemStatus == MediaPlayerAVPlayerItemStatusUnknown) {
    403442                    if (avAssetStatus == MediaPlayerAVAssetStatusFailed || m_preload > MediaPlayer::MetaData) {
    404443                        // We may have a playable asset that doesn't support inspection prior to playback; go ahead
    … …  
    407446                        m_networkState = MediaPlayer::Loading;
    408447                        prepareToPlay();
    409                     } else {
    410                         // The asset is playable, but we don't want to load media data yet so don't allocate
    411                         // the player item. Even though we don't want to play yet, allocate a player so
    412                         // we can create a layer as soon as possible.
    413                         createAVPlayer();
     448                    } else
    414449                        m_networkState = MediaPlayer::Idle;
    415                     }
    416450                }
    417                 m_readyState = MediaPlayer::HaveMetadata;
     451                if (avAssetStatus == MediaPlayerAVAssetStatusLoaded)
     452                    m_readyState = MediaPlayer::HaveMetadata;
    418453            } else {
    419454                // FIX ME: fetch the error associated with the @"playable" key to distinguish between format
    … …  
    429464                float maxLoaded = maxTimeLoaded();
    430465                switch (itemStatus) {
    431                 case MediaPlayerAVPlayerItemStatusDoesNotExist:
    432466                case MediaPlayerAVPlayerItemStatusUnknown:
    433467                    break;
    … …  
    438472                    m_readyState = MediaPlayer::HaveEnoughData;
    439473                    break;
    440 
     474                case MediaPlayerAVPlayerItemStatusReadyToPlay:
    441475                case MediaPlayerAVPlayerItemStatusPlaybackBufferFull:
    442                     m_networkState = MediaPlayer::Idle;
    443 
    444                 case MediaPlayerAVPlayerItemStatusReadyToPlay:
    445476                    // If the readyState is already HaveEnoughData, don't go lower because of this state change.
    446477                    if (m_readyState == MediaPlayer::HaveEnoughData)
    … …  
    455486                }
    456487
    457                 if (itemStatus != MediaPlayerAVPlayerItemStatusPlaybackBufferFull && itemStatus >= MediaPlayerAVPlayerItemStatusReadyToPlay)
     488                if (itemStatus >= MediaPlayerAVPlayerItemStatusReadyToPlay)
    458489                    m_networkState = (maxLoaded == duration()) ? MediaPlayer::Loaded : MediaPlayer::Loading;
    459490            }
    … …  
    465496
    466497    if (!m_haveReportedFirstVideoFrame && m_cachedHasVideo && hasAvailableVideoFrame()) {
    467         if (m_readyState < MediaPlayer::HaveCurrentData)
    468             m_readyState = MediaPlayer::HaveCurrentData;
    469498        m_haveReportedFirstVideoFrame = true;
    470499        m_player->firstVideoFrameAvailable();
    … …  
    502531}
    503532
     533bool MediaPlayerPrivateAVFoundation::hasAvailableVideoFrame() const
     534{
     535    if (currentRenderingMode() == MediaRenderingToLayer)
     536        return videoLayerIsReadyToDisplay();
     537
     538    // When using the software renderer we hope someone will signal that a frame is available so we might as well
     539    // wait until we know that a frame has been drawn.
     540    return m_videoFrameHasDrawn;
     541}
     542
    504543void MediaPlayerPrivateAVFoundation::acceleratedRenderingStateChanged()
    505544{
    … …  
    511550{
    512551    m_loadingMetadata = false;
    513     tracksChanged();
    514552    updateStates();
    515553}
    … …  
    538576    float dur = duration();
    539577    if (dur != m_reportedDuration) {
    540         if (m_reportedDuration != invalidTime())
     578        if (m_reportedDuration != invalidTime)
    541579            m_player->durationChanged();
    542580        m_reportedDuration = dur;
    … …  
    553591    LOG(Media, "MediaPlayerPrivateAVFoundation::timeChanged(%p) - time = %f", this, time);
    554592
    555     if (m_seekTo == invalidTime())
     593    if (m_seekTo == invalidTime)
    556594        return;
    557595
    … …  
    563601    float currentRate = rate();
    564602    if ((currentRate > 0 && time >= m_seekTo) || (currentRate < 0 && time <= m_seekTo) || (abs(m_seekTo - time) <= smallSeekDelta)) {
    565         m_seekTo = invalidTime();
     603        m_seekTo = invalidTime;
    566604        updateStates();
    567605        m_player->timeChanged();
    … …  
    574612   
    575613    if (finished)
    576         m_seekTo = invalidTime();
     614        m_seekTo = invalidTime;
    577615}
    578616
    … …  
    591629void MediaPlayerPrivateAVFoundation::repaint()
    592630{
     631    m_videoFrameHasDrawn = true;
    593632    m_player->repaint();
    594633}
    … …  
    608647{
    609648    m_preload = preload;
    610     if (!m_assetURL.length())
    611         return;
    612 
    613     if (m_preload >= MediaPlayer::MetaData && assetStatus() == MediaPlayerAVAssetStatusDoesNotExist) {
    614 #if ENABLE(OFFLINE_WEB_APPLICATIONS)
    615         Frame* frame = m_player->frameView() ? m_player->frameView()->frame() : 0;
    616         ApplicationCacheHost* cacheHost = frame ? frame->loader()->documentLoader()->applicationCacheHost() : 0;
    617         ApplicationCacheResource* resource;
    618         if (cacheHost && cacheHost->shouldLoadResourceFromApplicationCache(ResourceRequest(m_assetURL), resource) && resource) {
    619             // AVFoundation can't open arbitrary data pointers, so if this ApplicationCacheResource doesn't
    620             // have a valid local path, just open the resource's original URL.
    621             if (resource->path().isEmpty())
    622                 createAVAssetForURL(resource->url());
    623             else
    624                 createAVAssetForCacheResource(resource);
    625         } else
    626 #endif   
    627             createAVAssetForURL(m_assetURL);
    628 
    629         checkPlayability();
    630     }
    631 
    632     if (m_preload == MediaPlayer::Auto && playerItemStatus() == MediaPlayerAVPlayerItemStatusDoesNotExist)
    633         createAVPlayerItem();
     649    if (m_delayingLoad && m_preload != MediaPlayer::None)
     650        resumeLoad();
    634651}
    635652

  • trunk/Source/WebCore/platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.h

    r85483 r85518  
    143143    virtual unsigned bytesLoaded() const;
    144144    virtual void setSize(const IntSize&);
    145     virtual void paint(GraphicsContext*, const IntRect&) = 0;
     145    virtual void paint(GraphicsContext*, const IntRect&);
    146146    virtual void paintCurrentFrameInContext(GraphicsContext*, const IntRect&) = 0;
    147147    virtual void setPreload(MediaPlayer::Preload);
     148    virtual bool hasAvailableVideoFrame() const;
    148149#if USE(ACCELERATED_COMPOSITING)
    149150    virtual PlatformLayer* platformLayer() const { return 0; }
    … …  
    159160
    160161    // Required interfaces for concrete derived classes.
    161     virtual void createAVAssetForURL(const String&) = 0;
    162     virtual void createAVPlayer() = 0;
    163     virtual void createAVPlayerItem() = 0;
     162    virtual void createAVPlayerForURL(const String& url) = 0;
    164163#if ENABLE(OFFLINE_WEB_APPLICATIONS)
    165     virtual void createAVAssetForCacheResource(ApplicationCacheResource*) = 0;
     164    virtual void createAVPlayerForCacheResource(ApplicationCacheResource*) = 0;
    166165#endif
    167166
    168167    enum ItemStatus {
    169         MediaPlayerAVPlayerItemStatusDoesNotExist,
    170168        MediaPlayerAVPlayerItemStatusUnknown,
    171169        MediaPlayerAVPlayerItemStatusFailed,
    … …  
    177175    virtual ItemStatus playerItemStatus() const = 0;
    178176
    179     enum AssetStatus {
    180         MediaPlayerAVAssetStatusDoesNotExist,
     177    enum AVAssetStatus {
    181178        MediaPlayerAVAssetStatusUnknown,
    182179        MediaPlayerAVAssetStatusLoading,
    … …  
    186183        MediaPlayerAVAssetStatusPlayable,
    187184    };
    188     virtual AssetStatus assetStatus() const = 0;
     185    virtual AVAssetStatus assetStatus() const = 0;
    189186
    190187    virtual void platformSetVisible(bool) = 0;
    … …  
    210207    virtual void createVideoLayer() = 0;
    211208    virtual void destroyVideoLayer() = 0;
    212 
    213     virtual bool hasAvailableVideoFrame() const = 0;
     209    virtual bool videoLayerIsReadyToDisplay() const = 0;
    214210
    215211    virtual bool hasContextRenderer() const = 0;
    … …  
    217213
    218214protected:
     215    void resumeLoad();
    219216    void updateStates();
    220217
    … …  
    240237
    241238    static void mainThreadCallback(void*);
    242    
    243     float invalidTime() const { return -1.0f; }
    244239
    245240private:
     241
    246242    MediaPlayer* m_player;
    247243
    248244    Vector<Notification> m_queuedNotifications;
    249245    Mutex m_queueMutex;
     246    bool m_mainThreadCallPending;
    250247
    251248    mutable RefPtr<TimeRanges> m_cachedLoadedTimeRanges;
    … …  
    267264    float m_requestedRate;
    268265    int m_delayCallbacks;
    269     bool m_mainThreadCallPending;
     266    bool m_havePreparedToPlay;
    270267    bool m_assetIsPlayable;
    271268    bool m_visible;
     269    bool m_videoFrameHasDrawn;
    272270    bool m_loadingMetadata;
     271    bool m_delayingLoad;
    273272    bool m_isAllowedToRender;
    274273    bool m_cachedHasAudio;

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

    r85483 r85518  
    8787
    8888    virtual void createAVPlayer();
    89     virtual void createAVPlayerItem();
    90     virtual void createAVAssetForURL(const String& url);
     89    virtual void createAVPlayerForURL(const String& url);
    9190#if ENABLE(OFFLINE_WEB_APPLICATIONS)
    92     virtual void createAVAssetForCacheResource(ApplicationCacheResource*);
     91    virtual void createAVPlayerForCacheResource(ApplicationCacheResource*);
    9392#endif
    9493    virtual MediaPlayerPrivateAVFoundation::ItemStatus playerItemStatus() const;
    95     virtual MediaPlayerPrivateAVFoundation::AssetStatus assetStatus() const;
     94    virtual MediaPlayerPrivateAVFoundation::AVAssetStatus assetStatus() const;
    9695
    9796    virtual void checkPlayability();
    … …  
    107106    virtual void sizeChanged();
    108107
    109     virtual bool hasAvailableVideoFrame() const;
    110 
    111108    virtual void createContextVideoRenderer();
    112109    virtual void destroyContextVideoRenderer();
    … …  
    114111    virtual void createVideoLayer();
    115112    virtual void destroyVideoLayer();
     113    virtual bool videoLayerIsReadyToDisplay() const;
    116114
    117115    virtual bool hasContextRenderer() const;
    … …  
    128126    RetainPtr<AVAssetImageGenerator> m_imageGenerator;
    129127    id m_timeObserver;
    130     bool m_videoFrameHasDrawn;
    131128};
    132129

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

    r85483 r85518  
    139139    , m_objcObserver(AdoptNS, [[WebCoreAVFMovieObserver alloc] initWithCallback:this])
    140140    , m_timeObserver(0)
    141     , m_videoFrameHasDrawn(false)
    142141{
    143142}
    … …  
    236235}
    237236
    238 bool MediaPlayerPrivateAVFoundationObjC::hasAvailableVideoFrame() const
    239 {
    240     return (m_videoFrameHasDrawn || (m_videoLayer && [m_videoLayer.get() isReadyForDisplay]));
    241 }
    242 
    243 void MediaPlayerPrivateAVFoundationObjC::createAVAssetForURL(const String& url)
    244 {
    245     if (m_avAsset)
    246         return;
    247 
     237bool MediaPlayerPrivateAVFoundationObjC::videoLayerIsReadyToDisplay() const
     238{
     239    return (m_videoLayer && [m_videoLayer.get() isReadyForDisplay]);
     240}
     241
     242void MediaPlayerPrivateAVFoundationObjC::createAVPlayerForURL(const String& url)
     243{
    248244    setDelayCallbacks(true);
    249     NSURL *cocoaURL = KURL(ParsedURLString, url);
    250     m_avAsset.adoptNS([[AVURLAsset alloc] initWithURL:cocoaURL options:nil]);
    251     setDelayCallbacks(false);
     245
     246    if (!m_avAsset) {
     247        NSURL *cocoaURL = KURL(ParsedURLString, url);
     248        m_avAsset.adoptNS([[AVURLAsset alloc] initWithURL:cocoaURL options:nil]);
     249    }
     250   
     251    createAVPlayer();
    252252}
    253253
    254254#if ENABLE(OFFLINE_WEB_APPLICATIONS)
    255 void MediaPlayerPrivateAVFoundationObjC::createAVAssetForCacheResource(ApplicationCacheResource* resource)
    256 {
    257     if (m_avAsset)
    258         return;
    259 
    260     // AVFoundation can't open arbitrary data pointers.
    261     ASSERT(!resource->path().isEmpty());
     255void MediaPlayerPrivateAVFoundationObjC::createAVPlayerForCacheResource(ApplicationCacheResource* resource)
     256{
     257    // AVFoundation can't open arbitrary data pointers, so if this ApplicationCacheResource doesn't
     258    // have a valid local path, just open the resource's original URL.
     259    if (resource->path().isEmpty()) {
     260        createAVPlayerForURL(resource->url());
     261        return;
     262    }
    262263   
    263264    setDelayCallbacks(true);
    264265
    265     NSURL* localURL = [NSURL fileURLWithPath:resource->path()];
    266     m_avAsset.adoptNS([[AVURLAsset alloc] initWithURL:localURL options:nil]);
    267 
    268     setDelayCallbacks(false);
     266    if (!m_avAsset) {
     267        NSURL* localURL = [NSURL fileURLWithPath:resource->path()];
     268        m_avAsset.adoptNS([[AVURLAsset alloc] initWithURL:localURL options:nil]);
     269    }
     270
     271    createAVPlayer();
    269272}
    270273#endif
    … …  
    272275void MediaPlayerPrivateAVFoundationObjC::createAVPlayer()
    273276{
    274     if (m_avPlayer)
    275         return;
    276 
    277     setDelayCallbacks(true);
    278 
    279     m_avPlayer.adoptNS([[AVPlayer alloc] init]);
    280     [m_avPlayer.get() addObserver:m_objcObserver.get() forKeyPath:@"rate" options:nil context:(void *)MediaPlayerAVFoundationObservationContextPlayer];
    281    
    282     // Add a time observer, ask to be called infrequently because we don't really want periodic callbacks but
    283     // our observer will also be called whenever a seek happens.
    284     const double veryLongInterval = 60*60*60*24*30;
    285     WebCoreAVFMovieObserver *observer = m_objcObserver.get();
    286     m_timeObserver = [m_avPlayer.get() addPeriodicTimeObserverForInterval:CMTimeMakeWithSeconds(veryLongInterval, 10) queue:nil usingBlock:^(CMTime time){
    287         [observer timeChanged:CMTimeGetSeconds(time)];
    288     }];
    289 
    290     setDelayCallbacks(false);
    291 }
    292 
    293 void MediaPlayerPrivateAVFoundationObjC::createAVPlayerItem()
    294 {
    295     if (m_avPlayerItem)
    296         return;
    297 
    298     setDelayCallbacks(true);
    299 
    300     // Create the player item so we can media data.
    301     m_avPlayerItem.adoptNS([[AVPlayerItem alloc] initWithAsset:m_avAsset.get()]);
    302    
    303     [[NSNotificationCenter defaultCenter] addObserver:m_objcObserver.get()selector:@selector(didEnd:) name:AVPlayerItemDidPlayToEndTimeNotification object:m_avPlayerItem.get()];
    304 
    305     for (NSString *keyName in itemKVOProperties())
    306         [m_avPlayerItem.get() addObserver:m_objcObserver.get() forKeyPath:keyName options:nil context:(void *)MediaPlayerAVFoundationObservationContextPlayerItem];
    307 
    308     [m_avPlayer.get() replaceCurrentItemWithPlayerItem:m_avPlayerItem.get()];
     277    if (!m_avPlayer) {
     278        m_avPlayer.adoptNS([[AVPlayer alloc] init]);
     279       
     280        [m_avPlayer.get() addObserver:m_objcObserver.get() forKeyPath:@"rate" options:nil context:(void *)MediaPlayerAVFoundationObservationContextPlayer];
     281       
     282        // Add a time observer, ask to be called infrequently because we don't really want periodic callbacks but
     283        // our observer will also be called whenever a seek happens.
     284        const double veryLongInterval = 60*60*60*24*30;
     285        WebCoreAVFMovieObserver *observer = m_objcObserver.get();
     286        m_timeObserver = [m_avPlayer.get() addPeriodicTimeObserverForInterval:CMTimeMakeWithSeconds(veryLongInterval, 10) queue:nil usingBlock:^(CMTime time){
     287            [observer timeChanged:CMTimeGetSeconds(time)];
     288        }];
     289    }
     290
     291    if (!m_avPlayerItem) {
     292        // Create the player item so we can media data.
     293        m_avPlayerItem.adoptNS([[AVPlayerItem alloc] initWithAsset:m_avAsset.get()]);
     294       
     295        [[NSNotificationCenter defaultCenter] addObserver:m_objcObserver.get()selector:@selector(didEnd:) name:AVPlayerItemDidPlayToEndTimeNotification object:m_avPlayerItem.get()];
     296
     297        for (NSString *keyName in itemKVOProperties())
     298            [m_avPlayerItem.get() addObserver:m_objcObserver.get() forKeyPath:keyName options:nil context:(void *)MediaPlayerAVFoundationObservationContextPlayerItem];
     299
     300        [m_avPlayer.get() replaceCurrentItemWithPlayerItem:m_avPlayerItem.get()];
     301    }
    309302
    310303    setDelayCallbacks(false);
    … …  
    322315void MediaPlayerPrivateAVFoundationObjC::beginLoadingMetadata()
    323316{
    324     LOG(Media, "MediaPlayerPrivateAVFoundationObjC::beginLoadingMetadata(%p) - requesting metadata loading", this);
     317    LOG(Media, "MediaPlayerPrivateAVFoundationObjC::playabilityKnown(%p) - requesting metadata loading", this);
    325318    [m_avAsset.get() loadValuesAsynchronouslyForKeys:[assetMetadataKeyNames() retain] completionHandler:^{
    326319        [m_objcObserver.get() metadataLoaded];
    … …  
    331324{
    332325    if (!m_avPlayerItem)
    333         return MediaPlayerPrivateAVFoundation::MediaPlayerAVPlayerItemStatusDoesNotExist;
     326        return MediaPlayerPrivateAVFoundation::MediaPlayerAVPlayerItemStatusUnknown;
    334327
    335328    AVPlayerItemStatus status = [m_avPlayerItem.get() status];
    … …  
    340333    if ([m_avPlayerItem.get() isPlaybackLikelyToKeepUp])
    341334        return MediaPlayerPrivateAVFoundation::MediaPlayerAVPlayerItemStatusPlaybackLikelyToKeepUp;
    342     if ([m_avPlayerItem.get() isPlaybackBufferFull])
     335    if (buffered()->contain(duration()))
    343336        return MediaPlayerPrivateAVFoundation::MediaPlayerAVPlayerItemStatusPlaybackBufferFull;
    344     if ([m_avPlayerItem.get() isPlaybackBufferEmpty])
     337    if (buffered()->contain(currentTime()))
    345338        return MediaPlayerPrivateAVFoundation::MediaPlayerAVPlayerItemStatusPlaybackBufferEmpty;
    346339
    … …  
    393386float MediaPlayerPrivateAVFoundationObjC::platformDuration() const
    394387{
    395     if (!metaDataAvailable())
    396         return invalidTime();
     388    if (!metaDataAvailable() || !m_avPlayerItem)
     389        return 0;
    397390   
    398     CMTime cmDuration;
    399    
    400     // Check the avitem if we have one, some assets never report duration.
    401     if (m_avPlayerItem)
    402         cmDuration = [m_avPlayerItem.get() duration];
    403     else
    404         cmDuration= [m_avAsset.get() duration];
    405 
     391    float duration;
     392    CMTime cmDuration = [m_avPlayerItem.get() duration];
    406393    if (CMTIME_IS_NUMERIC(cmDuration))
    407         return narrowPrecisionToFloat(CMTimeGetSeconds(cmDuration));
    408 
    409     if (CMTIME_IS_INDEFINITE(cmDuration))
    410         return numeric_limits<float>::infinity();
    411 
    412     LOG(Media, "MediaPlayerPrivateAVFoundationObjC::duration(%p) - invalid duration, returning -1", this);
    413     return invalidTime();
     394        duration = narrowPrecisionToFloat(CMTimeGetSeconds(cmDuration));
     395    else if (CMTIME_IS_INDEFINITE(cmDuration))
     396        duration = numeric_limits<float>::infinity();
     397    else {
     398        LOG(Media, "MediaPlayerPrivateAVFoundationObjC::duration(%p) - invalid duration, returning 0", this);
     399        return 0;
     400    }
     401
     402    return duration;
    414403}
    415404
    … …  
    547536}
    548537
    549 MediaPlayerPrivateAVFoundation::AssetStatus MediaPlayerPrivateAVFoundationObjC::assetStatus() const
     538MediaPlayerPrivateAVFoundation::AVAssetStatus MediaPlayerPrivateAVFoundationObjC::assetStatus() const
    550539{
    551540    if (!m_avAsset)
    552         return MediaPlayerAVAssetStatusDoesNotExist;
     541        return MediaPlayerAVAssetStatusUnknown;
    553542
    554543    for (NSString *keyName in assetMetadataKeyNames()) {
    … …  
    599588    setDelayCallbacks(false);
    600589
    601     m_videoFrameHasDrawn = true;
     590    MediaPlayerPrivateAVFoundation::paint(context, rect);
    602591}
    603592
    … …  
    674663void MediaPlayerPrivateAVFoundationObjC::tracksChanged()
    675664{
    676     if (!m_avAsset)
    677         return;
    678 
    679665    // This is called whenever the tracks collection changes so cache hasVideo and hasAudio since we are
    680666    // asked about those fairly fequently.
    681     if (!m_avPlayerItem) {
    682         // We don't have a player item yet, so check with the asset because some assets support inspection
    683         // prior to becoming ready to play.
    684         setHasVideo([[m_avAsset.get() tracksWithMediaCharacteristic:AVMediaCharacteristicVisual] count]);
    685         setHasAudio([[m_avAsset.get() tracksWithMediaCharacteristic:AVMediaCharacteristicAudible] count]);
    686         setHasClosedCaptions([[m_avAsset.get() tracksWithMediaType:AVMediaTypeClosedCaption] count]);
    687     } else {
    688         bool hasVideo = false;
    689         bool hasAudio = false;
    690         bool hasCaptions = false;
    691         NSArray *tracks = [m_avPlayerItem.get() tracks];
    692         for (AVPlayerItemTrack *track in tracks) {
    693             if ([track isEnabled]) {
    694                 AVAssetTrack *assetTrack = [track assetTrack];
    695                 if ([[assetTrack mediaType] isEqualToString:AVMediaTypeVideo])
    696                     hasVideo = true;
    697                 else if ([[assetTrack mediaType] isEqualToString:AVMediaTypeAudio])
    698                     hasAudio = true;
    699                 else if ([[assetTrack mediaType] isEqualToString:AVMediaTypeClosedCaption])
    700                     hasCaptions = true;
    701             }
     667    bool hasVideo = false;
     668    bool hasAudio = false;
     669    bool hasCaptions = false;
     670    NSArray *tracks = [m_avPlayerItem.get() tracks];
     671    for (AVPlayerItemTrack *track in tracks) {
     672        if ([track isEnabled]) {
     673            AVAssetTrack *assetTrack = [track assetTrack];
     674            if ([[assetTrack mediaType] isEqualToString:AVMediaTypeVideo])
     675                hasVideo = true;
     676            else if ([[assetTrack mediaType] isEqualToString:AVMediaTypeAudio])
     677                hasAudio = true;
     678            else if ([[assetTrack mediaType] isEqualToString:AVMediaTypeClosedCaption])
     679                hasCaptions = true;
    702680        }
    703         setHasVideo(hasVideo);
    704         setHasAudio(hasAudio);
    705         setHasClosedCaptions(hasCaptions);
    706     }
     681    }
     682    setHasVideo(hasVideo);
     683    setHasAudio(hasAudio);
     684    setHasClosedCaptions(hasCaptions);
    707685
    708686    sizeChanged();
    … …  
    711689void MediaPlayerPrivateAVFoundationObjC::sizeChanged()
    712690{
    713     if (!m_avAsset)
    714         return;
    715 
    716691    NSArray *tracks = [m_avAsset.get() tracks];
    717692
    718693    // Some assets don't report track properties until they are completely ready to play, but we
    719694    // want to report a size as early as possible so use presentationSize when an asset has no tracks.
    720     if (m_avPlayerItem && ![tracks count]) {
     695    if (![tracks count]) {
    721696        setNaturalSize(IntSize([m_avPlayerItem.get() presentationSize]));
    722697        return;
Note: See TracChangeset for help on using the changeset viewer.