MediaStreamTrack.cpp [plain text]
#include "config.h"
#include "MediaStreamTrack.h"
#if ENABLE(MEDIA_STREAM)
#include "AllAudioCapabilities.h"
#include "AllVideoCapabilities.h"
#include "Dictionary.h"
#include "Event.h"
#include "ExceptionCode.h"
#include "ExceptionCodePlaceholder.h"
#include "MediaConstraintsImpl.h"
#include "MediaSourceStates.h"
#include "MediaStream.h"
#include "MediaStreamPrivate.h"
#include "MediaTrackConstraints.h"
#include "NotImplemented.h"
#include <wtf/Functional.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->setClient(this);
}
MediaStreamTrack::~MediaStreamTrack()
{
m_private->setClient(nullptr);
}
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();
}
const AtomicString& MediaStreamTrack::readyState() const
{
static NeverDestroyed<AtomicString> endedState("ended", AtomicString::ConstructFromLiteral);
static NeverDestroyed<AtomicString> liveState("live", AtomicString::ConstructFromLiteral);
return ended() ? endedState : liveState;
}
bool MediaStreamTrack::ended() const
{
return m_private->ended();
}
RefPtr<MediaStreamTrack> MediaStreamTrack::clone()
{
return MediaStreamTrack::create(*scriptExecutionContext(), *m_private->clone());
}
void MediaStreamTrack::stopProducingData()
{
if (remote() || ended())
return;
m_private->endTrack();
}
RefPtr<MediaTrackConstraints> MediaStreamTrack::getConstraints() const
{
notImplemented();
return 0;
}
RefPtr<MediaSourceStates> MediaStreamTrack::states() const
{
return MediaSourceStates::create(m_private->states());
}
RefPtr<MediaStreamCapabilities> MediaStreamTrack::getCapabilities() const
{
RefPtr<RealtimeMediaSourceCapabilities> sourceCapabilities = m_private->capabilities();
if (ended())
sourceCapabilities->setSourceType(RealtimeMediaSourceStates::None);
return MediaStreamCapabilities::create(sourceCapabilities.release());
}
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()
{
dispatchEvent(Event::create(eventNames().endedEvent, false, false));
for (auto& observer : m_observers)
observer->trackDidEnd();
configureTrackRendering();
}
void MediaStreamTrack::trackMutedChanged()
{
AtomicString eventType = muted() ? eventNames().muteEvent : eventNames().unmuteEvent;
dispatchEvent(Event::create(eventType, false, false));
configureTrackRendering();
}
void MediaStreamTrack::configureTrackRendering()
{
}
void MediaStreamTrack::stop()
{
stopProducingData();
}
const char* MediaStreamTrack::activeDOMObjectName() const
{
return "MediaStreamTrack";
}
bool MediaStreamTrack::canSuspendForPageCache() const
{
return false;
}
}
#endif // ENABLE(MEDIA_STREAM)