modules/rtp_rtcp/test/testAPI/test_api_audio.cc - src.git - Git at Google

 /*
  *  Copyright (c) 2012 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>
 #include <memory>
 #include <vector>

 #include "common_types.h"  // NOLINT(build/include)
 #include "modules/audio_coding/codecs/audio_format_conversion.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/source/rtp_receiver_audio.h"
 #include "modules/rtp_rtcp/test/testAPI/test_api.h"
 #include "rtc_base/rate_limiter.h"
 #include "test/gtest.h"

 namespace webrtc {
 namespace {

 const uint32_t kTestRate = 64000u;
 const uint8_t kTestPayload[] = {'t', 'e', 's', 't'};
 const uint8_t kPcmuPayloadType = 96;
 const uint8_t kDtmfPayloadType = 97;
 const uint32_t kSsrc = 3456;
 const uint32_t kTimestamp = 4567;

 struct CngCodecSpec {
   int payload_type;
   int clockrate_hz;
 };

 const CngCodecSpec kCngCodecs[] = {{13, 8000},
                                    {103, 16000},
                                    {104, 32000},
                                    {105, 48000}};

 // Rough sanity check of DTMF payload.
 void VerifyDtmf(const uint8_t* payloadData,
                 size_t payloadSize) {
   EXPECT_EQ(payloadSize, 4u);
   uint8_t p0 = (payloadSize > 0) ? payloadData[0] : 0xff;
   uint8_t p1 = (payloadSize > 1) ? payloadData[1] : 0xff;
   uint8_t p2 = (payloadSize > 2) ? payloadData[2] : 0xff;
   uint8_t p3 = (payloadSize > 3) ? payloadData[3] : 0xff;
   uint8_t event = p0;
   bool reserved = (p1 >> 6) & 1;
   uint8_t volume = p1 & 63;
   uint16_t duration = (p2 << 8) | p3;

   // 0-15 are digits, #, *, A-D, 32 is answer tone (see rfc 4734)
   EXPECT_LE(event, 32u);
   EXPECT_TRUE(event < 16u || event == 32u);
   EXPECT_FALSE(reserved);
   EXPECT_EQ(volume, 10u);
   // Long duration for answer tone events only
   EXPECT_TRUE(duration <= 1280 || event == 32u);
 }

 class VerifyingAudioReceiver : public RtpData {
  public:
   int32_t OnReceivedPayloadData(
       const uint8_t* payloadData,
       size_t payloadSize,
       const webrtc::WebRtcRTPHeader* rtpHeader) override {
     const uint8_t payload_type = rtpHeader->header.payloadType;
     if (payload_type == kPcmuPayloadType) {
       EXPECT_EQ(sizeof(kTestPayload), payloadSize);
       // All our test vectors for PCMU are equal to |kTestPayload|.
       const size_t min_size = std::min(sizeof(kTestPayload), payloadSize);
       EXPECT_EQ(0, memcmp(payloadData, kTestPayload, min_size));
     } else if (payload_type == kDtmfPayloadType) {
       VerifyDtmf(payloadData, payloadSize);
     }

     return 0;
   }
 };

 }  // namespace

 class RtpRtcpAudioTest : public ::testing::Test {
  protected:
   RtpRtcpAudioTest()
       : fake_clock_(123456),
         retransmission_rate_limiter_(&fake_clock_, 1000),
         receive_statistics1_(ReceiveStatistics::Create(&fake_clock_)),
         receive_statistics2_(ReceiveStatistics::Create(&fake_clock_)),
         rtp_receiver1_(
             RtpReceiver::CreateAudioReceiver(&fake_clock_,
                                              &data_receiver1_,
                                              &rtp_payload_registry1_)),
         rtp_receiver2_(
             RtpReceiver::CreateAudioReceiver(&fake_clock_,
                                              &data_receiver2_,
                                              &rtp_payload_registry2_)) {
     RtpRtcp::Configuration configuration;
     configuration.audio = true;
     configuration.clock = &fake_clock_;
     configuration.receive_statistics = receive_statistics1_.get();
     configuration.outgoing_transport = &transport1_;
     configuration.retransmission_rate_limiter = &retransmission_rate_limiter_;
     module1_.reset(RtpRtcp::CreateRtpRtcp(configuration));

     configuration.receive_statistics = receive_statistics2_.get();
     configuration.outgoing_transport = &transport2_;
     module2_.reset(RtpRtcp::CreateRtpRtcp(configuration));

     transport1_.SetSendModule(module2_.get(), &rtp_payload_registry2_,
                               rtp_receiver2_.get(), receive_statistics2_.get());
     transport2_.SetSendModule(module1_.get(), &rtp_payload_registry1_,
                               rtp_receiver1_.get(), receive_statistics1_.get());
   }

   ~RtpRtcpAudioTest() override = default;

   void RegisterPayload(const CodecInst& codec) {
     EXPECT_EQ(0, module1_->RegisterSendPayload(codec));
     EXPECT_EQ(0, rtp_receiver1_->RegisterReceivePayload(codec.pltype,
                                                         CodecInstToSdp(codec)));
     EXPECT_EQ(0, module2_->RegisterSendPayload(codec));
     EXPECT_EQ(0, rtp_receiver2_->RegisterReceivePayload(codec.pltype,
                                                         CodecInstToSdp(codec)));
   }

   SimulatedClock fake_clock_;
   RateLimiter retransmission_rate_limiter_;
   VerifyingAudioReceiver data_receiver1_;
   VerifyingAudioReceiver data_receiver2_;
   std::unique_ptr<ReceiveStatistics> receive_statistics1_;
   std::unique_ptr<ReceiveStatistics> receive_statistics2_;
   RTPPayloadRegistry rtp_payload_registry1_;
   RTPPayloadRegistry rtp_payload_registry2_;
   std::unique_ptr<RtpReceiver> rtp_receiver1_;
   std::unique_ptr<RtpReceiver> rtp_receiver2_;
   std::unique_ptr<RtpRtcp> module1_;
   std::unique_ptr<RtpRtcp> module2_;
   LoopBackTransport transport1_;
   LoopBackTransport transport2_;
 };

 TEST_F(RtpRtcpAudioTest, Basic) {
   module1_->SetSSRC(kSsrc);
   module1_->SetStartTimestamp(kTimestamp);

   // Test detection at the end of a DTMF tone.
   // EXPECT_EQ(0, module2_->SetTelephoneEventForwardToDecoder(true));

   EXPECT_EQ(0, module1_->SetSendingStatus(true));

   // Start basic RTP test.

   // Send an empty RTP packet.
   // Should fail since we have not registered the payload type.
   EXPECT_FALSE(module1_->SendOutgoingData(webrtc::kAudioFrameSpeech,
                                           kPcmuPayloadType, 0, -1, nullptr, 0,
                                           nullptr, nullptr, nullptr));

   CodecInst voice_codec = {};
   voice_codec.pltype = kPcmuPayloadType;
   voice_codec.plfreq = 8000;
   voice_codec.rate = kTestRate;
   memcpy(voice_codec.plname, "PCMU", 5);
   RegisterPayload(voice_codec);

   EXPECT_TRUE(module1_->SendOutgoingData(webrtc::kAudioFrameSpeech,
                                          kPcmuPayloadType, 0, -1, kTestPayload,
                                          4, nullptr, nullptr, nullptr));

   EXPECT_EQ(kSsrc, rtp_receiver2_->SSRC());
   uint32_t timestamp;
   int64_t receive_time_ms;
   EXPECT_TRUE(
       rtp_receiver2_->GetLatestTimestamps(&timestamp, &receive_time_ms));
   EXPECT_EQ(kTimestamp, timestamp);
   EXPECT_EQ(fake_clock_.TimeInMilliseconds(), receive_time_ms);
 }

 TEST_F(RtpRtcpAudioTest, DTMF) {
   CodecInst voice_codec = {};
   voice_codec.pltype = kPcmuPayloadType;
   voice_codec.plfreq = 8000;
   voice_codec.rate = kTestRate;
   memcpy(voice_codec.plname, "PCMU", 5);
   RegisterPayload(voice_codec);

   module1_->SetSSRC(kSsrc);
   module1_->SetStartTimestamp(kTimestamp);
   EXPECT_EQ(0, module1_->SetSendingStatus(true));

   // Prepare for DTMF.
   voice_codec.pltype = kDtmfPayloadType;
   voice_codec.plfreq = 8000;
   memcpy(voice_codec.plname, "telephone-event", 16);

   EXPECT_EQ(0, module1_->RegisterSendPayload(voice_codec));
   EXPECT_EQ(0, rtp_receiver2_->RegisterReceivePayload(
                    voice_codec.pltype, CodecInstToSdp(voice_codec)));

   // Start DTMF test.
   int timeStamp = 160;

   // Send a DTMF tone using RFC 2833 (4733).
   for (int i = 0; i < 16; i++) {
     EXPECT_EQ(0, module1_->SendTelephoneEventOutband(i, timeStamp, 10));
   }
   timeStamp += 160;  // Prepare for next packet.

   // Send RTP packets for 16 tones a 160 ms  100ms
   // pause between = 2560ms + 1600ms = 4160ms
   for (; timeStamp <= 250 * 160; timeStamp += 160) {
     EXPECT_TRUE(module1_->SendOutgoingData(
         webrtc::kAudioFrameSpeech, kPcmuPayloadType, timeStamp, -1,
         kTestPayload, 4, nullptr, nullptr, nullptr));
     fake_clock_.AdvanceTimeMilliseconds(20);
     module1_->Process();
   }
   EXPECT_EQ(0, module1_->SendTelephoneEventOutband(32, 9000, 10));

   for (; timeStamp <= 740 * 160; timeStamp += 160) {
     EXPECT_TRUE(module1_->SendOutgoingData(
         webrtc::kAudioFrameSpeech, kPcmuPayloadType, timeStamp, -1,
         kTestPayload, 4, nullptr, nullptr, nullptr));
     fake_clock_.AdvanceTimeMilliseconds(20);
     module1_->Process();
   }
 }

 TEST_F(RtpRtcpAudioTest, ComfortNoise) {
   module1_->SetSSRC(kSsrc);
   module1_->SetStartTimestamp(kTimestamp);

   EXPECT_EQ(0, module1_->SetSendingStatus(true));

   // Register PCMU and all four comfort noise codecs.
   CodecInst voice_codec = {};
   voice_codec.pltype = kPcmuPayloadType;
   voice_codec.plfreq = 8000;
   voice_codec.rate = kTestRate;
   memcpy(voice_codec.plname, "PCMU", 5);
   RegisterPayload(voice_codec);

   for (const auto& c : kCngCodecs) {
     CodecInst cng_codec = {};
     cng_codec.pltype = c.payload_type;
     cng_codec.plfreq = c.clockrate_hz;
     memcpy(cng_codec.plname, "CN", 3);
     RegisterPayload(cng_codec);
   }

   // Transmit comfort noise packets interleaved by PCMU packets.
   uint32_t in_timestamp = 0;
   for (const auto& c : kCngCodecs) {
     uint32_t timestamp;
     int64_t receive_time_ms;
     EXPECT_TRUE(module1_->SendOutgoingData(
         webrtc::kAudioFrameSpeech, kPcmuPayloadType, in_timestamp, -1,
         kTestPayload, 4, nullptr, nullptr, nullptr));

     EXPECT_EQ(kSsrc, rtp_receiver2_->SSRC());
     EXPECT_TRUE(
         rtp_receiver2_->GetLatestTimestamps(&timestamp, &receive_time_ms));
     EXPECT_EQ(kTimestamp + in_timestamp, timestamp);
     EXPECT_EQ(fake_clock_.TimeInMilliseconds(), receive_time_ms);
     in_timestamp += 10;
     fake_clock_.AdvanceTimeMilliseconds(20);

     EXPECT_TRUE(module1_->SendOutgoingData(
         webrtc::kAudioFrameCN, c.payload_type, in_timestamp, -1, kTestPayload,
         1, nullptr, nullptr, nullptr));

     EXPECT_EQ(kSsrc, rtp_receiver2_->SSRC());
     EXPECT_TRUE(
         rtp_receiver2_->GetLatestTimestamps(&timestamp, &receive_time_ms));
     EXPECT_EQ(kTimestamp + in_timestamp, timestamp);
     EXPECT_EQ(fake_clock_.TimeInMilliseconds(), receive_time_ms);
     in_timestamp += 10;
     fake_clock_.AdvanceTimeMilliseconds(20);
   }
 }

 }  // namespace webrtc
	/*
	* Copyright (c) 2012 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>
	#include <memory>
	#include <vector>

	#include "common_types.h" // NOLINT(build/include)
	#include "modules/audio_coding/codecs/audio_format_conversion.h"
	#include "modules/rtp_rtcp/include/rtp_rtcp.h"
	#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
	#include "modules/rtp_rtcp/source/rtp_receiver_audio.h"
	#include "modules/rtp_rtcp/test/testAPI/test_api.h"
	#include "rtc_base/rate_limiter.h"
	#include "test/gtest.h"

	namespace webrtc {
	namespace {

	const uint32_t kTestRate = 64000u;
	const uint8_t kTestPayload[] = {'t', 'e', 's', 't'};
	const uint8_t kPcmuPayloadType = 96;
	const uint8_t kDtmfPayloadType = 97;
	const uint32_t kSsrc = 3456;
	const uint32_t kTimestamp = 4567;

	struct CngCodecSpec {
	int payload_type;
	int clockrate_hz;
	};

	const CngCodecSpec kCngCodecs[] = {{13, 8000},
	{103, 16000},
	{104, 32000},
	{105, 48000}};

	// Rough sanity check of DTMF payload.
	void VerifyDtmf(const uint8_t* payloadData,
	size_t payloadSize) {
	EXPECT_EQ(payloadSize, 4u);
	uint8_t p0 = (payloadSize > 0) ? payloadData[0] : 0xff;
	uint8_t p1 = (payloadSize > 1) ? payloadData[1] : 0xff;
	uint8_t p2 = (payloadSize > 2) ? payloadData[2] : 0xff;
	uint8_t p3 = (payloadSize > 3) ? payloadData[3] : 0xff;
	uint8_t event = p0;
	bool reserved = (p1 >> 6) & 1;
	uint8_t volume = p1 & 63;
	uint16_t duration = (p2 << 8) \| p3;

	// 0-15 are digits, #, *, A-D, 32 is answer tone (see rfc 4734)
	EXPECT_LE(event, 32u);
	EXPECT_TRUE(event < 16u \|\| event == 32u);
	EXPECT_FALSE(reserved);
	EXPECT_EQ(volume, 10u);
	// Long duration for answer tone events only
	EXPECT_TRUE(duration <= 1280 \|\| event == 32u);
	}

	class VerifyingAudioReceiver : public RtpData {
	public:
	int32_t OnReceivedPayloadData(
	const uint8_t* payloadData,
	size_t payloadSize,
	const webrtc::WebRtcRTPHeader* rtpHeader) override {
	const uint8_t payload_type = rtpHeader->header.payloadType;
	if (payload_type == kPcmuPayloadType) {
	EXPECT_EQ(sizeof(kTestPayload), payloadSize);
	// All our test vectors for PCMU are equal to \|kTestPayload\|.
	const size_t min_size = std::min(sizeof(kTestPayload), payloadSize);
	EXPECT_EQ(0, memcmp(payloadData, kTestPayload, min_size));
	} else if (payload_type == kDtmfPayloadType) {
	VerifyDtmf(payloadData, payloadSize);
	}

	return 0;
	}
	};

	} // namespace

	class RtpRtcpAudioTest : public ::testing::Test {
	protected:
	RtpRtcpAudioTest()
	: fake_clock_(123456),
	retransmission_rate_limiter_(&fake_clock_, 1000),
	receive_statistics1_(ReceiveStatistics::Create(&fake_clock_)),
	receive_statistics2_(ReceiveStatistics::Create(&fake_clock_)),
	rtp_receiver1_(
	RtpReceiver::CreateAudioReceiver(&fake_clock_,
	&data_receiver1_,
	&rtp_payload_registry1_)),
	rtp_receiver2_(
	RtpReceiver::CreateAudioReceiver(&fake_clock_,
	&data_receiver2_,
	&rtp_payload_registry2_)) {
	RtpRtcp::Configuration configuration;
	configuration.audio = true;
	configuration.clock = &fake_clock_;
	configuration.receive_statistics = receive_statistics1_.get();
	configuration.outgoing_transport = &transport1_;
	configuration.retransmission_rate_limiter = &retransmission_rate_limiter_;
	module1_.reset(RtpRtcp::CreateRtpRtcp(configuration));

	configuration.receive_statistics = receive_statistics2_.get();
	configuration.outgoing_transport = &transport2_;
	module2_.reset(RtpRtcp::CreateRtpRtcp(configuration));

	transport1_.SetSendModule(module2_.get(), &rtp_payload_registry2_,
	rtp_receiver2_.get(), receive_statistics2_.get());
	transport2_.SetSendModule(module1_.get(), &rtp_payload_registry1_,
	rtp_receiver1_.get(), receive_statistics1_.get());
	}

	~RtpRtcpAudioTest() override = default;

	void RegisterPayload(const CodecInst& codec) {
	EXPECT_EQ(0, module1_->RegisterSendPayload(codec));
	EXPECT_EQ(0, rtp_receiver1_->RegisterReceivePayload(codec.pltype,
	CodecInstToSdp(codec)));
	EXPECT_EQ(0, module2_->RegisterSendPayload(codec));
	EXPECT_EQ(0, rtp_receiver2_->RegisterReceivePayload(codec.pltype,
	CodecInstToSdp(codec)));
	}

	SimulatedClock fake_clock_;
	RateLimiter retransmission_rate_limiter_;
	VerifyingAudioReceiver data_receiver1_;
	VerifyingAudioReceiver data_receiver2_;
	std::unique_ptr<ReceiveStatistics> receive_statistics1_;
	std::unique_ptr<ReceiveStatistics> receive_statistics2_;
	RTPPayloadRegistry rtp_payload_registry1_;
	RTPPayloadRegistry rtp_payload_registry2_;
	std::unique_ptr<RtpReceiver> rtp_receiver1_;
	std::unique_ptr<RtpReceiver> rtp_receiver2_;
	std::unique_ptr<RtpRtcp> module1_;
	std::unique_ptr<RtpRtcp> module2_;
	LoopBackTransport transport1_;
	LoopBackTransport transport2_;
	};

	TEST_F(RtpRtcpAudioTest, Basic) {
	module1_->SetSSRC(kSsrc);
	module1_->SetStartTimestamp(kTimestamp);

	// Test detection at the end of a DTMF tone.
	// EXPECT_EQ(0, module2_->SetTelephoneEventForwardToDecoder(true));

	EXPECT_EQ(0, module1_->SetSendingStatus(true));

	// Start basic RTP test.

	// Send an empty RTP packet.
	// Should fail since we have not registered the payload type.
	EXPECT_FALSE(module1_->SendOutgoingData(webrtc::kAudioFrameSpeech,
	kPcmuPayloadType, 0, -1, nullptr, 0,
	nullptr, nullptr, nullptr));

	CodecInst voice_codec = {};
	voice_codec.pltype = kPcmuPayloadType;
	voice_codec.plfreq = 8000;
	voice_codec.rate = kTestRate;
	memcpy(voice_codec.plname, "PCMU", 5);
	RegisterPayload(voice_codec);

	EXPECT_TRUE(module1_->SendOutgoingData(webrtc::kAudioFrameSpeech,
	kPcmuPayloadType, 0, -1, kTestPayload,
	4, nullptr, nullptr, nullptr));

	EXPECT_EQ(kSsrc, rtp_receiver2_->SSRC());
	uint32_t timestamp;
	int64_t receive_time_ms;
	EXPECT_TRUE(
	rtp_receiver2_->GetLatestTimestamps(&timestamp, &receive_time_ms));
	EXPECT_EQ(kTimestamp, timestamp);
	EXPECT_EQ(fake_clock_.TimeInMilliseconds(), receive_time_ms);
	}

	TEST_F(RtpRtcpAudioTest, DTMF) {
	CodecInst voice_codec = {};
	voice_codec.pltype = kPcmuPayloadType;
	voice_codec.plfreq = 8000;
	voice_codec.rate = kTestRate;
	memcpy(voice_codec.plname, "PCMU", 5);
	RegisterPayload(voice_codec);

	module1_->SetSSRC(kSsrc);
	module1_->SetStartTimestamp(kTimestamp);
	EXPECT_EQ(0, module1_->SetSendingStatus(true));

	// Prepare for DTMF.
	voice_codec.pltype = kDtmfPayloadType;
	voice_codec.plfreq = 8000;
	memcpy(voice_codec.plname, "telephone-event", 16);

	EXPECT_EQ(0, module1_->RegisterSendPayload(voice_codec));
	EXPECT_EQ(0, rtp_receiver2_->RegisterReceivePayload(
	voice_codec.pltype, CodecInstToSdp(voice_codec)));

	// Start DTMF test.
	int timeStamp = 160;

	// Send a DTMF tone using RFC 2833 (4733).
	for (int i = 0; i < 16; i++) {
	EXPECT_EQ(0, module1_->SendTelephoneEventOutband(i, timeStamp, 10));
	}
	timeStamp += 160; // Prepare for next packet.

	// Send RTP packets for 16 tones a 160 ms 100ms
	// pause between = 2560ms + 1600ms = 4160ms
	for (; timeStamp <= 250 * 160; timeStamp += 160) {
	EXPECT_TRUE(module1_->SendOutgoingData(
	webrtc::kAudioFrameSpeech, kPcmuPayloadType, timeStamp, -1,
	kTestPayload, 4, nullptr, nullptr, nullptr));
	fake_clock_.AdvanceTimeMilliseconds(20);
	module1_->Process();
	}
	EXPECT_EQ(0, module1_->SendTelephoneEventOutband(32, 9000, 10));

	for (; timeStamp <= 740 * 160; timeStamp += 160) {
	EXPECT_TRUE(module1_->SendOutgoingData(
	webrtc::kAudioFrameSpeech, kPcmuPayloadType, timeStamp, -1,
	kTestPayload, 4, nullptr, nullptr, nullptr));
	fake_clock_.AdvanceTimeMilliseconds(20);
	module1_->Process();
	}
	}

	TEST_F(RtpRtcpAudioTest, ComfortNoise) {
	module1_->SetSSRC(kSsrc);
	module1_->SetStartTimestamp(kTimestamp);

	EXPECT_EQ(0, module1_->SetSendingStatus(true));

	// Register PCMU and all four comfort noise codecs.
	CodecInst voice_codec = {};
	voice_codec.pltype = kPcmuPayloadType;
	voice_codec.plfreq = 8000;
	voice_codec.rate = kTestRate;
	memcpy(voice_codec.plname, "PCMU", 5);
	RegisterPayload(voice_codec);

	for (const auto& c : kCngCodecs) {
	CodecInst cng_codec = {};
	cng_codec.pltype = c.payload_type;
	cng_codec.plfreq = c.clockrate_hz;
	memcpy(cng_codec.plname, "CN", 3);
	RegisterPayload(cng_codec);
	}

	// Transmit comfort noise packets interleaved by PCMU packets.
	uint32_t in_timestamp = 0;
	for (const auto& c : kCngCodecs) {
	uint32_t timestamp;
	int64_t receive_time_ms;
	EXPECT_TRUE(module1_->SendOutgoingData(
	webrtc::kAudioFrameSpeech, kPcmuPayloadType, in_timestamp, -1,
	kTestPayload, 4, nullptr, nullptr, nullptr));

	EXPECT_EQ(kSsrc, rtp_receiver2_->SSRC());
	EXPECT_TRUE(
	rtp_receiver2_->GetLatestTimestamps(&timestamp, &receive_time_ms));
	EXPECT_EQ(kTimestamp + in_timestamp, timestamp);
	EXPECT_EQ(fake_clock_.TimeInMilliseconds(), receive_time_ms);
	in_timestamp += 10;
	fake_clock_.AdvanceTimeMilliseconds(20);

	EXPECT_TRUE(module1_->SendOutgoingData(
	webrtc::kAudioFrameCN, c.payload_type, in_timestamp, -1, kTestPayload,
	1, nullptr, nullptr, nullptr));

	EXPECT_EQ(kSsrc, rtp_receiver2_->SSRC());
	EXPECT_TRUE(
	rtp_receiver2_->GetLatestTimestamps(&timestamp, &receive_time_ms));
	EXPECT_EQ(kTimestamp + in_timestamp, timestamp);
	EXPECT_EQ(fake_clock_.TimeInMilliseconds(), receive_time_ms);
	in_timestamp += 10;
	fake_clock_.AdvanceTimeMilliseconds(20);
	}
	}

	} // namespace webrtc