Rename PayloadRouter to RtpVideoSender.
Bug: webrtc:9517
Change-Id: I18397a28067dbe5029fc80fe2eef360869abb339
Reviewed-on: https://webrtc-review.googlesource.com/89380
Commit-Queue: Stefan Holmer <stefan@webrtc.org>
Reviewed-by: Björn Terelius <terelius@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#24039}diff --git a/call/BUILD.gn b/call/BUILD.gn
index 7204dcc..afba0a4 100644
--- a/call/BUILD.gn
+++ b/call/BUILD.gn
@@ -100,13 +100,13 @@
rtc_source_set("rtp_sender") {
sources = [
- "payload_router.cc",
- "payload_router.h",
"rtp_payload_params.cc",
"rtp_payload_params.h",
"rtp_transport_controller_send.cc",
"rtp_transport_controller_send.h",
- "video_rtp_sender_interface.h",
+ "rtp_video_sender.cc",
+ "rtp_video_sender.h",
+ "rtp_video_sender_interface.h",
]
deps = [
":bitrate_configurator",
@@ -284,13 +284,13 @@
"bitrate_estimator_tests.cc",
"call_unittest.cc",
"flexfec_receive_stream_unittest.cc",
- "payload_router_unittest.cc",
"receive_time_calculator_unittest.cc",
"rtcp_demuxer_unittest.cc",
"rtp_bitrate_configurator_unittest.cc",
"rtp_demuxer_unittest.cc",
"rtp_payload_params_unittest.cc",
"rtp_rtcp_demuxer_helper_unittest.cc",
+ "rtp_video_sender_unittest.cc",
"rtx_receive_stream_unittest.cc",
]
deps = [
diff --git a/call/rtp_payload_params_unittest.cc b/call/rtp_payload_params_unittest.cc
index cdfbc70..96aa591 100644
--- a/call/rtp_payload_params_unittest.cc
+++ b/call/rtp_payload_params_unittest.cc
@@ -10,7 +10,7 @@
#include <memory>
-#include "call/payload_router.h"
+#include "call/rtp_payload_params.h"
#include "modules/video_coding/include/video_codec_interface.h"
#include "test/gtest.h"
diff --git a/call/rtp_transport_controller_send.cc b/call/rtp_transport_controller_send.cc
index ed01815..b0dd8d8 100644
--- a/call/rtp_transport_controller_send.cc
+++ b/call/rtp_transport_controller_send.cc
@@ -84,7 +84,7 @@
process_thread_->DeRegisterModule(&pacer_);
}
-VideoRtpSenderInterface* RtpTransportControllerSend::CreateVideoRtpSender(
+RtpVideoSenderInterface* RtpTransportControllerSend::CreateRtpVideoSender(
const std::vector<uint32_t>& ssrcs,
std::map<uint32_t, RtpState> suspended_ssrcs,
const std::map<uint32_t, RtpPayloadState>& states,
@@ -93,7 +93,7 @@
Transport* send_transport,
const RtpSenderObservers& observers,
RtcEventLog* event_log) {
- video_rtp_senders_.push_back(absl::make_unique<PayloadRouter>(
+ video_rtp_senders_.push_back(absl::make_unique<RtpVideoSender>(
ssrcs, suspended_ssrcs, states, rtp_config, rtcp_config, send_transport,
observers,
// TODO(holmer): Remove this circular dependency by injecting
@@ -102,9 +102,9 @@
return video_rtp_senders_.back().get();
}
-void RtpTransportControllerSend::DestroyVideoRtpSender(
- VideoRtpSenderInterface* rtp_video_sender) {
- std::vector<std::unique_ptr<VideoRtpSenderInterface>>::iterator it =
+void RtpTransportControllerSend::DestroyRtpVideoSender(
+ RtpVideoSenderInterface* rtp_video_sender) {
+ std::vector<std::unique_ptr<RtpVideoSenderInterface>>::iterator it =
video_rtp_senders_.end();
for (it = video_rtp_senders_.begin(); it != video_rtp_senders_.end(); ++it) {
if (it->get() == rtp_video_sender) {
diff --git a/call/rtp_transport_controller_send.h b/call/rtp_transport_controller_send.h
index f120ce0..496a00e 100644
--- a/call/rtp_transport_controller_send.h
+++ b/call/rtp_transport_controller_send.h
@@ -17,9 +17,9 @@
#include <vector>
#include "api/transport/network_control.h"
-#include "call/payload_router.h"
#include "call/rtp_bitrate_configurator.h"
#include "call/rtp_transport_controller_send_interface.h"
+#include "call/rtp_video_sender.h"
#include "common_types.h" // NOLINT(build/include)
#include "modules/congestion_controller/include/send_side_congestion_controller_interface.h"
#include "modules/pacing/packet_router.h"
@@ -46,7 +46,7 @@
const BitrateConstraints& bitrate_config);
~RtpTransportControllerSend() override;
- VideoRtpSenderInterface* CreateVideoRtpSender(
+ RtpVideoSenderInterface* CreateRtpVideoSender(
const std::vector<uint32_t>& ssrcs,
std::map<uint32_t, RtpState> suspended_ssrcs,
const std::map<uint32_t, RtpPayloadState>&
@@ -56,8 +56,8 @@
Transport* send_transport,
const RtpSenderObservers& observers,
RtcEventLog* event_log) override;
- void DestroyVideoRtpSender(
- VideoRtpSenderInterface* rtp_video_sender) override;
+ void DestroyRtpVideoSender(
+ RtpVideoSenderInterface* rtp_video_sender) override;
// Implements NetworkChangedObserver interface.
void OnNetworkChanged(uint32_t bitrate_bps,
@@ -105,7 +105,7 @@
private:
const Clock* const clock_;
PacketRouter packet_router_;
- std::vector<std::unique_ptr<VideoRtpSenderInterface>> video_rtp_senders_;
+ std::vector<std::unique_ptr<RtpVideoSenderInterface>> video_rtp_senders_;
PacedSender pacer_;
RtpKeepAliveConfig keepalive_;
RtpBitrateConfigurator bitrate_configurator_;
diff --git a/call/rtp_transport_controller_send_interface.h b/call/rtp_transport_controller_send_interface.h
index b9e84ae..828fec4 100644
--- a/call/rtp_transport_controller_send_interface.h
+++ b/call/rtp_transport_controller_send_interface.h
@@ -39,7 +39,7 @@
class PacedSender;
class PacketFeedbackObserver;
class PacketRouter;
-class VideoRtpSenderInterface;
+class RtpVideoSenderInterface;
class RateLimiter;
class RtcpBandwidthObserver;
class RtpPacketSender;
@@ -90,7 +90,7 @@
virtual rtc::TaskQueue* GetWorkerQueue() = 0;
virtual PacketRouter* packet_router() = 0;
- virtual VideoRtpSenderInterface* CreateVideoRtpSender(
+ virtual RtpVideoSenderInterface* CreateRtpVideoSender(
const std::vector<uint32_t>& ssrcs,
std::map<uint32_t, RtpState> suspended_ssrcs,
// TODO(holmer): Move states into RtpTransportControllerSend.
@@ -100,8 +100,8 @@
Transport* send_transport,
const RtpSenderObservers& observers,
RtcEventLog* event_log) = 0;
- virtual void DestroyVideoRtpSender(
- VideoRtpSenderInterface* rtp_video_sender) = 0;
+ virtual void DestroyRtpVideoSender(
+ RtpVideoSenderInterface* rtp_video_sender) = 0;
virtual TransportFeedbackObserver* transport_feedback_observer() = 0;
diff --git a/call/payload_router.cc b/call/rtp_video_sender.cc
similarity index 90%
rename from call/payload_router.cc
rename to call/rtp_video_sender.cc
index 4e7d13e..a7a5770 100644
--- a/call/payload_router.cc
+++ b/call/rtp_video_sender.cc
@@ -8,7 +8,7 @@
* be found in the AUTHORS file in the root of the source tree.
*/
-#include "call/payload_router.h"
+#include "call/rtp_video_sender.h"
#include <memory>
#include <string>
@@ -161,16 +161,17 @@
}
} // namespace
-PayloadRouter::PayloadRouter(const std::vector<uint32_t>& ssrcs,
- std::map<uint32_t, RtpState> suspended_ssrcs,
- const std::map<uint32_t, RtpPayloadState>& states,
- const RtpConfig& rtp_config,
- const RtcpConfig& rtcp_config,
- Transport* send_transport,
- const RtpSenderObservers& observers,
- RtpTransportControllerSendInterface* transport,
- RtcEventLog* event_log,
- RateLimiter* retransmission_limiter)
+RtpVideoSender::RtpVideoSender(
+ const std::vector<uint32_t>& ssrcs,
+ std::map<uint32_t, RtpState> suspended_ssrcs,
+ const std::map<uint32_t, RtpPayloadState>& states,
+ const RtpConfig& rtp_config,
+ const RtcpConfig& rtcp_config,
+ Transport* send_transport,
+ const RtpSenderObservers& observers,
+ RtpTransportControllerSendInterface* transport,
+ RtcEventLog* event_log,
+ RateLimiter* retransmission_limiter)
: active_(false),
module_process_thread_(nullptr),
suspended_ssrcs_(std::move(suspended_ssrcs)),
@@ -254,13 +255,13 @@
}
}
-PayloadRouter::~PayloadRouter() {
+RtpVideoSender::~RtpVideoSender() {
for (auto& rtp_rtcp : rtp_modules_) {
transport_->packet_router()->RemoveSendRtpModule(rtp_rtcp.get());
}
}
-void PayloadRouter::RegisterProcessThread(
+void RtpVideoSender::RegisterProcessThread(
ProcessThread* module_process_thread) {
RTC_DCHECK_RUN_ON(&module_process_thread_checker_);
RTC_DCHECK(!module_process_thread_);
@@ -270,13 +271,13 @@
module_process_thread_->RegisterModule(rtp_rtcp.get(), RTC_FROM_HERE);
}
-void PayloadRouter::DeRegisterProcessThread() {
+void RtpVideoSender::DeRegisterProcessThread() {
RTC_DCHECK_RUN_ON(&module_process_thread_checker_);
for (auto& rtp_rtcp : rtp_modules_)
module_process_thread_->DeRegisterModule(rtp_rtcp.get());
}
-void PayloadRouter::SetActive(bool active) {
+void RtpVideoSender::SetActive(bool active) {
rtc::CritScope lock(&crit_);
if (active_ == active)
return;
@@ -284,7 +285,7 @@
SetActiveModules(active_modules);
}
-void PayloadRouter::SetActiveModules(const std::vector<bool> active_modules) {
+void RtpVideoSender::SetActiveModules(const std::vector<bool> active_modules) {
rtc::CritScope lock(&crit_);
RTC_DCHECK_EQ(rtp_modules_.size(), active_modules.size());
active_ = false;
@@ -299,12 +300,12 @@
}
}
-bool PayloadRouter::IsActive() {
+bool RtpVideoSender::IsActive() {
rtc::CritScope lock(&crit_);
return active_ && !rtp_modules_.empty();
}
-EncodedImageCallback::Result PayloadRouter::OnEncodedImage(
+EncodedImageCallback::Result RtpVideoSender::OnEncodedImage(
const EncodedImage& encoded_image,
const CodecSpecificInfo* codec_specific_info,
const RTPFragmentationHeader* fragmentation) {
@@ -334,7 +335,7 @@
return Result(Result::OK, frame_id);
}
-void PayloadRouter::OnBitrateAllocationUpdated(
+void RtpVideoSender::OnBitrateAllocationUpdated(
const VideoBitrateAllocation& bitrate) {
rtc::CritScope lock(&crit_);
if (IsActive()) {
@@ -357,7 +358,7 @@
}
}
-void PayloadRouter::ConfigureProtection(const RtpConfig& rtp_config) {
+void RtpVideoSender::ConfigureProtection(const RtpConfig& rtp_config) {
// Consistency of FlexFEC parameters is checked in MaybeCreateFlexfecSender.
const bool flexfec_enabled = (flexfec_sender_ != nullptr);
@@ -416,28 +417,28 @@
}
}
-bool PayloadRouter::FecEnabled() const {
+bool RtpVideoSender::FecEnabled() const {
const bool flexfec_enabled = (flexfec_sender_ != nullptr);
int ulpfec_payload_type = rtp_config_.ulpfec.ulpfec_payload_type;
return flexfec_enabled || ulpfec_payload_type >= 0;
}
-bool PayloadRouter::NackEnabled() const {
+bool RtpVideoSender::NackEnabled() const {
const bool nack_enabled = rtp_config_.nack.rtp_history_ms > 0;
return nack_enabled;
}
-void PayloadRouter::DeliverRtcp(const uint8_t* packet, size_t length) {
+void RtpVideoSender::DeliverRtcp(const uint8_t* packet, size_t length) {
// Runs on a network thread.
for (auto& rtp_rtcp : rtp_modules_)
rtp_rtcp->IncomingRtcpPacket(packet, length);
}
-void PayloadRouter::ProtectionRequest(const FecProtectionParams* delta_params,
- const FecProtectionParams* key_params,
- uint32_t* sent_video_rate_bps,
- uint32_t* sent_nack_rate_bps,
- uint32_t* sent_fec_rate_bps) {
+void RtpVideoSender::ProtectionRequest(const FecProtectionParams* delta_params,
+ const FecProtectionParams* key_params,
+ uint32_t* sent_video_rate_bps,
+ uint32_t* sent_nack_rate_bps,
+ uint32_t* sent_fec_rate_bps) {
*sent_video_rate_bps = 0;
*sent_nack_rate_bps = 0;
*sent_fec_rate_bps = 0;
@@ -455,13 +456,13 @@
}
}
-void PayloadRouter::SetMaxRtpPacketSize(size_t max_rtp_packet_size) {
+void RtpVideoSender::SetMaxRtpPacketSize(size_t max_rtp_packet_size) {
for (auto& rtp_rtcp : rtp_modules_) {
rtp_rtcp->SetMaxRtpPacketSize(max_rtp_packet_size);
}
}
-void PayloadRouter::ConfigureSsrcs(const RtpConfig& rtp_config) {
+void RtpVideoSender::ConfigureSsrcs(const RtpConfig& rtp_config) {
// Configure regular SSRCs.
for (size_t i = 0; i < rtp_config.ssrcs.size(); ++i) {
uint32_t ssrc = rtp_config.ssrcs[i];
@@ -505,14 +506,14 @@
}
}
-void PayloadRouter::OnNetworkAvailability(bool network_available) {
+void RtpVideoSender::OnNetworkAvailability(bool network_available) {
for (auto& rtp_rtcp : rtp_modules_) {
rtp_rtcp->SetRTCPStatus(network_available ? rtp_config_.rtcp_mode
: RtcpMode::kOff);
}
}
-std::map<uint32_t, RtpState> PayloadRouter::GetRtpStates() const {
+std::map<uint32_t, RtpState> RtpVideoSender::GetRtpStates() const {
std::map<uint32_t, RtpState> rtp_states;
for (size_t i = 0; i < rtp_config_.ssrcs.size(); ++i) {
@@ -534,7 +535,8 @@
return rtp_states;
}
-std::map<uint32_t, RtpPayloadState> PayloadRouter::GetRtpPayloadStates() const {
+std::map<uint32_t, RtpPayloadState> RtpVideoSender::GetRtpPayloadStates()
+ const {
rtc::CritScope lock(&crit_);
std::map<uint32_t, RtpPayloadState> payload_states;
for (const auto& param : params_) {
diff --git a/call/payload_router.h b/call/rtp_video_sender.h
similarity index 90%
rename from call/payload_router.h
rename to call/rtp_video_sender.h
index cb43f27..5c56753 100644
--- a/call/payload_router.h
+++ b/call/rtp_video_sender.h
@@ -8,8 +8,8 @@
* be found in the AUTHORS file in the root of the source tree.
*/
-#ifndef CALL_PAYLOAD_ROUTER_H_
-#define CALL_PAYLOAD_ROUTER_H_
+#ifndef CALL_RTP_VIDEO_SENDER_H_
+#define CALL_RTP_VIDEO_SENDER_H_
#include <map>
#include <memory>
@@ -20,7 +20,7 @@
#include "call/rtp_config.h"
#include "call/rtp_payload_params.h"
#include "call/rtp_transport_controller_send_interface.h"
-#include "call/video_rtp_sender_interface.h"
+#include "call/rtp_video_sender_interface.h"
#include "common_types.h" // NOLINT(build/include)
#include "logging/rtc_event_log/rtc_event_log.h"
#include "modules/rtp_rtcp/include/flexfec_sender.h"
@@ -38,12 +38,12 @@
class RtpRtcp;
class RtpTransportControllerSendInterface;
-// PayloadRouter routes outgoing data to the correct sending RTP module, based
+// RtpVideoSender routes outgoing data to the correct sending RTP module, based
// on the simulcast layer in RTPVideoHeader.
-class PayloadRouter : public VideoRtpSenderInterface {
+class RtpVideoSender : public RtpVideoSenderInterface {
public:
// Rtp modules are assumed to be sorted in simulcast index order.
- PayloadRouter(
+ RtpVideoSender(
const std::vector<uint32_t>& ssrcs,
std::map<uint32_t, RtpState> suspended_ssrcs,
const std::map<uint32_t, RtpPayloadState>& states,
@@ -54,7 +54,7 @@
RtpTransportControllerSendInterface* transport,
RtcEventLog* event_log,
RateLimiter* retransmission_limiter); // move inside RtpTransport
- ~PayloadRouter() override;
+ ~RtpVideoSender() override;
// RegisterProcessThread register |module_process_thread| with those objects
// that use it. Registration has to happen on the thread were
@@ -64,7 +64,7 @@
void RegisterProcessThread(ProcessThread* module_process_thread) override;
void DeRegisterProcessThread() override;
- // PayloadRouter will only route packets if being active, all packets will be
+ // RtpVideoSender will only route packets if being active, all packets will be
// dropped otherwise.
void SetActive(bool active) override;
// Sets the sending status of the rtp modules and appropriately sets the
@@ -120,9 +120,9 @@
std::vector<RtpPayloadParams> params_ RTC_GUARDED_BY(crit_);
- RTC_DISALLOW_COPY_AND_ASSIGN(PayloadRouter);
+ RTC_DISALLOW_COPY_AND_ASSIGN(RtpVideoSender);
};
} // namespace webrtc
-#endif // CALL_PAYLOAD_ROUTER_H_
+#endif // CALL_RTP_VIDEO_SENDER_H_
diff --git a/call/video_rtp_sender_interface.h b/call/rtp_video_sender_interface.h
similarity index 84%
rename from call/video_rtp_sender_interface.h
rename to call/rtp_video_sender_interface.h
index 0d47845..c69f1ba 100644
--- a/call/video_rtp_sender_interface.h
+++ b/call/rtp_video_sender_interface.h
@@ -8,8 +8,8 @@
* be found in the AUTHORS file in the root of the source tree.
*/
-#ifndef CALL_VIDEO_RTP_SENDER_INTERFACE_H_
-#define CALL_VIDEO_RTP_SENDER_INTERFACE_H_
+#ifndef CALL_RTP_VIDEO_SENDER_INTERFACE_H_
+#define CALL_RTP_VIDEO_SENDER_INTERFACE_H_
#include <map>
#include <vector>
@@ -23,16 +23,16 @@
class VideoBitrateAllocation;
struct FecProtectionParams;
-class VideoRtpSenderInterface : public EncodedImageCallback {
+class RtpVideoSenderInterface : public EncodedImageCallback {
public:
virtual void RegisterProcessThread(ProcessThread* module_process_thread) = 0;
virtual void DeRegisterProcessThread() = 0;
- // PayloadRouter will only route packets if being active, all packets will be
- // dropped otherwise.
+ // RtpVideoSender will only route packets if being active, all
+ // packets will be dropped otherwise.
virtual void SetActive(bool active) = 0;
// Sets the sending status of the rtp modules and appropriately sets the
- // payload router to active if any rtp modules are active.
+ // RtpVideoSender to active if any rtp modules are active.
virtual void SetActiveModules(const std::vector<bool> active_modules) = 0;
virtual bool IsActive() = 0;
@@ -57,4 +57,4 @@
const VideoBitrateAllocation& bitrate) = 0;
};
} // namespace webrtc
-#endif // CALL_VIDEO_RTP_SENDER_INTERFACE_H_
+#endif // CALL_RTP_VIDEO_SENDER_INTERFACE_H_
diff --git a/call/payload_router_unittest.cc b/call/rtp_video_sender_unittest.cc
similarity index 92%
rename from call/payload_router_unittest.cc
rename to call/rtp_video_sender_unittest.cc
index c02bad9..45f8149 100644
--- a/call/payload_router_unittest.cc
+++ b/call/rtp_video_sender_unittest.cc
@@ -11,8 +11,8 @@
#include <memory>
#include <string>
-#include "call/payload_router.h"
#include "call/rtp_transport_controller_send.h"
+#include "call/rtp_video_sender.h"
#include "modules/video_coding/include/video_codec_interface.h"
#include "rtc_base/rate_limiter.h"
#include "test/field_trial.h"
@@ -85,9 +85,9 @@
return observers;
}
-class PayloadRouterTestFixture {
+class RtpVideoSenderTestFixture {
public:
- PayloadRouterTestFixture(
+ RtpVideoSenderTestFixture(
const std::vector<uint32_t>& ssrcs,
int payload_type,
const std::map<uint32_t, RtpPayloadState>& suspended_payload_states)
@@ -106,7 +106,7 @@
}
config_.rtp.payload_type = payload_type;
std::map<uint32_t, RtpState> suspended_ssrcs;
- router_ = absl::make_unique<PayloadRouter>(
+ router_ = absl::make_unique<RtpVideoSender>(
config_.rtp.ssrcs, suspended_ssrcs, suspended_payload_states,
config_.rtp, config_.rtcp, &transport_,
CreateObservers(&call_stats_, &encoder_feedback_, &stats_proxy_,
@@ -116,7 +116,7 @@
&transport_controller_, &event_log_, &retransmission_rate_limiter_);
}
- PayloadRouter* router() { return router_.get(); }
+ RtpVideoSender* router() { return router_.get(); }
private:
NiceMock<MockTransport> transport_;
@@ -133,11 +133,11 @@
CallStats call_stats_;
SendStatisticsProxy stats_proxy_;
RateLimiter retransmission_rate_limiter_;
- std::unique_ptr<PayloadRouter> router_;
+ std::unique_ptr<RtpVideoSender> router_;
};
} // namespace
-TEST(PayloadRouterTest, SendOnOneModule) {
+TEST(RtpVideoSenderTest, SendOnOneModule) {
uint8_t payload = 'a';
EncodedImage encoded_image;
encoded_image._timeStamp = 1;
@@ -146,7 +146,7 @@
encoded_image._buffer = &payload;
encoded_image._length = 1;
- PayloadRouterTestFixture test({kSsrc1}, kPayloadType, {});
+ RtpVideoSenderTestFixture test({kSsrc1}, kPayloadType, {});
EXPECT_NE(
EncodedImageCallback::Result::OK,
test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error);
@@ -167,7 +167,7 @@
test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error);
}
-TEST(PayloadRouterTest, SendSimulcastSetActive) {
+TEST(RtpVideoSenderTest, SendSimulcastSetActive) {
uint8_t payload = 'a';
EncodedImage encoded_image;
encoded_image._timeStamp = 1;
@@ -176,7 +176,7 @@
encoded_image._buffer = &payload;
encoded_image._length = 1;
- PayloadRouterTestFixture test({kSsrc1, kSsrc2}, kPayloadType, {});
+ RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, kPayloadType, {});
CodecSpecificInfo codec_info_1;
memset(&codec_info_1, 0, sizeof(CodecSpecificInfo));
@@ -214,7 +214,7 @@
// behavior of the payload router. First sets one module to active and checks
// that outgoing data can be sent on this module, and checks that no data can
// be sent if both modules are inactive.
-TEST(PayloadRouterTest, SendSimulcastSetActiveModules) {
+TEST(RtpVideoSenderTest, SendSimulcastSetActiveModules) {
uint8_t payload = 'a';
EncodedImage encoded_image;
encoded_image._timeStamp = 1;
@@ -223,7 +223,7 @@
encoded_image._buffer = &payload;
encoded_image._length = 1;
- PayloadRouterTestFixture test({kSsrc1, kSsrc2}, kPayloadType, {});
+ RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, kPayloadType, {});
CodecSpecificInfo codec_info_1;
memset(&codec_info_1, 0, sizeof(CodecSpecificInfo));
codec_info_1.codecType = kVideoCodecVP8;
@@ -258,8 +258,8 @@
.error);
}
-TEST(PayloadRouterTest, CreateWithNoPreviousStates) {
- PayloadRouterTestFixture test({kSsrc1, kSsrc2}, kPayloadType, {});
+TEST(RtpVideoSenderTest, CreateWithNoPreviousStates) {
+ RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, kPayloadType, {});
test.router()->SetActive(true);
std::map<uint32_t, RtpPayloadState> initial_states =
@@ -269,7 +269,7 @@
EXPECT_NE(initial_states.find(kSsrc2), initial_states.end());
}
-TEST(PayloadRouterTest, CreateWithPreviousStates) {
+TEST(RtpVideoSenderTest, CreateWithPreviousStates) {
RtpPayloadState state1;
state1.picture_id = kInitialPictureId1;
state1.tl0_pic_idx = kInitialTl0PicIdx1;
@@ -279,7 +279,7 @@
std::map<uint32_t, RtpPayloadState> states = {{kSsrc1, state1},
{kSsrc2, state2}};
- PayloadRouterTestFixture test({kSsrc1, kSsrc2}, kPayloadType, states);
+ RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, kPayloadType, states);
test.router()->SetActive(true);
std::map<uint32_t, RtpPayloadState> initial_states =
diff --git a/call/test/mock_rtp_transport_controller_send.h b/call/test/mock_rtp_transport_controller_send.h
index 1939c1e..828b030 100644
--- a/call/test/mock_rtp_transport_controller_send.h
+++ b/call/test/mock_rtp_transport_controller_send.h
@@ -30,8 +30,8 @@
: public RtpTransportControllerSendInterface {
public:
MOCK_METHOD8(
- CreateVideoRtpSender,
- VideoRtpSenderInterface*(const std::vector<uint32_t>&,
+ CreateRtpVideoSender,
+ RtpVideoSenderInterface*(const std::vector<uint32_t>&,
std::map<uint32_t, RtpState>,
const std::map<uint32_t, RtpPayloadState>&,
const RtpConfig&,
@@ -39,7 +39,7 @@
Transport*,
const RtpSenderObservers&,
RtcEventLog*));
- MOCK_METHOD1(DestroyVideoRtpSender, void(VideoRtpSenderInterface*));
+ MOCK_METHOD1(DestroyRtpVideoSender, void(RtpVideoSenderInterface*));
MOCK_METHOD0(GetWorkerQueue, rtc::TaskQueue*());
MOCK_METHOD0(packet_router, PacketRouter*());
MOCK_METHOD0(transport_feedback_observer, TransportFeedbackObserver*());
diff --git a/call/video_send_stream.h b/call/video_send_stream.h
index eada8fe..428ae20 100644
--- a/call/video_send_stream.h
+++ b/call/video_send_stream.h
@@ -17,8 +17,6 @@
#include <vector>
#include "api/call/transport.h"
-#include "api/rtp_headers.h"
-#include "api/rtpparameters.h"
#include "api/video/video_sink_interface.h"
#include "api/video/video_source_interface.h"
#include "api/video_codecs/video_encoder_config.h"
diff --git a/video/video_send_stream.h b/video/video_send_stream.h
index b0e4071..69c2401 100644
--- a/video/video_send_stream.h
+++ b/video/video_send_stream.h
@@ -17,7 +17,6 @@
#include "api/fec_controller.h"
#include "call/bitrate_allocator.h"
-#include "call/payload_router.h"
#include "call/video_receive_stream.h"
#include "call/video_send_stream.h"
#include "common_video/libyuv/include/webrtc_libyuv.h"
diff --git a/video/video_send_stream_impl.cc b/video/video_send_stream_impl.cc
index 303dc54..f660725 100644
--- a/video/video_send_stream_impl.cc
+++ b/video/video_send_stream_impl.cc
@@ -111,16 +111,7 @@
return static_cast<int>((bitrate_bps + packet_size_bits - 1) /
packet_size_bits);
}
-// call_stats,
-// &encoder_feedback_,
-// stats_proxy_,
-// stats_proxy_,
-// stats_proxy_,
-// stats_proxy_,
-// stats_proxy_,
-// stats_proxy_,
-// send_delay_stats,
-// this
+
RtpSenderObservers CreateObservers(CallStats* call_stats,
EncoderRtcpFeedback* encoder_feedback,
SendStatisticsProxy* stats_proxy,
@@ -229,8 +220,8 @@
config_->rtp.ssrcs,
video_stream_encoder),
bandwidth_observer_(transport->GetBandwidthObserver()),
- payload_router_(
- transport_->CreateVideoRtpSender(config_->rtp.ssrcs,
+ rtp_video_sender_(
+ transport_->CreateRtpVideoSender(config_->rtp.ssrcs,
suspended_ssrcs,
suspended_payload_states,
config_->rtp,
@@ -304,8 +295,8 @@
// Currently, both ULPFEC and FlexFEC use the same FEC rate calculation logic,
// so enable that logic if either of those FEC schemes are enabled.
- fec_controller_->SetProtectionMethod(payload_router_->FecEnabled(),
- payload_router_->NackEnabled());
+ fec_controller_->SetProtectionMethod(rtp_video_sender_->FecEnabled(),
+ rtp_video_sender_->NackEnabled());
fec_controller_->SetProtectionCallback(this);
// Signal congestion controller this object is ready for OnPacket* callbacks.
@@ -335,28 +326,28 @@
VideoSendStreamImpl::~VideoSendStreamImpl() {
RTC_DCHECK_RUN_ON(worker_queue_);
- RTC_DCHECK(!payload_router_->IsActive())
+ RTC_DCHECK(!rtp_video_sender_->IsActive())
<< "VideoSendStreamImpl::Stop not called";
RTC_LOG(LS_INFO) << "~VideoSendStreamInternal: " << config_->ToString();
if (fec_controller_->UseLossVectorMask()) {
transport_->DeRegisterPacketFeedbackObserver(this);
}
- transport_->DestroyVideoRtpSender(payload_router_);
+ transport_->DestroyRtpVideoSender(rtp_video_sender_);
}
void VideoSendStreamImpl::RegisterProcessThread(
ProcessThread* module_process_thread) {
- payload_router_->RegisterProcessThread(module_process_thread);
+ rtp_video_sender_->RegisterProcessThread(module_process_thread);
}
void VideoSendStreamImpl::DeRegisterProcessThread() {
- payload_router_->DeRegisterProcessThread();
+ rtp_video_sender_->DeRegisterProcessThread();
}
bool VideoSendStreamImpl::DeliverRtcp(const uint8_t* packet, size_t length) {
// Runs on a network thread.
RTC_DCHECK(!worker_queue_->IsCurrent());
- payload_router_->DeliverRtcp(packet, length);
+ rtp_video_sender_->DeliverRtcp(packet, length);
return true;
}
@@ -364,12 +355,12 @@
const std::vector<bool> active_layers) {
RTC_DCHECK_RUN_ON(worker_queue_);
RTC_LOG(LS_INFO) << "VideoSendStream::UpdateActiveSimulcastLayers";
- bool previously_active = payload_router_->IsActive();
- payload_router_->SetActiveModules(active_layers);
- if (!payload_router_->IsActive() && previously_active) {
+ bool previously_active = rtp_video_sender_->IsActive();
+ rtp_video_sender_->SetActiveModules(active_layers);
+ if (!rtp_video_sender_->IsActive() && previously_active) {
// Payload router switched from active to inactive.
StopVideoSendStream();
- } else if (payload_router_->IsActive() && !previously_active) {
+ } else if (rtp_video_sender_->IsActive() && !previously_active) {
// Payload router switched from inactive to active.
StartupVideoSendStream();
}
@@ -378,10 +369,10 @@
void VideoSendStreamImpl::Start() {
RTC_DCHECK_RUN_ON(worker_queue_);
RTC_LOG(LS_INFO) << "VideoSendStream::Start";
- if (payload_router_->IsActive())
+ if (rtp_video_sender_->IsActive())
return;
TRACE_EVENT_INSTANT0("webrtc", "VideoSendStream::Start");
- payload_router_->SetActive(true);
+ rtp_video_sender_->SetActive(true);
StartupVideoSendStream();
}
@@ -410,10 +401,10 @@
void VideoSendStreamImpl::Stop() {
RTC_DCHECK_RUN_ON(worker_queue_);
RTC_LOG(LS_INFO) << "VideoSendStream::Stop";
- if (!payload_router_->IsActive())
+ if (!rtp_video_sender_->IsActive())
return;
TRACE_EVENT_INSTANT0("webrtc", "VideoSendStream::Stop");
- payload_router_->SetActive(false);
+ rtp_video_sender_->SetActive(false);
StopVideoSendStream();
}
@@ -441,7 +432,7 @@
void VideoSendStreamImpl::OnBitrateAllocationUpdated(
const VideoBitrateAllocation& allocation) {
- payload_router_->OnBitrateAllocationUpdated(allocation);
+ rtp_video_sender_->OnBitrateAllocationUpdated(allocation);
}
void VideoSendStreamImpl::SignalEncoderActive() {
@@ -511,7 +502,7 @@
num_temporal_layers,
config_->rtp.max_packet_size);
- if (payload_router_->IsActive()) {
+ if (rtp_video_sender_->IsActive()) {
// The send stream is started already. Update the allocator with new bitrate
// limits.
bitrate_allocator_->AddObserver(
@@ -548,7 +539,7 @@
fec_controller_->UpdateWithEncodedData(encoded_image._length,
encoded_image._frameType);
- EncodedImageCallback::Result result = payload_router_->OnEncodedImage(
+ EncodedImageCallback::Result result = rtp_video_sender_->OnEncodedImage(
encoded_image, codec_specific_info, fragmentation);
RTC_DCHECK(codec_specific_info);
@@ -569,12 +560,12 @@
}
std::map<uint32_t, RtpState> VideoSendStreamImpl::GetRtpStates() const {
- return payload_router_->GetRtpStates();
+ return rtp_video_sender_->GetRtpStates();
}
std::map<uint32_t, RtpPayloadState> VideoSendStreamImpl::GetRtpPayloadStates()
const {
- return payload_router_->GetRtpPayloadStates();
+ return rtp_video_sender_->GetRtpPayloadStates();
}
uint32_t VideoSendStreamImpl::OnBitrateUpdated(uint32_t bitrate_bps,
@@ -582,7 +573,7 @@
int64_t rtt,
int64_t probing_interval_ms) {
RTC_DCHECK_RUN_ON(worker_queue_);
- RTC_DCHECK(payload_router_->IsActive())
+ RTC_DCHECK(rtp_video_sender_->IsActive())
<< "VideoSendStream::Start has not been called.";
// Substract overhead from bitrate.
@@ -657,9 +648,9 @@
uint32_t* sent_nack_rate_bps,
uint32_t* sent_fec_rate_bps) {
RTC_DCHECK_RUN_ON(worker_queue_);
- payload_router_->ProtectionRequest(delta_params, key_params,
- sent_video_rate_bps, sent_nack_rate_bps,
- sent_fec_rate_bps);
+ rtp_video_sender_->ProtectionRequest(delta_params, key_params,
+ sent_video_rate_bps, sent_nack_rate_bps,
+ sent_fec_rate_bps);
return 0;
}
@@ -681,7 +672,7 @@
std::min(config_->rtp.max_packet_size,
kPathMTU - transport_overhead_bytes_per_packet_);
- payload_router_->SetMaxRtpPacketSize(rtp_packet_size);
+ rtp_video_sender_->SetMaxRtpPacketSize(rtp_packet_size);
}
void VideoSendStreamImpl::OnPacketAdded(uint32_t ssrc, uint16_t seq_num) {
diff --git a/video/video_send_stream_impl.h b/video/video_send_stream_impl.h
index ae2e4f4..322c89a 100644
--- a/video/video_send_stream_impl.h
+++ b/video/video_send_stream_impl.h
@@ -16,7 +16,7 @@
#include <vector>
#include "call/bitrate_allocator.h"
-#include "call/payload_router.h"
+#include "call/rtp_video_sender_interface.h"
#include "common_types.h" // NOLINT(build/include)
#include "common_video/include/video_bitrate_allocator.h"
#include "modules/utility/include/process_thread.h"
@@ -170,7 +170,7 @@
EncoderRtcpFeedback encoder_feedback_;
RtcpBandwidthObserver* const bandwidth_observer_;
- VideoRtpSenderInterface* const payload_router_;
+ RtpVideoSenderInterface* const rtp_video_sender_;
// |weak_ptr_| to our self. This is used since we can not call
// |weak_ptr_factory_.GetWeakPtr| from multiple sequences but it is ok to copy
diff --git a/video/video_send_stream_impl_unittest.cc b/video/video_send_stream_impl_unittest.cc
index 66deb68..78a20c0 100644
--- a/video/video_send_stream_impl_unittest.cc
+++ b/video/video_send_stream_impl_unittest.cc
@@ -10,7 +10,7 @@
#include <string>
-#include "call/payload_router.h"
+#include "call/rtp_video_sender.h"
#include "call/test/mock_bitrate_allocator.h"
#include "call/test/mock_rtp_transport_controller_send.h"
#include "logging/rtc_event_log/rtc_event_log.h"
@@ -44,7 +44,7 @@
AlrExperimentSettings::kScreenshareProbingBweExperimentName) +
"/1.0,2875,80,40,-60,3/";
}
-class MockPayloadRouter : public VideoRtpSenderInterface {
+class MockPayloadRouter : public RtpVideoSenderInterface {
public:
MOCK_METHOD1(RegisterProcessThread, void(ProcessThread*));
MOCK_METHOD0(DeRegisterProcessThread, void());
@@ -93,7 +93,7 @@
EXPECT_CALL(transport_controller_, packet_router())
.WillRepeatedly(Return(&packet_router_));
EXPECT_CALL(transport_controller_,
- CreateVideoRtpSender(_, _, _, _, _, _, _, _))
+ CreateRtpVideoSender(_, _, _, _, _, _, _, _))
.WillRepeatedly(Return(&payload_router_));
EXPECT_CALL(payload_router_, SetActive(_))
.WillRepeatedly(testing::Invoke(
diff --git a/video/video_stream_decoder.cc b/video/video_stream_decoder.cc
index 10af016..c144217 100644
--- a/video/video_stream_decoder.cc
+++ b/video/video_stream_decoder.cc
@@ -14,7 +14,6 @@
#include <map>
#include <vector>
-#include "call/payload_router.h"
#include "modules/video_coding/video_coding_impl.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
