From a9d514136748df0083fbd67c8f96fb3e75b9d5b1 Mon Sep 17 00:00:00 2001 From: Philipp Hancke Date: Mon, 31 Jul 2023 13:27:37 +0200 Subject: [PATCH] Rename cricket::RtpParameters and derived classes Renames cricket::RtpParameters to cricket::MediaChannelParameters in order to distinguish it better from webrtc::RtpParameters. This involves renaming RtpSendParameters -> SenderParameters AudioSendParameters -> AudioSenderParameters AudioRecvParameters -> AudioReceiverParameters VideoSendParameters -> VideoSenderParameters VideoRecvParameters -> VideoReceiverParameters BUG=webrtc:13931 Change-Id: I664595ee3863418c0c6ca092ca77127be0f9498f Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/314360 Reviewed-by: Florent Castelli Reviewed-by: Harald Alvestrand Commit-Queue: Philipp Hancke Cr-Commit-Position: refs/heads/main@{#40497} --- media/base/fake_media_engine.cc | 8 +- media/base/fake_media_engine.h | 8 +- media/base/media_channel.h | 40 ++- media/base/media_channel_impl.cc | 16 +- media/engine/webrtc_video_engine.cc | 10 +- media/engine/webrtc_video_engine.h | 18 +- media/engine/webrtc_video_engine_unittest.cc | 260 +++++++++--------- media/engine/webrtc_voice_engine.cc | 4 +- media/engine/webrtc_voice_engine.h | 4 +- media/engine/webrtc_voice_engine_unittest.cc | 148 +++++----- pc/channel.cc | 26 +- pc/channel.h | 16 +- pc/rtp_sender_receiver_unittest.cc | 2 +- ...ck_voice_media_receive_channel_interface.h | 2 +- 14 files changed, 278 insertions(+), 284 deletions(-) diff --git a/media/base/fake_media_engine.cc b/media/base/fake_media_engine.cc index 02d94aae80..daf62894da 100644 --- a/media/base/fake_media_engine.cc +++ b/media/base/fake_media_engine.cc @@ -77,7 +77,7 @@ int FakeVoiceMediaReceiveChannel::max_bps() const { return max_bps_; } bool FakeVoiceMediaReceiveChannel::SetRecvParameters( - const AudioRecvParameters& params) { + const AudioReceiverParameters& params) { set_recv_rtcp_parameters(params.rtcp); return (SetRecvCodecs(params.codecs) && SetRecvRtpHeaderExtensions(params.extensions)); @@ -236,7 +236,7 @@ int FakeVoiceMediaSendChannel::max_bps() const { return max_bps_; } bool FakeVoiceMediaSendChannel::SetSendParameters( - const AudioSendParameters& params) { + const AudioSenderParameter& params) { set_send_rtcp_parameters(params.rtcp); SetExtmapAllowMixed(params.extmap_allow_mixed); return (SetSendCodecs(params.codecs) && @@ -356,7 +356,7 @@ int FakeVideoMediaSendChannel::max_bps() const { return max_bps_; } bool FakeVideoMediaSendChannel::SetSendParameters( - const VideoSendParameters& params) { + const VideoSenderParameters& params) { set_send_rtcp_parameters(params.rtcp); SetExtmapAllowMixed(params.extmap_allow_mixed); return (SetSendCodecs(params.codecs) && @@ -442,7 +442,7 @@ int FakeVideoMediaReceiveChannel::max_bps() const { return max_bps_; } bool FakeVideoMediaReceiveChannel::SetRecvParameters( - const VideoRecvParameters& params) { + const VideoReceiverParameters& params) { set_recv_rtcp_parameters(params.rtcp); return (SetRecvCodecs(params.codecs) && SetRecvRtpHeaderExtensions(params.extensions)); diff --git a/media/base/fake_media_engine.h b/media/base/fake_media_engine.h index 1fd95c9001..8525d0bfcf 100644 --- a/media/base/fake_media_engine.h +++ b/media/base/fake_media_engine.h @@ -469,7 +469,7 @@ class FakeVoiceMediaReceiveChannel return cricket::MEDIA_TYPE_AUDIO; } - bool SetRecvParameters(const AudioRecvParameters& params) override; + bool SetRecvParameters(const AudioReceiverParameters& params) override; void SetPlayout(bool playout) override; bool AddRecvStream(const StreamParams& sp) override; @@ -559,7 +559,7 @@ class FakeVoiceMediaSendChannel return cricket::MEDIA_TYPE_AUDIO; } - bool SetSendParameters(const AudioSendParameters& params) override; + bool SetSendParameters(const AudioSenderParameter& params) override; void SetSend(bool send) override; bool SetAudioSend(uint32_t ssrc, bool enable, @@ -644,7 +644,7 @@ class FakeVideoMediaReceiveChannel const std::map*>& sinks() const; int max_bps() const; - bool SetRecvParameters(const VideoRecvParameters& params) override; + bool SetRecvParameters(const VideoReceiverParameters& params) override; bool SetSink(uint32_t ssrc, rtc::VideoSinkInterface* sink) override; @@ -717,7 +717,7 @@ class FakeVideoMediaSendChannel const std::map*>& sinks() const; int max_bps() const; - bool SetSendParameters(const VideoSendParameters& params) override; + bool SetSendParameters(const VideoSenderParameters& params) override; absl::optional GetSendCodec() const override; diff --git a/media/base/media_channel.h b/media/base/media_channel.h index 92c7dff203..01aa2b251c 100644 --- a/media/base/media_channel.h +++ b/media/base/media_channel.h @@ -792,7 +792,7 @@ struct VideoMediaInfo { send_codecs.clear(); receive_codecs.clear(); } - // Each sender info represents one "outbound-rtp" stream.In non - simulcast, + // Each sender info represents one "outbound-rtp" stream. In non-simulcast, // this means one info per RtpSender but if simulcast is used this means // one info per simulcast layer. std::vector senders; @@ -811,8 +811,8 @@ struct RtcpParameters { bool remote_estimate = false; }; -struct RtpParameters { - virtual ~RtpParameters() = default; +struct MediaChannelParameters { + virtual ~MediaChannelParameters() = default; std::vector codecs; std::vector extensions; @@ -842,9 +842,7 @@ struct RtpParameters { } }; -// TODO(deadbeef): Rename to RtpSenderParameters, since they're intended to -// encapsulate all the parameters needed for an RtpSender. -struct RtpSendParameters : RtpParameters { +struct SenderParameters : MediaChannelParameters { int max_bandwidth_bps = -1; // This is the value to be sent in the MID RTP header extension (if the header // extension in included in the list of extensions). @@ -853,7 +851,7 @@ struct RtpSendParameters : RtpParameters { protected: std::map ToStringMap() const override { - auto params = RtpParameters::ToStringMap(); + auto params = MediaChannelParameters::ToStringMap(); params["max_bandwidth_bps"] = rtc::ToString(max_bandwidth_bps); params["mid"] = (mid.empty() ? "" : mid); params["extmap-allow-mixed"] = extmap_allow_mixed ? "true" : "false"; @@ -861,20 +859,20 @@ struct RtpSendParameters : RtpParameters { } }; -struct AudioSendParameters : RtpSendParameters { - AudioSendParameters(); - ~AudioSendParameters() override; +struct AudioSenderParameter : SenderParameters { + AudioSenderParameter(); + ~AudioSenderParameter() override; AudioOptions options; protected: std::map ToStringMap() const override; }; -struct AudioRecvParameters : RtpParameters {}; +struct AudioReceiverParameters : MediaChannelParameters {}; class VoiceMediaSendChannelInterface : public MediaSendChannelInterface { public: - virtual bool SetSendParameters(const AudioSendParameters& params) = 0; + virtual bool SetSendParameters(const AudioSenderParameter& params) = 0; // Starts or stops sending (and potentially capture) of local audio. virtual void SetSend(bool send) = 0; // Configure stream for sending. @@ -896,7 +894,7 @@ class VoiceMediaSendChannelInterface : public MediaSendChannelInterface { class VoiceMediaReceiveChannelInterface : public MediaReceiveChannelInterface { public: - virtual bool SetRecvParameters(const AudioRecvParameters& params) = 0; + virtual bool SetRecvParameters(const AudioReceiverParameters& params) = 0; // Get the receive parameters for the incoming stream identified by `ssrc`. virtual webrtc::RtpParameters GetRtpReceiveParameters( uint32_t ssrc) const = 0; @@ -920,11 +918,9 @@ class VoiceMediaReceiveChannelInterface : public MediaReceiveChannelInterface { virtual void SetReceiveNonSenderRttEnabled(bool enabled) = 0; }; -// TODO(deadbeef): Rename to VideoSenderParameters, since they're intended to -// encapsulate all the parameters needed for a video RtpSender. -struct VideoSendParameters : RtpSendParameters { - VideoSendParameters(); - ~VideoSendParameters() override; +struct VideoSenderParameters : SenderParameters { + VideoSenderParameters(); + ~VideoSenderParameters() override; // Use conference mode? This flag comes from the remote // description's SDP line 'a=x-google-flag:conference', copied over // by VideoChannel::SetRemoteContent_w, and ultimately used by @@ -937,13 +933,11 @@ struct VideoSendParameters : RtpSendParameters { std::map ToStringMap() const override; }; -// TODO(deadbeef): Rename to VideoReceiverParameters, since they're intended to -// encapsulate all the parameters needed for a video RtpReceiver. -struct VideoRecvParameters : RtpParameters {}; +struct VideoReceiverParameters : MediaChannelParameters {}; class VideoMediaSendChannelInterface : public MediaSendChannelInterface { public: - virtual bool SetSendParameters(const VideoSendParameters& params) = 0; + virtual bool SetSendParameters(const VideoSenderParameters& params) = 0; // Starts or stops transmission (and potentially capture) of local video. virtual bool SetSend(bool send) = 0; // Configure stream for sending and register a source. @@ -975,7 +969,7 @@ class VideoMediaSendChannelInterface : public MediaSendChannelInterface { class VideoMediaReceiveChannelInterface : public MediaReceiveChannelInterface { public: - virtual bool SetRecvParameters(const VideoRecvParameters& params) = 0; + virtual bool SetRecvParameters(const VideoReceiverParameters& params) = 0; // Get the receive parameters for the incoming stream identified by `ssrc`. virtual webrtc::RtpParameters GetRtpReceiveParameters( uint32_t ssrc) const = 0; diff --git a/media/base/media_channel_impl.cc b/media/base/media_channel_impl.cc index 2f4383db38..bd5b513e91 100644 --- a/media/base/media_channel_impl.cc +++ b/media/base/media_channel_impl.cc @@ -167,20 +167,20 @@ VideoMediaReceiveInfo::~VideoMediaReceiveInfo() = default; VoiceMediaReceiveInfo::VoiceMediaReceiveInfo() = default; VoiceMediaReceiveInfo::~VoiceMediaReceiveInfo() = default; -AudioSendParameters::AudioSendParameters() = default; -AudioSendParameters::~AudioSendParameters() = default; +AudioSenderParameter::AudioSenderParameter() = default; +AudioSenderParameter::~AudioSenderParameter() = default; -std::map AudioSendParameters::ToStringMap() const { - auto params = RtpSendParameters::ToStringMap(); +std::map AudioSenderParameter::ToStringMap() const { + auto params = SenderParameters::ToStringMap(); params["options"] = options.ToString(); return params; } -VideoSendParameters::VideoSendParameters() = default; -VideoSendParameters::~VideoSendParameters() = default; +VideoSenderParameters::VideoSenderParameters() = default; +VideoSenderParameters::~VideoSenderParameters() = default; -std::map VideoSendParameters::ToStringMap() const { - auto params = RtpSendParameters::ToStringMap(); +std::map VideoSenderParameters::ToStringMap() const { + auto params = SenderParameters::ToStringMap(); params["conference_mode"] = (conference_mode ? "yes" : "no"); return params; } diff --git a/media/engine/webrtc_video_engine.cc b/media/engine/webrtc_video_engine.cc index b552ee25be..f041dce5ef 100644 --- a/media/engine/webrtc_video_engine.cc +++ b/media/engine/webrtc_video_engine.cc @@ -972,7 +972,7 @@ std::vector WebRtcVideoSendChannel::SelectSendVideoCodecs( } bool WebRtcVideoSendChannel::GetChangedSendParameters( - const VideoSendParameters& params, + const VideoSenderParameters& params, ChangedSendParameters* changed_params) const { if (!ValidateCodecFormats(params.codecs) || !ValidateRtpExtensions(params.extensions, send_rtp_extensions_)) { @@ -1045,7 +1045,7 @@ bool WebRtcVideoSendChannel::GetChangedSendParameters( } bool WebRtcVideoSendChannel::SetSendParameters( - const VideoSendParameters& params) { + const VideoSenderParameters& params) { RTC_DCHECK_RUN_ON(&thread_checker_); TRACE_EVENT0("webrtc", "WebRtcVideoSendChannel::SetSendParameters"); RTC_LOG(LS_INFO) << "SetSendParameters: " << params.ToString(); @@ -1594,7 +1594,7 @@ WebRtcVideoSendChannel::WebRtcVideoSendStream::WebRtcVideoSendStream( const absl::optional>& rtp_extensions, // TODO(deadbeef): Don't duplicate information between send_params, // rtp_extensions, options, etc. - const VideoSendParameters& send_params) + const VideoSenderParameters& send_params) : worker_thread_(call->worker_thread()), ssrcs_(sp.ssrcs), ssrc_groups_(sp.ssrc_groups), @@ -2554,7 +2554,7 @@ WebRtcVideoReceiveChannel::GetDefaultRtpReceiveParameters() const { } bool WebRtcVideoReceiveChannel::GetChangedRecvParameters( - const VideoRecvParameters& params, + const VideoReceiverParameters& params, ChangedRecvParameters* changed_params) const { if (!ValidateCodecFormats(params.codecs) || !ValidateRtpExtensions(params.extensions, recv_rtp_extensions_)) { @@ -2609,7 +2609,7 @@ bool WebRtcVideoReceiveChannel::GetChangedRecvParameters( } bool WebRtcVideoReceiveChannel::SetRecvParameters( - const VideoRecvParameters& params) { + const VideoReceiverParameters& params) { RTC_DCHECK_RUN_ON(&thread_checker_); TRACE_EVENT0("webrtc", "WebRtcVideoReceiveChannel::SetRecvParameters"); RTC_LOG(LS_INFO) << "SetRecvParameters: " << params.ToString(); diff --git a/media/engine/webrtc_video_engine.h b/media/engine/webrtc_video_engine.h index db2519c480..4ad6a3ac70 100644 --- a/media/engine/webrtc_video_engine.h +++ b/media/engine/webrtc_video_engine.h @@ -190,7 +190,7 @@ class WebRtcVideoSendChannel : public MediaChannelUtil, // Common functions between sender and receiver void SetInterface(MediaChannelNetworkInterface* iface) override; // VideoMediaSendChannelInterface implementation - bool SetSendParameters(const VideoSendParameters& params) override; + bool SetSendParameters(const VideoSenderParameters& params) override; webrtc::RTCError SetRtpSendParameters( uint32_t ssrc, const webrtc::RtpParameters& parameters, @@ -308,7 +308,7 @@ class WebRtcVideoSendChannel : public MediaChannelUtil, absl::optional rtcp_mode; }; - bool GetChangedSendParameters(const VideoSendParameters& params, + bool GetChangedSendParameters(const VideoSenderParameters& params, ChangedSendParameters* changed_params) const RTC_EXCLUSIVE_LOCKS_REQUIRED(thread_checker_); bool ApplyChangedParams(const ChangedSendParameters& changed_params); @@ -336,7 +336,7 @@ class WebRtcVideoSendChannel : public MediaChannelUtil, int max_bitrate_bps, const absl::optional& codec_settings, const absl::optional>& rtp_extensions, - const VideoSendParameters& send_params); + const VideoSenderParameters& send_params); ~WebRtcVideoSendStream(); void SetSendParameters(const ChangedSendParameters& send_params); @@ -530,9 +530,9 @@ class WebRtcVideoSendChannel : public MediaChannelUtil, webrtc::BitrateConstraints bitrate_config_ RTC_GUARDED_BY(thread_checker_); // TODO(deadbeef): Don't duplicate information between // send_params/recv_params, rtp_extensions, options, etc. - VideoSendParameters send_params_ RTC_GUARDED_BY(thread_checker_); + VideoSenderParameters send_params_ RTC_GUARDED_BY(thread_checker_); VideoOptions default_send_options_ RTC_GUARDED_BY(thread_checker_); - VideoRecvParameters recv_params_ RTC_GUARDED_BY(thread_checker_); + VideoReceiverParameters recv_params_ RTC_GUARDED_BY(thread_checker_); int64_t last_send_stats_log_ms_ RTC_GUARDED_BY(thread_checker_); int64_t last_receive_stats_log_ms_ RTC_GUARDED_BY(thread_checker_); const bool discard_unknown_ssrc_packets_ RTC_GUARDED_BY(thread_checker_); @@ -590,7 +590,7 @@ class WebRtcVideoReceiveChannel : public MediaChannelUtil, // Common functions between sender and receiver void SetInterface(MediaChannelNetworkInterface* iface) override; // VideoMediaReceiveChannelInterface implementation - bool SetRecvParameters(const VideoRecvParameters& params) override; + bool SetRecvParameters(const VideoReceiverParameters& params) override; webrtc::RtpParameters GetRtpReceiveParameters(uint32_t ssrc) const override; webrtc::RtpParameters GetDefaultRtpReceiveParameters() const override; void SetReceive(bool receive) override; @@ -786,7 +786,7 @@ class WebRtcVideoReceiveChannel : public MediaChannelUtil, RTC_NO_UNIQUE_ADDRESS webrtc::SequenceChecker thread_checker_; bool receiving_ RTC_GUARDED_BY(&thread_checker_); }; - bool GetChangedRecvParameters(const VideoRecvParameters& params, + bool GetChangedRecvParameters(const VideoReceiverParameters& params, ChangedRecvParameters* changed_params) const RTC_EXCLUSIVE_LOCKS_REQUIRED(thread_checker_); @@ -862,9 +862,9 @@ class WebRtcVideoReceiveChannel : public MediaChannelUtil, webrtc::BitrateConstraints bitrate_config_ RTC_GUARDED_BY(thread_checker_); // TODO(deadbeef): Don't duplicate information between // send_params/recv_params, rtp_extensions, options, etc. - VideoSendParameters send_params_ RTC_GUARDED_BY(thread_checker_); + VideoSenderParameters send_params_ RTC_GUARDED_BY(thread_checker_); VideoOptions default_send_options_ RTC_GUARDED_BY(thread_checker_); - VideoRecvParameters recv_params_ RTC_GUARDED_BY(thread_checker_); + VideoReceiverParameters recv_params_ RTC_GUARDED_BY(thread_checker_); int64_t last_receive_stats_log_ms_ RTC_GUARDED_BY(thread_checker_); const bool discard_unknown_ssrc_packets_ RTC_GUARDED_BY(thread_checker_); // This is a stream param that comes from the remote description, but wasn't diff --git a/media/engine/webrtc_video_engine_unittest.cc b/media/engine/webrtc_video_engine_unittest.cc index aa59ce4d8d..c204326224 100644 --- a/media/engine/webrtc_video_engine_unittest.cc +++ b/media/engine/webrtc_video_engine_unittest.cc @@ -527,7 +527,7 @@ TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionBeforeCapturer) { // Add CVO extension. const int id = 1; - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.extensions.push_back( RtpExtension(RtpExtension::kVideoRotationUri, id)); @@ -561,7 +561,7 @@ TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionBeforeAddSendStream) { auto send_channel = SetSendParamsWithAllSupportedCodecs(); // Add CVO extension. const int id = 1; - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.extensions.push_back( RtpExtension(RtpExtension::kVideoRotationUri, id)); @@ -596,7 +596,7 @@ TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionAfterCapturer) { // Add CVO extension. const int id = 1; - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP9")); parameters.extensions.push_back( @@ -680,7 +680,7 @@ TEST_F(WebRtcVideoEngineTest, UseFactoryForVp8WhenSupported) { // Setting codecs of the same type should not reallocate any encoders // (expecting a no-op). - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); EXPECT_TRUE(send_channel->SetSendParameters(parameters)); EXPECT_EQ(num_created_encoders, encoder_factory_->GetNumCreatedEncoders()); @@ -866,7 +866,7 @@ WebRtcVideoEngineTest::SetSendParamsWithAllSupportedCodecs() { engine_.CreateSendChannel(call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(), video_bitrate_allocator_factory_.get()); - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; // We need to look up the codec in the engine to get the correct payload type. for (const webrtc::SdpVideoFormat& format : encoder_factory_->GetSupportedFormats()) { @@ -887,7 +887,7 @@ WebRtcVideoEngineTest::SetRecvParamsWithSupportedCodecs( std::unique_ptr channel = engine_.CreateReceiveChannel(call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions()); - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs = codecs; EXPECT_TRUE(channel->SetRecvParameters(parameters)); @@ -942,7 +942,7 @@ TEST_F(WebRtcVideoEngineTest, SendsFeedbackAfterUnsignaledRtxPacket) { std::unique_ptr receive_channel = engine_.CreateReceiveChannel(call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions()); - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs = supported_codecs; const int kTransportSeqExtensionId = 1; parameters.extensions.push_back(RtpExtension( @@ -984,7 +984,7 @@ TEST_F(WebRtcVideoEngineTest, UpdatesUnsignaledRtxSsrcAndRecoversPayload) { std::unique_ptr receive_channel = engine_.CreateReceiveChannel(call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions()); - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs = supported_codecs; ASSERT_TRUE(receive_channel->SetRecvParameters(parameters)); receive_channel->SetReceive(true); @@ -1067,7 +1067,7 @@ TEST_F(WebRtcVideoEngineTest, ChannelWithH264CanChangeToVp8) { engine_.CreateSendChannel(call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(), video_bitrate_allocator_factory_.get()); - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("H264")); EXPECT_TRUE(send_channel->SetSendParameters(parameters)); @@ -1080,7 +1080,7 @@ TEST_F(WebRtcVideoEngineTest, ChannelWithH264CanChangeToVp8) { ASSERT_EQ(1u, encoder_factory_->encoders().size()); - cricket::VideoSendParameters new_parameters; + cricket::VideoSenderParameters new_parameters; new_parameters.codecs.push_back(GetEngineCodec("VP8")); EXPECT_TRUE(send_channel->SetSendParameters(new_parameters)); @@ -1100,7 +1100,7 @@ TEST_F(WebRtcVideoEngineTest, engine_.CreateSendChannel(call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(), video_bitrate_allocator_factory_.get()); - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); EXPECT_TRUE(send_channel->SetSendParameters(parameters)); @@ -1140,7 +1140,7 @@ TEST_F(WebRtcVideoEngineTest, engine_.CreateSendChannel(call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(), video_bitrate_allocator_factory_.get()); - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("H264")); EXPECT_TRUE(send_channel->SetSendParameters(parameters)); @@ -1173,7 +1173,7 @@ TEST_F(WebRtcVideoEngineTest, SimulcastEnabledForH264) { webrtc::CryptoOptions(), video_bitrate_allocator_factory_.get()); - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("H264")); EXPECT_TRUE(send_channel->SetSendParameters(parameters)); @@ -1277,7 +1277,7 @@ TEST_F(WebRtcVideoEngineTest, ReportRtxForExternalCodec) { TEST_F(WebRtcVideoEngineTest, RegisterDecodersIfSupported) { AddSupportedVideoCodecType("VP8"); - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); auto receive_channel = SetRecvParamsWithSupportedCodecs(parameters.codecs); @@ -1321,7 +1321,7 @@ TEST_F(WebRtcVideoEngineTest, RegisterH264DecoderIfSupported) { TEST_F(WebRtcVideoEngineTest, GetSourcesWithNonExistingSsrc) { // Setup an recv stream with `kSsrc`. AddSupportedVideoCodecType("VP8"); - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); auto receive_channel = SetRecvParamsWithSupportedCodecs(parameters.codecs); @@ -1452,7 +1452,7 @@ TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, Vp8) { webrtc::CryptoOptions(), rate_allocator_factory.get()); - cricket::VideoSendParameters send_parameters; + cricket::VideoSenderParameters send_parameters; send_parameters.codecs.push_back(engine_codecs.at(0)); EXPECT_TRUE(send_channel->SetSendParameters(send_parameters)); send_channel->OnReadyToSend(true); @@ -1475,7 +1475,7 @@ TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, Vp8) { engine.CreateReceiveChannel(call.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions()); - cricket::VideoRecvParameters recv_parameters; + cricket::VideoReceiverParameters recv_parameters; recv_parameters.codecs.push_back(engine_codecs.at(0)); EXPECT_TRUE(receive_channel->SetRecvParameters(recv_parameters)); EXPECT_TRUE(receive_channel->AddRecvStream( @@ -1497,7 +1497,7 @@ TEST_F(WebRtcVideoEngineTest, DISABLED_RecreatesEncoderOnContentTypeChange) { ASSERT_TRUE( send_channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); cricket::VideoCodec codec = GetEngineCodec("VP8"); - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(codec); send_channel->OnReadyToSend(true); send_channel->SetSend(true); @@ -1606,7 +1606,7 @@ class WebRtcVideoChannelEncodedFrameCallbackTest : public ::testing::Test { network_interface_.SetDestination(receive_channel_.get()); send_channel_->SetInterface(&network_interface_); receive_channel_->SetInterface(&network_interface_); - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs = engine_.recv_codecs(); receive_channel_->SetRecvParameters(parameters); receive_channel_->SetReceive(true); @@ -1794,7 +1794,7 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test { network_interface_.SetDestination(receive_channel_.get()); send_channel_->SetInterface(&network_interface_); receive_channel_->SetInterface(&network_interface_); - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs = engine_.send_codecs(); receive_channel_->SetRecvParameters(parameters); EXPECT_TRUE(send_channel_->AddSendStream(DefaultSendStreamParams())); @@ -1863,7 +1863,7 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test { bool sending = SendImpl()->sending(); bool success = SetSend(false); if (success) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(codec); success = send_channel_->SetSendParameters(parameters); } @@ -2091,7 +2091,7 @@ TEST_F(WebRtcVideoChannelBaseTest, GetStats) { TEST_F(WebRtcVideoChannelBaseTest, GetStatsMultipleRecvStreams) { cricket::FakeVideoRenderer renderer1, renderer2; EXPECT_TRUE(SetOneCodec(DefaultCodec())); - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(DefaultCodec()); parameters.conference_mode = true; EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -2145,7 +2145,7 @@ TEST_F(WebRtcVideoChannelBaseTest, GetStatsMultipleSendStreams) { // Normal setup; note that we set the SSRC explicitly to ensure that // it will come first in the senders map. EXPECT_TRUE(SetOneCodec(DefaultCodec())); - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(DefaultCodec()); parameters.conference_mode = true; EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -2196,7 +2196,7 @@ TEST_F(WebRtcVideoChannelBaseTest, GetStatsMultipleSendStreams) { // Test that we can set the bandwidth. TEST_F(WebRtcVideoChannelBaseTest, SetSendBandwidth) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(DefaultCodec()); parameters.max_bandwidth_bps = -1; // <= 0 means unlimited. EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -2297,7 +2297,7 @@ TEST_F(WebRtcVideoChannelBaseTest, AddRemoveSendStreams) { TEST_F(WebRtcVideoChannelBaseTest, SimulateConference) { cricket::FakeVideoRenderer renderer1, renderer2; EXPECT_TRUE(SetDefaultCodec()); - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(DefaultCodec()); parameters.conference_mode = true; EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -2529,7 +2529,7 @@ TEST_F(WebRtcVideoChannelBaseTest, TwoStreamsSendAndReceive) { #if defined(RTC_ENABLE_VP9) TEST_F(WebRtcVideoChannelBaseTest, RequestEncoderFallback) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); parameters.codecs.push_back(GetEngineCodec("VP8")); EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -2555,7 +2555,7 @@ TEST_F(WebRtcVideoChannelBaseTest, RequestEncoderFallback) { } TEST_F(WebRtcVideoChannelBaseTest, RequestEncoderSwitchDefaultFallback) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); parameters.codecs.push_back(GetEngineCodec("VP8")); EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -2581,7 +2581,7 @@ TEST_F(WebRtcVideoChannelBaseTest, RequestEncoderSwitchStrictPreference) { VideoCodec vp9 = GetEngineCodec("VP9"); vp9.params["profile-id"] = "0"; - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(vp9); EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -2613,7 +2613,7 @@ TEST_F(WebRtcVideoChannelBaseTest, RequestEncoderSwitchStrictPreference) { } TEST_F(WebRtcVideoChannelBaseTest, SendCodecIsMovedToFrontInRtpParameters) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); parameters.codecs.push_back(GetEngineCodec("VP8")); EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -2813,7 +2813,7 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { void TestSetSendRtpHeaderExtensions(const std::string& ext_uri) { // Enable extension. const int id = 1; - cricket::VideoSendParameters parameters = send_parameters_; + cricket::VideoSenderParameters parameters = send_parameters_; parameters.extensions.push_back(RtpExtension(ext_uri, id)); EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* send_stream = @@ -2844,7 +2844,7 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { void TestSetRecvRtpHeaderExtensions(const std::string& ext_uri) { // Enable extension. const int id = 1; - cricket::VideoRecvParameters parameters = recv_parameters_; + cricket::VideoReceiverParameters parameters = recv_parameters_; parameters.extensions.push_back(RtpExtension(ext_uri, id)); EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); @@ -2879,7 +2879,7 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { AssignDefaultCodec(); VerifyCodecHasDefaultFeedbackParams(*default_codec_, expect_lntf_enabled); - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs = engine_.send_codecs(); EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); EXPECT_TRUE(send_channel_->SetSend(true)); @@ -2897,7 +2897,7 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { void TestExtensionFilter(const std::vector& extensions, const std::string& expected_extension) { - cricket::VideoSendParameters parameters = send_parameters_; + cricket::VideoSenderParameters parameters = send_parameters_; int expected_id = -1; int id = 1; for (const std::string& extension : extensions) { @@ -2970,7 +2970,7 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { void SetAndExpectMaxBitrate(int global_max, int stream_max, int expected_encoder_bitrate) { - VideoSendParameters limited_send_params = send_parameters_; + VideoSenderParameters limited_send_params = send_parameters_; limited_send_params.max_bandwidth_bps = global_max; EXPECT_TRUE(send_channel_->SetSendParameters(limited_send_params)); webrtc::RtpParameters parameters = @@ -3006,8 +3006,8 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { std::unique_ptr fake_call_; std::unique_ptr send_channel_; std::unique_ptr receive_channel_; - cricket::VideoSendParameters send_parameters_; - cricket::VideoRecvParameters recv_parameters_; + cricket::VideoSenderParameters send_parameters_; + cricket::VideoReceiverParameters recv_parameters_; uint32_t last_ssrc_; }; @@ -3026,7 +3026,7 @@ TEST_F(WebRtcVideoChannelTest, SetsSyncGroupFromSyncLabel) { } TEST_F(WebRtcVideoChannelTest, RecvStreamWithSimAndRtx) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs = engine_.send_codecs(); EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); EXPECT_TRUE(send_channel_->SetSend(true)); @@ -3281,7 +3281,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvRtpHeaderExtensionsRejectsDuplicateIds) { } TEST_F(WebRtcVideoChannelTest, OnPacketReceivedIdentifiesExtensions) { - cricket::VideoRecvParameters parameters = recv_parameters_; + cricket::VideoReceiverParameters parameters = recv_parameters_; parameters.extensions.push_back( RtpExtension(RtpExtension::kVideoRotationUri, /*id=*/1)); ASSERT_TRUE(receive_channel_->SetRecvParameters(parameters)); @@ -3332,7 +3332,7 @@ TEST_F(WebRtcVideoChannelTest, LossNotificationCanBeEnabledAndDisabled) { VerifyCodecHasDefaultFeedbackParams(*default_codec_, true); { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs = engine_.send_codecs(); EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); EXPECT_TRUE(send_channel_->SetSend(true)); @@ -3347,7 +3347,7 @@ TEST_F(WebRtcVideoChannelTest, LossNotificationCanBeEnabledAndDisabled) { ASSERT_TRUE(recv_stream->GetConfig().rtp.lntf.enabled); // Verify that LNTF is turned off when send(!) codecs without LNTF are set. - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(RemoveFeedbackParams(GetEngineCodec("VP8"))); EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty()); EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -3369,7 +3369,7 @@ TEST_F(WebRtcVideoChannelTest, NackIsEnabledByDefault) { AssignDefaultCodec(); VerifyCodecHasDefaultFeedbackParams(*default_codec_, false); - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs = engine_.send_codecs(); EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); EXPECT_TRUE(send_channel_->SetSend(true)); @@ -3397,7 +3397,7 @@ TEST_F(WebRtcVideoChannelTest, NackCanBeEnabledAndDisabled) { EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0); // Verify that NACK is turned off when send(!) codecs without NACK are set. - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(RemoveFeedbackParams(GetEngineCodec("VP8"))); EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty()); EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -3422,7 +3422,7 @@ TEST_F(WebRtcVideoChannelTest, NackCanBeEnabledAndDisabled) { // same source that will be sent later, which just means that we're ready // earlier. TEST_F(WebRtcVideoChannelTest, ReconfiguresEncodersWhenNotSending) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); send_channel_->SetSend(false); @@ -3453,7 +3453,7 @@ TEST_F(WebRtcVideoChannelTest, ReconfiguresEncodersWhenNotSending) { TEST_F(WebRtcVideoChannelTest, UsesCorrectSettingsForScreencast) { static const int kScreenshareMinBitrateKbps = 800; cricket::VideoCodec codec = GetEngineCodec("VP8"); - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(codec); EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); AddSendStream(); @@ -3591,7 +3591,7 @@ TEST_F(WebRtcVideoChannelTest, Vp8DenoisingEnabledByDefault) { } TEST_F(WebRtcVideoChannelTest, VerifyVp8SpecificSettings) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -3671,7 +3671,7 @@ TEST_F(WebRtcVideoChannelTest, SetIdenticalOptionsDoesntReconfigureEncoder) { webrtc::test::FrameForwarder frame_forwarder; AddSendStream(); - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front(); @@ -3720,7 +3720,7 @@ TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) { webrtc::SdpVideoFormat("VP9", webrtc::SdpVideoFormat::Parameters(), {ScalabilityMode::kL1T1, ScalabilityMode::kL2T1})); - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -3815,7 +3815,7 @@ TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) { } TEST_F(Vp9SettingsTest, MultipleSsrcsEnablesSvc) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -3844,7 +3844,7 @@ TEST_F(Vp9SettingsTest, MultipleSsrcsEnablesSvc) { } TEST_F(Vp9SettingsTest, SvcModeCreatesSingleRtpStream) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -3874,7 +3874,7 @@ TEST_F(Vp9SettingsTest, SvcModeCreatesSingleRtpStream) { } TEST_F(Vp9SettingsTest, AllEncodingParametersCopied) { - cricket::VideoSendParameters send_parameters; + cricket::VideoSenderParameters send_parameters; send_parameters.codecs.push_back(GetEngineCodec("VP9")); ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters)); @@ -3907,7 +3907,7 @@ TEST_F(Vp9SettingsTest, AllEncodingParametersCopied) { } TEST_F(Vp9SettingsTest, MaxBitrateDeterminedBySvcResolutions) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -3953,7 +3953,7 @@ TEST_F(Vp9SettingsTest, MaxBitrateDeterminedBySvcResolutions) { } TEST_F(Vp9SettingsTest, Vp9SvcTargetBitrateCappedByMax) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -4006,7 +4006,7 @@ class Vp9SettingsTestWithFieldTrial void VerifySettings(int num_spatial_layers, int num_temporal_layers, webrtc::InterLayerPredMode interLayerPred) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -4118,7 +4118,7 @@ TEST_F(WebRtcVideoChannelTest, DoesNotAdaptOnOveruseWhenScreensharing) { TEST_F(WebRtcVideoChannelTest, PreviousAdaptationDoesNotApplyToScreenshare) { cricket::VideoCodec codec = GetEngineCodec("VP8"); - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(codec); MediaConfig media_config = GetMediaConfig(); @@ -4172,7 +4172,7 @@ void WebRtcVideoChannelTest::TestDegradationPreference( bool resolution_scaling_enabled, bool fps_scaling_enabled) { cricket::VideoCodec codec = GetEngineCodec("VP8"); - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(codec); MediaConfig media_config = GetMediaConfig(); @@ -4206,7 +4206,7 @@ void WebRtcVideoChannelTest::TestDegradationPreference( void WebRtcVideoChannelTest::TestCpuAdaptation(bool enable_overuse, bool is_screenshare) { cricket::VideoCodec codec = GetEngineCodec("VP8"); - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(codec); MediaConfig media_config = GetMediaConfig(); @@ -4319,7 +4319,7 @@ TEST_F(WebRtcVideoChannelTest, SetDefaultSendCodecs) { } TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithoutPacketization) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -4329,7 +4329,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithoutPacketization) { } TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithPacketization) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.back().packetization = kPacketizationParamRaw; EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -4441,7 +4441,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetDefaultRecvCodecsWithSsrc) { // existing video stream instance. TEST_F(WebRtcVideoChannelFlexfecRecvTest, EnablingFlexfecDoesNotRecreateVideoReceiveStream) { - cricket::VideoRecvParameters recv_parameters; + cricket::VideoReceiverParameters recv_parameters; recv_parameters.codecs.push_back(GetEngineCodec("VP8")); ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); @@ -4482,7 +4482,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, // stream will be set/cleared as dictated by the configuration change. TEST_F(WebRtcVideoChannelFlexfecRecvTest, DisablingFlexfecDoesNotRecreateVideoReceiveStream) { - cricket::VideoRecvParameters recv_parameters; + cricket::VideoReceiverParameters recv_parameters; recv_parameters.codecs.push_back(GetEngineCodec("VP8")); recv_parameters.codecs.push_back(GetEngineCodec("flexfec-03")); ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); @@ -4522,7 +4522,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, TEST_F(WebRtcVideoChannelFlexfecRecvTest, DuplicateFlexfecCodecIsDropped) { constexpr int kUnusedPayloadType1 = 127; - cricket::VideoRecvParameters recv_parameters; + cricket::VideoReceiverParameters recv_parameters; recv_parameters.codecs.push_back(GetEngineCodec("VP8")); recv_parameters.codecs.push_back(GetEngineCodec("flexfec-03")); cricket::VideoCodec duplicate = GetEngineCodec("flexfec-03"); @@ -4573,7 +4573,7 @@ TEST_F(WebRtcVideoChannelFlexfecSendRecvTest, SetDefaultSendCodecsWithSsrc) { } TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithoutFec) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -4585,7 +4585,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithoutFec) { } TEST_F(WebRtcVideoChannelFlexfecSendRecvTest, SetSendCodecsWithoutFec) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -4599,7 +4599,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetRecvCodecsWithFec) { AddRecvStream( CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc)); - cricket::VideoRecvParameters recv_parameters; + cricket::VideoReceiverParameters recv_parameters; recv_parameters.codecs.push_back(GetEngineCodec("VP8")); recv_parameters.codecs.push_back(GetEngineCodec("flexfec-03")); ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); @@ -4633,7 +4633,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetRecvCodecsWithFec) { // TODO(brandtr): Remove when FlexFEC is enabled by default. TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetSendCodecsWithoutSsrcWithFecDoesNotEnableFec) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("flexfec-03")); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -4648,7 +4648,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetSendCodecsWithSsrcWithFecDoesNotEnableFec) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("flexfec-03")); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -4667,7 +4667,7 @@ TEST_F(WebRtcVideoChannelTest, const int kUnusedPayloadType = 127; EXPECT_FALSE(FindCodecById(engine_.send_codecs(), kUnusedPayloadType)); - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; cricket::VideoCodec rtx_codec = cricket::CreateVideoCodec(kUnusedPayloadType, "rtx"); parameters.codecs.push_back(rtx_codec); @@ -4684,7 +4684,7 @@ TEST_F(WebRtcVideoChannelTest, { cricket::VideoCodec rtx_codec = cricket::CreateVideoRtxCodec( kUnusedPayloadType1, GetEngineCodec("VP8").id); - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(rtx_codec); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -4692,7 +4692,7 @@ TEST_F(WebRtcVideoChannelTest, { cricket::VideoCodec rtx_codec = cricket::CreateVideoRtxCodec(kUnusedPayloadType1, kUnusedPayloadType2); - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(rtx_codec); EXPECT_FALSE(send_channel_->SetSendParameters(parameters)) @@ -4713,7 +4713,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithChangedRtxPayloadType) { AddSendStream(params); // Original payload type for RTX. - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); cricket::VideoCodec rtx_codec = cricket::CreateVideoCodec(kUnusedPayloadType1, "rtx"); @@ -4739,7 +4739,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithChangedRtxPayloadType) { } TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithoutFecDisablesFec) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("ulpfec")); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -4760,7 +4760,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithoutFecDisablesFec) { TEST_F(WebRtcVideoChannelFlexfecSendRecvTest, SetSendCodecsWithoutFecDisablesFec) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("flexfec-03")); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -4784,7 +4784,7 @@ TEST_F(WebRtcVideoChannelFlexfecSendRecvTest, } TEST_F(WebRtcVideoChannelTest, SetSendCodecsChangesExistingStreams) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; cricket::VideoCodec codec = cricket::CreateVideoCodec(100, "VP8"); codec.SetParam(kCodecParamMaxQuantization, kDefaultQpMax); parameters.codecs.push_back(codec); @@ -4901,7 +4901,7 @@ TEST_F(WebRtcVideoChannelTest, SetMaxSendBandwidthAndAddSendStream) { stream->GetVideoStreams()[0].max_bitrate_bps); } -// Tests that when the codec specific max bitrate and VideoSendParameters +// Tests that when the codec specific max bitrate and VideoSenderParameters // max_bandwidth_bps are used, that it sets the VideoStream's max bitrate // appropriately. TEST_F(WebRtcVideoChannelTest, @@ -4922,7 +4922,7 @@ TEST_F(WebRtcVideoChannelTest, EXPECT_EQ(300000, video_send_streams[0]->GetVideoStreams()[0].max_bitrate_bps); - // The VideoSendParameters max bitrate overrides the codec's. + // The VideoSenderParameters max bitrate overrides the codec's. send_parameters_.max_bandwidth_bps = 500000; ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps); ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); @@ -4988,7 +4988,7 @@ TEST_F(WebRtcVideoChannelTest, } TEST_F(WebRtcVideoChannelTest, SetMaxSendBitrateCanIncreaseSenderBitrate) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); send_channel_->SetSend(true); @@ -5014,7 +5014,7 @@ TEST_F(WebRtcVideoChannelTest, SetMaxSendBitrateCanIncreaseSenderBitrate) { TEST_F(WebRtcVideoChannelTest, SetMaxSendBitrateCanIncreaseSimulcastSenderBitrate) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); send_channel_->SetSend(true); @@ -5047,7 +5047,7 @@ TEST_F(WebRtcVideoChannelTest, TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithMaxQuantization) { static const char* kMaxQuantization = "21"; - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs[0].params[kCodecParamMaxQuantization] = kMaxQuantization; EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -5062,7 +5062,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithMaxQuantization) { TEST_F(WebRtcVideoChannelTest, SetSendCodecsRejectBadPayloadTypes) { // TODO(pbos): Should we only allow the dynamic range? static const int kIncorrectPayloads[] = {-2, -1, 128, 129}; - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); for (size_t i = 0; i < arraysize(kIncorrectPayloads); ++i) { parameters.codecs[0].id = kIncorrectPayloads[i]; @@ -5072,7 +5072,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsRejectBadPayloadTypes) { } TEST_F(WebRtcVideoChannelTest, SetSendCodecsAcceptAllValidPayloadTypes) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); for (int payload_type = 96; payload_type <= 127; ++payload_type) { parameters.codecs[0].id = payload_type; @@ -5087,7 +5087,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsAcceptAllValidPayloadTypes) { // result of one of the codecs being rejected. TEST_F(WebRtcVideoChannelTest, SetSendCodecsIdenticalFirstCodecDoesntRecreateStream) { - cricket::VideoSendParameters parameters1; + cricket::VideoSenderParameters parameters1; parameters1.codecs.push_back(GetEngineCodec("VP8")); parameters1.codecs.push_back(GetEngineCodec("VP9")); EXPECT_TRUE(send_channel_->SetSendParameters(parameters1)); @@ -5095,14 +5095,14 @@ TEST_F(WebRtcVideoChannelTest, AddSendStream(); EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams()); - cricket::VideoSendParameters parameters2; + cricket::VideoSenderParameters parameters2; parameters2.codecs.push_back(GetEngineCodec("VP8")); EXPECT_TRUE(send_channel_->SetSendParameters(parameters2)); EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams()); } TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithOnlyVp8) { - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); } @@ -5114,7 +5114,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithRtx) { EXPECT_FALSE(FindCodecById(engine_.recv_codecs(), kUnusedPayloadType1)); EXPECT_FALSE(FindCodecById(engine_.recv_codecs(), kUnusedPayloadType2)); - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); cricket::VideoCodec rtx_codec = cricket::CreateVideoCodec(kUnusedPayloadType1, "rtx"); @@ -5143,7 +5143,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithPacketization) { cricket::VideoCodec vp8_codec = GetEngineCodec("VP8"); vp8_codec.packetization = kPacketizationParamRaw; - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs = {vp8_codec, GetEngineCodec("VP9")}; EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); @@ -5159,7 +5159,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithPacketization) { } TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithPacketizationRecreatesStream) { - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs = {GetEngineCodec("VP8"), GetEngineCodec("VP9")}; parameters.codecs.back().packetization = kPacketizationParamRaw; EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); @@ -5179,7 +5179,7 @@ TEST_F(WebRtcVideoChannelTest, DuplicateUlpfecCodecIsDropped) { constexpr int kFirstUlpfecPayloadType = 126; constexpr int kSecondUlpfecPayloadType = 127; - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(cricket::CreateVideoCodec( kFirstUlpfecPayloadType, cricket::kUlpfecCodecName)); @@ -5196,7 +5196,7 @@ TEST_F(WebRtcVideoChannelTest, DuplicateRedCodecIsDropped) { constexpr int kFirstRedPayloadType = 126; constexpr int kSecondRedPayloadType = 127; - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back( cricket::CreateVideoCodec(kFirstRedPayloadType, cricket::kRedCodecName)); @@ -5222,7 +5222,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithChangedRtxPayloadType) { AddRecvStream(params); // Original payload type for RTX. - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); cricket::VideoCodec rtx_codec = cricket::CreateVideoCodec(kUnusedPayloadType1, "rtx"); @@ -5266,7 +5266,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRtxWithRtxTime) { AddRecvStream(params); // Payload type for RTX. - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); cricket::VideoCodec rtx_codec = cricket::CreateVideoCodec(kUnusedPayloadType1, "rtx"); @@ -5325,14 +5325,14 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRtxWithRtxTime) { } TEST_F(WebRtcVideoChannelTest, SetRecvCodecsDifferentPayloadType) { - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs[0].id = 99; EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); } TEST_F(WebRtcVideoChannelTest, SetRecvCodecsAcceptDefaultCodecs) { - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs = engine_.recv_codecs(); EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); @@ -5345,21 +5345,21 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsAcceptDefaultCodecs) { } TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRejectUnsupportedCodec) { - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(cricket::CreateVideoCodec(101, "WTF3")); EXPECT_FALSE(receive_channel_->SetRecvParameters(parameters)); } TEST_F(WebRtcVideoChannelTest, SetRecvCodecsAcceptsMultipleVideoCodecs) { - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP9")); EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); } TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithoutFecDisablesFec) { - cricket::VideoSendParameters send_parameters; + cricket::VideoSenderParameters send_parameters; send_parameters.codecs.push_back(GetEngineCodec("VP8")); send_parameters.codecs.push_back(GetEngineCodec("red")); send_parameters.codecs.push_back(GetEngineCodec("ulpfec")); @@ -5370,7 +5370,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithoutFecDisablesFec) { EXPECT_EQ(GetEngineCodec("ulpfec").id, stream->GetConfig().rtp.ulpfec_payload_type); - cricket::VideoRecvParameters recv_parameters; + cricket::VideoReceiverParameters recv_parameters; recv_parameters.codecs.push_back(GetEngineCodec("VP8")); ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); stream = fake_call_->GetVideoReceiveStreams()[0]; @@ -5392,7 +5392,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetRecvParamsWithoutFecDisablesFec) { ASSERT_EQ(1U, stream->GetConfig().protected_media_ssrcs.size()); EXPECT_EQ(kSsrcs1[0], stream->GetConfig().protected_media_ssrcs[0]); - cricket::VideoRecvParameters recv_parameters; + cricket::VideoReceiverParameters recv_parameters; recv_parameters.codecs.push_back(GetEngineCodec("VP8")); ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); EXPECT_TRUE(streams.empty()) @@ -5404,7 +5404,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendParamsWithFecEnablesFec) { EXPECT_EQ(GetEngineCodec("ulpfec").id, stream->GetConfig().rtp.ulpfec_payload_type); - cricket::VideoRecvParameters recv_parameters; + cricket::VideoReceiverParameters recv_parameters; recv_parameters.codecs.push_back(GetEngineCodec("VP8")); recv_parameters.codecs.push_back(GetEngineCodec("red")); recv_parameters.codecs.push_back(GetEngineCodec("ulpfec")); @@ -5415,7 +5415,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendParamsWithFecEnablesFec) { stream->GetConfig().rtp.ulpfec_payload_type) << "ULPFEC should be enabled on the receive stream."; - cricket::VideoSendParameters send_parameters; + cricket::VideoSenderParameters send_parameters; send_parameters.codecs.push_back(GetEngineCodec("VP8")); send_parameters.codecs.push_back(GetEngineCodec("red")); send_parameters.codecs.push_back(GetEngineCodec("ulpfec")); @@ -5433,7 +5433,7 @@ TEST_F(WebRtcVideoChannelFlexfecSendRecvTest, const std::vector& streams = fake_call_->GetFlexfecReceiveStreams(); - cricket::VideoRecvParameters recv_parameters; + cricket::VideoReceiverParameters recv_parameters; recv_parameters.codecs.push_back(GetEngineCodec("VP8")); recv_parameters.codecs.push_back(GetEngineCodec("flexfec-03")); ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); @@ -5447,7 +5447,7 @@ TEST_F(WebRtcVideoChannelFlexfecSendRecvTest, EXPECT_EQ(kSsrcs1[0], stream_with_recv_params->GetConfig().protected_media_ssrcs[0]); - cricket::VideoSendParameters send_parameters; + cricket::VideoSenderParameters send_parameters; send_parameters.codecs.push_back(GetEngineCodec("VP8")); send_parameters.codecs.push_back(GetEngineCodec("flexfec-03")); ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters)); @@ -5463,7 +5463,7 @@ TEST_F(WebRtcVideoChannelFlexfecSendRecvTest, } TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRejectDuplicateFecPayloads) { - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("red")); parameters.codecs[1].id = parameters.codecs[0].id; @@ -5472,7 +5472,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRejectDuplicateFecPayloads) { TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetRecvCodecsRejectDuplicateFecPayloads) { - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("flexfec-03")); parameters.codecs[1].id = parameters.codecs[0].id; @@ -5480,7 +5480,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, } TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRejectDuplicateCodecPayloads) { - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP9")); parameters.codecs[1].id = parameters.codecs[0].id; @@ -5489,7 +5489,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRejectDuplicateCodecPayloads) { TEST_F(WebRtcVideoChannelTest, SetRecvCodecsAcceptSameCodecOnMultiplePayloadTypes) { - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs[1].id += 1; @@ -5500,7 +5500,7 @@ TEST_F(WebRtcVideoChannelTest, // doesn't result in the stream being recreated. TEST_F(WebRtcVideoChannelTest, SetRecvCodecsDifferentOrderDoesntRecreateStream) { - cricket::VideoRecvParameters parameters1; + cricket::VideoReceiverParameters parameters1; parameters1.codecs.push_back(GetEngineCodec("VP8")); parameters1.codecs.push_back(GetEngineCodec("red")); EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters1)); @@ -5508,7 +5508,7 @@ TEST_F(WebRtcVideoChannelTest, AddRecvStream(cricket::StreamParams::CreateLegacy(123)); EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams()); - cricket::VideoRecvParameters parameters2; + cricket::VideoReceiverParameters parameters2; parameters2.codecs.push_back(GetEngineCodec("red")); parameters2.codecs.push_back(GetEngineCodec("VP8")); EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters2)); @@ -5668,7 +5668,7 @@ TEST_F(WebRtcVideoChannelTest, OnReadyToSendSignalsNetworkState) { } TEST_F(WebRtcVideoChannelTest, GetStatsReportsSentCodecName) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -6175,7 +6175,7 @@ TEST_F(WebRtcVideoChannelTest, } TEST_F(WebRtcVideoChannelTest, OutboundRtpIsActiveComesFromAnyEncodingInSvc) { - cricket::VideoSendParameters send_parameters; + cricket::VideoSenderParameters send_parameters; send_parameters.codecs.push_back(GetEngineCodec("VP9")); ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters)); @@ -7474,7 +7474,7 @@ TEST_F(WebRtcVideoChannelTest, // Any different unsignalled SSRC received will replace the default. TEST_F(WebRtcVideoChannelTest, ReceiveDifferentUnsignaledSsrc) { // Allow receiving VP8, VP9, H264 (if enabled). - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP9")); @@ -7555,7 +7555,7 @@ TEST_F(WebRtcVideoChannelTest, ReceiveDifferentUnsignaledSsrc) { // been the default receive stream before being properly signaled. TEST_F(WebRtcVideoChannelTest, NewUnsignaledStreamDoesNotDestroyPreviouslyUnsignaledStream) { - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); ASSERT_TRUE(receive_channel_->SetRecvParameters(parameters)); @@ -7929,7 +7929,7 @@ TEST_F(WebRtcVideoChannelTest, SetRtpSendParametersPrioritySimulcastStreams) { TEST_F(WebRtcVideoChannelTest, GetAndSetRtpSendParametersScaleResolutionDownByVP8) { - VideoSendParameters parameters; + VideoSenderParameters parameters; parameters.codecs.push_back(cricket::CreateVideoCodec(kVp8CodecName)); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false); @@ -8047,7 +8047,7 @@ TEST_F(WebRtcVideoChannelTest, field_trials_, "WebRTC-NormalizeSimulcastResolution/Enabled-3/"); // Set up WebRtcVideoChannel for 3-layer VP8 simulcast. - VideoSendParameters parameters; + VideoSenderParameters parameters; parameters.codecs.push_back(cricket::CreateVideoCodec(kVp8CodecName)); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false); @@ -8090,7 +8090,7 @@ TEST_F(WebRtcVideoChannelTest, TEST_F(WebRtcVideoChannelTest, GetAndSetRtpSendParametersScaleResolutionDownByH264) { encoder_factory_->AddSupportedVideoCodecType(kH264CodecName); - VideoSendParameters parameters; + VideoSenderParameters parameters; parameters.codecs.push_back(cricket::CreateVideoCodec(kH264CodecName)); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false); @@ -8208,7 +8208,7 @@ TEST_F(WebRtcVideoChannelTest, // Set up WebRtcVideoChannel for 3-layer H264 simulcast. encoder_factory_->AddSupportedVideoCodecType(kH264CodecName); - VideoSendParameters parameters; + VideoSenderParameters parameters; parameters.codecs.push_back(cricket::CreateVideoCodec(kH264CodecName)); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false); @@ -8523,7 +8523,7 @@ TEST_F(WebRtcVideoChannelTest, encoder_factory_->AddSupportedVideoCodec(webrtc::SdpVideoFormat( "VP9", webrtc::SdpVideoFormat::Parameters(), {ScalabilityMode::kL3T3})); - cricket::VideoSendParameters send_parameters; + cricket::VideoSenderParameters send_parameters; send_parameters.codecs.push_back(GetEngineCodec("VP9")); EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters)); @@ -8577,7 +8577,7 @@ TEST_F(WebRtcVideoChannelTest, kDefaultScalabilityModeStr))); // Change codec to VP8. - cricket::VideoSendParameters vp8_parameters; + cricket::VideoSenderParameters vp8_parameters; vp8_parameters.codecs.push_back(GetEngineCodec("VP8")); EXPECT_TRUE(send_channel_->SetSendParameters(vp8_parameters)); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); @@ -9141,7 +9141,7 @@ TEST_F(WebRtcVideoChannelTest, TEST_F(WebRtcVideoChannelTest, InactiveStreamDoesntStartSendingWhenReconfigured) { // Set an initial codec list, which will be modified later. - cricket::VideoSendParameters parameters1; + cricket::VideoSenderParameters parameters1; parameters1.codecs.push_back(GetEngineCodec("VP8")); parameters1.codecs.push_back(GetEngineCodec("VP9")); EXPECT_TRUE(send_channel_->SetSendParameters(parameters1)); @@ -9162,7 +9162,7 @@ TEST_F(WebRtcVideoChannelTest, EXPECT_FALSE(stream->IsSending()); // Reorder the codec list, causing the stream to be reconfigured. - cricket::VideoSendParameters parameters2; + cricket::VideoSenderParameters parameters2; parameters2.codecs.push_back(GetEngineCodec("VP9")); parameters2.codecs.push_back(GetEngineCodec("VP8")); EXPECT_TRUE(send_channel_->SetSendParameters(parameters2)); @@ -9180,7 +9180,7 @@ TEST_F(WebRtcVideoChannelTest, // Test that GetRtpSendParameters returns the currently configured codecs. TEST_F(WebRtcVideoChannelTest, GetRtpSendParametersCodecs) { AddSendStream(); - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP9")); EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -9258,7 +9258,7 @@ TEST_F(WebRtcVideoChannelTest, GetRtpSendParametersDegradationPreference) { // Test that if we set/get parameters multiple times, we get the same results. TEST_F(WebRtcVideoChannelTest, SetAndGetRtpSendParameters) { AddSendStream(); - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP9")); EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -9277,7 +9277,7 @@ TEST_F(WebRtcVideoChannelTest, SetAndGetRtpSendParameters) { // Test that GetRtpReceiveParameters returns the currently configured codecs. TEST_F(WebRtcVideoChannelTest, GetRtpReceiveParametersCodecs) { AddRecvStream(); - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP9")); EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); @@ -9296,7 +9296,7 @@ TEST_F(WebRtcVideoChannelTest, GetRtpReceiveFmtpSprop) { #else TEST_F(WebRtcVideoChannelTest, DISABLED_GetRtpReceiveFmtpSprop) { #endif - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; cricket::VideoCodec kH264sprop1 = cricket::CreateVideoCodec(101, "H264"); kH264sprop1.SetParam(kH264FmtpSpropParameterSets, "uvw"); parameters.codecs.push_back(kH264sprop1); @@ -9342,7 +9342,7 @@ TEST_F(WebRtcVideoChannelTest, GetRtpReceiveParametersSsrc) { // Test that if we set/get parameters multiple times, we get the same results. TEST_F(WebRtcVideoChannelTest, SetAndGetRtpReceiveParameters) { AddRecvStream(); - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP9")); EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); @@ -9364,7 +9364,7 @@ TEST_F(WebRtcVideoChannelTest, GetDefaultRtpReceiveParametersWithUnsignaledSsrc) { // Call necessary methods to configure receiving a default stream as // soon as it arrives. - cricket::VideoRecvParameters parameters; + cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP9")); EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); @@ -9544,7 +9544,7 @@ class WebRtcVideoChannelSimulcastTest : public ::testing::Test { size_t expected_num_streams, bool screenshare, bool conference_mode) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(codec); parameters.conference_mode = conference_mode; ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -9777,7 +9777,7 @@ TEST_F(WebRtcVideoChannelTest, SetsRidsOnSendStream) { TEST_F(WebRtcVideoChannelBaseTest, EncoderSelectorSwitchCodec) { VideoCodec vp9 = GetEngineCodec("VP9"); - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(vp9); EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -9803,7 +9803,7 @@ TEST_F(WebRtcVideoChannelBaseTest, EncoderSelectorSwitchCodec) { } TEST_F(WebRtcVideoChannelTest, RequestedResolutionSinglecast) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -9862,7 +9862,7 @@ TEST_F(WebRtcVideoChannelTest, RequestedResolutionSinglecast) { } TEST_F(WebRtcVideoChannelTest, RequestedResolutionSinglecastCropping) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); @@ -9920,7 +9920,7 @@ TEST_F(WebRtcVideoChannelTest, RequestedResolutionSinglecastCropping) { } TEST_F(WebRtcVideoChannelTest, RequestedResolutionSimulcast) { - cricket::VideoSendParameters parameters; + cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); diff --git a/media/engine/webrtc_voice_engine.cc b/media/engine/webrtc_voice_engine.cc index ba664a5752..25fdbdc811 100644 --- a/media/engine/webrtc_voice_engine.cc +++ b/media/engine/webrtc_voice_engine.cc @@ -1263,7 +1263,7 @@ bool WebRtcVoiceSendChannel::SetOptions(const AudioOptions& options) { } bool WebRtcVoiceSendChannel::SetSendParameters( - const AudioSendParameters& params) { + const AudioSenderParameter& params) { TRACE_EVENT0("webrtc", "WebRtcVoiceMediaChannel::SetSendParameters"); RTC_DCHECK_RUN_ON(worker_thread_); RTC_LOG(LS_INFO) << "WebRtcVoiceMediaChannel::SetSendParameters: " @@ -1998,7 +1998,7 @@ WebRtcVoiceReceiveChannel::~WebRtcVoiceReceiveChannel() { } bool WebRtcVoiceReceiveChannel::SetRecvParameters( - const AudioRecvParameters& params) { + const AudioReceiverParameters& params) { TRACE_EVENT0("webrtc", "WebRtcVoiceMediaChannel::SetRecvParameters"); RTC_DCHECK_RUN_ON(worker_thread_); RTC_LOG(LS_INFO) << "WebRtcVoiceMediaChannel::SetRecvParameters: " diff --git a/media/engine/webrtc_voice_engine.h b/media/engine/webrtc_voice_engine.h index a0b1b703c9..925d086fde 100644 --- a/media/engine/webrtc_voice_engine.h +++ b/media/engine/webrtc_voice_engine.h @@ -227,7 +227,7 @@ class WebRtcVoiceSendChannel final : public MediaChannelUtil, const AudioOptions& options() const { return options_; } - bool SetSendParameters(const AudioSendParameters& params) override; + bool SetSendParameters(const AudioSenderParameter& params) override; webrtc::RtpParameters GetRtpSendParameters(uint32_t ssrc) const override; webrtc::RTCError SetRtpSendParameters( uint32_t ssrc, @@ -377,7 +377,7 @@ class WebRtcVoiceReceiveChannel final void SetInterface(MediaChannelNetworkInterface* iface) override { MediaChannelUtil::SetInterface(iface); } - bool SetRecvParameters(const AudioRecvParameters& params) override; + bool SetRecvParameters(const AudioReceiverParameters& params) override; webrtc::RtpParameters GetRtpReceiveParameters(uint32_t ssrc) const override; webrtc::RtpParameters GetDefaultRtpReceiveParameters() const override; diff --git a/media/engine/webrtc_voice_engine_unittest.cc b/media/engine/webrtc_voice_engine_unittest.cc index 65c187bbda..5cfc5beb72 100644 --- a/media/engine/webrtc_voice_engine_unittest.cc +++ b/media/engine/webrtc_voice_engine_unittest.cc @@ -338,7 +338,7 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam { send_channel_->SetSend(enable); } - void SetSendParameters(const cricket::AudioSendParameters& params) { + void SetSendParameters(const cricket::AudioSenderParameter& params) { ASSERT_TRUE(send_channel_); EXPECT_TRUE(send_channel_->SetSendParameters(params)); } @@ -429,7 +429,7 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam { int max_bitrate, bool expected_result, int expected_bitrate) { - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(codec); parameters.max_bandwidth_bps = max_bitrate; if (expected_result) { @@ -451,7 +451,7 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam { } void SetGlobalMaxBitrate(const cricket::AudioCodec& codec, int bitrate) { - cricket::AudioSendParameters send_parameters; + cricket::AudioSenderParameter send_parameters; send_parameters.codecs.push_back(codec); send_parameters.max_bandwidth_bps = bitrate; SetSendParameters(send_parameters); @@ -847,8 +847,8 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam { std::unique_ptr engine_; std::unique_ptr send_channel_; std::unique_ptr receive_channel_; - cricket::AudioSendParameters send_parameters_; - cricket::AudioRecvParameters recv_parameters_; + cricket::AudioSenderParameter send_parameters_; + cricket::AudioReceiverParameters recv_parameters_; FakeAudioSource fake_source_; webrtc::AudioProcessing::Config apm_config_; }; @@ -901,7 +901,7 @@ TEST_P(WebRtcVoiceEngineTestFake, OpusSupportsTransportCc) { // Test that we set our inbound codecs properly, including changing PT. TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecs) { EXPECT_TRUE(SetupChannel()); - cricket::AudioRecvParameters parameters; + cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kTelephoneEventCodec1); @@ -921,7 +921,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecs) { // Test that we fail to set an unknown inbound codec. TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsUnsupportedCodec) { EXPECT_TRUE(SetupChannel()); - cricket::AudioRecvParameters parameters; + cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(cricket::CreateAudioCodec(127, "XYZ", 32000, 1)); EXPECT_FALSE(receive_channel_->SetRecvParameters(parameters)); @@ -930,7 +930,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsUnsupportedCodec) { // Test that we fail if we have duplicate types in the inbound list. TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsDuplicatePayloadType) { EXPECT_TRUE(SetupChannel()); - cricket::AudioRecvParameters parameters; + cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kCn16000Codec); parameters.codecs[1].id = kOpusCodec.id; @@ -940,7 +940,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsDuplicatePayloadType) { // Test that we can decode OPUS without stereo parameters. TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpusNoStereo) { EXPECT_TRUE(SetupChannel()); - cricket::AudioRecvParameters parameters; + cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kOpusCodec); EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); @@ -953,7 +953,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpusNoStereo) { // Test that we can decode OPUS with stereo = 0. TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus0Stereo) { EXPECT_TRUE(SetupChannel()); - cricket::AudioRecvParameters parameters; + cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kOpusCodec); parameters.codecs[1].params["stereo"] = "0"; @@ -968,7 +968,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus0Stereo) { // Test that we can decode OPUS with stereo = 1. TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus1Stereo) { EXPECT_TRUE(SetupChannel()); - cricket::AudioRecvParameters parameters; + cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kOpusCodec); parameters.codecs[1].params["stereo"] = "1"; @@ -983,7 +983,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus1Stereo) { // Test that changes to recv codecs are applied to all streams. TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWithMultipleStreams) { EXPECT_TRUE(SetupChannel()); - cricket::AudioRecvParameters parameters; + cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kTelephoneEventCodec1); @@ -1004,7 +1004,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWithMultipleStreams) { TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsAfterAddingStreams) { EXPECT_TRUE(SetupRecvStream()); - cricket::AudioRecvParameters parameters; + cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].id = 106; // collide with existing CN 32k EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); @@ -1017,7 +1017,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsAfterAddingStreams) { // Test that we can apply the same set of codecs again while playing. TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWhilePlaying) { EXPECT_TRUE(SetupRecvStream()); - cricket::AudioRecvParameters parameters; + cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kCn16000Codec); EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); @@ -1034,7 +1034,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWhilePlaying) { // Test that we can add a codec while playing. TEST_P(WebRtcVoiceEngineTestFake, AddRecvCodecsWhilePlaying) { EXPECT_TRUE(SetupRecvStream()); - cricket::AudioRecvParameters parameters; + cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kCn16000Codec); EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); @@ -1049,7 +1049,7 @@ TEST_P(WebRtcVoiceEngineTestFake, AddRecvCodecsWhilePlaying) { // See: https://bugs.chromium.org/p/webrtc/issues/detail?id=5847 TEST_P(WebRtcVoiceEngineTestFake, ChangeRecvCodecPayloadType) { EXPECT_TRUE(SetupRecvStream()); - cricket::AudioRecvParameters parameters; + cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kOpusCodec); EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); @@ -1060,7 +1060,7 @@ TEST_P(WebRtcVoiceEngineTestFake, ChangeRecvCodecPayloadType) { // Test that we do allow setting Opus/Red by default. TEST_P(WebRtcVoiceEngineTestFake, RecvRedDefault) { EXPECT_TRUE(SetupRecvStream()); - cricket::AudioRecvParameters parameters; + cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kRed48000Codec); parameters.codecs[1].params[""] = "111/111"; @@ -1114,7 +1114,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthFixedRateAsCaller) { TEST_P(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCallee) { EXPECT_TRUE(SetupChannel()); const int kDesiredBitrate = 128000; - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs = engine_->send_codecs(); parameters.max_bandwidth_bps = kDesiredBitrate; SetSendParameters(parameters); @@ -1303,7 +1303,7 @@ TEST_P(WebRtcVoiceEngineTestFake, RtpParametersArePerStream) { // Test that GetRtpSendParameters returns the currently configured codecs. TEST_P(WebRtcVoiceEngineTestFake, GetRtpSendParametersCodecs) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kPcmuCodec); SetSendParameters(parameters); @@ -1353,7 +1353,7 @@ TEST_P(WebRtcVoiceEngineTestFake, GetRtpSendParametersSsrc) { // Test that if we set/get parameters multiple times, we get the same results. TEST_P(WebRtcVoiceEngineTestFake, SetAndGetRtpSendParameters) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kPcmuCodec); SetSendParameters(parameters); @@ -1374,7 +1374,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetAndGetRtpSendParameters) { // SetRtpSendParameters is called. TEST_P(WebRtcVoiceEngineTestFake, SetRtpSendParameterUpdatesMaxBitrate) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters send_parameters; + cricket::AudioSenderParameter send_parameters; send_parameters.codecs.push_back(kOpusCodec); SetSendParameters(send_parameters); @@ -1434,7 +1434,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRtpSendParameterUpdatesBitratePriority) { // Test that GetRtpReceiveParameters returns the currently configured codecs. TEST_P(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersCodecs) { EXPECT_TRUE(SetupRecvStream()); - cricket::AudioRecvParameters parameters; + cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kPcmuCodec); EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); @@ -1458,7 +1458,7 @@ TEST_P(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersSsrc) { // Test that if we set/get parameters multiple times, we get the same results. TEST_P(WebRtcVoiceEngineTestFake, SetAndGetRtpReceiveParameters) { EXPECT_TRUE(SetupRecvStream()); - cricket::AudioRecvParameters parameters; + cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kPcmuCodec); EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); @@ -1481,7 +1481,7 @@ TEST_P(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersWithUnsignaledSsrc) { ASSERT_TRUE(SetupChannel()); // Call necessary methods to configure receiving a default stream as // soon as it arrives. - cricket::AudioRecvParameters parameters; + cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kPcmuCodec); EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); @@ -1512,7 +1512,7 @@ TEST_P(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersWithUnsignaledSsrc) { TEST_P(WebRtcVoiceEngineTestFake, OnPacketReceivedIdentifiesExtensions) { ASSERT_TRUE(SetupChannel()); - cricket::AudioRecvParameters parameters = recv_parameters_; + cricket::AudioReceiverParameters parameters = recv_parameters_; parameters.extensions.push_back( RtpExtension(RtpExtension::kAudioLevelUri, /*id=*/1)); ASSERT_TRUE(receive_channel_->SetRecvParameters(parameters)); @@ -1538,7 +1538,7 @@ TEST_P(WebRtcVoiceEngineTestFake, OnPacketReceivedIdentifiesExtensions) { // Test that we apply codecs properly. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecs) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kCn8000Codec); @@ -1558,7 +1558,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecs) { // listed as the first codec and there is an fmtp line. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRed) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kRed48000Codec); parameters.codecs[0].params[""] = "111/111"; parameters.codecs.push_back(kOpusCodec); @@ -1573,7 +1573,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRed) { // listed as the first codec but there is no fmtp line. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRedNoFmtp) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kRed48000Codec); parameters.codecs.push_back(kOpusCodec); SetSendParameters(parameters); @@ -1586,7 +1586,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRedNoFmtp) { // Test that we do not use Opus/Red by default. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRedDefault) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kRed48000Codec); parameters.codecs[1].params[""] = "111/111"; @@ -1600,7 +1600,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRedDefault) { // Test that the RED fmtp line must match the payload type. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRedFmtpMismatch) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kRed48000Codec); parameters.codecs[0].params[""] = "8/8"; parameters.codecs.push_back(kOpusCodec); @@ -1614,7 +1614,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRedFmtpMismatch) { // Test that the RED fmtp line must show 2..32 payloads. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRedFmtpAmountOfRedundancy) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kRed48000Codec); parameters.codecs[0].params[""] = "111"; parameters.codecs.push_back(kOpusCodec); @@ -1643,7 +1643,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRedFmtpAmountOfRedundancy) { // AudioSendStream. TEST_P(WebRtcVoiceEngineTestFake, DontRecreateSendStream) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kCn8000Codec); @@ -1664,7 +1664,7 @@ TEST_P(WebRtcVoiceEngineTestFake, DontRecreateSendStream) { // Test that if clockrate is not 48000 for opus, we fail. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 0; parameters.codecs[0].clockrate = 50000; @@ -1674,7 +1674,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) { // Test that if channels=0 for opus, we fail. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad0ChannelsNoStereo) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 0; parameters.codecs[0].channels = 0; @@ -1684,7 +1684,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad0ChannelsNoStereo) { // Test that if channels=0 for opus, we fail. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad0Channels1Stereo) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 0; parameters.codecs[0].channels = 0; @@ -1695,7 +1695,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad0Channels1Stereo) { // Test that if channel is 1 for opus and there's no stereo, we fail. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpus1ChannelNoStereo) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 0; parameters.codecs[0].channels = 1; @@ -1705,7 +1705,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpus1ChannelNoStereo) { // Test that if channel is 1 for opus and stereo=0, we fail. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel0Stereo) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 0; parameters.codecs[0].channels = 1; @@ -1716,7 +1716,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel0Stereo) { // Test that if channel is 1 for opus and stereo=1, we fail. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel1Stereo) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 0; parameters.codecs[0].channels = 1; @@ -1727,7 +1727,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel1Stereo) { // Test that with bitrate=0 and no stereo, bitrate is 32000. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0BitrateNoStereo) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 0; SetSendParameters(parameters); @@ -1737,7 +1737,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0BitrateNoStereo) { // Test that with bitrate=0 and stereo=0, bitrate is 32000. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate0Stereo) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 0; parameters.codecs[0].params["stereo"] = "0"; @@ -1748,7 +1748,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate0Stereo) { // Test that with bitrate=invalid and stereo=0, bitrate is 32000. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate0Stereo) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].params["stereo"] = "0"; // bitrate that's out of the range between 6000 and 510000 will be clamped. @@ -1764,7 +1764,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate0Stereo) { // Test that with bitrate=0 and stereo=1, bitrate is 64000. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate1Stereo) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 0; parameters.codecs[0].params["stereo"] = "1"; @@ -1775,7 +1775,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate1Stereo) { // Test that with bitrate=invalid and stereo=1, bitrate is 64000. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate1Stereo) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].params["stereo"] = "1"; // bitrate that's out of the range between 6000 and 510000 will be clamped. @@ -1791,7 +1791,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate1Stereo) { // Test that with bitrate=N and stereo unset, bitrate is N. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 96000; SetSendParameters(parameters); @@ -1806,7 +1806,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) { // Test that with bitrate=N and stereo=0, bitrate is N. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 30000; parameters.codecs[0].params["stereo"] = "0"; @@ -1817,7 +1817,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) { // Test that with bitrate=N and without any parameters, bitrate is N. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoParameters) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 30000; SetSendParameters(parameters); @@ -1827,7 +1827,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoParameters) { // Test that with bitrate=N and stereo=1, bitrate is N. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 30000; parameters.codecs[0].params["stereo"] = "1"; @@ -1870,7 +1870,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthForAudioDoesntAffectBwe) { // Test that we can enable NACK with opus as callee. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCallee) { EXPECT_TRUE(SetupRecvStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].AddFeedbackParam(cricket::FeedbackParam( cricket::kRtcpFbParamNack, cricket::kParamValueEmpty)); @@ -1887,7 +1887,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCallee) { TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackRecvStreams) { EXPECT_TRUE(SetupSendStream()); EXPECT_TRUE(AddRecvStream(kSsrcY)); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].AddFeedbackParam(cricket::FeedbackParam( cricket::kRtcpFbParamNack, cricket::kParamValueEmpty)); @@ -1900,7 +1900,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackRecvStreams) { TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecDisableNackRecvStreams) { EXPECT_TRUE(SetupSendStream()); EXPECT_TRUE(AddRecvStream(kSsrcY)); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].AddFeedbackParam(cricket::FeedbackParam( cricket::kRtcpFbParamNack, cricket::kParamValueEmpty)); @@ -1916,7 +1916,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecDisableNackRecvStreams) { // Test that NACK is enabled on a new receive stream. TEST_P(WebRtcVoiceEngineTestFake, AddRecvStreamEnableNack) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kCn16000Codec); parameters.codecs[0].AddFeedbackParam(cricket::FeedbackParam( @@ -1933,7 +1933,7 @@ TEST_P(WebRtcVoiceEngineTestFake, AddRecvStreamEnableNack) { TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsOpusPcmuSwitching) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters opus_parameters; + cricket::AudioSenderParameter opus_parameters; opus_parameters.codecs.push_back(kOpusCodec); SetSendParameters(opus_parameters); { @@ -1942,7 +1942,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsOpusPcmuSwitching) { EXPECT_STRCASEEQ("opus", spec.format.name.c_str()); } - cricket::AudioSendParameters pcmu_parameters; + cricket::AudioSenderParameter pcmu_parameters; pcmu_parameters.codecs.push_back(kPcmuCodec); pcmu_parameters.codecs.push_back(kCn16000Codec); pcmu_parameters.codecs.push_back(kOpusCodec); @@ -1964,7 +1964,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsOpusPcmuSwitching) { // Test that we handle various ways of specifying bitrate. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kPcmuCodec); SetSendParameters(parameters); { @@ -1997,7 +1997,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) { // Test that we fail if no codecs are specified. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; EXPECT_FALSE(send_channel_->SetSendParameters(parameters)); } @@ -2005,7 +2005,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) { // one on the list. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kTelephoneEventCodec1); parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kPcmuCodec); @@ -2022,7 +2022,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) { // Test that CanInsertDtmf() is governed by the send flag TEST_P(WebRtcVoiceEngineTestFake, DTMFControlledBySendFlag) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kTelephoneEventCodec1); parameters.codecs.push_back(kPcmuCodec); parameters.codecs[0].id = 98; // DTMF @@ -2038,7 +2038,7 @@ TEST_P(WebRtcVoiceEngineTestFake, DTMFControlledBySendFlag) { // Test that payload type range is limited for telephone-event codec. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFPayloadTypeOutOfRange) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kTelephoneEventCodec2); parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].id = 0; // DTMF @@ -2061,7 +2061,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFPayloadTypeOutOfRange) { // one on the list. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kCn8000Codec); parameters.codecs.push_back(kPcmuCodec); parameters.codecs[0].id = 98; // narrowband CN @@ -2075,7 +2075,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) { // Test that we set VAD and DTMF types correctly as caller. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kCn16000Codec); parameters.codecs.push_back(kCn8000Codec); @@ -2096,7 +2096,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) { // Test that we set VAD and DTMF types correctly as callee. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) { EXPECT_TRUE(SetupChannel()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kCn16000Codec); parameters.codecs.push_back(kCn8000Codec); @@ -2121,7 +2121,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) { // send codec clockrate. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; // Set PCMU(8K) and CN(16K). VAD should not be activated. parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kCn16000Codec); @@ -2154,7 +2154,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) { // Test that we perform case-insensitive matching of codec names. TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kCn16000Codec); parameters.codecs.push_back(kCn8000Codec); @@ -2306,7 +2306,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsWithMultipleSendStreams) { cricket::StreamParams::CreateLegacy(ssrc))); } - cricket::AudioSendParameters parameters; + cricket::AudioSenderParameter parameters; // Set PCMU and CN(8K). VAD should be activated. parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kCn8000Codec); @@ -2893,7 +2893,7 @@ TEST_P(WebRtcVoiceEngineTestFake, AddRecvStream) { // those previously passed into SetRecvCodecs. TEST_P(WebRtcVoiceEngineTestFake, AddRecvStreamUnsupportedCodec) { EXPECT_TRUE(SetupSendStream()); - cricket::AudioRecvParameters parameters; + cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kPcmuCodec); EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); @@ -3120,7 +3120,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { send_channel2->AddSendStream(stream2); // AEC and AGC and NS - cricket::AudioSendParameters parameters_options_all = send_parameters_; + cricket::AudioSenderParameter parameters_options_all = send_parameters_; parameters_options_all.options.echo_cancellation = true; parameters_options_all.options.auto_gain_control = true; parameters_options_all.options.noise_suppression = true; @@ -3140,7 +3140,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { } // unset NS - cricket::AudioSendParameters parameters_options_no_ns = send_parameters_; + cricket::AudioSenderParameter parameters_options_no_ns = send_parameters_; parameters_options_no_ns.options.noise_suppression = false; EXPECT_TRUE(send_channel1->SetSendParameters(parameters_options_no_ns)); cricket::AudioOptions expected_options = parameters_options_all.options; @@ -3157,7 +3157,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { } // unset AGC - cricket::AudioSendParameters parameters_options_no_agc = send_parameters_; + cricket::AudioSenderParameter parameters_options_no_agc = send_parameters_; parameters_options_no_agc.options.auto_gain_control = false; EXPECT_TRUE(send_channel2->SetSendParameters(parameters_options_no_agc)); if (!use_null_apm_) { @@ -3197,7 +3197,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { } // Make sure settings take effect while we are sending. - cricket::AudioSendParameters parameters_options_no_agc_nor_ns = + cricket::AudioSenderParameter parameters_options_no_agc_nor_ns = send_parameters_; parameters_options_no_agc_nor_ns.options.auto_gain_control = false; parameters_options_no_agc_nor_ns.options.noise_suppression = false; @@ -3441,7 +3441,7 @@ TEST_P(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) { // Set up receive extensions. const std::vector header_extensions = GetDefaultEnabledRtpHeaderExtensions(*engine_); - cricket::AudioRecvParameters recv_parameters; + cricket::AudioReceiverParameters recv_parameters; recv_parameters.extensions = header_extensions; receive_channel_->SetRecvParameters(recv_parameters); EXPECT_EQ(2u, call_.GetAudioReceiveStreams().size()); @@ -3452,7 +3452,7 @@ TEST_P(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) { } // Disable receive extensions. - receive_channel_->SetRecvParameters(cricket::AudioRecvParameters()); + receive_channel_->SetRecvParameters(cricket::AudioReceiverParameters()); for (uint32_t ssrc : ssrcs) { EXPECT_THAT( receive_channel_->GetRtpReceiveParameters(ssrc).header_extensions, @@ -3630,7 +3630,7 @@ TEST_P(WebRtcVoiceEngineTestFake, PreservePlayoutWhenRecreateRecvStream) { // Changing RTP header extensions will recreate the // AudioReceiveStreamInterface. - cricket::AudioRecvParameters parameters; + cricket::AudioReceiverParameters parameters; parameters.extensions.push_back( webrtc::RtpExtension(webrtc::RtpExtension::kAudioLevelUri, 12)); receive_channel_->SetRecvParameters(parameters); @@ -3849,7 +3849,7 @@ TEST(WebRtcVoiceEngineTest, SetRecvCodecs) { &engine, cricket::MediaConfig(), cricket::AudioOptions(), webrtc::CryptoOptions(), call.get(), webrtc::AudioCodecPairId::Create()); - cricket::AudioRecvParameters parameters; + cricket::AudioReceiverParameters parameters; parameters.codecs = engine.recv_codecs(); EXPECT_TRUE(channel.SetRecvParameters(parameters)); } @@ -3885,7 +3885,7 @@ TEST(WebRtcVoiceEngineTest, SetRtpSendParametersMaxBitrate) { &engine, cricket::MediaConfig(), cricket::AudioOptions(), webrtc::CryptoOptions(), call.get(), webrtc::AudioCodecPairId::Create()); { - cricket::AudioSendParameters params; + cricket::AudioSenderParameter params; params.codecs.push_back(cricket::CreateAudioCodec(1, "opus", 48000, 2)); params.extensions.push_back(webrtc::RtpExtension( webrtc::RtpExtension::kTransportSequenceNumberUri, 1)); diff --git a/pc/channel.cc b/pc/channel.cc index 53a9a106cc..46cd377693 100644 --- a/pc/channel.cc +++ b/pc/channel.cc @@ -78,11 +78,11 @@ struct StreamFinder { } // namespace template -void RtpParametersFromMediaDescription( +void MediaChannelParametersFromMediaDescription( const MediaContentDescriptionImpl* desc, const RtpHeaderExtensions& extensions, bool is_stream_active, - RtpParameters* params) { + MediaChannelParameters* params) { params->is_stream_active = is_stream_active; params->codecs = desc->codecs(); // TODO(bugs.webrtc.org/11513): See if we really need @@ -98,14 +98,14 @@ template void RtpSendParametersFromMediaDescription( const MediaContentDescriptionImpl* desc, webrtc::RtpExtension::Filter extensions_filter, - RtpSendParameters* send_params) { + SenderParameters* send_params) { RtpHeaderExtensions extensions = webrtc::RtpExtension::DeduplicateHeaderExtensions( desc->rtp_header_extensions(), extensions_filter); const bool is_stream_active = webrtc::RtpTransceiverDirectionHasRecv(desc->direction()); - RtpParametersFromMediaDescription(desc, extensions, is_stream_active, - send_params); + MediaChannelParametersFromMediaDescription(desc, extensions, is_stream_active, + send_params); send_params->max_bandwidth_bps = desc->bandwidth(); send_params->extmap_allow_mixed = desc->extmap_allow_mixed(); } @@ -882,8 +882,8 @@ bool VoiceChannel::SetLocalContent_w(const MediaContentDescription* content, bool update_header_extensions = true; media_send_channel()->SetExtmapAllowMixed(content->extmap_allow_mixed()); - AudioRecvParameters recv_params = last_recv_params_; - RtpParametersFromMediaDescription( + AudioReceiverParameters recv_params = last_recv_params_; + MediaChannelParametersFromMediaDescription( content->as_audio(), header_extensions, webrtc::RtpTransceiverDirectionHasRecv(content->direction()), &recv_params); @@ -935,7 +935,7 @@ bool VoiceChannel::SetRemoteContent_w(const MediaContentDescription* content, TRACE_EVENT0("webrtc", "VoiceChannel::SetRemoteContent_w"); RTC_LOG(LS_INFO) << "Setting remote voice description for " << ToString(); - AudioSendParameters send_params = last_send_params_; + AudioSenderParameter send_params = last_send_params_; RtpSendParametersFromMediaDescription(content->as_audio(), extensions_filter(), &send_params); send_params.mid = mid(); @@ -1022,14 +1022,14 @@ bool VideoChannel::SetLocalContent_w(const MediaContentDescription* content, bool update_header_extensions = true; media_send_channel()->SetExtmapAllowMixed(content->extmap_allow_mixed()); - VideoRecvParameters recv_params = last_recv_params_; + VideoReceiverParameters recv_params = last_recv_params_; - RtpParametersFromMediaDescription( + MediaChannelParametersFromMediaDescription( content->as_video(), header_extensions, webrtc::RtpTransceiverDirectionHasRecv(content->direction()), &recv_params); - VideoSendParameters send_params = last_send_params_; + VideoSenderParameters send_params = last_send_params_; bool needs_send_params_update = false; if (type == SdpType::kAnswer || type == SdpType::kPrAnswer) { @@ -1108,13 +1108,13 @@ bool VideoChannel::SetRemoteContent_w(const MediaContentDescription* content, const VideoContentDescription* video = content->as_video(); - VideoSendParameters send_params = last_send_params_; + VideoSenderParameters send_params = last_send_params_; RtpSendParametersFromMediaDescription(video, extensions_filter(), &send_params); send_params.mid = mid(); send_params.conference_mode = video->conference_mode(); - VideoRecvParameters recv_params = last_recv_params_; + VideoReceiverParameters recv_params = last_recv_params_; bool needs_recv_params_update = false; if (type == SdpType::kAnswer || type == SdpType::kPrAnswer) { diff --git a/pc/channel.h b/pc/channel.h index 1e158879b6..5078225e61 100644 --- a/pc/channel.h +++ b/pc/channel.h @@ -429,12 +429,12 @@ class VoiceChannel : public BaseChannel { std::string& error_desc) RTC_RUN_ON(worker_thread()) override; - // Last AudioSendParameters sent down to the media_channel() via + // Last AudioSenderParameter sent down to the media_channel() via // SetSendParameters. - AudioSendParameters last_send_params_ RTC_GUARDED_BY(worker_thread()); - // Last AudioRecvParameters sent down to the media_channel() via + AudioSenderParameter last_send_params_ RTC_GUARDED_BY(worker_thread()); + // Last AudioReceiverParameters sent down to the media_channel() via // SetRecvParameters. - AudioRecvParameters last_recv_params_ RTC_GUARDED_BY(worker_thread()); + AudioReceiverParameters last_recv_params_ RTC_GUARDED_BY(worker_thread()); }; // VideoChannel is a specialization for video. @@ -498,12 +498,12 @@ class VideoChannel : public BaseChannel { std::string& error_desc) RTC_RUN_ON(worker_thread()) override; - // Last VideoSendParameters sent down to the media_channel() via + // Last VideoSenderParameters sent down to the media_channel() via // SetSendParameters. - VideoSendParameters last_send_params_ RTC_GUARDED_BY(worker_thread()); - // Last VideoRecvParameters sent down to the media_channel() via + VideoSenderParameters last_send_params_ RTC_GUARDED_BY(worker_thread()); + // Last VideoReceiverParameters sent down to the media_channel() via // SetRecvParameters. - VideoRecvParameters last_recv_params_ RTC_GUARDED_BY(worker_thread()); + VideoReceiverParameters last_recv_params_ RTC_GUARDED_BY(worker_thread()); }; } // namespace cricket diff --git a/pc/rtp_sender_receiver_unittest.cc b/pc/rtp_sender_receiver_unittest.cc index 09470d657d..18a5505f39 100644 --- a/pc/rtp_sender_receiver_unittest.cc +++ b/pc/rtp_sender_receiver_unittest.cc @@ -172,7 +172,7 @@ class RtpSenderReceiverTest // Needed to use DTMF sender. void AddDtmfCodec() { - cricket::AudioSendParameters params; + cricket::AudioSenderParameter params; const cricket::AudioCodec kTelephoneEventCodec = cricket::CreateAudioCodec(106, "telephone-event", 8000, 1); params.codecs.push_back(kTelephoneEventCodec); diff --git a/pc/test/mock_voice_media_receive_channel_interface.h b/pc/test/mock_voice_media_receive_channel_interface.h index b53c204f0d..98723bcc36 100644 --- a/pc/test/mock_voice_media_receive_channel_interface.h +++ b/pc/test/mock_voice_media_receive_channel_interface.h @@ -35,7 +35,7 @@ class MockVoiceMediaReceiveChannelInterface // VoiceMediaReceiveChannelInterface MOCK_METHOD(bool, SetRecvParameters, - (const AudioRecvParameters& params), + (const AudioReceiverParameters& params), (override)); MOCK_METHOD(webrtc::RtpParameters, GetRtpReceiveParameters,