Switch voice transport to use Call and Stream instead of VoENetwork.

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 1062 matching lines @@
 }
 
 class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
     : public AudioSource::Sink {
  public:
   WebRtcAudioSendStream(int ch,
                         webrtc::AudioTransport* voe_audio_transport,
                         uint32_t ssrc,
                         const std::string& c_name,
                         const std::vector<webrtc::RtpExtension>& extensions,
-                        webrtc::Call* call)
+                        webrtc::Call* call,
+                        webrtc::Transport* send_transport)
       : voe_audio_transport_(voe_audio_transport),
         call_(call),
-        config_(nullptr),
+        config_(send_transport),
         rtp_parameters_(CreateRtpParametersWithOneEncoding()) {
     RTC_DCHECK_GE(ch, 0);
     // TODO(solenberg): Once we're not using FakeWebRtcVoiceEngine anymore:
     // RTC_DCHECK(voe_audio_transport);
     RTC_DCHECK(call);
     audio_capture_thread_checker_.DetachFromThread();
     config_.rtp.ssrc = ssrc;
     config_.rtp.c_name = c_name;
     config_.voe_channel_id = ch;
     RecreateAudioSendStream(extensions);
@@ skipping 807 matching lines @@
   }
   return true;
 }
 
 int WebRtcVoiceMediaChannel::CreateVoEChannel() {
   int id = engine()->CreateVoEChannel();
   if (id == -1) {
     LOG_RTCERR0(CreateVoEChannel);
     return -1;
   }
-  if (engine()->voe()->network()->RegisterExternalTransport(id, *this) == -1) {
-    LOG_RTCERR2(RegisterExternalTransport, id, this);
-    engine()->voe()->base()->DeleteChannel(id);
-    return -1;
-  }
+
   return id;
 }
 
 bool WebRtcVoiceMediaChannel::DeleteVoEChannel(int channel) {
-  if (engine()->voe()->network()->DeRegisterExternalTransport(channel) == -1) {
-    LOG_RTCERR1(DeRegisterExternalTransport, channel);
-  }
   if (engine()->voe()->base()->DeleteChannel(channel) == -1) {
     LOG_RTCERR1(DeleteChannel, channel);
     return false;
   }
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::AddSendStream(const StreamParams& sp) {
   TRACE_EVENT0("webrtc", "WebRtcVoiceMediaChannel::AddSendStream");
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
@@ skipping 10 matching lines @@
   // Create a new channel for sending audio data.
   int channel = CreateVoEChannel();
   if (channel == -1) {
     return false;
   }
 
   // Save the channel to send_streams_, so that RemoveSendStream() can still
   // delete the channel in case failure happens below.
   webrtc::AudioTransport* audio_transport =
       engine()->voe()->base()->audio_transport();
+
   WebRtcAudioSendStream* stream = new WebRtcAudioSendStream(
-      channel, audio_transport, ssrc, sp.cname, send_rtp_extensions_, call_);
+      channel, audio_transport, ssrc, sp.cname, send_rtp_extensions_, call_,
+      this);
   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;
   }
 
@@ skipping 276 matching lines @@
     LOG(LS_WARNING) << "DTMF event duration " << duration << " out of range.";
     return false;
   }
   return it->second->SendTelephoneEvent(*dtmf_payload_type_, event, duration);
 }
 
 void WebRtcVoiceMediaChannel::OnPacketReceived(
     rtc::CopyOnWriteBuffer* packet, const rtc::PacketTime& packet_time) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
 
+  const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp,
+                                              packet_time.not_before);
+  webrtc::PacketReceiver::DeliveryStatus delivery_result =
+      call_->Receiver()->DeliverPacket(webrtc::MediaType::AUDIO,
+                                       packet->cdata(), packet->size(),
+                                       webrtc_packet_time);
+

[the sun, 2016/04/28 09:15:56]

nit: remove blank line

[mflodman, 2016/04/29 05:54:00]

Done.

+  if (delivery_result != webrtc::PacketReceiver::DELIVERY_UNKNOWN_SSRC) {
+    return;
+  }
+
+  // Create a default receive stream for this unsignalled annd previously not

[the sun, 2016/04/28 09:15:56]

s/annd/and

[mflodman, 2016/04/29 05:54:00]

Done.

+  // received ssrc. If there already is a default receive stream, delete it.

[the sun, 2016/04/28 09:15:56]

Add:
// See: https://bugs.chromium.org/p/webrtc/issues/detail?id=5208

[mflodman, 2016/04/29 05:54:00]

Done.

   uint32_t ssrc = 0;
   if (!GetRtpSsrc(packet->cdata(), packet->size(), &ssrc)) {
     return;
   }
 
