zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Migrate modules/congestion_controller to webrtc::Mutex.

Browse Source 
Bug: webrtc:11567
Change-Id: I284eaebf863e0c63d2aa162a5df56380f9cf4838
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/178841
Reviewed-by: Sebastian Jansson <srte@webrtc.org>
Commit-Queue: Markus Handell <handellm@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31659}
This commit is contained in:
Markus Handell
2020-07-07 22:03:26 +02:00
committed by Commit Bot
parent 656efbee6f
commit 9c96250dd5
6 changed files with 21 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
modules/congestion_controller/BUILD.gn
View File

@ -28,6 +28,7 @@ rtc_library("congestion_controller") {
"..:module_api", "..:module_api",
"../../api/transport:field_trial_based_config", "../../api/transport:field_trial_based_config",
"../../api/transport:network_control", "../../api/transport:network_control",
"../../rtc_base/synchronization:mutex",
"../pacing", "../pacing",
"../remote_bitrate_estimator", "../remote_bitrate_estimator",
"../rtp_rtcp:rtp_rtcp_format", "../rtp_rtcp:rtp_rtcp_format",

8
modules/congestion_controller/include/receive_side_congestion_controller.h
View File

@ -19,7 +19,7 @@
#include "modules/include/module.h" #include "modules/include/module.h"
#include "modules/remote_bitrate_estimator/remote_estimator_proxy.h" #include "modules/remote_bitrate_estimator/remote_estimator_proxy.h"
#include "rtc_base/constructor_magic.h" #include "rtc_base/constructor_magic.h"
#include "rtc_base/critical_section.h" #include "rtc_base/synchronization/mutex.h"
namespace webrtc { namespace webrtc {
class RemoteBitrateEstimator; class RemoteBitrateEstimator;
@ -87,11 +87,11 @@ class ReceiveSideCongestionController : public CallStatsObserver,
private: private:
void PickEstimatorFromHeader(const RTPHeader& header) void PickEstimatorFromHeader(const RTPHeader& header)
RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
void PickEstimator() RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); void PickEstimator() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
RemoteBitrateObserver* observer_; RemoteBitrateObserver* observer_;
Clock* const clock_; Clock* const clock_;
rtc::CriticalSection crit_sect_; mutable Mutex mutex_;
std::unique_ptr<RemoteBitrateEstimator> rbe_; std::unique_ptr<RemoteBitrateEstimator> rbe_;
bool using_absolute_send_time_; bool using_absolute_send_time_;
uint32_t packets_since_absolute_send_time_; uint32_t packets_since_absolute_send_time_;

14
modules/congestion_controller/receive_side_congestion_controller.cc
View File

@ -38,45 +38,45 @@ void ReceiveSideCongestionController::WrappingBitrateEstimator::IncomingPacket(
int64_t arrival_time_ms, int64_t arrival_time_ms,
size_t payload_size, size_t payload_size,
const RTPHeader& header) { const RTPHeader& header) {
rtc::CritScope cs(&crit_sect_); MutexLock lock(&mutex_);
PickEstimatorFromHeader(header); PickEstimatorFromHeader(header);
rbe_->IncomingPacket(arrival_time_ms, payload_size, header); rbe_->IncomingPacket(arrival_time_ms, payload_size, header);
} }
void ReceiveSideCongestionController::WrappingBitrateEstimator::Process() { void ReceiveSideCongestionController::WrappingBitrateEstimator::Process() {
rtc::CritScope cs(&crit_sect_); MutexLock lock(&mutex_);
rbe_->Process(); rbe_->Process();
} }
int64_t ReceiveSideCongestionController::WrappingBitrateEstimator:: int64_t ReceiveSideCongestionController::WrappingBitrateEstimator::
TimeUntilNextProcess() { TimeUntilNextProcess() {
rtc::CritScope cs(&crit_sect_); MutexLock lock(&mutex_);
return rbe_->TimeUntilNextProcess(); return rbe_->TimeUntilNextProcess();
} }
void ReceiveSideCongestionController::WrappingBitrateEstimator::OnRttUpdate( void ReceiveSideCongestionController::WrappingBitrateEstimator::OnRttUpdate(
int64_t avg_rtt_ms, int64_t avg_rtt_ms,
int64_t max_rtt_ms) { int64_t max_rtt_ms) {
rtc::CritScope cs(&crit_sect_); MutexLock lock(&mutex_);
rbe_->OnRttUpdate(avg_rtt_ms, max_rtt_ms); rbe_->OnRttUpdate(avg_rtt_ms, max_rtt_ms);
} }
void ReceiveSideCongestionController::WrappingBitrateEstimator::RemoveStream( void ReceiveSideCongestionController::WrappingBitrateEstimator::RemoveStream(
unsigned int ssrc) { unsigned int ssrc) {
rtc::CritScope cs(&crit_sect_); MutexLock lock(&mutex_);
rbe_->RemoveStream(ssrc); rbe_->RemoveStream(ssrc);
} }
bool ReceiveSideCongestionController::WrappingBitrateEstimator::LatestEstimate( bool ReceiveSideCongestionController::WrappingBitrateEstimator::LatestEstimate(
std::vector<unsigned int>* ssrcs, std::vector<unsigned int>* ssrcs,
unsigned int* bitrate_bps) const { unsigned int* bitrate_bps) const {
rtc::CritScope cs(&crit_sect_); MutexLock lock(&mutex_);
return rbe_->LatestEstimate(ssrcs, bitrate_bps); return rbe_->LatestEstimate(ssrcs, bitrate_bps);
} }
void ReceiveSideCongestionController::WrappingBitrateEstimator::SetMinBitrate( void ReceiveSideCongestionController::WrappingBitrateEstimator::SetMinBitrate(
int min_bitrate_bps) { int min_bitrate_bps) {
rtc::CritScope cs(&crit_sect_); MutexLock lock(&mutex_);
rbe_->SetMinBitrate(min_bitrate_bps); rbe_->SetMinBitrate(min_bitrate_bps);
min_bitrate_bps_ = min_bitrate_bps; min_bitrate_bps_ = min_bitrate_bps;
} }

1
modules/congestion_controller/rtp/BUILD.gn
View File

@ -58,6 +58,7 @@ rtc_library("transport_feedback") {
"../../../rtc_base:checks", "../../../rtc_base:checks",
"../../../rtc_base:rtc_base_approved", "../../../rtc_base:rtc_base_approved",
"../../../rtc_base/network:sent_packet", "../../../rtc_base/network:sent_packet",
"../../../rtc_base/synchronization:mutex",
"../../../system_wrappers", "../../../system_wrappers",
"../../../system_wrappers:field_trial", "../../../system_wrappers:field_trial",
"../../rtp_rtcp:rtp_rtcp_format", "../../rtp_rtcp:rtp_rtcp_format",

10
modules/congestion_controller/rtp/transport_feedback_demuxer.cc
View File

@ -18,7 +18,7 @@ static const size_t kMaxPacketsInHistory = 5000;
void TransportFeedbackDemuxer::RegisterStreamFeedbackObserver( void TransportFeedbackDemuxer::RegisterStreamFeedbackObserver(
std::vector<uint32_t> ssrcs, std::vector<uint32_t> ssrcs,
StreamFeedbackObserver* observer) { StreamFeedbackObserver* observer) {
rtc::CritScope cs(&observers_lock_); MutexLock lock(&observers_lock_);
RTC_DCHECK(observer); RTC_DCHECK(observer);
RTC_DCHECK(absl::c_find_if(observers_, [=](const auto& pair) { RTC_DCHECK(absl::c_find_if(observers_, [=](const auto& pair) {
return pair.second == observer; return pair.second == observer;
@ -28,7 +28,7 @@ void TransportFeedbackDemuxer::RegisterStreamFeedbackObserver(
void TransportFeedbackDemuxer::DeRegisterStreamFeedbackObserver( void TransportFeedbackDemuxer::DeRegisterStreamFeedbackObserver(
StreamFeedbackObserver* observer) { StreamFeedbackObserver* observer) {
rtc::CritScope cs(&observers_lock_); MutexLock lock(&observers_lock_);
RTC_DCHECK(observer); RTC_DCHECK(observer);
const auto it = absl::c_find_if( const auto it = absl::c_find_if(
observers_, [=](const auto& pair) { return pair.second == observer; }); observers_, [=](const auto& pair) { return pair.second == observer; });
@ -37,7 +37,7 @@ void TransportFeedbackDemuxer::DeRegisterStreamFeedbackObserver(
} }
void TransportFeedbackDemuxer::AddPacket(const RtpPacketSendInfo& packet_info) { void TransportFeedbackDemuxer::AddPacket(const RtpPacketSendInfo& packet_info) {
rtc::CritScope cs(&lock_); MutexLock lock(&lock_);
if (packet_info.ssrc != 0) { if (packet_info.ssrc != 0) {
StreamFeedbackObserver::StreamPacketInfo info; StreamFeedbackObserver::StreamPacketInfo info;
info.ssrc = packet_info.ssrc; info.ssrc = packet_info.ssrc;
@ -56,7 +56,7 @@ void TransportFeedbackDemuxer::OnTransportFeedback(
const rtcp::TransportFeedback& feedback) { const rtcp::TransportFeedback& feedback) {
std::vector<StreamFeedbackObserver::StreamPacketInfo> stream_feedbacks; std::vector<StreamFeedbackObserver::StreamPacketInfo> stream_feedbacks;
{ {
rtc::CritScope cs(&lock_); MutexLock lock(&lock_);
for (const auto& packet : feedback.GetAllPackets()) { for (const auto& packet : feedback.GetAllPackets()) {
int64_t seq_num = int64_t seq_num =
seq_num_unwrapper_.UnwrapWithoutUpdate(packet.sequence_number()); seq_num_unwrapper_.UnwrapWithoutUpdate(packet.sequence_number());
@ -71,7 +71,7 @@ void TransportFeedbackDemuxer::OnTransportFeedback(
} }
} }
rtc::CritScope cs(&observers_lock_); MutexLock lock(&observers_lock_);
for (auto& observer : observers_) { for (auto& observer : observers_) {
std::vector<StreamFeedbackObserver::StreamPacketInfo> selected_feedback; std::vector<StreamFeedbackObserver::StreamPacketInfo> selected_feedback;
for (const auto& packet_info : stream_feedbacks) { for (const auto& packet_info : stream_feedbacks) {

6
modules/congestion_controller/rtp/transport_feedback_demuxer.h
View File

@ -16,7 +16,7 @@
#include "modules/include/module_common_types_public.h" #include "modules/include/module_common_types_public.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "rtc_base/critical_section.h" #include "rtc_base/synchronization/mutex.h"
namespace webrtc { namespace webrtc {
@ -32,7 +32,7 @@ class TransportFeedbackDemuxer : public StreamFeedbackProvider {
void OnTransportFeedback(const rtcp::TransportFeedback& feedback); void OnTransportFeedback(const rtcp::TransportFeedback& feedback);
private: private:
rtc::CriticalSection lock_; Mutex lock_;
SequenceNumberUnwrapper seq_num_unwrapper_ RTC_GUARDED_BY(&lock_); SequenceNumberUnwrapper seq_num_unwrapper_ RTC_GUARDED_BY(&lock_);
std::map<int64_t, StreamFeedbackObserver::StreamPacketInfo> history_ std::map<int64_t, StreamFeedbackObserver::StreamPacketInfo> history_
RTC_GUARDED_BY(&lock_); RTC_GUARDED_BY(&lock_);
@ -40,7 +40,7 @@ class TransportFeedbackDemuxer : public StreamFeedbackProvider {
// Maps a set of ssrcs to corresponding observer. Vectors are used rather than // Maps a set of ssrcs to corresponding observer. Vectors are used rather than
// set/map to ensure that the processing order is consistent independently of // set/map to ensure that the processing order is consistent independently of
// the randomized ssrcs. // the randomized ssrcs.
rtc::CriticalSection observers_lock_; Mutex observers_lock_;
std::vector<std::pair<std::vector<uint32_t>, StreamFeedbackObserver*>> std::vector<std::pair<std::vector<uint32_t>, StreamFeedbackObserver*>>
observers_ RTC_GUARDED_BY(&observers_lock_); observers_ RTC_GUARDED_BY(&observers_lock_);
}; };