Configure FlexFEC in VideoQualityTest.

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 799 matching lines @@
   std::deque<FrameComparison> comparisons_ GUARDED_BY(comparison_lock_);
   rtc::Event done_;
 };
 
 VideoQualityTest::VideoQualityTest()
     : clock_(Clock::GetRealTimeClock()), receive_logs_(0), send_logs_(0) {}
 
 VideoQualityTest::Params::Params()
     : call({false, Call::Config::BitrateConfig()}),
       video({false, 640, 480, 30, 50, 800, 800, false, "VP8", 1, -1, 0, false,
-             "", ""}),
+             false, "", ""}),
       audio({false, false}),
       screenshare({false, 10, 0}),
       analyzer({"", 0.0, 0.0, 0, "", ""}),
       pipe(),
       logs(false),
       ss({std::vector<VideoStream>(), 0, 0, -1, std::vector<SpatialLayer>()}) {}
 
 VideoQualityTest::Params::~Params() = default;
 
 void VideoQualityTest::TestBody() {}
@@ skipping 200 matching lines @@
         RtpExtension(RtpExtension::kTransportSequenceNumberUri,
                      test::kTransportSequenceNumberExtensionId));
   } else {
     video_send_config_.rtp.extensions.push_back(RtpExtension(
         RtpExtension::kAbsSendTimeUri, test::kAbsSendTimeExtensionId));
   }
 
   video_encoder_config_.min_transmit_bitrate_bps =
       params_.video.min_transmit_bps;
 
+  video_send_config_.suspend_below_min_bitrate =
+      params_.video.suspend_below_min_bitrate;
+
   video_encoder_config_.number_of_streams = params_.ss.streams.size();
   video_encoder_config_.max_bitrate_bps = 0;
   for (size_t i = 0; i < params_.ss.streams.size(); ++i) {
     video_encoder_config_.max_bitrate_bps +=
         params_.ss.streams[i].max_bitrate_bps;
   }
   video_encoder_config_.video_stream_factory =
       new rtc::RefCountedObject<VideoStreamFactory>(params_.ss.streams);
 
   video_encoder_config_.spatial_layers = params_.ss.spatial_layers;
 
   CreateMatchingReceiveConfigs(recv_transport);
 
   for (size_t i = 0; i < num_streams; ++i) {
     video_receive_configs_[i].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
     video_receive_configs_[i].rtp.rtx[payload_type].ssrc = kSendRtxSsrcs[i];
     video_receive_configs_[i].rtp.rtx[payload_type].payload_type =
         kSendRtxPayloadType;
     video_receive_configs_[i].rtp.transport_cc = params_.call.send_side_bwe;
   }
+
+  if (params_.video.flexfec) {
+    video_send_config_.rtp.flexfec.flexfec_payload_type = kFlexfecPayloadType;
+    video_send_config_.rtp.flexfec.flexfec_ssrc = kFlexfecSendSsrc;
+    video_send_config_.rtp.flexfec.protected_media_ssrcs = {
+        kVideoSendSsrcs[params_.ss.selected_stream]};
+
+    FlexfecReceiveStream::Config flexfec_receive_config;
+    flexfec_receive_config.flexfec_payload_type =
+        video_send_config_.rtp.flexfec.flexfec_payload_type;
+    flexfec_receive_config.flexfec_ssrc =
+        video_send_config_.rtp.flexfec.flexfec_ssrc;
+    flexfec_receive_config.protected_media_ssrcs =
+        video_send_config_.rtp.flexfec.protected_media_ssrcs;
+    flexfec_receive_configs_.push_back(flexfec_receive_config);
+  }
+
+  if (params_.video.ulpfec) {
+    video_send_config_.rtp.ulpfec.red_payload_type = kRedPayloadType;
+    video_send_config_.rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType;
+    video_send_config_.rtp.ulpfec.red_rtx_payload_type = kRtxRedPayloadType;
+
+    video_receive_configs_[params_.ss.selected_stream]
+        .rtp.ulpfec.red_payload_type =
+        video_send_config_.rtp.ulpfec.red_payload_type;
+    video_receive_configs_[params_.ss.selected_stream]
+        .rtp.ulpfec.ulpfec_payload_type =
+        video_send_config_.rtp.ulpfec.ulpfec_payload_type;
+    video_receive_configs_[params_.ss.selected_stream]
+        .rtp.ulpfec.red_rtx_payload_type =
+        video_send_config_.rtp.ulpfec.red_rtx_payload_type;
+  }
 }
 
 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") {
     VideoCodecVP8 vp8_settings = VideoEncoder::GetDefaultVp8Settings();
     vp8_settings.denoisingOn = false;
