admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Call OnSentPacket for all packets sent in the test framework.

Browse Source 
Required a bit of refactoring to make it possible to pass a Call to DirectTransport on construction. This also lead to me having to remove the shared lock between PacketTransport and RtpRtcpObserver. Now RtpRtcpObserver has a SetTransports method instead of a SetReceivers method.

BUG=webrtc:4173

Review URL: https://codereview.webrtc.org/1419193002

Cr-Commit-Position: refs/heads/master@{#10430}
This commit is contained in:
stefan 2015-10-27 08:29:42 -07:00 committed by Commit bot
parent f1dcd46a9b
commit f116bd0d7a
16 changed files with 411 additions and 464 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
webrtc/call/bitrate_estimator_tests.cc
View File

@ -116,15 +116,7 @@ static const int kASTExtensionId = 5;
class BitrateEstimatorTest : public test::CallTest {
public:
BitrateEstimatorTest()
: receiver_trace_(),
send_transport_(),
receive_transport_(),
sender_call_(),
receiver_call_(),
receive_config_(nullptr),
streams_() {
}
BitrateEstimatorTest() : receive_config_(nullptr) {}
virtual ~BitrateEstimatorTest() {
EXPECT_TRUE(streams_.empty());
@ -136,10 +128,12 @@ class BitrateEstimatorTest : public test::CallTest {
receiver_call_.reset(Call::Create(config));
sender_call_.reset(Call::Create(config));
send_transport_.SetReceiver(receiver_call_->Receiver());
receive_transport_.SetReceiver(sender_call_->Receiver());
send_transport_.reset(new test::DirectTransport(sender_call_.get()));
send_transport_->SetReceiver(receiver_call_->Receiver());
receive_transport_.reset(new test::DirectTransport(receiver_call_.get()));
receive_transport_->SetReceiver(sender_call_->Receiver());
send_config_ = VideoSendStream::Config(&send_transport_);
send_config_ = VideoSendStream::Config(send_transport_.get());
send_config_.rtp.ssrcs.push_back(kSendSsrcs[0]);
// Encoders will be set separately per stream.
send_config_.encoder_settings.encoder = nullptr;
@ -147,7 +141,7 @@ class BitrateEstimatorTest : public test::CallTest {
send_config_.encoder_settings.payload_type = kFakeSendPayloadType;
encoder_config_.streams = test::CreateVideoStreams(1);
receive_config_ = VideoReceiveStream::Config(&receive_transport_);
receive_config_ = VideoReceiveStream::Config(receive_transport_.get());
// receive_config_.decoders will be set by every stream separately.
receive_config_.rtp.remote_ssrc = send_config_.rtp.ssrcs[0];
receive_config_.rtp.local_ssrc = kReceiverLocalSsrc;
@ -162,8 +156,8 @@ class BitrateEstimatorTest : public test::CallTest {
std::for_each(streams_.begin(), streams_.end(),
std::mem_fun(&Stream::StopSending));
send_transport_.StopSending();
receive_transport_.StopSending();
send_transport_->StopSending();
receive_transport_->StopSending();
while (!streams_.empty()) {
delete streams_.back();
@ -211,8 +205,8 @@ class BitrateEstimatorTest : public test::CallTest {
receive_config.rtp.extensions.push_back(
RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId));
receive_config.combined_audio_video_bwe = true;
audio_receive_stream_ = test_->receiver_call_->CreateAudioReceiveStream(
receive_config);
audio_receive_stream_ =
test_->receiver_call_->CreateAudioReceiveStream(receive_config);
} else {
VideoReceiveStream::Decoder decoder;
decoder.decoder = &fake_decoder_;
@ -270,8 +264,8 @@ class BitrateEstimatorTest : public test::CallTest {
test::FakeVoiceEngine fake_voice_engine_;
TraceObserver receiver_trace_;
test::DirectTransport send_transport_;
test::DirectTransport receive_transport_;
rtc::scoped_ptr<test::DirectTransport> send_transport_;
rtc::scoped_ptr<test::DirectTransport> receive_transport_;
rtc::scoped_ptr<Call> sender_call_;
rtc::scoped_ptr<Call> receiver_call_;
VideoReceiveStream::Config receive_config_;

1
webrtc/call/call.cc
View File

@ -463,7 +463,6 @@ void Call::SignalNetworkState(NetworkState state) {
}
void Call::OnSentPacket(const rtc::SentPacket& sent_packet) {
RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
congestion_controller_->OnSentPacket(sent_packet);
}

101
webrtc/call/call_perf_tests.cc
View File

@ -58,8 +58,7 @@ class CallPerfTest : public test::CallTest {
class SyncRtcpObserver : public test::RtpRtcpObserver {
public:
explicit SyncRtcpObserver(const FakeNetworkPipe::Config& config)
: test::RtpRtcpObserver(CallPerfTest::kLongTimeoutMs, config) {}
SyncRtcpObserver() : test::RtpRtcpObserver(CallPerfTest::kLongTimeoutMs) {}
Action OnSendRtcp(const uint8_t* packet, size_t length) override {
RTCPUtility::RTCPParserV2 parser(packet, length, true);
@ -127,8 +126,7 @@ class VideoRtcpAndSyncObserver : public SyncRtcpObserver, public VideoRenderer {
int voe_channel,
VoEVideoSync* voe_sync,
SyncRtcpObserver* audio_observer)
: SyncRtcpObserver(FakeNetworkPipe::Config()),
clock_(clock),
: clock_(clock),
voe_channel_(voe_channel),
voe_sync_(voe_sync),
audio_observer_(audio_observer),
@ -182,10 +180,10 @@ class VideoRtcpAndSyncObserver : public SyncRtcpObserver, public VideoRenderer {
private:
Clock* const clock_;
int voe_channel_;
VoEVideoSync* voe_sync_;
SyncRtcpObserver* audio_observer_;
int64_t creation_time_ms_;
const int voe_channel_;
VoEVideoSync* const voe_sync_;
SyncRtcpObserver* const audio_observer_;
const int64_t creation_time_ms_;
int64_t first_time_in_sync_;
};
@ -232,14 +230,7 @@ void CallPerfTest::TestAudioVideoSync(bool fec, bool create_audio_first) {
EXPECT_EQ(0, voe_base->Init(&fake_audio_device, nullptr));
int channel = voe_base->CreateChannel();
FakeNetworkPipe::Config net_config;
net_config.queue_delay_ms = 500;
net_config.loss_percent = 5;
SyncRtcpObserver audio_observer(net_config);
VideoRtcpAndSyncObserver observer(Clock::GetRealTimeClock(),
channel,
voe_sync,
&audio_observer);
SyncRtcpObserver audio_observer;
Call::Config receiver_config;
receiver_config.voice_engine = voice_engine;
@ -249,19 +240,38 @@ void CallPerfTest::TestAudioVideoSync(bool fec, bool create_audio_first) {
EXPECT_EQ(0, voe_codec->SetSendCodec(channel, isac));
AudioPacketReceiver voe_packet_receiver(channel, voe_network);
audio_observer.SetReceivers(&voe_packet_receiver, &voe_packet_receiver);
internal::TransportAdapter transport_adapter(audio_observer.SendTransport());
FakeNetworkPipe::Config net_config;
net_config.queue_delay_ms = 500;
net_config.loss_percent = 5;
test::PacketTransport audio_send_transport(
nullptr, &audio_observer, test::PacketTransport::kSender, net_config);
audio_send_transport.SetReceiver(&voe_packet_receiver);
test::PacketTransport audio_receive_transport(
nullptr, &audio_observer, test::PacketTransport::kReceiver, net_config);
audio_receive_transport.SetReceiver(&voe_packet_receiver);
internal::TransportAdapter transport_adapter(&audio_send_transport);
transport_adapter.Enable();
EXPECT_EQ(0,
voe_network->RegisterExternalTransport(channel, transport_adapter));
observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
VideoRtcpAndSyncObserver observer(Clock::GetRealTimeClock(), channel,
voe_sync, &audio_observer);
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::FakeDecoder fake_decoder;
CreateSendConfig(1, observer.SendTransport());
CreateMatchingReceiveConfigs(observer.ReceiveTransport());
CreateSendConfig(1, &sync_send_transport);
CreateMatchingReceiveConfigs(&sync_receive_transport);
send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
if (fec) {
@ -308,8 +318,10 @@ void CallPerfTest::TestAudioVideoSync(bool fec, bool create_audio_first) {
fake_audio_device.Stop();
Stop();
observer.StopSending();
audio_observer.StopSending();
sync_send_transport.StopSending();
sync_receive_transport.StopSending();
audio_send_transport.StopSending();
audio_receive_transport.StopSending();
voe_base->DeleteChannel(channel);
voe_base->Release();
@ -345,11 +357,8 @@ void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
class CaptureNtpTimeObserver : public test::EndToEndTest,
public VideoRenderer {
public:
CaptureNtpTimeObserver(const FakeNetworkPipe::Config& config,
int threshold_ms,
int start_time_ms,
int run_time_ms)
: EndToEndTest(kLongTimeoutMs, config),
CaptureNtpTimeObserver(int threshold_ms, int start_time_ms, int run_time_ms)
: EndToEndTest(kLongTimeoutMs),
clock_(Clock::GetRealTimeClock()),
threshold_ms_(threshold_ms),
start_time_ms_(start_time_ms),
@ -362,6 +371,7 @@ void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
private:
void RenderFrame(const VideoFrame& video_frame,
int time_to_render_ms) override {
rtc::CritScope lock(&crit_);
if (video_frame.ntp_time_ms() <= 0) {
// Haven't got enough RTCP SR in order to calculate the capture ntp
// time.
@ -402,6 +412,7 @@ void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
bool IsTextureSupported() const override { return false; }
virtual Action OnSendRtp(const uint8_t* packet, size_t length) {
rtc::CritScope lock(&crit_);
RTPHeader header;
EXPECT_TRUE(parser_->Parse(packet, length, &header));
@ -440,7 +451,8 @@ void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
"within bounds.";
}
Clock* clock_;
rtc::CriticalSection crit_;
Clock* const clock_;
int threshold_ms_;
int start_time_ms_;
int run_time_ms_;
@ -449,10 +461,10 @@ void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
bool rtp_start_timestamp_set_;
uint32_t rtp_start_timestamp_;
typedef std::map<uint32_t, uint32_t> FrameCaptureTimeList;
FrameCaptureTimeList capture_time_list_;
} test(net_config, threshold_ms, start_time_ms, run_time_ms);
FrameCaptureTimeList capture_time_list_ GUARDED_BY(&crit_);
} test(threshold_ms, start_time_ms, run_time_ms);
RunBaseTest(&test);
RunBaseTest(&test, net_config);
}
TEST_F(CallPerfTest, CaptureNtpTimeWithNetworkDelay) {
@ -508,7 +520,7 @@ void CallPerfTest::TestCpuOveruse(LoadObserver::Load tested_load,
test::DelayedEncoder encoder_;
} test(tested_load, encode_delay_ms);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(CallPerfTest, ReceivesCpuUnderuse) {
@ -528,26 +540,17 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
static const int kMaxAcceptableTransmitBitrate = 170;
static const int kNumBitrateObservationsInRange = 100;
static const int kAcceptableBitrateErrorMargin = 15; // +- 7
class BitrateObserver : public test::EndToEndTest, public PacketReceiver {
class BitrateObserver : public test::EndToEndTest {
public:
explicit BitrateObserver(bool using_min_transmit_bitrate)
: EndToEndTest(kLongTimeoutMs),
send_stream_(nullptr),
send_transport_receiver_(nullptr),
pad_to_min_bitrate_(using_min_transmit_bitrate),
num_bitrate_observations_in_range_(0) {}
private:
void SetReceivers(PacketReceiver* send_transport_receiver,
PacketReceiver* receive_transport_receiver) override {
send_transport_receiver_ = send_transport_receiver;
test::RtpRtcpObserver::SetReceivers(this, receive_transport_receiver);
}
DeliveryStatus DeliverPacket(MediaType media_type,
const uint8_t* packet,
size_t length,
const PacketTime& packet_time) override {
// TODO(holmer): Run this with a timer instead of once per packet.
Action OnSendRtp(const uint8_t* packet, size_t length) override {
VideoSendStream::Stats stats = send_stream_->GetStats();
if (stats.substreams.size() > 0) {
RTC_DCHECK_EQ(1u, stats.substreams.size());
@ -581,8 +584,7 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
observation_complete_->Set();
}
}
return send_transport_receiver_->DeliverPacket(media_type, packet, length,
packet_time);
return SEND_PACKET;
}
void OnStreamsCreated(
@ -607,13 +609,12 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
}
VideoSendStream* send_stream_;
PacketReceiver* send_transport_receiver_;
const bool pad_to_min_bitrate_;
int num_bitrate_observations_in_range_;
} test(pad_to_min_bitrate);
fake_encoder_.SetMaxBitrate(kMaxEncodeBitrateKbps);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(CallPerfTest, PadsToMinTransmitBitrate) { TestMinTransmitBitrate(true); }
@ -708,7 +709,7 @@ TEST_F(CallPerfTest, KeepsHighBitrateWhenReconfiguringSender) {
VideoEncoderConfig encoder_config_;
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
} // namespace webrtc

13
webrtc/modules/rtp_rtcp/source/rtp_sender.cc
View File

@ -680,13 +680,13 @@ size_t RTPSender::SendPadData(size_t bytes,
UpdateTransportSequenceNumber(padding_packet, length, rtp_header);
}
if (!SendPacketToNetwork(padding_packet, length, options))
break;
if (using_transport_seq && transport_feedback_observer_) {
transport_feedback_observer_->AddPacket(options.packet_id, length, true);
}
if (!SendPacketToNetwork(padding_packet, length, options))
break;
bytes_sent += padding_bytes_in_packet;
UpdateRtpStats(padding_packet, length, rtp_header, over_rtx, false);
}
@ -940,14 +940,15 @@ bool RTPSender::PrepareAndSendPacket(uint8_t* buffer,
UpdateTransportSequenceNumber(buffer_to_send_ptr, length, rtp_header);
}
if (using_transport_seq && transport_feedback_observer_) {
transport_feedback_observer_->AddPacket(options.packet_id, length, true);
}
bool ret = SendPacketToNetwork(buffer_to_send_ptr, length, options);
if (ret) {
CriticalSectionScoped lock(send_critsect_.get());
media_has_been_sent_ = true;
}
if (using_transport_seq && transport_feedback_observer_) {
transport_feedback_observer_->AddPacket(options.packet_id, length, true);
}
UpdateRtpStats(buffer_to_send_ptr, length, rtp_header, send_over_rtx,
is_retransmit);
return ret;

39
webrtc/test/call_test.cc
View File

@ -27,22 +27,30 @@ CallTest::CallTest()
CallTest::~CallTest() {
}
void CallTest::RunBaseTest(BaseTest* test) {
void CallTest::RunBaseTest(BaseTest* test,
const FakeNetworkPipe::Config& config) {
CreateSenderCall(test->GetSenderCallConfig());
if (test->ShouldCreateReceivers())
CreateReceiverCall(test->GetReceiverCallConfig());
send_transport_.reset(new PacketTransport(
sender_call_.get(), test, test::PacketTransport::kSender, config));
receive_transport_.reset(new PacketTransport(
nullptr, test, test::PacketTransport::kReceiver, config));
test->OnTransportsCreated(send_transport_.get(), receive_transport_.get());
test->OnCallsCreated(sender_call_.get(), receiver_call_.get());
if (test->ShouldCreateReceivers()) {
test->SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
send_transport_->SetReceiver(receiver_call_->Receiver());
receive_transport_->SetReceiver(sender_call_->Receiver());
} else {
// Sender-only call delivers to itself.
test->SetReceivers(sender_call_->Receiver(), NULL);
send_transport_->SetReceiver(sender_call_->Receiver());
receive_transport_->SetReceiver(nullptr);
}
CreateSendConfig(test->GetNumStreams(), test->SendTransport());
CreateSendConfig(test->GetNumStreams(), send_transport_.get());
if (test->ShouldCreateReceivers()) {
CreateMatchingReceiveConfigs(test->ReceiveTransport());
CreateMatchingReceiveConfigs(receive_transport_.get());
}
test->ModifyConfigs(&send_config_, &receive_configs_, &encoder_config_);
CreateStreams();
@ -53,7 +61,8 @@ void CallTest::RunBaseTest(BaseTest* test) {
Start();
test->PerformTest();
test->StopSending();
send_transport_->StopSending();
receive_transport_->StopSending();
Stop();
DestroyStreams();
@ -182,11 +191,6 @@ const int CallTest::kAbsSendTimeExtensionId = 7;
BaseTest::BaseTest(unsigned int timeout_ms) : RtpRtcpObserver(timeout_ms) {
}
BaseTest::BaseTest(unsigned int timeout_ms,
const FakeNetworkPipe::Config& config)
: RtpRtcpObserver(timeout_ms, config) {
}
BaseTest::~BaseTest() {
}
@ -201,6 +205,9 @@ Call::Config BaseTest::GetReceiverCallConfig() {
void BaseTest::OnCallsCreated(Call* sender_call, Call* receiver_call) {
}
void BaseTest::OnTransportsCreated(PacketTransport* send_transport,
PacketTransport* receive_transport) {}
size_t BaseTest::GetNumStreams() const {
return 1;
}
@ -223,11 +230,6 @@ void BaseTest::OnFrameGeneratorCapturerCreated(
SendTest::SendTest(unsigned int timeout_ms) : BaseTest(timeout_ms) {
}
SendTest::SendTest(unsigned int timeout_ms,
const FakeNetworkPipe::Config& config)
: BaseTest(timeout_ms, config) {
}
bool SendTest::ShouldCreateReceivers() const {
return false;
}
@ -235,11 +237,6 @@ bool SendTest::ShouldCreateReceivers() const {
EndToEndTest::EndToEndTest(unsigned int timeout_ms) : BaseTest(timeout_ms) {
}
EndToEndTest::EndToEndTest(unsigned int timeout_ms,
const FakeNetworkPipe::Config& config)
: BaseTest(timeout_ms, config) {
}
bool EndToEndTest::ShouldCreateReceivers() const {
return true;
}

9
webrtc/test/call_test.h
View File

@ -46,7 +46,7 @@ class CallTest : public ::testing::Test {
static const int kAbsSendTimeExtensionId;
protected:
void RunBaseTest(BaseTest* test);
void RunBaseTest(BaseTest* test, const FakeNetworkPipe::Config& config);
void CreateCalls(const Call::Config& sender_config,
const Call::Config& receiver_config);
@ -67,11 +67,13 @@ class CallTest : public ::testing::Test {
Clock* const clock_;
rtc::scoped_ptr<Call> sender_call_;
rtc::scoped_ptr<PacketTransport> send_transport_;
VideoSendStream::Config send_config_;
VideoEncoderConfig encoder_config_;
VideoSendStream* send_stream_;
rtc::scoped_ptr<Call> receiver_call_;
rtc::scoped_ptr<PacketTransport> receive_transport_;
std::vector<VideoReceiveStream::Config> receive_configs_;
std::vector<VideoReceiveStream*> receive_streams_;
@ -83,7 +85,6 @@ class CallTest : public ::testing::Test {
class BaseTest : public RtpRtcpObserver {
public:
explicit BaseTest(unsigned int timeout_ms);
BaseTest(unsigned int timeout_ms, const FakeNetworkPipe::Config& config);
virtual ~BaseTest();
virtual void PerformTest() = 0;
@ -94,6 +95,8 @@ class BaseTest : public RtpRtcpObserver {
virtual Call::Config GetSenderCallConfig();
virtual Call::Config GetReceiverCallConfig();
virtual void OnCallsCreated(Call* sender_call, Call* receiver_call);
virtual void OnTransportsCreated(PacketTransport* send_transport,
PacketTransport* receive_transport);
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
@ -110,7 +113,6 @@ class BaseTest : public RtpRtcpObserver {
class SendTest : public BaseTest {
public:
explicit SendTest(unsigned int timeout_ms);
SendTest(unsigned int timeout_ms, const FakeNetworkPipe::Config& config);
bool ShouldCreateReceivers() const override;
};
@ -118,7 +120,6 @@ class SendTest : public BaseTest {
class EndToEndTest : public BaseTest {
public:
explicit EndToEndTest(unsigned int timeout_ms);
EndToEndTest(unsigned int timeout_ms, const FakeNetworkPipe::Config& config);
bool ShouldCreateReceivers() const override;
};

16
webrtc/test/direct_transport.cc
View File

@ -17,8 +17,9 @@
namespace webrtc {
namespace test {
DirectTransport::DirectTransport()
: packet_event_(EventWrapper::Create()),
DirectTransport::DirectTransport(Call* send_call)
: send_call_(send_call),
packet_event_(EventWrapper::Create()),
thread_(
ThreadWrapper::CreateThread(NetworkProcess, this, "NetworkProcess")),
clock_(Clock::GetRealTimeClock()),
@ -27,8 +28,10 @@ DirectTransport::DirectTransport()
EXPECT_TRUE(thread_->Start());
}
DirectTransport::DirectTransport(const FakeNetworkPipe::Config& config)
: packet_event_(EventWrapper::Create()),
DirectTransport::DirectTransport(const FakeNetworkPipe::Config& config,
Call* send_call)
: send_call_(send_call),
packet_event_(EventWrapper::Create()),
thread_(
ThreadWrapper::CreateThread(NetworkProcess, this, "NetworkProcess")),
clock_(Clock::GetRealTimeClock()),
@ -60,6 +63,11 @@ void DirectTransport::SetReceiver(PacketReceiver* receiver) {
bool DirectTransport::SendRtp(const uint8_t* data,
size_t length,
const PacketOptions& options) {
if (send_call_) {
rtc::SentPacket sent_packet(options.packet_id,
clock_->TimeInMilliseconds());
send_call_->OnSentPacket(sent_packet);
}
fake_network_.SendPacket(data, length);
packet_event_->Set();
return true;

7
webrtc/test/direct_transport.h
View File

@ -23,6 +23,7 @@
namespace webrtc {
class Call;
class Clock;
class PacketReceiver;
@ -30,13 +31,14 @@ namespace test {
class DirectTransport : public Transport {
public:
DirectTransport();
explicit DirectTransport(const FakeNetworkPipe::Config& config);
explicit DirectTransport(Call* send_call);
DirectTransport(const FakeNetworkPipe::Config& config, Call* send_call);
~DirectTransport();
void SetConfig(const FakeNetworkPipe::Config& config);
virtual void StopSending();
// TODO(holmer): Look into moving this to the constructor.
virtual void SetReceiver(PacketReceiver* receiver);
bool SendRtp(const uint8_t* data,
@ -49,6 +51,7 @@ class DirectTransport : public Transport {
bool SendPackets();
rtc::CriticalSection lock_;
Call* const send_call_;
rtc::scoped_ptr<EventWrapper> packet_event_;
rtc::scoped_ptr<ThreadWrapper> thread_;
Clock* const clock_;

6
webrtc/test/layer_filtering_transport.cc
View File

@ -21,16 +21,16 @@ namespace test {
LayerFilteringTransport::LayerFilteringTransport(
const FakeNetworkPipe::Config& config,
Call* send_call,
uint8_t vp8_video_payload_type,
uint8_t vp9_video_payload_type,
uint8_t tl_discard_threshold,
uint8_t sl_discard_threshold)
: test::DirectTransport(config),
: test::DirectTransport(config, send_call),
vp8_video_payload_type_(vp8_video_payload_type),
vp9_video_payload_type_(vp9_video_payload_type),
tl_discard_threshold_(tl_discard_threshold),
sl_discard_threshold_(sl_discard_threshold) {
}
sl_discard_threshold_(sl_discard_threshold) {}
uint16_t LayerFilteringTransport::NextSequenceNumber(uint32_t ssrc) {
auto it = current_seq_nums_.find(ssrc);

2
webrtc/test/layer_filtering_transport.h
View File

@ -10,6 +10,7 @@
#ifndef WEBRTC_TEST_LAYER_FILTERING_TRANSPORT_H_
#define WEBRTC_TEST_LAYER_FILTERING_TRANSPORT_H_
#include "webrtc/call.h"
#include "webrtc/test/direct_transport.h"
#include "webrtc/test/fake_network_pipe.h"
@ -22,6 +23,7 @@ namespace test {
class LayerFilteringTransport : public test::DirectTransport {
public:
LayerFilteringTransport(const FakeNetworkPipe::Config& config,
Call* send_call,
uint8_t vp8_video_payload_type,
uint8_t vp9_video_payload_type,
uint8_t tl_discard_threshold,

215
webrtc/test/rtp_rtcp_observer.h
View File

@ -24,160 +24,109 @@
namespace webrtc {
namespace test {
class PacketTransport;
class RtpRtcpObserver {
public:
enum Action {
SEND_PACKET,
DROP_PACKET,
};
virtual ~RtpRtcpObserver() {}
Transport* SendTransport() {
return &send_transport_;
}
Transport* ReceiveTransport() {
return &receive_transport_;
}
virtual void SetReceivers(PacketReceiver* send_transport_receiver,
PacketReceiver* receive_transport_receiver) {
send_transport_.SetReceiver(send_transport_receiver);
receive_transport_.SetReceiver(receive_transport_receiver);
}
void StopSending() {
send_transport_.StopSending();
receive_transport_.StopSending();
}
virtual EventTypeWrapper Wait() {
EventTypeWrapper result = observation_complete_->Wait(timeout_ms_);
return result;
}
protected:
RtpRtcpObserver(unsigned int event_timeout_ms,
const FakeNetworkPipe::Config& configuration)
: observation_complete_(EventWrapper::Create()),
parser_(RtpHeaderParser::Create()),
send_transport_(&crit_,
this,
&RtpRtcpObserver::OnSendRtp,
&RtpRtcpObserver::OnSendRtcp,
configuration),
receive_transport_(&crit_,
this,
&RtpRtcpObserver::OnReceiveRtp,
&RtpRtcpObserver::OnReceiveRtcp,
configuration),
timeout_ms_(event_timeout_ms) {}
virtual Action OnSendRtp(const uint8_t* packet, size_t length) {
return SEND_PACKET;
}
virtual Action OnSendRtcp(const uint8_t* packet, size_t length) {
return SEND_PACKET;
}
virtual Action OnReceiveRtp(const uint8_t* packet, size_t length) {
return SEND_PACKET;
}
virtual Action OnReceiveRtcp(const uint8_t* packet, size_t length) {
return SEND_PACKET;
}
protected:
explicit RtpRtcpObserver(unsigned int event_timeout_ms)
: observation_complete_(EventWrapper::Create()),
parser_(RtpHeaderParser::Create()),
send_transport_(&crit_,
this,
&RtpRtcpObserver::OnSendRtp,
&RtpRtcpObserver::OnSendRtcp,
FakeNetworkPipe::Config()),
receive_transport_(&crit_,
this,
&RtpRtcpObserver::OnReceiveRtp,
&RtpRtcpObserver::OnReceiveRtcp,
FakeNetworkPipe::Config()),
timeout_ms_(event_timeout_ms) {}
enum Action {
SEND_PACKET,
DROP_PACKET,
};
virtual Action OnSendRtp(const uint8_t* packet, size_t length)
EXCLUSIVE_LOCKS_REQUIRED(crit_) {
return SEND_PACKET;
}
virtual Action OnSendRtcp(const uint8_t* packet, size_t length)
EXCLUSIVE_LOCKS_REQUIRED(crit_) {
return SEND_PACKET;
}
virtual Action OnReceiveRtp(const uint8_t* packet, size_t length)
EXCLUSIVE_LOCKS_REQUIRED(crit_) {
return SEND_PACKET;
}
virtual Action OnReceiveRtcp(const uint8_t* packet, size_t length)
EXCLUSIVE_LOCKS_REQUIRED(crit_) {
return SEND_PACKET;
}
private:
class PacketTransport : public test::DirectTransport {
public:
typedef Action (RtpRtcpObserver::*PacketTransportAction)(const uint8_t*,
size_t);
PacketTransport(rtc::CriticalSection* lock,
RtpRtcpObserver* observer,
PacketTransportAction on_rtp,
PacketTransportAction on_rtcp,
const FakeNetworkPipe::Config& configuration)
: test::DirectTransport(configuration),
crit_(lock),
observer_(observer),
on_rtp_(on_rtp),
on_rtcp_(on_rtcp) {}
private:
bool SendRtp(const uint8_t* packet,
size_t length,
const PacketOptions& options) override {
EXPECT_FALSE(RtpHeaderParser::IsRtcp(packet, length));
Action action;
{
rtc::CritScope lock(crit_);
action = (observer_->*on_rtp_)(packet, length);
}
switch (action) {
case DROP_PACKET:
// Drop packet silently.
return true;
case SEND_PACKET:
return test::DirectTransport::SendRtp(packet, length, options);
}
return true; // Will never happen, makes compiler happy.
}
bool SendRtcp(const uint8_t* packet, size_t length) override {
EXPECT_TRUE(RtpHeaderParser::IsRtcp(packet, length));
Action action;
{
rtc::CritScope lock(crit_);
action = (observer_->*on_rtcp_)(packet, length);
}
switch (action) {
case DROP_PACKET:
// Drop packet silently.
return true;
case SEND_PACKET:
return test::DirectTransport::SendRtcp(packet, length);
}
return true; // Will never happen, makes compiler happy.
}
// Pointer to shared lock instance protecting on_rtp_/on_rtcp_ calls.
rtc::CriticalSection* const crit_;
RtpRtcpObserver* const observer_;
const PacketTransportAction on_rtp_, on_rtcp_;
};
protected:
rtc::CriticalSection crit_;
const rtc::scoped_ptr<EventWrapper> observation_complete_;
const rtc::scoped_ptr<RtpHeaderParser> parser_;
PacketTransport send_transport_, receive_transport_;
private:
unsigned int timeout_ms_;
};
class PacketTransport : public test::DirectTransport {
public:
enum TransportType { kReceiver, kSender };
PacketTransport(Call* send_call,
RtpRtcpObserver* observer,
TransportType transport_type,
const FakeNetworkPipe::Config& configuration)
: test::DirectTransport(configuration, send_call),
observer_(observer),
transport_type_(transport_type) {}
private:
bool SendRtp(const uint8_t* packet,
size_t length,
const PacketOptions& options) override {
EXPECT_FALSE(RtpHeaderParser::IsRtcp(packet, length));
RtpRtcpObserver::Action action;
{
if (transport_type_ == kSender) {
action = observer_->OnSendRtp(packet, length);
} else {
action = observer_->OnReceiveRtp(packet, length);
}
}
switch (action) {
case RtpRtcpObserver::DROP_PACKET:
// Drop packet silently.
return true;
case RtpRtcpObserver::SEND_PACKET:
return test::DirectTransport::SendRtp(packet, length, options);
}
return true; // Will never happen, makes compiler happy.
}
bool SendRtcp(const uint8_t* packet, size_t length) override {
EXPECT_TRUE(RtpHeaderParser::IsRtcp(packet, length));
RtpRtcpObserver::Action action;
{
if (transport_type_ == kSender) {
action = observer_->OnSendRtcp(packet, length);
} else {
action = observer_->OnReceiveRtcp(packet, length);
}
}
switch (action) {
case RtpRtcpObserver::DROP_PACKET:
// Drop packet silently.
return true;
case RtpRtcpObserver::SEND_PACKET:
return test::DirectTransport::SendRtcp(packet, length);
}
return true; // Will never happen, makes compiler happy.
}
RtpRtcpObserver* const observer_;
TransportType transport_type_;
};
} // namespace test
} // namespace webrtc

200
webrtc/video/end_to_end_tests.cc
View File

@ -81,7 +81,6 @@ class EndToEndTest : public test::CallTest {
void TestXrReceiverReferenceTimeReport(bool enable_rrtr);
void TestSendsSetSsrcs(size_t num_ssrcs, bool send_single_ssrc_first);
void TestRtpStatePreservation(bool use_rtx);
void TestReceivedFecPacketsNotNacked(const FakeNetworkPipe::Config& config);
void VerifyHistogramStats(bool use_rtx, bool use_red);
};
@ -156,7 +155,8 @@ TEST_F(EndToEndTest, RendersSingleDelayedFrame) {
CreateCalls(Call::Config(), Call::Config());
test::DirectTransport sender_transport, receiver_transport;
test::DirectTransport sender_transport(sender_call_.get());
test::DirectTransport receiver_transport(receiver_call_.get());
sender_transport.SetReceiver(receiver_call_->Receiver());
receiver_transport.SetReceiver(sender_call_->Receiver());
@ -206,7 +206,8 @@ TEST_F(EndToEndTest, TransmitsFirstFrame) {
CreateCalls(Call::Config(), Call::Config());
test::DirectTransport sender_transport, receiver_transport;
test::DirectTransport sender_transport(sender_call_.get());
test::DirectTransport receiver_transport(receiver_call_.get());
sender_transport.SetReceiver(receiver_call_->Receiver());
receiver_transport.SetReceiver(sender_call_->Receiver());
@ -281,7 +282,7 @@ TEST_F(EndToEndTest, SendsAndReceivesVP9) {
int frame_counter_;
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(EndToEndTest, SendsAndReceivesH264) {
@ -333,7 +334,7 @@ TEST_F(EndToEndTest, SendsAndReceivesH264) {
int frame_counter_;
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(EndToEndTest, ReceiverUsesLocalSsrc) {
@ -361,7 +362,7 @@ TEST_F(EndToEndTest, ReceiverUsesLocalSsrc) {
}
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) {
@ -379,6 +380,7 @@ TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) {
private:
Action OnSendRtp(const uint8_t* packet, size_t length) override {
rtc::CritScope lock(&crit_);
RTPHeader header;
EXPECT_TRUE(rtp_parser_->Parse(packet, length, &header));
@ -414,6 +416,7 @@ TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) {
}
Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
rtc::CritScope lock(&crit_);
RTCPUtility::RTCPParserV2 parser(packet, length, true);
EXPECT_TRUE(parser.IsValid());
@ -441,15 +444,16 @@ TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) {
"rendered.";
}
rtc::CriticalSection crit_;
rtc::scoped_ptr<RtpHeaderParser> rtp_parser_;
std::set<uint16_t> dropped_packets_;
std::set<uint16_t> retransmitted_packets_;
uint64_t sent_rtp_packets_;
int packets_left_to_drop_;
int nacks_left_;
int nacks_left_ GUARDED_BY(&crit_);
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(EndToEndTest, CanReceiveFec) {
@ -459,8 +463,8 @@ TEST_F(EndToEndTest, CanReceiveFec) {
: EndToEndTest(kDefaultTimeoutMs), state_(kFirstPacket) {}
private:
Action OnSendRtp(const uint8_t* packet, size_t length) override
EXCLUSIVE_LOCKS_REQUIRED(crit_) {
Action OnSendRtp(const uint8_t* packet, size_t length) override {
rtc::CritScope lock(&crit_);
RTPHeader header;
EXPECT_TRUE(parser_->Parse(packet, length, &header));
@ -544,29 +548,20 @@ TEST_F(EndToEndTest, CanReceiveFec) {
<< "Timed out waiting for dropped frames frames to be rendered.";
}
rtc::CriticalSection crit_;
std::set<uint32_t> protected_sequence_numbers_ GUARDED_BY(crit_);
std::set<uint32_t> protected_timestamps_ GUARDED_BY(crit_);
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
// Flacky on all platforms. See webrtc:4328.
TEST_F(EndToEndTest, DISABLED_ReceivedFecPacketsNotNacked) {
// At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
// Configure some network delay.
const int kNetworkDelayMs = 50;
FakeNetworkPipe::Config config;
config.queue_delay_ms = kNetworkDelayMs;
TestReceivedFecPacketsNotNacked(config);
}
void EndToEndTest::TestReceivedFecPacketsNotNacked(
const FakeNetworkPipe::Config& config) {
class FecNackObserver : public test::EndToEndTest {
public:
explicit FecNackObserver(const FakeNetworkPipe::Config& config)
: EndToEndTest(kDefaultTimeoutMs, config),
explicit FecNackObserver()
: EndToEndTest(kDefaultTimeoutMs),
state_(kFirstPacket),
fec_sequence_number_(0),
has_last_sequence_number_(false),
@ -674,9 +669,14 @@ void EndToEndTest::TestReceivedFecPacketsNotNacked(
uint16_t fec_sequence_number_;
bool has_last_sequence_number_;
uint16_t last_sequence_number_;
} test(config);
} test;
RunBaseTest(&test);
// At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
// Configure some network delay.
const int kNetworkDelayMs = 50;
FakeNetworkPipe::Config config;
config.queue_delay_ms = kNetworkDelayMs;
RunBaseTest(&test, config);
}
// This test drops second RTP packet with a marker bit set, makes sure it's
@ -700,6 +700,7 @@ void EndToEndTest::DecodesRetransmittedFrame(bool use_rtx, bool use_red) {
private:
Action OnSendRtp(const uint8_t* packet, size_t length) override {
rtc::CritScope lock(&crit_);
RTPHeader header;
EXPECT_TRUE(parser_->Parse(packet, length, &header));
@ -773,16 +774,17 @@ void EndToEndTest::DecodesRetransmittedFrame(bool use_rtx, bool use_red) {
: (use_red ? kRedPayloadType : kFakeSendPayloadType);
}
rtc::CriticalSection crit_;
const int payload_type_;
const uint32_t retransmission_ssrc_;
const int retransmission_payload_type_;
int marker_bits_observed_;
int num_packets_observed_;
uint32_t retransmitted_timestamp_;
uint32_t retransmitted_timestamp_ GUARDED_BY(&crit_);
bool frame_retransmitted_;
} test(use_rtx, use_red);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(EndToEndTest, DecodesRetransmittedFrame) {
@ -861,7 +863,8 @@ TEST_F(EndToEndTest, UsesFrameCallbacks) {
CreateCalls(Call::Config(), Call::Config());
test::DirectTransport sender_transport, receiver_transport;
test::DirectTransport sender_transport(sender_call_.get());
test::DirectTransport receiver_transport(receiver_call_.get());
sender_transport.SetReceiver(receiver_call_->Receiver());
receiver_transport.SetReceiver(sender_call_->Receiver());
@ -918,6 +921,7 @@ void EndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) {
private:
Action OnSendRtp(const uint8_t* packet, size_t length) override {
rtc::CritScope lock(&crit_);
RTPHeader header;
EXPECT_TRUE(parser_->Parse(packet, length, &header));
@ -935,6 +939,7 @@ void EndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) {
}
Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
rtc::CritScope lock(&crit_);
RTCPUtility::RTCPParserV2 parser(packet, length, true);
EXPECT_TRUE(parser.IsValid());
@ -979,14 +984,15 @@ void EndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) {
"rendered afterwards.";
}
rtc::CriticalSection crit_;
int rtp_history_ms_;
bool nack_enabled_;
uint32_t highest_dropped_timestamp_;
int frames_to_drop_;
bool received_pli_;
uint32_t highest_dropped_timestamp_ GUARDED_BY(&crit_);
int frames_to_drop_ GUARDED_BY(&crit_);
bool received_pli_ GUARDED_BY(&crit_);
} test(rtp_history_ms);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(EndToEndTest, ReceivesPliAndRecoversWithNack) {
@ -1031,7 +1037,8 @@ TEST_F(EndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
CreateCalls(Call::Config(), Call::Config());
test::DirectTransport send_transport, receive_transport;
test::DirectTransport send_transport(sender_call_.get());
test::DirectTransport receive_transport(receiver_call_.get());
PacketInputObserver input_observer(receiver_call_->Receiver());
send_transport.SetReceiver(&input_observer);
receive_transport.SetReceiver(sender_call_->Receiver());
@ -1135,7 +1142,7 @@ void EndToEndTest::RespectsRtcpMode(RtcpMode rtcp_mode) {
int sent_rtcp_;
} test(rtcp_mode);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(EndToEndTest, UsesRtcpCompoundMode) {
@ -1167,13 +1174,12 @@ class MultiStreamTest {
virtual ~MultiStreamTest() {}
void RunTest() {
rtc::scoped_ptr<test::DirectTransport> sender_transport(
CreateSendTransport());
rtc::scoped_ptr<test::DirectTransport> receiver_transport(
CreateReceiveTransport());
rtc::scoped_ptr<Call> sender_call(Call::Create(Call::Config()));
rtc::scoped_ptr<Call> receiver_call(Call::Create(Call::Config()));
rtc::scoped_ptr<test::DirectTransport> sender_transport(
CreateSendTransport(sender_call.get()));
rtc::scoped_ptr<test::DirectTransport> receiver_transport(
CreateReceiveTransport(receiver_call.get()));
sender_transport->SetReceiver(receiver_call->Receiver());
receiver_transport->SetReceiver(sender_call->Receiver());
@ -1257,11 +1263,11 @@ class MultiStreamTest {
virtual void UpdateReceiveConfig(size_t stream_index,
VideoReceiveStream::Config* receive_config) {
}
virtual test::DirectTransport* CreateSendTransport() {
return new test::DirectTransport();
virtual test::DirectTransport* CreateSendTransport(Call* sender_call) {
return new test::DirectTransport(sender_call);
}
virtual test::DirectTransport* CreateReceiveTransport() {
return new test::DirectTransport();
virtual test::DirectTransport* CreateReceiveTransport(Call* receiver_call) {
return new test::DirectTransport(receiver_call);
}
};
@ -1340,9 +1346,11 @@ TEST_F(EndToEndTest, AssignsTransportSequenceNumbers) {
class RtpExtensionHeaderObserver : public test::DirectTransport {
public:
RtpExtensionHeaderObserver(const uint32_t& first_media_ssrc,
RtpExtensionHeaderObserver(Call* sender_call,
const uint32_t& first_media_ssrc,
const std::map<uint32_t, uint32_t>& ssrc_map)
: done_(EventWrapper::Create()),
: DirectTransport(sender_call),
done_(EventWrapper::Create()),
parser_(RtpHeaderParser::Create()),
first_media_ssrc_(first_media_ssrc),
rtx_to_media_ssrcs_(ssrc_map),
@ -1507,8 +1515,8 @@ TEST_F(EndToEndTest, AssignsTransportSequenceNumbers) {
RtpExtension(RtpExtension::kTransportSequenceNumber, kExtensionId));
}
virtual test::DirectTransport* CreateSendTransport() {
observer_ = new RtpExtensionHeaderObserver(first_media_ssrc_,
test::DirectTransport* CreateSendTransport(Call* sender_call) override {
observer_ = new RtpExtensionHeaderObserver(sender_call, first_media_ssrc_,
rtx_to_media_ssrcs_);
return observer_;
}
@ -1527,7 +1535,8 @@ TEST_F(EndToEndTest, ReceivesTransportFeedback) {
class TransportFeedbackObserver : public test::DirectTransport {
public:
TransportFeedbackObserver(rtc::Event* done_event) : done_(done_event) {}
TransportFeedbackObserver(Call* receiver_call, rtc::Event* done_event)
: DirectTransport(receiver_call), done_(done_event) {}
virtual ~TransportFeedbackObserver() {}
bool SendRtcp(const uint8_t* data, size_t length) override {
@ -1575,8 +1584,9 @@ TEST_F(EndToEndTest, ReceivesTransportFeedback) {
RtpExtension(RtpExtension::kTransportSequenceNumber, kExtensionId));
}
virtual test::DirectTransport* CreateReceiveTransport() {
return new TransportFeedbackObserver(&done_);
test::DirectTransport* CreateReceiveTransport(
Call* receiver_call) override {
return new TransportFeedbackObserver(receiver_call, &done_);
}
private:
@ -1624,7 +1634,8 @@ TEST_F(EndToEndTest, ObserversEncodedFrames) {
CreateCalls(Call::Config(), Call::Config());
test::DirectTransport sender_transport, receiver_transport;
test::DirectTransport sender_transport(sender_call_.get());
test::DirectTransport receiver_transport(receiver_call_.get());
sender_transport.SetReceiver(receiver_call_->Receiver());
receiver_transport.SetReceiver(sender_call_->Receiver());
@ -1694,11 +1705,11 @@ TEST_F(EndToEndTest, ReceiveStreamSendsRemb) {
}
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(EndToEndTest, VerifyBandwidthStats) {
class RtcpObserver : public test::EndToEndTest, public PacketReceiver {
class RtcpObserver : public test::EndToEndTest {
public:
RtcpObserver()
: EndToEndTest(kDefaultTimeoutMs),
@ -1706,10 +1717,7 @@ TEST_F(EndToEndTest, VerifyBandwidthStats) {
receiver_call_(nullptr),
has_seen_pacer_delay_(false) {}
DeliveryStatus DeliverPacket(MediaType media_type,
const uint8_t* packet,
size_t length,
const PacketTime& packet_time) override {
Action OnSendRtp(const uint8_t* packet, size_t length) override {
Call::Stats sender_stats = sender_call_->GetStats();
Call::Stats receiver_stats = receiver_call_->GetStats();
if (!has_seen_pacer_delay_)
@ -1718,8 +1726,7 @@ TEST_F(EndToEndTest, VerifyBandwidthStats) {
receiver_stats.recv_bandwidth_bps > 0 && has_seen_pacer_delay_) {
observation_complete_->Set();
}
return receiver_call_->Receiver()->DeliverPacket(media_type, packet,
length, packet_time);
return SEND_PACKET;
}
void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
@ -1732,18 +1739,13 @@ TEST_F(EndToEndTest, VerifyBandwidthStats) {
"non-zero bandwidth stats.";
}
void SetReceivers(PacketReceiver* send_transport_receiver,
PacketReceiver* receive_transport_receiver) override {
test::RtpRtcpObserver::SetReceivers(this, receive_transport_receiver);
}
private:
Call* sender_call_;
Call* receiver_call_;
bool has_seen_pacer_delay_;
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(EndToEndTest, VerifyNackStats) {
@ -1844,7 +1846,7 @@ TEST_F(EndToEndTest, VerifyNackStats) {
} test;
test::ClearHistograms();
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
EXPECT_EQ(1, test::NumHistogramSamples(
"WebRTC.Video.UniqueNackRequestsSentInPercent"));
@ -1857,7 +1859,7 @@ TEST_F(EndToEndTest, VerifyNackStats) {
}
void EndToEndTest::VerifyHistogramStats(bool use_rtx, bool use_red) {
class StatsObserver : public test::EndToEndTest, public PacketReceiver {
class StatsObserver : public test::EndToEndTest {
public:
StatsObserver(bool use_rtx, bool use_red)
: EndToEndTest(kLongTimeoutMs),
@ -1872,20 +1874,13 @@ void EndToEndTest::VerifyHistogramStats(bool use_rtx, bool use_red) {
if (MinMetricRunTimePassed())
observation_complete_->Set();
return SEND_PACKET;
}
DeliveryStatus DeliverPacket(MediaType media_type,
const uint8_t* packet,
size_t length,
const PacketTime& packet_time) override {
// GetStats calls GetSendChannelRtcpStatistics
// (via VideoSendStream::GetRtt) which updates ReportBlockStats used by
// WebRTC.Video.SentPacketsLostInPercent.
// TODO(asapersson): Remove dependency on calling GetStats.
sender_call_->GetStats();
return receiver_call_->Receiver()->DeliverPacket(media_type, packet,
length, packet_time);
return SEND_PACKET;
}
bool MinMetricRunTimePassed() {
@ -1927,11 +1922,6 @@ void EndToEndTest::VerifyHistogramStats(bool use_rtx, bool use_red) {
receiver_call_ = receiver_call;
}
void SetReceivers(PacketReceiver* send_transport_receiver,
PacketReceiver* receive_transport_receiver) override {
test::RtpRtcpObserver::SetReceivers(this, receive_transport_receiver);
}
void PerformTest() override {
EXPECT_EQ(kEventSignaled, Wait())
<< "Timed out waiting for packet to be NACKed.";
@ -1945,7 +1935,7 @@ void EndToEndTest::VerifyHistogramStats(bool use_rtx, bool use_red) {
} test(use_rtx, use_red);
test::ClearHistograms();
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
// Verify that stats have been updated once.
EXPECT_EQ(1, test::NumHistogramSamples(
@ -2129,7 +2119,7 @@ void EndToEndTest::TestXrReceiverReferenceTimeReport(bool enable_rrtr) {
int sent_rtcp_dlrr_;
} test(enable_rrtr);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
@ -2227,7 +2217,7 @@ void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
VideoEncoderConfig encoder_config_all_streams_;
} test(kSendSsrcs, num_ssrcs, send_single_ssrc_first);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(EndToEndTest, ReportsSetEncoderRates) {
@ -2282,11 +2272,12 @@ TEST_F(EndToEndTest, ReportsSetEncoderRates) {
}
private:
rtc::CriticalSection crit_;
VideoSendStream* send_stream_;
uint32_t bitrate_kbps_ GUARDED_BY(crit_);
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(EndToEndTest, GetStats) {
@ -2294,8 +2285,8 @@ TEST_F(EndToEndTest, GetStats) {
static const int kExpectedRenderDelayMs = 20;
class StatsObserver : public test::EndToEndTest, public I420FrameCallback {
public:
explicit StatsObserver(const FakeNetworkPipe::Config& config)
: EndToEndTest(kLongTimeoutMs, config),
StatsObserver()
: EndToEndTest(kLongTimeoutMs),
send_stream_(nullptr),
expected_send_ssrcs_(),
check_stats_event_(EventWrapper::Create()) {}
@ -2542,13 +2533,11 @@ TEST_F(EndToEndTest, GetStats) {
std::string expected_cname_;
rtc::scoped_ptr<EventWrapper> check_stats_event_;
};
} test;
FakeNetworkPipe::Config network_config;
network_config.loss_percent = 5;
StatsObserver test(network_config);
RunBaseTest(&test);
RunBaseTest(&test, network_config);
}
TEST_F(EndToEndTest, ReceiverReferenceTimeReportEnabled) {
@ -2596,7 +2585,7 @@ TEST_F(EndToEndTest, TestReceivedRtpPacketStats) {
uint32_t sent_rtp_;
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(EndToEndTest, SendsSetSsrc) { TestSendsSetSsrcs(1, false); }
@ -2676,7 +2665,7 @@ TEST_F(EndToEndTest, DISABLED_RedundantPayloadsTransmittedOnAllSsrcs) {
std::map<uint32_t, bool> registered_rtx_ssrc_;
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
void EndToEndTest::TestRtpStatePreservation(bool use_rtx) {
@ -2771,9 +2760,17 @@ void EndToEndTest::TestRtpStatePreservation(bool use_rtx) {
} observer(use_rtx);
CreateCalls(Call::Config(), Call::Config());
observer.SetReceivers(sender_call_->Receiver(), nullptr);
CreateSendConfig(kNumSsrcs, observer.SendTransport());
test::PacketTransport send_transport(sender_call_.get(), &observer,
test::PacketTransport::kSender,
FakeNetworkPipe::Config());
test::PacketTransport receive_transport(nullptr, &observer,
test::PacketTransport::kReceiver,
FakeNetworkPipe::Config());
send_transport.SetReceiver(receiver_call_->Receiver());
receive_transport.SetReceiver(sender_call_->Receiver());
CreateSendConfig(kNumSsrcs, &send_transport);
if (use_rtx) {
for (size_t i = 0; i < kNumSsrcs; ++i) {
@ -2802,7 +2799,7 @@ void EndToEndTest::TestRtpStatePreservation(bool use_rtx) {
encoder_config_.streams[i].max_bitrate_bps;
}
CreateMatchingReceiveConfigs(observer.ReceiveTransport());
CreateMatchingReceiveConfigs(&receive_transport);
CreateStreams();
CreateFrameGeneratorCapturer();
@ -2847,7 +2844,8 @@ void EndToEndTest::TestRtpStatePreservation(bool use_rtx) {
<< "Timed out waiting for all SSRCs to send packets.";
}
observer.StopSending();
send_transport.StopSending();
receive_transport.StopSending();
Stop();
DestroyStreams();
@ -3033,7 +3031,7 @@ TEST_F(EndToEndTest, RespectsNetworkState) {
int down_frames_ GUARDED_BY(test_crit_);
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(EndToEndTest, CallReportsRttForSender) {
@ -3044,9 +3042,9 @@ TEST_F(EndToEndTest, CallReportsRttForSender) {
FakeNetworkPipe::Config config;
config.queue_delay_ms = kSendDelayMs;
test::DirectTransport sender_transport(config);
test::DirectTransport sender_transport(config, sender_call_.get());
config.queue_delay_ms = kReceiveDelayMs;
test::DirectTransport receiver_transport(config);
test::DirectTransport receiver_transport(config, receiver_call_.get());
sender_transport.SetReceiver(receiver_call_->Receiver());
receiver_transport.SetReceiver(sender_call_->Receiver());
@ -3108,7 +3106,7 @@ TEST_F(EndToEndTest, NewReceiveStreamsRespectNetworkDown) {
CreateCalls(Call::Config(), Call::Config());
receiver_call_->SignalNetworkState(kNetworkDown);
test::DirectTransport sender_transport;
test::DirectTransport sender_transport(sender_call_.get());
sender_transport.SetReceiver(receiver_call_->Receiver());
CreateSendConfig(1, &sender_transport);
UnusedTransport transport;

54
webrtc/video/rampup_tests.cc
View File

@ -89,6 +89,13 @@ void RampUpTester::OnStreamsCreated(
send_stream_ = send_stream;
}
void RampUpTester::OnTransportsCreated(
test::PacketTransport* send_transport,
test::PacketTransport* receive_transport) {
send_transport_ = send_transport;
send_transport_->SetConfig(forward_transport_config_);
}
size_t RampUpTester::GetNumStreams() const {
return num_streams_;
}
@ -286,7 +293,6 @@ RampUpDownUpTester::RampUpDownUpTester(size_t num_streams,
sent_bytes_(0) {
forward_transport_config_.link_capacity_kbps =
kHighBandwidthLimitBps / 1000;
send_transport_.SetConfig(forward_transport_config_);
}
RampUpDownUpTester::~RampUpDownUpTester() {}
@ -334,7 +340,7 @@ void RampUpDownUpTester::EvolveTestState(int bitrate_bps, bool suspended) {
// channel limit, and move to the next test state.
forward_transport_config_.link_capacity_kbps =
kLowBandwidthLimitBps / 1000;
send_transport_.SetConfig(forward_transport_config_);
send_transport_->SetConfig(forward_transport_config_);
test_state_ = kLowRate;
webrtc::test::PrintResult("ramp_up_down_up",
GetModifierString(),
@ -354,7 +360,7 @@ void RampUpDownUpTester::EvolveTestState(int bitrate_bps, bool suspended) {
// high value, and move to the next test state.
forward_transport_config_.link_capacity_kbps =
kHighBandwidthLimitBps / 1000;
send_transport_.SetConfig(forward_transport_config_);
send_transport_->SetConfig(forward_transport_config_);
test_state_ = kSecondRampup;
webrtc::test::PrintResult("ramp_up_down_up",
GetModifierString(),
@ -395,109 +401,109 @@ class RampUpTest : public test::CallTest {
TEST_F(RampUpTest, SingleStream) {
RampUpTester test(1, 0, RtpExtension::kTOffset, false, false);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, Simulcast) {
RampUpTester test(3, 0, RtpExtension::kTOffset, false, false);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, SimulcastWithRtx) {
RampUpTester test(3, 0, RtpExtension::kTOffset, true, false);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, SimulcastByRedWithRtx) {
RampUpTester test(3, 0, RtpExtension::kTOffset, true, true);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, SingleStreamWithHighStartBitrate) {
RampUpTester test(1, 0.9 * kSingleStreamTargetBps, RtpExtension::kTOffset,
false, false);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, UpDownUpOneStream) {
RampUpDownUpTester test(1, 60000, RtpExtension::kAbsSendTime, false, false);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, UpDownUpThreeStreams) {
RampUpDownUpTester test(3, 60000, RtpExtension::kAbsSendTime, false, false);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, UpDownUpOneStreamRtx) {
RampUpDownUpTester test(1, 60000, RtpExtension::kAbsSendTime, true, false);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, UpDownUpThreeStreamsRtx) {
RampUpDownUpTester test(3, 60000, RtpExtension::kAbsSendTime, true, false);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, UpDownUpOneStreamByRedRtx) {
RampUpDownUpTester test(1, 60000, RtpExtension::kAbsSendTime, true, true);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, UpDownUpThreeStreamsByRedRtx) {
RampUpDownUpTester test(3, 60000, RtpExtension::kAbsSendTime, true, true);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, AbsSendTimeSingleStream) {
RampUpTester test(1, 0, RtpExtension::kAbsSendTime, false, false);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, AbsSendTimeSimulcast) {
RampUpTester test(3, 0, RtpExtension::kAbsSendTime, false, false);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, AbsSendTimeSimulcastWithRtx) {
RampUpTester test(3, 0, RtpExtension::kAbsSendTime, true, false);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, AbsSendTimeSimulcastByRedWithRtx) {
RampUpTester test(3, 0, RtpExtension::kAbsSendTime, true, true);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, AbsSendTimeSingleStreamWithHighStartBitrate) {
RampUpTester test(1, 0.9 * kSingleStreamTargetBps, RtpExtension::kAbsSendTime,
false, false);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, TransportSequenceNumberSingleStream) {
RampUpTester test(1, 0, RtpExtension::kTransportSequenceNumber, false, false);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, TransportSequenceNumberSimulcast) {
RampUpTester test(3, 0, RtpExtension::kTransportSequenceNumber, false, false);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, TransportSequenceNumberSimulcastWithRtx) {
RampUpTester test(3, 0, RtpExtension::kTransportSequenceNumber, true, false);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, TransportSequenceNumberSimulcastByRedWithRtx) {
RampUpTester test(3, 0, RtpExtension::kTransportSequenceNumber, true, true);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, TransportSequenceNumberSingleStreamWithHighStartBitrate) {
RampUpTester test(1, 0.9 * kSingleStreamTargetBps,
RtpExtension::kTransportSequenceNumber, false, false);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
} // namespace webrtc

5
webrtc/video/rampup_tests.h
View File

@ -63,10 +63,12 @@ class RampUpTester : public test::EndToEndTest {
rtc::Event event_;
Clock* const clock_;
FakeNetworkPipe::Config forward_transport_config_;
const size_t num_streams_;
const bool rtx_;
const bool red_;
VideoSendStream* send_stream_;
test::PacketTransport* send_transport_;
private:
typedef std::map<uint32_t, uint32_t> SsrcMap;
@ -75,6 +77,8 @@ class RampUpTester : public test::EndToEndTest {
void OnStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override;
void OnTransportsCreated(test::PacketTransport* send_transport,
test::PacketTransport* receive_transport) override;
size_t GetNumStreams() const;
void ModifyConfigs(VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
@ -122,7 +126,6 @@ class RampUpDownUpTester : public RampUpTester {
std::string GetModifierString() const;
void EvolveTestState(int bitrate_bps, bool suspended);
FakeNetworkPipe::Config forward_transport_config_;
TestStates test_state_;
int64_t state_start_ms_;
int64_t interval_start_ms_;

17
webrtc/video/video_quality_test.cc
View File

@ -247,7 +247,7 @@ class VideoAnalyzer : public PacketReceiver,
}
VideoCaptureInput* input_;
Transport* transport_;
Transport* const transport_;
PacketReceiver* receiver_;
VideoSendStream* send_stream_;
@ -756,20 +756,21 @@ void VideoQualityTest::RunWithAnalyzer(const Params& params) {
<< params.analyzer.graph_data_output_filename << "!";
}
Call::Config call_config;
call_config.bitrate_config = params.common.call_bitrate_config;
CreateCalls(call_config, call_config);
test::LayerFilteringTransport send_transport(
params.pipe, kPayloadTypeVP8, kPayloadTypeVP9,
params.pipe, sender_call_.get(), kPayloadTypeVP8, kPayloadTypeVP9,
static_cast<uint8_t>(params.common.tl_discard_threshold), 0);
test::DirectTransport recv_transport(params.pipe);
test::DirectTransport recv_transport(params.pipe, receiver_call_.get());
VideoAnalyzer analyzer(
&send_transport, params.analyzer.test_label,
params.analyzer.avg_psnr_threshold, params.analyzer.avg_ssim_threshold,
params.analyzer.test_durations_secs * params.common.fps,
graph_data_output_file);
Call::Config call_config;
call_config.bitrate_config = params.common.call_bitrate_config;
CreateCalls(call_config, call_config);
analyzer.SetReceiver(receiver_call_->Receiver());
send_transport.SetReceiver(&analyzer);
recv_transport.SetReceiver(sender_call_->Receiver());
@ -827,7 +828,7 @@ void VideoQualityTest::RunWithVideoRenderer(const Params& params) {
rtc::scoped_ptr<Call> call(Call::Create(call_config));
test::LayerFilteringTransport transport(
params.pipe, kPayloadTypeVP8, kPayloadTypeVP9,
params.pipe, call.get(), kPayloadTypeVP8, kPayloadTypeVP9,
static_cast<uint8_t>(params.common.tl_discard_threshold), 0);
// TODO(ivica): Use two calls to be able to merge with RunWithAnalyzer or at
// least share as much code as possible. That way this test would also match

158
webrtc/video/video_send_stream_tests.cc
View File

@ -120,7 +120,7 @@ TEST_F(VideoSendStreamTest, SupportsCName) {
}
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
@ -159,7 +159,7 @@ TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
}
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
@ -204,7 +204,7 @@ TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
test::DelayedEncoder encoder_;
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(VideoSendStreamTest, SupportsTransportWideSequenceNumbers) {
@ -247,7 +247,7 @@ TEST_F(VideoSendStreamTest, SupportsTransportWideSequenceNumbers) {
test::FakeEncoder encoder_;
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
class FakeReceiveStatistics : public NullReceiveStatistics {
@ -311,11 +311,9 @@ TEST_F(VideoSendStreamTest, SupportsFec) {
public:
FecObserver()
: SendTest(kDefaultTimeoutMs),
transport_adapter_(SendTransport()),
send_count_(0),
received_media_(false),
received_fec_(false) {
transport_adapter_.Enable();
}
private:
@ -330,7 +328,7 @@ TEST_F(VideoSendStreamTest, SupportsFec) {
kSendSsrcs[0], header.sequenceNumber, send_count_ / 2, 127);
RTCPSender rtcp_sender(false, Clock::GetRealTimeClock(),
&lossy_receive_stats, nullptr,
&transport_adapter_);
transport_adapter_.get());
rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize);
rtcp_sender.SetRemoteSSRC(kSendSsrcs[0]);
@ -367,6 +365,9 @@ TEST_F(VideoSendStreamTest, SupportsFec) {
void ModifyConfigs(VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
transport_adapter_.reset(
new internal::TransportAdapter(send_config->send_transport));
transport_adapter_->Enable();
send_config->rtp.fec.red_payload_type = kRedPayloadType;
send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
}
@ -375,13 +376,13 @@ TEST_F(VideoSendStreamTest, SupportsFec) {
EXPECT_TRUE(Wait()) << "Timed out waiting for FEC and media packets.";
}
internal::TransportAdapter transport_adapter_;
rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_;
int send_count_;
bool received_media_;
bool received_fec_;
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
void VideoSendStreamTest::TestNackRetransmission(
@ -392,12 +393,10 @@ void VideoSendStreamTest::TestNackRetransmission(
explicit NackObserver(uint32_t retransmit_ssrc,
uint8_t retransmit_payload_type)
: SendTest(kDefaultTimeoutMs),
transport_adapter_(SendTransport()),
send_count_(0),
retransmit_ssrc_(retransmit_ssrc),
retransmit_payload_type_(retransmit_payload_type),
nacked_sequence_number_(-1) {
transport_adapter_.Enable();
}
private:
@ -411,7 +410,7 @@ void VideoSendStreamTest::TestNackRetransmission(
nacked_sequence_number_ = nack_sequence_number;
NullReceiveStatistics null_stats;
RTCPSender rtcp_sender(false, Clock::GetRealTimeClock(), &null_stats,
nullptr, &transport_adapter_);
nullptr, transport_adapter_.get());
rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize);
rtcp_sender.SetRemoteSSRC(kSendSsrcs[0]);
@ -445,6 +444,9 @@ void VideoSendStreamTest::TestNackRetransmission(
void ModifyConfigs(VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
transport_adapter_.reset(
new internal::TransportAdapter(send_config->send_transport));
transport_adapter_->Enable();
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
send_config->rtp.rtx.payload_type = retransmit_payload_type_;
if (retransmit_ssrc_ != kSendSsrcs[0])
@ -456,14 +458,14 @@ void VideoSendStreamTest::TestNackRetransmission(
<< "Timed out while waiting for NACK retransmission.";
}
internal::TransportAdapter transport_adapter_;
rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_;
int send_count_;
uint32_t retransmit_ssrc_;
uint8_t retransmit_payload_type_;
int nacked_sequence_number_;
} test(retransmit_ssrc, retransmit_payload_type);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(VideoSendStreamTest, RetransmitsNack) {
@ -496,7 +498,6 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
bool test_generic_packetization,
bool use_fec)
: SendTest(kLongTimeoutMs),
transport_adapter_(SendTransport()),
encoder_(stop),
max_packet_size_(max_packet_size),
stop_size_(stop_size),
@ -511,7 +512,6 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
// Fragmentation required, this test doesn't make sense without it.
encoder_.SetFrameSize(start_size);
RTC_DCHECK_GT(stop_size, max_packet_size);
transport_adapter_.Enable();
}
private:
@ -598,7 +598,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
kSendSsrcs[0], header.sequenceNumber, packet_count_ / 2, 127);
RTCPSender rtcp_sender(false, Clock::GetRealTimeClock(),
&lossy_receive_stats, nullptr,
&transport_adapter_);
transport_adapter_.get());
rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize);
rtcp_sender.SetRemoteSSRC(kSendSsrcs[0]);
@ -629,6 +629,9 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
void ModifyConfigs(VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
transport_adapter_.reset(
new internal::TransportAdapter(send_config->send_transport));
transport_adapter_->Enable();
if (use_fec_) {
send_config->rtp.fec.red_payload_type = kRedPayloadType;
send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
@ -651,7 +654,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
<< "Timed out while observing incoming RTP packets.";
}
internal::TransportAdapter transport_adapter_;
rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_;
test::ConfigurableFrameSizeEncoder encoder_;
const size_t max_packet_size_;
@ -673,7 +676,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
FrameFragmentationTest test(
kMaxPacketSize, start, stop, format == kGeneric, with_fec);
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
// TODO(sprang): Is there any way of speeding up these tests?
@ -709,7 +712,6 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
public:
RembObserver()
: SendTest(kDefaultTimeoutMs),
transport_adapter_(&transport_),
clock_(Clock::GetRealTimeClock()),
test_state_(kBeforeSuspend),
rtp_count_(0),
@ -717,18 +719,9 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
suspended_frame_count_(0),
low_remb_bps_(0),
high_remb_bps_(0) {
transport_adapter_.Enable();
}
private:
Action OnSendRtcp(const uint8_t* packet, size_t length) override {
// Receive statistics reporting having lost 0% of the packets.
// This is needed for the send-side bitrate controller to work properly.
rtc::CritScope lock(&crit_);
SendRtcpFeedback(0); // REMB is only sent if value is > 0.
return SEND_PACKET;
}
Action OnSendRtp(const uint8_t* packet, size_t length) override {
rtc::CritScope lock(&crit_);
++rtp_count_;
@ -746,18 +739,21 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
// counter.
suspended_frame_count_ = 0;
}
SendRtcpFeedback(0); // REMB is only sent if value is > 0.
} else if (test_state_ == kWaitingForPacket) {
if (header.paddingLength == 0) {
// Non-padding packet observed. Test is almost complete. Will just
// have to wait for the stats to change.
test_state_ = kWaitingForStats;
}
SendRtcpFeedback(0); // REMB is only sent if value is > 0.
} else if (test_state_ == kWaitingForStats) {
VideoSendStream::Stats stats = stream_->GetStats();
if (stats.suspended == false) {
// Stats flipped to false. Test is complete.
observation_complete_->Set();
}
SendRtcpFeedback(0); // REMB is only sent if value is > 0.
}
return SEND_PACKET;
@ -785,11 +781,6 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
high_remb_bps_ = value;
}
void SetReceivers(PacketReceiver* send_transport_receiver,
PacketReceiver* receive_transport_receiver) override {
transport_.SetReceiver(send_transport_receiver);
}
void OnStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
@ -799,6 +790,9 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
void ModifyConfigs(VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
transport_adapter_.reset(
new internal::TransportAdapter(send_config->send_transport));
transport_adapter_->Enable();
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
send_config->pre_encode_callback = this;
send_config->suspend_below_min_bitrate = true;
@ -813,7 +807,6 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
void PerformTest() override {
EXPECT_EQ(kEventSignaled, Wait())
<< "Timed out during suspend-below-min-bitrate test.";
transport_.StopSending();
}
enum TestState {
@ -828,7 +821,7 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
FakeReceiveStatistics receive_stats(
kSendSsrcs[0], last_sequence_number_, rtp_count_, 0);
RTCPSender rtcp_sender(false, clock_, &receive_stats, nullptr,
&transport_adapter_);
transport_adapter_.get());
rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize);
rtcp_sender.SetRemoteSSRC(kSendSsrcs[0]);
@ -840,8 +833,7 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
EXPECT_EQ(0, rtcp_sender.SendRTCP(feedback_state, kRtcpRr));
}
internal::TransportAdapter transport_adapter_;
test::DirectTransport transport_;
rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_;
Clock* const clock_;
VideoSendStream* stream_;
@ -854,7 +846,7 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
int high_remb_bps_ GUARDED_BY(crit_);
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
@ -863,10 +855,8 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
NoPaddingWhenVideoIsMuted()
: SendTest(kDefaultTimeoutMs),
clock_(Clock::GetRealTimeClock()),
transport_adapter_(ReceiveTransport()),
last_packet_time_ms_(-1),
capturer_(nullptr) {
transport_adapter_.Enable();
}
private:
@ -887,7 +877,7 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
// Receive statistics reporting having lost 50% of the packets.
FakeReceiveStatistics receive_stats(kSendSsrcs[0], 1, 1, 0);
RTCPSender rtcp_sender(false, Clock::GetRealTimeClock(), &receive_stats,
nullptr, &transport_adapter_);
nullptr, transport_adapter_.get());
rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize);
rtcp_sender.SetRemoteSSRC(kSendSsrcs[0]);
@ -898,10 +888,12 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
return SEND_PACKET;
}
void SetReceivers(PacketReceiver* send_transport_receiver,
PacketReceiver* receive_transport_receiver) override {
RtpRtcpObserver::SetReceivers(send_transport_receiver,
send_transport_receiver);
void OnTransportsCreated(
test::PacketTransport* send_transport,
test::PacketTransport* receive_transport) override {
transport_adapter_.reset(
new internal::TransportAdapter(receive_transport));
transport_adapter_->Enable();
}
size_t GetNumStreams() const override { return 3; }
@ -918,13 +910,13 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
}
Clock* const clock_;
internal::TransportAdapter transport_adapter_;
rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_;
rtc::CriticalSection crit_;
int64_t last_packet_time_ms_ GUARDED_BY(crit_);
test::FrameGeneratorCapturer* capturer_ GUARDED_BY(crit_);
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
// This test first observes "high" bitrate use at which point it sends a REMB to
@ -939,39 +931,21 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
static const int kHighBitrateBps = 150000;
static const int kRembBitrateBps = 80000;
static const int kRembRespectedBitrateBps = 100000;
class BitrateObserver : public test::SendTest, public PacketReceiver {
class BitrateObserver : public test::SendTest {
public:
BitrateObserver()
: SendTest(kDefaultTimeoutMs),
feedback_transport_(ReceiveTransport()),
bitrate_capped_(false) {
RtpRtcp::Configuration config;
feedback_transport_.Enable();
config.outgoing_transport = &feedback_transport_;
rtp_rtcp_.reset(RtpRtcp::CreateRtpRtcp(config));
rtp_rtcp_->SetREMBStatus(true);
rtp_rtcp_->SetRTCPStatus(RtcpMode::kReducedSize);
}
void OnStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
stream_ = send_stream;
}
private:
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::VIDEO);
virtual Action OnSendRtp(const uint8_t* packet, size_t length) {
if (RtpHeaderParser::IsRtcp(packet, length))
return DELIVERY_OK;
return DROP_PACKET;
RTPHeader header;
if (!parser_->Parse(packet, length, &header))
return DELIVERY_PACKET_ERROR;
return DROP_PACKET;
RTC_DCHECK(stream_ != nullptr);
VideoSendStream::Stats stats = stream_->GetStats();
if (!stats.substreams.empty()) {
@ -994,17 +968,27 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
observation_complete_->Set();
}
}
return DELIVERY_OK;
// Packets don't have to be delivered since the test is the receiver.
return DROP_PACKET;
}
void SetReceivers(PacketReceiver* send_transport_receiver,
PacketReceiver* receive_transport_receiver) override {
RtpRtcpObserver::SetReceivers(this, send_transport_receiver);
void OnStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
stream_ = send_stream;
RtpRtcp::Configuration config;
config.outgoing_transport = feedback_transport_.get();
rtp_rtcp_.reset(RtpRtcp::CreateRtpRtcp(config));
rtp_rtcp_->SetREMBStatus(true);
rtp_rtcp_->SetRTCPStatus(RtcpMode::kReducedSize);
}
void ModifyConfigs(VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
feedback_transport_.reset(
new internal::TransportAdapter(send_config->send_transport));
feedback_transport_->Enable();
encoder_config->min_transmit_bitrate_bps = kMinTransmitBitrateBps;
}
@ -1014,12 +998,12 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
}
rtc::scoped_ptr<RtpRtcp> rtp_rtcp_;
internal::TransportAdapter feedback_transport_;
rtc::scoped_ptr<internal::TransportAdapter> feedback_transport_;
VideoSendStream* stream_;
bool bitrate_capped_;
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(VideoSendStreamTest, CanReconfigureToUseStartBitrateAbovePreviousMax) {
@ -1329,7 +1313,7 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
VideoEncoderConfig encoder_config_;
} test_encoder;
RunBaseTest(&test_encoder);
RunBaseTest(&test_encoder, FakeNetworkPipe::Config());
EXPECT_TRUE(test_encoder.IsReleased());
EXPECT_EQ(1u, test_encoder.num_releases());
@ -1387,7 +1371,7 @@ TEST_F(VideoSendStreamTest, EncoderSetupPropagatesCommonEncoderConfigValues) {
VideoEncoderConfig encoder_config_;
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
static const size_t kVideoCodecConfigObserverNumberOfTemporalLayers = 4;
@ -1515,17 +1499,17 @@ void VideoCodecConfigObserver<VideoCodecVP9>::VerifyCodecSpecifics(
TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp8Config) {
VideoCodecConfigObserver<VideoCodecVP8> test(kVideoCodecVP8, "VP8");
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp9Config) {
VideoCodecConfigObserver<VideoCodecVP9> test(kVideoCodecVP9, "VP9");
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(VideoSendStreamTest, EncoderSetupPropagatesH264Config) {
VideoCodecConfigObserver<VideoCodecH264> test(kVideoCodecH264, "H264");
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(VideoSendStreamTest, RtcpSenderReportContainsMediaBytesSent) {
@ -1575,7 +1559,7 @@ TEST_F(VideoSendStreamTest, RtcpSenderReportContainsMediaBytesSent) {
size_t media_bytes_sent_;
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) {
@ -1615,7 +1599,7 @@ TEST_F(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) {
}
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
@ -1721,7 +1705,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
webrtc::VideoEncoderConfig encoder_config_;
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(VideoSendStreamTest, ReportsSentResolution) {
@ -1800,7 +1784,7 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) {
VideoSendStream* send_stream_;
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
class VP9HeaderObeserver : public test::SendTest {
@ -1880,7 +1864,7 @@ TEST_F(VideoSendStreamTest, VP9NoFlexMode) {
}
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(VideoSendStreamTest, DISABLED_VP9FlexMode) {
@ -1899,7 +1883,7 @@ TEST_F(VideoSendStreamTest, DISABLED_VP9FlexMode) {
} test;
RunBaseTest(&test);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
} // namespace webrtc