调用堆栈

image.png

VideoChannel::SetLocalContent_w

image.png

  1. bool VideoChannel::SetLocalContent_w(const MediaContentDescription* content,
  2.                                      SdpType type,
  3.                                      std::string* error_desc) {
  4.   TRACE_EVENT0("webrtc", "VideoChannel::SetLocalContent_w");
  5.   RTC_DCHECK_RUN_ON(worker_thread());
  6.   RTC_LOG(LS_INFO) << "Setting local video description for " << ToString();
  8.   RTC_DCHECK(content);
  9.   if (!content) {
  10.     SafeSetError("Can't find video content in local description.", error_desc);
  11.     return false;
  12.   }
  14.   const VideoContentDescription* video = content->as_video();
  16.   if (type == SdpType::kAnswer)
  17.     SetNegotiatedHeaderExtensions_w(video->rtp_header_extensions());
  19.   RtpHeaderExtensions rtp_header_extensions =
  20.       GetFilteredRtpHeaderExtensions(video->rtp_header_extensions());
  21.   UpdateRtpHeaderExtensionMap(rtp_header_extensions);
  22.   media_channel()->SetExtmapAllowMixed(video->extmap_allow_mixed());
  24.   VideoRecvParameters recv_params = last_recv_params_;
  25.   RtpParametersFromMediaDescription(
  26.       video, rtp_header_extensions,
  27.       webrtc::RtpTransceiverDirectionHasRecv(video->direction()), &recv_params);
  29.   VideoSendParameters send_params = last_send_params_;
  31.   bool needs_send_params_update = false;
  32.   if (type == SdpType::kAnswer || type == SdpType::kPrAnswer) {
  33.     for (auto& send_codec : send_params.codecs) {
  34.       auto* recv_codec = FindMatchingCodec(recv_params.codecs, send_codec);
  35.       if (recv_codec) {
  36.         if (!recv_codec->packetization && send_codec.packetization) {
  37.           send_codec.packetization.reset();
  38.           needs_send_params_update = true;
  39.         } else if (recv_codec->packetization != send_codec.packetization) {
  40.           SafeSetError(
  41.               "Failed to set local answer due to invalid codec packetization "
  42.               "specified in m-section with mid='" +
  43.                   content_name() + "'.",
  44.               error_desc);
  45.           return false;
  46.         }
  47.       }
  48.     }
  49.   }
  51.   if (!media_channel()->SetRecvParameters(recv_params)) {
  52.     SafeSetError(
  53.         "Failed to set local video description recv parameters for m-section "
  54.         "with mid='" +
  55.             content_name() + "'.",
  56.         error_desc);
  57.     return false;
  58.   }
  60.   if (webrtc::RtpTransceiverDirectionHasRecv(video->direction())) {
  61.     for (const VideoCodec& codec : video->codecs()) {
  62.       MaybeAddHandledPayloadType(codec.id);
  63.     }
  64.     // Need to re-register the sink to update the handled payload.
  65.     if (!RegisterRtpDemuxerSink_w()) {
  66.       RTC_LOG(LS_ERROR) << "Failed to set up video demuxing for " << ToString();
  67.       return false;
  68.     }
  69.   }
  71.   last_recv_params_ = recv_params;
  73.   if (needs_send_params_update) {
  74.     if (!media_channel()->SetSendParameters(send_params)) {
  75.       SafeSetError("Failed to set send parameters for m-section with mid='" +
  76.                        content_name() + "'.",
  77.                    error_desc);
  78.       return false;
  79.     }
  80.     last_send_params_ = send_params;
  81.   }
  83.   // TODO(pthatcher): Move local streams into VideoSendParameters, and
  84.   // only give it to the media channel once we have a remote
  85.   // description too (without a remote description, we won't be able
  86.   // to send them anyway).
  87.   if (!UpdateLocalStreams_w(video->streams(), type, error_desc)) {
  88.     SafeSetError(
  89.         "Failed to set local video description streams for m-section with "
  90.         "mid='" +
  91.             content_name() + "'.",
  92.         error_desc);
  93.     return false;
  94.   }
  96.   set_local_content_direction(content->direction());
  97.   UpdateMediaSendRecvState_w();
  98.   return true;
  99. }

BaseChannel::UpdateLocalStream_w

