webrtc/audio/audio_receive_stream_unittest.cc - Issue 1535963002: Wire-up BWE feedback for audio receive streams.

Unified Diff: webrtc/audio/audio_receive_stream_unittest.cc

Issue 1535963002: Wire-up BWE feedback for audio receive streams. (Closed) Base URL: https://chromium.googlesource.com/external/webrtc.git@master

Patch Set: Comments addressed. Created 5 years ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: webrtc/audio/audio_receive_stream_unittest.cc

diff --git a/webrtc/audio/audio_receive_stream_unittest.cc b/webrtc/audio/audio_receive_stream_unittest.cc

index bfd8dcaa33f92435da627009382d42f80200289a..ab6a4a96e121519d58ca936e6f1a0e48eaa6d819 100644

--- a/webrtc/audio/audio_receive_stream_unittest.cc

+++ b/webrtc/audio/audio_receive_stream_unittest.cc

@@ -14,10 +14,14 @@

#include "webrtc/audio/audio_receive_stream.h"

#include "webrtc/audio/conversion.h"

+#include "webrtc/call/mock/mock_congestion_controller.h"

+#include "webrtc/modules/bitrate_controller/include/mock/mock_bitrate_controller.h"

+#include "webrtc/modules/pacing/packet_router.h"

#include "webrtc/modules/remote_bitrate_estimator/include/mock/mock_remote_bitrate_estimator.h"

#include "webrtc/modules/rtp_rtcp/source/byte_io.h"

#include "webrtc/test/mock_voe_channel_proxy.h"

#include "webrtc/test/mock_voice_engine.h"

+#include "webrtc/video/call_stats.h"