@@ skipping 137 matching lines @@
   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();
 
+  CreateFlexfecStreams();
   CreateVideoStreams();
   analyzer.SetSendStream(video_send_stream_);
   video_send_stream_->SetSource(
       analyzer.OutputInterface(),
       VideoSendStream::DegradationPreference::kBalanced);
 
   CreateCapturer();
   rtc::VideoSinkWants 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();
+  for (FlexfecReceiveStream* receive_stream : flexfec_receive_streams_)
+    receive_stream->Start();
   video_capturer_->Start();
 
   analyzer.Wait();
 
   send_transport.StopSending();
   recv_transport.StopSending();
 
   video_capturer_->Stop();
+  for (FlexfecReceiveStream* receive_stream : flexfec_receive_streams_)
+    receive_stream->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);
 }
 
@@ skipping 59 matching lines @@
   // 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());
 
   VideoReceiveStream* video_receive_stream = nullptr;
+  FlexfecReceiveStream* flexfec_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));
 
     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();
     }
 
     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
-    // 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_send_config_.rtp.ulpfec.red_rtx_payload_type = kRtxRedPayloadType;
-      video_receive_configs_[stream_id].rtp.ulpfec.red_payload_type =
-          kRedPayloadType;
-      video_receive_configs_[stream_id].rtp.ulpfec.ulpfec_payload_type =
-          kUlpfecPayloadType;
-      video_receive_configs_[stream_id].rtp.ulpfec.red_rtx_payload_type =
-          kRtxRedPayloadType;
-    }
-
     if (params_.screenshare.enabled)
       SetupScreenshare();
 
     video_send_stream_ = call->CreateVideoSendStream(
         video_send_config_.Copy(), video_encoder_config_.Copy());
+    if (params_.video.flexfec) {
+      RTC_DCHECK(!flexfec_receive_configs_.empty());
+      flexfec_receive_stream =
+          call->CreateFlexfecReceiveStream(flexfec_receive_configs_[0]);
+    }
     video_receive_stream = call->CreateVideoReceiveStream(
         video_receive_configs_[stream_id].Copy());
     CreateCapturer();
     video_send_stream_->SetSource(
         video_capturer_.get(),
         VideoSendStream::DegradationPreference::kBalanced);
   }
 
   AudioReceiveStream* audio_receive_stream = nullptr;
   if (params_.audio.enabled) {
     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.
   if (params_.video.enabled) {
+    if (flexfec_receive_stream)
+      flexfec_receive_stream->Start();
     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));
 
@@ skipping 14 matching lines @@
     audio_receive_stream->Stop();
     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();
+    if (flexfec_receive_stream) {
+      flexfec_receive_stream->Stop();
+      call->DestroyFlexfecReceiveStream(flexfec_receive_stream);
+    }
     call->DestroyVideoReceiveStream(video_receive_stream);
     call->DestroyVideoSendStream(video_send_stream_);
   }
 
   transport.StopSending();
   if (params_.audio.enabled)
     DestroyVoiceEngine(&voe);
 }
 
 void VideoQualityTest::StartEncodedFrameLogs(VideoSendStream* stream) {
@@ skipping 15 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