image.png

  1. bool BaseChannel::UpdateLocalStreams_w(const std::vector<StreamParams>& streams,
  2.                                        SdpType type,
  3.                                        std::string* error_desc) {
  4.   // In the case of RIDs (where SSRCs are not negotiated), this method will
  5.   // generate an SSRC for each layer in StreamParams. That representation will
  6.   // be stored internally in |local_streams_|.
  7.   // In subsequent offers, the same stream can appear in |streams| again
  8.   // (without the SSRCs), so it should be looked up using RIDs (if available)
  9.   // and then by primary SSRC.
  10.   // In both scenarios, it is safe to assume that the media channel will be
  11.   // created with a StreamParams object with SSRCs. However, it is not safe to
  12.   // assume that |local_streams_| will always have SSRCs as there are scenarios
  13.   // in which niether SSRCs or RIDs are negotiated.
  15.   // Check for streams that have been removed.
  16.   bool ret = true;
  17.   for (const StreamParams& old_stream : local_streams_) {
  18.     if (!old_stream.has_ssrcs() ||
  19.         GetStream(streams, StreamFinder(&old_stream))) {
  20.       continue;
  21.     }
  22.     if (!media_channel()->RemoveSendStream(old_stream.first_ssrc())) {
  23.       rtc::StringBuilder desc;
  24.       desc << "Failed to remove send stream with ssrc "
  25.            << old_stream.first_ssrc() << " from m-section with mid='"
  26.            << content_name() << "'.";
  27.       SafeSetError(desc.str(), error_desc);
  28.       ret = false;
  29.     }
  30.   }
  31.   // Check for new streams.
  32.   std::vector<StreamParams> all_streams;
  33.   for (const StreamParams& stream : streams) {
  34.     StreamParams* existing = GetStream(local_streams_, StreamFinder(&stream));
  35.     if (existing) {
  36.       // Parameters cannot change for an existing stream.
  37.       all_streams.push_back(*existing);
  38.       continue;
  39.     }
  41.     all_streams.push_back(stream);
  42.     StreamParams& new_stream = all_streams.back();
  44.     if (!new_stream.has_ssrcs() && !new_stream.has_rids()) {
  45.       continue;
  46.     }
  48.     RTC_DCHECK(new_stream.has_ssrcs() || new_stream.has_rids());
  49.     if (new_stream.has_ssrcs() && new_stream.has_rids()) {
  50.       rtc::StringBuilder desc;
  51.       desc << "Failed to add send stream: " << new_stream.first_ssrc()
  52.            << " into m-section with mid='" << content_name()
  53.            << "'. Stream has both SSRCs and RIDs.";
  54.       SafeSetError(desc.str(), error_desc);
  55.       ret = false;
  56.       continue;
  57.     }
  59.     // At this point we use the legacy simulcast group in StreamParams to
  60.     // indicate that we want multiple layers to the media channel.
  61.     if (!new_stream.has_ssrcs()) {
  62.       // TODO(bugs.webrtc.org/10250): Indicate if flex is desired here.
  63.       new_stream.GenerateSsrcs(new_stream.rids().size(), /* rtx = */ true,
  64.                                /* flex_fec = */ false, ssrc_generator_);
  65.     }
  67.     if (media_channel()->AddSendStream(new_stream)) {
  68.       RTC_LOG(LS_INFO) << "Add send stream ssrc: " << new_stream.ssrcs[0]
  69.                        << " into " << ToString();
  70.     } else {
  71.       rtc::StringBuilder desc;
  72.       desc << "Failed to add send stream ssrc: " << new_stream.first_ssrc()
  73.            << " into m-section with mid='" << content_name() << "'";
  74.       SafeSetError(desc.str(), error_desc);
  75.       ret = false;
  76.     }
  77.   }
  78.   local_streams_ = all_streams;
  79.   return ret;
  80. }

WebRtcVideoChannel::AddSendStream

image.png

  1. bool WebRtcVideoChannel::AddSendStream(const StreamParams& sp) {
  2.   RTC_DCHECK_RUN_ON(&thread_checker_);
  3.   RTC_LOG(LS_INFO) << "AddSendStream: " << sp.ToString();
  4.   if (!ValidateStreamParams(sp))
  5.     return false;
  7.   if (!ValidateSendSsrcAvailability(sp))
  8.     return false;
  10.   for (uint32_t used_ssrc : sp.ssrcs)
  11.     send_ssrcs_.insert(used_ssrc);
  13.   webrtc::VideoSendStream::Config config(this);
  15.   for (const RidDescription& rid : sp.rids()) {
  16.     config.rtp.rids.push_back(rid.rid);
  17.   }
  19.   config.suspend_below_min_bitrate = video_config_.suspend_below_min_bitrate;
  20.   config.periodic_alr_bandwidth_probing =
  21.       video_config_.periodic_alr_bandwidth_probing;
  22.   config.encoder_settings.experiment_cpu_load_estimator =
  23.       video_config_.experiment_cpu_load_estimator;
  24.   config.encoder_settings.encoder_factory = encoder_factory_;
  25.   config.encoder_settings.bitrate_allocator_factory =
  26.       bitrate_allocator_factory_;
  27.   config.encoder_settings.encoder_switch_request_callback = this;
  28.   config.crypto_options = crypto_options_;
  29.   config.rtp.extmap_allow_mixed = ExtmapAllowMixed();
  30.   config.rtcp_report_interval_ms = video_config_.rtcp_report_interval_ms;
  32.   WebRtcVideoSendStream* stream = new WebRtcVideoSendStream(
  33.       call_, sp, std::move(config), default_send_options_,
  34.       video_config_.enable_cpu_adaptation, bitrate_config_.max_bitrate_bps,
  35.       send_codec_, send_rtp_extensions_, send_params_);
  37.   uint32_t ssrc = sp.first_ssrc();
  38.   RTC_DCHECK(ssrc != 0);
  39.   send_streams_[ssrc] = stream;
  41.   if (rtcp_receiver_report_ssrc_ == kDefaultRtcpReceiverReportSsrc) {
  42.     rtcp_receiver_report_ssrc_ = ssrc;
  43.     RTC_LOG(LS_INFO)
  44.         << "SetLocalSsrc on all the receive streams because we added "
  45.            "a send stream.";
  46.     for (auto& kv : receive_streams_)
  47.       kv.second->SetLocalSsrc(ssrc);
  48.   }
  49.   if (sending_) {
  50.     stream->SetSend(true);
  51.   }
  53.   return true;
  54. }