SDP中支持FEC

image.png

AssignPayloadTypesAndDefaultCodecs

设置本地SDP中支持RedFEC和UlpFEC
image.png
当前自己使用的webrtc版本的是 GetPayloadTypesAndDefaultCodecs

  1. // This function will assign dynamic payload types (in the range [96, 127]) to
  2. // the input codecs, and also add ULPFEC, RED, FlexFEC, and associated RTX
  3. // codecs for recognized codecs (VP8, VP9, H264, and RED). It will also add
  4. // default feedback params to the codecs.
  5. // is_decoder_factory is needed to keep track of the implict assumption that any
  6. // H264 decoder also supports constrained base line profile.
  7. // Also, is_decoder_factory is used to decide whether FlexFEC video format
  8. // should be advertised as supported.
  9. // TODO(kron): Perhaps it is better to move the implicit knowledge to the place
  10. // where codecs are negotiated.
  11. template <class T>
  12. std::vector<VideoCodec> GetPayloadTypesAndDefaultCodecs(
  13.     const T* factory,
  14.     bool is_decoder_factory,
  15.     const webrtc::WebRtcKeyValueConfig& trials) {
  16.   if (!factory) {
  17.     return {};
  18.   }
  20.   std::vector<webrtc::SdpVideoFormat> supported_formats =
  21.       factory->GetSupportedFormats();
  22.   if (is_decoder_factory) {
  23.     AddH264ConstrainedBaselineProfileToSupportedFormats(&supported_formats);
  24.   }
  26.   if (supported_formats.empty())
  27.     return std::vector<VideoCodec>();
  29.   // Due to interoperability issues with old Chrome/WebRTC versions only use
  30.   // the lower range for new codecs.
  31.   static const int kFirstDynamicPayloadTypeLowerRange = 35;
  32.   static const int kLastDynamicPayloadTypeLowerRange = 65;
  34.   static const int kFirstDynamicPayloadTypeUpperRange = 96;
  35.   static const int kLastDynamicPayloadTypeUpperRange = 127;
  36.   int payload_type_upper = kFirstDynamicPayloadTypeUpperRange;
  37.   int payload_type_lower = kFirstDynamicPayloadTypeLowerRange;
  39.   supported_formats.push_back(webrtc::SdpVideoFormat(kRedCodecName));
  40.   supported_formats.push_back(webrtc::SdpVideoFormat(kUlpfecCodecName));
  42.   // flexfec-03 is supported as
  43.   // - receive codec unless WebRTC-FlexFEC-03-Advertised is disabled
  44.   // - send codec if WebRTC-FlexFEC-03-Advertised is enabled
  45.   if ((is_decoder_factory &&
  46.        !IsDisabled(trials, "WebRTC-FlexFEC-03-Advertised")) ||
  47.       (!is_decoder_factory &&
  48.        IsEnabled(trials, "WebRTC-FlexFEC-03-Advertised"))) {
  49.     webrtc::SdpVideoFormat flexfec_format(kFlexfecCodecName);
  50.     // This value is currently arbitrarily set to 10 seconds. (The unit
  51.     // is microseconds.) This parameter MUST be present in the SDP, but
  52.     // we never use the actual value anywhere in our code however.
  53.     // TODO(brandtr): Consider honouring this value in the sender and receiver.
  54.     flexfec_format.parameters = {{kFlexfecFmtpRepairWindow, "10000000"}};
  55.     supported_formats.push_back(flexfec_format);
  56.   }
  58.   std::vector<VideoCodec> output_codecs;
  59.   for (const webrtc::SdpVideoFormat& format : supported_formats) {
  60.     VideoCodec codec(format);
  61.     bool isCodecValidForLowerRange =
  62.         absl::EqualsIgnoreCase(codec.name, kFlexfecCodecName) ||
  63.         absl::EqualsIgnoreCase(codec.name, kAv1CodecName);
  64.     if (!isCodecValidForLowerRange) {
  65.       codec.id = payload_type_upper++;
  66.     } else {
  67.       codec.id = payload_type_lower++;
  68.     }
  69.     AddDefaultFeedbackParams(&codec, trials);
  70.     output_codecs.push_back(codec);
  72.     if (payload_type_upper > kLastDynamicPayloadTypeUpperRange) {
  73.       RTC_LOG(LS_ERROR)
  74.           << "Out of dynamic payload types [96,127], skipping the rest.";
  75.       // TODO(https://bugs.chromium.org/p/webrtc/issues/detail?id=12194):
  76.       // continue in lower range.
  77.       break;
  78.     }
  79.     if (payload_type_lower > kLastDynamicPayloadTypeLowerRange) {
  80.       // TODO(https://bugs.chromium.org/p/webrtc/issues/detail?id=12248):
  81.       // return an error.
  82.       RTC_LOG(LS_ERROR)
  83.           << "Out of dynamic payload types [35,65], skipping the rest.";
  84.       break;
  85.     }
  87.     // Add associated RTX codec for non-FEC codecs.
  88.     if (!absl::EqualsIgnoreCase(codec.name, kUlpfecCodecName) &&
  89.         !absl::EqualsIgnoreCase(codec.name, kFlexfecCodecName)) {
  90.       if (!isCodecValidForLowerRange) {
  91.         output_codecs.push_back(
  92.             VideoCodec::CreateRtxCodec(payload_type_upper++, codec.id));
  93.       } else {
  94.         output_codecs.push_back(
  95.             VideoCodec::CreateRtxCodec(payload_type_lower++, codec.id));
  96.       }
  98.       if (payload_type_upper > kLastDynamicPayloadTypeUpperRange) {
  99.         RTC_LOG(LS_ERROR)
  100.             << "Out of dynamic payload types [96,127], skipping rtx.";
  101.         // TODO(https://bugs.chromium.org/p/webrtc/issues/detail?id=12194):
  102.         // continue in lower range.
  103.         break;
  104.       }
  105.       if (payload_type_lower > kLastDynamicPayloadTypeLowerRange) {
  106.         // TODO(https://bugs.chromium.org/p/webrtc/issues/detail?id=12248):
  107.         // return an error.
  108.         RTC_LOG(LS_ERROR)
  109.             << "Out of dynamic payload types [35,65], skipping rtx.";
  110.         break;
  111.       }
  112.     }
  113.   }
  114.   return output_codecs;
  115. }

