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

Use separate rtp module lists for send and receive in PacketRouter.

Browse Source 
This makes it possible to handle send and receive streams with the same SSRC, which is currently the case in some peer connection tests.

Also moves sending transport feedback to the pacer thread.

BUG=webrtc:5263

Review URL: https://codereview.webrtc.org/1628683002

Cr-Commit-Position: refs/heads/master@{#11443}
This commit is contained in:
stefan 2016-02-01 04:39:55 -08:00 committed by Commit bot
parent 1f611fa58b
commit bba9dec4d5
14 changed files with 171 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
webrtc/audio/audio_receive_stream.cc
View File

@ -117,8 +117,8 @@ AudioReceiveStream::AudioReceiveStream(
}
}
// Configure bandwidth estimation.
channel_proxy_->SetCongestionControlObjects(
nullptr, nullptr, congestion_controller->packet_router());
channel_proxy_->RegisterReceiverCongestionControlObjects(
congestion_controller->packet_router());
if (config.combined_audio_video_bwe) {
if (UseSendSideBwe(config)) {
remote_bitrate_estimator_ =
@ -134,7 +134,7 @@ AudioReceiveStream::AudioReceiveStream(
AudioReceiveStream::~AudioReceiveStream() {
RTC_DCHECK(thread_checker_.CalledOnValidThread());
LOG(LS_INFO) << "~AudioReceiveStream: " << config_.ToString();
channel_proxy_->SetCongestionControlObjects(nullptr, nullptr, nullptr);
channel_proxy_->ResetCongestionControlObjects();
if (remote_bitrate_estimator_) {
remote_bitrate_estimator_->RemoveStream(config_.rtp.remote_ssrc);
}

7
webrtc/audio/audio_receive_stream_unittest.cc
View File

@ -94,13 +94,12 @@ struct ConfigHelper {
EXPECT_CALL(*channel_proxy_, EnableReceiveTransportSequenceNumber(
kTransportSequenceNumberId))
.Times(1);
EXPECT_CALL(*channel_proxy_, SetCongestionControlObjects(
nullptr, nullptr, &packet_router_))
EXPECT_CALL(*channel_proxy_,
RegisterReceiverCongestionControlObjects(&packet_router_))
.Times(1);
EXPECT_CALL(congestion_controller_, packet_router())
.WillOnce(Return(&packet_router_));
EXPECT_CALL(*channel_proxy_,
SetCongestionControlObjects(nullptr, nullptr, nullptr))
EXPECT_CALL(*channel_proxy_, ResetCongestionControlObjects())
.Times(1);
return channel_proxy_;
}));

4
webrtc/audio/audio_send_stream.cc
View File

@ -68,7 +68,7 @@ AudioSendStream::AudioSendStream(
VoiceEngineImpl* voe_impl = static_cast<VoiceEngineImpl*>(voice_engine());
channel_proxy_ = voe_impl->GetChannelProxy(config_.voe_channel_id);
channel_proxy_->SetCongestionControlObjects(
channel_proxy_->RegisterSenderCongestionControlObjects(
congestion_controller->pacer(),
congestion_controller->GetTransportFeedbackObserver(),
congestion_controller->packet_router());
@ -92,7 +92,7 @@ AudioSendStream::AudioSendStream(
AudioSendStream::~AudioSendStream() {
RTC_DCHECK(thread_checker_.CalledOnValidThread());
LOG(LS_INFO) << "~AudioSendStream: " << config_.ToString();
channel_proxy_->SetCongestionControlObjects(nullptr, nullptr, nullptr);
channel_proxy_->ResetCongestionControlObjects();
}
void AudioSendStream::Start() {

5
webrtc/audio/audio_send_stream_unittest.cc
View File

@ -83,13 +83,12 @@ struct ConfigHelper {
kTransportSequenceNumberId))
.Times(1);
EXPECT_CALL(*channel_proxy_,
SetCongestionControlObjects(
RegisterSenderCongestionControlObjects(
congestion_controller_.pacer(),
congestion_controller_.GetTransportFeedbackObserver(),
congestion_controller_.packet_router()))
.Times(1);
EXPECT_CALL(*channel_proxy_,
SetCongestionControlObjects(nullptr, nullptr, nullptr))
EXPECT_CALL(*channel_proxy_, ResetCongestionControlObjects())
.Times(1);
return channel_proxy_;
}));

4
webrtc/call/congestion_controller.cc
View File

@ -171,9 +171,9 @@ CongestionController::CongestionController(ProcessThread* process_thread,
call_stats_->RegisterStatsObserver(remote_bitrate_estimator_.get());
pacer_thread_->RegisterModule(pacer_.get());
pacer_thread_->RegisterModule(remote_estimator_proxy_.get());
pacer_thread_->Start();
process_thread->RegisterModule(remote_estimator_proxy_.get());
process_thread->RegisterModule(remote_bitrate_estimator_.get());
process_thread->RegisterModule(bitrate_controller_.get());
}
@ -181,9 +181,9 @@ CongestionController::CongestionController(ProcessThread* process_thread,
CongestionController::~CongestionController() {
pacer_thread_->Stop();
pacer_thread_->DeRegisterModule(pacer_.get());
pacer_thread_->DeRegisterModule(remote_estimator_proxy_.get());
process_thread_->DeRegisterModule(bitrate_controller_.get());
process_thread_->DeRegisterModule(remote_bitrate_estimator_.get());
process_thread_->DeRegisterModule(remote_estimator_proxy_.get());
call_stats_->DeregisterStatsObserver(remote_bitrate_estimator_.get());
if (transport_feedback_adapter_.get())
call_stats_->DeregisterStatsObserver(transport_feedback_adapter_.get());

74
webrtc/modules/pacing/packet_router.cc
View File

@ -18,33 +18,64 @@
namespace webrtc {
namespace {
void AddModule(RtpRtcp* rtp_module, std::list<RtpRtcp*>* rtp_modules) {
RTC_DCHECK(std::find(rtp_modules->begin(), rtp_modules->end(), rtp_module) ==
rtp_modules->end());
rtp_modules->push_back(rtp_module);
}
void RemoveModule(RtpRtcp* rtp_module, std::list<RtpRtcp*>* rtp_modules) {
RTC_DCHECK(std::find(rtp_modules->begin(), rtp_modules->end(), rtp_module) !=
rtp_modules->end());
rtp_modules->remove(rtp_module);
}
bool SendFeedback(rtcp::TransportFeedback* packet,
std::list<RtpRtcp*>* rtp_modules) {
for (auto* rtp_module : *rtp_modules) {
packet->WithPacketSenderSsrc(rtp_module->SSRC());
if (rtp_module->SendFeedbackPacket(*packet))
return true;
}
return false;
}
}
PacketRouter::PacketRouter() : transport_seq_(0) {
pacer_thread_checker_.DetachFromThread();
}
PacketRouter::~PacketRouter() {
RTC_DCHECK(rtp_modules_.empty());
RTC_DCHECK(send_rtp_modules_.empty());
RTC_DCHECK(recv_rtp_modules_.empty());
}
void PacketRouter::AddRtpModule(RtpRtcp* rtp_module) {
rtc::CritScope cs(&modules_lock_);
RTC_DCHECK(std::find(rtp_modules_.begin(), rtp_modules_.end(), rtp_module) ==
rtp_modules_.end());
rtp_modules_.push_back(rtp_module);
void PacketRouter::AddRtpModule(RtpRtcp* rtp_module, bool sender) {
rtc::CritScope cs(&modules_crit_);
if (sender) {
AddModule(rtp_module, &send_rtp_modules_);
} else {
AddModule(rtp_module, &recv_rtp_modules_);
}
}
void PacketRouter::RemoveRtpModule(RtpRtcp* rtp_module) {
rtc::CritScope cs(&modules_lock_);
auto it = std::find(rtp_modules_.begin(), rtp_modules_.end(), rtp_module);
RTC_DCHECK(it != rtp_modules_.end());
rtp_modules_.erase(it);
void PacketRouter::RemoveRtpModule(RtpRtcp* rtp_module, bool sender) {
rtc::CritScope cs(&modules_crit_);
if (sender) {
RemoveModule(rtp_module, &send_rtp_modules_);
} else {
RemoveModule(rtp_module, &recv_rtp_modules_);
}
}
bool PacketRouter::TimeToSendPacket(uint32_t ssrc,
uint16_t sequence_number,
int64_t capture_timestamp,
bool retransmission) {
rtc::CritScope cs(&modules_lock_);
for (auto* rtp_module : rtp_modules_) {
RTC_DCHECK(pacer_thread_checker_.CalledOnValidThread());
rtc::CritScope cs(&modules_crit_);
for (auto* rtp_module : send_rtp_modules_) {
if (rtp_module->SendingMedia() && ssrc == rtp_module->SSRC()) {
return rtp_module->TimeToSendPacket(ssrc, sequence_number,
capture_timestamp, retransmission);
@ -54,9 +85,10 @@ bool PacketRouter::TimeToSendPacket(uint32_t ssrc,
}
size_t PacketRouter::TimeToSendPadding(size_t bytes_to_send) {
RTC_DCHECK(pacer_thread_checker_.CalledOnValidThread());
size_t total_bytes_sent = 0;
rtc::CritScope cs(&modules_lock_);
for (RtpRtcp* module : rtp_modules_) {
rtc::CritScope cs(&modules_crit_);
for (RtpRtcp* module : send_rtp_modules_) {
if (module->SendingMedia()) {
size_t bytes_sent =
module->TimeToSendPadding(bytes_to_send - total_bytes_sent);
@ -91,12 +123,12 @@ uint16_t PacketRouter::AllocateSequenceNumber() {
}
bool PacketRouter::SendFeedback(rtcp::TransportFeedback* packet) {
rtc::CritScope cs(&modules_lock_);
for (auto* rtp_module : rtp_modules_) {
packet->WithPacketSenderSsrc(rtp_module->SSRC());
if (rtp_module->SendFeedbackPacket(*packet))
return true;
}
RTC_DCHECK(pacer_thread_checker_.CalledOnValidThread());
rtc::CritScope cs(&modules_crit_);
if (::webrtc::SendFeedback(packet, &recv_rtp_modules_))
return true;
if (::webrtc::SendFeedback(packet, &send_rtp_modules_))
return true;
return false;
}

12
webrtc/modules/pacing/packet_router.h
View File

@ -17,6 +17,7 @@
#include "webrtc/base/criticalsection.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/base/thread_annotations.h"
#include "webrtc/base/thread_checker.h"
#include "webrtc/common_types.h"
#include "webrtc/modules/pacing/paced_sender.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
@ -36,8 +37,8 @@ class PacketRouter : public PacedSender::Callback,
PacketRouter();
virtual ~PacketRouter();
void AddRtpModule(RtpRtcp* rtp_module);
void RemoveRtpModule(RtpRtcp* rtp_module);
void AddRtpModule(RtpRtcp* rtp_module, bool sender);
void RemoveRtpModule(RtpRtcp* rtp_module, bool sender);
// Implements PacedSender::Callback.
bool TimeToSendPacket(uint32_t ssrc,
@ -54,9 +55,10 @@ class PacketRouter : public PacedSender::Callback,
virtual bool SendFeedback(rtcp::TransportFeedback* packet);
private:
rtc::CriticalSection modules_lock_;
// Map from ssrc to sending rtp module.
std::list<RtpRtcp*> rtp_modules_ GUARDED_BY(modules_lock_);
rtc::ThreadChecker pacer_thread_checker_;
rtc::CriticalSection modules_crit_;
std::list<RtpRtcp*> send_rtp_modules_ GUARDED_BY(modules_crit_);
std::list<RtpRtcp*> recv_rtp_modules_ GUARDED_BY(modules_crit_);
volatile int transport_seq_;

32
webrtc/modules/pacing/packet_router_unittest.cc
View File

@ -16,6 +16,7 @@
#include "webrtc/modules/pacing/packet_router.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
#include "webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
#include "webrtc/base/scoped_ptr.h"
using ::testing::_;
@ -35,8 +36,8 @@ class PacketRouterTest : public ::testing::Test {
TEST_F(PacketRouterTest, TimeToSendPacket) {
MockRtpRtcp rtp_1;
MockRtpRtcp rtp_2;
packet_router_->AddRtpModule(&rtp_1);
packet_router_->AddRtpModule(&rtp_2);
packet_router_->AddRtpModule(&rtp_1, true);
packet_router_->AddRtpModule(&rtp_2, true);
const uint16_t kSsrc1 = 1234;
uint16_t sequence_number = 17;
@ -88,7 +89,7 @@ TEST_F(PacketRouterTest, TimeToSendPacket) {
EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1 + kSsrc2, sequence_number,
timestamp, retransmission));
packet_router_->RemoveRtpModule(&rtp_1);
packet_router_->RemoveRtpModule(&rtp_1, true);
// rtp_1 has been removed, try sending a packet on that ssrc and make sure
// it is dropped as expected by not expecting any calls to rtp_1.
@ -98,7 +99,7 @@ TEST_F(PacketRouterTest, TimeToSendPacket) {
EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1, sequence_number,
timestamp, retransmission));
packet_router_->RemoveRtpModule(&rtp_2);
packet_router_->RemoveRtpModule(&rtp_2, true);
}
TEST_F(PacketRouterTest, TimeToSendPadding) {
@ -109,8 +110,8 @@ TEST_F(PacketRouterTest, TimeToSendPadding) {
EXPECT_CALL(rtp_1, SSRC()).WillRepeatedly(Return(kSsrc1));
MockRtpRtcp rtp_2;
EXPECT_CALL(rtp_2, SSRC()).WillRepeatedly(Return(kSsrc2));
packet_router_->AddRtpModule(&rtp_1);
packet_router_->AddRtpModule(&rtp_2);
packet_router_->AddRtpModule(&rtp_1, true);
packet_router_->AddRtpModule(&rtp_2, true);
// Default configuration, sending padding on all modules sending media,
// ordered by SSRC.
@ -146,7 +147,7 @@ TEST_F(PacketRouterTest, TimeToSendPadding) {
EXPECT_CALL(rtp_2, TimeToSendPadding(_)).Times(0);
EXPECT_EQ(0u, packet_router_->TimeToSendPadding(requested_padding_bytes));
packet_router_->RemoveRtpModule(&rtp_1);
packet_router_->RemoveRtpModule(&rtp_1, true);
// rtp_1 has been removed, try sending padding and make sure rtp_1 isn't asked
// to send by not expecting any calls. Instead verify rtp_2 is called.
@ -154,7 +155,7 @@ TEST_F(PacketRouterTest, TimeToSendPadding) {
EXPECT_CALL(rtp_2, TimeToSendPadding(requested_padding_bytes)).Times(1);
EXPECT_EQ(0u, packet_router_->TimeToSendPadding(requested_padding_bytes));
packet_router_->RemoveRtpModule(&rtp_2);
packet_router_->RemoveRtpModule(&rtp_2, true);
}
TEST_F(PacketRouterTest, AllocateSequenceNumbers) {
@ -169,4 +170,19 @@ TEST_F(PacketRouterTest, AllocateSequenceNumbers) {
EXPECT_EQ(static_cast<uint16_t>(expected_unwrapped_seq & 0xFFFF), seq);
}
}
TEST_F(PacketRouterTest, SendFeedback) {
MockRtpRtcp rtp_1;
MockRtpRtcp rtp_2;
packet_router_->AddRtpModule(&rtp_1, false);
packet_router_->AddRtpModule(&rtp_2, true);
rtcp::TransportFeedback feedback;
EXPECT_CALL(rtp_1, SendFeedbackPacket(_)).Times(1);
packet_router_->SendFeedback(&feedback);
packet_router_->RemoveRtpModule(&rtp_1, false);
EXPECT_CALL(rtp_2, SendFeedbackPacket(_)).Times(1);
packet_router_->SendFeedback(&feedback);
packet_router_->RemoveRtpModule(&rtp_2, true);
}
} // namespace webrtc

7
webrtc/test/mock_voe_channel_proxy.h
View File

@ -29,10 +29,13 @@ class MockVoEChannelProxy : public voe::ChannelProxy {
MOCK_METHOD2(SetReceiveAudioLevelIndicationStatus, void(bool enable, int id));
MOCK_METHOD1(EnableSendTransportSequenceNumber, void(int id));
MOCK_METHOD1(EnableReceiveTransportSequenceNumber, void(int id));
MOCK_METHOD3(SetCongestionControlObjects,
MOCK_METHOD3(RegisterSenderCongestionControlObjects,
void(RtpPacketSender* rtp_packet_sender,
TransportFeedbackObserver* transport_feedback_observer,
PacketRouter* seq_num_allocator));
PacketRouter* packet_router));
MOCK_METHOD1(RegisterReceiverCongestionControlObjects,
void(PacketRouter* packet_router));
MOCK_METHOD0(ResetCongestionControlObjects, void());
MOCK_CONST_METHOD0(GetRTCPStatistics, CallStatistics());
MOCK_CONST_METHOD0(GetRemoteRTCPReportBlocks, std::vector<ReportBlock>());
MOCK_CONST_METHOD0(GetNetworkStatistics, NetworkStatistics());

8
webrtc/video/vie_channel.cc
View File

@ -150,7 +150,7 @@ int32_t ViEChannel::Init() {
for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
rtp_rtcp->SetStorePacketsStatus(true, nack_history_size_sender_);
}
packet_router_->AddRtpModule(rtp_rtcp_modules_[0]);
packet_router_->AddRtpModule(rtp_rtcp_modules_[0], sender_);
if (sender_) {
std::list<RtpRtcp*> send_rtp_modules(1, rtp_rtcp_modules_[0]);
send_payload_router_->SetSendingRtpModules(send_rtp_modules);
@ -179,7 +179,7 @@ ViEChannel::~ViEChannel() {
module_process_thread_->DeRegisterModule(&vie_sync_);
send_payload_router_->SetSendingRtpModules(std::list<RtpRtcp*>());
for (size_t i = 0; i < num_active_rtp_rtcp_modules_; ++i)
packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i]);
packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i], sender_);
for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
module_process_thread_->DeRegisterModule(rtp_rtcp);
delete rtp_rtcp;
@ -400,12 +400,12 @@ int32_t ViEChannel::SetSendCodec(const VideoCodec& video_codec,
// Deregister previously registered modules.
for (size_t i = num_active_modules; i < num_prev_active_modules; ++i) {
module_process_thread_->DeRegisterModule(rtp_rtcp_modules_[i]);
packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i]);
packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i], sender_);
}
// Register new active modules.
for (size_t i = num_prev_active_modules; i < num_active_modules; ++i) {
module_process_thread_->RegisterModule(rtp_rtcp_modules_[i]);
packet_router_->AddRtpModule(rtp_rtcp_modules_[i]);
packet_router_->AddRtpModule(rtp_rtcp_modules_[i], sender_);
}
return 0;
}

73
webrtc/voice_engine/channel.cc
View File

@ -124,6 +124,12 @@ class RtpPacketSenderProxy : public RtpPacketSender {
rtp_packet_sender_ = rtp_packet_sender;
}
bool HasPacketSender() const {
RTC_DCHECK(thread_checker_.CalledOnValidThread());
rtc::CritScope lock(&crit_);
return rtp_packet_sender_ != nullptr;
}
// Implements RtpPacketSender.
void InsertPacket(Priority priority,
uint32_t ssrc,
@ -813,12 +819,9 @@ Channel::Channel(int32_t channelId,
network_predictor_(new NetworkPredictor(Clock::GetRealTimeClock())),
associate_send_channel_(ChannelOwner(nullptr)),
pacing_enabled_(config.Get<VoicePacing>().enabled),
feedback_observer_proxy_(pacing_enabled_ ? new TransportFeedbackProxy()
: nullptr),
seq_num_allocator_proxy_(
pacing_enabled_ ? new TransportSequenceNumberProxy() : nullptr),
rtp_packet_sender_proxy_(pacing_enabled_ ? new RtpPacketSenderProxy()
: nullptr) {
feedback_observer_proxy_(new TransportFeedbackProxy()),
seq_num_allocator_proxy_(new TransportSequenceNumberProxy()),
rtp_packet_sender_proxy_(new RtpPacketSenderProxy()) {
WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, _channelId),
"Channel::Channel() - ctor");
AudioCodingModule::Config acm_config;
@ -843,10 +846,12 @@ Channel::Channel(int32_t channelId,
configuration.audio_messages = this;
configuration.receive_statistics = rtp_receive_statistics_.get();
configuration.bandwidth_callback = rtcp_observer_.get();
configuration.paced_sender = rtp_packet_sender_proxy_.get();
configuration.transport_sequence_number_allocator =
seq_num_allocator_proxy_.get();
configuration.transport_feedback_callback = feedback_observer_proxy_.get();
if (pacing_enabled_) {
configuration.paced_sender = rtp_packet_sender_proxy_.get();
configuration.transport_sequence_number_allocator =
seq_num_allocator_proxy_.get();
configuration.transport_feedback_callback = feedback_observer_proxy_.get();
}
configuration.event_log = event_log;
_rtpRtcpModule.reset(RtpRtcp::CreateRtpRtcp(configuration));
@ -2582,32 +2587,40 @@ void Channel::EnableReceiveTransportSequenceNumber(int id) {
RTC_DCHECK(ret);
}
void Channel::SetCongestionControlObjects(
void Channel::RegisterSenderCongestionControlObjects(
RtpPacketSender* rtp_packet_sender,
TransportFeedbackObserver* transport_feedback_observer,
PacketRouter* packet_router) {
RTC_DCHECK(packet_router != nullptr || packet_router_ != nullptr);
if (transport_feedback_observer) {
RTC_DCHECK(feedback_observer_proxy_.get());
feedback_observer_proxy_->SetTransportFeedbackObserver(
transport_feedback_observer);
}
if (rtp_packet_sender) {
RTC_DCHECK(rtp_packet_sender_proxy_.get());
rtp_packet_sender_proxy_->SetPacketSender(rtp_packet_sender);
}
if (seq_num_allocator_proxy_.get()) {
seq_num_allocator_proxy_->SetSequenceNumberAllocator(packet_router);
}
_rtpRtcpModule->SetStorePacketsStatus(rtp_packet_sender != nullptr, 600);
if (packet_router != nullptr) {
packet_router->AddRtpModule(_rtpRtcpModule.get());
} else {
packet_router_->RemoveRtpModule(_rtpRtcpModule.get());
}
RTC_DCHECK(rtp_packet_sender);
RTC_DCHECK(transport_feedback_observer);
RTC_DCHECK(packet_router && !packet_router_);
feedback_observer_proxy_->SetTransportFeedbackObserver(
transport_feedback_observer);
seq_num_allocator_proxy_->SetSequenceNumberAllocator(packet_router);
rtp_packet_sender_proxy_->SetPacketSender(rtp_packet_sender);
_rtpRtcpModule->SetStorePacketsStatus(true, 600);
packet_router->AddRtpModule(_rtpRtcpModule.get(), true);
packet_router_ = packet_router;
}
void Channel::RegisterReceiverCongestionControlObjects(
PacketRouter* packet_router) {
RTC_DCHECK(packet_router && !packet_router_);
packet_router->AddRtpModule(_rtpRtcpModule.get(), false);
packet_router_ = packet_router;
}
void Channel::ResetCongestionControlObjects() {
RTC_DCHECK(packet_router_);
_rtpRtcpModule->SetStorePacketsStatus(false, 600);
feedback_observer_proxy_->SetTransportFeedbackObserver(nullptr);
seq_num_allocator_proxy_->SetSequenceNumberAllocator(nullptr);
const bool sender = rtp_packet_sender_proxy_->HasPacketSender();
packet_router_->RemoveRtpModule(_rtpRtcpModule.get(), sender);
packet_router_ = nullptr;
rtp_packet_sender_proxy_->SetPacketSender(nullptr);
}
void Channel::SetRTCPStatus(bool enable) {
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
"Channel::SetRTCPStatus()");

10
webrtc/voice_engine/channel.h
View File

@ -339,10 +339,12 @@ class Channel
void EnableSendTransportSequenceNumber(int id);
void EnableReceiveTransportSequenceNumber(int id);
void SetCongestionControlObjects(
RtpPacketSender* rtp_packet_sender,
TransportFeedbackObserver* transport_feedback_observer,
PacketRouter* packet_router);
void RegisterSenderCongestionControlObjects(
RtpPacketSender* rtp_packet_sender,
TransportFeedbackObserver* transport_feedback_observer,
PacketRouter* packet_router);
void RegisterReceiverCongestionControlObjects(PacketRouter* packet_router);
void ResetCongestionControlObjects();
void SetRTCPStatus(bool enable);
int GetRTCPStatus(bool& enabled);

15
webrtc/voice_engine/channel_proxy.cc
View File

@ -79,15 +79,26 @@ void ChannelProxy::EnableReceiveTransportSequenceNumber(int id) {
channel()->EnableReceiveTransportSequenceNumber(id);
}
void ChannelProxy::SetCongestionControlObjects(
void ChannelProxy::RegisterSenderCongestionControlObjects(
RtpPacketSender* rtp_packet_sender,
TransportFeedbackObserver* transport_feedback_observer,
PacketRouter* packet_router) {
RTC_DCHECK(thread_checker_.CalledOnValidThread());
channel()->SetCongestionControlObjects(
channel()->RegisterSenderCongestionControlObjects(
rtp_packet_sender, transport_feedback_observer, packet_router);
}
void ChannelProxy::RegisterReceiverCongestionControlObjects(
PacketRouter* packet_router) {
RTC_DCHECK(thread_checker_.CalledOnValidThread());
channel()->RegisterReceiverCongestionControlObjects(packet_router);
}
void ChannelProxy::ResetCongestionControlObjects() {
RTC_DCHECK(thread_checker_.CalledOnValidThread());
channel()->ResetCongestionControlObjects();
}
CallStatistics ChannelProxy::GetRTCPStatistics() const {
RTC_DCHECK(thread_checker_.CalledOnValidThread());
CallStatistics stats = {0};

5
webrtc/voice_engine/channel_proxy.h
View File

@ -51,10 +51,13 @@ class ChannelProxy {
virtual void SetReceiveAudioLevelIndicationStatus(bool enable, int id);
virtual void EnableSendTransportSequenceNumber(int id);
virtual void EnableReceiveTransportSequenceNumber(int id);
virtual void SetCongestionControlObjects(
virtual void RegisterSenderCongestionControlObjects(
RtpPacketSender* rtp_packet_sender,
TransportFeedbackObserver* transport_feedback_observer,
PacketRouter* packet_router);
virtual void RegisterReceiverCongestionControlObjects(
PacketRouter* packet_router);
virtual void ResetCongestionControlObjects();
virtual CallStatistics GetRTCPStatistics() const;
virtual std::vector<ReportBlock> GetRemoteRTCPReportBlocks() const;