Call OnSentPacket for all packets sent in the test framework.
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}
diff --git a/webrtc/call/bitrate_estimator_tests.cc b/webrtc/call/bitrate_estimator_tests.cc
index 08e36c8..e327c59 100644
--- a/webrtc/call/bitrate_estimator_tests.cc
+++ b/webrtc/call/bitrate_estimator_tests.cc
@@ -116,15 +116,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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_;
diff --git a/webrtc/call/call.cc b/webrtc/call/call.cc
index eda209a..7bb22af 100644
--- a/webrtc/call/call.cc
+++ b/webrtc/call/call.cc
@@ -463,7 +463,6 @@
}
void Call::OnSentPacket(const rtc::SentPacket& sent_packet) {
- RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
congestion_controller_->OnSentPacket(sent_packet);
}
diff --git a/webrtc/call/call_perf_tests.cc b/webrtc/call/call_perf_tests.cc
index cab3914..d9edac8 100644
--- a/webrtc/call/call_perf_tests.cc
+++ b/webrtc/call/call_perf_tests.cc
@@ -58,8 +58,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
"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 @@
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 @@
test::DelayedEncoder encoder_;
} test(tested_load, encode_delay_ms);
- RunBaseTest(&test);
+ RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(CallPerfTest, ReceivesCpuUnderuse) {
@@ -528,26 +540,17 @@
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 @@
observation_complete_->Set();
}
}
- return send_transport_receiver_->DeliverPacket(media_type, packet, length,
- packet_time);
+ return SEND_PACKET;
}
void OnStreamsCreated(
@@ -607,13 +609,12 @@
}
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 @@
VideoEncoderConfig encoder_config_;
} test;
- RunBaseTest(&test);
+ RunBaseTest(&test, FakeNetworkPipe::Config());
}
} // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
index 342486e..61ed512 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
@@ -680,13 +680,13 @@
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 @@
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;
diff --git a/webrtc/test/call_test.cc b/webrtc/test/call_test.cc
index f2b5f91..7d73f15 100644
--- a/webrtc/test/call_test.cc
+++ b/webrtc/test/call_test.cc
@@ -27,22 +27,30 @@
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 @@
Start();
test->PerformTest();
- test->StopSending();
+ send_transport_->StopSending();
+ receive_transport_->StopSending();
Stop();
DestroyStreams();
@@ -182,11 +191,6 @@
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 @@
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 @@
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 @@
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;
}
diff --git a/webrtc/test/call_test.h b/webrtc/test/call_test.h
index 4a645b4..d80d819 100644
--- a/webrtc/test/call_test.h
+++ b/webrtc/test/call_test.h
@@ -46,7 +46,7 @@
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 @@
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 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 @@
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 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 EndToEndTest : public BaseTest {
public:
explicit EndToEndTest(unsigned int timeout_ms);
- EndToEndTest(unsigned int timeout_ms, const FakeNetworkPipe::Config& config);
bool ShouldCreateReceivers() const override;
};
diff --git a/webrtc/test/direct_transport.cc b/webrtc/test/direct_transport.cc
index 1f92e92..ac56ec3 100644
--- a/webrtc/test/direct_transport.cc
+++ b/webrtc/test/direct_transport.cc
@@ -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 @@
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 @@
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;
diff --git a/webrtc/test/direct_transport.h b/webrtc/test/direct_transport.h
index 1c6f937..f910efa 100644
--- a/webrtc/test/direct_transport.h
+++ b/webrtc/test/direct_transport.h
@@ -23,6 +23,7 @@
namespace webrtc {
+class Call;
class Clock;
class PacketReceiver;
@@ -30,13 +31,14 @@
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 @@
bool SendPackets();
rtc::CriticalSection lock_;
+ Call* const send_call_;
rtc::scoped_ptr<EventWrapper> packet_event_;
rtc::scoped_ptr<ThreadWrapper> thread_;
Clock* const clock_;
diff --git a/webrtc/test/layer_filtering_transport.cc b/webrtc/test/layer_filtering_transport.cc
index b9bc24d..a4ebf47 100644
--- a/webrtc/test/layer_filtering_transport.cc
+++ b/webrtc/test/layer_filtering_transport.cc
@@ -21,16 +21,16 @@
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);
diff --git a/webrtc/test/layer_filtering_transport.h b/webrtc/test/layer_filtering_transport.h
index 58c2dd5..3f2389a 100644
--- a/webrtc/test/layer_filtering_transport.h
+++ b/webrtc/test/layer_filtering_transport.h
@@ -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 @@
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,
diff --git a/webrtc/test/rtp_rtcp_observer.h b/webrtc/test/rtp_rtcp_observer.h
index 97aa7b6..50fd864 100644
--- a/webrtc/test/rtp_rtcp_observer.h
+++ b/webrtc/test/rtp_rtcp_observer.h
@@ -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
diff --git a/webrtc/video/end_to_end_tests.cc b/webrtc/video/end_to_end_tests.cc
index 31ec7d5..c57b8a1 100644
--- a/webrtc/video/end_to_end_tests.cc
+++ b/webrtc/video/end_to_end_tests.cc
@@ -81,7 +81,6 @@
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 @@
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 @@
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 @@
int frame_counter_;
} test;
- RunBaseTest(&test);
+ RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(EndToEndTest, SendsAndReceivesH264) {
@@ -333,7 +334,7 @@
int frame_counter_;
} test;
- RunBaseTest(&test);
+ RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(EndToEndTest, ReceiverUsesLocalSsrc) {
@@ -361,7 +362,7 @@
}
} test;
- RunBaseTest(&test);
+ RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) {
@@ -379,6 +380,7 @@
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 @@
}
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 @@
"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 @@
: 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 @@
<< "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 @@
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 @@
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 @@
: (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 @@
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 @@
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 @@
}
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 @@
"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 @@
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 @@
int sent_rtcp_;
} test(rtcp_mode);
- RunBaseTest(&test);
+ RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(EndToEndTest, UsesRtcpCompoundMode) {
@@ -1167,13 +1174,12 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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;
- 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 @@
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 @@
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 @@
"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;
test::ClearHistograms();
- RunBaseTest(&test);
+ RunBaseTest(&test, FakeNetworkPipe::Config());
EXPECT_EQ(1, test::NumHistogramSamples(
"WebRTC.Video.UniqueNackRequestsSentInPercent"));
@@ -1857,7 +1859,7 @@
}
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 @@
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 @@
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 @@
} 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 @@
int sent_rtcp_dlrr_;
} test(enable_rrtr);
- RunBaseTest(&test);
+ RunBaseTest(&test, FakeNetworkPipe::Config());
}
void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
@@ -2227,7 +2217,7 @@
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 @@
}
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 @@
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 @@
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 @@
uint32_t sent_rtp_;
} test;
- RunBaseTest(&test);
+ RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(EndToEndTest, SendsSetSsrc) { TestSendsSetSsrcs(1, false); }
@@ -2676,7 +2665,7 @@
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 @@
} 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 @@
encoder_config_.streams[i].max_bitrate_bps;
}
- CreateMatchingReceiveConfigs(observer.ReceiveTransport());
+ CreateMatchingReceiveConfigs(&receive_transport);
CreateStreams();
CreateFrameGeneratorCapturer();
@@ -2847,7 +2844,8 @@
<< "Timed out waiting for all SSRCs to send packets.";
}
- observer.StopSending();
+ send_transport.StopSending();
+ receive_transport.StopSending();
Stop();
DestroyStreams();
@@ -3033,7 +3031,7 @@
int down_frames_ GUARDED_BY(test_crit_);
} test;
- RunBaseTest(&test);
+ RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(EndToEndTest, CallReportsRttForSender) {
@@ -3044,9 +3042,9 @@
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 @@
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;
diff --git a/webrtc/video/rampup_tests.cc b/webrtc/video/rampup_tests.cc
index 8c6b026..d0ce8a1 100644
--- a/webrtc/video/rampup_tests.cc
+++ b/webrtc/video/rampup_tests.cc
@@ -89,6 +89,13 @@
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 @@
sent_bytes_(0) {
forward_transport_config_.link_capacity_kbps =
kHighBandwidthLimitBps / 1000;
- send_transport_.SetConfig(forward_transport_config_);
}
RampUpDownUpTester::~RampUpDownUpTester() {}
@@ -334,7 +340,7 @@
// 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 @@
// 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 @@
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
diff --git a/webrtc/video/rampup_tests.h b/webrtc/video/rampup_tests.h
index 927d912..9a04656 100644
--- a/webrtc/video/rampup_tests.h
+++ b/webrtc/video/rampup_tests.h
@@ -63,10 +63,12 @@
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 @@
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 @@
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_;
diff --git a/webrtc/video/video_quality_test.cc b/webrtc/video/video_quality_test.cc
index 1513b81..a475c9f 100644
--- a/webrtc/video/video_quality_test.cc
+++ b/webrtc/video/video_quality_test.cc
@@ -247,7 +247,7 @@
}
VideoCaptureInput* input_;
- Transport* transport_;
+ Transport* const transport_;
PacketReceiver* receiver_;
VideoSendStream* send_stream_;
@@ -756,20 +756,21 @@
<< 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 @@
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
diff --git a/webrtc/video/video_send_stream_tests.cc b/webrtc/video/video_send_stream_tests.cc
index 40aaf32..92e3b73 100644
--- a/webrtc/video/video_send_stream_tests.cc
+++ b/webrtc/video/video_send_stream_tests.cc
@@ -120,7 +120,7 @@
}
} test;
- RunBaseTest(&test);
+ RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
@@ -159,7 +159,7 @@
}
} test;
- RunBaseTest(&test);
+ RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
@@ -204,7 +204,7 @@
test::DelayedEncoder encoder_;
} test;
- RunBaseTest(&test);
+ RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(VideoSendStreamTest, SupportsTransportWideSequenceNumbers) {
@@ -247,7 +247,7 @@
test::FakeEncoder encoder_;
} test;
- RunBaseTest(&test);
+ RunBaseTest(&test, FakeNetworkPipe::Config());
}
class FakeReceiveStatistics : public NullReceiveStatistics {
@@ -311,11 +311,9 @@
public:
FecObserver()
: SendTest(kDefaultTimeoutMs),
- transport_adapter_(SendTransport()),
send_count_(0),
received_media_(false),
received_fec_(false) {
- transport_adapter_.Enable();
}
private:
@@ -330,7 +328,7 @@
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 @@
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 @@
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 @@
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 @@
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 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 @@
<< "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 @@
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 @@
// 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 @@
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 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 @@
<< "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 @@
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 @@
public:
RembObserver()
: SendTest(kDefaultTimeoutMs),
- transport_adapter_(&transport_),
clock_(Clock::GetRealTimeClock()),
test_state_(kBeforeSuspend),
rtp_count_(0),
@@ -717,18 +719,9 @@
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 @@
// 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 @@
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 @@
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 @@
void PerformTest() override {
EXPECT_EQ(kEventSignaled, Wait())
<< "Timed out during suspend-below-min-bitrate test.";
- transport_.StopSending();
}
enum TestState {
@@ -828,7 +821,7 @@
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 @@
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 @@
int high_remb_bps_ GUARDED_BY(crit_);
} test;
- RunBaseTest(&test);
+ RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
@@ -863,10 +855,8 @@
NoPaddingWhenVideoIsMuted()
: SendTest(kDefaultTimeoutMs),
clock_(Clock::GetRealTimeClock()),
- transport_adapter_(ReceiveTransport()),
last_packet_time_ms_(-1),
capturer_(nullptr) {
- transport_adapter_.Enable();
}
private:
@@ -887,7 +877,7 @@
// 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 @@
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 @@
}
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 @@
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 @@
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 @@
}
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 @@
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 @@
VideoEncoderConfig encoder_config_;
} test;
- RunBaseTest(&test);
+ RunBaseTest(&test, FakeNetworkPipe::Config());
}
static const size_t kVideoCodecConfigObserverNumberOfTemporalLayers = 4;
@@ -1515,17 +1499,17 @@
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 @@
size_t media_bytes_sent_;
} test;
- RunBaseTest(&test);
+ RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) {
@@ -1615,7 +1599,7 @@
}
} test;
- RunBaseTest(&test);
+ RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
@@ -1721,7 +1705,7 @@
webrtc::VideoEncoderConfig encoder_config_;
} test;
- RunBaseTest(&test);
+ RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(VideoSendStreamTest, ReportsSentResolution) {
@@ -1800,7 +1784,7 @@
VideoSendStream* send_stream_;
} test;
- RunBaseTest(&test);
+ RunBaseTest(&test, FakeNetworkPipe::Config());
}
class VP9HeaderObeserver : public test::SendTest {
@@ -1880,7 +1864,7 @@
}
} test;
- RunBaseTest(&test);
+ RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(VideoSendStreamTest, DISABLED_VP9FlexMode) {
@@ -1899,7 +1883,7 @@
} test;
- RunBaseTest(&test);
+ RunBaseTest(&test, FakeNetworkPipe::Config());
}
} // namespace webrtc
