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

webrtc/audio/audio_receive_stream.cc

 /*
  *  Copyright (c) 2015 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 132 matching lines @@
 
 void AudioReceiveStream::SignalNetworkState(NetworkState state) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 bool AudioReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) {
   // TODO(solenberg): Tests call this function on a network thread, libjingle
   // calls on the worker thread. We should move towards always using a network
   // thread. Then this check can be enabled.
   // RTC_DCHECK(!thread_checker_.CalledOnValidThread());
-  return false;
+  return channel_proxy_->ReceivedRTCPPacket(static_cast<const uint8_t*>(packet),

[the sun, 2016/04/22 12:40:31]

Looks like this cast is not needed anymore?

[mflodman, 2016/04/27 13:42:17]

Doh!

+                                            length) == 0;
 }
 
 bool AudioReceiveStream::DeliverRtp(const uint8_t* packet,
                                     size_t length,
                                     const PacketTime& packet_time) {
   // TODO(solenberg): Tests call this function on a network thread, libjingle
   // calls on the worker thread. We should move towards always using a network
   // thread. Then this check can be enabled.
   // RTC_DCHECK(!thread_checker_.CalledOnValidThread());
   RTPHeader header;
   if (!rtp_header_parser_->Parse(packet, length, &header)) {
     return false;
   }
 
   // Only forward if the parsed header has one of the headers necessary for
   // bandwidth estimation. RTP timestamps has different rates for audio and
   // video and shouldn't be mixed.
   if (remote_bitrate_estimator_ &&
       header.extension.hasTransportSequenceNumber) {
     int64_t arrival_time_ms = TickTime::MillisecondTimestamp();
     if (packet_time.timestamp >= 0)
       arrival_time_ms = (packet_time.timestamp + 500) / 1000;
     size_t payload_size = length - header.headerLength;
     remote_bitrate_estimator_->IncomingPacket(arrival_time_ms, payload_size,

[the sun, 2016/04/22 12:40:31]

stefan: is it still appropriate to fork packets off for BWE here or should that
happen some other way (e.g. through the Channel's RtpRtcpModule)?

[mflodman, 2016/04/27 13:42:17]

For video this is done in ViEReciever, that we're refactoring and this might end
up in VideoReceiveStream too. So I'd prefer to keep it here at lest for now
until this has been settled.

ok?

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

ok, just wanted to make sure we won't magically send packets twice to the RBE or
something.

[stefan-webrtc, 2016/04/28 09:27:48]

Should be fine, and I also prefer it being done this way.

                                               header, false);
   }
-  return true;
+
+  return channel_proxy_->ReceivedRTPPacket(packet, length, packet_time);

[the sun, 2016/04/22 12:40:31]

VoE::ReceivedRTPPacket() will:
  if ((length < 12) || (length > 1292)) {
    return -1;
  }
but it seems to me that we shouldn't make such a decision at that level, and I
can't find anything in the code that looks like it will break if the packet is <
12 bytes or > 1292 bytes. However, we should be aware that were potentially
opening up for abuse.

[mflodman, 2016/04/27 13:42:17]

Channel::ReceivedRTPPacket is calling rtp_header_parser_->Parse(received_packet,
length, &header) right away and this will catch length < 12.

I can add back a check for too large packets if you think this is needed for
audio, I'm not very familiar with the potential risks there.

In that case, I can add that check in Channel::ReceivedRTPPacket rather than
here.

WDYT?

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

Yes, please add the check in Channel::ReceivedRTPPacket().

 }
 
 webrtc::AudioReceiveStream::Stats AudioReceiveStream::GetStats() const {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   webrtc::AudioReceiveStream::Stats stats;
   stats.remote_ssrc = config_.rtp.remote_ssrc;
   ScopedVoEInterface<VoECodec> codec(voice_engine());
 
   webrtc::CallStatistics call_stats = channel_proxy_->GetRTCPStatistics();
   webrtc::CodecInst codec_inst = {0};
@@ skipping 49 matching lines @@
 
 VoiceEngine* AudioReceiveStream::voice_engine() const {
   internal::AudioState* audio_state =
       static_cast<internal::AudioState*>(audio_state_.get());
   VoiceEngine* voice_engine = audio_state->voice_engine();
   RTC_DCHECK(voice_engine);
   return voice_engine;
 }
 }  // namespace internal
 }  // namespace webrtc