zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleanup MultiStreamTester

Browse Source 
Instead of taking TaskQueue from outside create one internally.
Detach MultiStreamTests from test::CallTest since that inheritance
only used for constants and (now unneeded) task_queue object.

Bug: webrtc:10933
Change-Id: I7e30ddcf6faaa134ebcd9d53b578b40fdedf2a3c
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/159034
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#29744}
This commit is contained in:
Danil Chapovalov
2019-11-08 09:40:26 +01:00
committed by Commit Bot
parent 2bc811ea07
commit d6b9b0a1f4
4 changed files with 35 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
video/end_to_end_tests/multi_stream_tester.cc
View File

@ -31,23 +31,20 @@
namespace webrtc { namespace webrtc {
MultiStreamTester::MultiStreamTester(TaskQueueBase* task_queue) MultiStreamTester::MultiStreamTester() {
: task_queue_(task_queue) {
// TODO(sprang): Cleanup when msvc supports explicit initializers for array. // TODO(sprang): Cleanup when msvc supports explicit initializers for array.
codec_settings[0] = {1, 640, 480}; codec_settings[0] = {1, 640, 480};
codec_settings[1] = {2, 320, 240}; codec_settings[1] = {2, 320, 240};
codec_settings[2] = {3, 240, 160}; codec_settings[2] = {3, 240, 160};
class multi_stream_test {
public:
multi_stream_test();
};
} }
MultiStreamTester::~MultiStreamTester() {} MultiStreamTester::~MultiStreamTester() = default;
void MultiStreamTester::RunTest() { void MultiStreamTester::RunTest() {
webrtc::RtcEventLogNull event_log; webrtc::RtcEventLogNull event_log;
auto task_queue_factory = CreateDefaultTaskQueueFactory(); auto task_queue_factory = CreateDefaultTaskQueueFactory();
auto task_queue = task_queue_factory->CreateTaskQueue(
"TaskQueue", TaskQueueFactory::Priority::NORMAL);
Call::Config config(&event_log); Call::Config config(&event_log);
config.task_queue_factory = task_queue_factory.get(); config.task_queue_factory = task_queue_factory.get();
std::unique_ptr<Call> sender_call; std::unique_ptr<Call> sender_call;
@ -64,12 +61,12 @@ void MultiStreamTester::RunTest() {
CreateBuiltinVideoBitrateAllocatorFactory(); CreateBuiltinVideoBitrateAllocatorFactory();
InternalDecoderFactory decoder_factory; InternalDecoderFactory decoder_factory;
SendTask(RTC_FROM_HERE, task_queue_, [&]() { SendTask(RTC_FROM_HERE, task_queue.get(), [&]() {
sender_call = absl::WrapUnique(Call::Create(config)); sender_call = absl::WrapUnique(Call::Create(config));
receiver_call = absl::WrapUnique(Call::Create(config)); receiver_call = absl::WrapUnique(Call::Create(config));
sender_transport = CreateSendTransport(task_queue_, sender_call.get()); sender_transport = CreateSendTransport(task_queue.get(), sender_call.get());
receiver_transport = receiver_transport =
CreateReceiveTransport(task_queue_, receiver_call.get()); CreateReceiveTransport(task_queue.get(), receiver_call.get());
sender_transport->SetReceiver(receiver_call->Receiver()); sender_transport->SetReceiver(receiver_call->Receiver());
receiver_transport->SetReceiver(sender_call->Receiver()); receiver_transport->SetReceiver(sender_call->Receiver());
@ -125,7 +122,7 @@ void MultiStreamTester::RunTest() {
Wait(); Wait();
SendTask(RTC_FROM_HERE, task_queue_, [&]() { SendTask(RTC_FROM_HERE, task_queue.get(), [&]() {
for (size_t i = 0; i < kNumStreams; ++i) { for (size_t i = 0; i < kNumStreams; ++i) {
frame_generators[i]->Stop(); frame_generators[i]->Stop();
sender_call->DestroyVideoSendStream(send_streams[i]); sender_call->DestroyVideoSendStream(send_streams[i]);

4
video/end_to_end_tests/multi_stream_tester.h
View File

@ -35,7 +35,7 @@ class MultiStreamTester {
int height; int height;
} codec_settings[kNumStreams]; } codec_settings[kNumStreams];
explicit MultiStreamTester(TaskQueueBase* task_queue); MultiStreamTester();
virtual ~MultiStreamTester(); virtual ~MultiStreamTester();
@ -58,8 +58,6 @@ class MultiStreamTester {
virtual std::unique_ptr<test::DirectTransport> CreateReceiveTransport( virtual std::unique_ptr<test::DirectTransport> CreateReceiveTransport(
TaskQueueBase* task_queue, TaskQueueBase* task_queue,
Call* receiver_call); Call* receiver_call);
TaskQueueBase* const task_queue_;
}; };
} // namespace webrtc } // namespace webrtc
#endif // VIDEO_END_TO_END_TESTS_MULTI_STREAM_TESTER_H_ #endif // VIDEO_END_TO_END_TESTS_MULTI_STREAM_TESTER_H_

21
video/end_to_end_tests/multi_stream_tests.cc
View File

@ -21,20 +21,14 @@
#include "call/video_receive_stream.h" #include "call/video_receive_stream.h"
#include "call/video_send_stream.h" #include "call/video_send_stream.h"
#include "rtc_base/event.h" #include "rtc_base/event.h"
#include "test/call_test.h"
#include "test/frame_generator_capturer.h" #include "test/frame_generator_capturer.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "video/end_to_end_tests/multi_stream_tester.h" #include "video/end_to_end_tests/multi_stream_tester.h"
namespace webrtc { namespace webrtc {
class MultiStreamEndToEndTest : public test::CallTest {
public:
MultiStreamEndToEndTest() = default;
};
// Each renderer verifies that it receives the expected resolution, and as soon // Each renderer verifies that it receives the expected resolution, and as soon
// as every renderer has received a frame, the test finishes. // as every renderer has received a frame, the test finishes.
TEST_F(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) { TEST(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) {
class VideoOutputObserver : public rtc::VideoSinkInterface<VideoFrame> { class VideoOutputObserver : public rtc::VideoSinkInterface<VideoFrame> {
public: public:
VideoOutputObserver(const MultiStreamTester::CodecSettings& settings, VideoOutputObserver(const MultiStreamTester::CodecSettings& settings,
@ -51,7 +45,7 @@ TEST_F(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) {
uint32_t Ssrc() { return ssrc_; } uint32_t Ssrc() { return ssrc_; }
bool Wait() { return done_.Wait(kDefaultTimeoutMs); } bool Wait() { return done_.Wait(30 * 1000); }
private: private:
const MultiStreamTester::CodecSettings& settings_; const MultiStreamTester::CodecSettings& settings_;
@ -62,9 +56,8 @@ TEST_F(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) {
class Tester : public MultiStreamTester { class Tester : public MultiStreamTester {
public: public:
explicit Tester(TaskQueueBase* task_queue) Tester() = default;
: MultiStreamTester(task_queue) {} ~Tester() override = default;
virtual ~Tester() {}
protected: protected:
void Wait() override { void Wait() override {
@ -79,9 +72,9 @@ TEST_F(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) {
VideoSendStream::Config* send_config, VideoSendStream::Config* send_config,
VideoEncoderConfig* encoder_config, VideoEncoderConfig* encoder_config,
test::FrameGeneratorCapturer** frame_generator) override { test::FrameGeneratorCapturer** frame_generator) override {
observers_[stream_index].reset(new VideoOutputObserver( observers_[stream_index] = std::make_unique<VideoOutputObserver>(
codec_settings[stream_index], send_config->rtp.ssrcs.front(), codec_settings[stream_index], send_config->rtp.ssrcs.front(),
frame_generator)); frame_generator);
} }
void UpdateReceiveConfig( void UpdateReceiveConfig(
@ -92,7 +85,7 @@ TEST_F(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) {
private: private:
std::unique_ptr<VideoOutputObserver> observers_[kNumStreams]; std::unique_ptr<VideoOutputObserver> observers_[kNumStreams];
} tester(task_queue()); } tester;
tester.RunTest(); tester.RunTest();
} }

35
video/end_to_end_tests/transport_feedback_tests.cc
View File

@ -29,15 +29,13 @@ enum : int { // The first valid value is 1.
}; };
} // namespace } // namespace
class TransportFeedbackEndToEndTest : public test::CallTest { TEST(TransportFeedbackMultiStreamTest, AssignsTransportSequenceNumbers) {
public: static constexpr int kSendRtxPayloadType = 98;
TransportFeedbackEndToEndTest() { static constexpr int kDefaultTimeoutMs = 30 * 1000;
RegisterRtpExtension(RtpExtension(RtpExtension::kTransportSequenceNumberUri, static constexpr int kNackRtpHistoryMs = 1000;
kTransportSequenceNumberExtensionId)); static constexpr uint32_t kSendRtxSsrcs[MultiStreamTester::kNumStreams] = {
} 0xBADCAFD, 0xBADCAFE, 0xBADCAFF};
};
TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
class RtpExtensionHeaderObserver : public test::DirectTransport { class RtpExtensionHeaderObserver : public test::DirectTransport {
public: public:
RtpExtensionHeaderObserver( RtpExtensionHeaderObserver(
@ -56,7 +54,6 @@ TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
parser_(RtpHeaderParser::CreateForTest()), parser_(RtpHeaderParser::CreateForTest()),
first_media_ssrc_(first_media_ssrc), first_media_ssrc_(first_media_ssrc),
rtx_to_media_ssrcs_(ssrc_map), rtx_to_media_ssrcs_(ssrc_map),
padding_observed_(false),
rtx_padding_observed_(false), rtx_padding_observed_(false),
retransmit_observed_(false), retransmit_observed_(false),
started_(false) { started_(false) {
@ -149,6 +146,7 @@ TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
return done_.Wait(kDefaultTimeoutMs); return done_.Wait(kDefaultTimeoutMs);
} }
private:
rtc::CriticalSection lock_; rtc::CriticalSection lock_;
rtc::Event done_; rtc::Event done_;
std::unique_ptr<RtpHeaderParser> parser_; std::unique_ptr<RtpHeaderParser> parser_;
@ -158,7 +156,6 @@ TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
std::map<uint32_t, std::set<uint16_t>> dropped_seq_; std::map<uint32_t, std::set<uint16_t>> dropped_seq_;
const uint32_t& first_media_ssrc_; const uint32_t& first_media_ssrc_;
const std::map<uint32_t, uint32_t>& rtx_to_media_ssrcs_; const std::map<uint32_t, uint32_t>& rtx_to_media_ssrcs_;
bool padding_observed_;
bool rtx_padding_observed_; bool rtx_padding_observed_;
bool retransmit_observed_; bool retransmit_observed_;
bool started_; bool started_;
@ -166,11 +163,9 @@ TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
class TransportSequenceNumberTester : public MultiStreamTester { class TransportSequenceNumberTester : public MultiStreamTester {
public: public:
explicit TransportSequenceNumberTester(TaskQueueBase* task_queue) TransportSequenceNumberTester()
: MultiStreamTester(task_queue), : first_media_ssrc_(0), observer_(nullptr) {}
first_media_ssrc_(0), ~TransportSequenceNumberTester() override = default;
observer_(nullptr) {}
virtual ~TransportSequenceNumberTester() {}
protected: protected:
void Wait() override { void Wait() override {
@ -238,11 +233,19 @@ TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
uint32_t first_media_ssrc_; uint32_t first_media_ssrc_;
std::map<uint32_t, uint32_t> rtx_to_media_ssrcs_; std::map<uint32_t, uint32_t> rtx_to_media_ssrcs_;
RtpExtensionHeaderObserver* observer_; RtpExtensionHeaderObserver* observer_;
} tester(task_queue()); } tester;
tester.RunTest(); tester.RunTest();
} }
class TransportFeedbackEndToEndTest : public test::CallTest {
public:
TransportFeedbackEndToEndTest() {
RegisterRtpExtension(RtpExtension(RtpExtension::kTransportSequenceNumberUri,
kTransportSequenceNumberExtensionId));
}
};
class TransportFeedbackTester : public test::EndToEndTest { class TransportFeedbackTester : public test::EndToEndTest {
public: public:
TransportFeedbackTester(bool feedback_enabled, TransportFeedbackTester(bool feedback_enabled,