Use the configured remote ssrc instead of relying on the first received packet.

webrtc/video/rtp_video_stream_receiver.cc

 /*
  *  Copyright (c) 2012 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 109 matching lines @@
   RTC_DCHECK(config_.rtp.rtcp_mode != RtcpMode::kOff)
       << "A stream should not be configured with RTCP disabled. This value is "
          "reserved for internal usage.";
   RTC_DCHECK(config_.rtp.remote_ssrc != 0);
   // TODO(pbos): What's an appropriate local_ssrc for receive-only streams?
   RTC_DCHECK(config_.rtp.local_ssrc != 0);
   RTC_DCHECK(config_.rtp.remote_ssrc != config_.rtp.local_ssrc);
 
   rtp_rtcp_->SetRTCPStatus(config_.rtp.rtcp_mode);
   rtp_rtcp_->SetSSRC(config_.rtp.local_ssrc);
+  rtp_rtcp_->SetRemoteSSRC(config_.rtp.remote_ssrc);
   rtp_rtcp_->SetKeyFrameRequestMethod(kKeyFrameReqPliRtcp);
 
   for (size_t i = 0; i < config_.rtp.extensions.size(); ++i) {
     EnableReceiveRtpHeaderExtension(config_.rtp.extensions[i].uri,
                                     config_.rtp.extensions[i].id);
   }
 
   static const int kMaxPacketAgeToNack = 450;
   const int max_reordering_threshold = (config_.rtp.nack.rtp_history_ms > 0)
                                            ? kMaxPacketAgeToNack
@@ skipping 70 matching lines @@
 bool RtpVideoStreamReceiver::AddReceiveCodec(const VideoCodec& video_codec) {
   int8_t old_pltype = -1;
   if (rtp_payload_registry_.ReceivePayloadType(video_codec, &old_pltype) !=
       -1) {
     rtp_payload_registry_.DeRegisterReceivePayload(old_pltype);
   }
   return rtp_payload_registry_.RegisterReceivePayload(video_codec) == 0;
 }
 
 uint32_t RtpVideoStreamReceiver::GetRemoteSsrc() const {
-  return rtp_receiver_->SSRC();
+  return config_.rtp.remote_ssrc;
 }
 
 int RtpVideoStreamReceiver::GetCsrcs(uint32_t* csrcs) const {
   return rtp_receiver_->CSRCs(csrcs);
 }
 
 RtpReceiver* RtpVideoStreamReceiver::GetRtpReceiver() const {
   return rtp_receiver_.get();
 }
 
@@ skipping 64 matching lines @@
 int32_t RtpVideoStreamReceiver::OnInitializeDecoder(
     const int8_t payload_type,
     const char payload_name[RTP_PAYLOAD_NAME_SIZE],
     const int frequency,
     const size_t channels,
     const uint32_t rate) {
   RTC_NOTREACHED();
   return 0;
 }
 
-void RtpVideoStreamReceiver::OnIncomingSSRCChanged(const uint32_t ssrc) {
-  rtp_rtcp_->SetRemoteSSRC(ssrc);
-}
-
 // This method handles both regular RTP packets and packets recovered
 // via FlexFEC.
 void RtpVideoStreamReceiver::OnRtpPacket(const RtpPacketReceived& packet) {
   {
     rtc::CritScope lock(&receive_cs_);
     if (!receiving_) {
       return;
     }
 
     if (!packet.recovered()) {
@@ skipping 155 matching lines @@
     if (packet_length < header.headerLength)
       return;
     if (packet_length > sizeof(restored_packet_))
       return;
     rtc::CritScope lock(&receive_cs_);
     if (restored_packet_in_use_) {
       LOG(LS_WARNING) << "Multiple RTX headers detected, dropping packet.";
       return;
     }
     if (!rtp_payload_registry_.RestoreOriginalPacket(
-            restored_packet_, packet, &packet_length, rtp_receiver_->SSRC(),
+            restored_packet_, packet, &packet_length, config_.rtp.remote_ssrc,
             header)) {
       LOG(LS_WARNING) << "Incoming RTX packet: Invalid RTP header ssrc: "
                       << header.ssrc << " payload type: "
                       << static_cast<int>(header.payloadType);
       return;
     }
     restored_packet_in_use_ = true;
     OnRecoveredPacket(restored_packet_, packet_length);
     restored_packet_in_use_ = false;
   }
@@ skipping 121 matching lines @@
                                                    bool in_order) const {
   // Retransmissions are handled separately if RTX is enabled.
   if (rtp_payload_registry_.RtxEnabled())
     return false;
   StreamStatistician* statistician =
       rtp_receive_statistics_->GetStatistician(header.ssrc);
   if (!statistician)
     return false;
   // Check if this is a retransmission.
   int64_t min_rtt = 0;
-  rtp_rtcp_->RTT(rtp_receiver_->SSRC(), nullptr, nullptr, &min_rtt, nullptr);
+  rtp_rtcp_->RTT(config_.rtp.remote_ssrc, nullptr, nullptr, &min_rtt, nullptr);
   return !in_order &&
       statistician->IsRetransmitOfOldPacket(header, min_rtt);
 }
 
 void RtpVideoStreamReceiver::UpdateHistograms() {
   FecPacketCounter counter = ulpfec_receiver_->GetPacketCounter();
   if (counter.first_packet_time_ms == -1)
     return;
 
   int64_t elapsed_sec =
@@ skipping 39 matching lines @@
     return;
 
   if (!sprop_decoder.DecodeSprop(sprop_base64_it->second.c_str()))
     return;
 
   tracker_.InsertSpsPpsNalus(sprop_decoder.sps_nalu(),
                              sprop_decoder.pps_nalu());
 }
 
 }  // namespace webrtc