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

Delete class voe::RtcEventLogProxy

Browse Source 
Bug: None
Change-Id: Ic0c380e2f7f844a0e06c8c2a3d8bcb42ecee1eba
Reviewed-on: https://webrtc-review.googlesource.com/94040
Reviewed-by: Ivo Creusen <ivoc@webrtc.org>
Reviewed-by: Oskar Sundbom <ossu@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#24287}
This commit is contained in:
Niels Möller 2018-08-14 09:43:34 +02:00 committed by Commit Bot
parent 7d2df3f848
commit fa4e185684
9 changed files with 31 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
audio/audio_receive_stream.cc
View File

@ -66,16 +66,16 @@ namespace {
std::unique_ptr<voe::ChannelProxy> CreateChannelAndProxy(
webrtc::AudioState* audio_state,
ProcessThread* module_process_thread,
const webrtc::AudioReceiveStream::Config& config) {
const webrtc::AudioReceiveStream::Config& config,
RtcEventLog* event_log) {
RTC_DCHECK(audio_state);
internal::AudioState* internal_audio_state =
static_cast<internal::AudioState*>(audio_state);
return std::unique_ptr<voe::ChannelProxy>(
new voe::ChannelProxy(std::unique_ptr<voe::Channel>(new voe::Channel(
module_process_thread, internal_audio_state->audio_device_module(),
nullptr /* RtcpRttStats */, config.jitter_buffer_max_packets,
config.jitter_buffer_fast_accelerate, config.decoder_factory,
config.codec_pair_id))));
return absl::make_unique<voe::ChannelProxy>(absl::make_unique<voe::Channel>(
module_process_thread, internal_audio_state->audio_device_module(),
nullptr /* RtcpRttStats */, event_log, config.jitter_buffer_max_packets,
config.jitter_buffer_fast_accelerate, config.decoder_factory,
config.codec_pair_id));
}
} // namespace
@ -93,7 +93,8 @@ AudioReceiveStream::AudioReceiveStream(
event_log,
CreateChannelAndProxy(audio_state.get(),
module_process_thread,
config)) {}
config,
event_log)) {}
AudioReceiveStream::AudioReceiveStream(
RtpStreamReceiverControllerInterface* receiver_controller,
@ -112,7 +113,6 @@ AudioReceiveStream::AudioReceiveStream(
module_process_thread_checker_.DetachFromThread();
channel_proxy_->SetRtcEventLog(event_log);
channel_proxy_->RegisterTransport(config.rtcp_send_transport);
// Configure bandwidth estimation.
@ -132,7 +132,6 @@ AudioReceiveStream::~AudioReceiveStream() {
channel_proxy_->DisassociateSendChannel();
channel_proxy_->RegisterTransport(nullptr);
channel_proxy_->ResetReceiverCongestionControlObjects();
channel_proxy_->SetRtcEventLog(nullptr);
}
void AudioReceiveStream::Reconfigure(

5
audio/audio_receive_stream_unittest.cc
View File

@ -91,11 +91,6 @@ struct ConfigHelper {
EXPECT_CALL(*channel_proxy_, ResetReceiverCongestionControlObjects())
.Times(1);
EXPECT_CALL(*channel_proxy_, RegisterTransport(nullptr)).Times(2);
testing::Expectation expect_set =
EXPECT_CALL(*channel_proxy_, SetRtcEventLog(&event_log_)).Times(1);
EXPECT_CALL(*channel_proxy_, SetRtcEventLog(testing::IsNull()))
.Times(1)
.After(expect_set);
EXPECT_CALL(*channel_proxy_, DisassociateSendChannel()).Times(1);
EXPECT_CALL(*channel_proxy_, SetReceiveCodecs(_))
.WillRepeatedly(Invoke([](const std::map<int, SdpAudioFormat>& codecs) {

17
audio/audio_send_stream.cc
View File

@ -14,6 +14,8 @@
#include <utility>
#include <vector>
#include "absl/memory/memory.h"
#include "audio/audio_state.h"
#include "audio/channel_proxy.h"
#include "audio/conversion.h"
@ -48,14 +50,14 @@ std::unique_ptr<voe::ChannelProxy> CreateChannelAndProxy(
webrtc::AudioState* audio_state,
rtc::TaskQueue* worker_queue,
ProcessThread* module_process_thread,
RtcpRttStats* rtcp_rtt_stats) {
RtcpRttStats* rtcp_rtt_stats,
RtcEventLog* event_log) {
RTC_DCHECK(audio_state);
internal::AudioState* internal_audio_state =
static_cast<internal::AudioState*>(audio_state);
return std::unique_ptr<voe::ChannelProxy>(
new voe::ChannelProxy(std::unique_ptr<voe::Channel>(new voe::Channel(
worker_queue, module_process_thread,
internal_audio_state->audio_device_module(), rtcp_rtt_stats))));
return absl::make_unique<voe::ChannelProxy>(absl::make_unique<voe::Channel>(
worker_queue, module_process_thread,
internal_audio_state->audio_device_module(), rtcp_rtt_stats, event_log));
}
} // namespace
@ -105,7 +107,8 @@ AudioSendStream::AudioSendStream(
CreateChannelAndProxy(audio_state.get(),
worker_queue,
module_process_thread,
rtcp_rtt_stats)) {}
rtcp_rtt_stats,
event_log)) {}
AudioSendStream::AudioSendStream(
const webrtc::AudioSendStream::Config& config,
@ -139,7 +142,6 @@ AudioSendStream::AudioSendStream(
RTC_DCHECK(transport);
RTC_DCHECK(overall_call_lifetime_);
channel_proxy_->SetRtcEventLog(event_log_);
channel_proxy_->SetRTCPStatus(true);
rtp_rtcp_module_ = channel_proxy_->GetRtpRtcp();
RTC_DCHECK(rtp_rtcp_module_);
@ -158,7 +160,6 @@ AudioSendStream::~AudioSendStream() {
transport_->DeRegisterPacketFeedbackObserver(this);
channel_proxy_->RegisterTransport(nullptr);
channel_proxy_->ResetSenderCongestionControlObjects();
channel_proxy_->SetRtcEventLog(nullptr);
// Lifetime can only be updated after deregistering
// |timed_send_transport_adapter_| in the underlying channel object to avoid
// data races in |active_lifetime_|.

3
audio/audio_send_stream_unittest.cc
View File

@ -221,9 +221,6 @@ struct ConfigHelper {
EXPECT_CALL(*channel_proxy_, RegisterTransport(_)).Times(1);
EXPECT_CALL(*channel_proxy_, RegisterTransport(nullptr)).Times(1);
}
EXPECT_CALL(*channel_proxy_, SetRtcEventLog(testing::NotNull())).Times(1);
EXPECT_CALL(*channel_proxy_, SetRtcEventLog(testing::IsNull()))
.Times(1); // Destructor resets the event log
}
void SetupMockForSetupSendCodec(bool expect_set_encoder_call) {

49
audio/channel.cc
View File

@ -63,36 +63,6 @@ constexpr int kVoiceEngineMaxMinPlayoutDelayMs = 10000;
const int kTelephoneEventAttenuationdB = 10;
class RtcEventLogProxy final : public webrtc::RtcEventLog {
public:
RtcEventLogProxy() : event_log_(nullptr) {}
bool StartLogging(std::unique_ptr<RtcEventLogOutput> output,
int64_t output_period_ms) override {
RTC_NOTREACHED();
return false;
}
void StopLogging() override { RTC_NOTREACHED(); }
void Log(std::unique_ptr<RtcEvent> event) override {
rtc::CritScope lock(&crit_);
if (event_log_) {
event_log_->Log(std::move(event));
}
}
void SetEventLog(RtcEventLog* event_log) {
rtc::CritScope lock(&crit_);
event_log_ = event_log;
}
private:
rtc::CriticalSection crit_;
RtcEventLog* event_log_ RTC_GUARDED_BY(crit_);
RTC_DISALLOW_COPY_AND_ASSIGN(RtcEventLogProxy);
};
class TransportFeedbackProxy : public TransportFeedbackObserver {
public:
TransportFeedbackProxy() : feedback_observer_(nullptr) {
@ -393,7 +363,7 @@ AudioMixer::Source::AudioFrameInfo Channel::GetAudioFrameWithInfo(
unsigned int ssrc;
RTC_CHECK_EQ(GetRemoteSSRC(ssrc), 0);
event_log_proxy_->Log(absl::make_unique<RtcEventAudioPlayout>(ssrc));
event_log_->Log(absl::make_unique<RtcEventAudioPlayout>(ssrc));
// Get 10ms raw PCM data from the ACM (mixer limits output frequency)
bool muted;
if (audio_coding_->PlayoutData10Ms(audio_frame->sample_rate_hz_, audio_frame,
@ -502,10 +472,12 @@ int Channel::PreferredSampleRate() const {
Channel::Channel(rtc::TaskQueue* encoder_queue,
ProcessThread* module_process_thread,
AudioDeviceModule* audio_device_module,
RtcpRttStats* rtcp_rtt_stats)
RtcpRttStats* rtcp_rtt_stats,
RtcEventLog* rtc_event_log)
: Channel(module_process_thread,
audio_device_module,
rtcp_rtt_stats,
rtc_event_log,
0,
false,
rtc::scoped_refptr<AudioDecoderFactory>(),
@ -517,11 +489,12 @@ Channel::Channel(rtc::TaskQueue* encoder_queue,
Channel::Channel(ProcessThread* module_process_thread,
AudioDeviceModule* audio_device_module,
RtcpRttStats* rtcp_rtt_stats,
RtcEventLog* rtc_event_log,
size_t jitter_buffer_max_packets,
bool jitter_buffer_fast_playout,
rtc::scoped_refptr<AudioDecoderFactory> decoder_factory,
absl::optional<AudioCodecPairId> codec_pair_id)
: event_log_proxy_(new RtcEventLogProxy()),
: event_log_(rtc_event_log),
rtp_payload_registry_(new RTPPayloadRegistry()),
rtp_receive_statistics_(
ReceiveStatistics::Create(Clock::GetRealTimeClock())),
@ -581,7 +554,7 @@ Channel::Channel(ProcessThread* module_process_thread,
seq_num_allocator_proxy_.get();
configuration.transport_feedback_callback = feedback_observer_proxy_.get();
}
configuration.event_log = &(*event_log_proxy_);
configuration.event_log = event_log_;
configuration.rtt_stats = rtcp_rtt_stats;
configuration.retransmission_rate_limiter =
retransmission_rate_limiter_.get();
@ -831,8 +804,8 @@ bool Channel::EnableAudioNetworkAdaptor(const std::string& config_string) {
bool success = false;
audio_coding_->ModifyEncoder([&](std::unique_ptr<AudioEncoder>* encoder) {
if (*encoder) {
success = (*encoder)->EnableAudioNetworkAdaptor(config_string,
event_log_proxy_.get());
success =
(*encoder)->EnableAudioNetworkAdaptor(config_string, event_log_);
}
});
return success;
@ -1270,10 +1243,6 @@ void Channel::SetAssociatedSendChannel(Channel* channel) {
associated_send_channel_ = channel;
}
void Channel::SetRtcEventLog(RtcEventLog* event_log) {
event_log_proxy_->SetEventLog(event_log);
}
void Channel::UpdateOverheadForEncoder() {
size_t overhead_per_packet =
transport_overhead_per_packet_ + rtp_overhead_per_packet_;

10
audio/channel.h
View File

@ -89,7 +89,6 @@ struct ReportBlock {
namespace voe {
class RtcEventLogProxy;
class RtpPacketSenderProxy;
class TransportFeedbackProxy;
class TransportSequenceNumberProxy;
@ -150,11 +149,13 @@ class Channel
Channel(rtc::TaskQueue* encoder_queue,
ProcessThread* module_process_thread,
AudioDeviceModule* audio_device_module,
RtcpRttStats* rtcp_rtt_stats);
RtcpRttStats* rtcp_rtt_stats,
RtcEventLog* rtc_event_log);
// Used for receive streams.
Channel(ProcessThread* module_process_thread,
AudioDeviceModule* audio_device_module,
RtcpRttStats* rtcp_rtt_stats,
RtcEventLog* rtc_event_log,
size_t jitter_buffer_max_packets,
bool jitter_buffer_fast_playout,
rtc::scoped_refptr<AudioDecoderFactory> decoder_factory,
@ -285,9 +286,6 @@ class Channel
// Used for obtaining RTT for a receive-only channel.
void SetAssociatedSendChannel(Channel* channel);
// Set a RtcEventLog logging object.
void SetRtcEventLog(RtcEventLog* event_log);
void SetTransportOverhead(size_t transport_overhead_per_packet);
// From OverheadObserver in the RTP/RTCP module
@ -341,7 +339,7 @@ class Channel
ChannelState channel_state_;
std::unique_ptr<voe::RtcEventLogProxy> event_log_proxy_;
RtcEventLog* const event_log_;
std::unique_ptr<RTPPayloadRegistry> rtp_payload_registry_;
std::unique_ptr<ReceiveStatistics> rtp_receive_statistics_;

5
audio/channel_proxy.cc
View File

@ -226,11 +226,6 @@ void ChannelProxy::SetChannelOutputVolumeScaling(float scaling) {
channel_->SetChannelOutputVolumeScaling(scaling);
}
void ChannelProxy::SetRtcEventLog(RtcEventLog* event_log) {
RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
channel_->SetRtcEventLog(event_log);
}
AudioMixer::Source::AudioFrameInfo ChannelProxy::GetAudioFrameWithInfo(
int sample_rate_hz,
AudioFrame* audio_frame) {

1
audio/channel_proxy.h
View File

@ -99,7 +99,6 @@ class ChannelProxy : public RtpPacketSinkInterface {
void OnRtpPacket(const RtpPacketReceived& packet) override;
virtual bool ReceivedRTCPPacket(const uint8_t* packet, size_t length);
virtual void SetChannelOutputVolumeScaling(float scaling);
virtual void SetRtcEventLog(RtcEventLog* event_log);
virtual AudioMixer::Source::AudioFrameInfo GetAudioFrameWithInfo(
int sample_rate_hz,
AudioFrame* audio_frame);

1
audio/mock_voe_channel_proxy.h
View File

@ -68,7 +68,6 @@ class MockVoEChannelProxy : public voe::ChannelProxy {
MOCK_METHOD1(OnRtpPacket, void(const RtpPacketReceived& packet));
MOCK_METHOD2(ReceivedRTCPPacket, bool(const uint8_t* packet, size_t length));
MOCK_METHOD1(SetChannelOutputVolumeScaling, void(float scaling));
MOCK_METHOD1(SetRtcEventLog, void(RtcEventLog* event_log));
MOCK_METHOD2(GetAudioFrameWithInfo,
AudioMixer::Source::AudioFrameInfo(int sample_rate_hz,
AudioFrame* audio_frame));