admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

WebRTC-DeprecateGlobalFieldTrialString/Enabled/ - part 3/inf

Browse Source 
convert much of media/ (and the collateral)

Bug: webrtc:10335
Change-Id: I04489dfe9622efe7f89e04aba3be6b3f60e77c91
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/254520
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Commit-Queue: Jonas Oreland <jonaso@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#36177}
This commit is contained in:
Jonas Oreland 2022-03-10 15:21:28 +01:00 committed by WebRTC LUCI CQ
parent 041c08377a
commit 4476b82b35
17 changed files with 254 additions and 214 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
media/BUILD.gn
View File

@ -57,6 +57,7 @@ rtc_library("rtc_media_base") {
"../api:rtp_parameters",
"../api:scoped_refptr",
"../api:sequence_checker",
"../api:webrtc_key_value_config",
"../api/audio:audio_frame_processor",
"../api/audio_codecs:audio_codecs_api",
"../api/crypto:frame_decryptor_interface",
@ -64,7 +65,6 @@ rtc_library("rtc_media_base") {
"../api/crypto:options",
"../api/transport:datagram_transport_interface",
"../api/transport:stun_types",
"../api/transport:webrtc_key_value_config",
"../api/transport/rtp:rtp_source",
"../api/units:time_delta",
"../api/video:video_bitrate_allocation",
@ -453,6 +453,7 @@ rtc_library("rtc_data_sctp_transport_factory") {
]
deps = [
":rtc_data_sctp_transport_internal",
"../api:webrtc_key_value_config",
"../api/transport:sctp_transport_factory_interface",
"../rtc_base:threading",
"../rtc_base/experiments:field_trial_parser",
@ -641,6 +642,7 @@ if (rtc_include_tests) {
"../test:fake_video_codecs",
"../test:field_trial",
"../test:rtp_test_utils",
"../test:scoped_key_value_config",
"../test:test_main",
"../test:test_support",
"../test:video_test_common",

20
media/base/codec.cc
View File

@ -18,7 +18,6 @@
#include "rtc_base/logging.h"
#include "rtc_base/string_encode.h"
#include "rtc_base/strings/string_builder.h"
#include "system_wrappers/include/field_trial.h"
namespace cricket {
namespace {
@ -129,13 +128,14 @@ bool Codec::operator==(const Codec& c) const {
feedback_params == c.feedback_params;
}
bool Codec::Matches(const Codec& codec) const {
bool Codec::Matches(const Codec& codec,
const webrtc::WebRtcKeyValueConfig* field_trials) const {
// Match the codec id/name based on the typical static/dynamic name rules.
// Matching is case-insensitive.
// Legacy behaviour with killswitch.
if (webrtc::field_trial::IsDisabled(
"WebRTC-PayloadTypes-Lower-Dynamic-Range")) {
if (field_trials &&
field_trials->IsDisabled("WebRTC-PayloadTypes-Lower-Dynamic-Range")) {
const int kMaxStaticPayloadId = 95;
return (id <= kMaxStaticPayloadId || codec.id <= kMaxStaticPayloadId)
? (id == codec.id)
@ -238,7 +238,9 @@ bool AudioCodec::operator==(const AudioCodec& c) const {
return bitrate == c.bitrate && channels == c.channels && Codec::operator==(c);
}
bool AudioCodec::Matches(const AudioCodec& codec) const {
bool AudioCodec::Matches(
const AudioCodec& codec,
const webrtc::WebRtcKeyValueConfig* field_trials) const {
// If a nonzero clockrate is specified, it must match the actual clockrate.
// If a nonzero bitrate is specified, it must match the actual bitrate,
// unless the codec is VBR (0), where we just force the supplied value.
@ -248,7 +250,7 @@ bool AudioCodec::Matches(const AudioCodec& codec) const {
// omitted if the number of channels is one."
// Preference is ignored.
// TODO(juberti): Treat a zero clockrate as 8000Hz, the RTP default clockrate.
return Codec::Matches(codec) &&
return Codec::Matches(codec, field_trials) &&
((codec.clockrate == 0 /*&& clockrate == 8000*/) ||
clockrate == codec.clockrate) &&
(codec.bitrate == 0 || bitrate <= 0 || bitrate == codec.bitrate) &&
@ -324,8 +326,10 @@ bool VideoCodec::operator==(const VideoCodec& c) const {
return Codec::operator==(c) && packetization == c.packetization;
}
bool VideoCodec::Matches(const VideoCodec& other) const {
return Codec::Matches(other) &&
bool VideoCodec::Matches(
const VideoCodec& other,
const webrtc::WebRtcKeyValueConfig* field_trials) const {
return Codec::Matches(other, field_trials) &&
IsSameCodecSpecific(name, params, other.name, other.params);
}

13
media/base/codec.h
View File

@ -19,6 +19,7 @@
#include "absl/types/optional.h"
#include "api/rtp_parameters.h"
#include "api/video_codecs/sdp_video_format.h"
#include "api/webrtc_key_value_config.h"
#include "media/base/media_constants.h"
#include "rtc_base/system/rtc_export.h"
@ -75,7 +76,9 @@ struct RTC_EXPORT Codec {
virtual ~Codec();
// Indicates if this codec is compatible with the specified codec.
bool Matches(const Codec& codec) const;
bool Matches(
const Codec& codec,
const webrtc::WebRtcKeyValueConfig* field_trials = nullptr) const;
bool MatchesCapability(const webrtc::RtpCodecCapability& capability) const;
// Find the parameter for `name` and write the value to `out`.
@ -132,7 +135,9 @@ struct AudioCodec : public Codec {
~AudioCodec() override = default;
// Indicates if this codec is compatible with the specified codec.
bool Matches(const AudioCodec& codec) const;
bool Matches(
const AudioCodec& codec,
const webrtc::WebRtcKeyValueConfig* field_trials = nullptr) const;
std::string ToString() const;
@ -163,7 +168,9 @@ struct RTC_EXPORT VideoCodec : public Codec {
// Indicates if this video codec is the same as the other video codec, e.g. if
// they are both VP8 or VP9, or if they are both H264 with the same H264
// profile. H264 levels however are not compared.
bool Matches(const VideoCodec& codec) const;
bool Matches(
const VideoCodec& codec,
const webrtc::WebRtcKeyValueConfig* field_trials = nullptr) const;
std::string ToString() const;

2
media/base/media_engine.h
View File

@ -19,8 +19,8 @@
#include "api/audio_codecs/audio_encoder_factory.h"
#include "api/crypto/crypto_options.h"
#include "api/rtp_parameters.h"
#include "api/transport/webrtc_key_value_config.h"
#include "api/video/video_bitrate_allocator_factory.h"
#include "api/webrtc_key_value_config.h"
#include "call/audio_state.h"
#include "media/base/codec.h"
#include "media/base/media_channel.h"

6
media/base/test_utils.h
View File

@ -37,10 +37,12 @@ inline std::vector<T> MakeVector(const T a[], size_t s) {
// Checks whether `codecs` contains `codec`; checks using Codec::Matches().
template <class C>
bool ContainsMatchingCodec(const std::vector<C>& codecs, const C& codec) {
bool ContainsMatchingCodec(const std::vector<C>& codecs,
const C& codec,
const webrtc::WebRtcKeyValueConfig* field_trials) {
typename std::vector<C>::const_iterator it;
for (it = codecs.begin(); it != codecs.end(); ++it) {
if (it->Matches(codec)) {
if (it->Matches(codec, field_trials)) {
return true;
}
}

35
media/engine/webrtc_media_engine_unittest.cc
View File

@ -13,10 +13,9 @@
#include <memory>
#include <utility>
#include "api/transport/field_trial_based_config.h"
#include "media/engine/webrtc_media_engine_defaults.h"
#include "test/field_trial.h"
#include "test/gtest.h"
#include "test/scoped_key_value_config.h"
using webrtc::RtpExtension;
@ -129,7 +128,7 @@ TEST(WebRtcMediaEngineTest, ValidateRtpExtensionsChangeIdForUrl) {
TEST(WebRtcMediaEngineTest, FilterRtpExtensionsEmptyList) {
std::vector<RtpExtension> extensions;
webrtc::FieldTrialBasedConfig trials;
webrtc::test::ScopedKeyValueConfig trials;
std::vector<webrtc::RtpExtension> filtered =
FilterRtpExtensions(extensions, SupportedExtensions1, true, trials);
EXPECT_EQ(0u, filtered.size());
@ -137,7 +136,7 @@ TEST(WebRtcMediaEngineTest, FilterRtpExtensionsEmptyList) {
TEST(WebRtcMediaEngineTest, FilterRtpExtensionsIncludeOnlySupported) {
std::vector<RtpExtension> extensions = MakeUniqueExtensions();
webrtc::FieldTrialBasedConfig trials;
webrtc::test::ScopedKeyValueConfig trials;
std::vector<webrtc::RtpExtension> filtered =
FilterRtpExtensions(extensions, SupportedExtensions1, false, trials);
EXPECT_EQ(2u, filtered.size());
@ -147,7 +146,7 @@ TEST(WebRtcMediaEngineTest, FilterRtpExtensionsIncludeOnlySupported) {
TEST(WebRtcMediaEngineTest, FilterRtpExtensionsSortedByName1) {
std::vector<RtpExtension> extensions = MakeUniqueExtensions();
webrtc::FieldTrialBasedConfig trials;
webrtc::test::ScopedKeyValueConfig trials;
std::vector<webrtc::RtpExtension> filtered =
FilterRtpExtensions(extensions, SupportedExtensions2, false, trials);
EXPECT_EQ(12u, filtered.size());
@ -156,7 +155,7 @@ TEST(WebRtcMediaEngineTest, FilterRtpExtensionsSortedByName1) {
TEST(WebRtcMediaEngineTest, FilterRtpExtensionsSortedByName2) {
std::vector<RtpExtension> extensions = MakeUniqueExtensions();
webrtc::FieldTrialBasedConfig trials;
webrtc::test::ScopedKeyValueConfig trials;
std::vector<webrtc::RtpExtension> filtered =
FilterRtpExtensions(extensions, SupportedExtensions2, true, trials);
EXPECT_EQ(12u, filtered.size());
@ -165,7 +164,7 @@ TEST(WebRtcMediaEngineTest, FilterRtpExtensionsSortedByName2) {
TEST(WebRtcMediaEngineTest, FilterRtpExtensionsDontRemoveRedundant) {
std::vector<RtpExtension> extensions = MakeRedundantExtensions();
webrtc::FieldTrialBasedConfig trials;
webrtc::test::ScopedKeyValueConfig trials;
std::vector<webrtc::RtpExtension> filtered =
FilterRtpExtensions(extensions, SupportedExtensions2, false, trials);
EXPECT_EQ(12u, filtered.size());
@ -175,7 +174,7 @@ TEST(WebRtcMediaEngineTest, FilterRtpExtensionsDontRemoveRedundant) {
TEST(WebRtcMediaEngineTest, FilterRtpExtensionsRemoveRedundant) {
std::vector<RtpExtension> extensions = MakeRedundantExtensions();
webrtc::FieldTrialBasedConfig trials;
webrtc::test::ScopedKeyValueConfig trials;
std::vector<webrtc::RtpExtension> filtered =
FilterRtpExtensions(extensions, SupportedExtensions2, true, trials);
EXPECT_EQ(6u, filtered.size());
@ -189,7 +188,7 @@ TEST(WebRtcMediaEngineTest, FilterRtpExtensionsRemoveRedundantEncrypted1) {
extensions.push_back(webrtc::RtpExtension("b", 2, true));
extensions.push_back(webrtc::RtpExtension("c", 3));
extensions.push_back(webrtc::RtpExtension("b", 4));
webrtc::FieldTrialBasedConfig trials;
webrtc::test::ScopedKeyValueConfig trials;
std::vector<webrtc::RtpExtension> filtered =
FilterRtpExtensions(extensions, SupportedExtensions2, true, trials);
EXPECT_EQ(3u, filtered.size());
@ -206,7 +205,7 @@ TEST(WebRtcMediaEngineTest, FilterRtpExtensionsRemoveRedundantEncrypted2) {
extensions.push_back(webrtc::RtpExtension("b", 2));
extensions.push_back(webrtc::RtpExtension("c", 3));
extensions.push_back(webrtc::RtpExtension("b", 4));
webrtc::FieldTrialBasedConfig trials;
webrtc::test::ScopedKeyValueConfig trials;
std::vector<webrtc::RtpExtension> filtered =
FilterRtpExtensions(extensions, SupportedExtensions2, true, trials);
EXPECT_EQ(3u, filtered.size());
@ -218,9 +217,8 @@ TEST(WebRtcMediaEngineTest, FilterRtpExtensionsRemoveRedundantEncrypted2) {
}
TEST(WebRtcMediaEngineTest, FilterRtpExtensionsRemoveRedundantBwe1) {
webrtc::test::ScopedFieldTrials override_field_trials_(
webrtc::test::ScopedKeyValueConfig trials(
"WebRTC-FilterAbsSendTimeExtension/Enabled/");
webrtc::FieldTrialBasedConfig trials;
std::vector<RtpExtension> extensions;
extensions.push_back(
RtpExtension(RtpExtension::kTransportSequenceNumberUri, 3));
@ -245,7 +243,7 @@ TEST(WebRtcMediaEngineTest,
extensions.push_back(
RtpExtension(RtpExtension::kTransportSequenceNumberUri, 1));
extensions.push_back(RtpExtension(RtpExtension::kTimestampOffsetUri, 14));
webrtc::FieldTrialBasedConfig trials;
webrtc::test::ScopedKeyValueConfig trials;
std::vector<webrtc::RtpExtension> filtered =
FilterRtpExtensions(extensions, SupportedExtensions2, true, trials);
EXPECT_EQ(2u, filtered.size());
@ -254,9 +252,8 @@ TEST(WebRtcMediaEngineTest,
}
TEST(WebRtcMediaEngineTest, FilterRtpExtensionsRemoveRedundantBweEncrypted1) {
webrtc::test::ScopedFieldTrials override_field_trials_(
webrtc::test::ScopedKeyValueConfig trials(
"WebRTC-FilterAbsSendTimeExtension/Enabled/");
webrtc::FieldTrialBasedConfig trials;
std::vector<RtpExtension> extensions;
extensions.push_back(
RtpExtension(RtpExtension::kTransportSequenceNumberUri, 3));
@ -291,7 +288,7 @@ TEST(WebRtcMediaEngineTest,
extensions.push_back(
RtpExtension(RtpExtension::kTransportSequenceNumberUri, 2, true));
extensions.push_back(RtpExtension(RtpExtension::kTimestampOffsetUri, 14));
webrtc::FieldTrialBasedConfig trials;
webrtc::test::ScopedKeyValueConfig trials;
std::vector<webrtc::RtpExtension> filtered =
FilterRtpExtensions(extensions, SupportedExtensions2, true, trials);
EXPECT_EQ(3u, filtered.size());
@ -306,7 +303,7 @@ TEST(WebRtcMediaEngineTest, FilterRtpExtensionsRemoveRedundantBwe2) {
extensions.push_back(RtpExtension(RtpExtension::kTimestampOffsetUri, 1));
extensions.push_back(RtpExtension(RtpExtension::kAbsSendTimeUri, 14));
extensions.push_back(RtpExtension(RtpExtension::kTimestampOffsetUri, 7));
webrtc::FieldTrialBasedConfig trials;
webrtc::test::ScopedKeyValueConfig trials;
std::vector<webrtc::RtpExtension> filtered =
FilterRtpExtensions(extensions, SupportedExtensions2, true, trials);
EXPECT_EQ(1u, filtered.size());
@ -317,7 +314,7 @@ TEST(WebRtcMediaEngineTest, FilterRtpExtensionsRemoveRedundantBwe3) {
std::vector<RtpExtension> extensions;
extensions.push_back(RtpExtension(RtpExtension::kTimestampOffsetUri, 2));
extensions.push_back(RtpExtension(RtpExtension::kTimestampOffsetUri, 14));
webrtc::FieldTrialBasedConfig trials;
webrtc::test::ScopedKeyValueConfig trials;
std::vector<webrtc::RtpExtension> filtered =
FilterRtpExtensions(extensions, SupportedExtensions2, true, trials);
EXPECT_EQ(1u, filtered.size());
@ -327,7 +324,7 @@ TEST(WebRtcMediaEngineTest, FilterRtpExtensionsRemoveRedundantBwe3) {
TEST(WebRtcMediaEngineTest, Create) {
MediaEngineDependencies deps;
webrtc::SetMediaEngineDefaults(&deps);
webrtc::FieldTrialBasedConfig trials;
webrtc::test::ScopedKeyValueConfig trials;
deps.trials = &trials;
std::unique_ptr<MediaEngineInterface> engine =

85
media/engine/webrtc_video_engine_unittest.cc
View File

@ -60,11 +60,10 @@
#include "rtc_base/gunit.h"
#include "rtc_base/numerics/safe_conversions.h"
#include "rtc_base/time_utils.h"
#include "system_wrappers/include/field_trial.h"
#include "test/fake_decoder.h"
#include "test/field_trial.h"
#include "test/frame_forwarder.h"
#include "test/gmock.h"
#include "test/scoped_key_value_config.h"
#include "test/time_controller/simulated_time_controller.h"
using ::testing::_;
@ -244,12 +243,8 @@ class WebRtcVideoEngineTest : public ::testing::Test {
public:
WebRtcVideoEngineTest() : WebRtcVideoEngineTest("") {}
explicit WebRtcVideoEngineTest(const std::string& field_trials)
: time_controller_(webrtc::Timestamp::Millis(4711)),
override_field_trials_(
field_trials.empty()
? nullptr
: std::make_unique<webrtc::test::ScopedFieldTrials>(
field_trials)),
: field_trials_(field_trials),
time_controller_(webrtc::Timestamp::Millis(4711)),
task_queue_factory_(time_controller_.CreateTaskQueueFactory()),
call_(webrtc::Call::Create([&] {
webrtc::Call::Config call_config(&event_log_);
@ -286,9 +281,8 @@ class WebRtcVideoEngineTest : public ::testing::Test {
void ExpectRtpCapabilitySupport(const char* uri, bool supported) const;
webrtc::test::ScopedKeyValueConfig field_trials_;
webrtc::GlobalSimulatedTimeController time_controller_;
std::unique_ptr<webrtc::test::ScopedFieldTrials> override_field_trials_;
webrtc::FieldTrialBasedConfig field_trials_;
webrtc::RtcEventLogNull event_log_;
std::unique_ptr<webrtc::TaskQueueFactory> task_queue_factory_;
// Used in WebRtcVideoEngineVoiceTest, but defined here so it's properly
@ -936,9 +930,8 @@ TEST_F(WebRtcVideoEngineTest,
}
TEST_F(WebRtcVideoEngineTest, SimulcastEnabledForH264BehindFieldTrial) {
RTC_DCHECK(!override_field_trials_);
override_field_trials_ = std::make_unique<webrtc::test::ScopedFieldTrials>(
"WebRTC-H264Simulcast/Enabled/");
webrtc::test::ScopedKeyValueConfig override_field_trials(
field_trials_, "WebRTC-H264Simulcast/Enabled/");
AddSupportedVideoCodecType("H264");
std::unique_ptr<VideoMediaChannel> channel(engine_.CreateMediaChannel(
@ -978,9 +971,8 @@ TEST_F(WebRtcVideoEngineTest, Flexfec03SendCodecEnablesWithFieldTrial) {
EXPECT_THAT(engine_.send_codecs(), Not(Contains(flexfec)));
RTC_DCHECK(!override_field_trials_);
override_field_trials_ = std::make_unique<webrtc::test::ScopedFieldTrials>(
"WebRTC-FlexFEC-03-Advertised/Enabled/");
webrtc::test::ScopedKeyValueConfig override_field_trials(
field_trials_, "WebRTC-FlexFEC-03-Advertised/Enabled/");
EXPECT_THAT(engine_.send_codecs(), Contains(flexfec));
}
@ -993,9 +985,8 @@ TEST_F(WebRtcVideoEngineTest, Flexfec03ReceiveCodecDisablesWithFieldTrial) {
EXPECT_THAT(engine_.recv_codecs(), Contains(flexfec));
RTC_DCHECK(!override_field_trials_);
override_field_trials_ = std::make_unique<webrtc::test::ScopedFieldTrials>(
"WebRTC-FlexFEC-03-Advertised/Disabled/");
webrtc::test::ScopedKeyValueConfig override_field_trials(
field_trials_, "WebRTC-FlexFEC-03-Advertised/Disabled/");
EXPECT_THAT(engine_.recv_codecs(), Not(Contains(flexfec)));
}
@ -1006,9 +997,8 @@ TEST_F(WebRtcVideoEngineTest, Flexfec03LowerPayloadTypeRange) {
auto flexfec = Field("name", &VideoCodec::name, "flexfec-03");
// FlexFEC is active with field trial.
RTC_DCHECK(!override_field_trials_);
override_field_trials_ = std::make_unique<webrtc::test::ScopedFieldTrials>(
"WebRTC-FlexFEC-03-Advertised/Enabled/");
webrtc::test::ScopedKeyValueConfig override_field_trials(
field_trials_, "WebRTC-FlexFEC-03-Advertised/Enabled/");
auto send_codecs = engine_.send_codecs();
auto it = std::find_if(send_codecs.begin(), send_codecs.end(),
[](const cricket::VideoCodec& codec) {
@ -1452,7 +1442,7 @@ class WebRtcVideoChannelEncodedFrameCallbackTest : public ::testing::Test {
}
static const std::vector<webrtc::SdpVideoFormat> kSdpVideoFormats;
webrtc::FieldTrialBasedConfig field_trials_;
webrtc::test::ScopedKeyValueConfig field_trials_;
webrtc::RtcEventLogNull event_log_;
std::unique_ptr<webrtc::TaskQueueFactory> task_queue_factory_;
std::unique_ptr<webrtc::Call> call_;
@ -1740,8 +1730,7 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test {
}
webrtc::RtcEventLogNull event_log_;
webrtc::FieldTrialBasedConfig field_trials_;
std::unique_ptr<webrtc::test::ScopedFieldTrials> override_field_trials_;
webrtc::test::ScopedKeyValueConfig field_trials_;
std::unique_ptr<webrtc::TaskQueueFactory> task_queue_factory_;
std::unique_ptr<webrtc::Call> call_;
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>
@ -1796,9 +1785,8 @@ TEST_F(WebRtcVideoChannelBaseTest, OverridesRecvBufferSize) {
// Set field trial to override the default recv buffer size, and then re-run
// setup where the interface is created and configured.
const int kCustomRecvBufferSize = 123456;
RTC_DCHECK(!override_field_trials_);
override_field_trials_ = std::make_unique<webrtc::test::ScopedFieldTrials>(
"WebRTC-IncreasedReceivebuffers/123456/");
webrtc::test::ScopedKeyValueConfig override_field_trials(
field_trials_, "WebRTC-IncreasedReceivebuffers/123456/");
ResetTest();
@ -1814,9 +1802,8 @@ TEST_F(WebRtcVideoChannelBaseTest, OverridesRecvBufferSizeWithSuffix) {
// Set field trial to override the default recv buffer size, and then re-run
// setup where the interface is created and configured.
const int kCustomRecvBufferSize = 123456;
RTC_DCHECK(!override_field_trials_);
override_field_trials_ = std::make_unique<webrtc::test::ScopedFieldTrials>(
"WebRTC-IncreasedReceivebuffers/123456_Dogfood/");
webrtc::test::ScopedKeyValueConfig override_field_trials(
field_trials_, "WebRTC-IncreasedReceivebuffers/123456_Dogfood/");
ResetTest();
EXPECT_TRUE(SetOneCodec(DefaultCodec()));
@ -1832,8 +1819,6 @@ TEST_F(WebRtcVideoChannelBaseTest, InvalidRecvBufferSize) {
// then re-run setup where the interface is created and configured. The
// default value should still be used.
const char* prev_field_trials = webrtc::field_trial::GetFieldTrialString();
std::string field_trial_string;
for (std::string group : {" ", "NotANumber", "-1", "0"}) {
std::string trial_string = "WebRTC-IncreasedReceivebuffers/";
@ -1858,8 +1843,8 @@ TEST_F(WebRtcVideoChannelBaseTest, InvalidRecvBufferSize) {
});
waiting.Wait(rtc::Event::kForever);
field_trial_string = std::move(trial_string);
webrtc::field_trial::InitFieldTrialsFromString(field_trial_string.c_str());
webrtc::test::ScopedKeyValueConfig field_trial_override(field_trials_,
trial_string);
SetUp();
resume.Set();
@ -1873,8 +1858,6 @@ TEST_F(WebRtcVideoChannelBaseTest, InvalidRecvBufferSize) {
EXPECT_EQ(64 * 1024, network_interface_.sendbuf_size());
EXPECT_EQ(256 * 1024, network_interface_.recvbuf_size());
}
webrtc::field_trial::InitFieldTrialsFromString(prev_field_trials);
}
// Test that stats work properly for a 1-1 call.
@ -3177,17 +3160,15 @@ TEST_F(WebRtcVideoChannelTest, LossNotificationIsDisabledByDefault) {
}
TEST_F(WebRtcVideoChannelTest, LossNotificationIsEnabledByFieldTrial) {
RTC_DCHECK(!override_field_trials_);
override_field_trials_ = std::make_unique<webrtc::test::ScopedFieldTrials>(
"WebRTC-RtcpLossNotification/Enabled/");
webrtc::test::ScopedKeyValueConfig override_field_trials(
field_trials_, "WebRTC-RtcpLossNotification/Enabled/");
ResetTest();
TestLossNotificationState(true);
}
TEST_F(WebRtcVideoChannelTest, LossNotificationCanBeEnabledAndDisabled) {
RTC_DCHECK(!override_field_trials_);
override_field_trials_ = std::make_unique<webrtc::test::ScopedFieldTrials>(
"WebRTC-RtcpLossNotification/Enabled/");
webrtc::test::ScopedKeyValueConfig override_field_trials(
field_trials_, "WebRTC-RtcpLossNotification/Enabled/");
ResetTest();
AssignDefaultCodec();
@ -3788,8 +3769,8 @@ TEST_F(WebRtcVideoChannelTest, VerifyMinBitrate) {
}
TEST_F(WebRtcVideoChannelTest, VerifyMinBitrateWithForcedFallbackFieldTrial) {
RTC_DCHECK(!override_field_trials_);
override_field_trials_ = std::make_unique<webrtc::test::ScopedFieldTrials>(
webrtc::test::ScopedKeyValueConfig override_field_trials(
field_trials_,
"WebRTC-VP8-Forced-Fallback-Encoder-v2/Enabled-1,2,34567/");
std::vector<webrtc::VideoStream> streams = AddSendStream()->GetVideoStreams();
ASSERT_EQ(1u, streams.size());
@ -3798,9 +3779,8 @@ TEST_F(WebRtcVideoChannelTest, VerifyMinBitrateWithForcedFallbackFieldTrial) {
TEST_F(WebRtcVideoChannelTest,
BalancedDegradationPreferenceNotSupportedWithoutFieldtrial) {
RTC_DCHECK(!override_field_trials_);
override_field_trials_ = std::make_unique<webrtc::test::ScopedFieldTrials>(
"WebRTC-Video-BalancedDegradation/Disabled/");
webrtc::test::ScopedKeyValueConfig override_field_trials(
field_trials_, "WebRTC-Video-BalancedDegradation/Disabled/");
const bool kResolutionScalingEnabled = true;
const bool kFpsScalingEnabled = false;
TestDegradationPreference(kResolutionScalingEnabled, kFpsScalingEnabled);
@ -3808,9 +3788,8 @@ TEST_F(WebRtcVideoChannelTest,
TEST_F(WebRtcVideoChannelTest,
BalancedDegradationPreferenceSupportedBehindFieldtrial) {
RTC_DCHECK(!override_field_trials_);
override_field_trials_ = std::make_unique<webrtc::test::ScopedFieldTrials>(
"WebRTC-Video-BalancedDegradation/Enabled/");
webrtc::test::ScopedKeyValueConfig override_field_trials(
field_trials_, "WebRTC-Video-BalancedDegradation/Enabled/");
const bool kResolutionScalingEnabled = true;
const bool kFpsScalingEnabled = true;
TestDegradationPreference(kResolutionScalingEnabled, kFpsScalingEnabled);
@ -4000,7 +3979,7 @@ TEST_F(WebRtcVideoChannelTest, SetDefaultSendCodecs) {
VideoCodec codec;
EXPECT_TRUE(channel_->GetSendCodec(&codec));
EXPECT_TRUE(codec.Matches(engine_.send_codecs()[0]));
EXPECT_TRUE(codec.Matches(engine_.send_codecs()[0], &field_trials_));
// Using a RTX setup to verify that the default RTX payload type is good.
const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
@ -8857,7 +8836,7 @@ class WebRtcVideoChannelSimulcastTest : public ::testing::Test {
cricket::FakeWebRtcVideoDecoderFactory* decoder_factory_;
std::unique_ptr<webrtc::MockVideoBitrateAllocatorFactory>
mock_rate_allocator_factory_;
webrtc::FieldTrialBasedConfig field_trials_;
webrtc::test::ScopedKeyValueConfig field_trials_;
WebRtcVideoEngine engine_;
std::unique_ptr<VideoMediaChannel> channel_;
uint32_t last_ssrc_;

7
media/engine/webrtc_voice_engine.cc
View File

@ -125,9 +125,10 @@ bool IsCodec(const AudioCodec& codec, const char* ref_name) {
bool FindCodec(const std::vector<AudioCodec>& codecs,
const AudioCodec& codec,
AudioCodec* found_codec) {
AudioCodec* found_codec,
const webrtc::WebRtcKeyValueConfig* field_trials) {
for (const AudioCodec& c : codecs) {
if (c.Matches(codec)) {
if (c.Matches(codec, field_trials)) {
if (found_codec != NULL) {
*found_codec = c;
}
@ -1557,7 +1558,7 @@ bool WebRtcVoiceMediaChannel::SetRecvCodecs(
// Log a warning if a codec's payload type is changing. This used to be
// treated as an error. It's abnormal, but not really illegal.
AudioCodec old_codec;
if (FindCodec(recv_codecs_, codec, &old_codec) &&
if (FindCodec(recv_codecs_, codec, &old_codec, &call_->trials()) &&
old_codec.id != codec.id) {
RTC_LOG(LS_WARNING) << codec.name << " mapped to a second payload type ("
<< codec.id << ", was already mapped to "

28
media/engine/webrtc_voice_engine_unittest.cc
View File

@ -33,10 +33,10 @@
#include "rtc_base/arraysize.h"
#include "rtc_base/byte_order.h"
#include "rtc_base/numerics/safe_conversions.h"
#include "test/field_trial.h"
#include "test/gtest.h"
#include "test/mock_audio_decoder_factory.h"
#include "test/mock_audio_encoder_factory.h"
#include "test/scoped_key_value_config.h"
using ::testing::_;
using ::testing::ContainerEq;
@ -180,9 +180,7 @@ class FakeAudioSource : public cricket::AudioSource {
class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam<bool> {
public:
WebRtcVoiceEngineTestFake() : WebRtcVoiceEngineTestFake("") {}
explicit WebRtcVoiceEngineTestFake(const char* field_trials)
WebRtcVoiceEngineTestFake()
: use_null_apm_(GetParam()),
task_queue_factory_(webrtc::CreateDefaultTaskQueueFactory()),
adm_(webrtc::test::MockAudioDeviceModule::CreateStrict()),
@ -190,8 +188,7 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam<bool> {
? nullptr
: rtc::make_ref_counted<
StrictMock<webrtc::test::MockAudioProcessing>>()),
call_(),
override_field_trials_(field_trials) {
call_() {
// AudioDeviceModule.
AdmSetupExpectations(adm_);
@ -212,7 +209,7 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam<bool> {
auto decoder_factory = webrtc::CreateBuiltinAudioDecoderFactory();
engine_.reset(new cricket::WebRtcVoiceEngine(
task_queue_factory_.get(), adm_, encoder_factory, decoder_factory,
nullptr, apm_, nullptr, trials_config_));
nullptr, apm_, nullptr, field_trials_));
engine_->Init();
send_parameters_.codecs.push_back(kPcmuCodec);
recv_parameters_.codecs.push_back(kPcmuCodec);
@ -800,10 +797,7 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam<bool> {
cricket::AudioRecvParameters recv_parameters_;
FakeAudioSource fake_source_;
webrtc::AudioProcessing::Config apm_config_;
private:
webrtc::test::ScopedFieldTrials override_field_trials_;
webrtc::FieldTrialBasedConfig trials_config_;
webrtc::test::ScopedKeyValueConfig field_trials_;
};
INSTANTIATE_TEST_SUITE_P(TestBothWithAndWithoutNullApm,
@ -1232,8 +1226,8 @@ TEST_P(WebRtcVoiceEngineTestFake,
}
TEST_P(WebRtcVoiceEngineTestFake, AdaptivePtimeFieldTrial) {
webrtc::test::ScopedFieldTrials override_field_trials(
"WebRTC-Audio-AdaptivePtime/enabled:true/");
webrtc::test::ScopedKeyValueConfig override_field_trials(
field_trials_, "WebRTC-Audio-AdaptivePtime/enabled:true/");
EXPECT_TRUE(SetupSendStream());
EXPECT_TRUE(GetAudioNetworkAdaptorConfig(kSsrcX));
}
@ -2503,14 +2497,6 @@ TEST_P(WebRtcVoiceEngineTestFake, AudioNetworkAdaptorNotGetOverridden) {
GetAudioNetworkAdaptorConfig(kSsrcX));
}
class WebRtcVoiceEngineWithSendSideBweWithOverheadTest
: public WebRtcVoiceEngineTestFake {
public:
WebRtcVoiceEngineWithSendSideBweWithOverheadTest()
: WebRtcVoiceEngineTestFake(
"WebRTC-Audio-Allocation/min:6000bps,max:32000bps/") {}
};
// Test that we can set the outgoing SSRC properly.
// SSRC is set in SetupSendStream() by calling AddSendStream.
TEST_P(WebRtcVoiceEngineTestFake, SetSendSsrc) {

10
media/sctp/sctp_transport_factory.cc
View File

@ -10,12 +10,12 @@
#include "media/sctp/sctp_transport_factory.h"
#include "api/webrtc_key_value_config.h"
#include "rtc_base/system/unused.h"
#ifdef WEBRTC_HAVE_DCSCTP
#include "media/sctp/dcsctp_transport.h" // nogncheck
#include "system_wrappers/include/clock.h" // nogncheck
#include "system_wrappers/include/field_trial.h" // nogncheck
#endif
#ifdef WEBRTC_HAVE_USRSCTP
@ -24,12 +24,14 @@
namespace cricket {
SctpTransportFactory::SctpTransportFactory(rtc::Thread* network_thread)
SctpTransportFactory::SctpTransportFactory(
rtc::Thread* network_thread,
const webrtc::WebRtcKeyValueConfig& field_trials)
: network_thread_(network_thread), use_usrsctp_("Disabled", false) {
RTC_UNUSED(network_thread_);
#ifdef WEBRTC_HAVE_DCSCTP
webrtc::ParseFieldTrial({&use_usrsctp_}, webrtc::field_trial::FindFullName(
"WebRTC-DataChannel-Dcsctp"));
webrtc::ParseFieldTrial({&use_usrsctp_},
field_trials.Lookup("WebRTC-DataChannel-Dcsctp"));
#endif
}

5
media/sctp/sctp_transport_factory.h
View File

@ -14,6 +14,7 @@
#include <memory>
#include "api/transport/sctp_transport_factory_interface.h"
#include "api/webrtc_key_value_config.h"
#include "media/sctp/sctp_transport_internal.h"
#include "rtc_base/experiments/field_trial_parser.h"
#include "rtc_base/thread.h"
@ -22,7 +23,9 @@ namespace cricket {
class SctpTransportFactory : public webrtc::SctpTransportFactoryInterface {
public:
explicit SctpTransportFactory(rtc::Thread* network_thread);
explicit SctpTransportFactory(
rtc::Thread* network_thread,
const webrtc::WebRtcKeyValueConfig& field_trials);
std::unique_ptr<SctpTransportInternal> CreateSctpTransport(
rtc::PacketTransportInternal* transport) override;

12
pc/channel_manager_unittest.cc
View File

@ -99,25 +99,25 @@ TEST_F(ChannelManagerTest, SetVideoRtxEnabled) {
// By default RTX is disabled.
cm_->GetSupportedVideoSendCodecs(&send_codecs);
EXPECT_FALSE(ContainsMatchingCodec(send_codecs, rtx_codec));
EXPECT_FALSE(ContainsMatchingCodec(send_codecs, rtx_codec, &field_trials_));
cm_->GetSupportedVideoSendCodecs(&recv_codecs);
EXPECT_FALSE(ContainsMatchingCodec(recv_codecs, rtx_codec));
EXPECT_FALSE(ContainsMatchingCodec(recv_codecs, rtx_codec, &field_trials_));
// Enable and check.
cm_ = cricket::ChannelManager::Create(CreateFakeMediaEngine(),
true, worker_, network_.get());
cm_->GetSupportedVideoSendCodecs(&send_codecs);
EXPECT_TRUE(ContainsMatchingCodec(send_codecs, rtx_codec));
EXPECT_TRUE(ContainsMatchingCodec(send_codecs, rtx_codec, &field_trials_));
cm_->GetSupportedVideoSendCodecs(&recv_codecs);
EXPECT_TRUE(ContainsMatchingCodec(recv_codecs, rtx_codec));
EXPECT_TRUE(ContainsMatchingCodec(recv_codecs, rtx_codec, &field_trials_));
// Disable and check.
cm_ = cricket::ChannelManager::Create(CreateFakeMediaEngine(),
false, worker_, network_.get());
cm_->GetSupportedVideoSendCodecs(&send_codecs);
EXPECT_FALSE(ContainsMatchingCodec(send_codecs, rtx_codec));
EXPECT_FALSE(ContainsMatchingCodec(send_codecs, rtx_codec, &field_trials_));
cm_->GetSupportedVideoSendCodecs(&recv_codecs);
EXPECT_FALSE(ContainsMatchingCodec(recv_codecs, rtx_codec));
EXPECT_FALSE(ContainsMatchingCodec(recv_codecs, rtx_codec, &field_trials_));
}
TEST_F(ChannelManagerTest, CreateDestroyChannels) {

24
pc/channel_unittest.cc
View File

@ -2020,9 +2020,11 @@ TEST_F(VideoChannelSingleThreadTest, TestSetLocalOfferWithPacketization) {
EXPECT_TRUE(channel1_->SetLocalContent(&video, SdpType::kOffer, err));
EXPECT_THAT(media_channel1()->send_codecs(), testing::IsEmpty());
ASSERT_THAT(media_channel1()->recv_codecs(), testing::SizeIs(2));
EXPECT_TRUE(media_channel1()->recv_codecs()[0].Matches(kVp8Codec));
EXPECT_TRUE(
media_channel1()->recv_codecs()[0].Matches(kVp8Codec, &field_trials_));
EXPECT_EQ(media_channel1()->recv_codecs()[0].packetization, absl::nullopt);
EXPECT_TRUE(media_channel1()->recv_codecs()[1].Matches(vp9_codec));
EXPECT_TRUE(
media_channel1()->recv_codecs()[1].Matches(vp9_codec, &field_trials_));
EXPECT_EQ(media_channel1()->recv_codecs()[1].packetization,
cricket::kPacketizationParamRaw);
}
@ -2041,9 +2043,11 @@ TEST_F(VideoChannelSingleThreadTest, TestSetRemoteOfferWithPacketization) {
EXPECT_TRUE(err.empty());
EXPECT_THAT(media_channel1()->recv_codecs(), testing::IsEmpty());
ASSERT_THAT(media_channel1()->send_codecs(), testing::SizeIs(2));
EXPECT_TRUE(media_channel1()->send_codecs()[0].Matches(kVp8Codec));
EXPECT_TRUE(
media_channel1()->send_codecs()[0].Matches(kVp8Codec, &field_trials_));
EXPECT_EQ(media_channel1()->send_codecs()[0].packetization, absl::nullopt);
EXPECT_TRUE(media_channel1()->send_codecs()[1].Matches(vp9_codec));
EXPECT_TRUE(
media_channel1()->send_codecs()[1].Matches(vp9_codec, &field_trials_));
EXPECT_EQ(media_channel1()->send_codecs()[1].packetization,
cricket::kPacketizationParamRaw);
}
@ -2063,15 +2067,19 @@ TEST_F(VideoChannelSingleThreadTest, TestSetAnswerWithPacketization) {
EXPECT_TRUE(channel1_->SetRemoteContent(&video, SdpType::kAnswer, err));
EXPECT_TRUE(err.empty());
ASSERT_THAT(media_channel1()->recv_codecs(), testing::SizeIs(2));
EXPECT_TRUE(media_channel1()->recv_codecs()[0].Matches(kVp8Codec));
EXPECT_TRUE(
media_channel1()->recv_codecs()[0].Matches(kVp8Codec, &field_trials_));
EXPECT_EQ(media_channel1()->recv_codecs()[0].packetization, absl::nullopt);
EXPECT_TRUE(media_channel1()->recv_codecs()[1].Matches(vp9_codec));
EXPECT_TRUE(
media_channel1()->recv_codecs()[1].Matches(vp9_codec, &field_trials_));
EXPECT_EQ(media_channel1()->recv_codecs()[1].packetization,
cricket::kPacketizationParamRaw);
EXPECT_THAT(media_channel1()->send_codecs(), testing::SizeIs(2));
EXPECT_TRUE(media_channel1()->send_codecs()[0].Matches(kVp8Codec));
EXPECT_TRUE(
media_channel1()->send_codecs()[0].Matches(kVp8Codec, &field_trials_));
EXPECT_EQ(media_channel1()->send_codecs()[0].packetization, absl::nullopt);
EXPECT_TRUE(media_channel1()->send_codecs()[1].Matches(vp9_codec));
EXPECT_TRUE(
media_channel1()->send_codecs()[1].Matches(vp9_codec, &field_trials_));
EXPECT_EQ(media_channel1()->send_codecs()[1].packetization,
cricket::kPacketizationParamRaw);
}

3
pc/connection_context.cc
View File

@ -79,7 +79,8 @@ std::unique_ptr<SctpTransportFactoryInterface> MaybeCreateSctpFactory(
return factory;
}
#ifdef WEBRTC_HAVE_SCTP
return std::make_unique<cricket::SctpTransportFactory>(network_thread);
return std::make_unique<cricket::SctpTransportFactory>(network_thread,
field_trials);
#else
return nullptr;
#endif

197
pc/media_session.cc
View File

@ -726,13 +726,16 @@ static bool CreateMediaContentOffer(
}
template <class C>
static bool ReferencedCodecsMatch(const std::vector<C>& codecs1,
const int codec1_id,
const std::vector<C>& codecs2,
const int codec2_id) {
static bool ReferencedCodecsMatch(
const std::vector<C>& codecs1,
const int codec1_id,
const std::vector<C>& codecs2,
const int codec2_id,
const webrtc::WebRtcKeyValueConfig* field_trials) {
const C* codec1 = FindCodecById(codecs1, codec1_id);
const C* codec2 = FindCodecById(codecs2, codec2_id);
return codec1 != nullptr && codec2 != nullptr && codec1->Matches(*codec2);
return codec1 != nullptr && codec2 != nullptr &&
codec1->Matches(*codec2, field_trials);
}
template <class C>
@ -752,12 +755,14 @@ template <class C>
static void NegotiateCodecs(const std::vector<C>& local_codecs,
const std::vector<C>& offered_codecs,
std::vector<C>* negotiated_codecs,
bool keep_offer_order) {
bool keep_offer_order,
const webrtc::WebRtcKeyValueConfig* field_trials) {
for (const C& ours : local_codecs) {
C theirs;
// Note that we intentionally only find one matching codec for each of our
// local codecs, in case the remote offer contains duplicate codecs.
if (FindMatchingCodec(local_codecs, offered_codecs, ours, &theirs)) {
if (FindMatchingCodec(local_codecs, offered_codecs, ours, &theirs,
field_trials)) {
C negotiated = ours;
NegotiatePacketization(ours, theirs, &negotiated);
negotiated.IntersectFeedbackParams(theirs);
@ -810,10 +815,12 @@ static void NegotiateCodecs(const std::vector<C>& local_codecs,
// a member of `codecs1`. If `codec_to_match` is an RED or RTX codec, both
// the codecs themselves and their associated codecs must match.
template <class C>
static bool FindMatchingCodec(const std::vector<C>& codecs1,
const std::vector<C>& codecs2,
const C& codec_to_match,
C* found_codec) {
static bool FindMatchingCodec(
const std::vector<C>& codecs1,
const std::vector<C>& codecs2,
const C& codec_to_match,
C* found_codec,
const webrtc::WebRtcKeyValueConfig* field_trials) {
// `codec_to_match` should be a member of `codecs1`, in order to look up
// RED/RTX codecs' associated codecs correctly. If not, that's a programming
// error.
@ -821,7 +828,7 @@ static bool FindMatchingCodec(const std::vector<C>& codecs1,
return &codec == &codec_to_match;
}));
for (const C& potential_match : codecs2) {
if (potential_match.Matches(codec_to_match)) {
if (potential_match.Matches(codec_to_match, field_trials)) {
if (IsRtxCodec(codec_to_match)) {
int apt_value_1 = 0;
int apt_value_2 = 0;
@ -832,8 +839,8 @@ static bool FindMatchingCodec(const std::vector<C>& codecs1,
RTC_LOG(LS_WARNING) << "RTX missing associated payload type.";
continue;
}
if (!ReferencedCodecsMatch(codecs1, apt_value_1, codecs2,
apt_value_2)) {
if (!ReferencedCodecsMatch(codecs1, apt_value_1, codecs2, apt_value_2,
field_trials)) {
continue;
}
} else if (IsRedCodec(codec_to_match)) {
@ -876,7 +883,7 @@ static bool FindMatchingCodec(const std::vector<C>& codecs1,
if (rtc::FromString(redundant_payloads_1[0], &red_value_1) &&
rtc::FromString(redundant_payloads_2[0], &red_value_2)) {
if (!ReferencedCodecsMatch(codecs1, red_value_1, codecs2,
red_value_2)) {
red_value_2, field_trials)) {
continue;
}
}
@ -967,14 +974,15 @@ static const C* GetAssociatedCodecForRed(const std::vector<C>& codec_list,
template <class C>
static void MergeCodecs(const std::vector<C>& reference_codecs,
std::vector<C>* offered_codecs,
UsedPayloadTypes* used_pltypes) {
UsedPayloadTypes* used_pltypes,
const webrtc::WebRtcKeyValueConfig* field_trials) {
// Add all new codecs that are not RTX/RED codecs.
// The two-pass splitting of the loops means preferring payload types
// of actual codecs with respect to collisions.
for (const C& reference_codec : reference_codecs) {
if (!IsRtxCodec(reference_codec) && !IsRedCodec(reference_codec) &&
!FindMatchingCodec<C>(reference_codecs, *offered_codecs,
reference_codec, nullptr)) {
reference_codec, nullptr, field_trials)) {
C codec = reference_codec;
used_pltypes->FindAndSetIdUsed(&codec);
offered_codecs->push_back(codec);
@ -985,7 +993,7 @@ static void MergeCodecs(const std::vector<C>& reference_codecs,
for (const C& reference_codec : reference_codecs) {
if (IsRtxCodec(reference_codec) &&
!FindMatchingCodec<C>(reference_codecs, *offered_codecs,
reference_codec, nullptr)) {
reference_codec, nullptr, field_trials)) {
C rtx_codec = reference_codec;
const C* associated_codec =
GetAssociatedCodecForRtx(reference_codecs, rtx_codec);
@ -996,7 +1004,8 @@ static void MergeCodecs(const std::vector<C>& reference_codecs,
// Its payload type may be different than the reference codec.
C matching_codec;
if (!FindMatchingCodec<C>(reference_codecs, *offered_codecs,
*associated_codec, &matching_codec)) {
*associated_codec, &matching_codec,
field_trials)) {
RTC_LOG(LS_WARNING)
<< "Couldn't find matching " << associated_codec->name << " codec.";
continue;
@ -1008,14 +1017,15 @@ static void MergeCodecs(const std::vector<C>& reference_codecs,
offered_codecs->push_back(rtx_codec);
} else if (IsRedCodec(reference_codec) &&
!FindMatchingCodec<C>(reference_codecs, *offered_codecs,
reference_codec, nullptr)) {
reference_codec, nullptr, field_trials)) {
C red_codec = reference_codec;
const C* associated_codec =
GetAssociatedCodecForRed(reference_codecs, red_codec);
if (associated_codec) {
C matching_codec;
if (!FindMatchingCodec<C>(reference_codecs, *offered_codecs,
*associated_codec, &matching_codec)) {
*associated_codec, &matching_codec,
field_trials)) {
RTC_LOG(LS_WARNING) << "Couldn't find matching "
<< associated_codec->name << " codec.";
continue;
@ -1039,7 +1049,8 @@ template <typename Codecs>
static Codecs MatchCodecPreference(
const std::vector<webrtc::RtpCodecCapability>& codec_preferences,
const Codecs& codecs,
const Codecs& supported_codecs) {
const Codecs& supported_codecs,
const webrtc::WebRtcKeyValueConfig* field_trials) {
Codecs filtered_codecs;
bool want_rtx = false;
bool want_red = false;
@ -1068,7 +1079,7 @@ static Codecs MatchCodecPreference(
if (found_codec != supported_codecs.end()) {
typename Codecs::value_type found_codec_with_correct_pt;
if (FindMatchingCodec(supported_codecs, codecs, *found_codec,
&found_codec_with_correct_pt)) {
&found_codec_with_correct_pt, field_trials)) {
filtered_codecs.push_back(found_codec_with_correct_pt);
std::string id = rtc::ToString(found_codec_with_correct_pt.id);
// Search for the matching rtx or red codec.
@ -1111,8 +1122,10 @@ static Codecs MatchCodecPreference(
// Compute the union of `codecs1` and `codecs2`.
template <class C>
std::vector<C> ComputeCodecsUnion(const std::vector<C>& codecs1,
const std::vector<C>& codecs2) {
std::vector<C> ComputeCodecsUnion(
const std::vector<C>& codecs1,
const std::vector<C>& codecs2,
const webrtc::WebRtcKeyValueConfig* field_trials) {
std::vector<C> all_codecs;
UsedPayloadTypes used_payload_types;
for (const C& codec : codecs1) {
@ -1123,7 +1136,7 @@ std::vector<C> ComputeCodecsUnion(const std::vector<C>& codecs1,
// Use MergeCodecs to merge the second half of our list as it already checks
// and fixes problems with duplicate payload types.
MergeCodecs<C>(codecs2, &all_codecs, &used_payload_types);
MergeCodecs<C>(codecs2, &all_codecs, &used_payload_types, field_trials);
return all_codecs;
}
@ -1355,7 +1368,8 @@ static bool SetCodecsInAnswer(
const webrtc::WebRtcKeyValueConfig& field_trials) {
std::vector<C> negotiated_codecs;
NegotiateCodecs(local_codecs, offer->codecs(), &negotiated_codecs,
media_description_options.codec_preferences.empty());
media_description_options.codec_preferences.empty(),
&field_trials);
answer->AddCodecs(negotiated_codecs);
answer->set_protocol(offer->protocol());
if (!AddStreamParams(media_description_options.sender_options,
@ -2039,16 +2053,19 @@ void MergeCodecsFromDescription(
const std::vector<const ContentInfo*>& current_active_contents,
AudioCodecs* audio_codecs,
VideoCodecs* video_codecs,
UsedPayloadTypes* used_pltypes) {
UsedPayloadTypes* used_pltypes,
const webrtc::WebRtcKeyValueConfig* field_trials) {
for (const ContentInfo* content : current_active_contents) {
if (IsMediaContentOfType(content, MEDIA_TYPE_AUDIO)) {
const AudioContentDescription* audio =
content->media_description()->as_audio();
MergeCodecs<AudioCodec>(audio->codecs(), audio_codecs, used_pltypes);
MergeCodecs<AudioCodec>(audio->codecs(), audio_codecs, used_pltypes,
field_trials);
} else if (IsMediaContentOfType(content, MEDIA_TYPE_VIDEO)) {
const VideoContentDescription* video =
content->media_description()->as_video();
MergeCodecs<VideoCodec>(video->codecs(), video_codecs, used_pltypes);
MergeCodecs<VideoCodec>(video->codecs(), video_codecs, used_pltypes,
field_trials);
}
}
}
@ -2063,16 +2080,20 @@ void MediaSessionDescriptionFactory::GetCodecsForOffer(
const std::vector<const ContentInfo*>& current_active_contents,
AudioCodecs* audio_codecs,
VideoCodecs* video_codecs) const {
const webrtc::WebRtcKeyValueConfig* field_trials =
&transport_desc_factory_->trials();
// First - get all codecs from the current description if the media type
// is used. Add them to `used_pltypes` so the payload type is not reused if a
// new media type is added.
UsedPayloadTypes used_pltypes;
MergeCodecsFromDescription(current_active_contents, audio_codecs,
video_codecs, &used_pltypes);
video_codecs, &used_pltypes, field_trials);
// Add our codecs that are not in the current description.
MergeCodecs<AudioCodec>(all_audio_codecs_, audio_codecs, &used_pltypes);
MergeCodecs<VideoCodec>(all_video_codecs_, video_codecs, &used_pltypes);
MergeCodecs<AudioCodec>(all_audio_codecs_, audio_codecs, &used_pltypes,
field_trials);
MergeCodecs<VideoCodec>(all_video_codecs_, video_codecs, &used_pltypes,
field_trials);
}
// Getting codecs for an answer involves these steps:
@ -2087,12 +2108,14 @@ void MediaSessionDescriptionFactory::GetCodecsForAnswer(
const SessionDescription& remote_offer,
AudioCodecs* audio_codecs,
VideoCodecs* video_codecs) const {
const webrtc::WebRtcKeyValueConfig* field_trials =
&transport_desc_factory_->trials();
// First - get all codecs from the current description if the media type
// is used. Add them to `used_pltypes` so the payload type is not reused if a
// new media type is added.
UsedPayloadTypes used_pltypes;
MergeCodecsFromDescription(current_active_contents, audio_codecs,
video_codecs, &used_pltypes);
video_codecs, &used_pltypes, field_trials);
// Second - filter out codecs that we don't support at all and should ignore.
AudioCodecs filtered_offered_audio_codecs;
@ -2102,11 +2125,12 @@ void MediaSessionDescriptionFactory::GetCodecsForAnswer(
const AudioContentDescription* audio =
content.media_description()->as_audio();
for (const AudioCodec& offered_audio_codec : audio->codecs()) {
if (!FindMatchingCodec<AudioCodec>(audio->codecs(),
filtered_offered_audio_codecs,
offered_audio_codec, nullptr) &&
if (!FindMatchingCodec<AudioCodec>(
audio->codecs(), filtered_offered_audio_codecs,
offered_audio_codec, nullptr, field_trials) &&
FindMatchingCodec<AudioCodec>(audio->codecs(), all_audio_codecs_,
offered_audio_codec, nullptr)) {
offered_audio_codec, nullptr,
field_trials)) {
filtered_offered_audio_codecs.push_back(offered_audio_codec);
}
}
@ -2114,11 +2138,12 @@ void MediaSessionDescriptionFactory::GetCodecsForAnswer(
const VideoContentDescription* video =
content.media_description()->as_video();
for (const VideoCodec& offered_video_codec : video->codecs()) {
if (!FindMatchingCodec<VideoCodec>(video->codecs(),
filtered_offered_video_codecs,
offered_video_codec, nullptr) &&
if (!FindMatchingCodec<VideoCodec>(
video->codecs(), filtered_offered_video_codecs,
offered_video_codec, nullptr, field_trials) &&
FindMatchingCodec<VideoCodec>(video->codecs(), all_video_codecs_,
offered_video_codec, nullptr)) {
offered_video_codec, nullptr,
field_trials)) {
filtered_offered_video_codecs.push_back(offered_video_codec);
}
}
@ -2128,9 +2153,9 @@ void MediaSessionDescriptionFactory::GetCodecsForAnswer(
// Add codecs that are not in the current description but were in
// `remote_offer`.
MergeCodecs<AudioCodec>(filtered_offered_audio_codecs, audio_codecs,
&used_pltypes);
&used_pltypes, field_trials);
MergeCodecs<VideoCodec>(filtered_offered_video_codecs, video_codecs,
&used_pltypes);
&used_pltypes, field_trials);
}
MediaSessionDescriptionFactory::AudioVideoRtpHeaderExtensions
@ -2272,6 +2297,8 @@ bool MediaSessionDescriptionFactory::AddAudioContentForOffer(
StreamParamsVec* current_streams,
SessionDescription* desc,
IceCredentialsIterator* ice_credentials) const {
const webrtc::WebRtcKeyValueConfig* field_trials =
&transport_desc_factory_->trials();
// Filter audio_codecs (which includes all codecs, with correctly remapped
// payload types) based on transceiver direction.
const AudioCodecs& supported_audio_codecs =
@ -2282,9 +2309,9 @@ bool MediaSessionDescriptionFactory::AddAudioContentForOffer(
if (!media_description_options.codec_preferences.empty()) {
// Add the codecs from the current transceiver's codec preferences.
// They override any existing codecs from previous negotiations.
filtered_codecs =
MatchCodecPreference(media_description_options.codec_preferences,
audio_codecs, supported_audio_codecs);
filtered_codecs = MatchCodecPreference(
media_description_options.codec_preferences, audio_codecs,
supported_audio_codecs, field_trials);
} else {
// Add the codecs from current content if it exists and is not rejected nor
// recycled.
@ -2295,7 +2322,7 @@ bool MediaSessionDescriptionFactory::AddAudioContentForOffer(
current_content->media_description()->as_audio();
for (const AudioCodec& codec : acd->codecs()) {
if (FindMatchingCodec<AudioCodec>(acd->codecs(), audio_codecs, codec,
nullptr)) {
nullptr, field_trials)) {
filtered_codecs.push_back(codec);
}
}
@ -2304,9 +2331,10 @@ bool MediaSessionDescriptionFactory::AddAudioContentForOffer(
AudioCodec found_codec;
for (const AudioCodec& codec : supported_audio_codecs) {
if (FindMatchingCodec<AudioCodec>(supported_audio_codecs, audio_codecs,
codec, &found_codec) &&
codec, &found_codec, field_trials) &&
!FindMatchingCodec<AudioCodec>(supported_audio_codecs,
filtered_codecs, codec, nullptr)) {
filtered_codecs, codec, nullptr,
field_trials)) {
// Use the `found_codec` from `audio_codecs` because it has the
// correctly mapped payload type.
filtered_codecs.push_back(found_codec);
@ -2362,6 +2390,8 @@ bool MediaSessionDescriptionFactory::AddVideoContentForOffer(
StreamParamsVec* current_streams,
SessionDescription* desc,
IceCredentialsIterator* ice_credentials) const {
const webrtc::WebRtcKeyValueConfig* field_trials =
&transport_desc_factory_->trials();
// Filter video_codecs (which includes all codecs, with correctly remapped
// payload types) based on transceiver direction.
const VideoCodecs& supported_video_codecs =
@ -2372,9 +2402,9 @@ bool MediaSessionDescriptionFactory::AddVideoContentForOffer(
if (!media_description_options.codec_preferences.empty()) {
// Add the codecs from the current transceiver's codec preferences.
// They override any existing codecs from previous negotiations.
filtered_codecs =
MatchCodecPreference(media_description_options.codec_preferences,
video_codecs, supported_video_codecs);
filtered_codecs = MatchCodecPreference(
media_description_options.codec_preferences, video_codecs,
supported_video_codecs, field_trials);
} else {
// Add the codecs from current content if it exists and is not rejected nor
// recycled.
@ -2385,7 +2415,7 @@ bool MediaSessionDescriptionFactory::AddVideoContentForOffer(
current_content->media_description()->as_video();
for (const VideoCodec& codec : vcd->codecs()) {
if (FindMatchingCodec<VideoCodec>(vcd->codecs(), video_codecs, codec,
nullptr)) {
nullptr, field_trials)) {
filtered_codecs.push_back(codec);
}
}
@ -2394,9 +2424,10 @@ bool MediaSessionDescriptionFactory::AddVideoContentForOffer(
VideoCodec found_codec;
for (const VideoCodec& codec : supported_video_codecs) {
if (FindMatchingCodec<VideoCodec>(supported_video_codecs, video_codecs,
codec, &found_codec) &&
codec, &found_codec, field_trials) &&
!FindMatchingCodec<VideoCodec>(supported_video_codecs,
filtered_codecs, codec, nullptr)) {
filtered_codecs, codec, nullptr,
field_trials)) {
// Use the `found_codec` from `video_codecs` because it has the
// correctly mapped payload type.
if (IsRtxCodec(codec)) {
@ -2408,9 +2439,9 @@ bool MediaSessionDescriptionFactory::AddVideoContentForOffer(
// Find the codec we should be referencing and point to it.
VideoCodec changed_referenced_codec;
if (FindMatchingCodec<VideoCodec>(supported_video_codecs,
filtered_codecs, *referenced_codec,
&changed_referenced_codec)) {
if (FindMatchingCodec<VideoCodec>(
supported_video_codecs, filtered_codecs, *referenced_codec,
&changed_referenced_codec, field_trials)) {
found_codec.SetParam(kCodecParamAssociatedPayloadType,
changed_referenced_codec.id);
}
@ -2556,6 +2587,8 @@ bool MediaSessionDescriptionFactory::AddAudioContentForAnswer(
StreamParamsVec* current_streams,
SessionDescription* answer,
IceCredentialsIterator* ice_credentials) const {
const webrtc::WebRtcKeyValueConfig* field_trials =
&transport_desc_factory_->trials();
RTC_CHECK(IsMediaContentOfType(offer_content, MEDIA_TYPE_AUDIO));
const AudioContentDescription* offer_audio_description =
offer_content->media_description()->as_audio();
@ -2580,9 +2613,9 @@ bool MediaSessionDescriptionFactory::AddAudioContentForAnswer(
AudioCodecs filtered_codecs;
if (!media_description_options.codec_preferences.empty()) {
filtered_codecs =
MatchCodecPreference(media_description_options.codec_preferences,
audio_codecs, supported_audio_codecs);
filtered_codecs = MatchCodecPreference(
media_description_options.codec_preferences, audio_codecs,
supported_audio_codecs, field_trials);
} else {
// Add the codecs from current content if it exists and is not rejected nor
// recycled.
@ -2593,7 +2626,7 @@ bool MediaSessionDescriptionFactory::AddAudioContentForAnswer(
current_content->media_description()->as_audio();
for (const AudioCodec& codec : acd->codecs()) {
if (FindMatchingCodec<AudioCodec>(acd->codecs(), audio_codecs, codec,
nullptr)) {
nullptr, field_trials)) {
filtered_codecs.push_back(codec);
}
}
@ -2601,9 +2634,10 @@ bool MediaSessionDescriptionFactory::AddAudioContentForAnswer(
// Add other supported audio codecs.
for (const AudioCodec& codec : supported_audio_codecs) {
if (FindMatchingCodec<AudioCodec>(supported_audio_codecs, audio_codecs,
codec, nullptr) &&
codec, nullptr, field_trials) &&
!FindMatchingCodec<AudioCodec>(supported_audio_codecs,
filtered_codecs, codec, nullptr)) {
filtered_codecs, codec, nullptr,
field_trials)) {
// We should use the local codec with local parameters and the codec id
// would be correctly mapped in `NegotiateCodecs`.
filtered_codecs.push_back(codec);
@ -2672,6 +2706,8 @@ bool MediaSessionDescriptionFactory::AddVideoContentForAnswer(
StreamParamsVec* current_streams,
SessionDescription* answer,
IceCredentialsIterator* ice_credentials) const {
const webrtc::WebRtcKeyValueConfig* field_trials =
&transport_desc_factory_->trials();
RTC_CHECK(IsMediaContentOfType(offer_content, MEDIA_TYPE_VIDEO));
const VideoContentDescription* offer_video_description =
offer_content->media_description()->as_video();
@ -2696,9 +2732,9 @@ bool MediaSessionDescriptionFactory::AddVideoContentForAnswer(
VideoCodecs filtered_codecs;
if (!media_description_options.codec_preferences.empty()) {
filtered_codecs =
MatchCodecPreference(media_description_options.codec_preferences,
video_codecs, supported_video_codecs);
filtered_codecs = MatchCodecPreference(
media_description_options.codec_preferences, video_codecs,
supported_video_codecs, field_trials);
} else {
// Add the codecs from current content if it exists and is not rejected nor
// recycled.
@ -2709,7 +2745,7 @@ bool MediaSessionDescriptionFactory::AddVideoContentForAnswer(
current_content->media_description()->as_video();
for (const VideoCodec& codec : vcd->codecs()) {
if (FindMatchingCodec<VideoCodec>(vcd->codecs(), video_codecs, codec,
nullptr)) {
nullptr, field_trials)) {
filtered_codecs.push_back(codec);
}
}
@ -2719,9 +2755,10 @@ bool MediaSessionDescriptionFactory::AddVideoContentForAnswer(
VideoCodecs other_video_codecs;
for (const VideoCodec& codec : supported_video_codecs) {
if (FindMatchingCodec<VideoCodec>(supported_video_codecs, video_codecs,
codec, nullptr) &&
codec, nullptr, field_trials) &&
!FindMatchingCodec<VideoCodec>(supported_video_codecs,
filtered_codecs, codec, nullptr)) {
filtered_codecs, codec, nullptr,
field_trials)) {
// We should use the local codec with local parameters and the codec id
// would be correctly mapped in `NegotiateCodecs`.
other_video_codecs.push_back(codec);
@ -2729,8 +2766,8 @@ bool MediaSessionDescriptionFactory::AddVideoContentForAnswer(
}
// Use ComputeCodecsUnion to avoid having duplicate payload IDs
filtered_codecs =
ComputeCodecsUnion<VideoCodec>(filtered_codecs, other_video_codecs);
filtered_codecs = ComputeCodecsUnion<VideoCodec>(
filtered_codecs, other_video_codecs, field_trials);
}
if (session_options.raw_packetization_for_video) {
@ -2895,13 +2932,15 @@ bool MediaSessionDescriptionFactory::AddUnsupportedContentForAnswer(
}
void MediaSessionDescriptionFactory::ComputeAudioCodecsIntersectionAndUnion() {
const webrtc::WebRtcKeyValueConfig* field_trials =
&transport_desc_factory_->trials();
audio_sendrecv_codecs_.clear();
all_audio_codecs_.clear();
// Compute the audio codecs union.
for (const AudioCodec& send : audio_send_codecs_) {
all_audio_codecs_.push_back(send);
if (!FindMatchingCodec<AudioCodec>(audio_send_codecs_, audio_recv_codecs_,
send, nullptr)) {
send, nullptr, field_trials)) {
// It doesn't make sense to have an RTX codec we support sending but not
// receiving.
RTC_DCHECK(!IsRtxCodec(send));
@ -2909,7 +2948,7 @@ void MediaSessionDescriptionFactory::ComputeAudioCodecsIntersectionAndUnion() {
}
for (const AudioCodec& recv : audio_recv_codecs_) {
if (!FindMatchingCodec<AudioCodec>(audio_recv_codecs_, audio_send_codecs_,
recv, nullptr)) {
recv, nullptr, field_trials)) {
all_audio_codecs_.push_back(recv);
}
}
@ -2919,15 +2958,17 @@ void MediaSessionDescriptionFactory::ComputeAudioCodecsIntersectionAndUnion() {
// expensive than decoding, and prioritizing a codec in the send list probably
// means it's a codec we can handle efficiently.
NegotiateCodecs(audio_recv_codecs_, audio_send_codecs_,
&audio_sendrecv_codecs_, true);
&audio_sendrecv_codecs_, true, field_trials);
}
void MediaSessionDescriptionFactory::ComputeVideoCodecsIntersectionAndUnion() {
const webrtc::WebRtcKeyValueConfig* field_trials =
&transport_desc_factory_->trials();
video_sendrecv_codecs_.clear();
// Use ComputeCodecsUnion to avoid having duplicate payload IDs
all_video_codecs_ =
ComputeCodecsUnion(video_recv_codecs_, video_send_codecs_);
ComputeCodecsUnion(video_recv_codecs_, video_send_codecs_, field_trials);
// Use NegotiateCodecs to merge our codec lists, since the operation is
// essentially the same. Put send_codecs as the offered_codecs, which is the
@ -2935,7 +2976,7 @@ void MediaSessionDescriptionFactory::ComputeVideoCodecsIntersectionAndUnion() {
// expensive than decoding, and prioritizing a codec in the send list probably
// means it's a codec we can handle efficiently.
NegotiateCodecs(video_recv_codecs_, video_send_codecs_,
&video_sendrecv_codecs_, true);
&video_sendrecv_codecs_, true, field_trials);
}
bool IsMediaContent(const ContentInfo* content) {

14
pc/media_session_unittest.cc
View File

@ -4454,13 +4454,14 @@ namespace {
// Compare the two vectors of codecs ignoring the payload type.
template <class Codec>
bool CodecsMatch(const std::vector<Codec>& codecs1,
const std::vector<Codec>& codecs2) {
const std::vector<Codec>& codecs2,
const webrtc::WebRtcKeyValueConfig* field_trials) {
if (codecs1.size() != codecs2.size()) {
return false;
}
for (size_t i = 0; i < codecs1.size(); ++i) {
if (!codecs1[i].Matches(codecs2[i])) {
if (!codecs1[i].Matches(codecs2[i], field_trials)) {
return false;
}
}
@ -4503,11 +4504,14 @@ void TestAudioCodecsOffer(RtpTransceiverDirection direction) {
// might eventually be used anything, but we don't know more at this
// moment.
if (acd->direction() == RtpTransceiverDirection::kSendOnly) {
EXPECT_TRUE(CodecsMatch<AudioCodec>(send_codecs, acd->codecs()));
EXPECT_TRUE(
CodecsMatch<AudioCodec>(send_codecs, acd->codecs(), &field_trials));
} else if (acd->direction() == RtpTransceiverDirection::kRecvOnly) {
EXPECT_TRUE(CodecsMatch<AudioCodec>(recv_codecs, acd->codecs()));
EXPECT_TRUE(
CodecsMatch<AudioCodec>(recv_codecs, acd->codecs(), &field_trials));
} else {
EXPECT_TRUE(CodecsMatch<AudioCodec>(sendrecv_codecs, acd->codecs()));
EXPECT_TRUE(CodecsMatch<AudioCodec>(sendrecv_codecs, acd->codecs(),
&field_trials));
}
}
}

3
test/BUILD.gn
View File

@ -110,6 +110,7 @@ rtc_library("video_test_common") {
deps = [
":fileutils",
":frame_utils",
":scoped_key_value_config",
"../api:array_view",
"../api:create_frame_generator",
"../api:frame_generator_api",
@ -178,6 +179,7 @@ if (!build_with_chromium) {
"vcm_capturer.h",
]
deps += [
":scoped_key_value_config",
"../api:scoped_refptr",
"../modules/video_capture:video_capture_module",
"../rtc_base:checks",
@ -524,6 +526,7 @@ if (rtc_include_tests && !build_with_chromium) {
":perf_test",
":rtc_expect_death",
":rtp_test_utils",
":scoped_key_value_config",
":test_common",
":test_main",
":test_support",