-  // If we don't have a default channel, and the SSRC is unknown, create a
-  // default channel.
-  if (default_recv_ssrc_ == -1 && GetReceiveChannelId(ssrc) == -1) {
-    StreamParams sp;
-    sp.ssrcs.push_back(ssrc);
-    LOG(LS_INFO) << "Creating default receive stream for SSRC=" << ssrc << ".";
-    if (!AddRecvStream(sp)) {
-      LOG(LS_WARNING) << "Could not create default receive stream.";
-      return;
-    }
-    default_recv_ssrc_ = ssrc;
-    SetOutputVolume(default_recv_ssrc_, default_recv_volume_);
-    if (default_sink_) {
-      std::unique_ptr<webrtc::AudioSinkInterface> proxy_sink(
-          new ProxySink(default_sink_.get()));
-      SetRawAudioSink(default_recv_ssrc_, std::move(proxy_sink));
-    }
+  if (default_recv_ssrc_ != -1) {

[the sun, 2016/04/28 09:15:56]

Thanks! This logic is actually easier to follow now.

[mflodman, 2016/04/29 05:54:00]

Agree, thanks!

+    LOG(LS_INFO) << "Removing default receive stream with ssrc "
+                 << default_recv_ssrc_;
+    RTC_DCHECK_NE(ssrc, default_recv_ssrc_);
+    RemoveRecvStream(default_recv_ssrc_);
+    default_recv_ssrc_ = -1;
   }
 
-  // Forward packet to Call. If the SSRC is unknown we'll return after this.
-  const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp,
-                                              packet_time.not_before);
-  webrtc::PacketReceiver::DeliveryStatus delivery_result =
-      call_->Receiver()->DeliverPacket(webrtc::MediaType::AUDIO,
-          packet->cdata(), packet->size(), webrtc_packet_time);
-  if (webrtc::PacketReceiver::DELIVERY_OK != delivery_result) {
-    // If the SSRC is unknown here, route it to the default channel, if we have
-    // one. See: https://bugs.chromium.org/p/webrtc/issues/detail?id=5208
-    if (default_recv_ssrc_ == -1) {
-      return;
-    } else {
-      ssrc = default_recv_ssrc_;
-    }
+  StreamParams sp;
+  sp.ssrcs.push_back(ssrc);
+  LOG(LS_INFO) << "Creating default receive stream for SSRC=" << ssrc << ".";
+  if (!AddRecvStream(sp)) {
+    LOG(LS_WARNING) << "Could not create default receive stream.";
+    return;
   }
-
-  // Find the channel to send this packet to. It must exist since webrtc::Call
-  // was able to demux the packet.
-  int channel = GetReceiveChannelId(ssrc);
-  RTC_DCHECK(channel != -1);
-
-  // Pass it off to the decoder.
-  engine()->voe()->network()->ReceivedRTPPacket(
-      channel, packet->cdata(), packet->size(), webrtc_packet_time);
+  default_recv_ssrc_ = ssrc;
+  SetOutputVolume(default_recv_ssrc_, default_recv_volume_);
+  if (default_sink_) {
+    std::unique_ptr<webrtc::AudioSinkInterface> proxy_sink(
+        new ProxySink(default_sink_.get()));
+    SetRawAudioSink(default_recv_ssrc_, std::move(proxy_sink));
+  }
+  delivery_result = call_->Receiver()->DeliverPacket(webrtc::MediaType::AUDIO,
+                                                     packet->cdata(),
+                                                     packet->size(),
+                                                     webrtc_packet_time);
+  RTC_DCHECK_NE(webrtc::PacketReceiver::DELIVERY_UNKNOWN_SSRC, delivery_result);
 }
 
 void WebRtcVoiceMediaChannel::OnRtcpReceived(
     rtc::CopyOnWriteBuffer* packet, const rtc::PacketTime& packet_time) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
 
   // Forward packet to Call as well.
   const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp,
                                               packet_time.not_before);
   call_->Receiver()->DeliverPacket(webrtc::MediaType::AUDIO,
       packet->cdata(), packet->size(), webrtc_packet_time);
-
-  // Sending channels need all RTCP packets with feedback information.
-  // Even sender reports can contain attached report blocks.
-  // Receiving channels need sender reports in order to create
-  // correct receiver reports.
-  int type = 0;
-  if (!GetRtcpType(packet->cdata(), packet->size(), &type)) {
-    LOG(LS_WARNING) << "Failed to parse type from received RTCP packet";
-    return;
-  }
-
-  // If it is a sender report, find the receive channel that is listening.
-  if (type == kRtcpTypeSR) {
-    uint32_t ssrc = 0;
-    if (!GetRtcpSsrc(packet->cdata(), packet->size(), &ssrc)) {
-      return;
-    }
-    int recv_channel_id = GetReceiveChannelId(ssrc);
-    if (recv_channel_id != -1) {
-      engine()->voe()->network()->ReceivedRTCPPacket(
-          recv_channel_id, packet->cdata(), packet->size());
-    }
-  }
-
-  // SR may continue RR and any RR entry may correspond to any one of the send
-  // channels. So all RTCP packets must be forwarded all send channels. VoE
-  // will filter out RR internally.
-  for (const auto& ch : send_streams_) {
-    engine()->voe()->network()->ReceivedRTCPPacket(
-        ch.second->channel(), packet->cdata(), packet->size());
-  }
 }
 
 void WebRtcVoiceMediaChannel::OnNetworkRouteChanged(
     const std::string& transport_name,
     const rtc::NetworkRoute& network_route) {
   call_->OnNetworkRouteChanged(transport_name, network_route);
 }
 
 bool WebRtcVoiceMediaChannel::MuteStream(uint32_t ssrc, bool muted) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
@@ skipping 221 matching lines @@
     }
   } else {
     LOG(LS_INFO) << "Stopping playout for channel #" << channel;
     engine()->voe()->base()->StopPlayout(channel);
   }
   return true;
 }
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE