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

Reland "Change CallTests to use new PacketReceiver::DeliverRtp and PacketReceiver::DeliverRtcp"

Browse Source 
This reverts commit 3e61f881cd2ba9040a07371e0ba6dda902aa60ae.

Reason for revert: Issue fixed in https://webrtc-review.googlesource.com/c/src/+/291104

Original change's description:
> Revert "Change CallTests to use new PacketReceiver::DeliverRtp and PacketReceiver::DeliverRtcp"
>
> This reverts commit 3b96f2c770df7691df90c2cc1be40509a76ae425.
>
> Reason for revert: Seems to cause test failures and perf regressions in tests: webrtc:14833, and  CallPerfTest.Min_Bitrate_VideoAndAudio 
>
>
> Original change's description:
> > Change CallTests to use new PacketReceiver::DeliverRtp and PacketReceiver::DeliverRtcp
> >
> > PacketReceiver::DeliverRtp requires delivered packets to have extensions already mapped.
> > Therefore DirectTransport is provided with the extension mapping.
> >
> > CallTests and tests derived from CallTest create transports in different ways, this cl change CallTest to create tests in only one way to simplify how extensions are provided to the transport but at the same time still allows different network behaviour.
> >
> >
> > Change-Id: Ie8b3ad947c170be61e62c02dadf4adedbb3841f1
> > Bug: webrtc:7135, webrtc:14795
> > Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/290980
> > Reviewed-by: Jakob Ivarsson‎ <jakobi@webrtc.org>
> > Commit-Queue: Per Kjellander <perkj@webrtc.org>
> > Reviewed-by: Erik Språng <sprang@webrtc.org>
> > Cr-Commit-Position: refs/heads/main@{#39137}
>
> Bug: webrtc:7135, webrtc:14795, webrtc:14833
> Change-Id: Ib6180a47cf7611ed2bc648acc3b9e5cfeec4d9cf
> No-Presubmit: true
> No-Tree-Checks: true
> No-Try: true
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/291220
> Owners-Override: Björn Terelius <terelius@webrtc.org>
> Auto-Submit: Per Kjellander <perkj@webrtc.org>
> Reviewed-by: Björn Terelius <terelius@webrtc.org>
> Commit-Queue: Björn Terelius <terelius@webrtc.org>
> Bot-Commit: rubber-stamper@appspot.gserviceaccount.com <rubber-stamper@appspot.gserviceaccount.com>
> Cr-Commit-Position: refs/heads/main@{#39146}

Bug: webrtc:7135, webrtc:14795, webrtc:14833
Change-Id: I3fb0210d7a33c600ead5719ce2acb8cc68ec20bd
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/291222
Commit-Queue: Per Kjellander <perkj@webrtc.org>
Reviewed-by: Jakob Ivarsson‎ <jakobi@webrtc.org>
Bot-Commit: rubber-stamper@appspot.gserviceaccount.com <rubber-stamper@appspot.gserviceaccount.com>
Owners-Override: Per Kjellander <perkj@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#39157}
This commit is contained in:
Per Kjellander 2023-01-19 15:45:58 +00:00 committed by WebRTC LUCI CQ
parent 8e1d61338a
commit 89870ffa95
38 changed files with 477 additions and 591 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
audio/test/audio_bwe_integration_test.cc
View File

@ -58,27 +58,6 @@ void AudioBweTest::OnFakeAudioDevicesCreated(
send_audio_device_ = send_audio_device;
}
std::unique_ptr<test::PacketTransport> AudioBweTest::CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) {
return std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
test::CallTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(GetNetworkPipeConfig())));
}
std::unique_ptr<test::PacketTransport> AudioBweTest::CreateReceiveTransport(
TaskQueueBase* task_queue) {
return std::make_unique<test::PacketTransport>(
task_queue, nullptr, this, test::PacketTransport::kReceiver,
test::CallTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(GetNetworkPipeConfig())));
}
void AudioBweTest::PerformTest() {
send_audio_device_->WaitForRecordingEnd();
SleepMs(GetNetworkPipeConfig().queue_delay_ms + kExtraProcessTimeMs);

6
audio/test/audio_bwe_integration_test.h
View File

@ -39,12 +39,6 @@ class AudioBweTest : public test::EndToEndTest {
TestAudioDeviceModule* send_audio_device,
TestAudioDeviceModule* recv_audio_device) override;
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override;
std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
TaskQueueBase* task_queue) override;
void PerformTest() override;
private:

27
audio/test/audio_end_to_end_test.cc
View File

@ -31,10 +31,6 @@ constexpr int kSampleRate = 48000;
AudioEndToEndTest::AudioEndToEndTest()
: EndToEndTest(CallTest::kDefaultTimeout) {}
BuiltInNetworkBehaviorConfig AudioEndToEndTest::GetNetworkPipeConfig() const {
return BuiltInNetworkBehaviorConfig();
}
size_t AudioEndToEndTest::GetNumVideoStreams() const {
return 0;
}
@ -63,27 +59,6 @@ void AudioEndToEndTest::OnFakeAudioDevicesCreated(
send_audio_device_ = send_audio_device;
}
std::unique_ptr<test::PacketTransport> AudioEndToEndTest::CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) {
return std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
test::CallTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(GetNetworkPipeConfig())));
}
std::unique_ptr<test::PacketTransport>
AudioEndToEndTest::CreateReceiveTransport(TaskQueueBase* task_queue) {
return std::make_unique<test::PacketTransport>(
task_queue, nullptr, this, test::PacketTransport::kReceiver,
test::CallTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(GetNetworkPipeConfig())));
}
void AudioEndToEndTest::ModifyAudioConfigs(
AudioSendStream::Config* send_config,
std::vector<AudioReceiveStreamInterface::Config>* receive_configs) {
@ -110,7 +85,7 @@ void AudioEndToEndTest::PerformTest() {
// Wait until the input audio file is done...
send_audio_device_->WaitForRecordingEnd();
// and some extra time to account for network delay.
SleepMs(GetNetworkPipeConfig().queue_delay_ms + kExtraRecordTimeMs);
SleepMs(GetSendTransportConfig().queue_delay_ms + kExtraRecordTimeMs);
}
} // namespace test
} // namespace webrtc

8
audio/test/audio_end_to_end_test.h
View File

@ -32,8 +32,6 @@ class AudioEndToEndTest : public test::EndToEndTest {
return receive_stream_;
}
virtual BuiltInNetworkBehaviorConfig GetNetworkPipeConfig() const;
size_t GetNumVideoStreams() const override;
size_t GetNumAudioStreams() const override;
size_t GetNumFlexfecStreams() const override;
@ -45,12 +43,6 @@ class AudioEndToEndTest : public test::EndToEndTest {
TestAudioDeviceModule* send_audio_device,
TestAudioDeviceModule* recv_audio_device) override;
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override;
std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
TaskQueueBase* task_queue) override;
void ModifyAudioConfigs(AudioSendStream::Config* send_config,
std::vector<AudioReceiveStreamInterface::Config>*
receive_configs) override;

2
audio/test/audio_stats_test.cc
View File

@ -32,7 +32,7 @@ class NoLossTest : public AudioEndToEndTest {
NoLossTest() = default;
BuiltInNetworkBehaviorConfig GetNetworkPipeConfig() const override {
BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
BuiltInNetworkBehaviorConfig pipe_config;
pipe_config.queue_delay_ms = kRttMs / 2;
return pipe_config;

2
audio/test/low_bandwidth_audio_test.cc
View File

@ -84,7 +84,7 @@ class Mobile2GNetworkTest : public AudioQualityTest {
{{"maxaveragebitrate", "6000"}, {"ptime", "60"}, {"stereo", "1"}}});
}
BuiltInNetworkBehaviorConfig GetNetworkPipeConfig() const override {
BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
BuiltInNetworkBehaviorConfig pipe_config;
pipe_config.link_capacity_kbps = 12;
pipe_config.queue_length_packets = 1500;

2
audio/test/nack_test.cc
View File

@ -25,7 +25,7 @@ TEST_F(NackTest, ShouldNackInLossyNetwork) {
const int64_t kLossPercent = 30;
const int kNackHistoryMs = 1000;
BuiltInNetworkBehaviorConfig GetNetworkPipeConfig() const override {
BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
BuiltInNetworkBehaviorConfig pipe_config;
pipe_config.queue_delay_ms = kRttMs / 2;
pipe_config.loss_percent = kLossPercent;

2
audio/test/non_sender_rtt_test.cc
View File

@ -23,7 +23,7 @@ TEST_F(NonSenderRttTest, NonSenderRttStats) {
const int kTestDurationMs = 10000;
const int64_t kRttMs = 30;
BuiltInNetworkBehaviorConfig GetNetworkPipeConfig() const override {
BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
BuiltInNetworkBehaviorConfig pipe_config;
pipe_config.queue_delay_ms = kRttMs / 2;
return pipe_config;

26
call/bitrate_estimator_tests.cc
View File

@ -7,6 +7,7 @@
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include <cstddef>
#include <functional>
#include <list>
#include <memory>
@ -15,7 +16,6 @@
#include "absl/strings/string_view.h"
#include "api/test/create_frame_generator.h"
#include "call/call.h"
#include "call/fake_network_pipe.h"
#include "call/simulated_network.h"
#include "rtc_base/checks.h"
#include "rtc_base/event.h"
@ -24,7 +24,6 @@
#include "rtc_base/task_queue_for_test.h"
#include "rtc_base/thread_annotations.h"
#include "test/call_test.h"
#include "test/direct_transport.h"
#include "test/encoder_settings.h"
#include "test/fake_decoder.h"
#include "test/fake_encoder.h"
@ -113,20 +112,9 @@ class BitrateEstimatorTest : public test::CallTest {
SendTask(task_queue(), [this]() {
CreateCalls();
send_transport_.reset(new test::DirectTransport(
task_queue(),
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
BuiltInNetworkBehaviorConfig())),
sender_call_.get(), payload_type_map_));
send_transport_->SetReceiver(receiver_call_->Receiver());
receive_transport_.reset(new test::DirectTransport(
task_queue(),
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
BuiltInNetworkBehaviorConfig())),
receiver_call_.get(), payload_type_map_));
receive_transport_->SetReceiver(sender_call_->Receiver());
CreateSendTransport(BuiltInNetworkBehaviorConfig(), /*observer=*/nullptr);
CreateReceiveTransport(BuiltInNetworkBehaviorConfig(),
/*observer=*/nullptr);
VideoSendStream::Config video_send_config(send_transport_.get());
video_send_config.rtp.ssrcs.push_back(kVideoSendSsrcs[0]);
@ -160,10 +148,6 @@ class BitrateEstimatorTest : public test::CallTest {
delete stream;
}
streams_.clear();
send_transport_.reset();
receive_transport_.reset();
DestroyCalls();
});
}
@ -245,8 +229,6 @@ class BitrateEstimatorTest : public test::CallTest {
};
LogObserver receiver_log_;
std::unique_ptr<test::DirectTransport> send_transport_;
std::unique_ptr<test::DirectTransport> receive_transport_;
VideoReceiveStreamInterface::Config receive_config_;
std::vector<Stream*> streams_;
};

