Low-bandwidth audio testing

webrtc/test/call_test.cc

 /*
  *  Copyright (c) 2014 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.
  */
 
@@ skipping 32 matching lines @@
 CallTest::~CallTest() {
 }
 
 void CallTest::RunBaseTest(BaseTest* test) {
   num_video_streams_ = test->GetNumVideoStreams();
   num_audio_streams_ = test->GetNumAudioStreams();
   num_flexfec_streams_ = test->GetNumFlexfecStreams();
   RTC_DCHECK(num_video_streams_ > 0 || num_audio_streams_ > 0);
   Call::Config send_config(test->GetSenderCallConfig());
   if (num_audio_streams_ > 0) {
+    CreateFakeAudioDevices(test->CreateCapturer(), test->CreateRenderer());
+    test->OnFakeAudioDevicesCreated(fake_send_audio_device_.get(),
+                                    fake_recv_audio_device_.get());
     CreateVoiceEngines();
     AudioState::Config audio_state_config;
     audio_state_config.voice_engine = voe_send_.voice_engine;
     audio_state_config.audio_mixer = AudioMixerImpl::Create();
     send_config.audio_state = AudioState::Create(audio_state_config);
   }
   CreateSenderCall(send_config);
   if (test->ShouldCreateReceivers()) {
     Call::Config recv_config(test->GetReceiverCallConfig());
     if (num_audio_streams_ > 0) {
@@ skipping 62 matching lines @@
   Start();
   test->PerformTest();
   send_transport_->StopSending();
   receive_transport_->StopSending();
   Stop();
 
   DestroyStreams();
   DestroyCalls();
   if (num_audio_streams_ > 0)
     DestroyVoiceEngines();
+
+  test->OnTestFinished();
 }
 
 void CallTest::Start() {
   if (video_send_stream_)
     video_send_stream_->Start();
   for (VideoReceiveStream* video_recv_stream : video_receive_streams_)
     video_recv_stream->Start();
   if (audio_send_stream_) {
     audio_send_stream_->Start();
   }
@@ skipping 146 matching lines @@
 void CallTest::CreateFrameGeneratorCapturer(int framerate,
                                             int width,
                                             int height) {
   frame_generator_capturer_.reset(
       test::FrameGeneratorCapturer::Create(width, height, framerate, clock_));
   video_send_stream_->SetSource(
       frame_generator_capturer_.get(),
       VideoSendStream::DegradationPreference::kBalanced);
 }
 
-void CallTest::CreateFakeAudioDevices() {
+void CallTest::CreateFakeAudioDevices(
+    std::unique_ptr<FakeAudioDevice::Capturer> capturer,
+    std::unique_ptr<FakeAudioDevice::Renderer> renderer) {
   fake_send_audio_device_.reset(new FakeAudioDevice(
-      FakeAudioDevice::CreatePulsedNoiseCapturer(256, 48000), nullptr, 1.f));
+      std::move(capturer), nullptr, 1.f));
   fake_recv_audio_device_.reset(new FakeAudioDevice(
-      nullptr, FakeAudioDevice::CreateDiscardRenderer(48000), 1.f));
+      nullptr, std::move(renderer), 1.f));
 }
 
 void CallTest::CreateVideoStreams() {
   RTC_DCHECK(video_send_stream_ == nullptr);
   RTC_DCHECK(video_receive_streams_.empty());
   RTC_DCHECK(audio_send_stream_ == nullptr);
   RTC_DCHECK(audio_receive_streams_.empty());
 
   video_send_stream_ = sender_call_->CreateVideoSendStream(
       video_send_config_.Copy(), video_encoder_config_.Copy());
@@ skipping 38 matching lines @@
     receiver_call_->DestroyVideoReceiveStream(video_recv_stream);
 
   for (FlexfecReceiveStream* flexfec_recv_stream : flexfec_receive_streams_)
     receiver_call_->DestroyFlexfecReceiveStream(flexfec_recv_stream);
 
   video_receive_streams_.clear();
   allocated_decoders_.clear();
 }
 
 void CallTest::CreateVoiceEngines() {
-  CreateFakeAudioDevices();

[kjellander_webrtc, 2017/03/17 07:11:41]

Won't this affect other tests using this code?

[oprypin_webrtc, 2017/03/20 10:39:27]

I only moved this call outside of CreateVoiceEngines in the only place where
it's called. Since it's private, other code can't be affected.

   voe_send_.voice_engine = VoiceEngine::Create();
   voe_send_.base = VoEBase::GetInterface(voe_send_.voice_engine);
   EXPECT_EQ(0, voe_send_.base->Init(fake_send_audio_device_.get(), nullptr,
                                     decoder_factory_));
   VoEBase::ChannelConfig config;
   config.enable_voice_pacing = true;
   voe_send_.channel_id = voe_send_.base->CreateChannel(config);
   EXPECT_GE(voe_send_.channel_id, 0);
 
   voe_recv_.voice_engine = VoiceEngine::Create();
@@ skipping 43 matching lines @@
 const uint32_t CallTest::kReceiverLocalVideoSsrc = 0x123456;
 const uint32_t CallTest::kReceiverLocalAudioSsrc = 0x1234567;
 const int CallTest::kNackRtpHistoryMs = 1000;
 
 BaseTest::BaseTest(unsigned int timeout_ms) : RtpRtcpObserver(timeout_ms) {
 }
 
 BaseTest::~BaseTest() {
 }
 
+std::unique_ptr<FakeAudioDevice::Capturer> BaseTest::CreateCapturer() {
+  return FakeAudioDevice::CreatePulsedNoiseCapturer(256, 48000);
+}
+
+std::unique_ptr<FakeAudioDevice::Renderer> BaseTest::CreateRenderer() {
+  return FakeAudioDevice::CreateDiscardRenderer(48000);
+}
+
+void BaseTest::OnFakeAudioDevicesCreated(FakeAudioDevice* send_audio_device,
+                                         FakeAudioDevice* recv_audio_device) {
+}
+
 Call::Config BaseTest::GetSenderCallConfig() {
   return Call::Config(&event_log_);
 }
 
 Call::Config BaseTest::GetReceiverCallConfig() {
   return Call::Config(&event_log_);
 }
 
 void BaseTest::OnCallsCreated(Call* sender_call, Call* receiver_call) {
 }
@@ skipping 44 matching lines @@
 void BaseTest::ModifyFlexfecConfigs(
     std::vector<FlexfecReceiveStream::Config>* receive_configs) {}
 
 void BaseTest::OnFlexfecStreamsCreated(
     const std::vector<FlexfecReceiveStream*>& receive_streams) {}
 
 void BaseTest::OnFrameGeneratorCapturerCreated(
     FrameGeneratorCapturer* frame_generator_capturer) {
 }
 
+void BaseTest::OnTestFinished() {
+}
+
 SendTest::SendTest(unsigned int timeout_ms) : BaseTest(timeout_ms) {
 }
 
 bool SendTest::ShouldCreateReceivers() const {
   return false;
 }
 
 EndToEndTest::EndToEndTest(unsigned int timeout_ms) : BaseTest(timeout_ms) {
 }
 
 bool EndToEndTest::ShouldCreateReceivers() const {
   return true;
 }
 
 }  // namespace test
 }  // namespace webrtc