AnotherFoxGuy/webrtc-audio-processing
1
0
Fork 0
Code Pull Requests Activity

Bump to WebRTC M131 release

Browse Source 
Ongoing fixes and improvements, transient suppressor is gone. Also,
dropping isac because it doesn't seem to be useful, and is just build
system deadweight now.

Upstream references:

  Version: 131.0.6778.200
  WebRTC: 79aff54b0fa9238ce3518dd9eaf9610cd6f22e82
  Chromium: 2a19506ad24af755f2a215a4c61f775393e0db42
This commit is contained in:
Arun Raghavan
2024-12-24 19:32:07 -05:00
parent 8bdb53d91c
commit b5c48b97f6
263 changed files with 4628 additions and 20416 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
webrtc/rtc_base/experiments/field_trial_parser.cc
View File

@ -60,7 +60,7 @@ void ParseFieldTrial(
while (!tail.empty()) {
size_t key_end = tail.find_first_of(",:");
absl::string_view key = tail.substr(0, key_end);
absl::optional<std::string> opt_value;
std::optional<std::string> opt_value;
if (key_end == absl::string_view::npos) {
tail = "";
} else if (tail[key_end] == ':') {
@ -112,17 +112,17 @@ void ParseFieldTrial(
}
template <>
absl::optional<bool> ParseTypedParameter<bool>(absl::string_view str) {
std::optional<bool> ParseTypedParameter<bool>(absl::string_view str) {
if (str == "true" || str == "1") {
return true;
} else if (str == "false" || str == "0") {
return false;
}
return absl::nullopt;
return std::nullopt;
}
template <>
absl::optional<double> ParseTypedParameter<double>(absl::string_view str) {
std::optional<double> ParseTypedParameter<double>(absl::string_view str) {
double value;
char unit[2]{0, 0};
if (sscanf(std::string(str).c_str(), "%lf%1s", &value, unit) >= 1) {
@ -130,56 +130,56 @@ absl::optional<double> ParseTypedParameter<double>(absl::string_view str) {
return value / 100;
return value;
} else {
return absl::nullopt;
return std::nullopt;
}
}
template <>
absl::optional<int> ParseTypedParameter<int>(absl::string_view str) {
std::optional<int> ParseTypedParameter<int>(absl::string_view str) {
int64_t value;
if (sscanf(std::string(str).c_str(), "%" SCNd64, &value) == 1) {
if (rtc::IsValueInRangeForNumericType<int, int64_t>(value)) {
return static_cast<int>(value);
}
}
return absl::nullopt;
return std::nullopt;
}
template <>
absl::optional<unsigned> ParseTypedParameter<unsigned>(absl::string_view str) {
std::optional<unsigned> ParseTypedParameter<unsigned>(absl::string_view str) {
int64_t value;
if (sscanf(std::string(str).c_str(), "%" SCNd64, &value) == 1) {
if (rtc::IsValueInRangeForNumericType<unsigned, int64_t>(value)) {
return static_cast<unsigned>(value);
}
}
return absl::nullopt;
return std::nullopt;
}
template <>
absl::optional<std::string> ParseTypedParameter<std::string>(
std::optional<std::string> ParseTypedParameter<std::string>(
absl::string_view str) {
return std::string(str);
}
template <>
absl::optional<absl::optional<bool>> ParseTypedParameter<absl::optional<bool>>(
std::optional<std::optional<bool>> ParseTypedParameter<std::optional<bool>>(
absl::string_view str) {
return ParseOptionalParameter<bool>(str);
}
template <>
absl::optional<absl::optional<int>> ParseTypedParameter<absl::optional<int>>(
std::optional<std::optional<int>> ParseTypedParameter<std::optional<int>>(
absl::string_view str) {
return ParseOptionalParameter<int>(str);
}
template <>
absl::optional<absl::optional<unsigned>>
ParseTypedParameter<absl::optional<unsigned>>(absl::string_view str) {
std::optional<std::optional<unsigned>>
ParseTypedParameter<std::optional<unsigned>>(absl::string_view str) {
return ParseOptionalParameter<unsigned>(str);
}
template <>
absl::optional<absl::optional<double>>
ParseTypedParameter<absl::optional<double>>(absl::string_view str) {
std::optional<std::optional<double>> ParseTypedParameter<std::optional<double>>(
absl::string_view str) {
return ParseOptionalParameter<double>(str);
}
@ -197,10 +197,10 @@ webrtc::FieldTrialFlag::operator bool() const {
return value_;
}
bool FieldTrialFlag::Parse(absl::optional<std::string> str_value) {
bool FieldTrialFlag::Parse(std::optional<std::string> str_value) {
// Only set the flag if there is no argument provided.
if (str_value) {
absl::optional<bool> opt_value = ParseTypedParameter<bool>(*str_value);
std::optional<bool> opt_value = ParseTypedParameter<bool>(*str_value);
if (!opt_value)
return false;
value_ = *opt_value;
@ -224,14 +224,14 @@ AbstractFieldTrialEnum::AbstractFieldTrialEnum(const AbstractFieldTrialEnum&) =
default;
AbstractFieldTrialEnum::~AbstractFieldTrialEnum() = default;
bool AbstractFieldTrialEnum::Parse(absl::optional<std::string> str_value) {
bool AbstractFieldTrialEnum::Parse(std::optional<std::string> str_value) {
if (str_value) {
auto it = enum_mapping_.find(*str_value);
if (it != enum_mapping_.end()) {
value_ = it->second;
return true;
}
absl::optional<int> value = ParseTypedParameter<int>(*str_value);
std::optional<int> value = ParseTypedParameter<int>(*str_value);
if (value.has_value() &&
(valid_values_.find(*value) != valid_values_.end())) {
value_ = *value;

71
webrtc/rtc_base/experiments/field_trial_parser.h
View File

@ -14,12 +14,12 @@
#include <initializer_list>
#include <map>
#include <optional>
#include <set>
#include <string>
#include <vector>
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
// Field trial parser functionality. Provides funcitonality to parse field trial
// argument strings in key:value format. Each parameter is described using
@ -51,7 +51,7 @@ class FieldTrialParameterInterface {
std::initializer_list<FieldTrialParameterInterface*> fields,
absl::string_view trial_string);
void MarkAsUsed() { used_ = true; }
virtual bool Parse(absl::optional<std::string> str_value) = 0;
virtual bool Parse(std::optional<std::string> str_value) = 0;
virtual void ParseDone() {}
@ -68,10 +68,10 @@ void ParseFieldTrial(
std::initializer_list<FieldTrialParameterInterface*> fields,
absl::string_view trial_string);
// Specialize this in code file for custom types. Should return absl::nullopt if
// Specialize this in code file for custom types. Should return std::nullopt if
// the given string cannot be properly parsed.
template <typename T>
absl::optional<T> ParseTypedParameter(absl::string_view);
std::optional<T> ParseTypedParameter(absl::string_view);
// This class uses the ParseTypedParameter function to implement a parameter
// implementation with an enforced default value.
@ -87,9 +87,9 @@ class FieldTrialParameter : public FieldTrialParameterInterface {
void SetForTest(T value) { value_ = value; }
protected:
bool Parse(absl::optional<std::string> str_value) override {
bool Parse(std::optional<std::string> str_value) override {
if (str_value) {
absl::optional<T> value = ParseTypedParameter<T>(*str_value);
std::optional<T> value = ParseTypedParameter<T>(*str_value);
if (value.has_value()) {
value_ = value.value();
return true;
@ -110,8 +110,8 @@ class FieldTrialConstrained : public FieldTrialParameterInterface {
public:
FieldTrialConstrained(absl::string_view key,
T default_value,
absl::optional<T> lower_limit,
absl::optional<T> upper_limit)
std::optional<T> lower_limit,
std::optional<T> upper_limit)
: FieldTrialParameterInterface(key),
value_(default_value),
lower_limit_(lower_limit),
@ -121,9 +121,9 @@ class FieldTrialConstrained : public FieldTrialParameterInterface {
const T* operator->() const { return &value_; }
protected:
bool Parse(absl::optional<std::string> str_value) override {
bool Parse(std::optional<std::string> str_value) override {
if (str_value) {
absl::optional<T> value = ParseTypedParameter<T>(*str_value);
std::optional<T> value = ParseTypedParameter<T>(*str_value);
if (value && (!lower_limit_ || *value >= *lower_limit_) &&
(!upper_limit_ || *value <= *upper_limit_)) {
value_ = *value;
@ -135,8 +135,8 @@ class FieldTrialConstrained : public FieldTrialParameterInterface {
private:
T value_;
absl::optional<T> lower_limit_;
absl::optional<T> upper_limit_;
std::optional<T> lower_limit_;
std::optional<T> upper_limit_;
};
class AbstractFieldTrialEnum : public FieldTrialParameterInterface {
@ -148,7 +148,7 @@ class AbstractFieldTrialEnum : public FieldTrialParameterInterface {
AbstractFieldTrialEnum(const AbstractFieldTrialEnum&);
protected:
bool Parse(absl::optional<std::string> str_value) override;
bool Parse(std::optional<std::string> str_value) override;
protected:
int value_;
@ -181,35 +181,35 @@ class FieldTrialEnum : public AbstractFieldTrialEnum {
};
// This class uses the ParseTypedParameter function to implement an optional
// parameter implementation that can default to absl::nullopt.
// parameter implementation that can default to std::nullopt.
template <typename T>
class FieldTrialOptional : public FieldTrialParameterInterface {
public:
explicit FieldTrialOptional(absl::string_view key)
: FieldTrialParameterInterface(key) {}
FieldTrialOptional(absl::string_view key, absl::optional<T> default_value)
FieldTrialOptional(absl::string_view key, std::optional<T> default_value)
: FieldTrialParameterInterface(key), value_(default_value) {}
absl::optional<T> GetOptional() const { return value_; }
std::optional<T> GetOptional() const { return value_; }
const T& Value() const { return value_.value(); }
const T& operator*() const { return value_.value(); }
const T* operator->() const { return &value_.value(); }
explicit operator bool() const { return value_.has_value(); }
protected:
bool Parse(absl::optional<std::string> str_value) override {
bool Parse(std::optional<std::string> str_value) override {
if (str_value) {
absl::optional<T> value = ParseTypedParameter<T>(*str_value);
std::optional<T> value = ParseTypedParameter<T>(*str_value);
if (!value.has_value())
return false;
value_ = value.value();
} else {
value_ = absl::nullopt;
value_ = std::nullopt;
}
return true;
}
private:
absl::optional<T> value_;
std::optional<T> value_;
};
// Equivalent to a FieldTrialParameter<bool> in the case that both key and value
@ -223,47 +223,46 @@ class FieldTrialFlag : public FieldTrialParameterInterface {
explicit operator bool() const;
protected:
bool Parse(absl::optional<std::string> str_value) override;
bool Parse(std::optional<std::string> str_value) override;
private:
bool value_;
};
template <typename T>
absl::optional<absl::optional<T>> ParseOptionalParameter(
absl::string_view str) {
std::optional<std::optional<T>> ParseOptionalParameter(absl::string_view str) {
if (str.empty())
return absl::optional<T>();
return std::optional<T>();
auto parsed = ParseTypedParameter<T>(str);
if (parsed.has_value())
return parsed;
return absl::nullopt;
return std::nullopt;
}
template <>
absl::optional<bool> ParseTypedParameter<bool>(absl::string_view str);
std::optional<bool> ParseTypedParameter<bool>(absl::string_view str);
template <>
absl::optional<double> ParseTypedParameter<double>(absl::string_view str);
std::optional<double> ParseTypedParameter<double>(absl::string_view str);
template <>
absl::optional<int> ParseTypedParameter<int>(absl::string_view str);
std::optional<int> ParseTypedParameter<int>(absl::string_view str);
template <>
absl::optional<unsigned> ParseTypedParameter<unsigned>(absl::string_view str);
std::optional<unsigned> ParseTypedParameter<unsigned>(absl::string_view str);
template <>
absl::optional<std::string> ParseTypedParameter<std::string>(
std::optional<std::string> ParseTypedParameter<std::string>(
absl::string_view str);
template <>
absl::optional<absl::optional<bool>> ParseTypedParameter<absl::optional<bool>>(
std::optional<std::optional<bool>> ParseTypedParameter<std::optional<bool>>(
absl::string_view str);
template <>
absl::optional<absl::optional<int>> ParseTypedParameter<absl::optional<int>>(
std::optional<std::optional<int>> ParseTypedParameter<std::optional<int>>(
absl::string_view str);
template <>
absl::optional<absl::optional<unsigned>>
ParseTypedParameter<absl::optional<unsigned>>(absl::string_view str);
std::optional<std::optional<unsigned>>
ParseTypedParameter<std::optional<unsigned>>(absl::string_view str);
template <>
absl::optional<absl::optional<double>>
ParseTypedParameter<absl::optional<double>>(absl::string_view str);
std::optional<std::optional<double>> ParseTypedParameter<std::optional<double>>(
absl::string_view str);
// Accepts true, false, else parsed with sscanf %i, true if != 0.
extern template class FieldTrialParameter<bool>;