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

webrtc/call/call_perf_tests.cc

 /*
  *  Copyright (c) 2013 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 131 matching lines @@
 };
 
 void CallPerfTest::TestAudioVideoSync(FecMode fec,
                                       CreateOrder create_first,
                                       float video_ntp_speed,
                                       float video_rtp_speed,
                                       float audio_rtp_speed) {
   const char* kSyncGroup = "av_sync";
   const uint32_t kAudioSendSsrc = 1234;
   const uint32_t kAudioRecvSsrc = 5678;
-  class AudioPacketReceiver : public PacketReceiver {
-   public:
-    AudioPacketReceiver(int channel, VoENetwork* voe_network)
-        : channel_(channel),
-          voe_network_(voe_network),
-          parser_(RtpHeaderParser::Create()) {}
-    DeliveryStatus DeliverPacket(MediaType media_type,
-                                 const uint8_t* packet,
-                                 size_t length,
-                                 const PacketTime& packet_time) override {
-      EXPECT_TRUE(media_type == MediaType::ANY ||
-                  media_type == MediaType::AUDIO);
-      int ret;
-      if (parser_->IsRtcp(packet, length)) {
-        ret = voe_network_->ReceivedRTCPPacket(channel_, packet, length);
-      } else {
-        ret = voe_network_->ReceivedRTPPacket(channel_, packet, length,
-                                              PacketTime());
-      }
-      return ret == 0 ? DELIVERY_OK : DELIVERY_PACKET_ERROR;
-    }
-
-   private:
-    int channel_;
-    VoENetwork* voe_network_;
-    std::unique_ptr<RtpHeaderParser> parser_;
-  };
 
   test::ClearHistograms();
   VoiceEngine* voice_engine = VoiceEngine::Create();
   VoEBase* voe_base = VoEBase::GetInterface(voice_engine);
   VoECodec* voe_codec = VoECodec::GetInterface(voice_engine);
   VoENetwork* voe_network = VoENetwork::GetInterface(voice_engine);

[stefan-webrtc, 2016/04/22 09:16:19]

No longer used.

If you feel like it, it should be straightforward to build this test upon
EndToEndTest now, which uses CallTest which sets up legacy voice engine objects,
calls, send/receive streams and fake devices for you.

[mflodman, 2016/04/22 09:41:48]

Removed.

I'd prefer to followup with the refactoring to avoid more changes, if you're ok
with that?

[stefan-webrtc, 2016/04/22 10:35:04]

Sure, no problem.

   const std::string audio_filename =
       test::ResourcePath("voice_engine/audio_long16", "pcm");
   ASSERT_STRNE("", audio_filename.c_str());
   FakeAudioDevice fake_audio_device(Clock::GetRealTimeClock(), audio_filename,
                                     audio_rtp_speed);
   EXPECT_EQ(0, voe_base->Init(&fake_audio_device, nullptr));
   Config voe_config;
   voe_config.Set<VoicePacing>(new VoicePacing(true));
   int send_channel_id = voe_base->CreateChannel(voe_config);
   int recv_channel_id = voe_base->CreateChannel();
 
   AudioState::Config send_audio_state_config;
   send_audio_state_config.voice_engine = voice_engine;
   Call::Config sender_config;
   sender_config.audio_state = AudioState::Create(send_audio_state_config);
   Call::Config receiver_config;
   receiver_config.audio_state = sender_config.audio_state;
   CreateCalls(sender_config, receiver_config);
 
-  AudioPacketReceiver voe_send_packet_receiver(send_channel_id, voe_network);
-  AudioPacketReceiver voe_recv_packet_receiver(recv_channel_id, voe_network);
 
   VideoRtcpAndSyncObserver observer(Clock::GetRealTimeClock());
 
-  FakeNetworkPipe::Config net_config;
-  net_config.queue_delay_ms = 500;
-  net_config.loss_percent = 5;
-  test::PacketTransport audio_send_transport(
-      nullptr, &observer, test::PacketTransport::kSender, net_config);
-  audio_send_transport.SetReceiver(&voe_recv_packet_receiver);
-  test::PacketTransport audio_receive_transport(
-      nullptr, &observer, test::PacketTransport::kReceiver, net_config);
-  audio_receive_transport.SetReceiver(&voe_send_packet_receiver);
+  // Helper class to ensure we deliver correct media_type to the receiving call.
+  class MediaTypePacketReceiver : public PacketReceiver {
+   public:
+    MediaTypePacketReceiver(PacketReceiver* packet_receiver,
+                            MediaType media_type)
+        : packet_receiver_(packet_receiver), media_type_(media_type) {}
 
-  internal::TransportAdapter send_transport_adapter(&audio_send_transport);
-  send_transport_adapter.Enable();
-  EXPECT_EQ(0, voe_network->RegisterExternalTransport(send_channel_id,
-                                                      send_transport_adapter));
+    DeliveryStatus DeliverPacket(MediaType media_type,
+                                 const uint8_t* packet,
+                                 size_t length,
+                                 const PacketTime& packet_time) override {
+      return packet_receiver_->DeliverPacket(media_type_, packet, length,
+                                             packet_time);
+    }
+   private:
+    PacketReceiver* packet_receiver_;
+    const MediaType media_type_;
+  };
 
-  internal::TransportAdapter recv_transport_adapter(&audio_receive_transport);
-  recv_transport_adapter.Enable();
-  EXPECT_EQ(0, voe_network->RegisterExternalTransport(recv_channel_id,
-                                                      recv_transport_adapter));
+  FakeNetworkPipe::Config audio_net_config;
+  audio_net_config.queue_delay_ms = 500;
+  audio_net_config.loss_percent = 5;
+  test::PacketTransport audio_send_transport(sender_call_.get(), &observer,
+                                             test::PacketTransport::kSender,
+                                             audio_net_config);
+  MediaTypePacketReceiver audio_receiver(receiver_call_->Receiver(),
+                                         MediaType::AUDIO);
+  audio_send_transport.SetReceiver(&audio_receiver);
 
-  test::PacketTransport sync_send_transport(sender_call_.get(), &observer,
-                                            test::PacketTransport::kSender,
-                                            FakeNetworkPipe::Config());
-  sync_send_transport.SetReceiver(receiver_call_->Receiver());
-  test::PacketTransport sync_receive_transport(receiver_call_.get(), &observer,
-                                               test::PacketTransport::kReceiver,
-                                               FakeNetworkPipe::Config());
-  sync_receive_transport.SetReceiver(sender_call_->Receiver());
+  test::PacketTransport video_send_transport(sender_call_.get(), &observer,
+                                             test::PacketTransport::kSender,
+                                             FakeNetworkPipe::Config());
+  MediaTypePacketReceiver video_receiver(receiver_call_->Receiver(),
+                                         MediaType::VIDEO);
+  video_send_transport.SetReceiver(&video_receiver);
+
+  test::PacketTransport receive_transport(
+      receiver_call_.get(), &observer, test::PacketTransport::kReceiver,
+      FakeNetworkPipe::Config());
+  receive_transport.SetReceiver(sender_call_->Receiver());
 
   test::FakeDecoder fake_decoder;
 
-  CreateSendConfig(1, 0, &sync_send_transport);
-  CreateMatchingReceiveConfigs(&sync_receive_transport);
+  CreateSendConfig(1, 0, &video_send_transport);
+  CreateMatchingReceiveConfigs(&receive_transport);
 
   AudioSendStream::Config audio_send_config(&audio_send_transport);

[stefan-webrtc, 2016/04/22 09:16:19]

I'm not sure this actually works in practice. All packets go to the same pacer
which will send them out on the same transport. Have you verified that the
streams aren't in sync already at the beginning?

[mflodman, 2016/04/22 09:41:48]

If that is the case, our API is wrong if we can set one transport per send
stream.

The test starts by printing:
"RESULT stream_offset: synchronization= -553 ms"

to slowly go down to:
"RESULT stream_offset: synchronization= -14 ms"

I'll look at the code though.

[stefan-webrtc, 2016/04/22 10:35:04]

You're right, it does go over separate transports, my mistake.

   audio_send_config.voe_channel_id = send_channel_id;
   audio_send_config.rtp.ssrc = kAudioSendSsrc;
   AudioSendStream* audio_send_stream =
       sender_call_->CreateAudioSendStream(audio_send_config);
 
   CodecInst isac = {103, "ISAC", 16000, 480, 1, 32000};
   EXPECT_EQ(0, voe_codec->SetSendCodec(send_channel_id, isac));
 
   video_send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
   if (fec == FecMode::kOn) {
@@ skipping 37 matching lines @@
 
   EXPECT_TRUE(observer.Wait())
       << "Timed out while waiting for audio and video to be synchronized.";
 
   EXPECT_EQ(0, voe_base->StopSend(send_channel_id));
   EXPECT_EQ(0, voe_base->StopReceive(recv_channel_id));
   EXPECT_EQ(0, voe_base->StopPlayout(recv_channel_id));
   fake_audio_device.Stop();
 
   Stop();
-  sync_send_transport.StopSending();
-  sync_receive_transport.StopSending();
+  video_send_transport.StopSending();
   audio_send_transport.StopSending();
-  audio_receive_transport.StopSending();
+  receive_transport.StopSending();
 
   DestroyStreams();
 
   sender_call_->DestroyAudioSendStream(audio_send_stream);
   receiver_call_->DestroyAudioReceiveStream(audio_receive_stream);
 
   voe_base->DeleteChannel(send_channel_id);
   voe_base->DeleteChannel(recv_channel_id);
   voe_base->Release();
   voe_codec->Release();
@@ skipping 396 matching lines @@
     int encoder_inits_;
     uint32_t last_set_bitrate_;
     VideoSendStream* send_stream_;
     VideoEncoderConfig encoder_config_;
   } test;
 
   RunBaseTest(&test);
 }
 
 }  // namespace webrtc