Base A/V synchronization on sync_labels.

webrtc/video/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.
  */
 #include <algorithm>
@@ skipping 26 matching lines @@
 #include "webrtc/voice_engine/include/voe_base.h"
 #include "webrtc/voice_engine/include/voe_codec.h"
 #include "webrtc/voice_engine/include/voe_network.h"
 #include "webrtc/voice_engine/include/voe_rtp_rtcp.h"
 #include "webrtc/voice_engine/include/voe_video_sync.h"
 
 namespace webrtc {
 
 class CallPerfTest : public test::CallTest {
  protected:
-  void TestAudioVideoSync(bool fec);
+  void TestAudioVideoSync(bool fec, bool create_audio_first);
 
   void TestCpuOveruse(LoadObserver::Load tested_load, int encode_delay_ms);
 
   void TestMinTransmitBitrate(bool pad_to_min_bitrate);
 
   void TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
                           int threshold_ms,
                           int start_time_ms,
                           int run_time_ms);
 };
@@ skipping 124 matching lines @@
 
  private:
   Clock* const clock_;
   int voe_channel_;
   VoEVideoSync* voe_sync_;
   SyncRtcpObserver* audio_observer_;
   int64_t creation_time_ms_;
   int64_t first_time_in_sync_;
 };
 
-void CallPerfTest::TestAudioVideoSync(bool fec) {
+void CallPerfTest::TestAudioVideoSync(bool fec, bool create_audio_first) {
+  const char* kSyncGroup = "av_sync";
   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) override {
       EXPECT_TRUE(media_type == MediaType::ANY ||
                   media_type == MediaType::AUDIO);
@@ skipping 59 matching lines @@
 
   send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
   if (fec) {
     send_config_.rtp.fec.red_payload_type = kRedPayloadType;
     send_config_.rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
     receive_configs_[0].rtp.fec.red_payload_type = kRedPayloadType;
     receive_configs_[0].rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
   }
   receive_configs_[0].rtp.nack.rtp_history_ms = 1000;
   receive_configs_[0].renderer = &observer;
-  receive_configs_[0].audio_channel_id = channel;
+  receive_configs_[0].sync_group = kSyncGroup;
+
+  AudioReceiveStream::Config audio_config;
+  audio_config.voe_channel_id = channel;
+  audio_config.sync_group = kSyncGroup;
+
+  AudioReceiveStream* audio_receive_stream = nullptr;
+
+  if (create_audio_first) {
+    audio_receive_stream =
+        receiver_call_->CreateAudioReceiveStream(audio_config);
+  }
 
   CreateStreams();
 
+  if (!create_audio_first) {
+    audio_receive_stream =
+        receiver_call_->CreateAudioReceiveStream(audio_config);
+  }
+
   CreateFrameGeneratorCapturer();
 
   Start();
 
   fake_audio_device.Start();
   EXPECT_EQ(0, voe_base->StartPlayout(channel));
   EXPECT_EQ(0, voe_base->StartReceive(channel));
   EXPECT_EQ(0, voe_base->StartSend(channel));
 
   EXPECT_EQ(kEventSignaled, observer.Wait())
       << "Timed out while waiting for audio and video to be synchronized.";
 
   EXPECT_EQ(0, voe_base->StopSend(channel));
   EXPECT_EQ(0, voe_base->StopReceive(channel));
   EXPECT_EQ(0, voe_base->StopPlayout(channel));
   fake_audio_device.Stop();
 
   Stop();
   observer.StopSending();
   audio_observer.StopSending();
 
   voe_base->DeleteChannel(channel);
   voe_base->Release();
   voe_codec->Release();
   voe_network->Release();
   voe_sync->Release();
 
   DestroyStreams();
 
+  receiver_call_->DestroyAudioReceiveStream(audio_receive_stream);
+
   VoiceEngine::Delete(voice_engine);
 }
 
-TEST_F(CallPerfTest, PlaysOutAudioAndVideoInSync) {
-  TestAudioVideoSync(false);
+TEST_F(CallPerfTest, PlaysOutAudioAndVideoInSyncWithAudioCreatedFirst) {
+  TestAudioVideoSync(false, true);
+}
+
+TEST_F(CallPerfTest, PlaysOutAudioAndVideoInSyncWithVideoCreatedFirst) {
+  TestAudioVideoSync(false, false);
 }
 
 TEST_F(CallPerfTest, PlaysOutAudioAndVideoInSyncWithFec) {
-  TestAudioVideoSync(true);
+  TestAudioVideoSync(true, false);
 }
 
 void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
                                       int threshold_ms,
                                       int start_time_ms,
                                       int run_time_ms) {
   class CaptureNtpTimeObserver : public test::EndToEndTest,
                                  public VideoRenderer {
    public:
     CaptureNtpTimeObserver(const FakeNetworkPipe::Config& config,
@@ skipping 354 matching lines @@
     int encoder_inits_;
     uint32_t last_set_bitrate_;
     VideoSendStream* send_stream_;
     VideoEncoderConfig encoder_config_;
   } test;
 
   RunBaseTest(&test);
 }
 
 }  // namespace webrtc