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

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>;