Re-Land: Implement AudioReceiveStream::GetStats().
R=tommi@webrtc.org
BUG=webrtc:4690
Committed: https://chromium.googlesource.com/external/webrtc/+/a457752f4afc496ed7f4d6b584b08d8635f18cc0
Review URL: https://codereview.webrtc.org/1390753002 .
Cr-Commit-Position: refs/heads/master@{#10369}
diff --git a/webrtc/audio/BUILD.gn b/webrtc/audio/BUILD.gn
index c6f4b6b..d5061db 100644
--- a/webrtc/audio/BUILD.gn
+++ b/webrtc/audio/BUILD.gn
@@ -14,6 +14,8 @@
"audio_receive_stream.h",
"audio_send_stream.cc",
"audio_send_stream.h",
+ "conversion.h",
+ "scoped_voe_interface.h",
]
configs += [ "..:common_config" ]
diff --git a/webrtc/audio/audio_receive_stream.cc b/webrtc/audio/audio_receive_stream.cc
index c725e37..0fd96d0 100644
--- a/webrtc/audio/audio_receive_stream.cc
+++ b/webrtc/audio/audio_receive_stream.cc
@@ -12,10 +12,17 @@
#include <string>
+#include "webrtc/audio/conversion.h"
#include "webrtc/base/checks.h"
#include "webrtc/base/logging.h"
#include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
#include "webrtc/system_wrappers/interface/tick_util.h"
+#include "webrtc/voice_engine/include/voe_base.h"
+#include "webrtc/voice_engine/include/voe_codec.h"
+#include "webrtc/voice_engine/include/voe_neteq_stats.h"
+#include "webrtc/voice_engine/include/voe_rtp_rtcp.h"
+#include "webrtc/voice_engine/include/voe_video_sync.h"
+#include "webrtc/voice_engine/include/voe_volume_control.h"
namespace webrtc {
std::string AudioReceiveStream::Config::Rtp::ToString() const {
@@ -24,8 +31,9 @@
ss << ", extensions: [";
for (size_t i = 0; i < extensions.size(); ++i) {
ss << extensions[i].ToString();
- if (i != extensions.size() - 1)
+ if (i != extensions.size() - 1) {
ss << ", ";
+ }
}
ss << ']';
ss << '}';
@@ -36,8 +44,9 @@
std::stringstream ss;
ss << "{rtp: " << rtp.ToString();
ss << ", voe_channel_id: " << voe_channel_id;
- if (!sync_group.empty())
+ if (!sync_group.empty()) {
ss << ", sync_group: " << sync_group;
+ }
ss << '}';
return ss.str();
}
@@ -45,13 +54,18 @@
namespace internal {
AudioReceiveStream::AudioReceiveStream(
RemoteBitrateEstimator* remote_bitrate_estimator,
- const webrtc::AudioReceiveStream::Config& config)
+ const webrtc::AudioReceiveStream::Config& config,
+ VoiceEngine* voice_engine)
: remote_bitrate_estimator_(remote_bitrate_estimator),
config_(config),
+ voice_engine_(voice_engine),
+ voe_base_(voice_engine),
rtp_header_parser_(RtpHeaderParser::Create()) {
+ RTC_DCHECK(thread_checker_.CalledOnValidThread());
LOG(LS_INFO) << "AudioReceiveStream: " << config_.ToString();
RTC_DCHECK(config.voe_channel_id != -1);
RTC_DCHECK(remote_bitrate_estimator_ != nullptr);
+ RTC_DCHECK(voice_engine_ != nullptr);
RTC_DCHECK(rtp_header_parser_ != nullptr);
for (const auto& ext : config.rtp.extensions) {
// One-byte-extension local identifiers are in the range 1-14 inclusive.
@@ -73,33 +87,117 @@
}
AudioReceiveStream::~AudioReceiveStream() {
+ RTC_DCHECK(thread_checker_.CalledOnValidThread());
LOG(LS_INFO) << "~AudioReceiveStream: " << config_.ToString();
}
webrtc::AudioReceiveStream::Stats AudioReceiveStream::GetStats() const {
- return webrtc::AudioReceiveStream::Stats();
+ RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ webrtc::AudioReceiveStream::Stats stats;
+ stats.remote_ssrc = config_.rtp.remote_ssrc;
+ ScopedVoEInterface<VoECodec> codec(voice_engine_);
+ ScopedVoEInterface<VoENetEqStats> neteq(voice_engine_);
+ ScopedVoEInterface<VoERTP_RTCP> rtp(voice_engine_);
+ ScopedVoEInterface<VoEVideoSync> sync(voice_engine_);
+ ScopedVoEInterface<VoEVolumeControl> volume(voice_engine_);
+ unsigned int ssrc = 0;
+ webrtc::CallStatistics cs = {0};
+ webrtc::CodecInst ci = {0};
+ // Only collect stats if we have seen some traffic with the SSRC.
+ if (rtp->GetRemoteSSRC(config_.voe_channel_id, ssrc) == -1 ||
+ rtp->GetRTCPStatistics(config_.voe_channel_id, cs) == -1 ||
+ codec->GetRecCodec(config_.voe_channel_id, ci) == -1) {
+ return stats;
+ }
+
+ stats.bytes_rcvd = cs.bytesReceived;
+ stats.packets_rcvd = cs.packetsReceived;
+ stats.packets_lost = cs.cumulativeLost;
+ stats.fraction_lost = static_cast<float>(cs.fractionLost) / (1 << 8);
+ if (ci.pltype != -1) {
+ stats.codec_name = ci.plname;
+ }
+
+ stats.ext_seqnum = cs.extendedMax;
+ if (ci.plfreq / 1000 > 0) {
+ stats.jitter_ms = cs.jitterSamples / (ci.plfreq / 1000);
+ }
+ {
+ int jitter_buffer_delay_ms = 0;
+ int playout_buffer_delay_ms = 0;
+ sync->GetDelayEstimate(config_.voe_channel_id, &jitter_buffer_delay_ms,
+ &playout_buffer_delay_ms);
+ stats.delay_estimate_ms =
+ jitter_buffer_delay_ms + playout_buffer_delay_ms;
+ }
+ {
+ unsigned int level = 0;
+ if (volume->GetSpeechOutputLevelFullRange(config_.voe_channel_id, level)
+ != -1) {
+ stats.audio_level = static_cast<int32_t>(level);
+ }
+ }
+
+ webrtc::NetworkStatistics ns = {0};
+ if (neteq->GetNetworkStatistics(config_.voe_channel_id, ns) != -1) {
+ // Get jitter buffer and total delay (alg + jitter + playout) stats.
+ stats.jitter_buffer_ms = ns.currentBufferSize;
+ stats.jitter_buffer_preferred_ms = ns.preferredBufferSize;
+ stats.expand_rate = Q14ToFloat(ns.currentExpandRate);
+ stats.speech_expand_rate = Q14ToFloat(ns.currentSpeechExpandRate);
+ stats.secondary_decoded_rate = Q14ToFloat(ns.currentSecondaryDecodedRate);
+ stats.accelerate_rate = Q14ToFloat(ns.currentAccelerateRate);
+ stats.preemptive_expand_rate = Q14ToFloat(ns.currentPreemptiveRate);
+ }
+
+ webrtc::AudioDecodingCallStats ds;
+ if (neteq->GetDecodingCallStatistics(config_.voe_channel_id, &ds) != -1) {
+ stats.decoding_calls_to_silence_generator =
+ ds.calls_to_silence_generator;
+ stats.decoding_calls_to_neteq = ds.calls_to_neteq;
+ stats.decoding_normal = ds.decoded_normal;
+ stats.decoding_plc = ds.decoded_plc;
+ stats.decoding_cng = ds.decoded_cng;
+ stats.decoding_plc_cng = ds.decoded_plc_cng;
+ }
+
+ stats.capture_start_ntp_time_ms = cs.capture_start_ntp_time_ms_;
+
+ return stats;
}
const webrtc::AudioReceiveStream::Config& AudioReceiveStream::config() const {
+ RTC_DCHECK(thread_checker_.CalledOnValidThread());
return config_;
}
void AudioReceiveStream::Start() {
+ RTC_DCHECK(thread_checker_.CalledOnValidThread());
}
void AudioReceiveStream::Stop() {
+ RTC_DCHECK(thread_checker_.CalledOnValidThread());
}
void AudioReceiveStream::SignalNetworkState(NetworkState state) {
+ RTC_DCHECK(thread_checker_.CalledOnValidThread());
}
bool AudioReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) {
+ // TODO(solenberg): Tests call this function on a network thread, libjingle
+ // calls on the worker thread. We should move towards always using a network
+ // thread. Then this check can be enabled.
+ // RTC_DCHECK(!thread_checker_.CalledOnValidThread());
return false;
}
bool AudioReceiveStream::DeliverRtp(const uint8_t* packet,
size_t length,
const PacketTime& packet_time) {
+ // TODO(solenberg): Tests call this function on a network thread, libjingle
+ // calls on the worker thread. We should move towards always using a network
+ // thread. Then this check can be enabled.
+ // RTC_DCHECK(!thread_checker_.CalledOnValidThread());
RTPHeader header;
if (!rtp_header_parser_->Parse(packet, length, &header)) {
diff --git a/webrtc/audio/audio_receive_stream.h b/webrtc/audio/audio_receive_stream.h
index 1e52724..5c77653 100644
--- a/webrtc/audio/audio_receive_stream.h
+++ b/webrtc/audio/audio_receive_stream.h
@@ -12,18 +12,23 @@
#define WEBRTC_AUDIO_AUDIO_RECEIVE_STREAM_H_
#include "webrtc/audio_receive_stream.h"
+#include "webrtc/audio/scoped_voe_interface.h"
+#include "webrtc/base/thread_checker.h"
#include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
+#include "webrtc/voice_engine/include/voe_base.h"
namespace webrtc {
class RemoteBitrateEstimator;
+class VoiceEngine;
namespace internal {
class AudioReceiveStream : public webrtc::AudioReceiveStream {
public:
AudioReceiveStream(RemoteBitrateEstimator* remote_bitrate_estimator,
- const webrtc::AudioReceiveStream::Config& config);
+ const webrtc::AudioReceiveStream::Config& config,
+ VoiceEngine* voice_engine);
~AudioReceiveStream() override;
// webrtc::ReceiveStream implementation.
@@ -41,8 +46,12 @@
const webrtc::AudioReceiveStream::Config& config() const;
private:
+ rtc::ThreadChecker thread_checker_;
RemoteBitrateEstimator* const remote_bitrate_estimator_;
const webrtc::AudioReceiveStream::Config config_;
+ VoiceEngine* voice_engine_;
+ // We hold one interface pointer to the VoE to make sure it is kept alive.
+ ScopedVoEInterface<VoEBase> voe_base_;
rtc::scoped_ptr<RtpHeaderParser> rtp_header_parser_;
};
} // namespace internal
diff --git a/webrtc/audio/audio_receive_stream_unittest.cc b/webrtc/audio/audio_receive_stream_unittest.cc
index d6cce69..8809b35 100644
--- a/webrtc/audio/audio_receive_stream_unittest.cc
+++ b/webrtc/audio/audio_receive_stream_unittest.cc
@@ -11,10 +11,14 @@
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/audio/audio_receive_stream.h"
+#include "webrtc/audio/conversion.h"
#include "webrtc/modules/remote_bitrate_estimator/include/mock/mock_remote_bitrate_estimator.h"
#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
+#include "webrtc/test/fake_voice_engine.h"
-namespace webrtc {
+namespace {
+
+using webrtc::ByteWriter;
const size_t kAbsoluteSendTimeLength = 4;
@@ -45,33 +49,93 @@
ByteWriter<uint16_t>::WriteBigEndian(header + 2, 0x1234); // Sequence number.
ByteWriter<uint32_t>::WriteBigEndian(header + 4, 0x5678); // Timestamp.
ByteWriter<uint32_t>::WriteBigEndian(header + 8, 0x4321); // SSRC.
- int32_t rtp_header_length = kRtpHeaderSize;
+ int32_t rtp_header_length = webrtc::kRtpHeaderSize;
BuildAbsoluteSendTimeExtension(header + rtp_header_length, extension_id,
abs_send_time);
rtp_header_length += kAbsoluteSendTimeLength;
return rtp_header_length;
}
+} // namespace
+
+namespace webrtc {
+namespace test {
TEST(AudioReceiveStreamTest, AudioPacketUpdatesBweWithTimestamp) {
- MockRemoteBitrateEstimator rbe;
+ MockRemoteBitrateEstimator remote_bitrate_estimator;
+ FakeVoiceEngine voice_engine;
AudioReceiveStream::Config config;
config.combined_audio_video_bwe = true;
- config.voe_channel_id = 1;
+ config.voe_channel_id = voice_engine.kReceiveChannelId;
const int kAbsSendTimeId = 3;
config.rtp.extensions.push_back(
RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeId));
- internal::AudioReceiveStream recv_stream(&rbe, config);
+ internal::AudioReceiveStream recv_stream(&remote_bitrate_estimator, config,
+ &voice_engine);
uint8_t rtp_packet[30];
const int kAbsSendTimeValue = 1234;
CreateRtpHeaderWithAbsSendTime(rtp_packet, kAbsSendTimeId, kAbsSendTimeValue);
PacketTime packet_time(5678000, 0);
const size_t kExpectedHeaderLength = 20;
- EXPECT_CALL(rbe, IncomingPacket(packet_time.timestamp / 1000,
- sizeof(rtp_packet) - kExpectedHeaderLength,
- testing::_, false))
+ EXPECT_CALL(remote_bitrate_estimator,
+ IncomingPacket(packet_time.timestamp / 1000,
+ sizeof(rtp_packet) - kExpectedHeaderLength, testing::_, false))
.Times(1);
EXPECT_TRUE(
recv_stream.DeliverRtp(rtp_packet, sizeof(rtp_packet), packet_time));
}
+
+TEST(AudioReceiveStreamTest, GetStats) {
+ const uint32_t kSsrc1 = 667;
+
+ MockRemoteBitrateEstimator remote_bitrate_estimator;
+ FakeVoiceEngine voice_engine;
+ AudioReceiveStream::Config config;
+ config.rtp.remote_ssrc = kSsrc1;
+ config.voe_channel_id = voice_engine.kReceiveChannelId;
+ internal::AudioReceiveStream recv_stream(&remote_bitrate_estimator, config,
+ &voice_engine);
+
+ AudioReceiveStream::Stats stats = recv_stream.GetStats();
+ const CallStatistics& call_stats = voice_engine.GetRecvCallStats();
+ const CodecInst& codec_inst = voice_engine.GetRecvRecCodecInst();
+ const NetworkStatistics& net_stats = voice_engine.GetRecvNetworkStats();
+ const AudioDecodingCallStats& decode_stats =
+ voice_engine.GetRecvAudioDecodingCallStats();
+ EXPECT_EQ(kSsrc1, stats.remote_ssrc);
+ EXPECT_EQ(static_cast<int64_t>(call_stats.bytesReceived), stats.bytes_rcvd);
+ EXPECT_EQ(static_cast<uint32_t>(call_stats.packetsReceived),
+ stats.packets_rcvd);
+ EXPECT_EQ(call_stats.cumulativeLost, stats.packets_lost);
+ EXPECT_EQ(static_cast<float>(call_stats.fractionLost) / 256,
+ stats.fraction_lost);
+ EXPECT_EQ(std::string(codec_inst.plname), stats.codec_name);
+ EXPECT_EQ(call_stats.extendedMax, stats.ext_seqnum);
+ EXPECT_EQ(call_stats.jitterSamples / (codec_inst.plfreq / 1000),
+ stats.jitter_ms);
+ EXPECT_EQ(net_stats.currentBufferSize, stats.jitter_buffer_ms);
+ EXPECT_EQ(net_stats.preferredBufferSize, stats.jitter_buffer_preferred_ms);
+ EXPECT_EQ(static_cast<uint32_t>(voice_engine.kRecvJitterBufferDelay +
+ voice_engine.kRecvPlayoutBufferDelay), stats.delay_estimate_ms);
+ EXPECT_EQ(static_cast<int32_t>(voice_engine.kRecvSpeechOutputLevel),
+ stats.audio_level);
+ EXPECT_EQ(Q14ToFloat(net_stats.currentExpandRate), stats.expand_rate);
+ EXPECT_EQ(Q14ToFloat(net_stats.currentSpeechExpandRate),
+ stats.speech_expand_rate);
+ EXPECT_EQ(Q14ToFloat(net_stats.currentSecondaryDecodedRate),
+ stats.secondary_decoded_rate);
+ EXPECT_EQ(Q14ToFloat(net_stats.currentAccelerateRate), stats.accelerate_rate);
+ EXPECT_EQ(Q14ToFloat(net_stats.currentPreemptiveRate),
+ stats.preemptive_expand_rate);
+ EXPECT_EQ(decode_stats.calls_to_silence_generator,
+ stats.decoding_calls_to_silence_generator);
+ EXPECT_EQ(decode_stats.calls_to_neteq, stats.decoding_calls_to_neteq);
+ EXPECT_EQ(decode_stats.decoded_normal, stats.decoding_normal);
+ EXPECT_EQ(decode_stats.decoded_plc, stats.decoding_plc);
+ EXPECT_EQ(decode_stats.decoded_cng, stats.decoding_cng);
+ EXPECT_EQ(decode_stats.decoded_plc_cng, stats.decoding_plc_cng);
+ EXPECT_EQ(call_stats.capture_start_ntp_time_ms_,
+ stats.capture_start_ntp_time_ms);
+}
+} // namespace test
} // namespace webrtc
diff --git a/webrtc/audio/conversion.h b/webrtc/audio/conversion.h
new file mode 100644
index 0000000..c1cf9b6
--- /dev/null
+++ b/webrtc/audio/conversion.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef WEBRTC_AUDIO_CONVERSION_H_
+#define WEBRTC_AUDIO_CONVERSION_H_
+
+namespace webrtc {
+
+// Convert fixed point number with 14 bit fractional part, to floating point.
+inline float Q14ToFloat(uint16_t v) {
+ return static_cast<float>(v) / (1 << 14);
+}
+} // namespace webrtc
+
+#endif // WEBRTC_AUDIO_CONVERSION_H_
diff --git a/webrtc/audio/scoped_voe_interface.h b/webrtc/audio/scoped_voe_interface.h
new file mode 100644
index 0000000..1029337
--- /dev/null
+++ b/webrtc/audio/scoped_voe_interface.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef WEBRTC_AUDIO_SCOPED_VOE_INTERFACE_H_
+#define WEBRTC_AUDIO_SCOPED_VOE_INTERFACE_H_
+
+#include "webrtc/base/checks.h"
+
+namespace webrtc {
+
+class VoiceEngine;
+
+namespace internal {
+
+// Utility template for obtaining and holding a reference to a VoiceEngine
+// interface and making sure it is released when this object goes out of scope.
+template<class T> class ScopedVoEInterface {
+ public:
+ explicit ScopedVoEInterface(webrtc::VoiceEngine* e)
+ : ptr_(T::GetInterface(e)) {
+ RTC_DCHECK(ptr_);
+ }
+ ~ScopedVoEInterface() {
+ if (ptr_) {
+ ptr_->Release();
+ }
+ }
+ T* operator->() {
+ RTC_DCHECK(ptr_);
+ return ptr_;
+ }
+ private:
+ T* ptr_;
+};
+} // namespace internal
+} // namespace webrtc
+
+#endif // WEBRTC_AUDIO_SCOPED_VOE_INTERFACE_H_
diff --git a/webrtc/audio/webrtc_audio.gypi b/webrtc/audio/webrtc_audio.gypi
index 40ccff6..b9d45db 100644
--- a/webrtc/audio/webrtc_audio.gypi
+++ b/webrtc/audio/webrtc_audio.gypi
@@ -18,6 +18,8 @@
'audio/audio_receive_stream.h',
'audio/audio_send_stream.cc',
'audio/audio_send_stream.h',
+ 'audio/conversion.h',
+ 'audio/scoped_voe_interface.h',
],
},
}
diff --git a/webrtc/audio_receive_stream.h b/webrtc/audio_receive_stream.h
index 70d6480..3e5a518 100644
--- a/webrtc/audio_receive_stream.h
+++ b/webrtc/audio_receive_stream.h
@@ -26,7 +26,32 @@
class AudioReceiveStream : public ReceiveStream {
public:
- struct Stats {};
+ struct Stats {
+ uint32_t remote_ssrc = 0;
+ int64_t bytes_rcvd = 0;
+ uint32_t packets_rcvd = 0;
+ uint32_t packets_lost = 0;
+ float fraction_lost = 0.0f;
+ std::string codec_name;
+ uint32_t ext_seqnum = 0;
+ uint32_t jitter_ms = 0;
+ uint32_t jitter_buffer_ms = 0;
+ uint32_t jitter_buffer_preferred_ms = 0;
+ uint32_t delay_estimate_ms = 0;
+ int32_t audio_level = -1;
+ float expand_rate = 0.0f;
+ float speech_expand_rate = 0.0f;
+ float secondary_decoded_rate = 0.0f;
+ float accelerate_rate = 0.0f;
+ float preemptive_expand_rate = 0.0f;
+ int32_t decoding_calls_to_silence_generator = 0;
+ int32_t decoding_calls_to_neteq = 0;
+ int32_t decoding_normal = 0;
+ int32_t decoding_plc = 0;
+ int32_t decoding_cng = 0;
+ int32_t decoding_plc_cng = 0;
+ int64_t capture_start_ntp_time_ms = 0;
+ };
struct Config {
std::string ToString() const;
diff --git a/webrtc/call/bitrate_estimator_tests.cc b/webrtc/call/bitrate_estimator_tests.cc
index f7044ae..08e36c8 100644
--- a/webrtc/call/bitrate_estimator_tests.cc
+++ b/webrtc/call/bitrate_estimator_tests.cc
@@ -25,6 +25,7 @@
#include "webrtc/test/encoder_settings.h"
#include "webrtc/test/fake_decoder.h"
#include "webrtc/test/fake_encoder.h"
+#include "webrtc/test/fake_voice_engine.h"
#include "webrtc/test/frame_generator_capturer.h"
namespace webrtc {
@@ -130,8 +131,10 @@
}
virtual void SetUp() {
- receiver_call_.reset(Call::Create(Call::Config()));
- sender_call_.reset(Call::Create(Call::Config()));
+ Call::Config config;
+ config.voice_engine = &fake_voice_engine_;
+ receiver_call_.reset(Call::Create(config));
+ sender_call_.reset(Call::Create(config));
send_transport_.SetReceiver(receiver_call_->Receiver());
receive_transport_.SetReceiver(sender_call_->Receiver());
@@ -265,6 +268,7 @@
test::FakeDecoder fake_decoder_;
};
+ test::FakeVoiceEngine fake_voice_engine_;
TraceObserver receiver_trace_;
test::DirectTransport send_transport_;
test::DirectTransport receive_transport_;
diff --git a/webrtc/call/call.cc b/webrtc/call/call.cc
index b142453..3969bc6 100644
--- a/webrtc/call/call.cc
+++ b/webrtc/call/call.cc
@@ -126,7 +126,8 @@
VideoSendStream::RtpStateMap suspended_video_send_ssrcs_;
- RtcEventLog* event_log_;
+ RtcEventLog* event_log_ = nullptr;
+ VoECodec* voe_codec_ = nullptr;
RTC_DISALLOW_COPY_AND_ASSIGN(Call);
};
@@ -147,8 +148,7 @@
config_(config),
network_enabled_(true),
receive_crit_(RWLockWrapper::CreateRWLock()),
- send_crit_(RWLockWrapper::CreateRWLock()),
- event_log_(nullptr) {
+ send_crit_(RWLockWrapper::CreateRWLock()) {
RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
RTC_DCHECK_GE(config.bitrate_config.min_bitrate_bps, 0);
RTC_DCHECK_GE(config.bitrate_config.start_bitrate_bps,
@@ -158,11 +158,11 @@
config.bitrate_config.start_bitrate_bps);
}
if (config.voice_engine) {
- VoECodec* voe_codec = VoECodec::GetInterface(config.voice_engine);
- if (voe_codec) {
- event_log_ = voe_codec->GetEventLog();
- voe_codec->Release();
- }
+ // Keep a reference to VoECodec, so we're sure the VoiceEngine lives for the
+ // duration of the call.
+ voe_codec_ = VoECodec::GetInterface(config.voice_engine);
+ if (voe_codec_)
+ event_log_ = voe_codec_->GetEventLog();
}
Trace::CreateTrace();
@@ -187,6 +187,9 @@
module_process_thread_->DeRegisterModule(call_stats_.get());
module_process_thread_->Stop();
Trace::ReturnTrace();
+
+ if (voe_codec_)
+ voe_codec_->Release();
}
PacketReceiver* Call::Receiver() {
@@ -237,7 +240,8 @@
TRACE_EVENT0("webrtc", "Call::CreateAudioReceiveStream");
RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
AudioReceiveStream* receive_stream = new AudioReceiveStream(
- congestion_controller_->GetRemoteBitrateEstimator(false), config);
+ congestion_controller_->GetRemoteBitrateEstimator(false), config,
+ config_.voice_engine);
{
WriteLockScoped write_lock(*receive_crit_);
RTC_DCHECK(audio_receive_ssrcs_.find(config.rtp.remote_ssrc) ==
diff --git a/webrtc/call/call_perf_tests.cc b/webrtc/call/call_perf_tests.cc
index a7714b1..cab3914 100644
--- a/webrtc/call/call_perf_tests.cc
+++ b/webrtc/call/call_perf_tests.cc
@@ -321,6 +321,8 @@
receiver_call_->DestroyAudioReceiveStream(audio_receive_stream);
+ DestroyCalls();
+
VoiceEngine::Delete(voice_engine);
}
diff --git a/webrtc/call/call_unittest.cc b/webrtc/call/call_unittest.cc
index 9adecc3..9819b53 100644
--- a/webrtc/call/call_unittest.cc
+++ b/webrtc/call/call_unittest.cc
@@ -13,19 +13,21 @@
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/call.h"
+#include "webrtc/test/fake_voice_engine.h"
namespace {
struct CallHelper {
- CallHelper() {
+ CallHelper() : voice_engine_(new webrtc::test::FakeVoiceEngine()) {
webrtc::Call::Config config;
- // TODO(solenberg): Fill in with VoiceEngine* etc.
+ config.voice_engine = voice_engine_.get();
call_.reset(webrtc::Call::Create(config));
}
webrtc::Call* operator->() { return call_.get(); }
private:
+ rtc::scoped_ptr<webrtc::test::FakeVoiceEngine> voice_engine_;
rtc::scoped_ptr<webrtc::Call> call_;
};
} // namespace
diff --git a/webrtc/test/call_test.cc b/webrtc/test/call_test.cc
index 0986df5..f2b5f91 100644
--- a/webrtc/test/call_test.cc
+++ b/webrtc/test/call_test.cc
@@ -89,6 +89,11 @@
receiver_call_.reset(Call::Create(config));
}
+void CallTest::DestroyCalls() {
+ sender_call_.reset(nullptr);
+ receiver_call_.reset(nullptr);
+}
+
void CallTest::CreateSendConfig(size_t num_streams,
Transport* send_transport) {
assert(num_streams <= kNumSsrcs);
diff --git a/webrtc/test/call_test.h b/webrtc/test/call_test.h
index 2b9dcee..4a645b4 100644
--- a/webrtc/test/call_test.h
+++ b/webrtc/test/call_test.h
@@ -52,6 +52,7 @@
const Call::Config& receiver_config);
void CreateSenderCall(const Call::Config& config);
void CreateReceiverCall(const Call::Config& config);
+ void DestroyCalls();
void CreateSendConfig(size_t num_streams, Transport* send_transport);
void CreateMatchingReceiveConfigs(Transport* rtcp_send_transport);
diff --git a/webrtc/test/fake_voice_engine.h b/webrtc/test/fake_voice_engine.h
new file mode 100644
index 0000000..72f6b27
--- /dev/null
+++ b/webrtc/test/fake_voice_engine.h
@@ -0,0 +1,421 @@
+/*
+ * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef WEBRTC_AUDIO_FAKE_VOICE_ENGINE_H_
+#define WEBRTC_AUDIO_FAKE_VOICE_ENGINE_H_
+
+#include <vector>
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+#include "webrtc/voice_engine/voice_engine_impl.h"
+
+namespace webrtc {
+namespace test {
+
+// NOTE: This class inherits from VoiceEngineImpl so that its clients will be
+// able to get the various interfaces as usual, via T::GetInterface().
+class FakeVoiceEngine final : public VoiceEngineImpl {
+ public:
+ const int kSendChannelId = 1;
+ const int kReceiveChannelId = 2;
+
+ const int kRecvJitterBufferDelay = -7;
+ const int kRecvPlayoutBufferDelay = 302;
+ const unsigned int kRecvSpeechOutputLevel = 99;
+
+ FakeVoiceEngine() : VoiceEngineImpl(new Config(), true) {
+ // Increase ref count so this object isn't automatically deleted whenever
+ // interfaces are Release():d.
+ ++_ref_count;
+ }
+ ~FakeVoiceEngine() override {
+ // Decrease ref count before base class d-tor is called; otherwise it will
+ // trigger an assertion.
+ --_ref_count;
+ }
+
+ const CallStatistics& GetRecvCallStats() const {
+ static const CallStatistics kStats = {
+ 345, 678, 901, 234, -1, 0, 0, 567, 890, 123
+ };
+ return kStats;
+ }
+
+ const CodecInst& GetRecvRecCodecInst() const {
+ static const CodecInst kStats = {
+ 123, "codec_name", 96000, -1, -1, -1
+ };
+ return kStats;
+ }
+
+ const NetworkStatistics& GetRecvNetworkStats() const {
+ static const NetworkStatistics kStats = {
+ 123, 456, false, 0, 0, 789, 12, 345, 678, 901, -1, -1, -1, -1, -1, 0
+ };
+ return kStats;
+ }
+
+ const AudioDecodingCallStats& GetRecvAudioDecodingCallStats() const {
+ static AudioDecodingCallStats stats;
+ if (stats.calls_to_silence_generator == 0) {
+ stats.calls_to_silence_generator = 234;
+ stats.calls_to_neteq = 567;
+ stats.decoded_normal = 890;
+ stats.decoded_plc = 123;
+ stats.decoded_cng = 456;
+ stats.decoded_plc_cng = 789;
+ }
+ return stats;
+ }
+
+ // VoEBase
+ int RegisterVoiceEngineObserver(VoiceEngineObserver& observer) override {
+ return -1;
+ }
+ int DeRegisterVoiceEngineObserver() override { return -1; }
+ int Init(AudioDeviceModule* external_adm = NULL,
+ AudioProcessing* audioproc = NULL) override { return -1; }
+ AudioProcessing* audio_processing() override { return nullptr; }
+ int Terminate() override { return -1; }
+ int CreateChannel() override { return -1; }
+ int CreateChannel(const Config& config) override { return -1; }
+ int DeleteChannel(int channel) override { return -1; }
+ int StartReceive(int channel) override { return -1; }
+ int StopReceive(int channel) override { return -1; }
+ int StartPlayout(int channel) override { return -1; }
+ int StopPlayout(int channel) override { return -1; }
+ int StartSend(int channel) override { return -1; }
+ int StopSend(int channel) override { return -1; }
+ int GetVersion(char version[1024]) override { return -1; }
+ int LastError() override { return -1; }
+ AudioTransport* audio_transport() { return nullptr; }
+ int AssociateSendChannel(int channel, int accociate_send_channel) override {
+ return -1;
+ }
+
+ // VoECodec
+ int NumOfCodecs() override { return -1; }
+ int GetCodec(int index, CodecInst& codec) override { return -1; }
+ int SetSendCodec(int channel, const CodecInst& codec) override { return -1; }
+ int GetSendCodec(int channel, CodecInst& codec) override { return -1; }
+ int SetBitRate(int channel, int bitrate_bps) override { return -1; }
+ int GetRecCodec(int channel, CodecInst& codec) override {
+ EXPECT_EQ(channel, kReceiveChannelId);
+ codec = GetRecvRecCodecInst();
+ return 0;
+ }
+ int SetRecPayloadType(int channel, const CodecInst& codec) override {
+ return -1;
+ }
+ int GetRecPayloadType(int channel, CodecInst& codec) override { return -1; }
+ int SetSendCNPayloadType(int channel, int type,
+ PayloadFrequencies frequency = kFreq16000Hz) override { return -1; }
+ int SetVADStatus(int channel,
+ bool enable,
+ VadModes mode = kVadConventional,
+ bool disableDTX = false) override { return -1; }
+ int GetVADStatus(int channel,
+ bool& enabled,
+ VadModes& mode,
+ bool& disabledDTX) override { return -1; }
+ int SetOpusMaxPlaybackRate(int channel, int frequency_hz) override {
+ return -1;
+ }
+ int SetOpusDtx(int channel, bool enable_dtx) override { return -1; }
+ RtcEventLog* GetEventLog() override { return nullptr; }
+
+ // VoEDtmf
+ int SendTelephoneEvent(int channel,
+ int eventCode,
+ bool outOfBand = true,
+ int lengthMs = 160,
+ int attenuationDb = 10) override { return -1; }
+ int SetSendTelephoneEventPayloadType(int channel,
+ unsigned char type) override {
+ return -1;
+ }
+ int GetSendTelephoneEventPayloadType(int channel,
+ unsigned char& type) override {
+ return -1;
+ }
+ int SetDtmfFeedbackStatus(bool enable,
+ bool directFeedback = false) override { return -1; }
+ int GetDtmfFeedbackStatus(bool& enabled, bool& directFeedback) override {
+ return -1;
+ }
+ int PlayDtmfTone(int eventCode,
+ int lengthMs = 200,
+ int attenuationDb = 10) override { return -1; }
+
+ // VoEExternalMedia
+ int RegisterExternalMediaProcessing(
+ int channel,
+ ProcessingTypes type,
+ VoEMediaProcess& processObject) override { return -1; }
+ int DeRegisterExternalMediaProcessing(int channel,
+ ProcessingTypes type) override {
+ return -1;
+ }
+ int GetAudioFrame(int channel,
+ int desired_sample_rate_hz,
+ AudioFrame* frame) override { return -1; }
+ int SetExternalMixing(int channel, bool enable) override { return -1; }
+
+ // VoEFile
+ int StartPlayingFileLocally(
+ int channel,
+ const char fileNameUTF8[1024],
+ bool loop = false,
+ FileFormats format = kFileFormatPcm16kHzFile,
+ float volumeScaling = 1.0,
+ int startPointMs = 0,
+ int stopPointMs = 0) override { return -1; }
+ int StartPlayingFileLocally(
+ int channel,
+ InStream* stream,
+ FileFormats format = kFileFormatPcm16kHzFile,
+ float volumeScaling = 1.0,
+ int startPointMs = 0,
+ int stopPointMs = 0) override { return -1; }
+ int StopPlayingFileLocally(int channel) override { return -1; }
+ int IsPlayingFileLocally(int channel) override { return -1; }
+ int StartPlayingFileAsMicrophone(
+ int channel,
+ const char fileNameUTF8[1024],
+ bool loop = false,
+ bool mixWithMicrophone = false,
+ FileFormats format = kFileFormatPcm16kHzFile,
+ float volumeScaling = 1.0) override { return -1; }
+ int StartPlayingFileAsMicrophone(
+ int channel,
+ InStream* stream,
+ bool mixWithMicrophone = false,
+ FileFormats format = kFileFormatPcm16kHzFile,
+ float volumeScaling = 1.0) override { return -1; }
+ int StopPlayingFileAsMicrophone(int channel) override { return -1; }
+ int IsPlayingFileAsMicrophone(int channel) override { return -1; }
+ int StartRecordingPlayout(int channel,
+ const char* fileNameUTF8,
+ CodecInst* compression = NULL,
+ int maxSizeBytes = -1) override { return -1; }
+ int StopRecordingPlayout(int channel) override { return -1; }
+ int StartRecordingPlayout(int channel,
+ OutStream* stream,
+ CodecInst* compression = NULL) override {
+ return -1;
+ }
+ int StartRecordingMicrophone(const char* fileNameUTF8,
+ CodecInst* compression = NULL,
+ int maxSizeBytes = -1) override { return -1; }
+ int StartRecordingMicrophone(OutStream* stream,
+ CodecInst* compression = NULL) override {
+ return -1;
+ }
+ int StopRecordingMicrophone() override { return -1; }
+
+ // VoEHardware
+ int GetNumOfRecordingDevices(int& devices) override { return -1; }
+
+ // Gets the number of audio devices available for playout.
+ int GetNumOfPlayoutDevices(int& devices) override { return -1; }
+
+ // Gets the name of a specific recording device given by an |index|.
+ // On Windows Vista/7, it also retrieves an additional unique ID
+ // (GUID) for the recording device.
+ int GetRecordingDeviceName(int index,
+ char strNameUTF8[128],
+ char strGuidUTF8[128]) override { return -1; }
+
+ // Gets the name of a specific playout device given by an |index|.
+ // On Windows Vista/7, it also retrieves an additional unique ID
+ // (GUID) for the playout device.
+ int GetPlayoutDeviceName(int index,
+ char strNameUTF8[128],
+ char strGuidUTF8[128]) override { return -1; }
+
+ // Sets the audio device used for recording.
+ int SetRecordingDevice(
+ int index,
+ StereoChannel recordingChannel = kStereoBoth) override { return -1; }
+
+ // Sets the audio device used for playout.
+ int SetPlayoutDevice(int index) override { return -1; }
+
+ // Sets the type of audio device layer to use.
+ int SetAudioDeviceLayer(AudioLayers audioLayer) override { return -1; }
+
+ // Gets the currently used (active) audio device layer.
+ int GetAudioDeviceLayer(AudioLayers& audioLayer) override { return -1; }
+
+ // Native sample rate controls (samples/sec)
+ int SetRecordingSampleRate(unsigned int samples_per_sec) override {
+ return -1;
+ }
+ int RecordingSampleRate(unsigned int* samples_per_sec) const override {
+ return -1;
+ }
+ int SetPlayoutSampleRate(unsigned int samples_per_sec) override {
+ return -1;
+ }
+ int PlayoutSampleRate(unsigned int* samples_per_sec) const override {
+ return -1;
+ }
+
+ // Queries and controls platform audio effects on Android devices.
+ bool BuiltInAECIsAvailable() const override { return false; }
+ int EnableBuiltInAEC(bool enable) override { return -1; }
+ bool BuiltInAGCIsAvailable() const override { return false; }
+ int EnableBuiltInAGC(bool enable) override { return -1; }
+ bool BuiltInNSIsAvailable() const override { return false; }
+ int EnableBuiltInNS(bool enable) override { return -1; }
+
+ // VoENetwork
+ int RegisterExternalTransport(int channel, Transport& transport) override {
+ return -1;
+ }
+ int DeRegisterExternalTransport(int channel) override { return -1; }
+ int ReceivedRTPPacket(int channel,
+ const void* data,
+ size_t length) override { return -1; }
+ int ReceivedRTPPacket(int channel,
+ const void* data,
+ size_t length,
+ const PacketTime& packet_time) override { return -1; }
+ int ReceivedRTCPPacket(int channel,
+ const void* data,
+ size_t length) { return -1; }
+
+ // VoENetEqStats
+ int GetNetworkStatistics(int channel, NetworkStatistics& stats) override {
+ EXPECT_EQ(channel, kReceiveChannelId);
+ stats = GetRecvNetworkStats();
+ return 0;
+ }
+ int GetDecodingCallStatistics(int channel,
+ AudioDecodingCallStats* stats) const override {
+ EXPECT_EQ(channel, kReceiveChannelId);
+ EXPECT_NE(nullptr, stats);
+ *stats = GetRecvAudioDecodingCallStats();
+ return 0;
+ }
+
+ // VoERTP_RTCP
+ int SetLocalSSRC(int channel, unsigned int ssrc) override { return -1; }
+ int GetLocalSSRC(int channel, unsigned int& ssrc) override { return -1; }
+ int GetRemoteSSRC(int channel, unsigned int& ssrc) override {
+ EXPECT_EQ(channel, kReceiveChannelId);
+ ssrc = 0;
+ return 0;
+ }
+ int SetSendAudioLevelIndicationStatus(int channel,
+ bool enable,
+ unsigned char id = 1) override {
+ return -1;
+ }
+ int SetSendAbsoluteSenderTimeStatus(int channel,
+ bool enable,
+ unsigned char id) override { return -1; }
+ int SetReceiveAbsoluteSenderTimeStatus(int channel,
+ bool enable,
+ unsigned char id) override {
+ return -1;
+ }
+ int SetRTCPStatus(int channel, bool enable) override { return -1; }
+ int GetRTCPStatus(int channel, bool& enabled) override { return -1; }
+ int SetRTCP_CNAME(int channel, const char cName[256]) override { return -1; }
+ int GetRTCP_CNAME(int channel, char cName[256]) { return -1; }
+ int GetRemoteRTCP_CNAME(int channel, char cName[256]) override { return -1; }
+ int GetRemoteRTCPData(int channel,
+ unsigned int& NTPHigh,
+ unsigned int& NTPLow,
+ unsigned int& timestamp,
+ unsigned int& playoutTimestamp,
+ unsigned int* jitter = NULL,
+ unsigned short* fractionLost = NULL) override {
+ return -1;
+ }
+ int GetRTPStatistics(int channel,
+ unsigned int& averageJitterMs,
+ unsigned int& maxJitterMs,
+ unsigned int& discardedPackets) override { return -1; }
+ int GetRTCPStatistics(int channel, CallStatistics& stats) override {
+ EXPECT_EQ(channel, kReceiveChannelId);
+ stats = GetRecvCallStats();
+ return 0;
+ }
+ int GetRemoteRTCPReportBlocks(
+ int channel,
+ std::vector<ReportBlock>* receive_blocks) override { return -1; }
+ int SetNACKStatus(int channel, bool enable, int maxNoPackets) override {
+ return -1;
+ }
+
+ // VoEVideoSync
+ int GetPlayoutBufferSize(int& buffer_ms) override { return -1; }
+ int SetMinimumPlayoutDelay(int channel, int delay_ms) override { return -1; }
+ int SetInitialPlayoutDelay(int channel, int delay_ms) override { return -1; }
+ int GetDelayEstimate(int channel,
+ int* jitter_buffer_delay_ms,
+ int* playout_buffer_delay_ms) override {
+ EXPECT_EQ(channel, kReceiveChannelId);
+ *jitter_buffer_delay_ms = kRecvJitterBufferDelay;
+ *playout_buffer_delay_ms = kRecvPlayoutBufferDelay;
+ return 0;
+ }
+ int GetLeastRequiredDelayMs(int channel) const override { return -1; }
+ int SetInitTimestamp(int channel, unsigned int timestamp) override {
+ return -1;
+ }
+ int SetInitSequenceNumber(int channel, short sequenceNumber) override {
+ return -1;
+ }
+ int GetPlayoutTimestamp(int channel, unsigned int& timestamp) override {
+ return -1;
+ }
+ int GetRtpRtcp(int channel,
+ RtpRtcp** rtpRtcpModule,
+ RtpReceiver** rtp_receiver) override { return -1; }
+
+ // VoEVolumeControl
+ int SetSpeakerVolume(unsigned int volume) override { return -1; }
+ int GetSpeakerVolume(unsigned int& volume) override { return -1; }
+ int SetMicVolume(unsigned int volume) override { return -1; }
+ int GetMicVolume(unsigned int& volume) override { return -1; }
+ int SetInputMute(int channel, bool enable) override { return -1; }
+ int GetInputMute(int channel, bool& enabled) override { return -1; }
+ int GetSpeechInputLevel(unsigned int& level) override { return -1; }
+ int GetSpeechOutputLevel(int channel, unsigned int& level) override {
+ return -1;
+ }
+ int GetSpeechInputLevelFullRange(unsigned int& level) override { return -1; }
+ int GetSpeechOutputLevelFullRange(int channel,
+ unsigned int& level) override {
+ EXPECT_EQ(channel, kReceiveChannelId);
+ level = kRecvSpeechOutputLevel;
+ return 0;
+ }
+ int SetChannelOutputVolumeScaling(int channel, float scaling) override {
+ return -1;
+ }
+ int GetChannelOutputVolumeScaling(int channel, float& scaling) override {
+ return -1;
+ }
+ int SetOutputVolumePan(int channel, float left, float right) override {
+ return -1;
+ }
+ int GetOutputVolumePan(int channel, float& left, float& right) override {
+ return -1;
+ }
+};
+} // namespace test
+} // namespace webrtc
+
+#endif // WEBRTC_AUDIO_FAKE_VOICE_ENGINE_H_
diff --git a/webrtc/test/webrtc_test_common.gyp b/webrtc/test/webrtc_test_common.gyp
index f8d3365..5076900 100644
--- a/webrtc/test/webrtc_test_common.gyp
+++ b/webrtc/test/webrtc_test_common.gyp
@@ -30,6 +30,7 @@
'fake_encoder.h',
'fake_network_pipe.cc',
'fake_network_pipe.h',
+ 'fake_voice_engine.h',
'frame_generator_capturer.cc',
'frame_generator_capturer.h',
'layer_filtering_transport.cc',
diff --git a/webrtc/voice_engine/voice_engine_impl.h b/webrtc/voice_engine/voice_engine_impl.h
index 07f29c3..2103994 100644
--- a/webrtc/voice_engine/voice_engine_impl.h
+++ b/webrtc/voice_engine/voice_engine_impl.h
@@ -128,8 +128,11 @@
// This implements the Release() method for all the inherited interfaces.
int Release() override;
- private:
+ // This is *protected* so that FakeVoiceEngine can inherit from the class and
+ // manipulate the reference count. See: fake_voice_engine.h.
+ protected:
Atomic32 _ref_count;
+ private:
rtc::scoped_ptr<const Config> own_config_;
};