mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-12 21:30:45 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove use of ReceiveStreamRtpConfig:transport_cc

Browse source 
With this change, webrtc will send RTCP transport feedback for all received packets that have a transport sequence number, if the header extension
http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions is negotiated.
I.e the SDP attribute a=rtcp-fb:96 transport-cc is ignored.


Change-Id: I95d8d4405dc86a2f872f7883b7bafd623d5f7841

Bug: webrtc:14802
Change-Id: I95d8d4405dc86a2f872f7883b7bafd623d5f7841
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/290403
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Commit-Queue: Per Kjellander <perkj@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#38980}
This commit is contained in:
Per K 2023-01-02 16:57:18 +01:00 committed by WebRTC LUCI CQ
parent 0c2981364f
commit 97ba853295
33 changed files with 25 additions and 242 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
audio/audio_receive_stream.cc
View file

@ -38,7 +38,6 @@ std::string AudioReceiveStreamInterface::Config::Rtp::ToString() const {
rtc::SimpleStringBuilder ss(ss_buf);
ss << "{remote_ssrc: " << remote_ssrc;
ss << ", local_ssrc: " << local_ssrc;
ss << ", transport_cc: " << (transport_cc ? "on" : "off");
ss << ", nack: " << nack.ToString();
ss << ", extensions: [";
for (size_t i = 0; i < extensions.size(); ++i) {
@ -209,16 +208,6 @@ void AudioReceiveStreamImpl::Stop() {
audio_state()->RemoveReceivingStream(this);
}
bool AudioReceiveStreamImpl::transport_cc() const {
RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
return config_.rtp.transport_cc;
}
void AudioReceiveStreamImpl::SetTransportCc(bool transport_cc) {
RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
config_.rtp.transport_cc = transport_cc;
}
bool AudioReceiveStreamImpl::IsRunning() const {
RTC_DCHECK_RUN_ON(&worker_thread_checker_);
return playing_;

2
audio/audio_receive_stream.h
View file

@ -85,8 +85,6 @@ class AudioReceiveStreamImpl final : public webrtc::AudioReceiveStreamInterface,
// webrtc::AudioReceiveStreamInterface implementation.
void Start() override;
void Stop() override;
bool transport_cc() const override;
void SetTransportCc(bool transport_cc) override;
bool IsRunning() const override;
void SetDepacketizerToDecoderFrameTransformer(
rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)

4
audio/audio_receive_stream_unittest.cc
View file

@ -216,7 +216,7 @@ TEST(AudioReceiveStreamTest, ConfigToString) {
config.rtp.extensions.push_back(
RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelId));
EXPECT_EQ(
"{rtp: {remote_ssrc: 1234, local_ssrc: 5678, transport_cc: off, nack: "
"{rtp: {remote_ssrc: 1234, local_ssrc: 5678, nack: "
"{rtp_history_ms: 0}, extensions: [{uri: "
"urn:ietf:params:rtp-hdrext:ssrc-audio-level, id: 3}]}, "
"rtcp_send_transport: null}",
@ -234,7 +234,6 @@ TEST(AudioReceiveStreamTest, ConstructDestruct) {
TEST(AudioReceiveStreamTest, ReceiveRtcpPacket) {
for (bool use_null_audio_processing : {false, true}) {
ConfigHelper helper(use_null_audio_processing);
helper.config().rtp.transport_cc = true;
auto recv_stream = helper.CreateAudioReceiveStream();
std::vector<uint8_t> rtcp_packet = CreateRtcpSenderReport();
EXPECT_CALL(*helper.channel_receive(),
@ -403,7 +402,6 @@ TEST(AudioReceiveStreamTest, ReconfigureWithUpdatedConfig) {
recv_stream->SetDecoderMap(new_config.decoder_map);
EXPECT_CALL(channel_receive, SetNACKStatus(true, 15 + 1)).Times(1);
recv_stream->SetTransportCc(new_config.rtp.transport_cc);
recv_stream->SetNackHistory(300 + 20);
recv_stream->UnregisterFromTransport();

1
audio/test/audio_bwe_integration_test.cc
View file

@ -115,7 +115,6 @@ class NoBandwidthDropAfterDtx : public AudioBweTest {
RtpExtension(RtpExtension::kTransportSequenceNumberUri,
kTransportSequenceNumberExtensionId));
for (AudioReceiveStreamInterface::Config& recv_config : *receive_configs) {
recv_config.rtp.transport_cc = true;
recv_config.rtp.extensions = send_config->rtp.extensions;
recv_config.rtp.remote_ssrc = send_config->rtp.ssrc;
}

8
call/call.cc
View file

@ -84,11 +84,6 @@ bool HasTransportSequenceNumber(const RtpHeaderExtensionMap& map) {
map.IsRegistered(kRtpExtensionTransportSequenceNumber02);
}
bool UseSendSideBwe(const ReceiveStreamInterface* stream) {
return stream->transport_cc() &&
HasTransportSequenceNumber(stream->GetRtpExtensionMap());
}
const int* FindKeyByValue(const std::map<int, int>& m, int v) {
for (const auto& kv : m) {
if (kv.second == v)
@ -1553,7 +1548,8 @@ bool Call::IdentifyReceivedPacket(RtpPacketReceived& packet,
packet.IdentifyExtensions(it->second->GetRtpExtensionMap());
if (use_send_side_bwe) {
*use_send_side_bwe = UseSendSideBwe(it->second);
*use_send_side_bwe =
HasTransportSequenceNumber(it->second->GetRtpExtensionMap());
}
return true;

2
call/flexfec_receive_stream_impl.cc
View file

@ -42,7 +42,6 @@ std::string FlexfecReceiveStream::Config::ToString() const {
ss << protected_media_ssrcs[i] << ", ";
if (!protected_media_ssrcs.empty())
ss << protected_media_ssrcs[i];
ss << "], transport_cc: " << (rtp.transport_cc ? "on" : "off");
ss << ", rtp.extensions: [";
i = 0;
for (; i + 1 < rtp.extensions.size(); ++i)
@ -133,7 +132,6 @@ FlexfecReceiveStreamImpl::FlexfecReceiveStreamImpl(
RtcpRttStats* rtt_stats)
: extension_map_(std::move(config.rtp.extensions)),
remote_ssrc_(config.rtp.remote_ssrc),
transport_cc_(config.rtp.transport_cc),
payload_type_(config.payload_type),
receiver_(
MaybeCreateFlexfecReceiver(clock, config, recovered_packet_receiver)),

11
call/flexfec_receive_stream_impl.h
View file

@ -69,16 +69,6 @@ class FlexfecReceiveStreamImpl : public FlexfecReceiveStream {
uint32_t remote_ssrc() const { return remote_ssrc_; }
bool transport_cc() const override {
RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
return transport_cc_;
}
void SetTransportCc(bool transport_cc) override {
RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
transport_cc_ = transport_cc;
}
void SetRtcpMode(RtcpMode mode) override {
RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
rtp_rtcp_->SetRTCPStatus(mode);
@ -90,7 +80,6 @@ class FlexfecReceiveStreamImpl : public FlexfecReceiveStream {
RtpHeaderExtensionMap extension_map_;
const uint32_t remote_ssrc_;
bool transport_cc_ RTC_GUARDED_BY(packet_sequence_checker_);
// `payload_type_` is initially set to -1, indicating that FlexFec is
// disabled.

1
call/flexfec_receive_stream_unittest.cc
View file

@ -66,7 +66,6 @@ TEST(FlexfecReceiveStreamConfigTest, IsCompleteAndEnabled) {
config.rtp.local_ssrc = 18374743;
config.rtcp_mode = RtcpMode::kCompound;
config.rtp.transport_cc = true;
config.rtp.extensions.emplace_back(TransportSequenceNumber::Uri(), 7);
EXPECT_FALSE(config.IsCompleteAndEnabled());

10
call/rampup_tests.cc
View file

@ -188,17 +188,13 @@ void RampUpTester::ModifyVideoConfigs(
send_config->rtp.extensions.clear();
bool transport_cc;
if (extension_type_ == RtpExtension::kAbsSendTimeUri) {
transport_cc = false;
send_config->rtp.extensions.push_back(
RtpExtension(extension_type_.c_str(), kAbsSendTimeExtensionId));
} else if (extension_type_ == RtpExtension::kTransportSequenceNumberUri) {
transport_cc = true;
send_config->rtp.extensions.push_back(RtpExtension(
extension_type_.c_str(), kTransportSequenceNumberExtensionId));
} else {
transport_cc = false;
send_config->rtp.extensions.push_back(RtpExtension(
extension_type_.c_str(), kTransmissionTimeOffsetExtensionId));
}
@ -221,7 +217,6 @@ void RampUpTester::ModifyVideoConfigs(
size_t i = 0;
for (VideoReceiveStreamInterface::Config& recv_config : *receive_configs) {
recv_config.rtp.transport_cc = transport_cc;
recv_config.rtp.extensions = send_config->rtp.extensions;
recv_config.decoders.reserve(1);
recv_config.decoders[0].payload_type = send_config->rtp.payload_type;
@ -277,15 +272,12 @@ void RampUpTester::ModifyAudioConfigs(
send_config->min_bitrate_bps = 6000;
send_config->max_bitrate_bps = 60000;
bool transport_cc = false;
if (extension_type_ == RtpExtension::kTransportSequenceNumberUri) {
transport_cc = true;
send_config->rtp.extensions.push_back(RtpExtension(
extension_type_.c_str(), kTransportSequenceNumberExtensionId));
}
for (AudioReceiveStreamInterface::Config& recv_config : *receive_configs) {
recv_config.rtp.transport_cc = transport_cc;
recv_config.rtp.extensions = send_config->rtp.extensions;
recv_config.rtp.remote_ssrc = send_config->rtp.ssrc;
}
@ -301,11 +293,9 @@ void RampUpTester::ModifyFlexfecConfigs(
(*receive_configs)[0].protected_media_ssrcs = {video_ssrcs_[0]};
(*receive_configs)[0].rtp.local_ssrc = video_ssrcs_[0];
if (extension_type_ == RtpExtension::kAbsSendTimeUri) {
(*receive_configs)[0].rtp.transport_cc = false;
(*receive_configs)[0].rtp.extensions.push_back(
RtpExtension(extension_type_.c_str(), kAbsSendTimeExtensionId));
} else if (extension_type_ == RtpExtension::kTransportSequenceNumberUri) {
(*receive_configs)[0].rtp.transport_cc = true;
(*receive_configs)[0].rtp.extensions.push_back(RtpExtension(
extension_type_.c_str(), kTransportSequenceNumberExtensionId));
}

19
call/receive_stream.h
View file

@ -40,12 +40,9 @@ class ReceiveStreamInterface {
// that the value is read on (i.e. packet delivery).
uint32_t local_ssrc = 0;
// Enable feedback for send side bandwidth estimation.
// See
// https://tools.ietf.org/html/draft-holmer-rmcat-transport-wide-cc-extensions
// for details.
// This value may change mid-stream and must be done on the same thread
// that the value is read on (i.e. packet delivery).
// Deprecated. This flag has no effect.
// TODO(perkj, https://bugs.webrtc.org/14802): Remove this flag once no
// projects use it.
bool transport_cc = false;
// RTP header extensions used for the received stream.
@ -59,16 +56,6 @@ class ReceiveStreamInterface {
virtual void SetRtpExtensions(std::vector<RtpExtension> extensions) = 0;
virtual RtpHeaderExtensionMap GetRtpExtensionMap() const = 0;
// Returns a bool for whether feedback for send side bandwidth estimation is
// enabled. See
// https://tools.ietf.org/html/draft-holmer-rmcat-transport-wide-cc-extensions
// for details.
// This value may change mid-stream and must be done on the same thread
// that the value is read on (i.e. packet delivery).
virtual bool transport_cc() const = 0;
virtual void SetTransportCc(bool transport_cc) = 0;
protected:
virtual ~ReceiveStreamInterface() {}
};

1
call/video_receive_stream.cc
View file

@ -131,7 +131,6 @@ std::string VideoReceiveStreamInterface::Config::Rtp::ToString() const {
ss << "{receiver_reference_time_report: "
<< (rtcp_xr.receiver_reference_time_report ? "on" : "off");
ss << '}';
ss << ", transport_cc: " << (transport_cc ? "on" : "off");
ss << ", lntf: {enabled: " << (lntf.enabled ? "true" : "false") << '}';
ss << ", nack: {rtp_history_ms: " << nack.rtp_history_ms << '}';
ss << ", ulpfec_payload_type: " << ulpfec_payload_type;

12
media/engine/fake_webrtc_call.h
View file

@ -113,10 +113,6 @@ class FakeAudioReceiveStream final
config_.sync_group = std::string(sync_group);
}
bool transport_cc() const override { return config_.rtp.transport_cc; }
void SetTransportCc(bool transport_cc) override {
config_.rtp.transport_cc = transport_cc;
}
uint32_t remote_ssrc() const override { return config_.rtp.remote_ssrc; }
void Start() override { started_ = true; }
void Stop() override { started_ = false; }
@ -282,10 +278,6 @@ class FakeVideoReceiveStream final
// webrtc::VideoReceiveStreamInterface implementation.
void SetRtpExtensions(std::vector<webrtc::RtpExtension> extensions) override;
webrtc::RtpHeaderExtensionMap GetRtpExtensionMap() const override;
bool transport_cc() const override { return config_.rtp.transport_cc; }
void SetTransportCc(bool transport_cc) override {
config_.rtp.transport_cc = transport_cc;
}
void SetRtcpMode(webrtc::RtcpMode mode) override {
config_.rtp.rtcp_mode = mode;
}
@ -351,10 +343,6 @@ class FakeFlexfecReceiveStream final : public webrtc::FlexfecReceiveStream {
void SetRtpExtensions(std::vector<webrtc::RtpExtension> extensions) override;
webrtc::RtpHeaderExtensionMap GetRtpExtensionMap() const override;
bool transport_cc() const override { return config_.rtp.transport_cc; }
void SetTransportCc(bool transport_cc) override {
config_.rtp.transport_cc = transport_cc;
}
void SetRtcpMode(webrtc::RtcpMode mode) override { config_.rtcp_mode = mode; }
int payload_type() const override { return config_.payload_type; }

20
media/engine/webrtc_video_engine.cc
View file

@ -998,7 +998,6 @@ bool WebRtcVideoChannel::ApplyChangedParams(
RTC_DCHECK(kv.second != nullptr);
kv.second->SetFeedbackParameters(
HasLntf(send_codec_->codec), HasNack(send_codec_->codec),
HasTransportCc(send_codec_->codec),
send_params_.rtcp.reduced_size ? webrtc::RtcpMode::kReducedSize
: webrtc::RtcpMode::kCompound,
send_codec_->rtx_time);
@ -1515,10 +1514,6 @@ void WebRtcVideoChannel::ConfigureReceiverRtp(
if (send_codec_ && send_codec_->rtx_time != -1) {
config->rtp.nack.rtp_history_ms = send_codec_->rtx_time;
}
config->rtp.transport_cc =
send_codec_ ? HasTransportCc(send_codec_->codec) : false;
sp.GetFidSsrc(ssrc, &config->rtp.rtx_ssrc);
config->rtp.extensions = recv_rtp_extensions_;
@ -1530,9 +1525,6 @@ void WebRtcVideoChannel::ConfigureReceiverRtp(
flexfec_config->protected_media_ssrcs = {ssrc};
flexfec_config->rtp.local_ssrc = config->rtp.local_ssrc;
flexfec_config->rtcp_mode = config->rtp.rtcp_mode;
// TODO(brandtr): We should be spec-compliant and set `transport_cc` here
// based on the rtcp-fb for the FlexFEC codec, not the media codec.
flexfec_config->rtp.transport_cc = config->rtp.transport_cc;
flexfec_config->rtp.extensions = config->rtp.extensions;
}
}
@ -2986,7 +2978,6 @@ bool WebRtcVideoChannel::WebRtcVideoReceiveStream::ReconfigureCodecs(
void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetFeedbackParameters(
bool lntf_enabled,
bool nack_enabled,
bool transport_cc_enabled,
webrtc::RtcpMode rtcp_mode,
int rtx_time) {
RTC_DCHECK(stream_);
@ -3001,17 +2992,6 @@ void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetFeedbackParameters(
}
}
if (config_.rtp.transport_cc != transport_cc_enabled) {
config_.rtp.transport_cc = transport_cc_enabled;
stream_->SetTransportCc(transport_cc_enabled);
// TODO(brandtr): We should be spec-compliant and set `transport_cc` here
// based on the rtcp-fb for the FlexFEC codec, not the media codec.
flexfec_config_.rtp.transport_cc = transport_cc_enabled;
if (flexfec_stream_) {
flexfec_stream_->SetTransportCc(transport_cc_enabled);
}
}
config_.rtp.lntf.enabled = lntf_enabled;
stream_->SetLossNotificationEnabled(lntf_enabled);

1
media/engine/webrtc_video_engine.h
View file

@ -487,7 +487,6 @@ class WebRtcVideoChannel : public VideoMediaChannel,
// TODO(deadbeef): Move these feedback parameters into the recv parameters.
void SetFeedbackParameters(bool lntf_enabled,
bool nack_enabled,
bool transport_cc_enabled,
webrtc::RtcpMode rtcp_mode,
int rtx_time);
void SetRecvParameters(const ChangedRecvParameters& recv_params);

30
media/engine/webrtc_video_engine_unittest.cc
View file

@ -3107,32 +3107,6 @@ TEST_F(WebRtcVideoChannelTest, RtcpIsCompoundByDefault) {
EXPECT_EQ(webrtc::RtcpMode::kCompound, stream->GetConfig().rtp.rtcp_mode);
}
TEST_F(WebRtcVideoChannelTest, TransportCcIsEnabledByDefault) {
FakeVideoReceiveStream* stream = AddRecvStream();
EXPECT_TRUE(stream->transport_cc());
}
TEST_F(WebRtcVideoChannelTest, TransportCcCanBeEnabledAndDisabled) {
FakeVideoReceiveStream* stream = AddRecvStream();
EXPECT_TRUE(stream->transport_cc());
// Verify that transport cc feedback is turned off when send(!) codecs without
// transport cc feedback are set.
cricket::VideoSendParameters parameters;
parameters.codecs.push_back(RemoveFeedbackParams(GetEngineCodec("VP8")));
EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty());
EXPECT_TRUE(channel_->SetSendParameters(parameters));
stream = fake_call_->GetVideoReceiveStreams()[0];
EXPECT_FALSE(stream->transport_cc());
// Verify that transport cc feedback is turned on when setting default codecs
// since the default codecs have transport cc feedback enabled.
parameters.codecs = engine_.send_codecs();
EXPECT_TRUE(channel_->SetSendParameters(parameters));
stream = fake_call_->GetVideoReceiveStreams()[0];
EXPECT_TRUE(stream->transport_cc());
}
TEST_F(WebRtcVideoChannelTest, LossNotificationIsDisabledByDefault) {
TestLossNotificationState(false);
}
@ -4414,10 +4388,6 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetRecvCodecsWithFec) {
EXPECT_EQ(video_stream_config.rtp.rtcp_mode, flexfec_stream_config.rtcp_mode);
EXPECT_EQ(video_stream_config.rtcp_send_transport,
flexfec_stream_config.rtcp_send_transport);
// TODO(brandtr): Update this EXPECT when we set `transport_cc` in a
// spec-compliant way.
EXPECT_EQ(video_stream_config.rtp.transport_cc,
flexfec_stream_config.rtp.transport_cc);
EXPECT_EQ(video_stream_config.rtp.rtcp_mode, flexfec_stream_config.rtcp_mode);
EXPECT_EQ(video_stream_config.rtp.extensions,
flexfec_stream_config.rtp.extensions);

24
media/engine/webrtc_voice_engine.cc
View file

@ -247,7 +247,6 @@ struct AdaptivePtimeConfig {
webrtc::AudioReceiveStreamInterface::Config BuildReceiveStreamConfig(
uint32_t remote_ssrc,
uint32_t local_ssrc,
bool use_transport_cc,
bool use_nack,
bool enable_non_sender_rtt,
const std::vector<std::string>& stream_ids,
@ -265,7 +264,6 @@ webrtc::AudioReceiveStreamInterface::Config BuildReceiveStreamConfig(
webrtc::AudioReceiveStreamInterface::Config config;
config.rtp.remote_ssrc = remote_ssrc;
config.rtp.local_ssrc = local_ssrc;
config.rtp.transport_cc = use_transport_cc;
config.rtp.nack.rtp_history_ms = use_nack ? kNackRtpHistoryMs : 0;
if (!stream_ids.empty()) {
config.sync_group = stream_ids[0];
@ -1163,9 +1161,8 @@ class WebRtcVoiceMediaChannel::WebRtcAudioReceiveStream {
stream_->SetFrameDecryptor(std::move(frame_decryptor));
}
void SetUseTransportCc(bool use_transport_cc, bool use_nack) {
void SetUseNack(bool use_nack) {
RTC_DCHECK_RUN_ON(&worker_thread_checker_);
stream_->SetTransportCc(use_transport_cc);
stream_->SetNackHistory(use_nack ? kNackRtpHistoryMs : 0);
}
@ -1740,17 +1737,13 @@ bool WebRtcVoiceMediaChannel::SetSendCodecs(
}
call_->GetTransportControllerSend()->SetSdpBitrateParameters(bitrate_config);
// Check if the transport cc feedback or NACK status has changed on the
// Check if the NACK status has changed on the
// preferred send codec, and in that case reconfigure all receive streams.
if (recv_transport_cc_enabled_ != send_codec_spec_->transport_cc_enabled ||
recv_nack_enabled_ != send_codec_spec_->nack_enabled) {
RTC_LOG(LS_INFO) << "Changing transport cc and NACK status on receive "
"streams.";
recv_transport_cc_enabled_ = send_codec_spec_->transport_cc_enabled;
if (recv_nack_enabled_ != send_codec_spec_->nack_enabled) {
RTC_LOG(LS_INFO) << "Changing NACK status on receive streams.";
recv_nack_enabled_ = send_codec_spec_->nack_enabled;
for (auto& kv : recv_streams_) {
kv.second->SetUseTransportCc(recv_transport_cc_enabled_,
recv_nack_enabled_);
kv.second->SetUseNack(recv_nack_enabled_);
}
}
@ -1928,10 +1921,9 @@ bool WebRtcVoiceMediaChannel::AddRecvStream(const StreamParams& sp) {
// Create a new channel for receiving audio data.
auto config = BuildReceiveStreamConfig(
ssrc, receiver_reports_ssrc_, recv_transport_cc_enabled_,
recv_nack_enabled_, enable_non_sender_rtt_, sp.stream_ids(),
recv_rtp_extensions_, this, engine()->decoder_factory_, decoder_map_,
codec_pair_id_, engine()->audio_jitter_buffer_max_packets_,
ssrc, receiver_reports_ssrc_, recv_nack_enabled_, enable_non_sender_rtt_,
sp.stream_ids(), recv_rtp_extensions_, this, engine()->decoder_factory_,
decoder_map_, codec_pair_id_, engine()->audio_jitter_buffer_max_packets_,
engine()->audio_jitter_buffer_fast_accelerate_,
engine()->audio_jitter_buffer_min_delay_ms_, unsignaled_frame_decryptor_,
crypto_options_, unsignaled_frame_transformer_);

1
media/engine/webrtc_voice_engine.h
View file

@ -270,7 +270,6 @@ class WebRtcVoiceMediaChannel final : public VoiceMediaChannel,
AudioOptions options_;
absl::optional<int> dtmf_payload_type_;
int dtmf_payload_freq_ = -1;
bool recv_transport_cc_enabled_ = false;
bool recv_nack_enabled_ = false;
bool enable_non_sender_rtt_ = false;
bool playout_ = false;

21
media/engine/webrtc_voice_engine_unittest.cc
View file

@ -842,7 +842,6 @@ TEST_P(WebRtcVoiceEngineTestFake, CreateRecvStream) {
GetRecvStreamConfig(kSsrcX);
EXPECT_EQ(kSsrcX, config.rtp.remote_ssrc);
EXPECT_EQ(0xFA17FA17, config.rtp.local_ssrc);
EXPECT_FALSE(config.rtp.transport_cc);
EXPECT_EQ(0u, config.rtp.extensions.size());
EXPECT_EQ(static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_),
config.rtcp_send_transport);
@ -1866,26 +1865,6 @@ TEST_P(WebRtcVoiceEngineTestFake, AddRecvStreamEnableNack) {
EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcZ).rtp.nack.rtp_history_ms);
}
TEST_P(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) {
EXPECT_TRUE(SetupChannel());
cricket::AudioSendParameters send_parameters;
send_parameters.codecs.push_back(kOpusCodec);
EXPECT_TRUE(send_parameters.codecs[0].feedback_params.params().empty());
SetSendParameters(send_parameters);
cricket::AudioRecvParameters recv_parameters;
recv_parameters.codecs.push_back(kOpusCodec);
EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters));
EXPECT_TRUE(AddRecvStream(kSsrcX));
ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrcX) != nullptr);
EXPECT_FALSE(call_.GetAudioReceiveStream(kSsrcX)->transport_cc());
send_parameters.codecs = engine_->send_codecs();
SetSendParameters(send_parameters);
ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrcX) != nullptr);
EXPECT_TRUE(call_.GetAudioReceiveStream(kSsrcX)->transport_cc());
}
// Test that we can switch back and forth between Opus and PCMU with CN.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsOpusPcmuSwitching) {
EXPECT_TRUE(SetupSendStream());

2
test/call_config_utils.cc
View file

@ -43,7 +43,6 @@ VideoReceiveStreamInterface::Config ParseVideoReceiveStreamJsonConfig(
json["rtp"]["rtcp_mode"].asString() == "RtcpMode::kCompound"
? RtcpMode::kCompound
: RtcpMode::kReducedSize;
receive_config.rtp.transport_cc = json["rtp"]["transport_cc"].asBool();
receive_config.rtp.lntf.enabled = json["rtp"]["lntf"]["enabled"].asInt64();
receive_config.rtp.nack.rtp_history_ms =
json["rtp"]["nack"]["rtp_history_ms"].asInt64();
@ -92,7 +91,6 @@ Json::Value GenerateVideoReceiveStreamJsonConfig(
rtp_json["rtcp_mode"] = config.rtp.rtcp_mode == RtcpMode::kCompound
? "RtcpMode::kCompound"
: "RtcpMode::kReducedSize";
rtp_json["transport_cc"] = config.rtp.transport_cc;
rtp_json["lntf"]["enabled"] = config.rtp.lntf.enabled;
rtp_json["nack"]["rtp_history_ms"] = config.rtp.nack.rtp_history_ms;
rtp_json["ulpfec_payload_type"] = config.rtp.ulpfec_payload_type;

2
test/call_config_utils_unittest.cc
View file

@ -28,7 +28,6 @@ TEST(CallConfigUtils, MarshalUnmarshalProcessSameObject) {
recv_config.rtp.remote_ssrc = 100;
recv_config.rtp.local_ssrc = 101;
recv_config.rtp.rtcp_mode = RtcpMode::kCompound;
recv_config.rtp.transport_cc = false;
recv_config.rtp.lntf.enabled = false;
recv_config.rtp.nack.rtp_history_ms = 150;
recv_config.rtp.red_payload_type = 50;
@ -50,7 +49,6 @@ TEST(CallConfigUtils, MarshalUnmarshalProcessSameObject) {
EXPECT_EQ(recv_config.rtp.remote_ssrc, unmarshaled_config.rtp.remote_ssrc);
EXPECT_EQ(recv_config.rtp.local_ssrc, unmarshaled_config.rtp.local_ssrc);
EXPECT_EQ(recv_config.rtp.rtcp_mode, unmarshaled_config.rtp.rtcp_mode);
EXPECT_EQ(recv_config.rtp.transport_cc, unmarshaled_config.rtp.transport_cc);
EXPECT_EQ(recv_config.rtp.lntf.enabled, unmarshaled_config.rtp.lntf.enabled);
EXPECT_EQ(recv_config.rtp.nack.rtp_history_ms,
unmarshaled_config.rtp.nack.rtp_history_ms);

13
test/call_test.cc
View file

@ -334,36 +334,33 @@ void CallTest::CreateMatchingVideoReceiveConfigs(
const VideoSendStream::Config& video_send_config,
Transport* rtcp_send_transport) {
CreateMatchingVideoReceiveConfigs(video_send_config, rtcp_send_transport,
true, &fake_decoder_factory_, absl::nullopt,
&fake_decoder_factory_, absl::nullopt,
false, 0);
}
void CallTest::CreateMatchingVideoReceiveConfigs(
const VideoSendStream::Config& video_send_config,
Transport* rtcp_send_transport,
bool send_side_bwe,
VideoDecoderFactory* decoder_factory,
absl::optional<size_t> decode_sub_stream,
bool receiver_reference_time_report,
int rtp_history_ms) {
AddMatchingVideoReceiveConfigs(
&video_receive_configs_, video_send_config, rtcp_send_transport,
send_side_bwe, decoder_factory, decode_sub_stream,
receiver_reference_time_report, rtp_history_ms);
decoder_factory, decode_sub_stream, receiver_reference_time_report,
rtp_history_ms);
}
void CallTest::AddMatchingVideoReceiveConfigs(
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
const VideoSendStream::Config& video_send_config,
Transport* rtcp_send_transport,
bool send_side_bwe,
VideoDecoderFactory* decoder_factory,
absl::optional<size_t> decode_sub_stream,
bool receiver_reference_time_report,
int rtp_history_ms) {
RTC_DCHECK(!video_send_config.rtp.ssrcs.empty());
VideoReceiveStreamInterface::Config default_config(rtcp_send_transport);
default_config.rtp.transport_cc = send_side_bwe;
default_config.rtp.local_ssrc = kReceiverLocalVideoSsrc;
for (const RtpExtension& extension : video_send_config.rtp.extensions)
default_config.rtp.extensions.push_back(extension);
@ -429,10 +426,6 @@ AudioReceiveStreamInterface::Config CallTest::CreateMatchingAudioConfig(
audio_config.rtp.local_ssrc = kReceiverLocalAudioSsrc;
audio_config.rtcp_send_transport = transport;
audio_config.rtp.remote_ssrc = send_config.rtp.ssrc;
audio_config.rtp.transport_cc =
send_config.send_codec_spec
? send_config.send_codec_spec->transport_cc_enabled
: false;
audio_config.rtp.extensions = send_config.rtp.extensions;
audio_config.decoder_factory = audio_decoder_factory;
audio_config.decoder_map = {{kAudioSendPayloadType, {"opus", 48000, 2}}};

2
test/call_test.h
View file

@ -113,7 +113,6 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
void CreateMatchingVideoReceiveConfigs(
const VideoSendStream::Config& video_send_config,
Transport* rtcp_send_transport,
bool send_side_bwe,
VideoDecoderFactory* decoder_factory,
absl::optional<size_t> decode_sub_stream,
bool receiver_reference_time_report,
@ -122,7 +121,6 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
const VideoSendStream::Config& video_send_config,
Transport* rtcp_send_transport,
bool send_side_bwe,
VideoDecoderFactory* decoder_factory,
absl::optional<size_t> decode_sub_stream,
bool receiver_reference_time_report,

1
test/fuzzers/vp8_replay_fuzzer.cc
View file

@ -29,7 +29,6 @@ void FuzzOneInput(const uint8_t* data, size_t size) {
vp8_config.rtp.local_ssrc = 7731;
vp8_config.rtp.remote_ssrc = 1337;
vp8_config.rtp.rtx_ssrc = 100;
vp8_config.rtp.transport_cc = true;
vp8_config.rtp.nack.rtp_history_ms = 1000;
vp8_config.rtp.lntf.enabled = true;

1
test/fuzzers/vp9_replay_fuzzer.cc
View file

@ -29,7 +29,6 @@ void FuzzOneInput(const uint8_t* data, size_t size) {
vp9_config.rtp.local_ssrc = 7731;
vp9_config.rtp.remote_ssrc = 1337;
vp9_config.rtp.rtx_ssrc = 100;
vp9_config.rtp.transport_cc = true;
vp9_config.rtp.nack.rtp_history_ms = 1000;
std::vector<VideoReceiveStreamInterface::Config> replay_configs;

1
test/scenario/audio_stream.cc
View file

@ -180,7 +180,6 @@ ReceiveAudioStream::ReceiveAudioStream(
recv_config.rtp.remote_ssrc = send_stream->ssrc_;
receiver->ssrc_media_types_[recv_config.rtp.remote_ssrc] = MediaType::AUDIO;
if (config.stream.in_bandwidth_estimation) {
recv_config.rtp.transport_cc = true;
recv_config.rtp.extensions = {{RtpExtension::kTransportSequenceNumberUri,
kTransportSequenceNumberExtensionId}};
}

1
test/scenario/video_stream.cc
View file

@ -329,7 +329,6 @@ VideoReceiveStreamInterface::Config CreateVideoReceiveStreamConfig(
uint32_t ssrc,
uint32_t rtx_ssrc) {
VideoReceiveStreamInterface::Config recv(feedback_transport);
recv.rtp.transport_cc = config.stream.packet_feedback;
recv.rtp.local_ssrc = local_ssrc;
recv.rtp.extensions = GetVideoRtpExtensions(config);

3
video/end_to_end_tests/bandwidth_tests.cc
View file

@ -55,7 +55,6 @@ TEST_F(BandwidthEndToEndTest, ReceiveStreamSendsRemb) {
send_config->rtp.extensions.clear();
send_config->rtp.extensions.push_back(
RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId));
(*receive_configs)[0].rtp.transport_cc = false;
}
Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
@ -106,12 +105,10 @@ class BandwidthStatsTest : public test::EndToEndTest {
if (!send_side_bwe_) {
send_config->rtp.extensions.push_back(
RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId));
(*receive_configs)[0].rtp.transport_cc = false;
} else {
send_config->rtp.extensions.push_back(
RtpExtension(RtpExtension::kTransportSequenceNumberUri,
kTransportSequenceNumberId));
(*receive_configs)[0].rtp.transport_cc = true;
}
// Force a too high encoder bitrate to make sure we get pacer delay.

1
video/end_to_end_tests/rtp_rtcp_tests.cc
View file

@ -540,7 +540,6 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
flexfec_receive_config.protected_media_ssrcs =
GetVideoSendConfig()->rtp.flexfec.protected_media_ssrcs;
flexfec_receive_config.rtp.local_ssrc = kReceiverLocalVideoSsrc;
flexfec_receive_config.rtp.transport_cc = true;
flexfec_receive_config.rtp.extensions.emplace_back(
RtpExtension::kTransportSequenceNumberUri,
kTransportSequenceNumberExtensionId);

37
video/end_to_end_tests/transport_feedback_tests.cc
View file

@ -244,11 +244,8 @@ class TransportFeedbackEndToEndTest : public test::CallTest {
class TransportFeedbackTester : public test::EndToEndTest {
public:
TransportFeedbackTester(bool feedback_enabled,
size_t num_video_streams,
size_t num_audio_streams)
TransportFeedbackTester(size_t num_video_streams, size_t num_audio_streams)
: EndToEndTest(::webrtc::TransportFeedbackEndToEndTest::kDefaultTimeout),
feedback_enabled_(feedback_enabled),
num_video_streams_(num_video_streams),
num_audio_streams_(num_audio_streams),
receiver_call_(nullptr) {
@ -276,11 +273,7 @@ class TransportFeedbackTester : public test::EndToEndTest {
}
void PerformTest() override {
constexpr TimeDelta kDisabledFeedbackTimeout = TimeDelta::Seconds(5);
EXPECT_EQ(feedback_enabled_,
observation_complete_.Wait(feedback_enabled_
? test::CallTest::kDefaultTimeout
: kDisabledFeedbackTimeout));
EXPECT_TRUE(observation_complete_.Wait(test::CallTest::kDefaultTimeout));
}
void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
@ -290,13 +283,6 @@ class TransportFeedbackTester : public test::EndToEndTest {
size_t GetNumVideoStreams() const override { return num_video_streams_; }
size_t GetNumAudioStreams() const override { return num_audio_streams_; }
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
(*receive_configs)[0].rtp.transport_cc = feedback_enabled_;
}
void ModifyAudioConfigs(AudioSendStream::Config* send_config,
std::vector<AudioReceiveStreamInterface::Config>*
receive_configs) override {
@ -306,38 +292,25 @@ class TransportFeedbackTester : public test::EndToEndTest {
kTransportSequenceNumberExtensionId));
(*receive_configs)[0].rtp.extensions.clear();
(*receive_configs)[0].rtp.extensions = send_config->rtp.extensions;
(*receive_configs)[0].rtp.transport_cc = feedback_enabled_;
}
private:
const bool feedback_enabled_;
const size_t num_video_streams_;
const size_t num_audio_streams_;
Call* receiver_call_;
};
TEST_F(TransportFeedbackEndToEndTest, VideoReceivesTransportFeedback) {
TransportFeedbackTester test(true, 1, 0);
TransportFeedbackTester test(1, 0);
RunBaseTest(&test);
}
TEST_F(TransportFeedbackEndToEndTest, VideoTransportFeedbackNotConfigured) {
TransportFeedbackTester test(false, 1, 0);
RunBaseTest(&test);
}
TEST_F(TransportFeedbackEndToEndTest, AudioReceivesTransportFeedback) {
TransportFeedbackTester test(true, 0, 1);
RunBaseTest(&test);
}
TEST_F(TransportFeedbackEndToEndTest, AudioTransportFeedbackNotConfigured) {
TransportFeedbackTester test(false, 0, 1);
TransportFeedbackTester test(0, 1);
RunBaseTest(&test);
}
TEST_F(TransportFeedbackEndToEndTest, AudioVideoReceivesTransportFeedback) {
TransportFeedbackTester test(true, 1, 1);
TransportFeedbackTester test(1, 1);
RunBaseTest(&test);
}

9
video/video_quality_test.cc
View file

@ -827,9 +827,8 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
if (!decode_all_receive_streams)
decode_sub_stream = params_.ss[video_idx].selected_stream;
CreateMatchingVideoReceiveConfigs(
video_send_configs_[video_idx], recv_transport,
params_.call.send_side_bwe, &video_decoder_factory_, decode_sub_stream,
true, kNackRtpHistoryMs);
video_send_configs_[video_idx], recv_transport, &video_decoder_factory_,
decode_sub_stream, true, kNackRtpHistoryMs);
if (params_.screenshare[video_idx].enabled) {
// Fill out codec settings.
@ -934,7 +933,6 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
}
CreateMatchingFecConfig(recv_transport, *GetVideoSendConfig());
GetFlexFecConfig()->rtp.transport_cc = params_.call.send_side_bwe;
if (params_.call.send_side_bwe) {
GetFlexFecConfig()->rtp.extensions.push_back(
RtpExtension(RtpExtension::kTransportSequenceNumberUri,
@ -1002,8 +1000,7 @@ void VideoQualityTest::SetupThumbnails(Transport* send_transport,
AddMatchingVideoReceiveConfigs(
&thumbnail_receive_configs_, thumbnail_send_config, send_transport,
params_.call.send_side_bwe, &video_decoder_factory_, absl::nullopt,
false, kNackRtpHistoryMs);
&video_decoder_factory_, absl::nullopt, false, kNackRtpHistoryMs);
}
for (size_t i = 0; i < thumbnail_send_configs_.size(); ++i) {
thumbnail_send_streams_.push_back(receiver_call_->CreateVideoSendStream(

11
video/video_receive_stream2.cc
View file

@ -463,17 +463,6 @@ RtpHeaderExtensionMap VideoReceiveStream2::GetRtpExtensionMap() const {
return rtp_video_stream_receiver_.GetRtpExtensions();
}
bool VideoReceiveStream2::transport_cc() const {
RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
return config_.rtp.transport_cc;
}
void VideoReceiveStream2::SetTransportCc(bool transport_cc) {
RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
// TODO(tommi): Stop using the config struct for the internal state.
const_cast<bool&>(config_.rtp.transport_cc) = transport_cc;
}
void VideoReceiveStream2::SetRtcpMode(RtcpMode mode) {
RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
// TODO(tommi): Stop using the config struct for the internal state.

2
video/video_receive_stream2.h
View file

@ -144,8 +144,6 @@ class VideoReceiveStream2
void SetRtpExtensions(std::vector<RtpExtension> extensions) override;
RtpHeaderExtensionMap GetRtpExtensionMap() const override;
bool transport_cc() const override;
void SetTransportCc(bool transport_cc) override;
void SetRtcpMode(RtcpMode mode) override;
void SetFlexFecProtection(RtpPacketSinkInterface* flexfec_sink) override;
void SetLossNotificationEnabled(bool enabled) override;

2
video/video_send_stream_tests.cc
View file

@ -1615,7 +1615,6 @@ TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
send_config->rtp.extensions.push_back(RtpExtension(
RtpExtension::kTransportSequenceNumberUri, kExtensionId));
(*receive_configs)[0].rtp.extensions = send_config->rtp.extensions;
(*receive_configs)[0].rtp.transport_cc = true;
}
void ModifyAudioConfigs(AudioSendStream::Config* send_config,
@ -1627,7 +1626,6 @@ TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
RtpExtension::kTransportSequenceNumberUri, kExtensionId));
(*receive_configs)[0].rtp.extensions.clear();
(*receive_configs)[0].rtp.extensions = send_config->rtp.extensions;
(*receive_configs)[0].rtp.transport_cc = true;
}
Action OnSendRtp(const uint8_t* packet, size_t length) override {