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 <stdio.h>
@@ skipping 897 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_.common.send_side_bwe) {
     video_send_config_.rtp.extensions.push_back(
@@ skipping 19 matching lines @@
     video_receive_configs_[i].rtp.transport_cc = params_.common.send_side_bwe;
   }
 }
 
 void VideoQualityTest::SetupScreenshare() {
   RTC_CHECK(params_.screenshare.enabled);
 
   // 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);
   }
 
   // Setup frame generator.
   const size_t kWidth = 1850;
   const size_t kHeight = 1110;
   std::vector<std::string> slides;
   slides.push_back(test::ResourcePath("web_screenshot_1850_1110", "yuv"));
   slides.push_back(test::ResourcePath("presentation_1850_1110", "yuv"));
   slides.push_back(test::ResourcePath("photo_1850_1110", "yuv"));
@@ skipping 21 matching lines @@
             kPauseDurationMs));
   }
 }
 
 void VideoQualityTest::CreateCapturer(VideoCaptureInput* input) {
   if (params_.screenshare.enabled) {
     test::FrameGeneratorCapturer* frame_generator_capturer =
         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?";
     }
   }
 }
 
 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 47 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.input_ = video_send_stream_->Input();
   analyzer.send_stream_ = video_send_stream_;
 
   CreateCapturer(&analyzer);
 
   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_.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;
   call_config.bitrate_config = params_.common.call_bitrate_config;
 
   ::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);
   }
 
   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 renders.
+    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.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;
+    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;
+    }
+
+    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_->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.
     audio_receive_stream->Start();
     EXPECT_EQ(0, voe.base->StartPlayout(voe.receive_channel_id));
     EXPECT_EQ(0, voe.base->StartReceive(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->StopReceive(voe.receive_channel_id));
     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);
 }
 
 }  // namespace webrtc