Rename FecConfig to UlpfecConfig in config.h.

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 879 matching lines @@
         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;
+          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->SetFecDisabledRemotely(red_disabled_by_remote_side_);
+          kv.second->SetUlpfecDisabledRemotely(red_disabled_by_remote_side_);
         }
       }
     }
   }
   send_params_ = params;
   return true;
 }
 
 webrtc::RtpParameters WebRtcVideoChannel2::GetRtpSendParameters(
     uint32_t ssrc) const {
@@ skipping 551 matching lines @@
     return;
   }
 
   // See if this payload_type is registered as one that usually gets its own
   // SSRC (RTX) or at least is safe to drop either way (ULPFEC). If it is, and
   // it wasn't handled above by DeliverPacket, that means we don't know what
   // stream it associates with, and we shouldn't ever create an implicit channel
   // for these.
   for (auto& codec : recv_codecs_) {
     if (payload_type == codec.rtx_payload_type ||
-        payload_type == codec.fec.red_rtx_payload_type ||
-        payload_type == codec.fec.ulpfec_payload_type) {
+        payload_type == codec.ulpfec.red_rtx_payload_type ||
+        payload_type == codec.ulpfec.ulpfec_payload_type) {
       return;
     }
   }
 
   switch (unsignalled_ssrc_handler_->OnUnsignalledSsrc(this, ssrc)) {
     case UnsignalledSsrcHandler::kDropPacket:
       return;
     case UnsignalledSsrcHandler::kDeliverPacket:
       break;
   }
@@ skipping 349 matching lines @@
   AllocatedEncoder new_encoder = CreateVideoEncoder(codec_settings.codec);
   parameters_.config.encoder_settings.encoder = new_encoder.encoder;
   parameters_.config.encoder_settings.full_overuse_time = new_encoder.external;
   parameters_.config.encoder_settings.payload_name = codec_settings.codec.name;
   parameters_.config.encoder_settings.payload_type = codec_settings.codec.id;
   if (new_encoder.external) {
     webrtc::VideoCodecType type = CodecTypeFromName(codec_settings.codec.name);
     parameters_.config.encoder_settings.internal_source =
         external_encoder_factory_->EncoderTypeHasInternalSource(type);
   }
-  parameters_.config.rtp.fec = codec_settings.fec;
+  parameters_.config.rtp.ulpfec = codec_settings.ulpfec;
 
   // Set RTX payload type if RTX is enabled.
   if (!parameters_.config.rtp.rtx.ssrcs.empty()) {
     if (codec_settings.rtx_payload_type == -1) {
       LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX "
                          "payload type. Ignoring.";
       parameters_.config.rtp.rtx.ssrcs.clear();
     } else {
       parameters_.config.rtp.rtx.payload_type = codec_settings.rtx_payload_type;
     }
@@ skipping 527 matching lines @@
 
     webrtc::VideoReceiveStream::Decoder decoder;
     decoder.decoder = allocated_decoder.decoder;
     decoder.payload_type = recv_codecs[i].codec.id;
     decoder.payload_name = recv_codecs[i].codec.name;
     ConfigureDecoderSpecifics(&decoder, recv_codecs[i].codec);
     config_.decoders.push_back(decoder);
   }
 
   // TODO(pbos): Reconfigure RTX based on incoming recv_codecs.
