Make |rtcp_send_transport| mandatory in FlexfecReceiveStream::Config.

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 1000 matching lines @@
     layer.target_bitrate_bps = v[2];
     params->ss.spatial_layers.push_back(layer);
   }
 }
 
 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, 0, send_transport);
+  size_t num_video_streams = params_.ss.streams.size();
+  size_t num_flexfec_streams = params_.video.flexfec ? 1 : 0;
+  CreateSendConfig(num_video_streams, 0, num_flexfec_streams, send_transport);
 
   int payload_type;
   if (params_.video.codec == "H264") {
     video_encoder_.reset(H264Encoder::Create(cricket::VideoCodec("H264")));
     payload_type = kPayloadTypeH264;
   } else if (params_.video.codec == "VP8") {
     video_encoder_.reset(VP8Encoder::Create());
     payload_type = kPayloadTypeVP8;
   } else if (params_.video.codec == "VP9") {
     video_encoder_.reset(VP9Encoder::Create());
     payload_type = kPayloadTypeVP9;
   } else {
     RTC_NOTREACHED() << "Codec not supported!";
     return;
   }
   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)
+  for (size_t i = 0; i < num_video_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(
         RtpExtension(RtpExtension::kTransportSequenceNumberUri,
                      test::kTransportSequenceNumberExtensionId));
   } else {
     video_send_config_.rtp.extensions.push_back(RtpExtension(
         RtpExtension::kAbsSendTimeUri, test::kAbsSendTimeExtensionId));
@@ skipping 11 matching lines @@
     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) {
+  for (size_t i = 0; i < num_video_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.payload_type =
-        video_send_config_.rtp.flexfec.flexfec_payload_type;
-    flexfec_receive_config.remote_ssrc =
-        video_send_config_.rtp.flexfec.flexfec_ssrc;
-    flexfec_receive_config.protected_media_ssrcs =
+    RTC_DCHECK(!flexfec_receive_configs_.empty());
+    flexfec_receive_configs_[0].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;
@@ skipping 392 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