MediaPlayerPrivateAVFoundation.cpp [plain text]
#include "config.h"
#if ENABLE(VIDEO) && USE(AVFOUNDATION)
#include "MediaPlayerPrivateAVFoundation.h"
#include "DocumentLoader.h"
#include "Frame.h"
#include "FrameView.h"
#include "GraphicsContext.h"
#include "GraphicsLayer.h"
#include "KURL.h"
#include "Logging.h"
#include "SoftLinking.h"
#include "TimeRanges.h"
#include <CoreMedia/CoreMedia.h>
#include <wtf/MainThread.h>
#include <wtf/UnusedParam.h>
using namespace std;
namespace WebCore {
MediaPlayerPrivateAVFoundation::MediaPlayerPrivateAVFoundation(MediaPlayer* player)
: m_player(player)
, m_queuedNotifications()
, m_queueMutex()
, m_networkState(MediaPlayer::Empty)
, m_readyState(MediaPlayer::HaveNothing)
, m_preload(MediaPlayer::Auto)
, m_cachedMaxTimeLoaded(0)
, m_cachedMaxTimeSeekable(0)
, m_cachedDuration(invalidTime())
, m_reportedDuration(invalidTime())
, m_seekTo(invalidTime())
, m_requestedRate(1)
, m_delayCallbacks(0)
, m_mainThreadCallPending(false)
, m_assetIsPlayable(false)
, m_visible(false)
, m_loadingMetadata(false)
, m_isAllowedToRender(false)
, m_cachedHasAudio(false)
, m_cachedHasVideo(false)
, m_cachedHasCaptions(false)
, m_ignoreLoadStateChanges(false)
, m_haveReportedFirstVideoFrame(false)
, m_playWhenFramesAvailable(false)
{
LOG(Media, "MediaPlayerPrivateAVFoundation::MediaPlayerPrivateAVFoundation(%p)", this);
}
MediaPlayerPrivateAVFoundation::~MediaPlayerPrivateAVFoundation()
{
LOG(Media, "MediaPlayerPrivateAVFoundation::~MediaPlayerPrivateAVFoundation(%p)", this);
setIgnoreLoadStateChanges(true);
cancelCallOnMainThread(mainThreadCallback, this);
}
MediaPlayerPrivateAVFoundation::MediaRenderingMode MediaPlayerPrivateAVFoundation::currentRenderingMode() const
{
#if USE(ACCELERATED_COMPOSITING)
if (platformLayer())
return MediaRenderingToLayer;
#endif
if (hasContextRenderer())
return MediaRenderingToContext;
return MediaRenderingNone;
}
MediaPlayerPrivateAVFoundation::MediaRenderingMode MediaPlayerPrivateAVFoundation::preferredRenderingMode() const
{
if (!m_player->visible() || !m_player->frameView() || assetStatus() == MediaPlayerAVAssetStatusUnknown)
return MediaRenderingNone;
#if USE(ACCELERATED_COMPOSITING)
if (supportsAcceleratedRendering() && m_player->mediaPlayerClient()->mediaPlayerRenderingCanBeAccelerated(m_player))
return MediaRenderingToLayer;
#endif
return MediaRenderingToContext;
}
void MediaPlayerPrivateAVFoundation::setUpVideoRendering()
{
if (!isReadyForVideoSetup())
return;
MediaRenderingMode currentMode = currentRenderingMode();
MediaRenderingMode preferredMode = preferredRenderingMode();
if (currentMode == preferredMode && currentMode != MediaRenderingNone)
return;
LOG(Media, "MediaPlayerPrivateAVFoundation::setUpVideoRendering(%p) - current mode = %d, preferred mode = %d",
this, static_cast<int>(currentMode), static_cast<int>(preferredMode));
if (currentMode != MediaRenderingNone)
tearDownVideoRendering();
switch (preferredMode) {
case MediaRenderingNone:
case MediaRenderingToContext:
createContextVideoRenderer();
break;
#if USE(ACCELERATED_COMPOSITING)
case MediaRenderingToLayer:
createVideoLayer();
break;
#endif
}
#if USE(ACCELERATED_COMPOSITING)
if (currentMode == MediaRenderingToLayer || preferredMode == MediaRenderingToLayer) {
LOG(Media, "MediaPlayerPrivateAVFoundation::setUpVideoRendering(%p) - calling mediaPlayerRenderingModeChanged()", this);
m_player->mediaPlayerClient()->mediaPlayerRenderingModeChanged(m_player);
}
#endif
}
void MediaPlayerPrivateAVFoundation::tearDownVideoRendering()
{
LOG(Media, "MediaPlayerPrivateAVFoundation::tearDownVideoRendering(%p)", this);
destroyContextVideoRenderer();
#if USE(ACCELERATED_COMPOSITING)
if (platformLayer())
destroyVideoLayer();
#endif
}
bool MediaPlayerPrivateAVFoundation::hasSetUpVideoRendering() const
{
return hasLayerRenderer() || hasContextRenderer();
}
void MediaPlayerPrivateAVFoundation::load(const String& url)
{
LOG(Media, "MediaPlayerPrivateAVFoundation::load(%p)", this);
if (m_networkState != MediaPlayer::Loading) {
m_networkState = MediaPlayer::Loading;
m_player->networkStateChanged();
}
if (m_readyState != MediaPlayer::HaveNothing) {
m_readyState = MediaPlayer::HaveNothing;
m_player->readyStateChanged();
}
m_assetURL = url;
if (!url.length())
return;
setPreload(m_preload);
}
void MediaPlayerPrivateAVFoundation::playabilityKnown()
{
LOG(Media, "MediaPlayerPrivateAVFoundation::playabilityKnown(%p)", this);
if (m_assetIsPlayable)
return;
if (assetStatus() > MediaPlayerAVAssetStatusLoading) {
LOG(Media, "MediaPlayerPrivateAVFoundation::playabilityKnown(%p) - all metadata loaded", this);
return;
}
m_loadingMetadata = true;
beginLoadingMetadata();
}
void MediaPlayerPrivateAVFoundation::prepareToPlay()
{
LOG(Media, "MediaPlayerPrivateAVFoundation::prepareToPlay(%p)", this);
setPreload(MediaPlayer::Auto);
}
void MediaPlayerPrivateAVFoundation::play()
{
LOG(Media, "MediaPlayerPrivateAVFoundation::play(%p)", this);
if (!m_cachedHasVideo || hasAvailableVideoFrame())
platformPlay();
else
m_playWhenFramesAvailable = true;
}
void MediaPlayerPrivateAVFoundation::pause()
{
LOG(Media, "MediaPlayerPrivateAVFoundation::pause(%p)", this);
m_playWhenFramesAvailable = false;
platformPause();
}
float MediaPlayerPrivateAVFoundation::duration() const
{
if (m_cachedDuration != invalidTime())
return m_cachedDuration;
float duration = platformDuration();
if (!duration || duration == invalidTime())
return 0;
m_cachedDuration = duration;
LOG(Media, "MediaPlayerPrivateAVFoundation::duration(%p) - caching %f", this, m_cachedDuration);
return m_cachedDuration;
}
void MediaPlayerPrivateAVFoundation::seek(float time)
{
if (!metaDataAvailable())
return;
if (time > duration())
time = duration();
if (currentTime() == time)
return;
LOG(Media, "MediaPlayerPrivateAVFoundation::seek(%p) - seeking to %f", this, time);
m_seekTo = time;
seekToTime(time);
}
void MediaPlayerPrivateAVFoundation::setRate(float rate)
{
LOG(Media, "MediaPlayerPrivateAVFoundation::setRate(%p) - seting to %f", this, rate);
m_requestedRate = rate;
updateRate();
}
bool MediaPlayerPrivateAVFoundation::paused() const
{
if (!metaDataAvailable())
return true;
return rate() == 0;
}
bool MediaPlayerPrivateAVFoundation::seeking() const
{
if (!metaDataAvailable())
return false;
return m_seekTo != invalidTime();
}
IntSize MediaPlayerPrivateAVFoundation::naturalSize() const
{
if (!metaDataAvailable())
return IntSize();
return m_cachedNaturalSize;
}
void MediaPlayerPrivateAVFoundation::setNaturalSize(IntSize size)
{
LOG(Media, "MediaPlayerPrivateAVFoundation:setNaturalSize(%p) - size = %d x %d", this, size.width(), size.height());
IntSize oldSize = m_cachedNaturalSize;
m_cachedNaturalSize = size;
if (oldSize != m_cachedNaturalSize)
m_player->sizeChanged();
}
void MediaPlayerPrivateAVFoundation::setHasVideo(bool b)
{
if (m_cachedHasVideo != b) {
m_cachedHasVideo = b;
m_player->characteristicChanged();
}
}
void MediaPlayerPrivateAVFoundation::setHasAudio(bool b)
{
if (m_cachedHasAudio != b) {
m_cachedHasAudio = b;
m_player->characteristicChanged();
}
}
void MediaPlayerPrivateAVFoundation::setHasClosedCaptions(bool b)
{
if (m_cachedHasCaptions != b) {
m_cachedHasCaptions = b;
m_player->characteristicChanged();
}
}
PassRefPtr<TimeRanges> MediaPlayerPrivateAVFoundation::buffered() const
{
if (!m_cachedLoadedTimeRanges)
m_cachedLoadedTimeRanges = platformBufferedTimeRanges();
return m_cachedLoadedTimeRanges->copy();
}
float MediaPlayerPrivateAVFoundation::maxTimeSeekable() const
{
if (!metaDataAvailable())
return 0;
if (!m_cachedMaxTimeSeekable)
m_cachedMaxTimeSeekable = platformMaxTimeSeekable();
LOG(Media, "MediaPlayerPrivateAVFoundation::maxTimeSeekable(%p) - returning %f", this, m_cachedMaxTimeSeekable);
return m_cachedMaxTimeSeekable;
}
float MediaPlayerPrivateAVFoundation::maxTimeLoaded() const
{
if (!metaDataAvailable())
return 0;
if (!m_cachedMaxTimeLoaded)
m_cachedMaxTimeLoaded = platformMaxTimeLoaded();
return m_cachedMaxTimeLoaded;
}
unsigned MediaPlayerPrivateAVFoundation::bytesLoaded() const
{
float dur = duration();
if (!dur)
return 0;
unsigned loaded = totalBytes() * maxTimeLoaded() / dur;
LOG(Media, "MediaPlayerPrivateAVFoundation::bytesLoaded(%p) - returning %i", this, loaded);
return loaded;
}
bool MediaPlayerPrivateAVFoundation::isReadyForVideoSetup() const
{
return (m_isAllowedToRender || m_cachedHasVideo) && m_readyState >= MediaPlayer::HaveMetadata && m_player->visible();
}
void MediaPlayerPrivateAVFoundation::prepareForRendering()
{
if (m_isAllowedToRender)
return;
m_isAllowedToRender = true;
setUpVideoRendering();
if (currentRenderingMode() == MediaRenderingToLayer || preferredRenderingMode() == MediaRenderingToLayer)
m_player->mediaPlayerClient()->mediaPlayerRenderingModeChanged(m_player);
}
bool MediaPlayerPrivateAVFoundation::supportsFullscreen() const
{
#if ENABLE(FULLSCREEN_API)
return true;
#else
return false;
#endif
}
void MediaPlayerPrivateAVFoundation::updateStates()
{
if (m_ignoreLoadStateChanges)
return;
MediaPlayer::NetworkState oldNetworkState = m_networkState;
MediaPlayer::ReadyState oldReadyState = m_readyState;
LOG(Media, "MediaPlayerPrivateAVFoundation::updateStates(%p) - entering with networkState = %i, readyState = %i",
this, static_cast<int>(m_networkState), static_cast<int>(m_readyState));
if (m_loadingMetadata)
m_networkState = MediaPlayer::Loading;
else {
AssetStatus assetStatus = this->assetStatus();
ItemStatus itemStatus = playerItemStatus();
m_assetIsPlayable = (assetStatus == MediaPlayerAVAssetStatusPlayable);
if (m_readyState < MediaPlayer::HaveMetadata && assetStatus > MediaPlayerAVAssetStatusLoading) {
if (m_assetIsPlayable) {
if (assetStatus >= MediaPlayerAVAssetStatusLoaded)
m_readyState = MediaPlayer::HaveMetadata;
if (itemStatus <= MediaPlayerAVPlayerItemStatusUnknown) {
if (assetStatus == MediaPlayerAVAssetStatusFailed || m_preload > MediaPlayer::MetaData || isLiveStream()) {
m_networkState = MediaPlayer::Loading;
prepareToPlay();
} else
m_networkState = MediaPlayer::Idle;
}
} else {
m_networkState = MediaPlayer::FormatError;
}
}
if (assetStatus >= MediaPlayerAVAssetStatusLoaded && itemStatus > MediaPlayerAVPlayerItemStatusUnknown) {
switch (itemStatus) {
case MediaPlayerAVPlayerItemStatusDoesNotExist:
case MediaPlayerAVPlayerItemStatusUnknown:
case MediaPlayerAVPlayerItemStatusFailed:
break;
case MediaPlayerAVPlayerItemStatusPlaybackLikelyToKeepUp:
case MediaPlayerAVPlayerItemStatusPlaybackBufferFull:
m_readyState = MediaPlayer::HaveEnoughData;
break;
case MediaPlayerAVPlayerItemStatusReadyToPlay:
if (m_readyState == MediaPlayer::HaveEnoughData)
break;
case MediaPlayerAVPlayerItemStatusPlaybackBufferEmpty:
if (maxTimeLoaded() > currentTime())
m_readyState = MediaPlayer::HaveFutureData;
else
m_readyState = MediaPlayer::HaveCurrentData;
break;
}
if (itemStatus == MediaPlayerAVPlayerItemStatusPlaybackBufferFull)
m_networkState = MediaPlayer::Idle;
else if (itemStatus == MediaPlayerAVPlayerItemStatusFailed)
m_networkState = MediaPlayer::DecodeError;
else if (itemStatus != MediaPlayerAVPlayerItemStatusPlaybackBufferFull && itemStatus >= MediaPlayerAVPlayerItemStatusReadyToPlay)
m_networkState = (maxTimeLoaded() == duration()) ? MediaPlayer::Loaded : MediaPlayer::Loading;
}
}
if (isReadyForVideoSetup() && currentRenderingMode() != preferredRenderingMode())
setUpVideoRendering();
if (!m_haveReportedFirstVideoFrame && m_cachedHasVideo && hasAvailableVideoFrame()) {
if (m_readyState < MediaPlayer::HaveCurrentData)
m_readyState = MediaPlayer::HaveCurrentData;
m_haveReportedFirstVideoFrame = true;
m_player->firstVideoFrameAvailable();
}
if (m_networkState != oldNetworkState)
m_player->networkStateChanged();
if (m_readyState != oldReadyState)
m_player->readyStateChanged();
if (m_playWhenFramesAvailable && hasAvailableVideoFrame()) {
m_playWhenFramesAvailable = false;
platformPlay();
}
LOG(Media, "MediaPlayerPrivateAVFoundation::updateStates(%p) - exiting with networkState = %i, readyState = %i",
this, static_cast<int>(m_networkState), static_cast<int>(m_readyState));
}
void MediaPlayerPrivateAVFoundation::setSize(const IntSize&)
{
}
void MediaPlayerPrivateAVFoundation::setVisible(bool visible)
{
if (m_visible == visible)
return;
m_visible = visible;
if (visible)
setUpVideoRendering();
platformSetVisible(visible);
}
void MediaPlayerPrivateAVFoundation::acceleratedRenderingStateChanged()
{
setUpVideoRendering();
}
void MediaPlayerPrivateAVFoundation::metadataLoaded()
{
m_loadingMetadata = false;
tracksChanged();
}
void MediaPlayerPrivateAVFoundation::rateChanged()
{
m_player->rateChanged();
}
void MediaPlayerPrivateAVFoundation::loadedTimeRangesChanged()
{
m_cachedLoadedTimeRanges = 0;
m_cachedMaxTimeLoaded = 0;
invalidateCachedDuration();
}
void MediaPlayerPrivateAVFoundation::seekableTimeRangesChanged()
{
m_cachedMaxTimeSeekable = 0;
}
void MediaPlayerPrivateAVFoundation::timeChanged(double time)
{
LOG(Media, "MediaPlayerPrivateAVFoundation::timeChanged(%p) - time = %f", this, time);
UNUSED_PARAM(time);
}
void MediaPlayerPrivateAVFoundation::seekCompleted(bool finished)
{
LOG(Media, "MediaPlayerPrivateAVFoundation::seekCompleted(%p) - finished = %d", this, finished);
UNUSED_PARAM(finished);
m_seekTo = invalidTime();
updateStates();
m_player->timeChanged();
}
void MediaPlayerPrivateAVFoundation::didEnd()
{
float now = currentTime();
if (now > 0)
m_cachedDuration = now;
updateStates();
m_player->timeChanged();
}
void MediaPlayerPrivateAVFoundation::invalidateCachedDuration()
{
LOG(Media, "MediaPlayerPrivateAVFoundation::invalidateCachedDuration(%p)", this);
m_cachedDuration = invalidTime();
float duration = this->duration();
if (duration != m_reportedDuration) {
if (m_reportedDuration != invalidTime())
m_player->durationChanged();
m_reportedDuration = duration;
}
}
void MediaPlayerPrivateAVFoundation::repaint()
{
m_player->repaint();
}
MediaPlayer::MovieLoadType MediaPlayerPrivateAVFoundation::movieLoadType() const
{
if (!metaDataAvailable() || assetStatus() == MediaPlayerAVAssetStatusUnknown)
return MediaPlayer::Unknown;
if (isLiveStream())
return MediaPlayer::LiveStream;
return MediaPlayer::Download;
}
void MediaPlayerPrivateAVFoundation::setPreload(MediaPlayer::Preload preload)
{
m_preload = preload;
if (!m_assetURL.length())
return;
setDelayCallbacks(true);
if (m_preload >= MediaPlayer::MetaData && assetStatus() == MediaPlayerAVAssetStatusDoesNotExist) {
createAVAssetForURL(m_assetURL);
checkPlayability();
}
if (m_preload == MediaPlayer::Auto && m_assetIsPlayable) {
createAVPlayerItem();
createAVPlayer();
}
setDelayCallbacks(false);
}
void MediaPlayerPrivateAVFoundation::setDelayCallbacks(bool delay) const
{
MutexLocker lock(m_queueMutex);
if (delay)
++m_delayCallbacks;
else {
ASSERT(m_delayCallbacks);
--m_delayCallbacks;
}
}
void MediaPlayerPrivateAVFoundation::mainThreadCallback(void* context)
{
LOG(Media, "MediaPlayerPrivateAVFoundation::mainThreadCallback(%p)", context);
MediaPlayerPrivateAVFoundation* player = static_cast<MediaPlayerPrivateAVFoundation*>(context);
player->clearMainThreadPendingFlag();
player->dispatchNotification();
}
void MediaPlayerPrivateAVFoundation::clearMainThreadPendingFlag()
{
MutexLocker lock(m_queueMutex);
m_mainThreadCallPending = false;
}
void MediaPlayerPrivateAVFoundation::scheduleMainThreadNotification(Notification::Type type, double time)
{
scheduleMainThreadNotification(Notification(type, time));
}
void MediaPlayerPrivateAVFoundation::scheduleMainThreadNotification(Notification::Type type, bool finished)
{
scheduleMainThreadNotification(Notification(type, finished));
}
void MediaPlayerPrivateAVFoundation::scheduleMainThreadNotification(Notification notification)
{
LOG(Media, "MediaPlayerPrivateAVFoundation::scheduleMainThreadNotification(%p) - notification %d", this, static_cast<int>(notification.type()));
m_queueMutex.lock();
m_queuedNotifications.append(notification);
bool delayDispatch = m_delayCallbacks || !isMainThread();
if (delayDispatch && !m_mainThreadCallPending) {
m_mainThreadCallPending = true;
callOnMainThread(mainThreadCallback, this);
}
m_queueMutex.unlock();
if (delayDispatch) {
LOG(Media, "MediaPlayerPrivateAVFoundation::scheduleMainThreadNotification(%p) - early return", this);
return;
}
dispatchNotification();
}
void MediaPlayerPrivateAVFoundation::dispatchNotification()
{
ASSERT(isMainThread());
Notification notification = Notification();
{
MutexLocker lock(m_queueMutex);
if (m_queuedNotifications.isEmpty())
return;
if (!m_delayCallbacks) {
notification = m_queuedNotifications.first();
m_queuedNotifications.remove(0);
}
if (!m_queuedNotifications.isEmpty() && !m_mainThreadCallPending)
callOnMainThread(mainThreadCallback, this);
if (!notification.isValid())
return;
}
LOG(Media, "MediaPlayerPrivateAVFoundation::dispatchNotification(%p) - dispatching %d", this, static_cast<int>(notification.type()));
switch (notification.type()) {
case Notification::ItemDidPlayToEndTime:
didEnd();
break;
case Notification::ItemTracksChanged:
tracksChanged();
updateStates();
break;
case Notification::ItemStatusChanged:
updateStates();
break;
case Notification::ItemSeekableTimeRangesChanged:
seekableTimeRangesChanged();
updateStates();
break;
case Notification::ItemLoadedTimeRangesChanged:
loadedTimeRangesChanged();
updateStates();
break;
case Notification::ItemPresentationSizeChanged:
sizeChanged();
updateStates();
break;
case Notification::ItemIsPlaybackLikelyToKeepUpChanged:
updateStates();
break;
case Notification::ItemIsPlaybackBufferEmptyChanged:
updateStates();
break;
case Notification::ItemIsPlaybackBufferFullChanged:
updateStates();
break;
case Notification::PlayerRateChanged:
updateStates();
rateChanged();
break;
case Notification::PlayerTimeChanged:
timeChanged(notification.time());
break;
case Notification::SeekCompleted:
seekCompleted(notification.finished());
break;
case Notification::AssetMetadataLoaded:
metadataLoaded();
updateStates();
break;
case Notification::AssetPlayabilityKnown:
updateStates();
playabilityKnown();
break;
case Notification::DurationChanged:
invalidateCachedDuration();
break;
case Notification::ContentsNeedsDisplay:
contentsNeedsDisplay();
break;
case Notification::None:
ASSERT_NOT_REACHED();
break;
}
}
}
#endif