RealtimeMediaSource.cpp [plain text]
#include "config.h"
#if ENABLE(MEDIA_STREAM)
#include "RealtimeMediaSource.h"
#include "MediaConstraints.h"
#include "NotImplemented.h"
#include "RealtimeMediaSourceCapabilities.h"
#include "UUID.h"
#include <wtf/MainThread.h>
#include <wtf/text/StringHash.h>
namespace WebCore {
RealtimeMediaSource::RealtimeMediaSource(const String& id, Type type, const String& name)
: m_weakPtrFactory(this)
, m_id(id)
, m_type(type)
, m_name(name)
{
if (m_id.isEmpty())
m_id = createCanonicalUUIDString();
m_persistentID = m_id;
m_suppressNotifications = false;
}
void RealtimeMediaSource::reset()
{
m_stopped = false;
m_muted = false;
m_readonly = false;
m_remote = false;
}
void RealtimeMediaSource::addObserver(RealtimeMediaSource::Observer* observer)
{
m_observers.append(observer);
}
void RealtimeMediaSource::removeObserver(RealtimeMediaSource::Observer* observer)
{
size_t pos = m_observers.find(observer);
if (pos != notFound)
m_observers.remove(pos);
if (!m_observers.size())
stop();
}
void RealtimeMediaSource::setMuted(bool muted)
{
if (m_stopped || m_muted == muted)
return;
m_muted = muted;
if (stopped())
return;
for (auto& observer : m_observers)
observer->sourceMutedChanged();
}
void RealtimeMediaSource::settingsDidChange()
{
ASSERT(isMainThread());
if (m_pendingSettingsDidChangeNotification || m_suppressNotifications)
return;
m_pendingSettingsDidChangeNotification = true;
scheduleDeferredTask([this] {
m_pendingSettingsDidChangeNotification = false;
for (auto& observer : m_observers)
observer->sourceSettingsChanged();
});
}
void RealtimeMediaSource::mediaDataUpdated(MediaSample& mediaSample)
{
for (auto& observer : m_observers)
observer->sourceHasMoreMediaData(mediaSample);
}
bool RealtimeMediaSource::readonly() const
{
return m_readonly;
}
void RealtimeMediaSource::stop(Observer* callingObserver)
{
if (stopped())
return;
m_stopped = true;
for (auto* observer : m_observers) {
if (observer != callingObserver)
observer->sourceStopped();
}
stopProducingData();
}
void RealtimeMediaSource::requestStop(Observer* callingObserver)
{
if (stopped())
return;
for (auto* observer : m_observers) {
if (observer->preventSourceFromStopping())
return;
}
stop(callingObserver);
}
bool RealtimeMediaSource::supportsSizeAndFrameRate(std::optional<int>, std::optional<int>, std::optional<double>)
{
return true;
}
bool RealtimeMediaSource::supportsSizeAndFrameRate(std::optional<IntConstraint> widthConstraint, std::optional<IntConstraint> heightConstraint, std::optional<DoubleConstraint> frameRateConstraint, String& badConstraint)
{
if (!widthConstraint && !heightConstraint && !frameRateConstraint)
return true;
ASSERT(this->capabilities());
RealtimeMediaSourceCapabilities& capabilities = *this->capabilities();
std::optional<int> width;
if (widthConstraint && capabilities.supportsWidth()) {
if (std::isinf(fitnessDistance(*widthConstraint))) {
badConstraint = widthConstraint->name();
return false;
}
auto range = capabilities.width();
width = widthConstraint->valueForCapabilityRange(size().width(), range.rangeMin().asInt, range.rangeMax().asInt);
}
std::optional<int> height;
if (heightConstraint && capabilities.supportsHeight()) {
if (std::isinf(fitnessDistance(*heightConstraint))) {
badConstraint = heightConstraint->name();
return false;
}
auto range = capabilities.height();
height = heightConstraint->valueForCapabilityRange(size().height(), range.rangeMin().asInt, range.rangeMax().asInt);
}
std::optional<double> frameRate;
if (frameRateConstraint && capabilities.supportsFrameRate()) {
if (std::isinf(fitnessDistance(*frameRateConstraint))) {
badConstraint = frameRateConstraint->name();
return false;
}
auto range = capabilities.frameRate();
frameRate = frameRateConstraint->valueForCapabilityRange(this->frameRate(), range.rangeMin().asDouble, range.rangeMax().asDouble);
}
if (!supportsSizeAndFrameRate(WTFMove(width), WTFMove(height), WTFMove(frameRate))) {
if (widthConstraint)
badConstraint = widthConstraint->name();
else if (heightConstraint)
badConstraint = heightConstraint->name();
else
badConstraint = frameRateConstraint->name();
return false;
}
return true;
}
double RealtimeMediaSource::fitnessDistance(const MediaConstraint& constraint)
{
ASSERT(this->capabilities());
RealtimeMediaSourceCapabilities& capabilities = *this->capabilities();
switch (constraint.constraintType()) {
case MediaConstraintType::Width: {
ASSERT(constraint.isInt());
if (!capabilities.supportsWidth())
return 0;
auto range = capabilities.width();
return downcast<IntConstraint>(constraint).fitnessDistance(range.rangeMin().asInt, range.rangeMax().asInt);
break;
}
case MediaConstraintType::Height: {
ASSERT(constraint.isInt());
if (!capabilities.supportsHeight())
return 0;
auto range = capabilities.height();
return downcast<IntConstraint>(constraint).fitnessDistance(range.rangeMin().asInt, range.rangeMax().asInt);
break;
}
case MediaConstraintType::FrameRate: {
ASSERT(constraint.isDouble());
if (!capabilities.supportsFrameRate())
return 0;
auto range = capabilities.frameRate();
return downcast<DoubleConstraint>(constraint).fitnessDistance(range.rangeMin().asDouble, range.rangeMax().asDouble);
break;
}
case MediaConstraintType::AspectRatio: {
ASSERT(constraint.isDouble());
if (!capabilities.supportsAspectRatio())
return 0;
auto range = capabilities.aspectRatio();
return downcast<DoubleConstraint>(constraint).fitnessDistance(range.rangeMin().asDouble, range.rangeMax().asDouble);
break;
}
case MediaConstraintType::Volume: {
ASSERT(constraint.isDouble());
if (!capabilities.supportsVolume())
return 0;
auto range = capabilities.volume();
return downcast<DoubleConstraint>(constraint).fitnessDistance(range.rangeMin().asDouble, range.rangeMax().asDouble);
break;
}
case MediaConstraintType::SampleRate: {
ASSERT(constraint.isInt());
if (!capabilities.supportsSampleRate())
return 0;
auto range = capabilities.sampleRate();
return downcast<IntConstraint>(constraint).fitnessDistance(range.rangeMin().asInt, range.rangeMax().asInt);
break;
}
case MediaConstraintType::SampleSize: {
ASSERT(constraint.isInt());
if (!capabilities.supportsSampleSize())
return 0;
auto range = capabilities.sampleSize();
return downcast<IntConstraint>(constraint).fitnessDistance(range.rangeMin().asInt, range.rangeMax().asInt);
break;
}
case MediaConstraintType::FacingMode: {
ASSERT(constraint.isString());
if (!capabilities.supportsFacingMode())
return 0;
auto& modes = capabilities.facingMode();
Vector<String> supportedModes;
supportedModes.reserveInitialCapacity(modes.size());
for (auto& mode : modes)
supportedModes.uncheckedAppend(RealtimeMediaSourceSettings::facingMode(mode));
return downcast<StringConstraint>(constraint).fitnessDistance(supportedModes);
break;
}
case MediaConstraintType::EchoCancellation: {
ASSERT(constraint.isBoolean());
if (!capabilities.supportsEchoCancellation())
return 0;
bool echoCancellationReadWrite = capabilities.echoCancellation() == RealtimeMediaSourceCapabilities::EchoCancellation::ReadWrite;
return downcast<BooleanConstraint>(constraint).fitnessDistance(echoCancellationReadWrite);
break;
}
case MediaConstraintType::DeviceId: {
ASSERT(constraint.isString());
if (!capabilities.supportsDeviceId())
return 0;
return downcast<StringConstraint>(constraint).fitnessDistance(m_id);
break;
}
case MediaConstraintType::GroupId: {
ASSERT(constraint.isString());
if (!capabilities.supportsDeviceId())
return 0;
return downcast<StringConstraint>(constraint).fitnessDistance(settings().groupId());
break;
}
case MediaConstraintType::Unknown:
break;
}
return 0;
}
template <typename ValueType>
static void applyNumericConstraint(const NumericConstraint<ValueType>& constraint, ValueType current, ValueType capabilityMin, ValueType capabilityMax, RealtimeMediaSource* source, void (RealtimeMediaSource::*applier)(ValueType))
{
ValueType value = constraint.valueForCapabilityRange(current, capabilityMin, capabilityMax);
if (value != current)
(source->*applier)(value);
}
void RealtimeMediaSource::applySizeAndFrameRate(std::optional<int> width, std::optional<int> height, std::optional<double> frameRate)
{
if (width)
setWidth(width.value());
if (height)
setHeight(height.value());
if (frameRate)
setFrameRate(frameRate.value());
}
void RealtimeMediaSource::applyConstraint(const MediaConstraint& constraint)
{
RealtimeMediaSourceCapabilities& capabilities = *this->capabilities();
switch (constraint.constraintType()) {
case MediaConstraintType::Width: {
ASSERT(constraint.isInt());
if (!capabilities.supportsWidth())
return;
auto range = capabilities.width();
applyNumericConstraint(downcast<IntConstraint>(constraint), size().width(), range.rangeMin().asInt, range.rangeMax().asInt, this, &RealtimeMediaSource::setWidth);
break;
}
case MediaConstraintType::Height: {
ASSERT(constraint.isInt());
if (!capabilities.supportsHeight())
return;
auto range = capabilities.height();
applyNumericConstraint(downcast<IntConstraint>(constraint), size().height(), range.rangeMin().asInt, range.rangeMax().asInt, this, &RealtimeMediaSource::setHeight);
break;
}
case MediaConstraintType::FrameRate: {
ASSERT(constraint.isDouble());
if (!capabilities.supportsFrameRate())
return;
auto range = capabilities.frameRate();
applyNumericConstraint(downcast<DoubleConstraint>(constraint), frameRate(), range.rangeMin().asDouble, range.rangeMax().asDouble, this, &RealtimeMediaSource::setFrameRate);
break;
}
case MediaConstraintType::AspectRatio: {
ASSERT(constraint.isDouble());
if (!capabilities.supportsAspectRatio())
return;
auto range = capabilities.aspectRatio();
applyNumericConstraint(downcast<DoubleConstraint>(constraint), aspectRatio(), range.rangeMin().asDouble, range.rangeMax().asDouble, this, &RealtimeMediaSource::setAspectRatio);
break;
}
case MediaConstraintType::Volume: {
ASSERT(constraint.isDouble());
if (!capabilities.supportsVolume())
return;
auto range = capabilities.volume();
applyNumericConstraint(downcast<DoubleConstraint>(constraint), volume(), range.rangeMin().asDouble, range.rangeMax().asDouble, this, &RealtimeMediaSource::setVolume);
break;
}
case MediaConstraintType::SampleRate: {
ASSERT(constraint.isInt());
if (!capabilities.supportsSampleRate())
return;
auto range = capabilities.sampleRate();
applyNumericConstraint(downcast<IntConstraint>(constraint), sampleRate(), range.rangeMin().asInt, range.rangeMax().asInt, this, &RealtimeMediaSource::setSampleRate);
break;
}
case MediaConstraintType::SampleSize: {
ASSERT(constraint.isInt());
if (!capabilities.supportsSampleSize())
return;
auto range = capabilities.sampleSize();
applyNumericConstraint(downcast<IntConstraint>(constraint), sampleSize(), range.rangeMin().asInt, range.rangeMax().asInt, this, &RealtimeMediaSource::setSampleSize);
break;
}
case MediaConstraintType::EchoCancellation: {
ASSERT(constraint.isBoolean());
if (!capabilities.supportsEchoCancellation())
return;
bool setting;
const BooleanConstraint& boolConstraint = downcast<BooleanConstraint>(constraint);
if (boolConstraint.getExact(setting) || boolConstraint.getIdeal(setting))
setEchoCancellation(setting);
break;
}
case MediaConstraintType::FacingMode: {
ASSERT(constraint.isString());
if (!capabilities.supportsFacingMode())
return;
auto& supportedModes = capabilities.facingMode();
auto filter = [supportedModes](const String& modeString) {
auto mode = RealtimeMediaSourceSettings::videoFacingModeEnum(modeString);
for (auto& supportedMode : supportedModes) {
if (mode == supportedMode)
return true;
}
return false;
};
auto modeString = downcast<StringConstraint>(constraint).find(filter);
if (!modeString.isEmpty())
setFacingMode(RealtimeMediaSourceSettings::videoFacingModeEnum(modeString));
break;
}
case MediaConstraintType::DeviceId:
case MediaConstraintType::GroupId:
ASSERT(constraint.isString());
break;
case MediaConstraintType::Unknown:
break;
}
}
bool RealtimeMediaSource::selectSettings(const MediaConstraints& constraints, FlattenedConstraint& candidates, String& failedConstraint)
{
failedConstraint = emptyString();
if (!supportsSizeAndFrameRate(constraints.mandatoryConstraints().width(), constraints.mandatoryConstraints().height(), constraints.mandatoryConstraints().frameRate(), failedConstraint))
return false;
constraints.mandatoryConstraints().filter([&](const MediaConstraint& constraint) {
if (constraint.constraintType() == MediaConstraintType::Width || constraint.constraintType() == MediaConstraintType::Height || constraint.constraintType() == MediaConstraintType::FrameRate) {
candidates.set(constraint);
return false;
}
if (std::isinf(fitnessDistance(constraint))) {
failedConstraint = constraint.name();
return true;
}
candidates.set(constraint);
return false;
});
if (!failedConstraint.isEmpty())
return false;
if (candidates.isEmpty())
return true;
Vector<std::pair<double, MediaTrackConstraintSetMap>> supportedConstraints;
double minimumDistance = std::numeric_limits<double>::infinity();
for (const auto& advancedConstraint : constraints.advancedConstraints()) {
double constraintDistance = 0;
bool supported = false;
advancedConstraint.forEach([&](const MediaConstraint& constraint) {
double distance = fitnessDistance(constraint);
constraintDistance += distance;
if (!std::isinf(distance))
supported = true;
});
if (constraintDistance < minimumDistance)
minimumDistance = constraintDistance;
if (supported)
supportedConstraints.append({constraintDistance, advancedConstraint});
}
if (!std::isinf(minimumDistance)) {
supportedConstraints.removeAllMatching([&](std::pair<double, MediaTrackConstraintSetMap> pair) -> bool {
return pair.first > minimumDistance;
});
if (!supportedConstraints.isEmpty()) {
auto& advancedConstraint = supportedConstraints[0].second;
advancedConstraint.forEach([&](const MediaConstraint& constraint) {
candidates.merge(constraint);
});
}
}
return true;
}
bool RealtimeMediaSource::supportsConstraints(const MediaConstraints& constraints, String& invalidConstraint)
{
ASSERT(constraints.isValid());
FlattenedConstraint candidates;
if (!selectSettings(constraints, candidates, invalidConstraint))
return false;
return true;
}
void RealtimeMediaSource::applyConstraints(const FlattenedConstraint& constraints)
{
if (constraints.isEmpty())
return;
beginConfiguration();
RealtimeMediaSourceCapabilities& capabilities = *this->capabilities();
std::optional<int> width;
if (const MediaConstraint* constraint = constraints.find(MediaConstraintType::Width)) {
ASSERT(constraint->isInt());
if (capabilities.supportsWidth()) {
auto range = capabilities.width();
width = downcast<IntConstraint>(*constraint).valueForCapabilityRange(size().width(), range.rangeMin().asInt, range.rangeMax().asInt);
}
}
std::optional<int> height;
if (const MediaConstraint* constraint = constraints.find(MediaConstraintType::Height)) {
ASSERT(constraint->isInt());
if (capabilities.supportsHeight()) {
auto range = capabilities.height();
height = downcast<IntConstraint>(*constraint).valueForCapabilityRange(size().height(), range.rangeMin().asInt, range.rangeMax().asInt);
}
}
std::optional<double> frameRate;
if (const MediaConstraint* constraint = constraints.find(MediaConstraintType::FrameRate)) {
ASSERT(constraint->isDouble());
if (capabilities.supportsFrameRate()) {
auto range = capabilities.frameRate();
frameRate = downcast<DoubleConstraint>(*constraint).valueForCapabilityRange(this->frameRate(), range.rangeMin().asDouble, range.rangeMax().asDouble);
}
}
if (width || height || frameRate)
applySizeAndFrameRate(WTFMove(width), WTFMove(height), WTFMove(frameRate));
for (auto& variant : constraints) {
if (variant.constraintType() == MediaConstraintType::Width || variant.constraintType() == MediaConstraintType::Height || variant.constraintType() == MediaConstraintType::FrameRate)
continue;
applyConstraint(variant);
}
commitConfiguration();
}
std::optional<std::pair<String, String>> RealtimeMediaSource::applyConstraints(const MediaConstraints& constraints)
{
ASSERT(constraints.isValid());
FlattenedConstraint candidates;
String failedConstraint;
if (!selectSettings(constraints, candidates, failedConstraint))
return { { failedConstraint, ASCIILiteral("Constraint not supported") } };
applyConstraints(candidates);
return std::nullopt;
}
void RealtimeMediaSource::applyConstraints(const MediaConstraints& constraints, SuccessHandler successHandler, FailureHandler failureHandler)
{
auto result = applyConstraints(constraints);
if (!result && successHandler)
successHandler();
else if (result && failureHandler)
failureHandler(result.value().first, result.value().second);
}
void RealtimeMediaSource::setWidth(int width)
{
if (width == m_size.width())
return;
int height = m_aspectRatio ? width / m_aspectRatio : m_size.height();
if (!applySize(IntSize(width, height)))
return;
m_size.setWidth(width);
if (m_aspectRatio)
m_size.setHeight(width / m_aspectRatio);
settingsDidChange();
}
void RealtimeMediaSource::setHeight(int height)
{
if (height == m_size.height())
return;
int width = m_aspectRatio ? height * m_aspectRatio : m_size.width();
if (!applySize(IntSize(width, height)))
return;
if (m_aspectRatio)
m_size.setWidth(width);
m_size.setHeight(height);
settingsDidChange();
}
void RealtimeMediaSource::setFrameRate(double rate)
{
if (m_frameRate == rate || !applyFrameRate(rate))
return;
m_frameRate = rate;
settingsDidChange();
}
void RealtimeMediaSource::setAspectRatio(double ratio)
{
if (m_aspectRatio == ratio || !applyAspectRatio(ratio))
return;
m_aspectRatio = ratio;
m_size.setHeight(m_size.width() / ratio);
settingsDidChange();
}
void RealtimeMediaSource::setFacingMode(RealtimeMediaSourceSettings::VideoFacingMode mode)
{
if (m_facingMode == mode || !applyFacingMode(mode))
return;
m_facingMode = mode;
settingsDidChange();
}
void RealtimeMediaSource::setVolume(double volume)
{
if (m_volume == volume || !applyVolume(volume))
return;
m_volume = volume;
settingsDidChange();
}
void RealtimeMediaSource::setSampleRate(int rate)
{
if (m_sampleRate == rate || !applySampleRate(rate))
return;
m_sampleRate = rate;
settingsDidChange();
}
void RealtimeMediaSource::setSampleSize(int size)
{
if (m_sampleSize == size || !applySampleSize(size))
return;
m_sampleSize = size;
settingsDidChange();
}
void RealtimeMediaSource::setEchoCancellation(bool echoCancellation)
{
if (m_echoCancellation == echoCancellation || !applyEchoCancellation(echoCancellation))
return;
m_echoCancellation = echoCancellation;
settingsDidChange();
}
void RealtimeMediaSource::scheduleDeferredTask(std::function<void()>&& function)
{
ASSERT(function);
callOnMainThread([weakThis = createWeakPtr(), function = WTFMove(function)] {
if (!weakThis)
return;
function();
});
}
}
#endif // ENABLE(MEDIA_STREAM)