创建FEC控制器

image.png
H:\webrtc-20210315\webrtc-20210315\webrtc\webrtc-checkout\src\modules\video_coding\fec_controller_default.h
FecControllerDefault 函数: 计算和维护fec所有使用的参数

创建FEC对象

image.png
H:\webrtc-20210315\webrtc-20210315\webrtc\webrtc-checkout\src\modules\rtp_rtcp\source\forward_error_correction.h

  1. std::unique_ptr<ForwardErrorCorrection> ForwardErrorCorrection::CreateUlpfec( 
  2.     uint32_t ssrc)
  4. std::unique_ptr<ForwardErrorCorrection> ForwardErrorCorrection::CreateFlexfec(
  5.     uint32_t ssrc,
  6.     uint32_t protected_media_ssrc)

MaybeCreateFecGenerator 函数判断创建redfec或者ulpfec

  1. // TODO(brandtr): Update this function when we support multistream protection.
  2. std::unique_ptr<VideoFecGenerator> MaybeCreateFecGenerator(
  3.     Clock* clock,
  4.     const RtpConfig& rtp,
  5.     const std::map<uint32_t, RtpState>& suspended_ssrcs,
  6.     int simulcast_index,
  7.     const WebRtcKeyValueConfig& trials) {
  8.   // If flexfec is configured that takes priority.
  9.   if (rtp.flexfec.payload_type >= 0) {
  10.     RTC_DCHECK_GE(rtp.flexfec.payload_type, 0);
  11.     RTC_DCHECK_LE(rtp.flexfec.payload_type, 127);
  12.     if (rtp.flexfec.ssrc == 0) {
  13.       RTC_LOG(LS_WARNING) << "FlexFEC is enabled, but no FlexFEC SSRC given. "
  14.                              "Therefore disabling FlexFEC.";
  15.       return nullptr;
  16.     }
  17.     if (rtp.flexfec.protected_media_ssrcs.empty()) {
  18.       RTC_LOG(LS_WARNING)
  19.           << "FlexFEC is enabled, but no protected media SSRC given. "
  20.              "Therefore disabling FlexFEC.";
  21.       return nullptr;
  22.     }
  24.     if (rtp.flexfec.protected_media_ssrcs.size() > 1) {
  25.       RTC_LOG(LS_WARNING)
  26.           << "The supplied FlexfecConfig contained multiple protected "
  27.              "media streams, but our implementation currently only "
  28.              "supports protecting a single media stream. "
  29.              "To avoid confusion, disabling FlexFEC completely.";
  30.       return nullptr;
  31.     }
  33.     if (absl::c_find(rtp.flexfec.protected_media_ssrcs,
  34.                      rtp.ssrcs[simulcast_index]) ==
  35.         rtp.flexfec.protected_media_ssrcs.end()) {
  36.       // Media SSRC not among flexfec protected SSRCs.
  37.       return nullptr;
  38.     }
  40.     const RtpState* rtp_state = nullptr;
  41.     auto it = suspended_ssrcs.find(rtp.flexfec.ssrc);
  42.     if (it != suspended_ssrcs.end()) {
  43.       rtp_state = &it->second;
  44.     }
  46.     RTC_DCHECK_EQ(1U, rtp.flexfec.protected_media_ssrcs.size());
  47.     return std::make_unique<FlexfecSender>(
  48.         rtp.flexfec.payload_type, rtp.flexfec.ssrc,
  49.         rtp.flexfec.protected_media_ssrcs[0], rtp.mid, rtp.extensions,
  50.         RTPSender::FecExtensionSizes(), rtp_state, clock);
  51.   } else if (rtp.ulpfec.red_payload_type >= 0 &&
  52.              rtp.ulpfec.ulpfec_payload_type >= 0 &&
  53.              !ShouldDisableRedAndUlpfec(/*flexfec_enabled=*/false, rtp,
  54.                                         trials)) {
  55.     // Flexfec not configured, but ulpfec is and is not disabled.
  56.     return std::make_unique<UlpfecGenerator>(
  57.         rtp.ulpfec.red_payload_type, rtp.ulpfec.ulpfec_payload_type, clock);
  58.   }
  60.   // Not a single FEC is given.
  61.   return nullptr;
  62. }

几个对象之间的关系

image.png