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

Removes locking in TransportFeedbackProxy.

Browse source 
The lock in TransportFeedbackProxy could cause a dead-lock if audio is
included in transport feedback messages, and necessitated a revert:
https://webrtc-review.googlesource.com/c/src/+/178100

This CL removes that lock and in fact the entire TransportFeedbackProxy
class, and instead sets the observer at construction time.
We therefore don't need to guard the observer pointer anymore.

For further context, see also internal bug b/153893626

Bug: webrtc:10809
Change-Id: I79b08d8d0e587a59736b383c3596a26836c33d2e
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/178207
Commit-Queue: Erik Språng <sprang@webrtc.org>
Reviewed-by: Sam Zackrisson <saza@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31583}
This commit is contained in:
Erik Språng 2020-06-29 16:37:44 +02:00 committed by Commit Bot
parent a1163749fd
commit 2b4d2f3561
3 changed files with 29 additions and 68 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

31
audio/audio_send_stream.cc
View file

@ -116,18 +116,20 @@ AudioSendStream::AudioSendStream(
bitrate_allocator, bitrate_allocator,
event_log, event_log,
suspended_rtp_state, suspended_rtp_state,
voe::CreateChannelSend(clock, voe::CreateChannelSend(
task_queue_factory, clock,
module_process_thread, task_queue_factory,
config.send_transport, module_process_thread,
rtcp_rtt_stats, config.send_transport,
event_log, rtcp_rtt_stats,
config.frame_encryptor, event_log,
config.crypto_options, config.frame_encryptor,
config.rtp.extmap_allow_mixed, config.crypto_options,
config.rtcp_report_interval_ms, config.rtp.extmap_allow_mixed,
config.rtp.ssrc, config.rtcp_report_interval_ms,
config.frame_transformer)) {} config.rtp.ssrc,
config.frame_transformer,
rtp_transport->transport_feedback_observer())) {}
AudioSendStream::AudioSendStream( AudioSendStream::AudioSendStream(
Clock* clock, Clock* clock,
@ -506,10 +508,7 @@ webrtc::AudioSendStream::Stats AudioSendStream::GetStats(
} }
void AudioSendStream::DeliverRtcp(const uint8_t* packet, size_t length) { void AudioSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
// TODO(solenberg): Tests call this function on a network thread, libjingle RTC_DCHECK_RUN_ON(&worker_thread_checker_);
// calls on the worker thread. We should move towards always using a network
// thread. Then this check can be enabled.
// RTC_DCHECK(!worker_thread_checker_.IsCurrent());
channel_send_->ReceivedRTCPPacket(packet, length); channel_send_->ReceivedRTCPPacket(packet, length);
worker_queue_->PostTask([&]() { worker_queue_->PostTask([&]() {
// Poll if overhead has changed, which it can do if ack triggers us to stop // Poll if overhead has changed, which it can do if ack triggers us to stop

63
audio/channel_send.cc
View file

@ -55,7 +55,6 @@ constexpr int64_t kMaxRetransmissionWindowMs = 1000;
constexpr int64_t kMinRetransmissionWindowMs = 30; constexpr int64_t kMinRetransmissionWindowMs = 30;
class RtpPacketSenderProxy; class RtpPacketSenderProxy;
class TransportFeedbackProxy;
class TransportSequenceNumberProxy; class TransportSequenceNumberProxy;
class VoERtcpObserver; class VoERtcpObserver;
@ -78,7 +77,8 @@ class ChannelSend : public ChannelSendInterface,
bool extmap_allow_mixed, bool extmap_allow_mixed,
int rtcp_report_interval_ms, int rtcp_report_interval_ms,
uint32_t ssrc, uint32_t ssrc,
rtc::scoped_refptr<FrameTransformerInterface> frame_transformer); rtc::scoped_refptr<FrameTransformerInterface> frame_transformer,
TransportFeedbackObserver* feedback_observer);
~ChannelSend() override; ~ChannelSend() override;
@ -213,7 +213,7 @@ class ChannelSend : public ChannelSendInterface,
PacketRouter* packet_router_ RTC_GUARDED_BY(&worker_thread_checker_) = PacketRouter* packet_router_ RTC_GUARDED_BY(&worker_thread_checker_) =
nullptr; nullptr;
const std::unique_ptr<TransportFeedbackProxy> feedback_observer_proxy_; TransportFeedbackObserver* const feedback_observer_;
const std::unique_ptr<RtpPacketSenderProxy> rtp_packet_pacer_proxy_; const std::unique_ptr<RtpPacketSenderProxy> rtp_packet_pacer_proxy_;
const std::unique_ptr<RateLimiter> retransmission_rate_limiter_; const std::unique_ptr<RateLimiter> retransmission_rate_limiter_;
@ -244,43 +244,6 @@ class ChannelSend : public ChannelSendInterface,
const int kTelephoneEventAttenuationdB = 10; const int kTelephoneEventAttenuationdB = 10;
class TransportFeedbackProxy : public TransportFeedbackObserver {
public:
TransportFeedbackProxy() : feedback_observer_(nullptr) {
pacer_thread_.Detach();
network_thread_.Detach();
}
void SetTransportFeedbackObserver(
TransportFeedbackObserver* feedback_observer) {
RTC_DCHECK(thread_checker_.IsCurrent());
rtc::CritScope lock(&crit_);
feedback_observer_ = feedback_observer;
}
// Implements TransportFeedbackObserver.
void OnAddPacket(const RtpPacketSendInfo& packet_info) override {
RTC_DCHECK(pacer_thread_.IsCurrent());
rtc::CritScope lock(&crit_);
if (feedback_observer_)
feedback_observer_->OnAddPacket(packet_info);
}
void OnTransportFeedback(const rtcp::TransportFeedback& feedback) override {
RTC_DCHECK(network_thread_.IsCurrent());
rtc::CritScope lock(&crit_);
if (feedback_observer_)
feedback_observer_->OnTransportFeedback(feedback);
}
private:
rtc::CriticalSection crit_;
rtc::ThreadChecker thread_checker_;
rtc::ThreadChecker pacer_thread_;
rtc::ThreadChecker network_thread_;
TransportFeedbackObserver* feedback_observer_ RTC_GUARDED_BY(&crit_);
};
class RtpPacketSenderProxy : public RtpPacketSender { class RtpPacketSenderProxy : public RtpPacketSender {
public: public:
RtpPacketSenderProxy() : rtp_packet_pacer_(nullptr) {} RtpPacketSenderProxy() : rtp_packet_pacer_(nullptr) {}
@ -489,7 +452,8 @@ ChannelSend::ChannelSend(
bool extmap_allow_mixed, bool extmap_allow_mixed,
int rtcp_report_interval_ms, int rtcp_report_interval_ms,
uint32_t ssrc, uint32_t ssrc,
rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) rtc::scoped_refptr<FrameTransformerInterface> frame_transformer,
TransportFeedbackObserver* feedback_observer)
: event_log_(rtc_event_log), : event_log_(rtc_event_log),
_timeStamp(0), // This is just an offset, RTP module will add it's own _timeStamp(0), // This is just an offset, RTP module will add it's own
// random offset // random offset
@ -498,7 +462,7 @@ ChannelSend::ChannelSend(
previous_frame_muted_(false), previous_frame_muted_(false),
_includeAudioLevelIndication(false), _includeAudioLevelIndication(false),
rtcp_observer_(new VoERtcpObserver(this)), rtcp_observer_(new VoERtcpObserver(this)),
feedback_observer_proxy_(new TransportFeedbackProxy()), feedback_observer_(feedback_observer),
rtp_packet_pacer_proxy_(new RtpPacketSenderProxy()), rtp_packet_pacer_proxy_(new RtpPacketSenderProxy()),
retransmission_rate_limiter_( retransmission_rate_limiter_(
new RateLimiter(clock, kMaxRetransmissionWindowMs)), new RateLimiter(clock, kMaxRetransmissionWindowMs)),
@ -514,7 +478,7 @@ ChannelSend::ChannelSend(
RtpRtcpInterface::Configuration configuration; RtpRtcpInterface::Configuration configuration;
configuration.bandwidth_callback = rtcp_observer_.get(); configuration.bandwidth_callback = rtcp_observer_.get();
configuration.transport_feedback_callback = feedback_observer_proxy_.get(); configuration.transport_feedback_callback = feedback_observer_;
configuration.clock = (clock ? clock : Clock::GetRealTimeClock()); configuration.clock = (clock ? clock : Clock::GetRealTimeClock());
configuration.audio = true; configuration.audio = true;
configuration.outgoing_transport = rtp_transport; configuration.outgoing_transport = rtp_transport;
@ -663,6 +627,8 @@ void ChannelSend::OnUplinkPacketLossRate(float packet_loss_rate) {
} }
void ChannelSend::ReceivedRTCPPacket(const uint8_t* data, size_t length) { void ChannelSend::ReceivedRTCPPacket(const uint8_t* data, size_t length) {
RTC_DCHECK_RUN_ON(&worker_thread_checker_);
// Deliver RTCP packet to RTP/RTCP module for parsing // Deliver RTCP packet to RTP/RTCP module for parsing
rtp_rtcp_->IncomingRtcpPacket(data, length); rtp_rtcp_->IncomingRtcpPacket(data, length);
@ -743,17 +709,12 @@ void ChannelSend::RegisterSenderCongestionControlObjects(
RtcpBandwidthObserver* bandwidth_observer) { RtcpBandwidthObserver* bandwidth_observer) {
RTC_DCHECK_RUN_ON(&worker_thread_checker_); RTC_DCHECK_RUN_ON(&worker_thread_checker_);
RtpPacketSender* rtp_packet_pacer = transport->packet_sender(); RtpPacketSender* rtp_packet_pacer = transport->packet_sender();
TransportFeedbackObserver* transport_feedback_observer =
transport->transport_feedback_observer();
PacketRouter* packet_router = transport->packet_router(); PacketRouter* packet_router = transport->packet_router();
RTC_DCHECK(rtp_packet_pacer); RTC_DCHECK(rtp_packet_pacer);
RTC_DCHECK(transport_feedback_observer);
RTC_DCHECK(packet_router); RTC_DCHECK(packet_router);
RTC_DCHECK(!packet_router_); RTC_DCHECK(!packet_router_);
rtcp_observer_->SetBandwidthObserver(bandwidth_observer); rtcp_observer_->SetBandwidthObserver(bandwidth_observer);
feedback_observer_proxy_->SetTransportFeedbackObserver(
transport_feedback_observer);
rtp_packet_pacer_proxy_->SetPacketPacer(rtp_packet_pacer); rtp_packet_pacer_proxy_->SetPacketPacer(rtp_packet_pacer);
rtp_rtcp_->SetStorePacketsStatus(true, 600); rtp_rtcp_->SetStorePacketsStatus(true, 600);
constexpr bool remb_candidate = false; constexpr bool remb_candidate = false;
@ -766,7 +727,6 @@ void ChannelSend::ResetSenderCongestionControlObjects() {
RTC_DCHECK(packet_router_); RTC_DCHECK(packet_router_);
rtp_rtcp_->SetStorePacketsStatus(false, 600); rtp_rtcp_->SetStorePacketsStatus(false, 600);
rtcp_observer_->SetBandwidthObserver(nullptr); rtcp_observer_->SetBandwidthObserver(nullptr);
feedback_observer_proxy_->SetTransportFeedbackObserver(nullptr);
packet_router_->RemoveSendRtpModule(rtp_rtcp_.get()); packet_router_->RemoveSendRtpModule(rtp_rtcp_.get());
packet_router_ = nullptr; packet_router_ = nullptr;
rtp_packet_pacer_proxy_->SetPacketPacer(nullptr); rtp_packet_pacer_proxy_->SetPacketPacer(nullptr);
@ -985,12 +945,13 @@ std::unique_ptr<ChannelSendInterface> CreateChannelSend(
bool extmap_allow_mixed, bool extmap_allow_mixed,
int rtcp_report_interval_ms, int rtcp_report_interval_ms,
uint32_t ssrc, uint32_t ssrc,
rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) { rtc::scoped_refptr<FrameTransformerInterface> frame_transformer,
TransportFeedbackObserver* feedback_observer) {
return std::make_unique<ChannelSend>( return std::make_unique<ChannelSend>(
clock, task_queue_factory, module_process_thread, rtp_transport, clock, task_queue_factory, module_process_thread, rtp_transport,
rtcp_rtt_stats, rtc_event_log, frame_encryptor, crypto_options, rtcp_rtt_stats, rtc_event_log, frame_encryptor, crypto_options,
extmap_allow_mixed, rtcp_report_interval_ms, ssrc, extmap_allow_mixed, rtcp_report_interval_ms, ssrc,
std::move(frame_transformer)); std::move(frame_transformer), feedback_observer);
} }
} // namespace voe } // namespace voe

3
audio/channel_send.h
View file

@ -135,7 +135,8 @@ std::unique_ptr<ChannelSendInterface> CreateChannelSend(
bool extmap_allow_mixed, bool extmap_allow_mixed,
int rtcp_report_interval_ms, int rtcp_report_interval_ms,
uint32_t ssrc, uint32_t ssrc,
rtc::scoped_refptr<FrameTransformerInterface> frame_transformer); rtc::scoped_refptr<FrameTransformerInterface> frame_transformer,
TransportFeedbackObserver* feedback_observer);
} // namespace voe } // namespace voe
} // namespace webrtc } // namespace webrtc