Adding audio only mode to video loopback test.

webrtc/video/video_quality_test.cc

Index: webrtc/video/video_quality_test.cc
diff --git a/webrtc/video/video_quality_test.cc b/webrtc/video/video_quality_test.cc
index d42ed9b0f6b8cf4435a43f13dcedf1da8c1175e6..3ab1f89b576325e7cbf464c7c6343e7f1731527e 100644
--- a/webrtc/video/video_quality_test.cc
+++ b/webrtc/video/video_quality_test.cc
@@ -915,8 +915,8 @@ void VideoQualityTest::FillScalabilitySettings(
   }
 }
 
-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);
 
@@ -925,19 +925,19 @@ void VideoQualityTest::SetupCommon(Transport* 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;
@@ -977,20 +977,22 @@ void VideoQualityTest::SetupScreenshare() {
   // Fill out codec settings.
   video_encoder_config_.content_type = VideoEncoderConfig::ContentType::kScreen;
   if (params_.video.codec == "VP8") {
-    codec_settings_.VP8 = VideoEncoder::GetDefaultVp8Settings();
-    codec_settings_.VP8.denoisingOn = false;
-    codec_settings_.VP8.frameDroppingOn = false;
-    codec_settings_.VP8.numberOfTemporalLayers =
+    video_codec_settings_.VP8 = VideoEncoder::GetDefaultVp8Settings();
+    video_codec_settings_.VP8.denoisingOn = false;
+    video_codec_settings_.VP8.frameDroppingOn = false;
+    video_codec_settings_.VP8.numberOfTemporalLayers =
         static_cast<unsigned char>(params_.video.num_temporal_layers);
-    video_encoder_config_.encoder_specific_settings = &codec_settings_.VP8;
+    video_encoder_config_.encoder_specific_settings =
+        &video_codec_settings_.VP8;
   } else if (params_.video.codec == "VP9") {
-    codec_settings_.VP9 = VideoEncoder::GetDefaultVp9Settings();
-    codec_settings_.VP9.denoisingOn = false;
-    codec_settings_.VP9.frameDroppingOn = false;
-    codec_settings_.VP9.numberOfTemporalLayers =
+    video_codec_settings_.VP9 = VideoEncoder::GetDefaultVp9Settings();
+    video_codec_settings_.VP9.denoisingOn = false;
+    video_codec_settings_.VP9.frameDroppingOn = false;
+    video_codec_settings_.VP9.numberOfTemporalLayers =
         static_cast<unsigned char>(params_.video.num_temporal_layers);
-    video_encoder_config_.encoder_specific_settings = &codec_settings_.VP9;
-    codec_settings_.VP9.numberOfSpatialLayers =
+    video_encoder_config_.encoder_specific_settings =
+        &video_codec_settings_.VP9;
+    video_codec_settings_.VP9.numberOfSpatialLayers =
         static_cast<unsigned char>(params_.ss.num_spatial_layers);
   }
 
@@ -1032,20 +1034,20 @@ void VideoQualityTest::CreateCapturer(VideoCaptureInput* input) {
         new test::FrameGeneratorCapturer(
             clock_, input, 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::VideoCapturer::Create(input, params_.video.width,
-                                                  params_.video.height,
-                                                  params_.video.fps, clock_));
+      video_capturer_.reset(test::VideoCapturer::Create(
+          input, params_.video.width, params_.video.height, params_.video.fps,
+          clock_));
     } else {
-      capturer_.reset(test::FrameGeneratorCapturer::CreateFromYuvFile(
+      video_capturer_.reset(test::FrameGeneratorCapturer::CreateFromYuvFile(
           input, 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?";
     }
   }
 }
@@ -1113,7 +1115,7 @@ void VideoQualityTest::RunWithAnalyzer(const Params& params) {
   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_)
@@ -1133,14 +1135,14 @@ void VideoQualityTest::RunWithAnalyzer(const Params& params) {
   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();
@@ -1151,26 +1153,46 @@ void VideoQualityTest::RunWithAnalyzer(const Params& params) {
     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_.common.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_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_.common.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.
   Call::Config call_config;
@@ -1179,6 +1201,8 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
   ::VoiceEngineState voe;
   if (params_.audio.enabled) {
     CreateVoiceEngine(&voe, decoder_factory_);
+    const CodecInst kOpusInst = {120, "OPUS", 48000, 960, 2, 64000};
+    EXPECT_EQ(0, voe.codec->SetSendCodec(voe.send_channel_id, kOpusInst));
     AudioState::Config audio_state_config;
     audio_state_config.voice_engine = voe.voice_engine;
     call_config.audio_state = AudioState::Create(audio_state_config);
@@ -1186,6 +1210,8 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
 
   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);
@@ -1194,74 +1220,69 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
   // 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 renders.
+    local_preview.reset(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();
+    }
 
-  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;
+    loopback_video.reset(test::VideoRenderer::Create(
+        title.c_str(), params_.ss.streams[stream_id].width,
+        params_.ss.streams[stream_id].height));
+
+    SetupVideo(&transport, &transport);
+
+    // TODO(minyue): maybe move the following to SetupVideo() to make code

[stefan-webrtc, 2016/09/07 13:12:10]

Any chance we can do this now? It would look a lot better as it'd be more
aligned with the audio part

[minyue-webrtc, 2016/09/08 15:38:24]

The reason that I am not very confident in modifying it is that SetupVideo() is
used by both RunWithRenderers and RunWithAnalyzer, the out-of-SetupVideo parts
of the two are hard to combine.

BTW, audio-only mode is not added to RunWithAnalyzer yet.

[stefan-webrtc, 2016/09/13 09:50:23]

I'm not sure I follow. This method is called RunWithRenderers, so I assume it's
only called for renderers? What is it that you have to combine?

[minyue-webrtc, 2016/10/28 14:00:59]

If you compare the lines following SetupVideo() in RunWithRenderers() and
RunWithAnalyzer(), i.e. line 1247 - 1271 vs line 1119 - 1127, there are quite
many differences. E.g. one deals with FEC and the other does not. I am not sure
that we should unify them now in this CL.

+    // cleaner.
+    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.fec.red_payload_type = kRedPayloadType;
+      video_send_config_.rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
+      video_receive_configs_[stream_id].rtp.fec.red_payload_type =
+          kRedPayloadType;
+      video_receive_configs_[stream_id].rtp.fec.ulpfec_payload_type =
+          kUlpfecPayloadType;
+    }
 
-  video_send_config_.suspend_below_min_bitrate =
-      params_.video.suspend_below_min_bitrate;
+    if (params_.screenshare.enabled)
+      SetupScreenshare();
 
-  if (params.video.fec) {
-    video_send_config_.rtp.fec.red_payload_type = kRedPayloadType;
-    video_send_config_.rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
-    video_receive_configs_[stream_id].rtp.fec.red_payload_type =
-      kRedPayloadType;
-    video_receive_configs_[stream_id].rtp.fec.ulpfec_payload_type =
-      kUlpfecPayloadType;
+    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_->Input());
   }
 
-  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_->Input());
-
   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_.common.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_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_.common.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);
-
-    const CodecInst kOpusInst = {120, "OPUS", 48000, 960, 2, 64000};
-    EXPECT_EQ(0, voe.codec->SetSendCodec(voe.send_channel_id, kOpusInst));
+    SetupAudio(voe.send_channel_id, voe.receive_channel_id, call.get(),
+               &transport, &audio_receive_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.
@@ -1285,19 +1306,17 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
     EXPECT_EQ(0, voe.base->StopReceive(voe.receive_channel_id));
     EXPECT_EQ(0, voe.base->StopPlayout(voe.receive_channel_id));
     audio_receive_stream->Stop();
+    call->DestroyAudioSendStream(audio_send_stream_);
+    call->DestroyAudioReceiveStream(audio_receive_stream);
   }
 
   // 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);
+  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();