Low-bandwidth audio testing

webrtc/audio/test/low_bandwidth_audio_test.cc

Index: webrtc/audio/test/low_bandwidth_audio_test.cc
diff --git a/webrtc/audio/test/low_bandwidth_audio_test.cc b/webrtc/audio/test/low_bandwidth_audio_test.cc
index c78e8897a824008e6336d676b7a3e5040c1ff5b5..c0bb703a08117b98b3f1101a069086a400acfd2f 100644
--- a/webrtc/audio/test/low_bandwidth_audio_test.cc
+++ b/webrtc/audio/test/low_bandwidth_audio_test.cc
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2017 The WebRTC Project Authors. All rights reserved.
+ *  Copyright (c) 2017 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
@@ -8,9 +8,144 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-// This is a placeholder for the work oprypin@ is doing on a low-bandwidth
-// audio test executable.
+#include <algorithm>
 
-int main() {
+#include "webrtc/audio/test/low_bandwidth_audio_test.h"
+#include "webrtc/common_audio/wav_file.h"
+#include "webrtc/test/gtest.h"
+#include "webrtc/test/run_test.h"
+#include "webrtc/system_wrappers/include/sleep.h"
+#include "webrtc/test/testsupport/fileutils.h"
+
+namespace {
+// Wait half a second between stopping sending and stopping receiving audio.
+constexpr int kExtraRecordTimeMs = 500;
+
+// Large bitrate by default.
+const webrtc::CodecInst kDefaultCodec{120, "OPUS", 48000, 960, 2, 64000};
+
+// The best that can be done with PESQ.
+constexpr int kAudioFileBitRate = 16000;
+}
+
+namespace webrtc {
+namespace test {
+
+AudioQualityTest::AudioQualityTest()
+    : EndToEndTest(CallTest::kDefaultTimeoutMs) {}
+
+size_t AudioQualityTest::GetNumVideoStreams() const {
   return 0;
 }
+size_t AudioQualityTest::GetNumAudioStreams() const {
+  return 1;
+}
+size_t AudioQualityTest::GetNumFlexfecStreams() const {
+  return 0;
+}
+
+std::string AudioQualityTest::AudioInputFile() {
+  return test::ResourcePath("voice_engine/audio_tiny16", "wav");
+}
+
+std::string AudioQualityTest::AudioOutputFile() {
+  const ::testing::TestInfo* const test_info =
+      ::testing::UnitTest::GetInstance()->current_test_info();
+  return webrtc::test::OutputPath() +
+      "LowBandwidth_" + test_info->name() + ".wav";
+}
+
+std::unique_ptr<test::FakeAudioDevice::Capturer>
+    AudioQualityTest::CreateCapturer() {
+  return test::FakeAudioDevice::CreateWavFileReader(AudioInputFile());
+}
+
+std::unique_ptr<test::FakeAudioDevice::Renderer>
+    AudioQualityTest::CreateRenderer() {
+  return test::FakeAudioDevice::CreateBoundedWavFileWriter(
+      AudioOutputFile(), kAudioFileBitRate);
+}
+
+void AudioQualityTest::OnFakeAudioDevicesCreated(
+    test::FakeAudioDevice* send_audio_device,
+    test::FakeAudioDevice* recv_audio_device) {
+  send_audio_device_ = send_audio_device;
+}
+
+FakeNetworkPipe::Config AudioQualityTest::GetNetworkPipeConfig() {
+  return FakeNetworkPipe::Config();
+}
+
+test::PacketTransport* AudioQualityTest::CreateSendTransport(
+    Call* sender_call) {
+  return new test::PacketTransport(
+      sender_call, this, test::PacketTransport::kSender,
+      GetNetworkPipeConfig());
+}
+
+test::PacketTransport* AudioQualityTest::CreateReceiveTransport() {
+  return new test::PacketTransport(nullptr, this,
+      test::PacketTransport::kReceiver, GetNetworkPipeConfig());
+}
+
+void AudioQualityTest::ModifyAudioConfigs(
+  AudioSendStream::Config* send_config,
+  std::vector<AudioReceiveStream::Config>* receive_configs) {
+  send_config->send_codec_spec.codec_inst = kDefaultCodec;
+}
+
+void AudioQualityTest::PerformTest() {
+  // Wait until the input audio file is done...
+  send_audio_device_->WaitForRecordingEnd();
+  // and some extra time to account for network delay.
+  SleepMs(GetNetworkPipeConfig().queue_delay_ms + kExtraRecordTimeMs);

[stefan-webrtc, 2017/03/20 14:40:10]

Can we perhaps wait until enough audio has been played out on the receiver
instead?

[oprypin_webrtc, 2017/03/20 15:09:16]

I've given this some thought. Relying on the receive side is always a dangerous
game, because what if the network is so congested that the test takes hours? (Of
course, in practice that won't happen because this is a "perfect" network amd
because the test can time out). Or maybe audio gets broken and never sent, or
too much of it is sent, or something else.

And if the audio takes that long to arrive, it should badly affect the resulting
score anyway, which currently automatically happens by cutting off the receiving
side.

All in all, I think this is not only the simpler option, but actually the better
option.

[stefan-webrtc, 2017/03/20 15:42:32]

Ok, convinced!

+}
+
+void AudioQualityTest::OnTestFinished() {
+  const ::testing::TestInfo* const test_info =
+    ::testing::UnitTest::GetInstance()->current_test_info();
+
+  // Output information about the input and output audio files so that further
+  // processing can be done by an external process.
+  printf("TEST %s %s:%s\n", test_info->name(),
+         AudioInputFile().c_str(), AudioOutputFile().c_str());
+}
+
+
+using LowBandwidthAudioTest = CallTest;
+
+TEST_F(LowBandwidthAudioTest, GoodNetworkHighBitrate) {
+  AudioQualityTest test;
+  RunBaseTest(&test);
+}
+
+
+class Mobile2GNetworkTest : public AudioQualityTest {
+  void ModifyAudioConfigs(AudioSendStream::Config* send_config,
+      std::vector<AudioReceiveStream::Config>* receive_configs) override {
+    send_config->send_codec_spec.codec_inst = CodecInst{
+        120,     // pltype
+        "OPUS",  // plname
+        48000,   // plfreq
+        2880,    // pacsize
+        1,       // channels
+        6000     // rate bits/sec
+    };
+  }
+
+  FakeNetworkPipe::Config GetNetworkPipeConfig() override {
+    FakeNetworkPipe::Config pipe_config;
+    pipe_config.link_capacity_kbps = 12;
+    pipe_config.queue_length_packets = 1500;
+    pipe_config.queue_delay_ms = 400;
+    return pipe_config;
+  }
+};
+
+TEST_F(LowBandwidthAudioTest, Mobile2GNetwork) {
+  Mobile2GNetworkTest test;
+  RunBaseTest(&test);
+}
+
+}  // namespace test
+}  // namespace webrtc