- Remove use of VoERTP_RTCP::SetLocalSSRC() for receive streams; recreate them instead.

webrtc/media/engine/webrtcvoiceengine.cc

 /*
  *  Copyright (c) 2004 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 1267 matching lines @@
       bool use_nack,
       const std::string& sync_group,
       const std::vector<webrtc::RtpExtension>& extensions,
       webrtc::Call* call,
       webrtc::Transport* rtcp_send_transport,
       const rtc::scoped_refptr<webrtc::AudioDecoderFactory>& decoder_factory)
       : call_(call), config_() {
     RTC_DCHECK_GE(ch, 0);
     RTC_DCHECK(call);
     config_.rtp.remote_ssrc = remote_ssrc;
-    config_.rtp.local_ssrc = local_ssrc;
     config_.rtcp_send_transport = rtcp_send_transport;
     config_.voe_channel_id = ch;
     config_.sync_group = sync_group;
     config_.decoder_factory = decoder_factory;
-    RecreateAudioReceiveStream(use_transport_cc, use_nack, extensions);
+    RecreateAudioReceiveStream(local_ssrc,
+                               use_transport_cc,
+                               use_nack,
+                               extensions);
   }
 
   ~WebRtcAudioReceiveStream() {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     call_->DestroyAudioReceiveStream(stream_);
   }
 
+  void RecreateAudioReceiveStream(uint32_t local_ssrc) {
+    RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+    RecreateAudioReceiveStream(local_ssrc,
+                               config_.rtp.transport_cc,
+                               config_.rtp.nack.rtp_history_ms != 0,
+                               config_.rtp.extensions);
+  }
+
+  void RecreateAudioReceiveStream(bool use_transport_cc, bool use_nack) {
+    RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+    RecreateAudioReceiveStream(config_.rtp.local_ssrc,
+                               use_transport_cc,
+                               use_nack,
+                               config_.rtp.extensions);
+  }
+
   void RecreateAudioReceiveStream(
       const std::vector<webrtc::RtpExtension>& extensions) {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-    RecreateAudioReceiveStream(config_.rtp.transport_cc,
+    RecreateAudioReceiveStream(config_.rtp.local_ssrc,
+                               config_.rtp.transport_cc,
                                config_.rtp.nack.rtp_history_ms != 0,
                                extensions);
   }
 
-  void RecreateAudioReceiveStream(bool use_transport_cc, bool use_nack) {
-    RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-    RecreateAudioReceiveStream(use_transport_cc,
-                               use_nack,
-                               config_.rtp.extensions);
-  }
-
   webrtc::AudioReceiveStream::Stats GetStats() const {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     RTC_DCHECK(stream_);
     return stream_->GetStats();
   }
 
   int channel() const {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     return config_.voe_channel_id;
   }
 
   void SetRawAudioSink(std::unique_ptr<webrtc::AudioSinkInterface> sink) {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     stream_->SetSink(std::move(sink));
   }
 
  private:
   void RecreateAudioReceiveStream(
+      uint32_t local_ssrc,
       bool use_transport_cc,
       bool use_nack,
       const std::vector<webrtc::RtpExtension>& extensions) {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     if (stream_) {
       call_->DestroyAudioReceiveStream(stream_);
       stream_ = nullptr;
     }
+    config_.rtp.local_ssrc = local_ssrc;
     config_.rtp.transport_cc = use_transport_cc;
     config_.rtp.nack.rtp_history_ms = use_nack ? kNackRtpHistoryMs : 0;
     config_.rtp.extensions = extensions;
     RTC_DCHECK(!stream_);
     stream_ = call_->CreateAudioReceiveStream(config_);
     RTC_CHECK(stream_);
   }
 
   rtc::ThreadChecker worker_thread_checker_;
   webrtc::Call* call_ = nullptr;
@@ skipping 663 matching lines @@
   send_streams_.insert(std::make_pair(ssrc, stream));
 
   // Set the current codecs to be used for the new channel. We need to do this
   // after adding the channel to send_channels_, because of how max bitrate is
   // currently being configured by SetSendCodec().
   if (HasSendCodec() && !SetSendCodecs(channel, stream->rtp_parameters())) {
     RemoveSendStream(ssrc);
     return false;
   }
 
-  // At this point the channel's local SSRC has been updated. If the channel is
-  // the first send channel make sure that all the receive channels are updated
-  // with the same SSRC in order to send receiver reports.
+  // At this point the stream's local SSRC has been updated. If it is the first
+  // send stream, make sure that all the receive streams are updated with the
+  // same SSRC in order to send receiver reports.
   if (send_streams_.size() == 1) {
     receiver_reports_ssrc_ = ssrc;
-    for (const auto& stream : recv_streams_) {
-      int recv_channel = stream.second->channel();
-      if (engine()->voe()->rtp()->SetLocalSSRC(recv_channel, ssrc) != 0) {
-        LOG_RTCERR2(SetLocalSSRC, recv_channel, ssrc);
-        return false;
-      }
+    for (const auto& kv : recv_streams_) {
+      kv.second->RecreateAudioReceiveStream(ssrc);
+      int recv_channel = kv.second->channel();

[pthatcher1, 2016/06/16 19:20:02]

Could you make a comment that this may cause callee receive streams to be
recreated for every call unless we can pass in the the receiver's SSRC in from
the application (which we're supposed to be able to do with ORTC someday)? 

Perhaps make it a TODO to allow applications to set the receiver's RTCP SSRC?

[the sun, 2016/06/16 19:34:21]

Done.

       engine()->voe()->base()->AssociateSendChannel(recv_channel, channel);
       LOG(LS_INFO) << "VoiceEngine channel #" << recv_channel
                    << " is associated with channel #" << channel << ".";
     }
   }
 
   send_streams_[ssrc]->SetSend(send_);
   return true;
 }
 
@@ skipping 548 matching lines @@
     }
   } else {
     LOG(LS_INFO) << "Stopping playout for channel #" << channel;
     engine()->voe()->base()->StopPlayout(channel);
   }
   return true;
 }
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE