Potential fix for rtx/red issue where red is removed only from the remote description.

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 245 matching lines @@
     const std::vector<webrtc::RtpExtension>& extensions,
     const std::string& name) {
   for (const auto& kv : extensions) {
     if (kv.name == name) {
       return true;
     }
   }
   return false;
 }
 
-// Merges two fec configs and logs an error if a conflict arises
-// such that merging in different order would trigger a different output.
-static void MergeFecConfig(const webrtc::FecConfig& other,
-                           webrtc::FecConfig* output) {
-  if (other.ulpfec_payload_type != -1) {
-    if (output->ulpfec_payload_type != -1 &&
-        output->ulpfec_payload_type != other.ulpfec_payload_type) {
-      LOG(LS_WARNING) << "Conflict merging ulpfec_payload_type configs: "
-                      << output->ulpfec_payload_type << " and "
-                      << other.ulpfec_payload_type;
-    }
-    output->ulpfec_payload_type = other.ulpfec_payload_type;
-  }
-  if (other.red_payload_type != -1) {
-    if (output->red_payload_type != -1 &&
-        output->red_payload_type != other.red_payload_type) {
-      LOG(LS_WARNING) << "Conflict merging red_payload_type configs: "
-                      << output->red_payload_type << " and "
-                      << other.red_payload_type;
-    }
-    output->red_payload_type = other.red_payload_type;
-  }
-  if (other.red_rtx_payload_type != -1) {
-    if (output->red_rtx_payload_type != -1 &&
-        output->red_rtx_payload_type != other.red_rtx_payload_type) {
-      LOG(LS_WARNING) << "Conflict merging red_rtx_payload_type configs: "
-                      << output->red_rtx_payload_type << " and "
-                      << other.red_rtx_payload_type;
-    }
-    output->red_rtx_payload_type = other.red_rtx_payload_type;
-  }
-}
-
 // Returns true if the given codec is disallowed from doing simulcast.
 bool IsCodecBlacklistedForSimulcast(const std::string& codec_name) {
   return CodecNamesEq(codec_name, kH264CodecName) ||
          CodecNamesEq(codec_name, kVp9CodecName);
 }
 
 // The selected thresholds for QVGA and VGA corresponded to a QP around 10.
 // The change in QP declined above the selected bitrates.
 static int GetMaxDefaultVideoBitrateKbps(int width, int height) {
   if (width * height <= 320 * 240) {
@@ skipping 366 matching lines @@
     const VideoOptions& options,
     const std::vector<VideoCodec>& recv_codecs,
     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) {
+      default_send_options_(options),
+      red_disabled_by_remote_side_(false) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
   rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
   sending_ = false;
   RTC_DCHECK(ValidateCodecFormats(recv_codecs));
   recv_codecs_ = FilterSupportedCodecs(MapCodecs(recv_codecs));
 }
 
 WebRtcVideoChannel2::~WebRtcVideoChannel2() {
   for (auto& kv : send_streams_)
@@ skipping 169 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->fec.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->SetFecDisabledRemotely(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 345 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, config, external_decoder_factory_, default_stream,
-      recv_codecs_);
+      recv_codecs_, red_disabled_by_remote_side_);
 
   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 15 matching lines @@
   // (receive-only) or know a good local SSRC.
   if (config->rtp.remote_ssrc == config->rtp.local_ssrc) {
     if (config->rtp.local_ssrc != kDefaultRtcpReceiverReportSsrc) {
       config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc;
     } else {
       config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc + 1;
     }
   }
 
   for (size_t i = 0; i < recv_codecs_.size(); ++i) {
-    MergeFecConfig(recv_codecs_[i].fec, &config->rtp.fec);
-  }
-
-  for (size_t i = 0; i < recv_codecs_.size(); ++i) {
     uint32_t rtx_ssrc;
     if (recv_codecs_[i].rtx_payload_type != -1 &&
         sp.GetFidSsrc(ssrc, &rtx_ssrc)) {
       webrtc::VideoReceiveStream::Config::Rtp::Rtx& rtx =
           config->rtp.rtx[recv_codecs_[i].codec.id];
       rtx.ssrc = rtx_ssrc;
       rtx.payload_type = recv_codecs_[i].rtx_payload_type;
     }
   }
 }
@@ skipping 942 matching lines @@
     stream_->Start();
   }
 }
 
 WebRtcVideoChannel2::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
     webrtc::Call* call,
     const StreamParams& sp,
     const webrtc::VideoReceiveStream::Config& config,
     WebRtcVideoDecoderFactory* external_decoder_factory,
     bool default_stream,
-    const std::vector<VideoCodecSettings>& recv_codecs)
+    const std::vector<VideoCodecSettings>& recv_codecs,
+    bool red_disabled_by_remote_side)
     : call_(call),
       ssrcs_(sp.ssrcs),
       ssrc_groups_(sp.ssrc_groups),
       stream_(NULL),
       default_stream_(default_stream),
       config_(config),
+      red_disabled_by_remote_side_(red_disabled_by_remote_side),
       external_decoder_factory_(external_decoder_factory),
       sink_(NULL),
       last_width_(-1),
       last_height_(-1),
       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();
@@ skipping 155 matching lines @@
     LOG(LS_INFO) << "RecreateWebRtcStream (recv) because of SetRecvParameters";
     RecreateWebRtcStream();
     ClearDecoders(&old_decoders);
   }
 }
 
 void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RecreateWebRtcStream() {
   if (stream_ != NULL) {
     call_->DestroyVideoReceiveStream(stream_);
   }
-  stream_ = call_->CreateVideoReceiveStream(config_);
+  webrtc::VideoReceiveStream::Config config = config_;
+  if (red_disabled_by_remote_side_) {
+    config.rtp.fec.red_payload_type = -1;
+    config.rtp.fec.ulpfec_payload_type = -1;
+    config.rtp.fec.red_rtx_payload_type = -1;
+  }
+  stream_ = call_->CreateVideoReceiveStream(config);
   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 87 matching lines @@
 
   info.codec_name = GetCodecNameFromPayloadType(stats.current_payload_type);
 
   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;
 
   return info;
 }
 
+void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetFecDisabledRemotely(
+    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 &&
          fec.ulpfec_payload_type == other.fec.ulpfec_payload_type &&
          fec.red_payload_type == other.fec.red_payload_type &&
          fec.red_rtx_payload_type == other.fec.red_rtx_payload_type &&
          rtx_payload_type == other.rtx_payload_type;
@@ skipping 93 matching lines @@
         rtx_mapping[video_codecs[i].codec.id] !=
             fec_settings.red_payload_type) {
       video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
     }
   }
 
   return video_codecs;
 }
 
 }  // namespace cricket