blob: ba028f4dbdfd19eb12a6c7fec6ca044869651409 [file] [log] [blame]
/*
* Copyright (C) 2012 Google Inc. All rights reserved.
* Copyright (C) 2016-2020 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name of Google Inc. nor the names of its contributors
* may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#if ENABLE(MEDIA_STREAM)
#include "RealtimeMediaSourceSupportedConstraints.h"
#include <cstdlib>
#include <wtf/EnumTraits.h>
#include <wtf/Function.h>
#include <wtf/Vector.h>
namespace WebCore {
class MediaConstraint {
public:
enum class DataType : uint8_t { None, Integer, Double, Boolean, String };
bool isInt() const { return m_dataType == DataType::Integer; }
bool isDouble() const { return m_dataType == DataType::Double; }
bool isBoolean() const { return m_dataType == DataType::Boolean; }
bool isString() const { return m_dataType == DataType::String; }
DataType dataType() const { return m_dataType; }
MediaConstraintType constraintType() const { return m_constraintType; }
const String& name() const { return m_name; }
template <class Encoder> void encode(Encoder& encoder) const
{
encoder << m_constraintType;
encoder << m_name;
encoder << m_dataType;
}
template <class Decoder> static WARN_UNUSED_RETURN bool decode(Decoder& decoder, MediaConstraint& constraint)
{
if (!decoder.decode(constraint.m_constraintType))
return false;
if (!decoder.decode(constraint.m_name))
return false;
if (!decoder.decode(constraint.m_dataType))
return false;
return true;
}
void log() const;
protected:
MediaConstraint(const String& name, MediaConstraintType constraintType, DataType dataType)
: m_name(name)
, m_constraintType(constraintType)
, m_dataType(dataType)
{
}
MediaConstraint() = default;
~MediaConstraint() = default;
private:
String m_name;
MediaConstraintType m_constraintType { MediaConstraintType::Unknown };
DataType m_dataType { DataType::None };
};
template<class ValueType>
class NumericConstraint : public MediaConstraint {
public:
void setMin(ValueType value) { m_min = value; }
void setMax(ValueType value) { m_max = value; }
void setExact(ValueType value) { m_exact = value; }
void setIdeal(ValueType value) { m_ideal = value; }
bool getMin(ValueType& min) const
{
if (!m_min)
return false;
min = m_min.value();
return true;
}
bool getMax(ValueType& max) const
{
if (!m_max)
return false;
max = m_max.value();
return true;
}
bool getExact(ValueType& exact) const
{
if (!m_exact)
return false;
exact = m_exact.value();
return true;
}
bool getIdeal(ValueType& ideal) const
{
if (!m_ideal)
return false;
ideal = m_ideal.value();
return true;
}
bool nearlyEqual(double a, double b) const
{
// Don't require strict equality when comparing constraints, or many floating point constraint values,
// e.g. "aspectRatio: 1.333", will never match.
const double epsilon = 0.00001;
return std::abs(a - b) <= epsilon;
}
double fitnessDistance(ValueType rangeMin, ValueType rangeMax) const
{
// https://w3c.github.io/mediacapture-main/#dfn-applyconstraints
// 1. If the constraint is not supported by the browser, the fitness distance is 0.
if (isEmpty())
return 0;
// 2. If the constraint is required ('min', 'max', or 'exact'), and the settings
// dictionary's value for the constraint does not satisfy the constraint, the
// fitness distance is positive infinity.
bool valid = validForRange(rangeMin, rangeMax);
if (m_exact) {
if (valid && m_min && m_exact.value() < m_min.value())
valid = false;
if (valid && m_max && m_exact.value() > m_max.value())
valid = false;
if (!valid)
return std::numeric_limits<double>::infinity();
}
if (m_min) {
if (valid && m_max && m_min.value() > m_max.value())
valid = false;
if (!valid)
return std::numeric_limits<double>::infinity();
}
if (m_max) {
if (valid && m_min && m_max.value() < m_min.value())
valid = false;
if (!valid)
return std::numeric_limits<double>::infinity();
}
// 3. If no ideal value is specified, the fitness distance is 0.
if (!m_ideal)
return 0;
// 4. For all positive numeric non-required constraints (such as height, width, frameRate,
// aspectRatio, sampleRate and sampleSize), the fitness distance is the result of the formula
//
// (actual == ideal) ? 0 : |actual - ideal| / max(|actual|,|ideal|)
ValueType ideal = m_ideal.value();
if (ideal >= rangeMin && ideal <= rangeMax)
return 0;
ideal = ideal > std::max(rangeMin, rangeMax) ? rangeMax : rangeMin;
return static_cast<double>(std::abs(ideal - m_ideal.value())) / std::max(std::abs(ideal), std::abs(m_ideal.value()));
}
double fitnessDistance(const Vector<ValueType>& discreteCapabilityValues) const
{
double minDistance = std::numeric_limits<double>::infinity();
for (auto& value : discreteCapabilityValues) {
auto distance = fitnessDistance(value, value);
if (distance < minDistance)
minDistance = distance;
}
return minDistance;
}
bool validForRange(ValueType rangeMin, ValueType rangeMax) const
{
if (isEmpty())
return false;
if (m_exact) {
const ValueType exact = m_exact.value();
if (exact < rangeMin && !nearlyEqual(exact, rangeMin))
return false;
if (exact > rangeMax && !nearlyEqual(exact, rangeMax))
return false;
}
if (m_min) {
const ValueType constraintMin = m_min.value();
if (constraintMin > rangeMax && !nearlyEqual(constraintMin, rangeMax))
return false;
}
if (m_max) {
const ValueType constraintMax = m_max.value();
if (constraintMax < rangeMin && !nearlyEqual(constraintMax, rangeMin))
return false;
}
return true;
}
ValueType find(const Function<bool(ValueType)>& function) const
{
if (m_min && function(m_min.value()))
return m_min.value();
if (m_max && function(m_max.value()))
return m_max.value();
if (m_exact && function(m_exact.value()))
return m_exact.value();
if (m_ideal && function(m_ideal.value()))
return m_ideal.value();
return 0;
}
ValueType valueForCapabilityRange(ValueType current, ValueType capabilityMin, ValueType capabilityMax) const
{
ValueType value { 0 };
ValueType min { capabilityMin };
ValueType max { capabilityMax };
if (m_exact) {
ASSERT(validForRange(capabilityMin, capabilityMax));
return m_exact.value();
}
if (m_min) {
value = m_min.value();
ASSERT(validForRange(value, capabilityMax));
if (value > min)
min = value;
if (value < min)
value = min;
// If there is no ideal, don't change if minimum is smaller than current.
if (!m_ideal && value < current)
value = current;
}
if (m_max) {
value = m_max.value();
ASSERT(validForRange(capabilityMin, value));
if (value < max)
max = value;
if (value > max)
value = max;
}
if (m_ideal)
value = std::max(min, std::min(max, m_ideal.value()));
return value;
}
std::optional<ValueType> valueForDiscreteCapabilityValues(ValueType current, const Vector<ValueType>& discreteCapabilityValues) const
{
std::optional<ValueType> value;
std::optional<ValueType> min;
std::optional<ValueType> max;
if (m_exact) {
ASSERT(discreteCapabilityValues.contains(m_exact.value()));
return m_exact.value();
}
if (m_min) {
auto index = discreteCapabilityValues.findMatching([&](ValueType value) { return m_min.value() >= value; });
if (index != notFound) {
min = value = discreteCapabilityValues[index];
// If there is no ideal, don't change if minimum is smaller than current.
if (!m_ideal && *value < current)
value = current;
}
}
if (m_max && m_max.value() >= discreteCapabilityValues[0]) {
for (auto& discreteValue : discreteCapabilityValues) {
if (m_max.value() <= discreteValue)
max = value = discreteValue;
}
}
if (m_ideal && discreteCapabilityValues.contains(m_ideal.value())) {
value = m_ideal.value();
if (max)
value = std::min(max.value(), *value);
if (min)
value = std::max(min.value(), *value);
}
return value;
}
bool isEmpty() const { return !m_min && !m_max && !m_exact && !m_ideal; }
bool isMandatory() const { return m_min || m_max || m_exact; }
template <class Encoder> void encode(Encoder& encoder) const
{
MediaConstraint::encode(encoder);
encoder << m_min;
encoder << m_max;
encoder << m_exact;
encoder << m_ideal;
}
template <class Decoder> static WARN_UNUSED_RETURN bool decode(Decoder& decoder, NumericConstraint& constraint)
{
if (!MediaConstraint::decode(decoder, constraint))
return false;
if (!decoder.decode(constraint.m_min))
return false;
if (!decoder.decode(constraint.m_max))
return false;
if (!decoder.decode(constraint.m_exact))
return false;
if (!decoder.decode(constraint.m_ideal))
return false;
return true;
}
protected:
NumericConstraint(const String& name, MediaConstraintType type, DataType dataType)
: MediaConstraint(name, type, dataType)
{
}
NumericConstraint() = default;
void innerMerge(const NumericConstraint& other)
{
if (other.isEmpty())
return;
ValueType value;
if (other.getExact(value))
m_exact = value;
if (other.getMin(value))
m_min = value;
if (other.getMax(value))
m_max = value;
// https://w3c.github.io/mediacapture-main/#constrainable-interface
// When processing advanced constraints:
// ... the User Agent must attempt to apply, individually, any 'ideal' constraints or
// a constraint given as a bare value for the property. Of these properties, it must
// satisfy the largest number that it can, in any order.
if (other.getIdeal(value)) {
if (!m_ideal || value > m_ideal.value())
m_ideal = value;
}
}
std::optional<ValueType> m_min;
std::optional<ValueType> m_max;
std::optional<ValueType> m_exact;
std::optional<ValueType> m_ideal;
};
class IntConstraint final : public NumericConstraint<int> {
public:
IntConstraint(const String& name, MediaConstraintType type)
: NumericConstraint<int>(name, type, DataType::Integer)
{
}
IntConstraint() = default;
void merge(const MediaConstraint& other)
{
ASSERT(other.isInt());
NumericConstraint::innerMerge(downcast<const IntConstraint>(other));
}
void logAsInt() const;
};
class DoubleConstraint final : public NumericConstraint<double> {
public:
DoubleConstraint(const String& name, MediaConstraintType type)
: NumericConstraint<double>(name, type, DataType::Double)
{
}
DoubleConstraint() = default;
void merge(const MediaConstraint& other)
{
ASSERT(other.isDouble());
NumericConstraint::innerMerge(downcast<DoubleConstraint>(other));
}
void logAsDouble() const;
};
class BooleanConstraint final : public MediaConstraint {
public:
BooleanConstraint(const String& name, MediaConstraintType type)
: MediaConstraint(name, type, DataType::Boolean)
{
}
BooleanConstraint() = default;
void setExact(bool value) { m_exact = value; }
void setIdeal(bool value) { m_ideal = value; }
bool getExact(bool& exact) const
{
if (!m_exact)
return false;
exact = m_exact.value();
return true;
}
bool getIdeal(bool& ideal) const
{
if (!m_ideal)
return false;
ideal = m_ideal.value();
return true;
}
double fitnessDistance(bool value) const
{
// https://w3c.github.io/mediacapture-main/#dfn-applyconstraints
// 1. If the constraint is not supported by the browser, the fitness distance is 0.
if (isEmpty())
return 0;
// 2. If the constraint is required ('min', 'max', or 'exact'), and the settings
// dictionary's value for the constraint does not satisfy the constraint, the
// fitness distance is positive infinity.
if (m_exact && value != m_exact.value())
return std::numeric_limits<double>::infinity();
// 3. If no ideal value is specified, the fitness distance is 0.
if (!m_ideal || m_ideal.value() == value)
return 0;
// 5. For all string and enum non-required constraints (deviceId, groupId, facingMode,
// echoCancellation), the fitness distance is the result of the formula
// (actual == ideal) ? 0 : 1
return 1;
}
void merge(const MediaConstraint& other)
{
ASSERT(other.isBoolean());
const BooleanConstraint& typedOther = downcast<BooleanConstraint>(other);
if (typedOther.isEmpty())
return;
bool value;
if (typedOther.getExact(value))
m_exact = value;
if (typedOther.getIdeal(value)) {
if (!m_ideal || (value && !m_ideal.value()))
m_ideal = value;
}
}
bool isEmpty() const { return !m_exact && !m_ideal; };
bool isMandatory() const { return bool(m_exact); }
template <class Encoder> void encode(Encoder& encoder) const
{
MediaConstraint::encode(encoder);
encoder << m_exact;
encoder << m_ideal;
}
template <class Decoder> static WARN_UNUSED_RETURN bool decode(Decoder& decoder, BooleanConstraint& constraint)
{
if (!MediaConstraint::decode(decoder, constraint))
return false;
if (!decoder.decode(constraint.m_exact))
return false;
if (!decoder.decode(constraint.m_ideal))
return false;
return true;
}
void logAsBoolean() const;
private:
std::optional<bool> m_exact;
std::optional<bool> m_ideal;
};
class StringConstraint : public MediaConstraint {
public:
StringConstraint(const String& name, MediaConstraintType type)
: MediaConstraint(name, type, DataType::String)
{
}
StringConstraint() = default;
void setExact(const String& value)
{
m_exact.clear();
m_exact.append(value);
}
void appendExact(const String& value)
{
m_exact.append(value);
}
void setIdeal(const String& value)
{
m_ideal.clear();
m_ideal.append(value);
}
void appendIdeal(const String& value)
{
m_ideal.append(value);
}
bool getExact(Vector<String>& exact) const
{
if (!m_exact.isEmpty())
return false;
exact = m_exact;
return true;
}
bool getIdeal(Vector<String>& ideal) const
{
if (!m_ideal.isEmpty())
return false;
ideal = m_ideal;
return true;
}
double fitnessDistance(const String&) const;
double fitnessDistance(const Vector<String>&) const;
const String& find(const Function<bool(const String&)>&) const;
bool isEmpty() const { return m_exact.isEmpty() && m_ideal.isEmpty(); }
bool isMandatory() const { return !m_exact.isEmpty(); }
WEBCORE_EXPORT void merge(const MediaConstraint&);
template <class Encoder> void encode(Encoder& encoder) const
{
MediaConstraint::encode(encoder);
encoder << m_exact;
encoder << m_ideal;
}
template <class Decoder> static WARN_UNUSED_RETURN bool decode(Decoder& decoder, StringConstraint& constraint)
{
if (!MediaConstraint::decode(decoder, constraint))
return false;
if (!decoder.decode(constraint.m_exact))
return false;
if (!decoder.decode(constraint.m_ideal))
return false;
return true;
}
void removeEmptyStringConstraint()
{
m_exact.removeAllMatching([](auto& constraint) {
return constraint.isEmpty();
});
m_ideal.removeAllMatching([](auto& constraint) {
return constraint.isEmpty();
});
}
private:
Vector<String> m_exact;
Vector<String> m_ideal;
};
class UnknownConstraint final : public MediaConstraint {
public:
UnknownConstraint(const String& name, MediaConstraintType type)
: MediaConstraint(name, type, DataType::None)
{
}
private:
bool isEmpty() const { return true; }
bool isMandatory() const { return false; }
void merge(const MediaConstraint&) { }
};
class MediaTrackConstraintSetMap {
public:
WEBCORE_EXPORT void forEach(Function<void(const MediaConstraint&)>&&) const;
void filter(const Function<bool(const MediaConstraint&)>&) const;
bool isEmpty() const;
WEBCORE_EXPORT size_t size() const;
WEBCORE_EXPORT void set(MediaConstraintType, std::optional<IntConstraint>&&);
WEBCORE_EXPORT void set(MediaConstraintType, std::optional<DoubleConstraint>&&);
WEBCORE_EXPORT void set(MediaConstraintType, std::optional<BooleanConstraint>&&);
WEBCORE_EXPORT void set(MediaConstraintType, std::optional<StringConstraint>&&);
std::optional<IntConstraint> width() const { return m_width; }
std::optional<IntConstraint> height() const { return m_height; }
std::optional<IntConstraint> sampleRate() const { return m_sampleRate; }
std::optional<IntConstraint> sampleSize() const { return m_sampleSize; }
std::optional<DoubleConstraint> aspectRatio() const { return m_aspectRatio; }
std::optional<DoubleConstraint> frameRate() const { return m_frameRate; }
std::optional<DoubleConstraint> volume() const { return m_volume; }
std::optional<BooleanConstraint> echoCancellation() const { return m_echoCancellation; }
std::optional<BooleanConstraint> displaySurface() const { return m_displaySurface; }
std::optional<BooleanConstraint> logicalSurface() const { return m_logicalSurface; }
std::optional<StringConstraint> facingMode() const { return m_facingMode; }
std::optional<StringConstraint> deviceId() const { return m_deviceId; }
std::optional<StringConstraint> groupId() const { return m_groupId; }
template <class Encoder> void encode(Encoder& encoder) const
{
encoder << m_width;
encoder << m_height;
encoder << m_sampleRate;
encoder << m_sampleSize;
encoder << m_aspectRatio;
encoder << m_frameRate;
encoder << m_volume;
encoder << m_echoCancellation;
encoder << m_displaySurface;
encoder << m_logicalSurface;
encoder << m_facingMode;
encoder << m_deviceId;
encoder << m_groupId;
}
template <class Decoder> static std::optional<MediaTrackConstraintSetMap> decode(Decoder& decoder)
{
MediaTrackConstraintSetMap map;
if (!decoder.decode(map.m_width))
return std::nullopt;
if (!decoder.decode(map.m_height))
return std::nullopt;
if (!decoder.decode(map.m_sampleRate))
return std::nullopt;
if (!decoder.decode(map.m_sampleSize))
return std::nullopt;
if (!decoder.decode(map.m_aspectRatio))
return std::nullopt;
if (!decoder.decode(map.m_frameRate))
return std::nullopt;
if (!decoder.decode(map.m_volume))
return std::nullopt;
if (!decoder.decode(map.m_echoCancellation))
return std::nullopt;
if (!decoder.decode(map.m_displaySurface))
return std::nullopt;
if (!decoder.decode(map.m_logicalSurface))
return std::nullopt;
if (!decoder.decode(map.m_facingMode))
return std::nullopt;
if (!decoder.decode(map.m_deviceId))
return std::nullopt;
if (!decoder.decode(map.m_groupId))
return std::nullopt;
return map;
}
private:
std::optional<IntConstraint> m_width;
std::optional<IntConstraint> m_height;
std::optional<IntConstraint> m_sampleRate;
std::optional<IntConstraint> m_sampleSize;
std::optional<DoubleConstraint> m_aspectRatio;
std::optional<DoubleConstraint> m_frameRate;
std::optional<DoubleConstraint> m_volume;
std::optional<BooleanConstraint> m_echoCancellation;
std::optional<BooleanConstraint> m_displaySurface;
std::optional<BooleanConstraint> m_logicalSurface;
std::optional<StringConstraint> m_facingMode;
std::optional<StringConstraint> m_deviceId;
std::optional<StringConstraint> m_groupId;
};
class FlattenedConstraint {
public:
void set(const MediaConstraint&);
void merge(const MediaConstraint&);
void append(const MediaConstraint&);
const MediaConstraint* find(MediaConstraintType) const;
bool isEmpty() const { return m_variants.isEmpty(); }
class iterator {
public:
iterator(const FlattenedConstraint* constraint, size_t index)
: m_constraint(constraint)
, m_index(index)
#ifndef NDEBUG
, m_generation(constraint->m_generation)
#endif
{
}
MediaConstraint& operator*() const
{
return m_constraint->m_variants.at(m_index).constraint();
}
iterator& operator++()
{
#ifndef NDEBUG
ASSERT(m_generation == m_constraint->m_generation);
#endif
m_index++;
return *this;
}
bool operator==(const iterator& other) const { return m_index == other.m_index; }
bool operator!=(const iterator& other) const { return !(*this == other); }
private:
const FlattenedConstraint* m_constraint { nullptr };
size_t m_index { 0 };
#ifndef NDEBUG
int m_generation { 0 };
#endif
};
const iterator begin() const { return iterator(this, 0); }
const iterator end() const { return iterator(this, m_variants.size()); }
private:
class ConstraintHolder {
public:
static ConstraintHolder create(const MediaConstraint& value) { return ConstraintHolder(value); }
~ConstraintHolder()
{
if (m_value.asRaw) {
switch (dataType()) {
case MediaConstraint::DataType::Integer:
delete m_value.asInteger;
break;
case MediaConstraint::DataType::Double:
delete m_value.asDouble;
break;
case MediaConstraint::DataType::Boolean:
delete m_value.asBoolean;
break;
case MediaConstraint::DataType::String:
delete m_value.asString;
break;
case MediaConstraint::DataType::None:
ASSERT_NOT_REACHED();
break;
}
}
#ifndef NDEBUG
m_value.asRaw = reinterpret_cast<MediaConstraint*>(0xbbadbeef);
#endif
}
ConstraintHolder(ConstraintHolder&& other)
{
switch (other.dataType()) {
case MediaConstraint::DataType::Integer:
m_value.asInteger = std::exchange(other.m_value.asInteger, nullptr);
break;
case MediaConstraint::DataType::Double:
m_value.asDouble = std::exchange(other.m_value.asDouble, nullptr);
break;
case MediaConstraint::DataType::Boolean:
m_value.asBoolean = std::exchange(other.m_value.asBoolean, nullptr);
break;
case MediaConstraint::DataType::String:
m_value.asString = std::exchange(other.m_value.asString, nullptr);
break;
case MediaConstraint::DataType::None:
ASSERT_NOT_REACHED();
break;
}
}
MediaConstraint& constraint() const { return *m_value.asRaw; }
MediaConstraint::DataType dataType() const { return constraint().dataType(); }
MediaConstraintType constraintType() const { return constraint().constraintType(); }
private:
explicit ConstraintHolder(const MediaConstraint& value)
{
switch (value.dataType()) {
case MediaConstraint::DataType::Integer:
m_value.asInteger = new IntConstraint(downcast<const IntConstraint>(value));
break;
case MediaConstraint::DataType::Double:
m_value.asDouble = new DoubleConstraint(downcast<DoubleConstraint>(value));
break;
case MediaConstraint::DataType::Boolean:
m_value.asBoolean = new BooleanConstraint(downcast<BooleanConstraint>(value));
break;
case MediaConstraint::DataType::String:
m_value.asString = new StringConstraint(downcast<StringConstraint>(value));
break;
case MediaConstraint::DataType::None:
ASSERT_NOT_REACHED();
break;
}
}
union {
MediaConstraint* asRaw;
IntConstraint* asInteger;
DoubleConstraint* asDouble;
BooleanConstraint* asBoolean;
StringConstraint* asString;
} m_value;
};
Vector<ConstraintHolder> m_variants;
#ifndef NDEBUG
int m_generation { 0 };
#endif
};
struct MediaConstraints {
void setDefaultVideoConstraints();
bool isConstraintSet(const Function<bool(const MediaTrackConstraintSetMap&)>&);
MediaTrackConstraintSetMap mandatoryConstraints;
Vector<MediaTrackConstraintSetMap> advancedConstraints;
bool isValid { false };
};
} // namespace WebCore
#define SPECIALIZE_TYPE_TRAITS_MEDIACONSTRAINT(ConstraintType, predicate) \
SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::ConstraintType) \
static bool isType(const WebCore::MediaConstraint& constraint) { return constraint.predicate; } \
SPECIALIZE_TYPE_TRAITS_END()
SPECIALIZE_TYPE_TRAITS_MEDIACONSTRAINT(IntConstraint, isInt())
SPECIALIZE_TYPE_TRAITS_MEDIACONSTRAINT(DoubleConstraint, isDouble())
SPECIALIZE_TYPE_TRAITS_MEDIACONSTRAINT(StringConstraint, isString())
SPECIALIZE_TYPE_TRAITS_MEDIACONSTRAINT(BooleanConstraint, isBoolean())
namespace WTF {
template<> struct EnumTraits<WebCore::MediaConstraint::DataType> {
using values = EnumValues<
WebCore::MediaConstraint::DataType,
WebCore::MediaConstraint::DataType::None,
WebCore::MediaConstraint::DataType::Integer,
WebCore::MediaConstraint::DataType::Double,
WebCore::MediaConstraint::DataType::Boolean,
WebCore::MediaConstraint::DataType::String
>;
};
} // namespace WTF
#endif // ENABLE(MEDIA_STREAM)