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

Migrate call/ to webrtc::Mutex.

Browse source 
Bug: webrtc:11567
Change-Id: Iab7142c77bc0c1a026cf5121b756094e05bccefe
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176742
Commit-Queue: Markus Handell <handellm@webrtc.org>
Reviewed-by: Sebastian Jansson <srte@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31636}
This commit is contained in:
Markus Handell 2020-07-06 17:41:35 +02:00 committed by Commit Bot
parent 6287280d64
commit 8fe932a5a3
15 changed files with 105 additions and 96 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
call/BUILD.gn
View file

@ -183,6 +183,7 @@ rtc_library("rtp_sender") {
"../rtc_base:rate_limiter",
"../rtc_base:rtc_base_approved",
"../rtc_base:rtc_task_queue",
"../rtc_base/synchronization:mutex",
"../rtc_base/task_utils:repeating_task",
]
absl_deps = [
@ -341,6 +342,7 @@ rtc_library("simulated_network") {
"../api/units:timestamp",
"../rtc_base:checks",
"../rtc_base:rtc_base_approved",
"../rtc_base/synchronization:mutex",
"../rtc_base/synchronization:sequence_checker",
]
absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
@ -369,6 +371,7 @@ rtc_library("fake_network") {
"../modules/utility",
"../rtc_base:checks",
"../rtc_base:rtc_base_approved",
"../rtc_base/synchronization:mutex",
"../rtc_base/synchronization:sequence_checker",
"../system_wrappers",
]
@ -434,6 +437,7 @@ if (rtc_include_tests) {
"../rtc_base:rate_limiter",
"../rtc_base:rtc_base_approved",
"../rtc_base:task_queue_for_test",
"../rtc_base/synchronization:mutex",
"../system_wrappers",
"../test:audio_codec_mocks",
"../test:direct_transport",
@ -493,6 +497,7 @@ if (rtc_include_tests) {
"../rtc_base:rtc_base_approved",
"../rtc_base:task_queue_for_test",
"../rtc_base:task_queue_for_test",
"../rtc_base/synchronization:mutex",
"../rtc_base/task_utils:repeating_task",
"../system_wrappers",
"../system_wrappers:metrics",

2
call/adaptation/BUILD.gn
View file

@ -49,6 +49,7 @@ rtc_library("resource_adaptation") {
"../../rtc_base:rtc_base_approved",
"../../rtc_base:rtc_task_queue",
"../../rtc_base/experiments:balanced_degradation_settings",
"../../rtc_base/synchronization:mutex",
"../../rtc_base/synchronization:sequence_checker",
"../../rtc_base/task_utils:to_queued_task",
]
@ -85,6 +86,7 @@ if (rtc_include_tests) {
"../../rtc_base:rtc_base_approved",
"../../rtc_base:rtc_task_queue",
"../../rtc_base:task_queue_for_test",
"../../rtc_base/synchronization:mutex",
"../../test:field_trial",
"../../test:rtc_expect_death",
"../../test:test_support",

20
call/adaptation/broadcast_resource_listener.cc
View file

@ -15,8 +15,8 @@
#include <utility>
#include "rtc_base/checks.h"
#include "rtc_base/critical_section.h"
#include "rtc_base/ref_counted_object.h"
#include "rtc_base/synchronization/mutex.h"
namespace webrtc {
@ -29,7 +29,7 @@ class BroadcastResourceListener::AdapterResource : public Resource {
// The parent is letting us know we have a usage neasurement.
void OnResourceUsageStateMeasured(ResourceUsageState usage_state) {
rtc::CritScope crit(&lock_);
MutexLock lock(&lock_);
if (!listener_)
return;
listener_->OnResourceUsageStateMeasured(this, usage_state);
@ -38,14 +38,14 @@ class BroadcastResourceListener::AdapterResource : public Resource {
// Resource implementation.
std::string Name() const override { return name_; }
void SetResourceListener(ResourceListener* listener) override {
rtc::CritScope crit(&lock_);
MutexLock lock(&lock_);
RTC_DCHECK(!listener_ || !listener);
listener_ = listener;
}
private:
const std::string name_;
rtc::CriticalSection lock_;
Mutex lock_;
ResourceListener* listener_ RTC_GUARDED_BY(lock_) = nullptr;
};
@ -64,14 +64,14 @@ rtc::scoped_refptr<Resource> BroadcastResourceListener::SourceResource() const {
}
void BroadcastResourceListener::StartListening() {
rtc::CritScope crit(&lock_);
MutexLock lock(&lock_);
RTC_DCHECK(!is_listening_);
source_resource_->SetResourceListener(this);
is_listening_ = true;
}
void BroadcastResourceListener::StopListening() {
rtc::CritScope crit(&lock_);
MutexLock lock(&lock_);
RTC_DCHECK(is_listening_);
RTC_DCHECK(adapters_.empty());
source_resource_->SetResourceListener(nullptr);
@ -80,7 +80,7 @@ void BroadcastResourceListener::StopListening() {
rtc::scoped_refptr<Resource>
BroadcastResourceListener::CreateAdapterResource() {
rtc::CritScope crit(&lock_);
MutexLock lock(&lock_);
RTC_DCHECK(is_listening_);
rtc::scoped_refptr<AdapterResource> adapter =
new rtc::RefCountedObject<AdapterResource>(source_resource_->Name() +
@ -91,7 +91,7 @@ BroadcastResourceListener::CreateAdapterResource() {
void BroadcastResourceListener::RemoveAdapterResource(
rtc::scoped_refptr<Resource> resource) {
rtc::CritScope crit(&lock_);
MutexLock lock(&lock_);
auto it = std::find(adapters_.begin(), adapters_.end(), resource);
RTC_DCHECK(it != adapters_.end());
adapters_.erase(it);
@ -100,7 +100,7 @@ void BroadcastResourceListener::RemoveAdapterResource(
std::vector<rtc::scoped_refptr<Resource>>
BroadcastResourceListener::GetAdapterResources() {
std::vector<rtc::scoped_refptr<Resource>> resources;
rtc::CritScope crit(&lock_);
MutexLock lock(&lock_);
for (const auto& adapter : adapters_) {
resources.push_back(adapter);
}
@ -111,7 +111,7 @@ void BroadcastResourceListener::OnResourceUsageStateMeasured(
rtc::scoped_refptr<Resource> resource,
ResourceUsageState usage_state) {
RTC_DCHECK_EQ(resource, source_resource_);
rtc::CritScope crit(&lock_);
MutexLock lock(&lock_);
for (const auto& adapter : adapters_) {
adapter->OnResourceUsageStateMeasured(usage_state);
}

4
call/adaptation/broadcast_resource_listener.h
View file

@ -15,7 +15,7 @@
#include "api/adaptation/resource.h"
#include "api/scoped_refptr.h"
#include "rtc_base/critical_section.h"
#include "rtc_base/synchronization/mutex.h"
namespace webrtc {
@ -62,7 +62,7 @@ class BroadcastResourceListener : public ResourceListener {
friend class AdapterResource;
const rtc::scoped_refptr<Resource> source_resource_;
rtc::CriticalSection lock_;
Mutex lock_;
bool is_listening_ RTC_GUARDED_BY(lock_);
// The AdapterResource unregisters itself prior to destruction, guaranteeing
// that these pointers are safe to use.

2
call/adaptation/resource_adaptation_processor_unittest.cc
View file

@ -20,9 +20,9 @@
#include "call/adaptation/test/fake_resource.h"
#include "call/adaptation/video_source_restrictions.h"
#include "call/adaptation/video_stream_input_state_provider.h"
#include "rtc_base/critical_section.h"
#include "rtc_base/event.h"
#include "rtc_base/gunit.h"
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/task_queue_for_test.h"
#include "test/gtest.h"

8
call/adaptation/video_stream_input_state_provider.cc
View file

@ -19,19 +19,19 @@ VideoStreamInputStateProvider::VideoStreamInputStateProvider(
VideoStreamInputStateProvider::~VideoStreamInputStateProvider() {}
void VideoStreamInputStateProvider::OnHasInputChanged(bool has_input) {
rtc::CritScope lock(&crit_);
MutexLock lock(&mutex_);
input_state_.set_has_input(has_input);
}
void VideoStreamInputStateProvider::OnFrameSizeObserved(int frame_size_pixels) {
RTC_DCHECK_GT(frame_size_pixels, 0);
rtc::CritScope lock(&crit_);
MutexLock lock(&mutex_);
input_state_.set_frame_size_pixels(frame_size_pixels);
}
void VideoStreamInputStateProvider::OnEncoderSettingsChanged(
EncoderSettings encoder_settings) {
rtc::CritScope lock(&crit_);
MutexLock lock(&mutex_);
input_state_.set_video_codec_type(
encoder_settings.encoder_config().codec_type);
input_state_.set_min_pixels_per_frame(
@ -41,7 +41,7 @@ void VideoStreamInputStateProvider::OnEncoderSettingsChanged(
VideoStreamInputState VideoStreamInputStateProvider::InputState() {
// GetInputFrameRate() is thread-safe.
int input_fps = frame_rate_provider_->GetInputFrameRate();
rtc::CritScope lock(&crit_);
MutexLock lock(&mutex_);
input_state_.set_frames_per_second(input_fps);
return input_state_;
}

6
call/adaptation/video_stream_input_state_provider.h
View file

@ -14,7 +14,7 @@
#include "api/video/video_stream_encoder_observer.h"
#include "call/adaptation/encoder_settings.h"
#include "call/adaptation/video_stream_input_state.h"
#include "rtc_base/critical_section.h"
#include "rtc_base/synchronization/mutex.h"
namespace webrtc {
@ -31,9 +31,9 @@ class VideoStreamInputStateProvider {
virtual VideoStreamInputState InputState();
private:
mutable rtc::CriticalSection crit_;
Mutex mutex_;
VideoStreamEncoderObserver* const frame_rate_provider_;
VideoStreamInputState input_state_ RTC_GUARDED_BY(crit_);
VideoStreamInputState input_state_ RTC_GUARDED_BY(mutex_);
};
} // namespace webrtc

11
call/bitrate_estimator_tests.cc
View file

@ -19,6 +19,7 @@
#include "rtc_base/checks.h"
#include "rtc_base/event.h"
#include "rtc_base/logging.h"
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/task_queue_for_test.h"
#include "rtc_base/thread_annotations.h"
#include "test/call_test.h"
@ -49,7 +50,7 @@ class LogObserver {
class Callback : public rtc::LogSink {
public:
void OnLogMessage(const std::string& message) override {
rtc::CritScope lock(&crit_sect_);
MutexLock lock(&mutex_);
// Ignore log lines that are due to missing AST extensions, these are
// logged when we switch back from AST to TOF until the wrapping bitrate
// estimator gives up on using AST.
@ -78,15 +79,15 @@ class LogObserver {
bool Wait() { return done_.Wait(test::CallTest::kDefaultTimeoutMs); }
void PushExpectedLogLine(const std::string& expected_log_line) {
rtc::CritScope lock(&crit_sect_);
MutexLock lock(&mutex_);
expected_log_lines_.push_back(expected_log_line);
}
private:
typedef std::list<std::string> Strings;
rtc::CriticalSection crit_sect_;
Strings received_log_lines_ RTC_GUARDED_BY(crit_sect_);
Strings expected_log_lines_ RTC_GUARDED_BY(crit_sect_);
Mutex mutex_;
Strings received_log_lines_ RTC_GUARDED_BY(mutex_);
Strings expected_log_lines_ RTC_GUARDED_BY(mutex_);
rtc::Event done_;
};

9
call/call_perf_tests.cc
View file

@ -29,6 +29,7 @@
#include "modules/audio_mixer/audio_mixer_impl.h"
#include "modules/rtp_rtcp/source/rtp_packet.h"
#include "rtc_base/checks.h"
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/task_queue_for_test.h"
#include "rtc_base/thread.h"
#include "rtc_base/thread_annotations.h"
@ -409,7 +410,7 @@ void CallPerfTest::TestCaptureNtpTime(
}
void OnFrame(const VideoFrame& video_frame) override {
rtc::CritScope lock(&crit_);
MutexLock lock(&mutex_);
if (video_frame.ntp_time_ms() <= 0) {
// Haven't got enough RTCP SR in order to calculate the capture ntp
// time.
@ -445,7 +446,7 @@ void CallPerfTest::TestCaptureNtpTime(
}
Action OnSendRtp(const uint8_t* packet, size_t length) override {
rtc::CritScope lock(&crit_);
MutexLock lock(&mutex_);
RtpPacket rtp_packet;
EXPECT_TRUE(rtp_packet.Parse(packet, length));
@ -488,7 +489,7 @@ void CallPerfTest::TestCaptureNtpTime(
time_offset_ms_list_, "ms", true);
}
rtc::CriticalSection crit_;
Mutex mutex_;
const BuiltInNetworkBehaviorConfig net_config_;
Clock* const clock_;
int threshold_ms_;
@ -499,7 +500,7 @@ void CallPerfTest::TestCaptureNtpTime(
bool rtp_start_timestamp_set_;
uint32_t rtp_start_timestamp_;
typedef std::map<uint32_t, uint32_t> FrameCaptureTimeList;
FrameCaptureTimeList capture_time_list_ RTC_GUARDED_BY(&crit_);
FrameCaptureTimeList capture_time_list_ RTC_GUARDED_BY(&mutex_);
std::vector<double> time_offset_ms_list_;
} test(net_config, threshold_ms, start_time_ms, run_time_ms);

32
call/fake_network_pipe.cc
View file

@ -122,17 +122,17 @@ FakeNetworkPipe::~FakeNetworkPipe() {
}
void FakeNetworkPipe::SetReceiver(PacketReceiver* receiver) {
rtc::CritScope crit(&config_lock_);
MutexLock lock(&config_lock_);
receiver_ = receiver;
}
void FakeNetworkPipe::AddActiveTransport(Transport* transport) {
rtc::CritScope crit(&config_lock_);
MutexLock lock(&config_lock_);
active_transports_[transport]++;
}
void FakeNetworkPipe::RemoveActiveTransport(Transport* transport) {
rtc::CritScope crit(&config_lock_);
MutexLock lock(&config_lock_);
auto it = active_transports_.find(transport);
RTC_CHECK(it != active_transports_.end());
if (--(it->second) == 0) {
@ -186,7 +186,7 @@ PacketReceiver::DeliveryStatus FakeNetworkPipe::DeliverPacket(
}
void FakeNetworkPipe::SetClockOffset(int64_t offset_ms) {
rtc::CritScope crit(&config_lock_);
MutexLock lock(&config_lock_);
clock_offset_ms_ = offset_ms;
}
@ -198,7 +198,7 @@ bool FakeNetworkPipe::EnqueuePacket(rtc::CopyOnWriteBuffer packet,
bool is_rtcp,
MediaType media_type,
absl::optional<int64_t> packet_time_us) {
rtc::CritScope crit(&process_lock_);
MutexLock lock(&process_lock_);
int64_t time_now_us = clock_->TimeInMicroseconds();
return EnqueuePacket(NetworkPacket(std::move(packet), time_now_us,
time_now_us, options, is_rtcp, media_type,
@ -209,7 +209,7 @@ bool FakeNetworkPipe::EnqueuePacket(rtc::CopyOnWriteBuffer packet,
absl::optional<PacketOptions> options,
bool is_rtcp,
Transport* transport) {
rtc::CritScope crit(&process_lock_);
MutexLock lock(&process_lock_);
int64_t time_now_us = clock_->TimeInMicroseconds();
return EnqueuePacket(NetworkPacket(std::move(packet), time_now_us,
time_now_us, options, is_rtcp,
@ -233,7 +233,7 @@ bool FakeNetworkPipe::EnqueuePacket(NetworkPacket&& net_packet) {
}
float FakeNetworkPipe::PercentageLoss() {
rtc::CritScope crit(&process_lock_);
MutexLock lock(&process_lock_);
if (sent_packets_ == 0)
return 0;
@ -242,7 +242,7 @@ float FakeNetworkPipe::PercentageLoss() {
}
int FakeNetworkPipe::AverageDelay() {
rtc::CritScope crit(&process_lock_);
MutexLock lock(&process_lock_);
if (sent_packets_ == 0)
return 0;
@ -251,12 +251,12 @@ int FakeNetworkPipe::AverageDelay() {
}
size_t FakeNetworkPipe::DroppedPackets() {
rtc::CritScope crit(&process_lock_);
MutexLock lock(&process_lock_);
return dropped_packets_;
}
size_t FakeNetworkPipe::SentPackets() {
rtc::CritScope crit(&process_lock_);
MutexLock lock(&process_lock_);
return sent_packets_;
}
@ -264,7 +264,7 @@ void FakeNetworkPipe::Process() {
int64_t time_now_us;
std::queue<NetworkPacket> packets_to_deliver;
{
rtc::CritScope crit(&process_lock_);
MutexLock lock(&process_lock_);
time_now_us = clock_->TimeInMicroseconds();
if (time_now_us - last_log_time_us_ > kLogIntervalMs * 1000) {
int64_t queueing_delay_us = 0;
@ -318,7 +318,7 @@ void FakeNetworkPipe::Process() {
}
}
rtc::CritScope crit(&config_lock_);
MutexLock lock(&config_lock_);
while (!packets_to_deliver.empty()) {
NetworkPacket packet = std::move(packets_to_deliver.front());
packets_to_deliver.pop();
@ -354,7 +354,7 @@ void FakeNetworkPipe::DeliverNetworkPacket(NetworkPacket* packet) {
}
absl::optional<int64_t> FakeNetworkPipe::TimeUntilNextProcess() {
rtc::CritScope crit(&process_lock_);
MutexLock lock(&process_lock_);
absl::optional<int64_t> delivery_us = network_behavior_->NextDeliveryTimeUs();
if (delivery_us) {
int64_t delay_us = *delivery_us - clock_->TimeInMicroseconds();
@ -364,17 +364,17 @@ absl::optional<int64_t> FakeNetworkPipe::TimeUntilNextProcess() {
}
bool FakeNetworkPipe::HasReceiver() const {
rtc::CritScope crit(&config_lock_);
MutexLock lock(&config_lock_);
return receiver_ != nullptr;
}
void FakeNetworkPipe::DeliverPacketWithLock(NetworkPacket* packet) {
rtc::CritScope crit(&config_lock_);
MutexLock lock(&config_lock_);
DeliverNetworkPacket(packet);
}
void FakeNetworkPipe::ResetStats() {
rtc::CritScope crit(&process_lock_);
MutexLock lock(&process_lock_);
dropped_packets_ = 0;
sent_packets_ = 0;
total_packet_delay_us_ = 0;

6
call/fake_network_pipe.h
View file

@ -24,7 +24,7 @@
#include "call/call.h"
#include "call/simulated_packet_receiver.h"
#include "rtc_base/constructor_magic.h"
#include "rtc_base/critical_section.h"
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/thread_annotations.h"
namespace webrtc {
@ -204,14 +204,14 @@ class FakeNetworkPipe : public SimulatedPacketReceiverInterface {
Clock* const clock_;
// |config_lock| guards the mostly constant things like the callbacks.
rtc::CriticalSection config_lock_;
mutable Mutex config_lock_;
const std::unique_ptr<NetworkBehaviorInterface> network_behavior_;
PacketReceiver* receiver_ RTC_GUARDED_BY(config_lock_);
Transport* const global_transport_;
// |process_lock| guards the data structures involved in delay and loss
// processes, such as the packet queues.
rtc::CriticalSection process_lock_;
Mutex process_lock_;
// Packets are added at the back of the deque, this makes the deque ordered
// by increasing send time. The common case when removing packets from the
// deque is removing early packets, which will be close to the front of the

20
call/rtp_video_sender.cc
View file

@ -467,7 +467,7 @@ void RtpVideoSender::DeRegisterProcessThread() {
}
void RtpVideoSender::SetActive(bool active) {
rtc::CritScope lock(&crit_);
MutexLock lock(&mutex_);
if (active_ == active)
return;
const std::vector<bool> active_modules(rtp_streams_.size(), active);
@ -475,7 +475,7 @@ void RtpVideoSender::SetActive(bool active) {
}
void RtpVideoSender::SetActiveModules(const std::vector<bool> active_modules) {
rtc::CritScope lock(&crit_);
MutexLock lock(&mutex_);
return SetActiveModulesLocked(active_modules);
}
@ -495,7 +495,7 @@ void RtpVideoSender::SetActiveModulesLocked(
}
bool RtpVideoSender::IsActive() {
rtc::CritScope lock(&crit_);
MutexLock lock(&mutex_);
return IsActiveLocked();
}
@ -509,7 +509,7 @@ EncodedImageCallback::Result RtpVideoSender::OnEncodedImage(
const RTPFragmentationHeader* fragmentation) {
fec_controller_->UpdateWithEncodedData(encoded_image.size(),
encoded_image._frameType);
rtc::CritScope lock(&crit_);
MutexLock lock(&mutex_);
RTC_DCHECK(!rtp_streams_.empty());
if (!active_)
return Result(Result::ERROR_SEND_FAILED);
@ -583,7 +583,7 @@ EncodedImageCallback::Result RtpVideoSender::OnEncodedImage(
void RtpVideoSender::OnBitrateAllocationUpdated(
const VideoBitrateAllocation& bitrate) {
rtc::CritScope lock(&crit_);
MutexLock lock(&mutex_);
if (IsActiveLocked()) {
if (rtp_streams_.size() == 1) {
// If spatial scalability is enabled, it is covered by a single stream.
@ -726,7 +726,7 @@ std::map<uint32_t, RtpState> RtpVideoSender::GetRtpStates() const {
std::map<uint32_t, RtpPayloadState> RtpVideoSender::GetRtpPayloadStates()
const {
rtc::CritScope lock(&crit_);
MutexLock lock(&mutex_);
std::map<uint32_t, RtpPayloadState> payload_states;
for (const auto& param : params_) {
payload_states[param.ssrc()] = param.state();
@ -737,7 +737,7 @@ std::map<uint32_t, RtpPayloadState> RtpVideoSender::GetRtpPayloadStates()
void RtpVideoSender::OnTransportOverheadChanged(
size_t transport_overhead_bytes_per_packet) {
rtc::CritScope lock(&crit_);
MutexLock lock(&mutex_);
transport_overhead_bytes_per_packet_ = transport_overhead_bytes_per_packet;
size_t max_rtp_packet_size =
@ -751,7 +751,7 @@ void RtpVideoSender::OnTransportOverheadChanged(
void RtpVideoSender::OnBitrateUpdated(BitrateAllocationUpdate update,
int framerate) {
// Substract overhead from bitrate.
rtc::CritScope lock(&crit_);
MutexLock lock(&mutex_);
size_t num_active_streams = 0;
size_t overhead_bytes_per_packet = 0;
for (const auto& stream : rtp_streams_) {
@ -880,14 +880,14 @@ int RtpVideoSender::ProtectionRequest(const FecProtectionParams* delta_params,
}
void RtpVideoSender::SetFecAllowed(bool fec_allowed) {
rtc::CritScope cs(&crit_);
MutexLock lock(&mutex_);
fec_allowed_ = fec_allowed;
}
void RtpVideoSender::OnPacketFeedbackVector(
std::vector<StreamPacketInfo> packet_feedback_vector) {
if (fec_controller_->UseLossVectorMask()) {
rtc::CritScope cs(&crit_);
MutexLock lock(&mutex_);
for (const StreamPacketInfo& packet : packet_feedback_vector) {
loss_mask_vector_.push_back(!packet.received);
}

64
call/rtp_video_sender.h
View file

@ -36,8 +36,8 @@
#include "modules/rtp_rtcp/source/rtp_video_header.h"
#include "modules/utility/include/process_thread.h"
#include "rtc_base/constructor_magic.h"
#include "rtc_base/critical_section.h"
#include "rtc_base/rate_limiter.h"
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/thread_annotations.h"
#include "rtc_base/thread_checker.h"
@ -97,27 +97,27 @@ class RtpVideoSender : public RtpVideoSenderInterface,
// TODO(perkj): Replace the use of |module_process_thread| with a TaskQueue,
// maybe |worker_queue|.
void RegisterProcessThread(ProcessThread* module_process_thread)
RTC_LOCKS_EXCLUDED(crit_) override;
void DeRegisterProcessThread() RTC_LOCKS_EXCLUDED(crit_) override;
RTC_LOCKS_EXCLUDED(mutex_) override;
void DeRegisterProcessThread() RTC_LOCKS_EXCLUDED(mutex_) override;
// RtpVideoSender will only route packets if being active, all packets will be
// dropped otherwise.
void SetActive(bool active) RTC_LOCKS_EXCLUDED(crit_) override;
void SetActive(bool active) RTC_LOCKS_EXCLUDED(mutex_) override;
// Sets the sending status of the rtp modules and appropriately sets the
// payload router to active if any rtp modules are active.
void SetActiveModules(const std::vector<bool> active_modules)
RTC_LOCKS_EXCLUDED(crit_) override;
bool IsActive() RTC_LOCKS_EXCLUDED(crit_) override;
RTC_LOCKS_EXCLUDED(mutex_) override;
bool IsActive() RTC_LOCKS_EXCLUDED(mutex_) override;
void OnNetworkAvailability(bool network_available)
RTC_LOCKS_EXCLUDED(crit_) override;
RTC_LOCKS_EXCLUDED(mutex_) override;
std::map<uint32_t, RtpState> GetRtpStates() const
RTC_LOCKS_EXCLUDED(crit_) override;
RTC_LOCKS_EXCLUDED(mutex_) override;
std::map<uint32_t, RtpPayloadState> GetRtpPayloadStates() const
RTC_LOCKS_EXCLUDED(crit_) override;
RTC_LOCKS_EXCLUDED(mutex_) override;
void DeliverRtcp(const uint8_t* packet, size_t length)
RTC_LOCKS_EXCLUDED(crit_) override;
RTC_LOCKS_EXCLUDED(mutex_) override;
// Implements webrtc::VCMProtectionCallback.
int ProtectionRequest(const FecProtectionParams* delta_params,
@ -125,10 +125,10 @@ class RtpVideoSender : public RtpVideoSenderInterface,
uint32_t* sent_video_rate_bps,
uint32_t* sent_nack_rate_bps,
uint32_t* sent_fec_rate_bps)
RTC_LOCKS_EXCLUDED(crit_) override;
RTC_LOCKS_EXCLUDED(mutex_) override;
// Implements FecControllerOverride.
void SetFecAllowed(bool fec_allowed) RTC_LOCKS_EXCLUDED(crit_) override;
void SetFecAllowed(bool fec_allowed) RTC_LOCKS_EXCLUDED(mutex_) override;
// Implements EncodedImageCallback.
// Returns 0 if the packet was routed / sent, -1 otherwise.
@ -136,35 +136,35 @@ class RtpVideoSender : public RtpVideoSenderInterface,
const EncodedImage& encoded_image,
const CodecSpecificInfo* codec_specific_info,
const RTPFragmentationHeader* fragmentation)
RTC_LOCKS_EXCLUDED(crit_) override;
RTC_LOCKS_EXCLUDED(mutex_) override;
void OnBitrateAllocationUpdated(const VideoBitrateAllocation& bitrate)
RTC_LOCKS_EXCLUDED(crit_) override;
RTC_LOCKS_EXCLUDED(mutex_) override;
void OnTransportOverheadChanged(size_t transport_overhead_bytes_per_packet)
RTC_LOCKS_EXCLUDED(crit_) override;
RTC_LOCKS_EXCLUDED(mutex_) override;
void OnBitrateUpdated(BitrateAllocationUpdate update, int framerate)
RTC_LOCKS_EXCLUDED(crit_) override;
uint32_t GetPayloadBitrateBps() const RTC_LOCKS_EXCLUDED(crit_) override;
uint32_t GetProtectionBitrateBps() const RTC_LOCKS_EXCLUDED(crit_) override;
RTC_LOCKS_EXCLUDED(mutex_) override;
uint32_t GetPayloadBitrateBps() const RTC_LOCKS_EXCLUDED(mutex_) override;
uint32_t GetProtectionBitrateBps() const RTC_LOCKS_EXCLUDED(mutex_) override;
void SetEncodingData(size_t width, size_t height, size_t num_temporal_layers)
RTC_LOCKS_EXCLUDED(crit_) override;
RTC_LOCKS_EXCLUDED(mutex_) override;
std::vector<RtpSequenceNumberMap::Info> GetSentRtpPacketInfos(
uint32_t ssrc,
rtc::ArrayView<const uint16_t> sequence_numbers) const
RTC_LOCKS_EXCLUDED(crit_) override;
RTC_LOCKS_EXCLUDED(mutex_) override;
// From StreamFeedbackObserver.
void OnPacketFeedbackVector(
std::vector<StreamPacketInfo> packet_feedback_vector)
RTC_LOCKS_EXCLUDED(crit_) override;
RTC_LOCKS_EXCLUDED(mutex_) override;
private:
bool IsActiveLocked() RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
bool IsActiveLocked() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
void SetActiveModulesLocked(const std::vector<bool> active_modules)
RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
void UpdateModuleSendingState() RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
void UpdateModuleSendingState() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
void ConfigureProtection();
void ConfigureSsrcs();
void ConfigureRids();
@ -178,17 +178,17 @@ class RtpVideoSender : public RtpVideoSenderInterface,
const bool has_packet_feedback_;
const bool use_deferred_fec_;
// TODO(holmer): Remove crit_ once RtpVideoSender runs on the
// TODO(holmer): Remove mutex_ once RtpVideoSender runs on the
// transport task queue.
rtc::CriticalSection crit_;
bool active_ RTC_GUARDED_BY(crit_);
mutable Mutex mutex_;
bool active_ RTC_GUARDED_BY(mutex_);
ProcessThread* module_process_thread_;
rtc::ThreadChecker module_process_thread_checker_;
std::map<uint32_t, RtpState> suspended_ssrcs_;
const std::unique_ptr<FecController> fec_controller_;
bool fec_allowed_ RTC_GUARDED_BY(crit_);
bool fec_allowed_ RTC_GUARDED_BY(mutex_);
// Rtp modules are assumed to be sorted in simulcast index order.
const std::vector<webrtc_internal_rtp_video_sender::RtpStreamSender>
@ -202,15 +202,15 @@ class RtpVideoSender : public RtpVideoSenderInterface,
// rewrite the frame id), therefore |shared_frame_id| has to live in a place
// where we are aware of all the different streams.
int64_t shared_frame_id_ = 0;
std::vector<RtpPayloadParams> params_ RTC_GUARDED_BY(crit_);
std::vector<RtpPayloadParams> params_ RTC_GUARDED_BY(mutex_);
size_t transport_overhead_bytes_per_packet_ RTC_GUARDED_BY(crit_);
size_t transport_overhead_bytes_per_packet_ RTC_GUARDED_BY(mutex_);
uint32_t protection_bitrate_bps_;
uint32_t encoder_target_rate_bps_;
std::vector<bool> loss_mask_vector_ RTC_GUARDED_BY(crit_);
std::vector<bool> loss_mask_vector_ RTC_GUARDED_BY(mutex_);
std::vector<FrameCounts> frame_counts_ RTC_GUARDED_BY(crit_);
std::vector<FrameCounts> frame_counts_ RTC_GUARDED_BY(mutex_);
FrameCountObserver* const frame_count_observer_;
// Effectively const map from SSRC to RtpRtcp, for all media SSRCs.

8
call/simulated_network.cc
View file

@ -87,7 +87,7 @@ SimulatedNetwork::SimulatedNetwork(Config config, uint64_t random_seed)
SimulatedNetwork::~SimulatedNetwork() = default;
void SimulatedNetwork::SetConfig(const Config& config) {
rtc::CritScope crit(&config_lock_);
MutexLock lock(&config_lock_);
config_state_.config = config; // Shallow copy of the struct.
double prob_loss = config.loss_percent / 100.0;
if (config_state_.config.avg_burst_loss_length == -1) {
@ -113,12 +113,12 @@ void SimulatedNetwork::SetConfig(const Config& config) {
void SimulatedNetwork::UpdateConfig(
std::function<void(BuiltInNetworkBehaviorConfig*)> config_modifier) {
rtc::CritScope crit(&config_lock_);
MutexLock lock(&config_lock_);
config_modifier(&config_state_.config);
}
void SimulatedNetwork::PauseTransmissionUntil(int64_t until_us) {
rtc::CritScope crit(&config_lock_);
MutexLock lock(&config_lock_);
config_state_.pause_transmission_until_us = until_us;
}
@ -260,7 +260,7 @@ void SimulatedNetwork::UpdateCapacityQueue(ConfigState state,
}
SimulatedNetwork::ConfigState SimulatedNetwork::GetConfigState() const {
rtc::CritScope crit(&config_lock_);
MutexLock lock(&config_lock_);
return config_state_;
}

4
call/simulated_network.h
View file

@ -20,9 +20,9 @@
#include "api/test/simulated_network.h"
#include "api/units/data_size.h"
#include "api/units/timestamp.h"
#include "rtc_base/critical_section.h"
#include "rtc_base/race_checker.h"
#include "rtc_base/random.h"
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/thread_annotations.h"
#include "rtc_base/thread_checker.h"
@ -96,7 +96,7 @@ class SimulatedNetwork : public SimulatedNetworkInterface {
RTC_RUN_ON(&process_checker_);
ConfigState GetConfigState() const;
rtc::CriticalSection config_lock_;
mutable Mutex config_lock_;
// |process_checker_| guards the data structures involved in delay and loss
// processes, such as the packet queues.