77
call/call_perf_tests.cc
View File

@ -243,23 +243,26 @@ void CallPerfTest::TestAudioVideoSync(FecMode fec,
test::PacketTransport::kSender, audio_pt_map,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(audio_net_config)));
std::make_unique<SimulatedNetwork>(audio_net_config)),
GetRegisteredExtensions(), GetRegisteredExtensions());
audio_send_transport->SetReceiver(receiver_call_->Receiver());
video_send_transport = std::make_unique<test::PacketTransport>(
task_queue(), sender_call_.get(), observer.get(),
test::PacketTransport::kSender, video_pt_map,
std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(
BuiltInNetworkBehaviorConfig())));
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig())),
GetRegisteredExtensions(), GetRegisteredExtensions());
video_send_transport->SetReceiver(receiver_call_->Receiver());
receive_transport = std::make_unique<test::PacketTransport>(
task_queue(), receiver_call_.get(), observer.get(),
test::PacketTransport::kReceiver, payload_type_map_,
std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(
BuiltInNetworkBehaviorConfig())));
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig())),
GetRegisteredExtensions(), GetRegisteredExtensions());
receive_transport->SetReceiver(sender_call_->Receiver());
CreateSendConfig(1, 0, 0, video_send_transport.get());
@ -412,25 +415,12 @@ void CallPerfTest::TestCaptureNtpTime(
rtp_start_timestamp_(0) {}
private:
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override {
return std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
payload_type_map_,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(net_config_)));
BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
return net_config_;
}
std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
TaskQueueBase* task_queue) override {
return std::make_unique<test::PacketTransport>(
task_queue, nullptr, this, test::PacketTransport::kReceiver,
payload_type_map_,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(net_config_)));
BuiltInNetworkBehaviorConfig GetReceiveTransportConfig() const override {
return net_config_;
}
void OnFrame(const VideoFrame& video_frame) override {
@ -946,35 +936,26 @@ void CallPerfTest::TestMinAudioVideoBitrate(int test_bitrate_from,
task_queue_(task_queue) {}
protected:
BuiltInNetworkBehaviorConfig GetFakeNetworkPipeConfig() {
BuiltInNetworkBehaviorConfig GetFakeNetworkPipeConfig() const {
BuiltInNetworkBehaviorConfig pipe_config;
pipe_config.link_capacity_kbps = test_bitrate_from_;
return pipe_config;
}
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override {
auto network =
std::make_unique<SimulatedNetwork>(GetFakeNetworkPipeConfig());
send_simulated_network_ = network.get();
return std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
test::CallTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
std::move(network)));
BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
return GetFakeNetworkPipeConfig();
}
BuiltInNetworkBehaviorConfig GetReceiveTransportConfig() const override {
return GetFakeNetworkPipeConfig();
}
std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
TaskQueueBase* task_queue) override {
auto network =
std::make_unique<SimulatedNetwork>(GetFakeNetworkPipeConfig());
receive_simulated_network_ = network.get();
return std::make_unique<test::PacketTransport>(
task_queue, nullptr, this, test::PacketTransport::kReceiver,
test::CallTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
std::move(network)));
void OnTransportCreated(
test::PacketTransport* to_receiver,
SimulatedNetworkInterface* sender_network,
test::PacketTransport* to_sender,
SimulatedNetworkInterface* receiver_network) override {
send_simulated_network_ = sender_network;
receive_simulated_network_ = receiver_network;
}
void PerformTest() override {
@ -1048,8 +1029,8 @@ void CallPerfTest::TestMinAudioVideoBitrate(int test_bitrate_from,
const int min_bwe_;
const int start_bwe_;
const int max_bwe_;
SimulatedNetwork* send_simulated_network_;
SimulatedNetwork* receive_simulated_network_;
SimulatedNetworkInterface* send_simulated_network_;
SimulatedNetworkInterface* receive_simulated_network_;
Call* sender_call_;
TaskQueueBase* const task_queue_;
} test(test_bitrate_from, test_bitrate_to, test_bitrate_step, min_bwe,

25
call/rampup_tests.cc
View File

@ -113,18 +113,8 @@ void RampUpTester::OnVideoStreamsCreated(
send_stream_ = send_stream;
}
std::unique_ptr<test::PacketTransport> RampUpTester::CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) {
auto network = std::make_unique<SimulatedNetwork>(forward_transport_config_);
send_simulated_network_ = network.get();
auto send_transport = std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
test::CallTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
std::move(network)));
send_transport_ = send_transport.get();
return send_transport;
BuiltInNetworkBehaviorConfig RampUpTester::GetSendTransportConfig() const {
return forward_transport_config_;
}
size_t RampUpTester::GetNumVideoStreams() const {
@ -310,6 +300,17 @@ void RampUpTester::OnCallsCreated(Call* sender_call, Call* receiver_call) {
});
}
void RampUpTester::OnTransportCreated(
test::PacketTransport* to_receiver,
SimulatedNetworkInterface* sender_network,
test::PacketTransport* to_sender,
SimulatedNetworkInterface* receiver_network) {
RTC_DCHECK_RUN_ON(task_queue_);
send_transport_ = to_receiver;
send_simulated_network_ = sender_network;
}
void RampUpTester::PollStats() {
RTC_DCHECK_RUN_ON(task_queue_);

10
call/rampup_tests.h
View File

@ -83,7 +83,7 @@ class RampUpTester : public test::EndToEndTest {
Call* sender_call_;
VideoSendStream* send_stream_;
test::PacketTransport* send_transport_;
SimulatedNetwork* send_simulated_network_;
SimulatedNetworkInterface* send_simulated_network_;
private:
typedef std::map<uint32_t, uint32_t> SsrcMap;
@ -93,9 +93,7 @@ class RampUpTester : public test::EndToEndTest {
void OnVideoStreamsCreated(VideoSendStream* send_stream,
const std::vector<VideoReceiveStreamInterface*>&
receive_streams) override;
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override;
BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override;
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
@ -106,6 +104,10 @@ class RampUpTester : public test::EndToEndTest {
void ModifyFlexfecConfigs(
std::vector<FlexfecReceiveStream::Config>* receive_configs) override;
void OnCallsCreated(Call* sender_call, Call* receiver_call) override;
void OnTransportCreated(test::PacketTransport* to_receiver,
SimulatedNetworkInterface* sender_network,
test::PacketTransport* to_sender,
SimulatedNetworkInterface* receiver_network) override;
const int start_bitrate_bps_;
const int64_t min_run_time_ms_;

2
test/BUILD.gn
View File

@ -863,6 +863,7 @@ rtc_library("direct_transport") {
"direct_transport.h",
]
deps = [
"../api:rtp_parameters",
"../api:sequence_checker",
"../api:simulated_network_api",
"../api:transport_api",
@ -871,6 +872,7 @@ rtc_library("direct_transport") {
"../call:call_interfaces",
"../call:simulated_packet_receiver",
"../modules/rtp_rtcp:rtp_rtcp_format",
"../rtc_base:checks",
"../rtc_base:macromagic",
"../rtc_base:timeutils",
"../rtc_base/synchronization:mutex",

77
test/call_test.cc
View File

@ -20,12 +20,14 @@
#include "api/test/create_frame_generator.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "call/fake_network_pipe.h"
#include "call/packet_receiver.h"
#include "call/simulated_network.h"
#include "modules/audio_mixer/audio_mixer_impl.h"
#include "rtc_base/checks.h"
#include "rtc_base/event.h"
#include "rtc_base/task_queue_for_test.h"
#include "test/fake_encoder.h"
#include "test/rtp_rtcp_observer.h"
#include "test/testsupport/file_utils.h"
#include "video/config/video_encoder_config.h"
@ -126,13 +128,12 @@ void CallTest::RunBaseTest(BaseTest* test) {
CreateReceiverCall(recv_config);
}
test->OnCallsCreated(sender_call_.get(), receiver_call_.get());
receive_transport_ = test->CreateReceiveTransport(task_queue());
send_transport_ =
test->CreateSendTransport(task_queue(), sender_call_.get());
CreateReceiveTransport(test->GetReceiveTransportConfig(), test);
CreateSendTransport(test->GetSendTransportConfig(), test);
test->OnTransportCreated(send_transport_.get(), send_simulated_network_,
receive_transport_.get(),
receive_simulated_network_);
if (test->ShouldCreateReceivers()) {
send_transport_->SetReceiver(receiver_call_->Receiver());
receive_transport_->SetReceiver(sender_call_->Receiver());
if (num_video_streams_ > 0)
receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
if (num_audio_streams_ > 0)
@ -146,7 +147,7 @@ void CallTest::RunBaseTest(BaseTest* test) {
CreateSendConfig(num_video_streams_, num_audio_streams_,
num_flexfec_streams_, send_transport_.get());
if (test->ShouldCreateReceivers()) {
CreateMatchingReceiveConfigs(receive_transport_.get());
CreateMatchingReceiveConfigs();
}
if (num_video_streams_ > 0) {
test->ModifyVideoConfigs(GetVideoSendConfig(), &video_receive_configs_,
@ -235,6 +236,8 @@ void CallTest::CreateReceiverCall(const Call::Config& config) {
}
void CallTest::DestroyCalls() {
send_transport_.reset();
receive_transport_.reset();
sender_call_.reset();
receiver_call_.reset();
}
@ -568,6 +571,35 @@ void CallTest::CreateFlexfecStreams() {
}
}
void CallTest::CreateSendTransport(const BuiltInNetworkBehaviorConfig& config,
RtpRtcpObserver* observer) {
PacketReceiver* receiver =
receiver_call_ ? receiver_call_->Receiver() : nullptr;
auto network = std::make_unique<SimulatedNetwork>(config);
send_simulated_network_ = network.get();
send_transport_ = std::make_unique<PacketTransport>(
task_queue(), sender_call_.get(), observer,
test::PacketTransport::kSender, payload_type_map_,
std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
std::move(network), receiver),
rtp_extensions_, rtp_extensions_);
}
void CallTest::CreateReceiveTransport(
const BuiltInNetworkBehaviorConfig& config,
RtpRtcpObserver* observer) {
auto network = std::make_unique<SimulatedNetwork>(config);
receive_simulated_network_ = network.get();
receive_transport_ = std::make_unique<PacketTransport>(
task_queue(), nullptr, observer, test::PacketTransport::kReceiver,
payload_type_map_,
std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
std::move(network),
sender_call_->Receiver()),
rtp_extensions_, rtp_extensions_);
}
void CallTest::ConnectVideoSourcesToStreams() {
for (size_t i = 0; i < video_sources_.size(); ++i)
video_send_streams_[i]->SetSource(video_sources_[i].get(),
@ -710,6 +742,10 @@ const std::map<uint8_t, MediaType> CallTest::payload_type_map_ = {
{CallTest::kVideoSendPayloadType, MediaType::VIDEO},
{CallTest::kFakeVideoSendPayloadType, MediaType::VIDEO},
{CallTest::kSendRtxPayloadType, MediaType::VIDEO},
{CallTest::kPayloadTypeVP8, MediaType::VIDEO},
{CallTest::kPayloadTypeVP9, MediaType::VIDEO},
{CallTest::kPayloadTypeH264, MediaType::VIDEO},
{CallTest::kPayloadTypeGeneric, MediaType::VIDEO},
{CallTest::kRedPayloadType, MediaType::VIDEO},
{CallTest::kRtxRedPayloadType, MediaType::VIDEO},
{CallTest::kUlpfecPayloadType, MediaType::VIDEO},
@ -741,27 +777,18 @@ void BaseTest::ModifyReceiverBitrateConfig(BitrateConstraints* bitrate_config) {
void BaseTest::OnCallsCreated(Call* sender_call, Call* receiver_call) {}
std::unique_ptr<PacketTransport> BaseTest::CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) {
return std::make_unique<PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
CallTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig())));
void BaseTest::OnTransportCreated(PacketTransport* to_receiver,
SimulatedNetworkInterface* sender_network,
PacketTransport* to_sender,
SimulatedNetworkInterface* receiver_network) {
}
std::unique_ptr<PacketTransport> BaseTest::CreateReceiveTransport(
TaskQueueBase* task_queue) {
return std::make_unique<PacketTransport>(
task_queue, nullptr, this, test::PacketTransport::kReceiver,
CallTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig())));
BuiltInNetworkBehaviorConfig BaseTest::GetSendTransportConfig() const {
return BuiltInNetworkBehaviorConfig();
}
BuiltInNetworkBehaviorConfig BaseTest::GetReceiveTransportConfig() const {
return BuiltInNetworkBehaviorConfig();
}
size_t BaseTest::GetNumVideoStreams() const {
return 1;
}

44
test/call_test.h
View File

@ -16,9 +16,11 @@
#include <vector>
#include "absl/types/optional.h"
#include "api/array_view.h"
#include "api/rtc_event_log/rtc_event_log.h"
#include "api/task_queue/task_queue_base.h"
#include "api/task_queue/task_queue_factory.h"
#include "api/test/simulated_network.h"
#include "api/test/video/function_video_decoder_factory.h"
#include "api/test/video/function_video_encoder_factory.h"
#include "api/units/time_delta.h"
@ -76,6 +78,10 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
protected:
void RegisterRtpExtension(const RtpExtension& extension);
// Returns header extensions that can be parsed by the transport.
rtc::ArrayView<const RtpExtension> GetRegisteredExtensions() {
return rtp_extensions_;
}
// RunBaseTest overwrites the audio_state of the send and receive Call configs
// to simplify test code.
@ -102,11 +108,23 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
void SetSendUlpFecConfig(VideoSendStream::Config* send_config);
void SetReceiveUlpFecConfig(
VideoReceiveStreamInterface::Config* receive_config);
void CreateSendConfig(size_t num_video_streams,
size_t num_audio_streams,
size_t num_flexfec_streams) {
CreateSendConfig(num_video_streams, num_audio_streams, num_flexfec_streams,
send_transport_.get());
}
void CreateSendConfig(size_t num_video_streams,
size_t num_audio_streams,
size_t num_flexfec_streams,
Transport* send_transport);
void CreateMatchingVideoReceiveConfigs(
const VideoSendStream::Config& video_send_config) {
CreateMatchingVideoReceiveConfigs(video_send_config,
receive_transport_.get());
}
void CreateMatchingVideoReceiveConfigs(
const VideoSendStream::Config& video_send_config,
Transport* rtcp_send_transport);
@ -136,6 +154,9 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
void CreateMatchingFecConfig(
Transport* transport,
const VideoSendStream::Config& video_send_config);
void CreateMatchingReceiveConfigs() {
CreateMatchingReceiveConfigs(receive_transport_.get());
}
void CreateMatchingReceiveConfigs(Transport* rtcp_send_transport);
void CreateFrameGeneratorCapturerWithDrift(Clock* drift_clock,
@ -154,6 +175,16 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
void CreateAudioStreams();
void CreateFlexfecStreams();
// Receiver call must be created before calling CreateSendTransport in order
// to set a receiver.
// Rtp header extensions must be registered (RegisterRtpExtension(..)) before
// the transport is created in order for the receiving call object receive RTP
// packets with extensions.
void CreateSendTransport(const BuiltInNetworkBehaviorConfig& config,
RtpRtcpObserver* observer);
void CreateReceiveTransport(const BuiltInNetworkBehaviorConfig& config,
RtpRtcpObserver* observer);
void ConnectVideoSourcesToStreams();
void Start();
@ -187,6 +218,7 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
std::unique_ptr<webrtc::RtcEventLog> recv_event_log_;
std::unique_ptr<Call> sender_call_;
std::unique_ptr<PacketTransport> send_transport_;
SimulatedNetworkInterface* send_simulated_network_ = nullptr;
std::vector<VideoSendStream::Config> video_send_configs_;
std::vector<VideoEncoderConfig> video_encoder_configs_;
std::vector<VideoSendStream*> video_send_streams_;
@ -195,6 +227,7 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
std::unique_ptr<Call> receiver_call_;
std::unique_ptr<PacketTransport> receive_transport_;
SimulatedNetworkInterface* receive_simulated_network_ = nullptr;
std::vector<VideoReceiveStreamInterface::Config> video_receive_configs_;
std::vector<VideoReceiveStreamInterface*> video_receive_streams_;
std::vector<AudioReceiveStreamInterface::Config> audio_receive_configs_;
@ -265,12 +298,13 @@ class BaseTest : public RtpRtcpObserver {
virtual void ModifyReceiverBitrateConfig(BitrateConstraints* bitrate_config);
virtual void OnCallsCreated(Call* sender_call, Call* receiver_call);
virtual void OnTransportCreated(PacketTransport* to_receiver,
SimulatedNetworkInterface* sender_network,
PacketTransport* to_sender,
SimulatedNetworkInterface* receiver_network);
virtual std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call);
virtual std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
TaskQueueBase* task_queue);
virtual BuiltInNetworkBehaviorConfig GetSendTransportConfig() const;
virtual BuiltInNetworkBehaviorConfig GetReceiveTransportConfig() const;
virtual void ModifyVideoConfigs(
VideoSendStream::Config* send_config,

66
test/direct_transport.cc
View File

@ -9,12 +9,14 @@
*/
#include "test/direct_transport.h"
#include "absl/memory/memory.h"
#include "api/media_types.h"
#include "api/task_queue/task_queue_base.h"
#include "api/units/time_delta.h"
#include "call/call.h"
#include "call/fake_network_pipe.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "modules/rtp_rtcp/source/rtp_util.h"
#include "rtc_base/checks.h"
#include "rtc_base/task_utils/repeating_task.h"
#include "rtc_base/time_utils.h"
@ -43,10 +45,27 @@ DirectTransport::DirectTransport(
std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
Call* send_call,
const std::map<uint8_t, MediaType>& payload_type_map)
: DirectTransport(task_queue,
std::move(pipe),
send_call,
payload_type_map,
{},
{}) {}
DirectTransport::DirectTransport(
TaskQueueBase* task_queue,
std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
Call* send_call,
const std::map<uint8_t, MediaType>& payload_type_map,
rtc::ArrayView<const RtpExtension> audio_extensions,
rtc::ArrayView<const RtpExtension> video_extensions)
: send_call_(send_call),
task_queue_(task_queue),
demuxer_(payload_type_map),
fake_network_(std::move(pipe)) {
fake_network_(std::move(pipe)),
use_legacy_send_(audio_extensions.empty() && video_extensions.empty()),
audio_extensions_(audio_extensions),
video_extensions_(video_extensions) {
Start();
}
@ -69,23 +88,54 @@ bool DirectTransport::SendRtp(const uint8_t* data,
sent_packet.info.packet_type = rtc::PacketType::kData;
send_call_->OnSentPacket(sent_packet);
}
SendPacket(data, length);
if (use_legacy_send_) {
LegacySendPacket(data, length);
} else {
const RtpHeaderExtensionMap* extensions = nullptr;
MediaType media_type = demuxer_.GetMediaType(data, length);
switch (demuxer_.GetMediaType(data, length)) {
case webrtc::MediaType::AUDIO:
extensions = &audio_extensions_;
break;
case webrtc::MediaType::VIDEO:
extensions = &video_extensions_;
break;
default:
RTC_CHECK_NOTREACHED();
}
RtpPacketReceived packet(extensions, Timestamp::Micros(rtc::TimeMicros()));
if (media_type == MediaType::VIDEO) {
packet.set_payload_type_frequency(kVideoPayloadTypeFrequency);
}
RTC_CHECK(packet.Parse(rtc::CopyOnWriteBuffer(data, length)));
fake_network_->DeliverRtpPacket(
media_type, std::move(packet),
[](const RtpPacketReceived& packet) { return false; });
}
MutexLock lock(&process_lock_);
if (!next_process_task_.Running())
ProcessPackets();
return true;
}
bool DirectTransport::SendRtcp(const uint8_t* data, size_t length) {
SendPacket(data, length);
if (use_legacy_send_) {
LegacySendPacket(data, length);
} else {
fake_network_->DeliverRtcpPacket(rtc::CopyOnWriteBuffer(data, length));
}
MutexLock lock(&process_lock_);
if (!next_process_task_.Running())
ProcessPackets();
return true;
}
void DirectTransport::SendPacket(const uint8_t* data, size_t length) {
void DirectTransport::LegacySendPacket(const uint8_t* data, size_t length) {
MediaType media_type = demuxer_.GetMediaType(data, length);
int64_t send_time_us = rtc::TimeMicros();
fake_network_->DeliverPacket(media_type, rtc::CopyOnWriteBuffer(data, length),
send_time_us);
MutexLock lock(&process_lock_);
if (!next_process_task_.Running())
ProcessPackets();
}
int DirectTransport::GetAverageDelayMs() {

17
test/direct_transport.h
View File

@ -44,11 +44,21 @@ class Demuxer {
// same task-queue - the one that's passed in via the constructor.
class DirectTransport : public Transport {
public:
DirectTransport(TaskQueueBase* task_queue,
// TODO(perkj, https://bugs.webrtc.org/7135): Remove header once downstream
// projects have been updated.
[[deprecated("Use ctor that provide header extensions.")]] DirectTransport(
TaskQueueBase* task_queue,
std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
Call* send_call,
const std::map<uint8_t, MediaType>& payload_type_map);
DirectTransport(TaskQueueBase* task_queue,
std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
Call* send_call,
const std::map<uint8_t, MediaType>& payload_type_map,
rtc::ArrayView<const RtpExtension> audio_extensions,
rtc::ArrayView<const RtpExtension> video_extensions);
~DirectTransport() override;
// TODO(holmer): Look into moving this to the constructor.
@ -63,7 +73,7 @@ class DirectTransport : public Transport {
private:
void ProcessPackets() RTC_EXCLUSIVE_LOCKS_REQUIRED(&process_lock_);
void SendPacket(const uint8_t* data, size_t length);
void LegacySendPacket(const uint8_t* data, size_t length);
void Start();
Call* const send_call_;
@ -75,6 +85,9 @@ class DirectTransport : public Transport {
const Demuxer demuxer_;
const std::unique_ptr<SimulatedPacketReceiverInterface> fake_network_;
const bool use_legacy_send_;
const RtpHeaderExtensionMap audio_extensions_;
const RtpHeaderExtensionMap video_extensions_;
};
} // namespace test
} // namespace webrtc

19
test/layer_filtering_transport.cc
View File

@ -39,8 +39,15 @@ LayerFilteringTransport::LayerFilteringTransport(
int selected_sl,
const std::map<uint8_t, MediaType>& payload_type_map,
uint32_t ssrc_to_filter_min,
uint32_t ssrc_to_filter_max)
: DirectTransport(task_queue, std::move(pipe), send_call, payload_type_map),
uint32_t ssrc_to_filter_max,
rtc::ArrayView<const RtpExtension> audio_extensions,
rtc::ArrayView<const RtpExtension> video_extensions)
: DirectTransport(task_queue,
std::move(pipe),
send_call,
payload_type_map,
audio_extensions,
video_extensions),
vp8_video_payload_type_(vp8_video_payload_type),
vp9_video_payload_type_(vp9_video_payload_type),
vp8_depacketizer_(CreateVideoRtpDepacketizer(kVideoCodecVP8)),
@ -59,7 +66,9 @@ LayerFilteringTransport::LayerFilteringTransport(
uint8_t vp9_video_payload_type,
int selected_tl,
int selected_sl,
const std::map<uint8_t, MediaType>& payload_type_map)
const std::map<uint8_t, MediaType>& payload_type_map,
rtc::ArrayView<const RtpExtension> audio_extensions,
rtc::ArrayView<const RtpExtension> video_extensions)
: LayerFilteringTransport(task_queue,
std::move(pipe),
send_call,
@ -69,7 +78,9 @@ LayerFilteringTransport::LayerFilteringTransport(
selected_sl,
payload_type_map,
/*ssrc_to_filter_min=*/0,
/*ssrc_to_filter_max=*/0xFFFFFFFF) {}
/*ssrc_to_filter_max=*/0xFFFFFFFF,
audio_extensions,
video_extensions) {}
bool LayerFilteringTransport::DiscardedLastPacket() const {
return discarded_last_packet_;

8
test/layer_filtering_transport.h
View File

@ -39,7 +39,9 @@ class LayerFilteringTransport : public test::DirectTransport {
int selected_sl,
const std::map<uint8_t, MediaType>& payload_type_map,
uint32_t ssrc_to_filter_min,
uint32_t ssrc_to_filter_max);
uint32_t ssrc_to_filter_max,
rtc::ArrayView<const RtpExtension> audio_extensions,
rtc::ArrayView<const RtpExtension> video_extensions);
LayerFilteringTransport(
TaskQueueBase* task_queue,
std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
@ -48,7 +50,9 @@ class LayerFilteringTransport : public test::DirectTransport {
uint8_t vp9_video_payload_type,
int selected_tl,
int selected_sl,
const std::map<uint8_t, MediaType>& payload_type_map);
const std::map<uint8_t, MediaType>& payload_type_map,
rtc::ArrayView<const RtpExtension> audio_extensions,
rtc::ArrayView<const RtpExtension> video_extensions);
bool DiscardedLastPacket() const;
bool SendRtp(const uint8_t* data,
size_t length,

16
test/rtp_rtcp_observer.h
View File

@ -87,11 +87,15 @@ class PacketTransport : public test::DirectTransport {
RtpRtcpObserver* observer,
TransportType transport_type,
const std::map<uint8_t, MediaType>& payload_type_map,
std::unique_ptr<SimulatedPacketReceiverInterface> nw_pipe)
std::unique_ptr<SimulatedPacketReceiverInterface> nw_pipe,
rtc::ArrayView<const RtpExtension> audio_extensions,
rtc::ArrayView<const RtpExtension> video_extensions)
: test::DirectTransport(task_queue,
std::move(nw_pipe),
send_call,
payload_type_map),
payload_type_map,
audio_extensions,
video_extensions),
observer_(observer),
transport_type_(transport_type) {}
@ -100,8 +104,8 @@ class PacketTransport : public test::DirectTransport {
size_t length,
const PacketOptions& options) override {
EXPECT_TRUE(IsRtpPacket(rtc::MakeArrayView(packet, length)));
RtpRtcpObserver::Action action;
{
RtpRtcpObserver::Action action = RtpRtcpObserver::SEND_PACKET;
if (observer_) {
if (transport_type_ == kSender) {
action = observer_->OnSendRtp(packet, length);
} else {
@ -120,8 +124,8 @@ class PacketTransport : public test::DirectTransport {
bool SendRtcp(const uint8_t* packet, size_t length) override {
EXPECT_TRUE(IsRtcpPacket(rtc::MakeArrayView(packet, length)));
RtpRtcpObserver::Action action;
{
RtpRtcpObserver::Action action = RtpRtcpObserver::SEND_PACKET;
if (observer_) {
if (transport_type_ == kSender) {
action = observer_->OnSendRtcp(packet, length);
} else {

44
video/end_to_end_tests/bandwidth_tests.cc
View File

@ -196,25 +196,12 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
clock_(Clock::GetRealTimeClock()),
sender_ssrc_(0),
remb_bitrate_bps_(1000000),
receive_transport_(nullptr),
state_(kWaitForFirstRampUp),
retransmission_rate_limiter_(clock_, 1000),
task_queue_(task_queue) {}
void OnStreamsStopped() override { rtp_rtcp_ = nullptr; }
std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
TaskQueueBase* task_queue) override {
auto receive_transport = std::make_unique<test::PacketTransport>(
task_queue, nullptr, this, test::PacketTransport::kReceiver,
payload_type_map_,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
BuiltInNetworkBehaviorConfig())));
receive_transport_ = receive_transport.get();
return receive_transport;
}
void ModifySenderBitrateConfig(
BitrateConstraints* bitrate_config) override {
// Set a high start bitrate to reduce the test completion time.
@ -231,15 +218,8 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
encoder_config->max_bitrate_bps = 2000000;
ASSERT_EQ(1u, receive_configs->size());
RtpRtcpInterface::Configuration config;
config.receiver_only = true;
config.clock = clock_;
config.outgoing_transport = receive_transport_;
config.retransmission_rate_limiter = &retransmission_rate_limiter_;
config.local_media_ssrc = (*receive_configs)[0].rtp.local_ssrc;
rtp_rtcp_ = ModuleRtpRtcpImpl2::Create(config);
rtp_rtcp_->SetRemoteSSRC((*receive_configs)[0].rtp.remote_ssrc);
rtp_rtcp_->SetRTCPStatus(RtcpMode::kReducedSize);
remb_sender_local_ssrc_ = (*receive_configs)[0].rtp.local_ssrc;
remb_sender_remote_ssrc_ = (*receive_configs)[0].rtp.remote_ssrc;
}
void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
@ -248,6 +228,23 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
task_queue_->PostTask([this]() { PollStats(); });
}
void OnTransportCreated(
test::PacketTransport* /*to_receiver*/,
SimulatedNetworkInterface* /*sender_network*/,
test::PacketTransport* to_sender,
SimulatedNetworkInterface* /*receiver_network*/) override {
RtpRtcpInterface::Configuration config;
config.receiver_only = true;
config.clock = clock_;
config.outgoing_transport = to_sender;
config.retransmission_rate_limiter = &retransmission_rate_limiter_;
config.local_media_ssrc = remb_sender_local_ssrc_;
rtp_rtcp_ = ModuleRtpRtcpImpl2::Create(config);
rtp_rtcp_->SetRemoteSSRC(remb_sender_remote_ssrc_);
rtp_rtcp_->SetRTCPStatus(RtcpMode::kReducedSize);
}
void PollStats() {
Call::Stats stats = sender_call_->GetStats();
switch (state_) {
@ -296,9 +293,10 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
Call* sender_call_;
Clock* const clock_;
uint32_t sender_ssrc_;
uint32_t remb_sender_local_ssrc_ = 0;
uint32_t remb_sender_remote_ssrc_ = 0;
int remb_bitrate_bps_;
std::unique_ptr<ModuleRtpRtcpImpl2> rtp_rtcp_;
test::PacketTransport* receive_transport_;
TestState state_;
RateLimiter retransmission_rate_limiter_;
TaskQueueBase* const task_queue_;

62
video/end_to_end_tests/call_operation_tests.cc
View File

@ -94,31 +94,17 @@ TEST_F(CallOperationEndToEndTest, RendersSingleDelayedFrame) {
} renderer;
test::FrameForwarder frame_forwarder;
std::unique_ptr<test::DirectTransport> sender_transport;
std::unique_ptr<test::DirectTransport> receiver_transport;
SendTask(
task_queue(), [this, &renderer, &frame_forwarder, &sender_transport,
&receiver_transport]() {
task_queue(), [this, &renderer, &frame_forwarder]() {
CreateCalls();
CreateSendTransport(BuiltInNetworkBehaviorConfig(),
/*observer=*/nullptr);
sender_transport = std::make_unique<test::DirectTransport>(
task_queue(),
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
BuiltInNetworkBehaviorConfig())),
sender_call_.get(), payload_type_map_);
receiver_transport = std::make_unique<test::DirectTransport>(
task_queue(),
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
BuiltInNetworkBehaviorConfig())),
receiver_call_.get(), payload_type_map_);
sender_transport->SetReceiver(receiver_call_->Receiver());
receiver_transport->SetReceiver(sender_call_->Receiver());
CreateSendConfig(1, 0, 0, sender_transport.get());
CreateMatchingReceiveConfigs(receiver_transport.get());
CreateReceiveTransport(BuiltInNetworkBehaviorConfig(),
/*observer=*/nullptr);
CreateSendConfig(1, 0, 0);
CreateMatchingReceiveConfigs();
video_receive_configs_[0].renderer = &renderer;
@ -145,11 +131,9 @@ TEST_F(CallOperationEndToEndTest, RendersSingleDelayedFrame) {
EXPECT_TRUE(renderer.Wait())
<< "Timed out while waiting for the frame to render.";
SendTask(task_queue(), [this, &sender_transport, &receiver_transport]() {
SendTask(task_queue(), [this]() {
Stop();
DestroyStreams();
sender_transport.reset();
receiver_transport.reset();
DestroyCalls();
});
}
@ -171,27 +155,15 @@ TEST_F(CallOperationEndToEndTest, TransmitsFirstFrame) {
std::unique_ptr<test::DirectTransport> receiver_transport;
SendTask(
task_queue(), [this, &renderer, &frame_generator, &frame_forwarder,
&sender_transport, &receiver_transport]() {
task_queue(), [this, &renderer, &frame_generator, &frame_forwarder]() {
CreateCalls();
CreateSendTransport(BuiltInNetworkBehaviorConfig(),
/*observer=*/nullptr);
CreateReceiveTransport(BuiltInNetworkBehaviorConfig(),
/*observer=*/nullptr);
sender_transport = std::make_unique<test::DirectTransport>(
task_queue(),
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
BuiltInNetworkBehaviorConfig())),
sender_call_.get(), payload_type_map_);
receiver_transport = std::make_unique<test::DirectTransport>(
task_queue(),
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
BuiltInNetworkBehaviorConfig())),
receiver_call_.get(), payload_type_map_);
sender_transport->SetReceiver(receiver_call_->Receiver());
receiver_transport->SetReceiver(sender_call_->Receiver());
CreateSendConfig(1, 0, 0, sender_transport.get());
CreateMatchingReceiveConfigs(receiver_transport.get());
CreateSendConfig(1, 0, 0);
CreateMatchingReceiveConfigs();
video_receive_configs_[0].renderer = &renderer;
CreateVideoStreams();
@ -213,11 +185,9 @@ TEST_F(CallOperationEndToEndTest, TransmitsFirstFrame) {
EXPECT_TRUE(renderer.Wait())
<< "Timed out while waiting for the frame to render.";
SendTask(task_queue(), [this, &sender_transport, &receiver_transport]() {
SendTask(task_queue(), [this]() {
Stop();
DestroyStreams();
sender_transport.reset();
receiver_transport.reset();
DestroyCalls();
});
}

23
video/end_to_end_tests/extended_reports_tests.cc
View File

@ -158,17 +158,16 @@ class RtcpXrObserver : public test::EndToEndTest {
return enable_zero_target_bitrate_ ? 2 : 1;
}
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) {
auto network =
std::make_unique<SimulatedNetwork>(forward_transport_config_);
send_simulated_network_ = network.get();
return std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
test::CallTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
std::move(network)));
BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
return forward_transport_config_;
}
void OnTransportCreated(
test::PacketTransport* to_receiver,
SimulatedNetworkInterface* sender_network,
test::PacketTransport* to_sender,
SimulatedNetworkInterface* receiver_network) override {
send_simulated_network_ = sender_network;
}
void ModifyVideoConfigs(
@ -210,7 +209,7 @@ class RtcpXrObserver : public test::EndToEndTest {
bool sent_zero_rtcp_target_bitrate_ RTC_GUARDED_BY(&mutex_);
int sent_rtcp_dlrr_;
BuiltInNetworkBehaviorConfig forward_transport_config_;
SimulatedNetwork* send_simulated_network_;
SimulatedNetworkInterface* send_simulated_network_ = nullptr;
};
TEST_F(ExtendedReportsEndToEndTest,

22
video/end_to_end_tests/fec_tests.cc
View File

@ -256,19 +256,12 @@ class FlexfecRenderObserver : public test::EndToEndTest,
return SEND_PACKET;
}
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override {
BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
// At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
const int kNetworkDelayMs = 100;
BuiltInNetworkBehaviorConfig config;
config.queue_delay_ms = kNetworkDelayMs;
return std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
test::CallTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(config)));
return config;
}
void OnFrame(const VideoFrame& video_frame) override {
@ -439,20 +432,13 @@ TEST_F(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
return SEND_PACKET;
}
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override {
BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
// At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
// Configure some network delay.
const int kNetworkDelayMs = 50;
BuiltInNetworkBehaviorConfig config;
config.queue_delay_ms = kNetworkDelayMs;
return std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
payload_type_map_,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(config)));
return config;
}
// TODO(holmer): Investigate why we don't send FEC packets when the bitrate

26
video/end_to_end_tests/multi_codec_receive_tests.cc
View File

@ -131,22 +131,8 @@ class MultiCodecReceiveTest : public test::CallTest {
MultiCodecReceiveTest() {
SendTask(task_queue(), [this]() {
CreateCalls();
send_transport_.reset(new test::PacketTransport(
task_queue(), sender_call_.get(), &observer_,
test::PacketTransport::kSender, kPayloadTypeMap,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
BuiltInNetworkBehaviorConfig()))));
send_transport_->SetReceiver(receiver_call_->Receiver());
receive_transport_.reset(new test::PacketTransport(
task_queue(), receiver_call_.get(), &observer_,
test::PacketTransport::kReceiver, kPayloadTypeMap,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
BuiltInNetworkBehaviorConfig()))));
receive_transport_->SetReceiver(sender_call_->Receiver());
CreateSendTransport(BuiltInNetworkBehaviorConfig(), &observer_);
CreateReceiveTransport(BuiltInNetworkBehaviorConfig(), &observer_);
});
}
@ -170,10 +156,6 @@ class MultiCodecReceiveTest : public test::CallTest {
void RunTestWithCodecs(const std::vector<CodecConfig>& configs);
private:
const std::map<uint8_t, MediaType> kPayloadTypeMap = {
{CallTest::kPayloadTypeVP8, MediaType::VIDEO},
{CallTest::kPayloadTypeVP9, MediaType::VIDEO},
{CallTest::kPayloadTypeH264, MediaType::VIDEO}};
FrameObserver observer_;
};
@ -245,9 +227,9 @@ void MultiCodecReceiveTest::RunTestWithCodecs(
// Create and start call.
SendTask(task_queue(),
[this, &configs, &encoder_factory, &decoder_factory]() {
CreateSendConfig(1, 0, 0, send_transport_.get());
CreateSendConfig(1, 0, 0);
ConfigureEncoder(configs[0], &encoder_factory);
CreateMatchingReceiveConfigs(receive_transport_.get());
CreateMatchingReceiveConfigs();
video_receive_configs_[0].renderer = &observer_;
// Disable to avoid post-decode frame dropping in
// VideoRenderFrames.

7
video/end_to_end_tests/multi_stream_tester.cc
View File

@ -73,7 +73,6 @@ void MultiStreamTester::RunTest() {
sender_transport = CreateSendTransport(task_queue.get(), sender_call.get());
receiver_transport =
CreateReceiveTransport(task_queue.get(), receiver_call.get());
sender_transport->SetReceiver(receiver_call->Receiver());
receiver_transport->SetReceiver(sender_call->Receiver());
@ -158,22 +157,24 @@ void MultiStreamTester::UpdateReceiveConfig(
std::unique_ptr<test::DirectTransport> MultiStreamTester::CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) {
std::vector<RtpExtension> extensions = {};
return std::make_unique<test::DirectTransport>(
task_queue,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig())),
sender_call, payload_type_map_);
sender_call, payload_type_map_, extensions, extensions);
}
std::unique_ptr<test::DirectTransport>
MultiStreamTester::CreateReceiveTransport(TaskQueueBase* task_queue,
Call* receiver_call) {
std::vector<RtpExtension> extensions = {};
return std::make_unique<test::DirectTransport>(
task_queue,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig())),
receiver_call, payload_type_map_);
receiver_call, payload_type_map_, extensions, extensions);
}
} // namespace webrtc

24
video/end_to_end_tests/network_state_tests.cc
View File

@ -122,22 +122,13 @@ void NetworkStateEndToEndTest::VerifyNewVideoSendStreamsRespectNetworkState(
void NetworkStateEndToEndTest::VerifyNewVideoReceiveStreamsRespectNetworkState(
MediaType network_to_bring_up,
Transport* transport) {
std::unique_ptr<test::DirectTransport> sender_transport;
SendTask(
task_queue(),
[this, &sender_transport, network_to_bring_up, transport]() {
SendTask(task_queue(), [this, network_to_bring_up, transport]() {
CreateCalls();
receiver_call_->SignalChannelNetworkState(network_to_bring_up,
kNetworkUp);
sender_transport = std::make_unique<test::DirectTransport>(
task_queue(),
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
BuiltInNetworkBehaviorConfig())),
sender_call_.get(), payload_type_map_);
sender_transport->SetReceiver(receiver_call_->Receiver());
CreateSendConfig(1, 0, 0, sender_transport.get());
receiver_call_->SignalChannelNetworkState(network_to_bring_up, kNetworkUp);
CreateSendTransport(BuiltInNetworkBehaviorConfig(),
/*observer=*/nullptr);
CreateSendConfig(1, 0, 0);
CreateMatchingReceiveConfigs(transport);
CreateVideoStreams();
CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
@ -147,10 +138,9 @@ void NetworkStateEndToEndTest::VerifyNewVideoReceiveStreamsRespectNetworkState(
SleepMs(kSilenceTimeoutMs);
SendTask(task_queue(), [this, &sender_transport]() {
SendTask(task_queue(), [this]() {
Stop();
DestroyStreams();
sender_transport.reset();
DestroyCalls();
});
}

14
video/end_to_end_tests/retransmission_tests.cc
View File

@ -142,24 +142,13 @@ TEST_F(RetransmissionEndToEndTest, ReceivesNackAndRetransmitsAudio) {
size_t GetNumVideoStreams() const override { return 0; }
size_t GetNumAudioStreams() const override { return 1; }
std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
TaskQueueBase* task_queue) override {
auto receive_transport = std::make_unique<test::PacketTransport>(
task_queue, nullptr, this, test::PacketTransport::kReceiver,
payload_type_map_,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
BuiltInNetworkBehaviorConfig())));
receive_transport_ = receive_transport.get();
return receive_transport;
}
Action OnSendRtp(const uint8_t* packet, size_t length) override {
RtpPacket rtp_packet;
EXPECT_TRUE(rtp_packet.Parse(packet, length));
if (!sequence_number_to_retransmit_) {
sequence_number_to_retransmit_ = rtp_packet.SequenceNumber();
return DROP_PACKET;
// Don't ask for retransmission straight away, may be deduped in pacer.
} else if (rtp_packet.SequenceNumber() ==
@ -186,6 +175,7 @@ TEST_F(RetransmissionEndToEndTest, ReceivesNackAndRetransmitsAudio) {
(*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
local_ssrc_ = (*receive_configs)[0].rtp.local_ssrc;
remote_ssrc_ = (*receive_configs)[0].rtp.remote_ssrc;
receive_transport_ = (*receive_configs)[0].rtcp_send_transport;
}
void PerformTest() override {

68
video/end_to_end_tests/rtp_rtcp_tests.cc
View File

@ -279,34 +279,13 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
std::map<uint32_t, bool> ssrc_observed_ RTC_GUARDED_BY(mutex_);
} observer(use_rtx);
std::unique_ptr<test::PacketTransport> send_transport;
std::unique_ptr<test::PacketTransport> receive_transport;
VideoEncoderConfig one_stream;
SendTask(
task_queue(), [this, &observer, &send_transport, &receive_transport,
&one_stream, use_rtx]() {
SendTask(task_queue(), [this, &observer, &one_stream, use_rtx]() {
CreateCalls();
send_transport = std::make_unique<test::PacketTransport>(
task_queue(), sender_call_.get(), &observer,
test::PacketTransport::kSender, payload_type_map_,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(
BuiltInNetworkBehaviorConfig())));
receive_transport = std::make_unique<test::PacketTransport>(
task_queue(), nullptr, &observer, test::PacketTransport::kReceiver,
payload_type_map_,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(
BuiltInNetworkBehaviorConfig())));
send_transport->SetReceiver(receiver_call_->Receiver());
receive_transport->SetReceiver(sender_call_->Receiver());
CreateSendConfig(kNumSimulcastStreams, 0, 0, send_transport.get());
CreateSendTransport(BuiltInNetworkBehaviorConfig(), &observer);
CreateReceiveTransport(BuiltInNetworkBehaviorConfig(), &observer);
CreateSendConfig(kNumSimulcastStreams, 0, 0);
if (use_rtx) {
for (size_t i = 0; i < kNumSimulcastStreams; ++i) {
@ -322,7 +301,7 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
one_stream = GetVideoEncoderConfig()->Copy();
// one_stream.streams.resize(1);
one_stream.number_of_streams = 1;
CreateMatchingReceiveConfigs(receive_transport.get());
CreateMatchingReceiveConfigs();
CreateVideoStreams();
CreateFrameGeneratorCapturer(30, 1280, 720);
@ -348,7 +327,7 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
// to wait for a second for periodic Sender Report.
rtcp::RapidResyncRequest force_send_sr_back_request;
rtc::Buffer packet = force_send_sr_back_request.Build();
static_cast<webrtc::test::DirectTransport*>(receive_transport.get())
static_cast<webrtc::Transport*>(receive_transport_.get())
->SendRtcp(packet.data(), packet.size());
}
CreateFrameGeneratorCapturer(30, 1280, 720);
@ -383,11 +362,9 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
<< "Timed out waiting for all SSRCs to send packets.";
}
SendTask(task_queue(), [this, &send_transport, &receive_transport]() {
SendTask(task_queue(), [this]() {
Stop();
DestroyStreams();
send_transport.reset();
receive_transport.reset();
DestroyCalls();
});
}
@ -478,8 +455,6 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
static constexpr int kFrameMaxHeight = 180;
static constexpr int kFrameRate = 15;
std::unique_ptr<test::PacketTransport> send_transport;
std::unique_ptr<test::PacketTransport> receive_transport;
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
@ -490,29 +465,14 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
lossy_delayed_link.loss_percent = 2;
lossy_delayed_link.queue_delay_ms = 50;
send_transport = std::make_unique<test::PacketTransport>(
task_queue(), sender_call_.get(), &observer,
test::PacketTransport::kSender, payload_type_map_,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(lossy_delayed_link)));
send_transport->SetReceiver(receiver_call_->Receiver());
BuiltInNetworkBehaviorConfig flawless_link;
receive_transport = std::make_unique<test::PacketTransport>(
task_queue(), nullptr, &observer, test::PacketTransport::kReceiver,
payload_type_map_,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(flawless_link)));
receive_transport->SetReceiver(sender_call_->Receiver());
CreateSendTransport(lossy_delayed_link, &observer);
CreateReceiveTransport(BuiltInNetworkBehaviorConfig(), &observer);
// For reduced flakyness, we use a real VP8 encoder together with NACK
// and RTX.
const int kNumVideoStreams = 1;
const int kNumFlexfecStreams = 1;
CreateSendConfig(kNumVideoStreams, 0, kNumFlexfecStreams,
send_transport.get());
CreateSendConfig(kNumVideoStreams, 0, kNumFlexfecStreams);
GetVideoSendConfig()->encoder_settings.encoder_factory = &encoder_factory;
GetVideoSendConfig()->rtp.payload_name = "VP8";
@ -522,7 +482,7 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
GetVideoSendConfig()->rtp.rtx.payload_type = kSendRtxPayloadType;
GetVideoEncoderConfig()->codec_type = kVideoCodecVP8;
CreateMatchingReceiveConfigs(receive_transport.get());
CreateMatchingReceiveConfigs();
video_receive_configs_[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
video_receive_configs_[0].rtp.rtx_ssrc = kSendRtxSsrcs[0];
video_receive_configs_[0]
@ -533,7 +493,7 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
// CreateMatchingReceiveConfigs since this is not a test::BaseTest.
// Set up the receive config manually instead.
FlexfecReceiveStream::Config flexfec_receive_config(
receive_transport.get());
receive_transport_.get());
flexfec_receive_config.payload_type =
GetVideoSendConfig()->rtp.flexfec.payload_type;
flexfec_receive_config.rtp.remote_ssrc =
@ -582,11 +542,9 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets.";
// Cleanup.
SendTask(task_queue(), [this, &send_transport, &receive_transport]() {
SendTask(task_queue(), [this]() {
Stop();
DestroyStreams();
send_transport.reset();
receive_transport.reset();
DestroyCalls();
});
}

44
video/end_to_end_tests/ssrc_tests.cc
View File

@ -12,8 +12,10 @@
#include "api/test/simulated_network.h"
#include "call/fake_network_pipe.h"
#include "call/packet_receiver.h"
#include "call/simulated_network.h"
#include "modules/rtp_rtcp/source/rtp_packet.h"
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
#include "modules/rtp_rtcp/source/rtp_util.h"
#include "rtc_base/task_queue_for_test.h"
#include "test/call_test.h"
@ -22,6 +24,12 @@
namespace webrtc {
class SsrcEndToEndTest : public test::CallTest {
public:
SsrcEndToEndTest() {
RegisterRtpExtension(
RtpExtension(RtpExtension::kTransportSequenceNumberUri, 1));
}
protected:
void TestSendsSetSsrcs(size_t num_ssrcs, bool send_single_ssrc_first);
};
@ -49,31 +57,34 @@ TEST_F(SsrcEndToEndTest, ReceiverUsesLocalSsrc) {
RunBaseTest(&test);
}
TEST_F(SsrcEndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
TEST_F(SsrcEndToEndTest, UnknownRtpPacketTriggersUndemuxablePacketHandler) {
class PacketInputObserver : public PacketReceiver {
public:
explicit PacketInputObserver(PacketReceiver* receiver)
: receiver_(receiver) {}
bool Wait() { return delivered_packet_.Wait(kDefaultTimeout); }
bool Wait() {
return undemuxable_packet_handler_triggered_.Wait(kDefaultTimeout);
}
private:
DeliveryStatus DeliverPacket(MediaType media_type,
rtc::CopyOnWriteBuffer packet,
int64_t packet_time_us) override {
if (IsRtcpPacket(packet)) {
return receiver_->DeliverPacket(media_type, std::move(packet),
packet_time_us);
}
DeliveryStatus delivery_status = receiver_->DeliverPacket(
media_type, std::move(packet), packet_time_us);
EXPECT_EQ(DELIVERY_UNKNOWN_SSRC, delivery_status);
delivered_packet_.Set();
return delivery_status;
void DeliverRtpPacket(
MediaType media_type,
RtpPacketReceived packet,
OnUndemuxablePacketHandler undemuxable_packet_handler) override {
PacketReceiver::OnUndemuxablePacketHandler handler =
[this](const RtpPacketReceived& packet) {
undemuxable_packet_handler_triggered_.Set();
// No need to re-attempt deliver the packet.
return false;
};
receiver_->DeliverRtpPacket(media_type, std::move(packet),
std::move(handler));
}
void DeliverRtcpPacket(rtc::CopyOnWriteBuffer packet) override {}
PacketReceiver* receiver_;
rtc::Event delivered_packet_;
rtc::Event undemuxable_packet_handler_triggered_;
};
std::unique_ptr<test::DirectTransport> send_transport;
@ -90,7 +101,8 @@ TEST_F(SsrcEndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
BuiltInNetworkBehaviorConfig())),
sender_call_.get(), payload_type_map_);
sender_call_.get(), payload_type_map_, GetRegisteredExtensions(),
GetRegisteredExtensions());
receive_transport = std::make_unique<test::DirectTransport>(
task_queue(),
std::make_unique<FakeNetworkPipe>(

61
video/end_to_end_tests/stats_tests.cc
View File

@ -228,17 +228,10 @@ TEST_F(StatsEndToEndTest, GetStats) {
return true;
}
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override {
BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
BuiltInNetworkBehaviorConfig network_config;
network_config.loss_percent = 5;
return std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
payload_type_map_,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(network_config)));
return network_config;
}
void ModifySenderBitrateConfig(
@ -349,6 +342,8 @@ TEST_F(StatsEndToEndTest, GetStats) {
TEST_F(StatsEndToEndTest, TimingFramesAreReported) {
static const int kExtensionId = 5;
RegisterRtpExtension(
RtpExtension(RtpExtension::kVideoTimingUri, kExtensionId));
class StatsObserver : public test::EndToEndTest {
public:
@ -514,16 +509,12 @@ TEST_F(StatsEndToEndTest, MAYBE_ContentTypeSwitches) {
&encoder_config_with_screenshare]() {
CreateSenderCall(send_config);
CreateReceiverCall(recv_config);
receive_transport_ = test.CreateReceiveTransport(task_queue());
send_transport_ =
test.CreateSendTransport(task_queue(), sender_call_.get());
send_transport_->SetReceiver(receiver_call_->Receiver());
receive_transport_->SetReceiver(sender_call_->Receiver());
CreateReceiveTransport(test.GetReceiveTransportConfig(), &test);
CreateSendTransport(test.GetReceiveTransportConfig(), &test);
receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
CreateSendConfig(1, 0, 0, send_transport_.get());
CreateMatchingReceiveConfigs(receive_transport_.get());
CreateSendConfig(1, 0, 0);
CreateMatchingReceiveConfigs();
// Modify send and receive configs.
GetVideoSendConfig()->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
@ -562,8 +553,6 @@ TEST_F(StatsEndToEndTest, MAYBE_ContentTypeSwitches) {
SendTask(task_queue(), [this]() {
Stop();
DestroyStreams();
send_transport_.reset();
receive_transport_.reset();
DestroyCalls();
});
@ -698,36 +687,22 @@ TEST_F(StatsEndToEndTest, CallReportsRttForSender) {
static const int kSendDelayMs = 30;
static const int kReceiveDelayMs = 70;
std::unique_ptr<test::DirectTransport> sender_transport;
std::unique_ptr<test::DirectTransport> receiver_transport;
SendTask(task_queue(),
[this, &sender_transport, &receiver_transport]() {
SendTask(task_queue(), [this]() {
BuiltInNetworkBehaviorConfig config;
config.queue_delay_ms = kSendDelayMs;
CreateCalls();
sender_transport = std::make_unique<test::DirectTransport>(
task_queue(),
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(config)),
sender_call_.get(), payload_type_map_);
config.queue_delay_ms = kReceiveDelayMs;
receiver_transport = std::make_unique<test::DirectTransport>(
task_queue(),
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(config)),
receiver_call_.get(), payload_type_map_);
sender_transport->SetReceiver(receiver_call_->Receiver());
receiver_transport->SetReceiver(sender_call_->Receiver());
CreateSendTransport(config, /*observer*/ nullptr);
CreateSendConfig(1, 0, 0, sender_transport.get());
CreateMatchingReceiveConfigs(receiver_transport.get());
config.queue_delay_ms = kReceiveDelayMs;
CreateReceiveTransport(config, /*observer*/ nullptr);
CreateSendConfig(1, 0, 0);
CreateMatchingReceiveConfigs();
CreateVideoStreams();
CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
kDefaultHeight);
receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
Start();
});
@ -749,11 +724,9 @@ TEST_F(StatsEndToEndTest, CallReportsRttForSender) {
SleepMs(10);
}
SendTask(task_queue(), [this, &sender_transport, &receiver_transport]() {
SendTask(task_queue(), [this]() {
Stop();
DestroyStreams();
sender_transport.reset();
receiver_transport.reset();
DestroyCalls();
});
}

16
video/end_to_end_tests/transport_feedback_tests.cc
View File

@ -9,7 +9,9 @@
*/
#include <memory>
#include <vector>
#include "api/rtp_parameters.h"
#include "api/task_queue/task_queue_base.h"
#include "api/units/time_delta.h"
#include "call/call.h"
@ -46,14 +48,18 @@ TEST(TransportFeedbackMultiStreamTest, AssignsTransportSequenceNumbers) {
TaskQueueBase* task_queue,
Call* sender_call,
const std::map<uint32_t, uint32_t>& ssrc_map,
const std::map<uint8_t, MediaType>& payload_type_map)
const std::map<uint8_t, MediaType>& payload_type_map,
rtc::ArrayView<const RtpExtension> audio_extensions,
rtc::ArrayView<const RtpExtension> video_extensions)
: DirectTransport(task_queue,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(
BuiltInNetworkBehaviorConfig())),
sender_call,
payload_type_map),
payload_type_map,
audio_extensions,
video_extensions),
rtx_to_media_ssrcs_(ssrc_map),
rtx_padding_observed_(false),
retransmit_observed_(false),
@ -219,8 +225,12 @@ TEST(TransportFeedbackMultiStreamTest, AssignsTransportSequenceNumbers) {
RTC_DCHECK(payload_type_map.find(kSendRtxPayloadType) ==
payload_type_map.end());
payload_type_map[kSendRtxPayloadType] = MediaType::VIDEO;
std::vector<RtpExtension> extensions = {
RtpExtension(RtpExtension::kTransportSequenceNumberUri,
kTransportSequenceNumberExtensionId)};
auto observer = std::make_unique<RtpExtensionHeaderObserver>(
task_queue, sender_call, rtx_to_media_ssrcs_, payload_type_map);
task_queue, sender_call, rtx_to_media_ssrcs_, payload_type_map,
extensions, extensions);
observer_ = observer.get();
return observer;
}

10
video/picture_id_tests.cc
View File

@ -256,15 +256,7 @@ void PictureIdTest::SetupEncoder(VideoEncoderFactory* encoder_factory,
SendTask(
task_queue(), [this, encoder_factory, payload_name]() {
CreateCalls();
send_transport_.reset(new test::PacketTransport(
task_queue(), sender_call_.get(), observer_.get(),
test::PacketTransport::kSender, payload_type_map_,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(
BuiltInNetworkBehaviorConfig()))));
CreateSendTransport(BuiltInNetworkBehaviorConfig(), observer_.get());
CreateSendConfig(kNumSimulcastStreams, 0, 0, send_transport_.get());
GetVideoSendConfig()->encoder_settings.encoder_factory =
encoder_factory;

33
video/video_analyzer.cc
View File

@ -218,43 +218,38 @@ rtc::VideoSourceInterface<VideoFrame>* VideoAnalyzer::OutputInterface() {
return &captured_frame_forwarder_;
}
PacketReceiver::DeliveryStatus VideoAnalyzer::DeliverPacket(
MediaType media_type,
rtc::CopyOnWriteBuffer packet,
int64_t packet_time_us) {
// Ignore timestamps of RTCP packets. They're not synchronized with
// RTP packet timestamps and so they would confuse wrap_handler_.
if (IsRtcpPacket(packet)) {
return receiver_->DeliverPacket(media_type, std::move(packet),
packet_time_us);
}
void VideoAnalyzer::DeliverRtcpPacket(rtc::CopyOnWriteBuffer packet) {
return receiver_->DeliverRtcpPacket(std::move(packet));
}
void VideoAnalyzer::DeliverRtpPacket(
MediaType media_type,
RtpPacketReceived packet,
PacketReceiver::OnUndemuxablePacketHandler undemuxable_packet_handler) {
if (rtp_file_writer_) {
test::RtpPacket p;
memcpy(p.data, packet.cdata(), packet.size());
memcpy(p.data, packet.Buffer().data(), packet.size());
p.length = packet.size();
p.original_length = packet.size();
p.time_ms = clock_->TimeInMilliseconds() - start_ms_;
rtp_file_writer_->WritePacket(&p);
}
RtpPacket rtp_packet;
rtp_packet.Parse(packet);
if (!IsFlexfec(rtp_packet.PayloadType()) &&
(rtp_packet.Ssrc() == ssrc_to_analyze_ ||
rtp_packet.Ssrc() == rtx_ssrc_to_analyze_)) {
if (!IsFlexfec(packet.PayloadType()) &&
(packet.Ssrc() == ssrc_to_analyze_ ||
packet.Ssrc() == rtx_ssrc_to_analyze_)) {
// Ignore FlexFEC timestamps, to avoid collisions with media timestamps.
// (FlexFEC and media are sent on different SSRCs, which have different
// timestamps spaces.)
// Also ignore packets from wrong SSRC, but include retransmits.
MutexLock lock(&lock_);
int64_t timestamp =
wrap_handler_.Unwrap(rtp_packet.Timestamp() - rtp_timestamp_delta_);
wrap_handler_.Unwrap(packet.Timestamp() - rtp_timestamp_delta_);
recv_times_[timestamp] = clock_->CurrentNtpInMilliseconds();
}
return receiver_->DeliverPacket(media_type, std::move(packet),
packet_time_us);
return receiver_->DeliverRtpPacket(media_type, std::move(packet),
std::move(undemuxable_packet_handler));
}
void VideoAnalyzer::PreEncodeOnFrame(const VideoFrame& video_frame) {

8
video/video_analyzer.h
View File

@ -67,9 +67,11 @@ class VideoAnalyzer : public PacketReceiver,
rtc::VideoSinkInterface<VideoFrame>* InputInterface();
rtc::VideoSourceInterface<VideoFrame>* OutputInterface();
DeliveryStatus DeliverPacket(MediaType media_type,
rtc::CopyOnWriteBuffer packet,
int64_t packet_time_us) override;
void DeliverRtcpPacket(rtc::CopyOnWriteBuffer packet) override;
void DeliverRtpPacket(MediaType media_type,
RtpPacketReceived packet,
PacketReceiver::OnUndemuxablePacketHandler
undemuxable_packet_handler) override;
void PreEncodeOnFrame(const VideoFrame& video_frame);
void PostEncodeOnFrame(size_t stream_id, uint32_t timestamp);

35
video/video_quality_test.cc
View File

@ -411,26 +411,27 @@ VideoQualityTest::VideoQualityTest(
encoder_factory_ = std::make_unique<InternalEncoderFactory>();
}
payload_type_map_ = test::CallTest::payload_type_map_;
RTC_DCHECK(payload_type_map_.find(kPayloadTypeH264) ==
payload_type_map_.end());
RTC_DCHECK(payload_type_map_.find(kPayloadTypeVP8) ==
payload_type_map_.end());
RTC_DCHECK(payload_type_map_.find(kPayloadTypeVP9) ==
payload_type_map_.end());
RTC_DCHECK(payload_type_map_.find(kPayloadTypeGeneric) ==
payload_type_map_.end());
payload_type_map_[kPayloadTypeH264] = webrtc::MediaType::VIDEO;
payload_type_map_[kPayloadTypeVP8] = webrtc::MediaType::VIDEO;
payload_type_map_[kPayloadTypeVP9] = webrtc::MediaType::VIDEO;
payload_type_map_[kPayloadTypeGeneric] = webrtc::MediaType::VIDEO;
fec_controller_factory_ =
std::move(injection_components_->fec_controller_factory);
network_state_predictor_factory_ =
std::move(injection_components_->network_state_predictor_factory);
network_controller_factory_ =
std::move(injection_components_->network_controller_factory);
// Register header extensions that are used by transport to identify
// extensions when parsing incomig packets.
RegisterRtpExtension(RtpExtension(RtpExtension::kTransportSequenceNumberUri,
kTransportSequenceNumberExtensionId));
RegisterRtpExtension(
RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId));
RegisterRtpExtension(RtpExtension(RtpExtension::kGenericFrameDescriptorUri00,
kGenericFrameDescriptorExtensionId00));
RegisterRtpExtension(RtpExtension(RtpExtension::kDependencyDescriptorUri,
kRtpExtensionDependencyDescriptor));
RegisterRtpExtension(RtpExtension(RtpExtension::kVideoContentTypeUri,
kVideoContentTypeExtensionId));
RegisterRtpExtension(
RtpExtension(RtpExtension::kVideoTimingUri, kVideoTimingExtensionId));
}
VideoQualityTest::InjectionComponents::InjectionComponents() = default;
@ -1185,7 +1186,8 @@ VideoQualityTest::CreateSendTransport() {
params_.video[0].selected_tl, params_.ss[0].selected_sl,
payload_type_map_, kVideoSendSsrcs[0],
static_cast<uint32_t>(kVideoSendSsrcs[0] + params_.ss[0].streams.size() -
1));
1),
GetRegisteredExtensions(), GetRegisteredExtensions());
}
std::unique_ptr<test::DirectTransport>
@ -1199,7 +1201,8 @@ VideoQualityTest::CreateReceiveTransport() {
return std::make_unique<test::DirectTransport>(
task_queue(),
std::make_unique<FakeNetworkPipe>(clock_, std::move(network_behavior)),
receiver_call_.get(), payload_type_map_);
receiver_call_.get(), payload_type_map_, GetRegisteredExtensions(),
GetRegisteredExtensions());
}
void VideoQualityTest::RunWithAnalyzer(const Params& params) {

2
video/video_quality_test.h
View File

@ -65,8 +65,6 @@ class VideoQualityTest : public test::CallTest,
static std::vector<int> ParseCSV(const std::string& str);
protected:
std::map<uint8_t, webrtc::MediaType> payload_type_map_;
// No-op implementation to be able to instantiate this class from non-TEST_F
// locations.
void TestBody() override;

46
video/video_send_stream_tests.cc
View File

@ -19,6 +19,7 @@
#include "api/test/metrics/global_metrics_logger_and_exporter.h"
#include "api/test/metrics/metric.h"
#include "api/test/simulated_network.h"
#include "api/units/time_delta.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "api/video/encoded_image.h"
#include "api/video/video_bitrate_allocation.h"
@ -68,6 +69,7 @@
#include "test/gtest.h"
#include "test/null_transport.h"
#include "test/rtcp_packet_parser.h"
#include "test/rtp_rtcp_observer.h"
#include "test/video_encoder_proxy_factory.h"
#include "video/config/encoder_stream_factory.h"
#include "video/send_statistics_proxy.h"
@ -600,21 +602,14 @@ class UlpfecObserver : public test::EndToEndTest {
return SEND_PACKET;
}
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override {
BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
// At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
// Configure some network delay.
const int kNetworkDelayMs = 100;
BuiltInNetworkBehaviorConfig config;
config.loss_percent = 5;
config.queue_delay_ms = kNetworkDelayMs;
return std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
VideoSendStreamTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(config)));
return config;
}
void ModifyVideoConfigs(
@ -799,36 +794,23 @@ class FlexfecObserver : public test::EndToEndTest {
return SEND_PACKET;
}
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override {
BuiltInNetworkBehaviorConfig GetSendTransportConfig() const {
// At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
// Therefore we need some network delay.
const int kNetworkDelayMs = 100;
BuiltInNetworkBehaviorConfig config;
config.loss_percent = 5;
config.queue_delay_ms = kNetworkDelayMs;
return std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
VideoSendStreamTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(config)));
return config;
}
std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
TaskQueueBase* task_queue) override {
BuiltInNetworkBehaviorConfig GetReceiveTransportConfig() const {
// We need the RTT to be >200 ms to send FEC and the network delay for the
// send transport is 100 ms, so add 100 ms (but no loss) on the return link.
BuiltInNetworkBehaviorConfig config;
config.loss_percent = 0;
config.queue_delay_ms = 100;
return std::make_unique<test::PacketTransport>(
task_queue, nullptr, this, test::PacketTransport::kReceiver,
VideoSendStreamTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(config)));
return config;
}
void ModifyVideoConfigs(
@ -1017,6 +999,7 @@ void VideoSendStreamTest::TestNackRetransmission(
sequence_numbers_pending_retransmission_.size() <
kRetransmitTarget) {
sequence_numbers_pending_retransmission_.insert(sequence_number);
return DROP_PACKET;
}
} else {
// Packet is a retransmission, remove it from queue and check if done.
@ -1431,20 +1414,13 @@ TEST_F(VideoSendStreamTest, PaddingIsPrimarilyRetransmissions) {
return SEND_PACKET;
}
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override {
BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
const int kNetworkDelayMs = 50;
BuiltInNetworkBehaviorConfig config;
config.loss_percent = 10;
config.link_capacity_kbps = kCapacityKbps;
config.queue_delay_ms = kNetworkDelayMs;
return std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
payload_type_map_,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(config)));
return config;
}
void ModifyVideoConfigs(