#include "config.h"
#include "MediaStream.h"
#if ENABLE(MEDIA_STREAM)
#include "Document.h"
#include "Event.h"
#include "EventNames.h"
#include "Logging.h"
#include "MediaStreamRegistry.h"
#include "MediaStreamTrackEvent.h"
#include "Page.h"
#include "RealtimeMediaSource.h"
#include "URL.h"
namespace WebCore {
Ref<MediaStream> MediaStream::create(ScriptExecutionContext& context)
{
return MediaStream::create(context, MediaStreamPrivate::create(Vector<RefPtr<MediaStreamTrackPrivate>>()));
}
Ref<MediaStream> MediaStream::create(ScriptExecutionContext& context, MediaStream& stream)
{
return adoptRef(*new MediaStream(context, stream.getTracks()));
}
Ref<MediaStream> MediaStream::create(ScriptExecutionContext& context, const MediaStreamTrackVector& tracks)
{
return adoptRef(*new MediaStream(context, tracks));
}
Ref<MediaStream> MediaStream::create(ScriptExecutionContext& context, RefPtr<MediaStreamPrivate>&& streamPrivate)
{
return adoptRef(*new MediaStream(context, WTFMove(streamPrivate)));
}
MediaStream::MediaStream(ScriptExecutionContext& context, const MediaStreamTrackVector& tracks)
: ContextDestructionObserver(&context)
, m_activityEventTimer(*this, &MediaStream::activityEventTimerFired)
{
MediaStreamTrackPrivateVector trackPrivates;
trackPrivates.reserveCapacity(tracks.size());
for (auto& track : tracks) {
track->addObserver(*this);
m_trackSet.add(track->id(), track);
trackPrivates.append(&track->privateTrack());
}
m_private = MediaStreamPrivate::create(trackPrivates);
setIsActive(m_private->active());
m_private->addObserver(*this);
MediaStreamRegistry::shared().registerStream(*this);
document()->addAudioProducer(this);
}
MediaStream::MediaStream(ScriptExecutionContext& context, RefPtr<MediaStreamPrivate>&& streamPrivate)
: ContextDestructionObserver(&context)
, m_private(streamPrivate)
, m_activityEventTimer(*this, &MediaStream::activityEventTimerFired)
{
ASSERT(m_private);
setIsActive(m_private->active());
m_private->addObserver(*this);
MediaStreamRegistry::shared().registerStream(*this);
for (auto& trackPrivate : m_private->tracks()) {
auto track = MediaStreamTrack::create(context, *trackPrivate);
track->addObserver(*this);
m_trackSet.add(track->id(), WTFMove(track));
}
document()->addAudioProducer(this);
}
MediaStream::~MediaStream()
{
m_isActive = false;
MediaStreamRegistry::shared().unregisterStream(*this);
m_private->removeObserver(*this);
for (auto& track : m_trackSet.values())
track->removeObserver(*this);
if (Document* document = this->document()) {
document->removeAudioProducer(this);
if (m_isWaitingUntilMediaCanStart)
document->removeMediaCanStartListener(this);
}
}
RefPtr<MediaStream> MediaStream::clone()
{
MediaStreamTrackVector clonedTracks;
clonedTracks.reserveCapacity(m_trackSet.size());
for (auto& track : m_trackSet.values())
clonedTracks.append(track->clone());
return MediaStream::create(*scriptExecutionContext(), clonedTracks);
}
void MediaStream::addTrack(MediaStreamTrack& track)
{
if (!internalAddTrack(track, StreamModifier::DomAPI))
return;
for (auto& observer : m_observers)
observer->didAddOrRemoveTrack();
}
void MediaStream::removeTrack(MediaStreamTrack& track)
{
if (!internalRemoveTrack(track.id(), StreamModifier::DomAPI))
return;
for (auto& observer : m_observers)
observer->didAddOrRemoveTrack();
}
MediaStreamTrack* MediaStream::getTrackById(String id)
{
auto it = m_trackSet.find(id);
if (it != m_trackSet.end())
return it->value.get();
return nullptr;
}
MediaStreamTrackVector MediaStream::getAudioTracks() const
{
return trackVectorForType(RealtimeMediaSource::Audio);
}
MediaStreamTrackVector MediaStream::getVideoTracks() const
{
return trackVectorForType(RealtimeMediaSource::Video);
}
MediaStreamTrackVector MediaStream::getTracks() const
{
MediaStreamTrackVector tracks;
tracks.reserveCapacity(m_trackSet.size());
copyValuesToVector(m_trackSet, tracks);
return tracks;
}
void MediaStream::contextDestroyed()
{
ContextDestructionObserver::contextDestroyed();
}
void MediaStream::trackDidEnd()
{
m_private->updateActiveState(MediaStreamPrivate::NotifyClientOption::Notify);
}
void MediaStream::activeStatusChanged()
{
scheduleActiveStateChange();
}
void MediaStream::didAddTrack(MediaStreamTrackPrivate& trackPrivate)
{
ScriptExecutionContext* context = scriptExecutionContext();
if (!context)
return;
if (!getTrackById(trackPrivate.id()))
internalAddTrack(MediaStreamTrack::create(*context, trackPrivate), StreamModifier::Platform);
}
void MediaStream::didRemoveTrack(MediaStreamTrackPrivate& trackPrivate)
{
internalRemoveTrack(trackPrivate.id(), StreamModifier::Platform);
}
bool MediaStream::internalAddTrack(Ref<MediaStreamTrack>&& trackToAdd, StreamModifier streamModifier)
{
auto result = m_trackSet.add(trackToAdd->id(), WTFMove(trackToAdd));
if (!result.isNewEntry)
return false;
ASSERT(result.iterator->value);
auto& track = *result.iterator->value;
track.addObserver(*this);
if (streamModifier == StreamModifier::DomAPI)
m_private->addTrack(&track.privateTrack(), MediaStreamPrivate::NotifyClientOption::DontNotify);
else
dispatchEvent(MediaStreamTrackEvent::create(eventNames().addtrackEvent, false, false, &track));
return true;
}
bool MediaStream::internalRemoveTrack(const String& trackId, StreamModifier streamModifier)
{
auto track = m_trackSet.take(trackId);
if (!track)
return false;
track->removeObserver(*this);
if (streamModifier == StreamModifier::DomAPI)
m_private->removeTrack(track->privateTrack(), MediaStreamPrivate::NotifyClientOption::DontNotify);
else
dispatchEvent(MediaStreamTrackEvent::create(eventNames().removetrackEvent, false, false, WTFMove(track)));
return true;
}
void MediaStream::setIsActive(bool active)
{
if (m_isActive == active)
return;
m_isActive = active;
statusDidChange();
}
void MediaStream::mediaCanStart(Document& document)
{
ASSERT_UNUSED(document, &document == this->document());
ASSERT(m_isWaitingUntilMediaCanStart);
if (m_isWaitingUntilMediaCanStart) {
m_isWaitingUntilMediaCanStart = false;
startProducingData();
}
}
void MediaStream::startProducingData()
{
Document* document = this->document();
if (!document || !document->page())
return;
if (!document->page()->canStartMedia()) {
LOG(Media, "MediaStream::startProducingData(%p) - not allowed to start in background, waiting", this);
if (m_isWaitingUntilMediaCanStart)
return;
m_isWaitingUntilMediaCanStart = true;
document->addMediaCanStartListener(this);
return;
}
m_private->startProducingData();
}
void MediaStream::stopProducingData()
{
m_private->stopProducingData();
}
void MediaStream::pageMutedStateDidChange()
{
if (!m_isActive)
return;
Document* document = this->document();
if (!document)
return;
bool pageMuted = document->page()->isMediaCaptureMuted();
if (m_externallyMuted == pageMuted)
return;
m_externallyMuted = pageMuted;
if (pageMuted)
stopProducingData();
else
startProducingData();
}
MediaProducer::MediaStateFlags MediaStream::mediaState() const
{
MediaStateFlags state = IsNotPlaying;
if (!m_isActive)
return state;
if (m_private->hasAudio()) {
state |= HasAudioOrVideo;
if (m_private->hasLocalAudioSource() && m_private->isProducingData())
state |= HasActiveAudioCaptureDevice;
}
if (m_private->hasVideo()) {
state |= HasAudioOrVideo;
if (m_private->hasLocalVideoSource() && m_private->isProducingData())
state |= HasActiveVideoCaptureDevice;
}
return state;
}
void MediaStream::statusDidChange()
{
if (Document* document = this->document()) {
if (m_isActive)
document->setHasActiveMediaStreamTrack();
document->updateIsPlayingMedia();
}
}
void MediaStream::characteristicsChanged()
{
bool muted = m_private->muted();
if (m_isMuted != muted) {
m_isMuted = muted;
statusDidChange();
}
}
void MediaStream::scheduleActiveStateChange()
{
bool active = false;
for (auto& track : m_trackSet.values()) {
if (!track->ended()) {
active = true;
break;
}
}
if (m_isActive == active)
return;
setIsActive(active);
const AtomicString& eventName = m_isActive ? eventNames().inactiveEvent : eventNames().activeEvent;
m_scheduledActivityEvents.append(Event::create(eventName, false, false));
if (!m_activityEventTimer.isActive())
m_activityEventTimer.startOneShot(0);
}
void MediaStream::activityEventTimerFired()
{
Vector<Ref<Event>> events;
events.swap(m_scheduledActivityEvents);
for (auto& event : events)
dispatchEvent(event);
}
URLRegistry& MediaStream::registry() const
{
return MediaStreamRegistry::shared();
}
MediaStreamTrackVector MediaStream::trackVectorForType(RealtimeMediaSource::Type filterType) const
{
MediaStreamTrackVector tracks;
for (auto& track : m_trackSet.values()) {
if (track->source().type() == filterType)
tracks.append(track);
}
return tracks;
}
void MediaStream::addObserver(MediaStream::Observer* observer)
{
if (m_observers.find(observer) == notFound)
m_observers.append(observer);
}
void MediaStream::removeObserver(MediaStream::Observer* observer)
{
size_t pos = m_observers.find(observer);
if (pos != notFound)
m_observers.remove(pos);
}
Document* MediaStream::document() const
{
return downcast<Document>(scriptExecutionContext());
}
}
#endif // ENABLE(MEDIA_STREAM)