自己的webrtc代码版本和老师的不一样。

调用栈image.png

Channel中的SetRecvParameters

image.png
第一步，获取解码器变化的参数，然后获取最优解码器参数；
第二步，保存媒体协商时的接收到的解码器参数。

  1. bool WebRtcVideoChannel::SetRecvParameters(const VideoRecvParameters& params) {
  2.   RTC_DCHECK_RUN_ON(&thread_checker_);
  3.   TRACE_EVENT0("webrtc", "WebRtcVideoChannel::SetRecvParameters");
  4.   RTC_DLOG(LS_INFO) << "SetRecvParameters: " << params.ToString();
  5.   ChangedRecvParameters changed_params;
  6.   if (!GetChangedRecvParameters(params, &changed_params)) {
  7.     return false;
  8.   }
  9.   if (changed_params.flexfec_payload_type) {
  10.     RTC_DLOG(LS_INFO) << "Changing FlexFEC payload type (recv) from "
  11.                       << recv_flexfec_payload_type_ << " to "
  12.                       << *changed_params.flexfec_payload_type;
  13.     recv_flexfec_payload_type_ = *changed_params.flexfec_payload_type;
  14.   }
  15.   if (changed_params.rtp_header_extensions) {
  16.     recv_rtp_extensions_ = *changed_params.rtp_header_extensions;
  17.   }
  18.   if (changed_params.codec_settings) {
  19.     RTC_DLOG(LS_INFO) << "Changing recv codecs from "
  20.                       << CodecSettingsVectorToString(recv_codecs_) << " to "
  21.                       << CodecSettingsVectorToString(
  22.                              *changed_params.codec_settings);
  23.     recv_codecs_ = *changed_params.codec_settings;
  24.   }
  26.   for (auto& kv : receive_streams_) {
  27.     kv.second->SetRecvParameters(changed_params);
  28.   }
  29.   recv_params_ = params;
  30.   return true;
  31. }

WebRtcVideoChannel::GetChangedRecvParameters

image.png
就是通过对比接收到的解码器信息，和创建解码器时的信息，获取改变的参数，这里忽略flexfec的参数变化。

  1. bool WebRtcVideoChannel::GetChangedRecvParameters(
  2.     const VideoRecvParameters& params,
  3.     ChangedRecvParameters* changed_params) const {
  4.   if (!ValidateCodecFormats(params.codecs) ||
  5.       !ValidateRtpExtensions(params.extensions)) {
  6.     return false;
  7.   }
  9.   // Handle receive codecs.
  10.   const std::vector<VideoCodecSettings> mapped_codecs =
  11.       MapCodecs(params.codecs);
  12.   if (mapped_codecs.empty()) {
  13.     RTC_LOG(LS_ERROR)
  14.         << "GetChangedRecvParameters called without any video codecs.";
  15.     return false;
  16.   }
  18.   // Verify that every mapped codec is supported locally.
  19.   if (params.is_stream_active) {
  20.     const std::vector<VideoCodec> local_supported_codecs =
  21.         GetPayloadTypesAndDefaultCodecs(decoder_factory_,
  22.                                         /*is_decoder_factory=*/true,
  23.                                         call_->trials());
  24.     for (const VideoCodecSettings& mapped_codec : mapped_codecs) {
  25.       if (!FindMatchingCodec(local_supported_codecs, mapped_codec.codec)) {
  26.         RTC_LOG(LS_ERROR)
  27.             << "GetChangedRecvParameters called with unsupported video codec: "
  28.             << mapped_codec.codec.ToString();
  29.         return false;
  30.       }
  31.     }
  32.   }
  34.   if (NonFlexfecReceiveCodecsHaveChanged(recv_codecs_, mapped_codecs)) {
  35.     changed_params->codec_settings =
  36.         absl::optional<std::vector<VideoCodecSettings>>(mapped_codecs);
  37.   }
  39.   // Handle RTP header extensions.
  40.   std::vector<webrtc::RtpExtension> filtered_extensions = FilterRtpExtensions(
  41.       params.extensions, webrtc::RtpExtension::IsSupportedForVideo, false,
  42.       call_->trials());
  43.   if (filtered_extensions != recv_rtp_extensions_) {
  44.     changed_params->rtp_header_extensions =
  45.         absl::optional<std::vector<webrtc::RtpExtension>>(filtered_extensions);
  46.   }
  48.   int flexfec_payload_type = mapped_codecs.front().flexfec_payload_type;
  49.   if (flexfec_payload_type != recv_flexfec_payload_type_) {
  50.     changed_params->flexfec_payload_type = flexfec_payload_type;
  51.   }
  53.   return true;
  54. }

WebRtcVideoChannel中的recvcodecs参数

image.png
这里是指构造WebRtcVideoChannel对象时，它的recvcodecs参数是从encoderfactory编码工厂中获取到的，这时候获取的编码的payloadtype值还是不确定的。
协商后的这个值，是从MediaSessionDescriptionFactory对象后获得的，是最终确定的编码参数值。

  1. WebRtcVideoChannel::WebRtcVideoChannel(
  2.     webrtc::Call* call,
  3.     const MediaConfig& config,
  4.     const VideoOptions& options,
  5.     const webrtc::CryptoOptions& crypto_options,
  6.     webrtc::VideoEncoderFactory* encoder_factory,
  7.     webrtc::VideoDecoderFactory* decoder_factory,
  8.     webrtc::VideoBitrateAllocatorFactory* bitrate_allocator_factory)
  9.     : VideoMediaChannel(config),
  10.       worker_thread_(rtc::Thread::Current()),
  11.       call_(call),
  12.       unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
  13.       video_config_(config.video),
  14.       encoder_factory_(encoder_factory),
  15.       decoder_factory_(decoder_factory),
  16.       bitrate_allocator_factory_(bitrate_allocator_factory),
  17.       default_send_options_(options),
  18.       last_stats_log_ms_(-1),
  19.       discard_unknown_ssrc_packets_(
  20.           IsEnabled(call_->trials(),
  21.                     "WebRTC-Video-DiscardPacketsWithUnknownSsrc")),
  22.       crypto_options_(crypto_options),
  23.       unknown_ssrc_packet_buffer_(
  24.           IsEnabled(call_->trials(),
  25.                     "WebRTC-Video-BufferPacketsWithUnknownSsrc")
  26.               ? new UnhandledPacketsBuffer()
  27.               : nullptr) {
  28.   RTC_DCHECK_RUN_ON(&thread_checker_);
  29.   network_thread_checker_.Detach();
  31.   rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
  32.   sending_ = false;
  33.   recv_codecs_ = MapCodecs(GetPayloadTypesAndDefaultCodecs(
  34.       decoder_factory_, /*is_decoder_factory=*/true, call_->trials()));
  35.   recv_flexfec_payload_type_ =
  36.       recv_codecs_.empty() ? 0 : recv_codecs_.front().flexfec_payload_type;
  37. }

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. }

image.png