MediaStreamTrack.cpp [plain text]
#include "config.h"
#include "MediaStreamTrack.h"
#if ENABLE(MEDIA_STREAM)
#include "Dictionary.h"
#include "Event.h"
#include "EventNames.h"
#include "ExceptionCode.h"
#include "ExceptionCodePlaceholder.h"
#include "MediaConstraintsImpl.h"
#include "MediaSourceSettings.h"
#include "MediaStream.h"
#include "MediaStreamPrivate.h"
#include "MediaTrackConstraints.h"
#include "NotImplemented.h"
#include "ScriptExecutionContext.h"
#include <wtf/NeverDestroyed.h>
namespace WebCore {
Ref<MediaStreamTrack> MediaStreamTrack::create(ScriptExecutionContext& context, MediaStreamTrackPrivate& privateTrack)
{
return adoptRef(*new MediaStreamTrack(context, privateTrack));
}
MediaStreamTrack::MediaStreamTrack(ScriptExecutionContext& context, MediaStreamTrackPrivate& privateTrack)
: RefCounted()
, ActiveDOMObject(&context)
, m_private(privateTrack)
{
suspendIfNeeded();
m_private->addObserver(*this);
}
MediaStreamTrack::~MediaStreamTrack()
{
m_private->removeObserver(*this);
}
const AtomicString& MediaStreamTrack::kind() const
{
static NeverDestroyed<AtomicString> audioKind("audio", AtomicString::ConstructFromLiteral);
static NeverDestroyed<AtomicString> videoKind("video", AtomicString::ConstructFromLiteral);
if (m_private->type() == RealtimeMediaSource::Audio)
return audioKind;
return videoKind;
}
const String& MediaStreamTrack::id() const
{
return m_private->id();
}
const String& MediaStreamTrack::label() const
{
return m_private->label();
}
bool MediaStreamTrack::enabled() const
{
return m_private->enabled();
}
void MediaStreamTrack::setEnabled(bool enabled)
{
m_private->setEnabled(enabled);
}
bool MediaStreamTrack::muted() const
{
return m_private->muted();
}
bool MediaStreamTrack::readonly() const
{
return m_private->readonly();
}
bool MediaStreamTrack::remote() const
{
return m_private->remote();
}
auto MediaStreamTrack::readyState() const -> State
{
return ended() ? State::Ended : State::Live;
}
bool MediaStreamTrack::ended() const
{
return m_ended || m_private->ended();
}
RefPtr<MediaStreamTrack> MediaStreamTrack::clone()
{
return MediaStreamTrack::create(*scriptExecutionContext(), *m_private->clone());
}
void MediaStreamTrack::stopProducingData()
{
if (remote() || ended())
return;
m_ended = true;
m_private->endTrack();
}
RefPtr<MediaTrackConstraints> MediaStreamTrack::getConstraints() const
{
notImplemented();
return 0;
}
RefPtr<MediaSourceSettings> MediaStreamTrack::getSettings() const
{
return MediaSourceSettings::create(m_private->settings());
}
RefPtr<RealtimeMediaSourceCapabilities> MediaStreamTrack::getCapabilities() const
{
return m_private->capabilities();
}
void MediaStreamTrack::applyConstraints(const Dictionary& constraints)
{
m_constraints->initialize(constraints);
m_private->applyConstraints(*m_constraints);
}
void MediaStreamTrack::applyConstraints(const MediaConstraints&)
{
}
void MediaStreamTrack::addObserver(MediaStreamTrack::Observer* observer)
{
m_observers.append(observer);
}
void MediaStreamTrack::removeObserver(MediaStreamTrack::Observer* observer)
{
size_t pos = m_observers.find(observer);
if (pos != notFound)
m_observers.remove(pos);
}
void MediaStreamTrack::trackEnded(MediaStreamTrackPrivate&)
{
if (m_ended)
return;
m_ended = true;
if (scriptExecutionContext()->activeDOMObjectsAreSuspended() || scriptExecutionContext()->activeDOMObjectsAreStopped())
return;
dispatchEvent(Event::create(eventNames().endedEvent, false, false));
for (auto& observer : m_observers)
observer->trackDidEnd();
configureTrackRendering();
}
void MediaStreamTrack::trackMutedChanged(MediaStreamTrackPrivate&)
{
if (scriptExecutionContext()->activeDOMObjectsAreSuspended() || scriptExecutionContext()->activeDOMObjectsAreStopped())
return;
AtomicString eventType = muted() ? eventNames().muteEvent : eventNames().unmuteEvent;
dispatchEvent(Event::create(eventType, false, false));
configureTrackRendering();
}
void MediaStreamTrack::trackSettingsChanged(MediaStreamTrackPrivate&)
{
configureTrackRendering();
}
void MediaStreamTrack::trackEnabledChanged(MediaStreamTrackPrivate&)
{
configureTrackRendering();
}
void MediaStreamTrack::configureTrackRendering()
{
}
void MediaStreamTrack::stop()
{
stopProducingData();
}
const char* MediaStreamTrack::activeDOMObjectName() const
{
return "MediaStreamTrack";
}
bool MediaStreamTrack::canSuspendForDocumentSuspension() const
{
return false;
}
AudioSourceProvider* MediaStreamTrack::audioSourceProvider()
{
return m_private->audioSourceProvider();
}
}
#endif // ENABLE(MEDIA_STREAM)