Low-bandwidth audio testing

webrtc/audio/test/low_bandwidth_audio_test.cc

 /*
- *  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
  *  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.
  */
 
-// This is a placeholder for the work oprypin@ is doing on a low-bandwidth
-// audio test executable.
-
-int main() {
+#include <algorithm>
+
+#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 {
+
+// Writes to a WAV file, cutting off silence at the beginning and the end.

[kwiberg-webrtc, 2017/03/17 11:19:32]

For silence in the beginning, you the amplitude only needs to be <=
kAmplitudeThreshold; for silence at the end, the amplitude is required to be
zero. If this is intentional, you should probably document it here.

[oprypin_webrtc, 2017/03/17 11:45:10]

It is intentional but it's just based on the strange effect that I noticed. The
recording side gets strictly zeros when the audio hasn't come through yet, then
around 20 samples smaller than 4, then strictly zeros again for a small while,
and then the actual audio starts. And no, it does NOT seem to be related to
silence in the audio file itself. I'd be interested to find out why this
happens.

+class BoundedWavFileWriter : public test::FakeAudioDevice::Renderer {
+ public:
+  BoundedWavFileWriter(std::string filename, int sampling_frequency_in_hz)
+      : sampling_frequency_in_hz_(sampling_frequency_in_hz),
+        wav_writer_(filename, sampling_frequency_in_hz, 1),
+        silent_audio_(test::FakeAudioDevice::SamplesPerFrame(
+            sampling_frequency_in_hz), 0),
+        started_writing_(false),
+        trailing_zeros_(0) {}
+
+  int SamplingFrequency() const override {
+    return sampling_frequency_in_hz_;
+  }
+
+  bool Render(rtc::ArrayView<const int16_t> data) override {
+    const int16_t kAmplitudeThreshold = 5;
+
+    const int16_t* begin = data.begin();
+    const int16_t* end = data.end();
+    if (!started_writing_) {
+      // Cut off silence at the beginning.
+      while (begin < end) {
+        if (*begin > kAmplitudeThreshold || *begin < -kAmplitudeThreshold) {

[kwiberg-webrtc, 2017/03/17 11:19:32]

std::abs(*begin) > kAmplitudeThreshold

?

[oprypin_webrtc, 2017/03/17 11:45:10]

Done.

+          started_writing_ = true;
+          break;
+        }
+        ++begin;
+      }
+    }
+    if (started_writing_) {
+      // Cut off silence at the end.
+      while (begin < end) {
+        if (*(end - 1) != 0) {
+          break;
+        }
+        --end;
+        ++trailing_zeros_;
+      }
+      if (begin < end) {
+        // If it turns out that the silence was not final, need to write all the
+        // skipped zeros and continue writing audio.
+        while (trailing_zeros_ > 0) {
+          const size_t zeros_to_write = std::min(trailing_zeros_,
+                                                 silent_audio_.size());
+          wav_writer_.WriteSamples(silent_audio_.data(), zeros_to_write);
+          trailing_zeros_ -= zeros_to_write;
+        }
+        wav_writer_.WriteSamples(begin, end - begin);
+      }
+    }
+    return true;
+  }
+
+ private:
+  int sampling_frequency_in_hz_;
+  WavWriter wav_writer_;
+  std::vector<int16_t> silent_audio_;
+  bool started_writing_;
+  size_t trailing_zeros_;
+};
+
+
+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 std::unique_ptr<test::FakeAudioDevice::Renderer>(
+      new BoundedWavFileWriter(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);
+}
+
+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 = test::CallTest;

[kwiberg-webrtc, 2017/03/17 11:19:33]

You don't need the test:: prefix, since you're in that namespace.

[oprypin_webrtc, 2017/03/17 11:45:10]

Done.

+
+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