Adding audio only mode to video loopback test.

webrtc/video/video_quality_test.cc

 /*
  *  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.
  */
 #include "webrtc/video/video_quality_test.h"
@@ skipping 977 matching lines @@
     RTC_CHECK_GT(v[2], 0);
 
     SpatialLayer layer;
     layer.scaling_factor_num = v[0] == -1 ? 1 : v[0];
     layer.scaling_factor_den = v[1] == -1 ? 1 : v[1];
     layer.target_bitrate_bps = v[2];
     params->ss.spatial_layers.push_back(layer);
   }
 }
 
-void VideoQualityTest::SetupCommon(Transport* send_transport,
-                                   Transport* recv_transport) {
+void VideoQualityTest::SetupVideo(Transport* send_transport,
+                                  Transport* recv_transport) {
   if (params_.logs)
     trace_to_stderr_.reset(new test::TraceToStderr);
 
   size_t num_streams = params_.ss.streams.size();
   CreateSendConfig(num_streams, 0, send_transport);
 
   int payload_type;
   if (params_.video.codec == "H264") {
-    encoder_.reset(VideoEncoder::Create(VideoEncoder::kH264));
+    video_encoder_.reset(VideoEncoder::Create(VideoEncoder::kH264));
     payload_type = kPayloadTypeH264;
   } else if (params_.video.codec == "VP8") {
-    encoder_.reset(VideoEncoder::Create(VideoEncoder::kVp8));
+    video_encoder_.reset(VideoEncoder::Create(VideoEncoder::kVp8));
     payload_type = kPayloadTypeVP8;
   } else if (params_.video.codec == "VP9") {
-    encoder_.reset(VideoEncoder::Create(VideoEncoder::kVp9));
+    video_encoder_.reset(VideoEncoder::Create(VideoEncoder::kVp9));
     payload_type = kPayloadTypeVP9;
   } else {
     RTC_NOTREACHED() << "Codec not supported!";
     return;
   }
-  video_send_config_.encoder_settings.encoder = encoder_.get();
+  video_send_config_.encoder_settings.encoder = video_encoder_.get();
   video_send_config_.encoder_settings.payload_name = params_.video.codec;
   video_send_config_.encoder_settings.payload_type = payload_type;
   video_send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
   video_send_config_.rtp.rtx.payload_type = kSendRtxPayloadType;
   for (size_t i = 0; i < num_streams; ++i)
     video_send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]);
 
   video_send_config_.rtp.extensions.clear();
   if (params_.call.send_side_bwe) {
     video_send_config_.rtp.extensions.push_back(
@@ skipping 85 matching lines @@
             kPauseDurationMs));
   }
 }
 
 void VideoQualityTest::CreateCapturer() {
   if (params_.screenshare.enabled) {
     test::FrameGeneratorCapturer* frame_generator_capturer =
         new test::FrameGeneratorCapturer(clock_, frame_generator_.release(),
                                          params_.video.fps);
     EXPECT_TRUE(frame_generator_capturer->Init());
-    capturer_.reset(frame_generator_capturer);
+    video_capturer_.reset(frame_generator_capturer);
   } else {
     if (params_.video.clip_name.empty()) {
-      capturer_.reset(test::VcmCapturer::Create(
+      video_capturer_.reset(test::VcmCapturer::Create(
           params_.video.width, params_.video.height, params_.video.fps));
     } else {
-      capturer_.reset(test::FrameGeneratorCapturer::CreateFromYuvFile(
+      video_capturer_.reset(test::FrameGeneratorCapturer::CreateFromYuvFile(
           test::ResourcePath(params_.video.clip_name, "yuv"),
           params_.video.width, params_.video.height, params_.video.fps,
           clock_));
-      ASSERT_TRUE(capturer_) << "Could not create capturer for "
-                             << params_.video.clip_name
-                             << ".yuv. Is this resource file present?";
+      ASSERT_TRUE(video_capturer_) << "Could not create capturer for "
+                                   << params_.video.clip_name
+                                   << ".yuv. Is this resource file present?";
     }
   }
 }
 
 void VideoQualityTest::RunWithAnalyzer(const Params& params) {
   params_ = params;
 
   RTC_CHECK(!params_.audio.enabled);
   // TODO(ivica): Merge with RunWithRenderer and use a flag / argument to
   // differentiate between the analyzer and the renderer case.
@@ skipping 48 matching lines @@
       disable_quality_check ? -1.1 : params_.analyzer.avg_psnr_threshold,
       disable_quality_check ? -1.1 : params_.analyzer.avg_ssim_threshold,
       params_.analyzer.test_durations_secs * params_.video.fps,
       graph_data_output_file, graph_title,
       kVideoSendSsrcs[params_.ss.selected_stream]);
 
   analyzer.SetReceiver(receiver_call_->Receiver());
   send_transport.SetReceiver(&analyzer);
   recv_transport.SetReceiver(sender_call_->Receiver());
 
-  SetupCommon(&analyzer, &recv_transport);
+  SetupVideo(&analyzer, &recv_transport);
   video_receive_configs_[params_.ss.selected_stream].renderer = &analyzer;
   video_send_config_.pre_encode_callback = analyzer.pre_encode_proxy();
   for (auto& config : video_receive_configs_)
     config.pre_decode_callback = &analyzer;
   RTC_DCHECK(!video_send_config_.post_encode_callback);
   video_send_config_.post_encode_callback = analyzer.encode_timing_proxy();
 
   if (params_.screenshare.enabled)
     SetupScreenshare();
 
   CreateVideoStreams();
   analyzer.SetSendStream(video_send_stream_);
   video_send_stream_->SetSource(analyzer.OutputInterface());
 
   CreateCapturer();
   rtc::VideoSinkWants wants;
-  capturer_->AddOrUpdateSink(analyzer.InputInterface(), wants);
+  video_capturer_->AddOrUpdateSink(analyzer.InputInterface(), wants);
 
   StartEncodedFrameLogs(video_send_stream_);
   StartEncodedFrameLogs(video_receive_streams_[0]);
   video_send_stream_->Start();
   for (VideoReceiveStream* receive_stream : video_receive_streams_)
     receive_stream->Start();
-  capturer_->Start();
+  video_capturer_->Start();
 
   analyzer.Wait();
 
   send_transport.StopSending();
   recv_transport.StopSending();
 
-  capturer_->Stop();
+  video_capturer_->Stop();
   for (VideoReceiveStream* receive_stream : video_receive_streams_)
     receive_stream->Stop();
   video_send_stream_->Stop();
 
   DestroyStreams();
 
   if (graph_data_output_file)
     fclose(graph_data_output_file);
 }
 
+void VideoQualityTest::SetupAudio(int send_channel_id,
+                                  int receive_channel_id,
+                                  Call* call,
+                                  Transport* transport,
+                                  AudioReceiveStream** audio_receive_stream) {
+  audio_send_config_ = AudioSendStream::Config(transport);
+  audio_send_config_.voe_channel_id = send_channel_id;
+  audio_send_config_.rtp.ssrc = kAudioSendSsrc;
+
+  // Add extension to enable audio send side BWE, and allow audio bit rate
+  // adaptation.
+  audio_send_config_.rtp.extensions.clear();
+  if (params_.call.send_side_bwe) {
+    audio_send_config_.rtp.extensions.push_back(
+        webrtc::RtpExtension(webrtc::RtpExtension::kTransportSequenceNumberUri,
+                             test::kTransportSequenceNumberExtensionId));
+    audio_send_config_.min_bitrate_kbps = kOpusMinBitrate / 1000;
+    audio_send_config_.max_bitrate_kbps = kOpusBitrateFb / 1000;
+  }
+  audio_send_config_.send_codec_spec.codec_inst =
+      CodecInst{120, "OPUS", 48000, 960, 2, 64000};
+
+  audio_send_stream_ = call->CreateAudioSendStream(audio_send_config_);
+
+  AudioReceiveStream::Config audio_config;
+  audio_config.rtp.local_ssrc = kReceiverLocalAudioSsrc;
+  audio_config.rtcp_send_transport = transport;
+  audio_config.voe_channel_id = receive_channel_id;
+  audio_config.rtp.remote_ssrc = audio_send_config_.rtp.ssrc;
+  audio_config.rtp.transport_cc = params_.call.send_side_bwe;
+  audio_config.rtp.extensions = audio_send_config_.rtp.extensions;
+  audio_config.decoder_factory = decoder_factory_;
+  if (params_.video.enabled && params_.audio.sync_video)
+    audio_config.sync_group = kSyncGroup;
+
+  *audio_receive_stream = call->CreateAudioReceiveStream(audio_config);
+}
+
 void VideoQualityTest::RunWithRenderers(const Params& params) {
   params_ = params;
   CheckParams();
 
-  std::unique_ptr<test::VideoRenderer> local_preview(
-      test::VideoRenderer::Create("Local Preview", params_.video.width,
-                                  params_.video.height));
-  size_t stream_id = params_.ss.selected_stream;
-  std::string title = "Loopback Video";
-  if (params_.ss.streams.size() > 1) {
-    std::ostringstream s;
-    s << stream_id;
-    title += " - Stream #" + s.str();
-  }
-
-  std::unique_ptr<test::VideoRenderer> loopback_video(
-      test::VideoRenderer::Create(title.c_str(),
-                                  params_.ss.streams[stream_id].width,
-                                  params_.ss.streams[stream_id].height));
-
   // TODO(ivica): Remove bitrate_config and use the default Call::Config(), to
   // match the full stack tests.
   webrtc::RtcEventLogNullImpl event_log;
   Call::Config call_config(&event_log_);
   call_config.bitrate_config = params_.call.call_bitrate_config;
 
   ::VoiceEngineState voe;
   if (params_.audio.enabled) {
     CreateVoiceEngine(&voe, decoder_factory_);
     AudioState::Config audio_state_config;
     audio_state_config.voice_engine = voe.voice_engine;
     call_config.audio_state = AudioState::Create(audio_state_config);
   }
 
   std::unique_ptr<Call> call(Call::Create(call_config));
 
+  // TODO(minyue): consider if this is a good transport even for audio only
+  // calls.
   test::LayerFilteringTransport transport(
       params.pipe, call.get(), kPayloadTypeVP8, kPayloadTypeVP9,
       params.video.selected_tl, params_.ss.selected_sl);
   // TODO(ivica): Use two calls to be able to merge with RunWithAnalyzer or at
   // least share as much code as possible. That way this test would also match
   // the full stack tests better.
   transport.SetReceiver(call->Receiver());
 
-  SetupCommon(&transport, &transport);
+  VideoReceiveStream* video_receive_stream = nullptr;
+  std::unique_ptr<test::VideoRenderer> local_preview;
+  std::unique_ptr<test::VideoRenderer> loopback_video;
+  if (params_.video.enabled) {
+    // Create video renderers.
+    local_preview.reset(test::VideoRenderer::Create(
+        "Local Preview", params_.video.width, params_.video.height));
 
-  video_send_config_.pre_encode_callback = local_preview.get();
-  video_receive_configs_[stream_id].renderer = loopback_video.get();
-  if (params_.audio.enabled && params_.audio.sync_video)
-    video_receive_configs_[stream_id].sync_group = kSyncGroup;
+    size_t stream_id = params_.ss.selected_stream;
+    std::string title = "Loopback Video";
+    if (params_.ss.streams.size() > 1) {
+      std::ostringstream s;
+      s << stream_id;
+      title += " - Stream #" + s.str();
+    }
 
-  video_send_config_.suspend_below_min_bitrate =
-      params_.video.suspend_below_min_bitrate;
+    loopback_video.reset(test::VideoRenderer::Create(
+        title.c_str(), params_.ss.streams[stream_id].width,
+        params_.ss.streams[stream_id].height));
 
-  if (params.video.fec) {
-    video_send_config_.rtp.ulpfec.red_payload_type = kRedPayloadType;
-    video_send_config_.rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType;
-    video_receive_configs_[stream_id].rtp.ulpfec.red_payload_type =
-        kRedPayloadType;
-    video_receive_configs_[stream_id].rtp.ulpfec.ulpfec_payload_type =
-        kUlpfecPayloadType;
+    SetupVideo(&transport, &transport);
+
+    // TODO(minyue): maybe move the following to SetupVideo() to make code
+    // cleaner.  Currently, RunWithRenderers() and RunWithAnalyzer() differ in
+    // the way they treat FEC etc., which makes it complicated to put these
+    // additional video setup into SetupVideo().
+    video_send_config_.pre_encode_callback = local_preview.get();
+    video_receive_configs_[stream_id].renderer = loopback_video.get();
+    if (params_.audio.enabled && params_.audio.sync_video)
+      video_receive_configs_[stream_id].sync_group = kSyncGroup;
+
+    video_send_config_.suspend_below_min_bitrate =
+        params_.video.suspend_below_min_bitrate;
+
+    if (params.video.fec) {
+      video_send_config_.rtp.ulpfec.red_payload_type = kRedPayloadType;
+      video_send_config_.rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType;
+      video_receive_configs_[stream_id].rtp.ulpfec.red_payload_type =
+          kRedPayloadType;
+      video_receive_configs_[stream_id].rtp.ulpfec.ulpfec_payload_type =
+          kUlpfecPayloadType;
+    }
+
+    if (params_.screenshare.enabled)
+      SetupScreenshare();
+
+    video_send_stream_ = call->CreateVideoSendStream(
+        video_send_config_.Copy(), video_encoder_config_.Copy());
+    video_receive_stream = call->CreateVideoReceiveStream(
+        video_receive_configs_[stream_id].Copy());
+    CreateCapturer();
+    video_send_stream_->SetSource(video_capturer_.get());
   }
 
-  if (params_.screenshare.enabled)
-    SetupScreenshare();
-
-  video_send_stream_ = call->CreateVideoSendStream(
-      video_send_config_.Copy(), video_encoder_config_.Copy());
-  VideoReceiveStream* video_receive_stream =
-      call->CreateVideoReceiveStream(video_receive_configs_[stream_id].Copy());
-  CreateCapturer();
-  video_send_stream_->SetSource(capturer_.get());
-
   AudioReceiveStream* audio_receive_stream = nullptr;
   if (params_.audio.enabled) {
-    audio_send_config_ = AudioSendStream::Config(&transport);
-    audio_send_config_.voe_channel_id = voe.send_channel_id;
-    audio_send_config_.rtp.ssrc = kAudioSendSsrc;
-
-    // Add extension to enable audio send side BWE, and allow audio bit rate
-    // adaptation.
-    audio_send_config_.rtp.extensions.clear();
-    if (params_.call.send_side_bwe) {
-      audio_send_config_.rtp.extensions.push_back(webrtc::RtpExtension(
-          webrtc::RtpExtension::kTransportSequenceNumberUri,
-          test::kTransportSequenceNumberExtensionId));
-      audio_send_config_.min_bitrate_kbps = kOpusMinBitrate / 1000;
-      audio_send_config_.max_bitrate_kbps = kOpusBitrateFb / 1000;
-    }
-    audio_send_config_.send_codec_spec.codec_inst =
-        CodecInst{120, "OPUS", 48000, 960, 2, 64000};
-
-    audio_send_stream_ = call->CreateAudioSendStream(audio_send_config_);
-
-    AudioReceiveStream::Config audio_config;
-    audio_config.rtp.local_ssrc = kReceiverLocalAudioSsrc;
-    audio_config.rtcp_send_transport = &transport;
-    audio_config.voe_channel_id = voe.receive_channel_id;
-    audio_config.rtp.remote_ssrc = audio_send_config_.rtp.ssrc;
-    audio_config.rtp.transport_cc = params_.call.send_side_bwe;
-    audio_config.rtp.extensions = audio_send_config_.rtp.extensions;
-    audio_config.decoder_factory = decoder_factory_;
-    if (params_.audio.sync_video)
-      audio_config.sync_group = kSyncGroup;
-
-    audio_receive_stream = call->CreateAudioReceiveStream(audio_config);
+    SetupAudio(voe.send_channel_id, voe.receive_channel_id, call.get(),
+               &transport, &audio_receive_stream);
   }
 
   StartEncodedFrameLogs(video_receive_stream);
   StartEncodedFrameLogs(video_send_stream_);
 
   // Start sending and receiving video.
-  video_receive_stream->Start();
-  video_send_stream_->Start();
-  capturer_->Start();
+  if (params_.video.enabled) {
+    video_receive_stream->Start();
+    video_send_stream_->Start();
+    video_capturer_->Start();
+  }
 
   if (params_.audio.enabled) {
     // Start receiving audio.
     audio_receive_stream->Start();
     EXPECT_EQ(0, voe.base->StartPlayout(voe.receive_channel_id));
 
     // Start sending audio.
     audio_send_stream_->Start();
     EXPECT_EQ(0, voe.base->StartSend(voe.send_channel_id));
   }
 
   test::PressEnterToContinue();
 
   if (params_.audio.enabled) {
     // Stop sending audio.
     EXPECT_EQ(0, voe.base->StopSend(voe.send_channel_id));
     audio_send_stream_->Stop();
 
     // Stop receiving audio.
     EXPECT_EQ(0, voe.base->StopPlayout(voe.receive_channel_id));
     audio_receive_stream->Stop();
-  }
-
-  // Stop receiving and sending video.
-  capturer_->Stop();
-  video_send_stream_->Stop();
-  video_receive_stream->Stop();
-
-  call->DestroyVideoReceiveStream(video_receive_stream);
-  call->DestroyVideoSendStream(video_send_stream_);
-
-  if (params_.audio.enabled) {
     call->DestroyAudioSendStream(audio_send_stream_);
     call->DestroyAudioReceiveStream(audio_receive_stream);
   }
 
+  // Stop receiving and sending video.
+  if (params_.video.enabled) {
+    video_capturer_->Stop();
+    video_send_stream_->Stop();
+    video_receive_stream->Stop();
+    call->DestroyVideoReceiveStream(video_receive_stream);
+    call->DestroyVideoSendStream(video_send_stream_);
+  }
+
   transport.StopSending();
   if (params_.audio.enabled)
     DestroyVoiceEngine(&voe);
 }
 
 void VideoQualityTest::StartEncodedFrameLogs(VideoSendStream* stream) {
   if (!params_.video.encoded_frame_base_path.empty()) {
     std::ostringstream str;
     str << send_logs_++;
     std::string prefix =
@@ skipping 11 matching lines @@
     std::ostringstream str;
     str << receive_logs_++;
     std::string path =
         params_.video.encoded_frame_base_path + "." + str.str() + ".recv.ivf";
     stream->EnableEncodedFrameRecording(rtc::CreatePlatformFile(path),
                                         10000000);
   }
 }
 
 }  // namespace webrtc