Remove RED/RTX workaround from sender/receiver and VideoEngine2.

webrtc/media/engine/webrtcvideoengine2.cc

 /*
  *  Copyright (c) 2014 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.
  */
 
@@ skipping 659 matching lines @@
     const VideoOptions& options,
     WebRtcVideoEncoderFactory* external_encoder_factory,
     WebRtcVideoDecoderFactory* external_decoder_factory)
     : VideoMediaChannel(config),
       call_(call),
       unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
       video_config_(config.video),
       external_encoder_factory_(external_encoder_factory),
       external_decoder_factory_(external_decoder_factory),
       default_send_options_(options),
-      red_disabled_by_remote_side_(false),
       last_stats_log_ms_(-1) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
   rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
   sending_ = false;
   recv_codecs_ = MapCodecs(GetSupportedCodecs(external_encoder_factory));
 }
 
 WebRtcVideoChannel2::~WebRtcVideoChannel2() {
   for (auto& kv : send_streams_)
@@ skipping 150 matching lines @@
              "codec or RTCP mode has changed.";
       for (auto& kv : receive_streams_) {
         RTC_DCHECK(kv.second != nullptr);
         kv.second->SetFeedbackParameters(
             HasNack(send_codec_->codec), HasRemb(send_codec_->codec),
             HasTransportCc(send_codec_->codec),
             params.rtcp.reduced_size ? webrtc::RtcpMode::kReducedSize
                                      : webrtc::RtcpMode::kCompound);
       }
     }
-    if (changed_params.codec) {
-      bool red_was_disabled = red_disabled_by_remote_side_;
-      red_disabled_by_remote_side_ =
-          changed_params.codec->ulpfec.red_payload_type == -1;
-      if (red_was_disabled != red_disabled_by_remote_side_) {
-        for (auto& kv : receive_streams_) {
-          // In practice VideoChannel::SetRemoteContent appears to most of the
-          // time also call UpdateRemoteStreams, which recreates the receive
-          // streams. If that's always true this call isn't needed.
-          kv.second->SetUlpfecDisabledRemotely(red_disabled_by_remote_side_);
-        }
-      }
-    }
   }
   send_params_ = params;
   return true;
 }
 
 webrtc::RtpParameters WebRtcVideoChannel2::GetRtpSendParameters(
     uint32_t ssrc) const {
   rtc::CritScope stream_lock(&stream_crit_);
   auto it = send_streams_.find(ssrc);
   if (it == send_streams_.end()) {
@@ skipping 359 matching lines @@
   config.sync_group = sp.sync_label;
 
   config.rtp.remb = send_codec_ ? HasRemb(send_codec_->codec) : false;
   config.rtp.transport_cc =
       send_codec_ ? HasTransportCc(send_codec_->codec) : false;
   config.disable_prerenderer_smoothing =
       video_config_.disable_prerenderer_smoothing;
 
   receive_streams_[ssrc] = new WebRtcVideoReceiveStream(
       call_, sp, std::move(config), external_decoder_factory_, default_stream,
-      recv_codecs_, red_disabled_by_remote_side_);
+      recv_codecs_);
 
   return true;
 }
 
 void WebRtcVideoChannel2::ConfigureReceiverRtp(
     webrtc::VideoReceiveStream::Config* config,
     const StreamParams& sp) const {
   uint32_t ssrc = sp.first_ssrc();
 
   config->rtp.remote_ssrc = ssrc;
@@ skipping 873 matching lines @@
   // Call stream_->Start() if necessary conditions are met.
   UpdateSendState();
 }
 
 WebRtcVideoChannel2::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
     webrtc::Call* call,
     const StreamParams& sp,
     webrtc::VideoReceiveStream::Config config,
     WebRtcVideoDecoderFactory* external_decoder_factory,
     bool default_stream,
-    const std::vector<VideoCodecSettings>& recv_codecs,
-    bool red_disabled_by_remote_side)
+    const std::vector<VideoCodecSettings>& recv_codecs)
     : call_(call),
       stream_params_(sp),
       stream_(NULL),
       default_stream_(default_stream),
       config_(std::move(config)),
-      red_disabled_by_remote_side_(red_disabled_by_remote_side),
       external_decoder_factory_(external_decoder_factory),
       sink_(NULL),
       first_frame_timestamp_(-1),
       estimated_remote_start_ntp_time_ms_(0) {
   config_.renderer = this;
   std::vector<AllocatedDecoder> old_decoders;
   ConfigureCodecs(recv_codecs, &old_decoders);
   RecreateWebRtcStream();
   RTC_DCHECK(old_decoders.empty());
 }
@@ skipping 182 matching lines @@
     LOG(LS_INFO) << "RecreateWebRtcStream (recv) because of SetRecvParameters";
     RecreateWebRtcStream();
     ClearDecoders(&old_decoders);
   }
 }
 
 void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RecreateWebRtcStream() {
   if (stream_ != NULL) {
     call_->DestroyVideoReceiveStream(stream_);
   }
-  webrtc::VideoReceiveStream::Config config = config_.Copy();
-  if (red_disabled_by_remote_side_) {
-    config.rtp.ulpfec.red_payload_type = -1;
-    config.rtp.ulpfec.ulpfec_payload_type = -1;
-    config.rtp.ulpfec.red_rtx_payload_type = -1;
-  }
-  stream_ = call_->CreateVideoReceiveStream(std::move(config));
+  stream_ = call_->CreateVideoReceiveStream(config_.Copy());
   stream_->Start();
 }
 
 void WebRtcVideoChannel2::WebRtcVideoReceiveStream::ClearDecoders(
     std::vector<AllocatedDecoder>* allocated_decoders) {
   for (size_t i = 0; i < allocated_decoders->size(); ++i) {
     if ((*allocated_decoders)[i].external) {
       external_decoder_factory_->DestroyVideoDecoder(
           (*allocated_decoders)[i].external_decoder);
     }
@@ skipping 86 matching lines @@
   info.firs_sent = stats.rtcp_packet_type_counts.fir_packets;
   info.plis_sent = stats.rtcp_packet_type_counts.pli_packets;
   info.nacks_sent = stats.rtcp_packet_type_counts.nack_packets;
 
   if (log_stats)
     LOG(LS_INFO) << stats.ToString(rtc::TimeMillis());
 
   return info;
 }
 
-void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetUlpfecDisabledRemotely(
-    bool disable) {
-  red_disabled_by_remote_side_ = disable;
-  RecreateWebRtcStream();
-}
-
 WebRtcVideoChannel2::VideoCodecSettings::VideoCodecSettings()
     : rtx_payload_type(-1) {}
 
 bool WebRtcVideoChannel2::VideoCodecSettings::operator==(
     const WebRtcVideoChannel2::VideoCodecSettings& other) const {
   return codec == other.codec &&
          ulpfec.ulpfec_payload_type == other.ulpfec.ulpfec_payload_type &&
          ulpfec.red_payload_type == other.ulpfec.red_payload_type &&
          ulpfec.red_rtx_payload_type == other.ulpfec.red_rtx_payload_type &&
          rtx_payload_type == other.rtx_payload_type;
@@ skipping 98 matching lines @@
         rtx_mapping[video_codecs[i].codec.id] !=
             ulpfec_config.red_payload_type) {
       video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
     }
   }
 
   return video_codecs;
 }
 
 }  // namespace cricket