namespace webrtc {

namespace test {

@@ -40,9 +44,10 @@ AudioDecodingCallStats MakeAudioDecodeStatsForTest() {

const int kChannelId = 2;

const uint32_t kRemoteSsrc = 1234;

const uint32_t kLocalSsrc = 5678;

-const size_t kAbsoluteSendTimeLength = 4;

+const size_t kOneByteExtensionLength = 4;

const int kAbsSendTimeId = 2;

const int kAudioLevelId = 3;

+const int kTransportSequenceNumberId = 4;

const int kJitterBufferDelay = -7;

const int kPlayoutBufferDelay = 302;

const unsigned int kSpeechOutputLevel = 99;

@@ -55,7 +60,12 @@ const NetworkStatistics kNetworkStats = {

const AudioDecodingCallStats kAudioDecodeStats = MakeAudioDecodeStatsForTest();

struct ConfigHelper {

- ConfigHelper() {

+ ConfigHelper()

+ : call_stats_(Clock::GetRealTimeClock()),

+ process_thread_(ProcessThread::Create("AudioTestThread")),

the sun 2015/12/22 00:14:14 Are we relying on this thread to run somehow? Or i

stefan-webrtc 2016/01/07 13:43:41 Done.

+ congestion_controller_(process_thread_.get(),

+ &call_stats_,

+ &bitrate_observer_) {

using testing::Invoke;

EXPECT_CALL(voice_engine_,

@@ -65,11 +75,10 @@ struct ConfigHelper {

AudioState::Config config;

config.voice_engine = &voice_engine_;

audio_state_ = AudioState::Create(config);

+ channel_proxy_ = new testing::StrictMock<MockVoEChannelProxy>();

EXPECT_CALL(voice_engine_, ChannelProxyFactory(kChannelId))

.WillOnce(Invoke([this](int channel_id) {

- EXPECT_FALSE(channel_proxy_);

- channel_proxy_ = new testing::StrictMock<MockVoEChannelProxy>();

EXPECT_CALL(*channel_proxy_, SetLocalSSRC(kLocalSsrc)).Times(1);

EXPECT_CALL(*channel_proxy_,

SetReceiveAbsoluteSenderTimeStatus(true, kAbsSendTimeId))

@@ -88,6 +97,9 @@ struct ConfigHelper {

RtpExtension(RtpExtension::kAudioLevel, kAudioLevelId));

}

+ MockCongestionController* congestion_controller() {

+ return &congestion_controller_;

+ }

MockRemoteBitrateEstimator* remote_bitrate_estimator() {

return &remote_bitrate_estimator_;

}

@@ -95,11 +107,27 @@ struct ConfigHelper {

rtc::scoped_refptr<AudioState> audio_state() { return audio_state_; }

MockVoiceEngine& voice_engine() { return voice_engine_; }

+ void SetupMockForBweFeedback() {

+ EXPECT_CALL(congestion_controller_, GetRemoteBitrateEstimator(true))

+ .WillOnce(Return(&remote_bitrate_estimator_));

+ EXPECT_CALL(congestion_controller_, packet_router())

+ .WillOnce(Return(&packet_router_));

+ EXPECT_CALL(remote_bitrate_estimator_,

+ RemoveStream(stream_config_.rtp.remote_ssrc));

+ ASSERT_TRUE(channel_proxy_);

+ EXPECT_CALL(*channel_proxy_,

+ SetCongestionControlObjects(nullptr, nullptr, &packet_router_))

+ .Times(1);

+ EXPECT_CALL(*channel_proxy_,

+ SetCongestionControlObjects(nullptr, nullptr, nullptr))

+ .Times(1);

+ }

void SetupMockForGetStats() {

using testing::DoAll;

using testing::SetArgReferee;

- EXPECT_TRUE(channel_proxy_);

+ ASSERT_TRUE(channel_proxy_);

the sun 2015/12/22 00:14:14 thanks

EXPECT_CALL(*channel_proxy_, GetRTCPStatistics())

.WillOnce(Return(kCallStats));

EXPECT_CALL(*channel_proxy_, GetDelayEstimate())

@@ -116,6 +144,11 @@ struct ConfigHelper {

}

private:

+ CallStats call_stats_;

+ PacketRouter packet_router_;

+ testing::NiceMock<MockBitrateObserver> bitrate_observer_;

+ rtc::scoped_ptr<ProcessThread> process_thread_;

+ MockCongestionController congestion_controller_;

MockRemoteBitrateEstimator remote_bitrate_estimator_;

testing::StrictMock<MockVoiceEngine> voice_engine_;

rtc::scoped_refptr<AudioState> audio_state_;

@@ -123,26 +156,29 @@ struct ConfigHelper {

testing::StrictMock<MockVoEChannelProxy>* channel_proxy_ = nullptr;

};

-void BuildAbsoluteSendTimeExtension(uint8_t* buffer,

- int id,

- uint32_t abs_send_time) {

+void BuildOneByteExtension(uint8_t* buffer,

the sun 2015/12/22 00:14:14 vector<uint8_t>::iterator?

+ int id,

+ uint32_t extension_value,

+ size_t value_length) {

const size_t kRtpOneByteHeaderLength = 4;

the sun 2015/12/22 00:14:14 Can this be removed?

stefan-webrtc 2016/01/07 13:43:41 Done.

const uint16_t kRtpOneByteHeaderExtensionId = 0xBEDE;

ByteWriter<uint16_t>::WriteBigEndian(buffer, kRtpOneByteHeaderExtensionId);

const uint32_t kPosLength = 2;

ByteWriter<uint16_t>::WriteBigEndian(buffer + kPosLength,

- kAbsoluteSendTimeLength / 4);

- const uint8_t kLengthOfData = 3;

- buffer[kRtpOneByteHeaderLength] = (id << 4) + (kLengthOfData - 1);

- ByteWriter<uint32_t, kLengthOfData>::WriteBigEndian(

- buffer + kRtpOneByteHeaderLength + 1, abs_send_time);

+ kOneByteExtensionLength / 4);

+ const size_t kExtensionDataLength = kOneByteExtensionLength - 1;

+ uint32_t shifted_value = extension_value

+ << (8 * (kExtensionDataLength - value_length));

+ buffer[kRtpOneByteHeaderLength] = (id << 4) + (value_length - 1);

+ ByteWriter<uint32_t, kExtensionDataLength>::WriteBigEndian(

+ buffer + kRtpOneByteHeaderLength + 1, shifted_value);

}

-size_t CreateRtpHeaderWithAbsSendTime(uint8_t* header,

- int extension_id,

- uint32_t abs_send_time) {

+size_t CreateRtpHeaderWithOneByteExtension(uint8_t* header,

the sun 2015/12/22 00:14:14 How about just returning a vector<uint8_t> by valu

stefan-webrtc 2016/01/07 13:43:41 Done.

+ int extension_id,

+ uint32_t extension_value,

+ size_t value_length) {

header[0] = 0x80; // Version 2.

header[0] |= 0x10; // Set extension bit.

header[1] = 100; // Payload type.

@@ -152,9 +188,9 @@ size_t CreateRtpHeaderWithAbsSendTime(uint8_t* header,

ByteWriter<uint32_t>::WriteBigEndian(header + 8, 0x4321); // SSRC.

int32_t rtp_header_length = webrtc::kRtpHeaderSize;

- BuildAbsoluteSendTimeExtension(header + rtp_header_length, extension_id,

- abs_send_time);

- rtp_header_length += kAbsoluteSendTimeLength;

+ BuildOneByteExtension(header + rtp_header_length, extension_id,

+ extension_value, value_length);

+ rtp_header_length += kOneByteExtensionLength;

return rtp_header_length;

}

} // namespace

@@ -178,23 +214,69 @@ TEST(AudioReceiveStreamTest, ConfigToString) {

TEST(AudioReceiveStreamTest, ConstructDestruct) {

ConfigHelper helper;

internal::AudioReceiveStream recv_stream(

- helper.remote_bitrate_estimator(), helper.config(), helper.audio_state());

+ helper.congestion_controller(), helper.config(), helper.audio_state());

+MATCHER_P(VerifyHeaderExtension, expected_extension, "") {

+ return arg.extension.hasAbsoluteSendTime ==

+ expected_extension.hasAbsoluteSendTime &&

+ arg.extension.absoluteSendTime ==

+ expected_extension.absoluteSendTime &&

+ arg.extension.hasTransportSequenceNumber ==

+ expected_extension.hasTransportSequenceNumber &&

+ arg.extension.transportSequenceNumber ==

+ expected_extension.transportSequenceNumber;

}

TEST(AudioReceiveStreamTest, AudioPacketUpdatesBweWithTimestamp) {

ConfigHelper helper;

helper.config().combined_audio_video_bwe = true;

+ EXPECT_CALL(*helper.congestion_controller(), GetRemoteBitrateEstimator(false))

+ .WillOnce(Return(helper.remote_bitrate_estimator()));

+ EXPECT_CALL(*helper.remote_bitrate_estimator(),

+ RemoveStream(helper.config().rtp.remote_ssrc));

internal::AudioReceiveStream recv_stream(

- helper.remote_bitrate_estimator(), helper.config(), helper.audio_state());

+ helper.congestion_controller(), helper.config(), helper.audio_state());

uint8_t rtp_packet[30];

const int kAbsSendTimeValue = 1234;

- CreateRtpHeaderWithAbsSendTime(rtp_packet, kAbsSendTimeId, kAbsSendTimeValue);

+ CreateRtpHeaderWithOneByteExtension(rtp_packet, kAbsSendTimeId,

+ kAbsSendTimeValue, 3);

+ PacketTime packet_time(5678000, 0);

+ const size_t kExpectedHeaderLength = 20;

+ RTPHeaderExtension expected_extension;

+ expected_extension.hasAbsoluteSendTime = true;

+ expected_extension.absoluteSendTime = kAbsSendTimeValue;

+ EXPECT_CALL(*helper.remote_bitrate_estimator(),

+ IncomingPacket(packet_time.timestamp / 1000,

+ sizeof(rtp_packet) - kExpectedHeaderLength,

+ VerifyHeaderExtension(expected_extension), false))

+ .Times(1);

+ EXPECT_TRUE(

+ recv_stream.DeliverRtp(rtp_packet, sizeof(rtp_packet), packet_time));

+TEST(AudioReceiveStreamTest, AudioPacketUpdatesBweFeedback) {

+ ConfigHelper helper;

+ helper.config().combined_audio_video_bwe = true;

+ helper.config().rtp.transport_cc = true;

+ helper.config().rtp.extensions.push_back(RtpExtension(

+ RtpExtension::kTransportSequenceNumber, kTransportSequenceNumberId));

+ helper.SetupMockForBweFeedback();

+ internal::AudioReceiveStream recv_stream(

+ helper.congestion_controller(), helper.config(), helper.audio_state());

+ uint8_t rtp_packet[30];

+ const int kTransportSequenceNumberValue = 1234;

+ CreateRtpHeaderWithOneByteExtension(rtp_packet, kTransportSequenceNumberId,

+ kTransportSequenceNumberValue, 2);

PacketTime packet_time(5678000, 0);

const size_t kExpectedHeaderLength = 20;

+ RTPHeaderExtension expected_extension;

+ expected_extension.hasTransportSequenceNumber = true;

+ expected_extension.transportSequenceNumber = kTransportSequenceNumberValue;

EXPECT_CALL(*helper.remote_bitrate_estimator(),

IncomingPacket(packet_time.timestamp / 1000,

sizeof(rtp_packet) - kExpectedHeaderLength,

- testing::_, false))

+ VerifyHeaderExtension(expected_extension), false))

.Times(1);

EXPECT_TRUE(

recv_stream.DeliverRtp(rtp_packet, sizeof(rtp_packet), packet_time));

@@ -203,7 +285,7 @@ TEST(AudioReceiveStreamTest, AudioPacketUpdatesBweWithTimestamp) {

TEST(AudioReceiveStreamTest, GetStats) {

ConfigHelper helper;

internal::AudioReceiveStream recv_stream(

- helper.remote_bitrate_estimator(), helper.config(), helper.audio_state());

+ helper.congestion_controller(), helper.config(), helper.audio_state());

helper.SetupMockForGetStats();

AudioReceiveStream::Stats stats = recv_stream.GetStats();

EXPECT_EQ(kRemoteSsrc, stats.remote_ssrc);

« webrtc/audio/audio_receive_stream.cc ('K') | « webrtc/audio/audio_receive_stream.cc ('k') | webrtc/audio/audio_send_stream_unittest.cc » ('j') | webrtc/audio_receive_stream.h » ('J')