MediaController.cpp [plain text]
#include "config.h"
#if ENABLE(VIDEO)
#include "MediaController.h"
#include "Clock.h"
#include "HTMLMediaElement.h"
#include "TimeRanges.h"
#include <wtf/CurrentTime.h>
#include <wtf/StdLibExtras.h>
#include <wtf/text/AtomicString.h>
using namespace WebCore;
Ref<MediaController> MediaController::create(ScriptExecutionContext& context)
{
return adoptRef(*new MediaController(context));
}
MediaController::MediaController(ScriptExecutionContext& context)
: m_paused(false)
, m_defaultPlaybackRate(1)
, m_volume(1)
, m_position(MediaPlayer::invalidTime())
, m_muted(false)
, m_readyState(HAVE_NOTHING)
, m_playbackState(WAITING)
, m_asyncEventTimer(*this, &MediaController::asyncEventTimerFired)
, m_clearPositionTimer(*this, &MediaController::clearPositionTimerFired)
, m_closedCaptionsVisible(false)
, m_clock(Clock::create())
, m_scriptExecutionContext(context)
, m_timeupdateTimer(*this, &MediaController::timeupdateTimerFired)
, m_previousTimeupdateTime(0)
{
}
MediaController::~MediaController()
{
}
void MediaController::addMediaElement(HTMLMediaElement* element)
{
ASSERT(element);
ASSERT(!m_mediaElements.contains(element));
m_mediaElements.append(element);
bringElementUpToSpeed(element);
}
void MediaController::removeMediaElement(HTMLMediaElement* element)
{
ASSERT(element);
ASSERT(m_mediaElements.contains(element));
m_mediaElements.remove(m_mediaElements.find(element));
}
bool MediaController::containsMediaElement(HTMLMediaElement* element) const
{
return m_mediaElements.contains(element);
}
PassRefPtr<TimeRanges> MediaController::buffered() const
{
if (m_mediaElements.isEmpty())
return TimeRanges::create();
RefPtr<TimeRanges> bufferedRanges = m_mediaElements.first()->buffered();
for (size_t index = 1; index < m_mediaElements.size(); ++index)
bufferedRanges->intersectWith(*m_mediaElements[index]->buffered().get());
return bufferedRanges;
}
PassRefPtr<TimeRanges> MediaController::seekable() const
{
if (m_mediaElements.isEmpty())
return TimeRanges::create();
RefPtr<TimeRanges> seekableRanges = m_mediaElements.first()->seekable();
for (size_t index = 1; index < m_mediaElements.size(); ++index)
seekableRanges->intersectWith(*m_mediaElements[index]->seekable().get());
return seekableRanges;
}
PassRefPtr<TimeRanges> MediaController::played()
{
if (m_mediaElements.isEmpty())
return TimeRanges::create();
RefPtr<TimeRanges> playedRanges = m_mediaElements.first()->played();
for (size_t index = 1; index < m_mediaElements.size(); ++index)
playedRanges->unionWith(*m_mediaElements[index]->played().get());
return playedRanges;
}
double MediaController::duration() const
{
double maxDuration = 0;
for (size_t index = 0; index < m_mediaElements.size(); ++index) {
double duration = m_mediaElements[index]->duration();
if (std::isnan(duration))
continue;
maxDuration = std::max(maxDuration, duration);
}
return maxDuration;
}
double MediaController::currentTime() const
{
if (m_mediaElements.isEmpty())
return 0;
if (m_position == MediaPlayer::invalidTime()) {
m_position = std::max<double>(0, std::min(duration(), m_clock->currentTime()));
m_clearPositionTimer.startOneShot(0);
}
return m_position;
}
void MediaController::setCurrentTime(double time)
{
time = std::max(0.0, time);
time = std::min(time, duration());
m_clock->setCurrentTime(time);
for (size_t index = 0; index < m_mediaElements.size(); ++index)
m_mediaElements[index]->seek(MediaTime::createWithDouble(time));
scheduleTimeupdateEvent();
}
void MediaController::unpause()
{
if (!m_paused)
return;
m_paused = false;
scheduleEvent(eventNames().playEvent);
reportControllerState();
}
void MediaController::play()
{
for (size_t index = 0; index < m_mediaElements.size(); ++index)
m_mediaElements[index]->play();
unpause();
}
void MediaController::pause()
{
if (m_paused)
return;
m_paused = true;
scheduleEvent(eventNames().pauseEvent);
reportControllerState();
}
void MediaController::setDefaultPlaybackRate(double rate)
{
if (m_defaultPlaybackRate == rate)
return;
m_defaultPlaybackRate = rate;
scheduleEvent(eventNames().ratechangeEvent);
}
double MediaController::playbackRate() const
{
return m_clock->playRate();
}
void MediaController::setPlaybackRate(double rate)
{
if (m_clock->playRate() == rate)
return;
m_clock->setPlayRate(rate);
for (size_t index = 0; index < m_mediaElements.size(); ++index)
m_mediaElements[index]->updatePlaybackRate();
scheduleEvent(eventNames().ratechangeEvent);
}
void MediaController::setVolume(double level, ExceptionCode& code)
{
if (m_volume == level)
return;
if (level < 0 || level > 1) {
code = INDEX_SIZE_ERR;
return;
}
m_volume = level;
scheduleEvent(eventNames().volumechangeEvent);
for (size_t index = 0; index < m_mediaElements.size(); ++index)
m_mediaElements[index]->updateVolume();
}
void MediaController::setMuted(bool flag)
{
if (m_muted == flag)
return;
m_muted = flag;
scheduleEvent(eventNames().volumechangeEvent);
for (size_t index = 0; index < m_mediaElements.size(); ++index)
m_mediaElements[index]->updateVolume();
}
static const AtomicString& playbackStateWaiting()
{
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, waiting, ("waiting", AtomicString::ConstructFromLiteral));
return waiting;
}
static const AtomicString& playbackStatePlaying()
{
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, playing, ("playing", AtomicString::ConstructFromLiteral));
return playing;
}
static const AtomicString& playbackStateEnded()
{
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, ended, ("ended", AtomicString::ConstructFromLiteral));
return ended;
}
const AtomicString& MediaController::playbackState() const
{
switch (m_playbackState) {
case WAITING:
return playbackStateWaiting();
case PLAYING:
return playbackStatePlaying();
case ENDED:
return playbackStateEnded();
default:
ASSERT_NOT_REACHED();
return nullAtom;
}
}
void MediaController::reportControllerState()
{
updateReadyState();
updatePlaybackState();
}
static AtomicString eventNameForReadyState(MediaControllerInterface::ReadyState state)
{
switch (state) {
case MediaControllerInterface::HAVE_NOTHING:
return eventNames().emptiedEvent;
case MediaControllerInterface::HAVE_METADATA:
return eventNames().loadedmetadataEvent;
case MediaControllerInterface::HAVE_CURRENT_DATA:
return eventNames().loadeddataEvent;
case MediaControllerInterface::HAVE_FUTURE_DATA:
return eventNames().canplayEvent;
case MediaControllerInterface::HAVE_ENOUGH_DATA:
return eventNames().canplaythroughEvent;
default:
ASSERT_NOT_REACHED();
return nullAtom;
}
}
void MediaController::updateReadyState()
{
ReadyState oldReadyState = m_readyState;
ReadyState newReadyState;
if (m_mediaElements.isEmpty()) {
newReadyState = HAVE_NOTHING;
} else {
newReadyState = m_mediaElements.first()->readyState();
for (size_t index = 1; index < m_mediaElements.size(); ++index)
newReadyState = std::min(newReadyState, m_mediaElements[index]->readyState());
}
if (newReadyState == oldReadyState)
return;
if (oldReadyState > newReadyState) {
scheduleEvent(eventNameForReadyState(newReadyState));
return;
}
ReadyState nextState = oldReadyState;
do {
nextState = static_cast<ReadyState>(nextState + 1);
scheduleEvent(eventNameForReadyState(nextState));
} while (nextState < newReadyState);
m_readyState = newReadyState;
}
void MediaController::updatePlaybackState()
{
PlaybackState oldPlaybackState = m_playbackState;
PlaybackState newPlaybackState;
if (m_mediaElements.isEmpty()) {
newPlaybackState = WAITING;
} else if (hasEnded()) {
newPlaybackState = ENDED;
} else if (isBlocked()) {
newPlaybackState = WAITING;
} else {
newPlaybackState = PLAYING;
}
if (newPlaybackState == oldPlaybackState)
return;
if (newPlaybackState == ENDED) {
if (!m_paused && hasEnded()) {
m_paused = true;
scheduleEvent(eventNames().pauseEvent);
}
}
AtomicString eventName;
switch (newPlaybackState) {
case WAITING:
eventName = eventNames().waitingEvent;
m_clock->stop();
m_timeupdateTimer.stop();
break;
case ENDED:
eventName = eventNames().endedEvent;
m_clock->stop();
m_clock->setCurrentTime(0);
m_timeupdateTimer.stop();
break;
case PLAYING:
eventName = eventNames().playingEvent;
m_clock->start();
startTimeupdateTimer();
break;
default:
ASSERT_NOT_REACHED();
}
scheduleEvent(eventName);
m_playbackState = newPlaybackState;
updateMediaElements();
}
void MediaController::updateMediaElements()
{
for (size_t index = 0; index < m_mediaElements.size(); ++index)
m_mediaElements[index]->updatePlayState();
}
void MediaController::bringElementUpToSpeed(HTMLMediaElement* element)
{
ASSERT(element);
ASSERT(m_mediaElements.contains(element));
element->seekInternal(MediaTime::createWithDouble(currentTime()));
}
bool MediaController::isBlocked() const
{
if (m_paused)
return true;
if (m_mediaElements.isEmpty())
return false;
bool allPaused = true;
for (size_t index = 0; index < m_mediaElements.size(); ++index) {
HTMLMediaElement* element = m_mediaElements[index];
if (element->isBlocked())
return true;
if (element->isAutoplaying() && element->paused())
return true;
if (!element->paused())
allPaused = false;
}
return allPaused;
}
bool MediaController::hasEnded() const
{
if (m_clock->playRate() < 0)
return false;
if (m_mediaElements.isEmpty())
return false;
bool allHaveEnded = true;
for (size_t index = 0; index < m_mediaElements.size(); ++index) {
if (!m_mediaElements[index]->ended())
allHaveEnded = false;
}
return allHaveEnded;
}
void MediaController::scheduleEvent(const AtomicString& eventName)
{
m_pendingEvents.append(Event::create(eventName, false, true));
if (!m_asyncEventTimer.isActive())
m_asyncEventTimer.startOneShot(0);
}
void MediaController::asyncEventTimerFired()
{
Vector<RefPtr<Event>> pendingEvents;
m_pendingEvents.swap(pendingEvents);
size_t count = pendingEvents.size();
for (size_t index = 0; index < count; ++index)
dispatchEvent(pendingEvents[index].release(), IGNORE_EXCEPTION);
}
void MediaController::clearPositionTimerFired()
{
m_position = MediaPlayer::invalidTime();
}
bool MediaController::hasAudio() const
{
for (size_t index = 0; index < m_mediaElements.size(); ++index) {
if (m_mediaElements[index]->hasAudio())
return true;
}
return false;
}
bool MediaController::hasVideo() const
{
for (size_t index = 0; index < m_mediaElements.size(); ++index) {
if (m_mediaElements[index]->hasVideo())
return true;
}
return false;
}
bool MediaController::hasClosedCaptions() const
{
for (size_t index = 0; index < m_mediaElements.size(); ++index) {
if (m_mediaElements[index]->hasClosedCaptions())
return true;
}
return false;
}
void MediaController::setClosedCaptionsVisible(bool visible)
{
m_closedCaptionsVisible = visible;
for (size_t index = 0; index < m_mediaElements.size(); ++index)
m_mediaElements[index]->setClosedCaptionsVisible(visible);
}
bool MediaController::supportsScanning() const
{
for (size_t index = 0; index < m_mediaElements.size(); ++index) {
if (!m_mediaElements[index]->supportsScanning())
return false;
}
return true;
}
void MediaController::beginScrubbing()
{
for (size_t index = 0; index < m_mediaElements.size(); ++index)
m_mediaElements[index]->beginScrubbing();
if (m_playbackState == PLAYING)
m_clock->stop();
}
void MediaController::endScrubbing()
{
for (size_t index = 0; index < m_mediaElements.size(); ++index)
m_mediaElements[index]->endScrubbing();
if (m_playbackState == PLAYING)
m_clock->start();
}
void MediaController::beginScanning(ScanDirection direction)
{
for (auto& mediaElement : m_mediaElements)
mediaElement->beginScanning(direction);
}
void MediaController::endScanning()
{
for (auto& mediaElement : m_mediaElements)
mediaElement->endScanning();
}
bool MediaController::canPlay() const
{
if (m_paused)
return true;
for (size_t index = 0; index < m_mediaElements.size(); ++index) {
if (!m_mediaElements[index]->canPlay())
return false;
}
return true;
}
bool MediaController::isLiveStream() const
{
for (size_t index = 0; index < m_mediaElements.size(); ++index) {
if (!m_mediaElements[index]->isLiveStream())
return false;
}
return true;
}
bool MediaController::hasCurrentSrc() const
{
for (size_t index = 0; index < m_mediaElements.size(); ++index) {
if (!m_mediaElements[index]->hasCurrentSrc())
return false;
}
return true;
}
void MediaController::returnToRealtime()
{
for (size_t index = 0; index < m_mediaElements.size(); ++index)
m_mediaElements[index]->returnToRealtime();
}
static const double maxTimeupdateEventFrequency = 0.25;
void MediaController::startTimeupdateTimer()
{
if (m_timeupdateTimer.isActive())
return;
m_timeupdateTimer.startRepeating(maxTimeupdateEventFrequency);
}
void MediaController::timeupdateTimerFired()
{
scheduleTimeupdateEvent();
}
void MediaController::scheduleTimeupdateEvent()
{
double now = monotonicallyIncreasingTime();
double timedelta = now - m_previousTimeupdateTime;
if (timedelta < maxTimeupdateEventFrequency)
return;
scheduleEvent(eventNames().timeupdateEvent);
m_previousTimeupdateTime = now;
}
#endif