-  config_.rtp.fec = recv_codecs.front().fec;
+  config_.rtp.ulpfec = recv_codecs.front().ulpfec;
   config_.rtp.nack.rtp_history_ms =
       HasNack(recv_codecs.begin()->codec) ? kNackHistoryMs : 0;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetLocalSsrc(
     uint32_t local_ssrc) {
   // TODO(pbos): Consider turning this sanity check into a RTC_DCHECK. You
   // should not be able to create a sender with the same SSRC as a receiver, but
   // right now this can't be done due to unittests depending on receiving what
   // they are sending from the same MediaChannel.
@@ skipping 56 matching lines @@
     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.fec.red_payload_type = -1;
-    config.rtp.fec.ulpfec_payload_type = -1;
-    config.rtp.fec.red_rtx_payload_type = -1;
+    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_->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(
@@ skipping 90 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::SetFecDisabledRemotely(
+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 &&
-         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 &&
+         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;
 }
 
 bool WebRtcVideoChannel2::VideoCodecSettings::operator!=(
     const WebRtcVideoChannel2::VideoCodecSettings& other) const {
   return !(*this == other);
 }
 
 std::vector<WebRtcVideoChannel2::VideoCodecSettings>
 WebRtcVideoChannel2::MapCodecs(const std::vector<VideoCodec>& codecs) {
   RTC_DCHECK(!codecs.empty());
 
   std::vector<VideoCodecSettings> video_codecs;
   std::map<int, bool> payload_used;
   std::map<int, VideoCodec::CodecType> payload_codec_type;
   // |rtx_mapping| maps video payload type to rtx payload type.
   std::map<int, int> rtx_mapping;
 
-  webrtc::FecConfig fec_settings;
+  webrtc::UlpfecConfig ulpfec_config;
 
   for (size_t i = 0; i < codecs.size(); ++i) {
     const VideoCodec& in_codec = codecs[i];
     int payload_type = in_codec.id;
 
     if (payload_used[payload_type]) {
       LOG(LS_ERROR) << "Payload type already registered: "
                     << in_codec.ToString();
       return std::vector<VideoCodecSettings>();
     }
     payload_used[payload_type] = true;
     payload_codec_type[payload_type] = in_codec.GetCodecType();
 
     switch (in_codec.GetCodecType()) {
       case VideoCodec::CODEC_RED: {
         // RED payload type, should not have duplicates.
-        RTC_DCHECK(fec_settings.red_payload_type == -1);
-        fec_settings.red_payload_type = in_codec.id;
+        RTC_DCHECK(ulpfec_config.red_payload_type == -1);
+        ulpfec_config.red_payload_type = in_codec.id;
         continue;
       }
 
       case VideoCodec::CODEC_ULPFEC: {
         // ULPFEC payload type, should not have duplicates.
-        RTC_DCHECK(fec_settings.ulpfec_payload_type == -1);
-        fec_settings.ulpfec_payload_type = in_codec.id;
+        RTC_DCHECK(ulpfec_config.ulpfec_payload_type == -1);
+        ulpfec_config.ulpfec_payload_type = in_codec.id;
         continue;
       }
 
       case VideoCodec::CODEC_RTX: {
         int associated_payload_type;
         if (!in_codec.GetParam(kCodecParamAssociatedPayloadType,
                                &associated_payload_type) ||
             !IsValidRtpPayloadType(associated_payload_type)) {
           LOG(LS_ERROR)
               << "RTX codec with invalid or no associated payload type: "
@@ skipping 22 matching lines @@
     if (!payload_used[it->first]) {
       LOG(LS_ERROR) << "RTX mapped to payload not in codec list.";
       return std::vector<VideoCodecSettings>();
     }
     if (payload_codec_type[it->first] != VideoCodec::CODEC_VIDEO &&
         payload_codec_type[it->first] != VideoCodec::CODEC_RED) {
       LOG(LS_ERROR) << "RTX not mapped to regular video codec or RED codec.";
       return std::vector<VideoCodecSettings>();
     }
 
-    if (it->first == fec_settings.red_payload_type) {
-      fec_settings.red_rtx_payload_type = it->second;
+    if (it->first == ulpfec_config.red_payload_type) {
+      ulpfec_config.red_rtx_payload_type = it->second;
     }
   }
 
   for (size_t i = 0; i < video_codecs.size(); ++i) {
-    video_codecs[i].fec = fec_settings;
+    video_codecs[i].ulpfec = ulpfec_config;
     if (rtx_mapping[video_codecs[i].codec.id] != 0 &&
         rtx_mapping[video_codecs[i].codec.id] !=
-            fec_settings.red_payload_type) {
+            ulpfec_config.red_payload_type) {
       video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
     }
   }
 
   return video_codecs;
 }
 
 }  // namespace cricket