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

Migrate audio/ to use webrtc::Mutex

Browse Source 
Bug: webrtc:11567
Change-Id: Ic6a753f09aafb508690f4b8dadd4c99433fcfeb6
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176741
Reviewed-by: Sam Zackrisson <saza@webrtc.org>
Commit-Queue: Markus Handell <handellm@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31635}
This commit is contained in:
Markus Handell
2020-07-06 15:15:07 +02:00
committed by Commit Bot
parent afd1dcbde0
commit 6287280d64
17 changed files with 103 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
audio/BUILD.gn
View File

@ -90,6 +90,7 @@ rtc_library("audio") {
"../rtc_base:rtc_task_queue",
"../rtc_base:safe_minmax",
"../rtc_base/experiments:field_trial_parser",
"../rtc_base/synchronization:mutex",
"../rtc_base/synchronization:sequence_checker",
"../rtc_base/task_utils:to_queued_task",
"../system_wrappers",

12
audio/audio_level.cc
View File

@ -22,7 +22,7 @@ AudioLevel::AudioLevel()
AudioLevel::~AudioLevel() {}
void AudioLevel::Reset() {
rtc::CritScope cs(&crit_sect_);
MutexLock lock(&mutex_);
abs_max_ = 0;
count_ = 0;
current_level_full_range_ = 0;
@ -31,24 +31,24 @@ void AudioLevel::Reset() {
}
int16_t AudioLevel::LevelFullRange() const {
rtc::CritScope cs(&crit_sect_);
MutexLock lock(&mutex_);
return current_level_full_range_;
}
void AudioLevel::ResetLevelFullRange() {
rtc::CritScope cs(&crit_sect_);
MutexLock lock(&mutex_);
abs_max_ = 0;
count_ = 0;
current_level_full_range_ = 0;
}
double AudioLevel::TotalEnergy() const {
rtc::CritScope cs(&crit_sect_);
MutexLock lock(&mutex_);
return total_energy_;
}
double AudioLevel::TotalDuration() const {
rtc::CritScope cs(&crit_sect_);
MutexLock lock(&mutex_);
return total_duration_;
}
@ -63,7 +63,7 @@ void AudioLevel::ComputeLevel(const AudioFrame& audioFrame, double duration) {
// Protect member access using a lock since this method is called on a
// dedicated audio thread in the RecordedDataIsAvailable() callback.
rtc::CritScope cs(&crit_sect_);
MutexLock lock(&mutex_);
if (abs_value > abs_max_)
abs_max_ = abs_value;

14
audio/audio_level.h
View File

@ -11,7 +11,7 @@
#ifndef AUDIO_AUDIO_LEVEL_H_
#define AUDIO_AUDIO_LEVEL_H_
#include "rtc_base/critical_section.h"
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/thread_annotations.h"
namespace webrtc {
@ -59,14 +59,14 @@ class AudioLevel {
private:
enum { kUpdateFrequency = 10 };
rtc::CriticalSection crit_sect_;
mutable Mutex mutex_;
int16_t abs_max_ RTC_GUARDED_BY(crit_sect_);
int16_t count_ RTC_GUARDED_BY(crit_sect_);
int16_t current_level_full_range_ RTC_GUARDED_BY(crit_sect_);
int16_t abs_max_ RTC_GUARDED_BY(mutex_);
int16_t count_ RTC_GUARDED_BY(mutex_);
int16_t current_level_full_range_ RTC_GUARDED_BY(mutex_);
double total_energy_ RTC_GUARDED_BY(crit_sect_) = 0.0;
double total_duration_ RTC_GUARDED_BY(crit_sect_) = 0.0;
double total_energy_ RTC_GUARDED_BY(mutex_) = 0.0;
double total_duration_ RTC_GUARDED_BY(mutex_) = 0.0;
};
} // namespace voe

14
audio/audio_send_stream.cc
View File

@ -347,7 +347,7 @@ void AudioSendStream::ConfigureStream(
// Set currently known overhead (used in ANA, opus only).
{
rtc::CritScope cs(&overhead_per_packet_lock_);
MutexLock lock(&overhead_per_packet_lock_);
UpdateOverheadForEncoder();
}
@ -422,7 +422,7 @@ void AudioSendStream::SendAudioData(std::unique_ptr<AudioFrame> audio_frame) {
// TODO(https://crbug.com/webrtc/10771): All "media-source" related stats
// should move from send-streams to the local audio sources or tracks; a
// send-stream should not be required to read the microphone audio levels.
rtc::CritScope cs(&audio_level_lock_);
MutexLock lock(&audio_level_lock_);
audio_level_.ComputeLevel(*audio_frame, duration);
}
channel_send_->ProcessAndEncodeAudio(std::move(audio_frame));
@ -488,7 +488,7 @@ webrtc::AudioSendStream::Stats AudioSendStream::GetStats(
}
{
rtc::CritScope cs(&audio_level_lock_);
MutexLock lock(&audio_level_lock_);
stats.audio_level = audio_level_.LevelFullRange();
stats.total_input_energy = audio_level_.TotalEnergy();
stats.total_input_duration = audio_level_.TotalDuration();
@ -513,7 +513,7 @@ void AudioSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
worker_queue_->PostTask([&]() {
// Poll if overhead has changed, which it can do if ack triggers us to stop
// sending mid/rid.
rtc::CritScope cs(&overhead_per_packet_lock_);
MutexLock lock(&overhead_per_packet_lock_);
UpdateOverheadForEncoder();
});
}
@ -538,7 +538,7 @@ uint32_t AudioSendStream::OnBitrateUpdated(BitrateAllocationUpdate update) {
void AudioSendStream::SetTransportOverhead(
int transport_overhead_per_packet_bytes) {
RTC_DCHECK(worker_thread_checker_.IsCurrent());
rtc::CritScope cs(&overhead_per_packet_lock_);
MutexLock lock(&overhead_per_packet_lock_);
transport_overhead_per_packet_bytes_ = transport_overhead_per_packet_bytes;
UpdateOverheadForEncoder();
}
@ -570,7 +570,7 @@ void AudioSendStream::UpdateOverheadForEncoder() {
}
size_t AudioSendStream::TestOnlyGetPerPacketOverheadBytes() const {
rtc::CritScope cs(&overhead_per_packet_lock_);
MutexLock lock(&overhead_per_packet_lock_);
return GetPerPacketOverheadBytes();
}
@ -670,7 +670,7 @@ bool AudioSendStream::SetupSendCodec(const Config& new_config) {
// Set currently known overhead (used in ANA, opus only).
// If overhead changes later, it will be updated in UpdateOverheadForEncoder.
{
rtc::CritScope cs(&overhead_per_packet_lock_);
MutexLock lock(&overhead_per_packet_lock_);
size_t overhead = GetPerPacketOverheadBytes();
if (overhead > 0) {
encoder->OnReceivedOverhead(overhead);

5
audio/audio_send_stream.h
View File

@ -24,6 +24,7 @@
#include "rtc_base/constructor_magic.h"
#include "rtc_base/experiments/struct_parameters_parser.h"
#include "rtc_base/race_checker.h"
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/task_queue.h"
#include "rtc_base/thread_checker.h"
@ -166,7 +167,7 @@ class AudioSendStream final : public webrtc::AudioSendStream,
int encoder_sample_rate_hz_ = 0;
size_t encoder_num_channels_ = 0;
bool sending_ = false;
rtc::CriticalSection audio_level_lock_;
mutable Mutex audio_level_lock_;
// Keeps track of audio level, total audio energy and total samples duration.
// https://w3c.github.io/webrtc-stats/#dom-rtcaudiohandlerstats-totalaudioenergy
webrtc::voe::AudioLevel audio_level_;
@ -194,7 +195,7 @@ class AudioSendStream final : public webrtc::AudioSendStream,
const std::vector<RtpExtension>& extensions);
static int TransportSeqNumId(const Config& config);
rtc::CriticalSection overhead_per_packet_lock_;
mutable Mutex overhead_per_packet_lock_;
size_t overhead_per_packet_ RTC_GUARDED_BY(overhead_per_packet_lock_) = 0;
// Current transport overhead (ICE, TURN, etc.)

10
audio/audio_transport_impl.cc
View File

@ -118,7 +118,7 @@ int32_t AudioTransportImpl::RecordedDataIsAvailable(
size_t send_num_channels = 0;
bool swap_stereo_channels = false;
{
rtc::CritScope lock(&capture_lock_);
MutexLock lock(&capture_lock_);
send_sample_rate_hz = send_sample_rate_hz_;
send_num_channels = send_num_channels_;
swap_stereo_channels = swap_stereo_channels_;
@ -149,7 +149,7 @@ int32_t AudioTransportImpl::RecordedDataIsAvailable(
// Copy frame and push to each sending stream. The copy is required since an
// encoding task will be posted internally to each stream.
{
rtc::CritScope lock(&capture_lock_);
MutexLock lock(&capture_lock_);
typing_noise_detected_ = typing_detected;
RTC_DCHECK_GT(audio_frame->samples_per_channel_, 0);
@ -237,19 +237,19 @@ void AudioTransportImpl::PullRenderData(int bits_per_sample,
void AudioTransportImpl::UpdateAudioSenders(std::vector<AudioSender*> senders,
int send_sample_rate_hz,
size_t send_num_channels) {
rtc::CritScope lock(&capture_lock_);
MutexLock lock(&capture_lock_);
audio_senders_ = std::move(senders);
send_sample_rate_hz_ = send_sample_rate_hz;
send_num_channels_ = send_num_channels;
}
void AudioTransportImpl::SetStereoChannelSwapping(bool enable) {
rtc::CritScope lock(&capture_lock_);
MutexLock lock(&capture_lock_);
swap_stereo_channels_ = enable;
}
bool AudioTransportImpl::typing_noise_detected() const {
rtc::CritScope lock(&capture_lock_);
MutexLock lock(&capture_lock_);
return typing_noise_detected_;
}
} // namespace webrtc

4
audio/audio_transport_impl.h
View File

@ -20,7 +20,7 @@
#include "modules/audio_processing/include/audio_processing.h"
#include "modules/audio_processing/typing_detection.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 {
@ -71,7 +71,7 @@ class AudioTransportImpl : public AudioTransport {
AudioProcessing* audio_processing_ = nullptr;
// Capture side.
rtc::CriticalSection capture_lock_;
mutable Mutex capture_lock_;
std::vector<AudioSender*> audio_senders_ RTC_GUARDED_BY(capture_lock_);
int send_sample_rate_hz_ RTC_GUARDED_BY(capture_lock_) = 8000;
size_t send_num_channels_ RTC_GUARDED_BY(capture_lock_) = 1;

58
audio/channel_receive.cc
View File

@ -40,12 +40,12 @@
#include "modules/rtp_rtcp/source/rtp_rtcp_impl2.h"
#include "modules/utility/include/process_thread.h"
#include "rtc_base/checks.h"
#include "rtc_base/critical_section.h"
#include "rtc_base/format_macros.h"
#include "rtc_base/location.h"
#include "rtc_base/logging.h"
#include "rtc_base/numerics/safe_minmax.h"
#include "rtc_base/race_checker.h"
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/thread_checker.h"
#include "rtc_base/time_utils.h"
#include "system_wrappers/include/metrics.h"
@ -188,7 +188,7 @@ class ChannelReceive : public ChannelReceiveInterface {
rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer);
bool Playing() const {
rtc::CritScope lock(&playing_lock_);
MutexLock lock(&playing_lock_);
return playing_;
}
@ -204,10 +204,10 @@ class ChannelReceive : public ChannelReceiveInterface {
// audio thread to another, but access is still sequential.
rtc::RaceChecker audio_thread_race_checker_;
rtc::RaceChecker video_capture_thread_race_checker_;
rtc::CriticalSection _callbackCritSect;
rtc::CriticalSection volume_settings_critsect_;
Mutex callback_mutex_;
Mutex volume_settings_mutex_;
rtc::CriticalSection playing_lock_;
mutable Mutex playing_lock_;
bool playing_ RTC_GUARDED_BY(&playing_lock_) = false;
RtcEventLog* const event_log_;
@ -221,7 +221,7 @@ class ChannelReceive : public ChannelReceiveInterface {
// Info for GetSyncInfo is updated on network or worker thread, and queried on
// the worker thread.
rtc::CriticalSection sync_info_lock_;
mutable Mutex sync_info_lock_;
absl::optional<uint32_t> last_received_rtp_timestamp_
RTC_GUARDED_BY(&sync_info_lock_);
absl::optional<int64_t> last_received_rtp_system_time_ms_
@ -237,7 +237,7 @@ class ChannelReceive : public ChannelReceiveInterface {
// Timestamp of the audio pulled from NetEq.
absl::optional<uint32_t> jitter_buffer_playout_timestamp_;
rtc::CriticalSection video_sync_lock_;
mutable Mutex video_sync_lock_;
uint32_t playout_timestamp_rtp_ RTC_GUARDED_BY(video_sync_lock_);
absl::optional<int64_t> playout_timestamp_rtp_time_ms_
RTC_GUARDED_BY(video_sync_lock_);
@ -247,7 +247,7 @@ class ChannelReceive : public ChannelReceiveInterface {
absl::optional<int64_t> playout_timestamp_ntp_time_ms_
RTC_GUARDED_BY(video_sync_lock_);
rtc::CriticalSection ts_stats_lock_;
mutable Mutex ts_stats_lock_;
std::unique_ptr<rtc::TimestampWrapAroundHandler> rtp_ts_wraparound_handler_;
// The rtp timestamp of the first played out audio frame.
@ -259,10 +259,10 @@ class ChannelReceive : public ChannelReceiveInterface {
// uses
ProcessThread* _moduleProcessThreadPtr;
AudioDeviceModule* _audioDeviceModulePtr;
float _outputGain RTC_GUARDED_BY(volume_settings_critsect_);
float _outputGain RTC_GUARDED_BY(volume_settings_mutex_);
// An associated send channel.
rtc::CriticalSection assoc_send_channel_lock_;
mutable Mutex assoc_send_channel_lock_;
const ChannelSendInterface* associated_send_channel_
RTC_GUARDED_BY(assoc_send_channel_lock_);
@ -359,7 +359,7 @@ AudioMixer::Source::AudioFrameInfo ChannelReceive::GetAudioFrameWithInfo(
// scaling/panning, as that applies to the mix operation.
// External recipients of the audio (e.g. via AudioTrack), will do their
// own mixing/dynamic processing.
rtc::CritScope cs(&_callbackCritSect);
MutexLock lock(&callback_mutex_);
if (audio_sink_) {
AudioSinkInterface::Data data(
audio_frame->data(), audio_frame->samples_per_channel_,
@ -371,7 +371,7 @@ AudioMixer::Source::AudioFrameInfo ChannelReceive::GetAudioFrameWithInfo(
float output_gain = 1.0f;
{
rtc::CritScope cs(&volume_settings_critsect_);
MutexLock lock(&volume_settings_mutex_);
output_gain = _outputGain;
}
@ -403,7 +403,7 @@ AudioMixer::Source::AudioFrameInfo ChannelReceive::GetAudioFrameWithInfo(
(GetRtpTimestampRateHz() / 1000);
{
rtc::CritScope lock(&ts_stats_lock_);
MutexLock lock(&ts_stats_lock_);
// Compute ntp time.
audio_frame->ntp_time_ms_ =
ntp_estimator_.Estimate(audio_frame->timestamp_);
@ -421,7 +421,7 @@ AudioMixer::Source::AudioFrameInfo ChannelReceive::GetAudioFrameWithInfo(
RTC_HISTOGRAM_COUNTS_1000("WebRTC.Audio.TargetJitterBufferDelayMs",
acm_receiver_.TargetDelayMs());
const int jitter_buffer_delay = acm_receiver_.FilteredCurrentDelayMs();
rtc::CritScope lock(&video_sync_lock_);
MutexLock lock(&video_sync_lock_);
RTC_HISTOGRAM_COUNTS_1000("WebRTC.Audio.ReceiverDelayEstimateMs",
jitter_buffer_delay + playout_delay_ms_);
RTC_HISTOGRAM_COUNTS_1000("WebRTC.Audio.ReceiverJitterBufferDelayMs",
@ -532,19 +532,19 @@ ChannelReceive::~ChannelReceive() {
void ChannelReceive::SetSink(AudioSinkInterface* sink) {
RTC_DCHECK(worker_thread_checker_.IsCurrent());
rtc::CritScope cs(&_callbackCritSect);
MutexLock lock(&callback_mutex_);
audio_sink_ = sink;
}
void ChannelReceive::StartPlayout() {
RTC_DCHECK(worker_thread_checker_.IsCurrent());
rtc::CritScope lock(&playing_lock_);
MutexLock lock(&playing_lock_);
playing_ = true;
}
void ChannelReceive::StopPlayout() {
RTC_DCHECK(worker_thread_checker_.IsCurrent());
rtc::CritScope lock(&playing_lock_);
MutexLock lock(&playing_lock_);
playing_ = false;
_outputAudioLevel.ResetLevelFullRange();
}
@ -570,7 +570,7 @@ void ChannelReceive::OnRtpPacket(const RtpPacketReceived& packet) {
int64_t now_ms = rtc::TimeMillis();
{
rtc::CritScope cs(&sync_info_lock_);
MutexLock lock(&sync_info_lock_);
last_received_rtp_timestamp_ = packet.Timestamp();
last_received_rtp_system_time_ms_ = now_ms;
}
@ -677,7 +677,7 @@ void ChannelReceive::ReceivedRTCPPacket(const uint8_t* data, size_t length) {
}
{
rtc::CritScope lock(&ts_stats_lock_);
MutexLock lock(&ts_stats_lock_);
ntp_estimator_.UpdateRtcpTimestamp(rtt, ntp_secs, ntp_frac, rtp_timestamp);
}
}
@ -699,7 +699,7 @@ double ChannelReceive::GetTotalOutputDuration() const {
void ChannelReceive::SetChannelOutputVolumeScaling(float scaling) {
RTC_DCHECK(worker_thread_checker_.IsCurrent());
rtc::CritScope cs(&volume_settings_critsect_);
MutexLock lock(&volume_settings_mutex_);
_outputGain = scaling;
}
@ -759,7 +759,7 @@ CallReceiveStatistics ChannelReceive::GetRTCPStatistics() const {
// --- Timestamps
{
rtc::CritScope lock(&ts_stats_lock_);
MutexLock lock(&ts_stats_lock_);
stats.capture_start_ntp_time_ms_ = capture_start_ntp_time_ms_;
}
return stats;
@ -787,7 +787,7 @@ int ChannelReceive::ResendPackets(const uint16_t* sequence_numbers,
void ChannelReceive::SetAssociatedSendChannel(
const ChannelSendInterface* channel) {
RTC_DCHECK(worker_thread_checker_.IsCurrent());
rtc::CritScope lock(&assoc_send_channel_lock_);
MutexLock lock(&assoc_send_channel_lock_);
associated_send_channel_ = channel;
}
@ -818,7 +818,7 @@ AudioDecodingCallStats ChannelReceive::GetDecodingCallStatistics() const {
uint32_t ChannelReceive::GetDelayEstimate() const {
RTC_DCHECK(worker_thread_checker_.IsCurrent() ||
module_process_thread_checker_.IsCurrent());
rtc::CritScope lock(&video_sync_lock_);
MutexLock lock(&video_sync_lock_);
return acm_receiver_.FilteredCurrentDelayMs() + playout_delay_ms_;
}
@ -838,7 +838,7 @@ bool ChannelReceive::GetPlayoutRtpTimestamp(uint32_t* rtp_timestamp,
int64_t* time_ms) const {
RTC_DCHECK_RUNS_SERIALIZED(&video_capture_thread_race_checker_);
{
rtc::CritScope lock(&video_sync_lock_);
MutexLock lock(&video_sync_lock_);
if (!playout_timestamp_rtp_time_ms_)
return false;
*rtp_timestamp = playout_timestamp_rtp_;
@ -850,7 +850,7 @@ bool ChannelReceive::GetPlayoutRtpTimestamp(uint32_t* rtp_timestamp,
void ChannelReceive::SetEstimatedPlayoutNtpTimestampMs(int64_t ntp_timestamp_ms,
int64_t time_ms) {
RTC_DCHECK_RUNS_SERIALIZED(&video_capture_thread_race_checker_);
rtc::CritScope lock(&video_sync_lock_);
MutexLock lock(&video_sync_lock_);
playout_timestamp_ntp_ = ntp_timestamp_ms;
playout_timestamp_ntp_time_ms_ = time_ms;
}
@ -858,7 +858,7 @@ void ChannelReceive::SetEstimatedPlayoutNtpTimestampMs(int64_t ntp_timestamp_ms,
absl::optional<int64_t>
ChannelReceive::GetCurrentEstimatedPlayoutNtpTimestampMs(int64_t now_ms) const {
RTC_DCHECK(worker_thread_checker_.IsCurrent());
rtc::CritScope lock(&video_sync_lock_);
MutexLock lock(&video_sync_lock_);
if (!playout_timestamp_ntp_ || !playout_timestamp_ntp_time_ms_)
return absl::nullopt;
@ -883,7 +883,7 @@ absl::optional<Syncable::Info> ChannelReceive::GetSyncInfo() const {
return absl::nullopt;
}
{
rtc::CritScope cs(&sync_info_lock_);
MutexLock lock(&sync_info_lock_);
if (!last_received_rtp_timestamp_ || !last_received_rtp_system_time_ms_) {
return absl::nullopt;
}
@ -917,7 +917,7 @@ void ChannelReceive::UpdatePlayoutTimestamp(bool rtcp, int64_t now_ms) {
playout_timestamp -= (delay_ms * (GetRtpTimestampRateHz() / 1000));
{
rtc::CritScope lock(&video_sync_lock_);
MutexLock lock(&video_sync_lock_);
if (!rtcp && playout_timestamp != playout_timestamp_rtp_) {
playout_timestamp_rtp_ = playout_timestamp;
playout_timestamp_rtp_time_ms_ = now_ms;
@ -947,7 +947,7 @@ int64_t ChannelReceive::GetRTT() const {
// TODO(nisse): Could we check the return value from the ->RTT() call below,
// instead of checking if we have any report blocks?
if (report_blocks.empty()) {
rtc::CritScope lock(&assoc_send_channel_lock_);
MutexLock lock(&assoc_send_channel_lock_);
// Tries to get RTT from an associated channel.
if (!associated_send_channel_) {
return 0;

35
audio/channel_send.cc
View File

@ -39,6 +39,7 @@
#include "rtc_base/numerics/safe_conversions.h"
#include "rtc_base/race_checker.h"
#include "rtc_base/rate_limiter.h"
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/task_queue.h"
#include "rtc_base/thread_checker.h"
#include "rtc_base/time_utils.h"
@ -186,7 +187,7 @@ class ChannelSend : public ChannelSendInterface,
// audio thread to another, but access is still sequential.
rtc::RaceChecker audio_thread_race_checker_;
rtc::CriticalSection volume_settings_critsect_;
mutable Mutex volume_settings_mutex_;
bool sending_ RTC_GUARDED_BY(&worker_thread_checker_) = false;
@ -201,7 +202,7 @@ class ChannelSend : public ChannelSendInterface,
// uses
ProcessThread* const _moduleProcessThreadPtr;
RmsLevel rms_level_ RTC_GUARDED_BY(encoder_queue_);
bool input_mute_ RTC_GUARDED_BY(volume_settings_critsect_);
bool input_mute_ RTC_GUARDED_BY(volume_settings_mutex_);
bool previous_frame_muted_ RTC_GUARDED_BY(encoder_queue_);
// VoeRTP_RTCP
// TODO(henrika): can today be accessed on the main thread and on the
@ -234,8 +235,8 @@ class ChannelSend : public ChannelSendInterface,
rtc::scoped_refptr<ChannelSendFrameTransformerDelegate>
frame_transformer_delegate_ RTC_GUARDED_BY(encoder_queue_);
rtc::CriticalSection bitrate_crit_section_;
int configured_bitrate_bps_ RTC_GUARDED_BY(bitrate_crit_section_) = 0;
mutable Mutex bitrate_mutex_;
int configured_bitrate_bps_ RTC_GUARDED_BY(bitrate_mutex_) = 0;
// Defined last to ensure that there are no running tasks when the other
// members are destroyed.
@ -250,20 +251,20 @@ class RtpPacketSenderProxy : public RtpPacketSender {
void SetPacketPacer(RtpPacketSender* rtp_packet_pacer) {
RTC_DCHECK(thread_checker_.IsCurrent());
rtc::CritScope lock(&crit_);
MutexLock lock(&mutex_);
rtp_packet_pacer_ = rtp_packet_pacer;
}
void EnqueuePackets(
std::vector<std::unique_ptr<RtpPacketToSend>> packets) override {
rtc::CritScope lock(&crit_);
MutexLock lock(&mutex_);
rtp_packet_pacer_->EnqueuePackets(std::move(packets));
}
private:
rtc::ThreadChecker thread_checker_;
rtc::CriticalSection crit_;
RtpPacketSender* rtp_packet_pacer_ RTC_GUARDED_BY(&crit_);
Mutex mutex_;
RtpPacketSender* rtp_packet_pacer_ RTC_GUARDED_BY(&mutex_);
};
class VoERtcpObserver : public RtcpBandwidthObserver {
@ -273,12 +274,12 @@ class VoERtcpObserver : public RtcpBandwidthObserver {
~VoERtcpObserver() override {}
void SetBandwidthObserver(RtcpBandwidthObserver* bandwidth_observer) {
rtc::CritScope lock(&crit_);
MutexLock lock(&mutex_);
bandwidth_observer_ = bandwidth_observer;
}
void OnReceivedEstimatedBitrate(uint32_t bitrate) override {
rtc::CritScope lock(&crit_);
MutexLock lock(&mutex_);
if (bandwidth_observer_) {
bandwidth_observer_->OnReceivedEstimatedBitrate(bitrate);
}
@ -288,7 +289,7 @@ class VoERtcpObserver : public RtcpBandwidthObserver {
int64_t rtt,
int64_t now_ms) override {
{
rtc::CritScope lock(&crit_);
MutexLock lock(&mutex_);
if (bandwidth_observer_) {
bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, rtt,
now_ms);
@ -336,8 +337,8 @@ class VoERtcpObserver : public RtcpBandwidthObserver {
ChannelSend* owner_;
// Maps remote side ssrc to extended highest sequence number received.
std::map<uint32_t, uint32_t> extended_max_sequence_number_;
rtc::CriticalSection crit_;
RtcpBandwidthObserver* bandwidth_observer_ RTC_GUARDED_BY(crit_);
Mutex mutex_;
RtcpBandwidthObserver* bandwidth_observer_ RTC_GUARDED_BY(mutex_);
};
int32_t ChannelSend::SendData(AudioFrameType frameType,
@ -606,7 +607,7 @@ void ChannelSend::OnBitrateAllocation(BitrateAllocationUpdate update) {
// rules.
// RTC_DCHECK(worker_thread_checker_.IsCurrent() ||
// module_process_thread_checker_.IsCurrent());
rtc::CritScope lock(&bitrate_crit_section_);
MutexLock lock(&bitrate_mutex_);
CallEncoder([&](AudioEncoder* encoder) {
encoder->OnReceivedUplinkAllocation(update);
@ -616,7 +617,7 @@ void ChannelSend::OnBitrateAllocation(BitrateAllocationUpdate update) {
}
int ChannelSend::GetBitrate() const {
rtc::CritScope lock(&bitrate_crit_section_);
MutexLock lock(&bitrate_mutex_);
return configured_bitrate_bps_;
}
@ -651,12 +652,12 @@ void ChannelSend::ReceivedRTCPPacket(const uint8_t* data, size_t length) {
void ChannelSend::SetInputMute(bool enable) {
RTC_DCHECK_RUN_ON(&worker_thread_checker_);
rtc::CritScope cs(&volume_settings_critsect_);
MutexLock lock(&volume_settings_mutex_);
input_mute_ = enable;
}
bool ChannelSend::InputMute() const {
rtc::CritScope cs(&volume_settings_critsect_);
MutexLock lock(&volume_settings_mutex_);
return input_mute_;
}

6
audio/channel_send_frame_transformer_delegate.cc
View File

@ -77,7 +77,7 @@ void ChannelSendFrameTransformerDelegate::Reset() {
frame_transformer_->UnregisterTransformedFrameCallback();
frame_transformer_ = nullptr;
rtc::CritScope lock(&send_lock_);
MutexLock lock(&send_lock_);
send_frame_callback_ = SendFrameCallback();
}
@ -97,7 +97,7 @@ void ChannelSendFrameTransformerDelegate::Transform(
void ChannelSendFrameTransformerDelegate::OnTransformedFrame(
std::unique_ptr<TransformableFrameInterface> frame) {
rtc::CritScope lock(&send_lock_);
MutexLock lock(&send_lock_);
if (!send_frame_callback_)
return;
rtc::scoped_refptr<ChannelSendFrameTransformerDelegate> delegate = this;
@ -109,7 +109,7 @@ void ChannelSendFrameTransformerDelegate::OnTransformedFrame(
void ChannelSendFrameTransformerDelegate::SendFrame(
std::unique_ptr<TransformableFrameInterface> frame) const {
rtc::CritScope lock(&send_lock_);
MutexLock lock(&send_lock_);
RTC_DCHECK_RUN_ON(encoder_queue_);
if (!send_frame_callback_)
return;

4
audio/channel_send_frame_transformer_delegate.h
View File

@ -16,7 +16,7 @@
#include "api/frame_transformer_interface.h"
#include "modules/audio_coding/include/audio_coding_module_typedefs.h"
#include "rtc_base/buffer.h"
#include "rtc_base/critical_section.h"
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "rtc_base/task_queue.h"
@ -72,7 +72,7 @@ class ChannelSendFrameTransformerDelegate : public TransformedFrameCallback {
~ChannelSendFrameTransformerDelegate() override = default;
private:
rtc::CriticalSection send_lock_;
mutable Mutex send_lock_;
SendFrameCallback send_frame_callback_ RTC_GUARDED_BY(send_lock_);
rtc::scoped_refptr<FrameTransformerInterface> frame_transformer_;
rtc::TaskQueue* encoder_queue_ RTC_GUARDED_BY(send_lock_);

3
audio/voip/BUILD.gn
View File

@ -26,6 +26,7 @@ rtc_library("voip_core") {
"../../modules/utility:utility",
"../../rtc_base:criticalsection",
"../../rtc_base:logging",
"../../rtc_base/synchronization:mutex",
]
absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
}
@ -74,6 +75,7 @@ rtc_library("audio_ingress") {
"../../rtc_base:logging",
"../../rtc_base:safe_minmax",
"../../rtc_base:timeutils",
"../../rtc_base/synchronization:mutex",
"../utility:audio_frame_operations",
]
}
@ -95,6 +97,7 @@ rtc_library("audio_egress") {
"../../rtc_base:rtc_task_queue",
"../../rtc_base:thread_checker",
"../../rtc_base:timeutils",
"../../rtc_base/synchronization:mutex",
"../utility:audio_frame_operations",
]
}

7
audio/voip/audio_egress.h
View File

@ -22,6 +22,7 @@
#include "modules/rtp_rtcp/include/report_block_data.h"
#include "modules/rtp_rtcp/source/rtp_rtcp_interface.h"
#include "modules/rtp_rtcp/source/rtp_sender_audio.h"
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/task_queue.h"
#include "rtc_base/thread_checker.h"
#include "rtc_base/time_utils.h"
@ -72,7 +73,7 @@ class AudioEgress : public AudioSender, public AudioPacketizationCallback {
// Retrieve current encoder format info. This returns encoder format set
// by SetEncoder() and if encoder is not set, this will return nullopt.
absl::optional<SdpAudioFormat> GetEncoderFormat() const {
rtc::CritScope lock(&lock_);
MutexLock lock(&lock_);
return encoder_format_;
}
@ -99,11 +100,11 @@ class AudioEgress : public AudioSender, public AudioPacketizationCallback {
private:
void SetEncoderFormat(const SdpAudioFormat& encoder_format) {
rtc::CritScope lock(&lock_);
MutexLock lock(&lock_);
encoder_format_ = encoder_format;
}
rtc::CriticalSection lock_;
mutable Mutex lock_;
// Current encoder format selected by caller.
absl::optional<SdpAudioFormat> encoder_format_ RTC_GUARDED_BY(lock_);

9
audio/voip/audio_ingress.cc
View File

@ -17,7 +17,6 @@
#include "api/audio_codecs/audio_format.h"
#include "audio/utility/audio_frame_operations.h"
#include "modules/audio_coding/include/audio_coding_module.h"
#include "rtc_base/critical_section.h"
#include "rtc_base/logging.h"
#include "rtc_base/numerics/safe_minmax.h"
@ -83,7 +82,7 @@ AudioMixer::Source::AudioFrameInfo AudioIngress::GetAudioFrameWithInfo(
// Compute elapsed and NTP times.
int64_t unwrap_timestamp;
{
rtc::CritScope lock(&lock_);
MutexLock lock(&lock_);
unwrap_timestamp =
timestamp_wrap_handler_.Unwrap(audio_frame->timestamp_);
audio_frame->ntp_time_ms_ =
@ -107,7 +106,7 @@ AudioMixer::Source::AudioFrameInfo AudioIngress::GetAudioFrameWithInfo(
void AudioIngress::SetReceiveCodecs(
const std::map<int, SdpAudioFormat>& codecs) {
{
rtc::CritScope lock(&lock_);
MutexLock lock(&lock_);
for (const auto& kv : codecs) {
receive_codec_info_[kv.first] = kv.second.clockrate_hz;
}
@ -125,7 +124,7 @@ void AudioIngress::ReceivedRTPPacket(rtc::ArrayView<const uint8_t> rtp_packet) {
// Set payload type's sampling rate before we feed it into ReceiveStatistics.
{
rtc::CritScope lock(&lock_);
MutexLock lock(&lock_);
const auto& it =
receive_codec_info_.find(rtp_packet_received.PayloadType());
// If sampling rate info is not available in our received codec set, it
@ -185,7 +184,7 @@ void AudioIngress::ReceivedRTCPPacket(
}
{
rtc::CritScope lock(&lock_);
MutexLock lock(&lock_);
ntp_estimator_.UpdateRtcpTimestamp(rtt, ntp_secs, ntp_frac, rtp_timestamp);
}
}

4
audio/voip/audio_ingress.h
View File

@ -28,7 +28,7 @@
#include "modules/rtp_rtcp/include/remote_ntp_time_estimator.h"
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
#include "modules/rtp_rtcp/source/rtp_rtcp_interface.h"
#include "rtc_base/critical_section.h"
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/time_utils.h"
namespace webrtc {
@ -131,7 +131,7 @@ class AudioIngress : public AudioMixer::Source {
// Synchronizaton is handled internally by voe::AudioLevel.
voe::AudioLevel output_audio_level_;
rtc::CriticalSection lock_;
Mutex lock_;
RemoteNtpTimeEstimator ntp_estimator_ RTC_GUARDED_BY(lock_);

11
audio/voip/voip_core.cc
View File

@ -15,7 +15,6 @@
#include <utility>
#include "api/audio_codecs/audio_format.h"
#include "rtc_base/critical_section.h"
#include "rtc_base/logging.h"
namespace webrtc {
@ -134,7 +133,7 @@ absl::optional<ChannelId> VoipCore::CreateChannel(
process_thread_.get(), audio_mixer_.get(), decoder_factory_);
{
rtc::CritScope lock(&lock_);
MutexLock lock(&lock_);
channel = static_cast<ChannelId>(next_channel_id_);
channels_[*channel] = audio_channel;
@ -154,7 +153,7 @@ void VoipCore::ReleaseChannel(ChannelId channel) {
// Destroy channel outside of the lock.
rtc::scoped_refptr<AudioChannel> audio_channel;
{
rtc::CritScope lock(&lock_);
MutexLock lock(&lock_);
auto iter = channels_.find(channel);
if (iter != channels_.end()) {
@ -170,7 +169,7 @@ void VoipCore::ReleaseChannel(ChannelId channel) {
rtc::scoped_refptr<AudioChannel> VoipCore::GetChannel(ChannelId channel) {
rtc::scoped_refptr<AudioChannel> audio_channel;
{
rtc::CritScope lock(&lock_);
MutexLock lock(&lock_);
auto iter = channels_.find(channel);
if (iter != channels_.end()) {
audio_channel = iter->second;
@ -191,7 +190,7 @@ bool VoipCore::UpdateAudioTransportWithSenders() {
int max_sampling_rate = 8000;
size_t max_num_channels = 1;
{
rtc::CritScope lock(&lock_);
MutexLock lock(&lock_);
// Reserve to prevent run time vector re-allocation.
audio_senders.reserve(channels_.size());
for (auto kv : channels_) {
@ -290,7 +289,7 @@ bool VoipCore::StopPlayout(ChannelId channel) {
bool stop_device = true;
{
rtc::CritScope lock(&lock_);
MutexLock lock(&lock_);
for (auto kv : channels_) {
rtc::scoped_refptr<AudioChannel>& channel = kv.second;
if (channel->IsPlaying()) {

4
audio/voip/voip_core.h
View File

@ -31,7 +31,7 @@
#include "modules/audio_mixer/audio_mixer_impl.h"
#include "modules/audio_processing/include/audio_processing.h"
#include "modules/utility/include/process_thread.h"
#include "rtc_base/critical_section.h"
#include "rtc_base/synchronization/mutex.h"
namespace webrtc {
@ -123,7 +123,7 @@ class VoipCore : public VoipEngine,
// Must be placed before |channels_| for proper destruction.
std::unique_ptr<ProcessThread> process_thread_;
rtc::CriticalSection lock_;
Mutex lock_;
// Member to track a next ChannelId for new AudioChannel.
int next_channel_id_ RTC_GUARDED_BY(lock_) = 0;