generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Refactor Call-based tests.

Browse Source 
Greatly reduces duplication of constants and setup code for tests based
on the new webrtc::Call APIs. It also makes it significantly easier to
convert sender-only to end-to-end tests as they share more code.

BUG=3035
R=kjellander@webrtc.org, stefan@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/17789004

git-svn-id: http://webrtc.googlecode.com/svn/trunk@6551 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
pbos@webrtc.org 2014-06-27 08:47:52 +00:00
parent 35d46fbe1a
commit 994d0b7229
13 changed files with 1527 additions and 1581 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tools/valgrind-webrtc/gtest_exclude/video_engine_tests.gtest-drmemory_win32.txt
View File

@ -1,6 +1,6 @@
# Never completes on Dr Memory Full.
# https://code.google.com/p/webrtc/issues/detail?id=3159
CallTest.SendsAndReceivesMultipleStreams
CallTest.ReceivesAndRetransmitsNack
EndToEndTest.SendsAndReceivesMultipleStreams
EndToEndTest.ReceivesAndRetransmitsNack
# https://code.google.com/p/webrtc/issues/detail?id=3471
VideoSendStreamTest.RetransmitsNackOverRtxWithPacing

2
tools/valgrind-webrtc/gtest_exclude/video_engine_tests.gtest-tsan.txt
View File

@ -1,2 +0,0 @@
# https://code.google.com/p/webrtc/issues/detail?id=2908
CallTest.ReceivesAndRetransmitsNack

216
webrtc/test/call_test.cc Normal file
View File

@ -0,0 +1,216 @@
/*
* Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "webrtc/test/call_test.h"
#include "webrtc/test/encoder_settings.h"
namespace webrtc {
namespace test {
CallTest::CallTest()
: send_stream_(NULL),
receive_stream_(NULL),
fake_encoder_(Clock::GetRealTimeClock()) {
}
CallTest::~CallTest() {
}
void CallTest::RunBaseTest(BaseTest* test) {
CreateSenderCall(test->GetSenderCallConfig());
if (test->ShouldCreateReceivers())
CreateReceiverCall(test->GetReceiverCallConfig());
test->OnCallsCreated(sender_call_.get(), receiver_call_.get());
if (test->ShouldCreateReceivers()) {
test->SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
} else {
// Sender-only call delivers to itself.
test->SetReceivers(sender_call_->Receiver(), NULL);
}
CreateSendConfig(test->GetNumStreams());
if (test->ShouldCreateReceivers()) {
CreateMatchingReceiveConfigs();
}
test->ModifyConfigs(&send_config_, &receive_config_, &video_streams_);
CreateStreams();
test->OnStreamsCreated(send_stream_, receive_stream_);
CreateFrameGeneratorCapturer();
test->OnFrameGeneratorCapturerCreated(frame_generator_capturer_.get());
Start();
test->PerformTest();
test->StopSending();
Stop();
DestroyStreams();
}
void CallTest::Start() {
send_stream_->Start();
if (receive_stream_ != NULL)
receive_stream_->Start();
frame_generator_capturer_->Start();
}
void CallTest::Stop() {
frame_generator_capturer_->Stop();
if (receive_stream_ != NULL)
receive_stream_->Stop();
send_stream_->Stop();
}
void CallTest::CreateCalls(const Call::Config& sender_config,
const Call::Config& receiver_config) {
CreateSenderCall(sender_config);
CreateReceiverCall(receiver_config);
}
void CallTest::CreateSenderCall(const Call::Config& config) {
sender_call_.reset(Call::Create(config));
}
void CallTest::CreateReceiverCall(const Call::Config& config) {
receiver_call_.reset(Call::Create(config));
}
void CallTest::CreateSendConfig(size_t num_streams) {
assert(num_streams <= kNumSsrcs);
send_config_ = sender_call_->GetDefaultSendConfig();
send_config_.encoder_settings.encoder = &fake_encoder_;
send_config_.encoder_settings.payload_name = "FAKE";
send_config_.encoder_settings.payload_type = kFakeSendPayloadType;
video_streams_ = test::CreateVideoStreams(num_streams);
for (size_t i = 0; i < num_streams; ++i)
send_config_.rtp.ssrcs.push_back(kSendSsrcs[i]);
}
// TODO(pbos): Make receive configs into a vector.
void CallTest::CreateMatchingReceiveConfigs() {
assert(send_config_.rtp.ssrcs.size() == 1);
receive_config_ = receiver_call_->GetDefaultReceiveConfig();
VideoCodec codec =
test::CreateDecoderVideoCodec(send_config_.encoder_settings);
receive_config_.codecs.push_back(codec);
if (send_config_.encoder_settings.encoder == &fake_encoder_) {
ExternalVideoDecoder decoder;
decoder.decoder = &fake_decoder_;
decoder.payload_type = send_config_.encoder_settings.payload_type;
receive_config_.external_decoders.push_back(decoder);
}
receive_config_.rtp.remote_ssrc = send_config_.rtp.ssrcs[0];
receive_config_.rtp.local_ssrc = kReceiverLocalSsrc;
}
void CallTest::CreateFrameGeneratorCapturer() {
VideoStream stream = video_streams_.back();
frame_generator_capturer_.reset(
test::FrameGeneratorCapturer::Create(send_stream_->Input(),
stream.width,
stream.height,
stream.max_framerate,
Clock::GetRealTimeClock()));
}
void CallTest::CreateStreams() {
assert(send_stream_ == NULL);
assert(receive_stream_ == NULL);
send_stream_ =
sender_call_->CreateVideoSendStream(send_config_, video_streams_, NULL);
if (receiver_call_.get() != NULL)
receive_stream_ = receiver_call_->CreateVideoReceiveStream(receive_config_);
}
void CallTest::DestroyStreams() {
if (send_stream_ != NULL)
sender_call_->DestroyVideoSendStream(send_stream_);
if (receive_stream_ != NULL)
receiver_call_->DestroyVideoReceiveStream(receive_stream_);
send_stream_ = NULL;
receive_stream_ = NULL;
}
const unsigned int CallTest::kDefaultTimeoutMs = 30 * 1000;
const unsigned int CallTest::kLongTimeoutMs = 120 * 1000;
const uint8_t CallTest::kSendPayloadType = 100;
const uint8_t CallTest::kFakeSendPayloadType = 125;
const uint8_t CallTest::kSendRtxPayloadType = 98;
const uint32_t CallTest::kSendRtxSsrc = 0xBADCAFE;
const uint32_t CallTest::kSendSsrcs[kNumSsrcs] = {0xC0FFED, 0xC0FFEE, 0xC0FFEF};
const uint32_t CallTest::kReceiverLocalSsrc = 0x123456;
const int CallTest::kNackRtpHistoryMs = 1000;
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() {
}
Call::Config BaseTest::GetSenderCallConfig() {
return Call::Config(SendTransport());
}
Call::Config BaseTest::GetReceiverCallConfig() {
return Call::Config(ReceiveTransport());
}
void BaseTest::OnCallsCreated(Call* sender_call, Call* receiver_call) {
}
size_t BaseTest::GetNumStreams() const {
return 1;
}
void BaseTest::ModifyConfigs(VideoSendStream::Config* send_config,
VideoReceiveStream::Config* receive_config,
std::vector<VideoStream>* video_streams) {
}
void BaseTest::OnStreamsCreated(VideoSendStream* send_stream,
VideoReceiveStream* receive_stream) {
}
void BaseTest::OnFrameGeneratorCapturerCreated(
FrameGeneratorCapturer* frame_generator_capturer) {
}
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;
}
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;
}
} // namespace test
} // namespace webrtc

119
webrtc/test/call_test.h Normal file
View File

@ -0,0 +1,119 @@
/*
* Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef WEBRTC_TEST_COMMON_CALL_TEST_H_
#define WEBRTC_TEST_COMMON_CALL_TEST_H_
#include <vector>
#include "webrtc/call.h"
#include "webrtc/test/fake_decoder.h"
#include "webrtc/test/fake_encoder.h"
#include "webrtc/test/frame_generator_capturer.h"
#include "webrtc/test/rtp_rtcp_observer.h"
namespace webrtc {
namespace test {
class BaseTest;
class CallTest : public ::testing::Test {
public:
CallTest();
~CallTest();
static const size_t kNumSsrcs = 3;
static const unsigned int kDefaultTimeoutMs;
static const unsigned int kLongTimeoutMs;
static const uint8_t kSendPayloadType;
static const uint8_t kSendRtxPayloadType;
static const uint8_t kFakeSendPayloadType;
static const uint32_t kSendRtxSsrc;
static const uint32_t kSendSsrcs[kNumSsrcs];
static const uint32_t kReceiverLocalSsrc;
static const int kNackRtpHistoryMs;
protected:
void RunBaseTest(BaseTest* test);
void CreateCalls(const Call::Config& sender_config,
const Call::Config& receiver_config);
void CreateSenderCall(const Call::Config& config);
void CreateReceiverCall(const Call::Config& config);
void CreateSendConfig(size_t num_streams);
void CreateMatchingReceiveConfigs();
void CreateFrameGeneratorCapturer();
void CreateStreams();
void Start();
void Stop();
void DestroyStreams();
scoped_ptr<Call> sender_call_;
VideoSendStream::Config send_config_;
std::vector<VideoStream> video_streams_;
VideoSendStream* send_stream_;
scoped_ptr<Call> receiver_call_;
VideoReceiveStream::Config receive_config_;
VideoReceiveStream* receive_stream_;
scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer_;
test::FakeEncoder fake_encoder_;
test::FakeDecoder fake_decoder_;
};
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;
virtual bool ShouldCreateReceivers() const = 0;
virtual size_t GetNumStreams() const;
virtual Call::Config GetSenderCallConfig();
virtual Call::Config GetReceiverCallConfig();
virtual void OnCallsCreated(Call* sender_call, Call* receiver_call);
virtual void ModifyConfigs(VideoSendStream::Config* send_config,
VideoReceiveStream::Config* receive_config,
std::vector<VideoStream>* video_streams);
virtual void OnStreamsCreated(VideoSendStream* send_stream,
VideoReceiveStream* receive_stream);
virtual void OnFrameGeneratorCapturerCreated(
FrameGeneratorCapturer* frame_generator_capturer);
};
class SendTest : public BaseTest {
public:
explicit SendTest(unsigned int timeout_ms);
SendTest(unsigned int timeout_ms, const FakeNetworkPipe::Config& config);
virtual bool ShouldCreateReceivers() const OVERRIDE;
};
class EndToEndTest : public BaseTest {
public:
explicit EndToEndTest(unsigned int timeout_ms);
EndToEndTest(unsigned int timeout_ms, const FakeNetworkPipe::Config& config);
virtual bool ShouldCreateReceivers() const OVERRIDE;
};
} // namespace test
} // namespace webrtc
#endif // WEBRTC_TEST_COMMON_CALL_TEST_H_

1
webrtc/test/rtp_rtcp_observer.h
View File

@ -16,6 +16,7 @@
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
#include "webrtc/test/direct_transport.h"
#include "webrtc/typedefs.h"
#include "webrtc/video_send_stream.h"

5
webrtc/test/webrtc_test_common.gyp
View File

@ -14,6 +14,8 @@
'target_name': 'webrtc_test_common',
'type': 'static_library',
'sources': [
'call_test.cc',
'call_test.h',
'configurable_frame_size_encoder.cc',
'configurable_frame_size_encoder.h',
'direct_transport.cc',
@ -54,10 +56,11 @@
'dependencies': [
'<(DEPTH)/testing/gtest.gyp:gtest',
'<(DEPTH)/third_party/gflags/gflags.gyp:gflags',
'<(webrtc_root)/modules/modules.gyp:video_capture_module',
'<(webrtc_root)/modules/modules.gyp:media_file',
'<(webrtc_root)/modules/modules.gyp:video_capture_module',
'<(webrtc_root)/test/test.gyp:frame_generator',
'<(webrtc_root)/test/test.gyp:test_support',
'<(webrtc_root)/webrtc.gyp:webrtc',
],
},
{

15
webrtc/video/bitrate_estimator_tests.cc
View File

@ -19,6 +19,7 @@
#include "webrtc/system_wrappers/interface/scoped_ptr.h"
#include "webrtc/system_wrappers/interface/thread_annotations.h"
#include "webrtc/system_wrappers/interface/trace.h"
#include "webrtc/test/call_test.h"
#include "webrtc/test/direct_transport.h"
#include "webrtc/test/encoder_settings.h"
#include "webrtc/test/fake_decoder.h"
@ -30,12 +31,7 @@ namespace webrtc {
static const int kTOFExtensionId = 4;
static const int kASTExtensionId = 5;
static unsigned int kDefaultTimeoutMs = 30 * 1000;
static const uint32_t kSendSsrc = 0x654321;
static const uint32_t kReceiverLocalSsrc = 0x123456;
static const uint8_t kSendPayloadType = 125;
class BitrateEstimatorTest : public ::testing::Test {
class BitrateEstimatorTest : public test::CallTest {
public:
BitrateEstimatorTest()
: receiver_trace_(),
@ -43,7 +39,6 @@ class BitrateEstimatorTest : public ::testing::Test {
receive_transport_(),
sender_call_(),
receiver_call_(),
send_config_(),
receive_config_(),
streams_() {
}
@ -68,11 +63,11 @@ class BitrateEstimatorTest : public ::testing::Test {
receive_transport_.SetReceiver(sender_call_->Receiver());
send_config_ = sender_call_->GetDefaultSendConfig();
send_config_.rtp.ssrcs.push_back(kSendSsrc);
send_config_.rtp.ssrcs.push_back(kSendSsrcs[0]);
// Encoders will be set separately per stream.
send_config_.encoder_settings.encoder = NULL;
send_config_.encoder_settings.payload_name = "FAKE";
send_config_.encoder_settings.payload_type = kSendPayloadType;
send_config_.encoder_settings.payload_type = kFakeSendPayloadType;
video_streams_ = test::CreateVideoStreams(1);
receive_config_ = receiver_call_->GetDefaultReceiveConfig();
@ -228,8 +223,6 @@ class BitrateEstimatorTest : public ::testing::Test {
test::DirectTransport receive_transport_;
scoped_ptr<Call> sender_call_;
scoped_ptr<Call> receiver_call_;
VideoSendStream::Config send_config_;
std::vector<VideoStream> video_streams_;
VideoReceiveStream::Config receive_config_;
std::vector<Stream*> streams_;
};

527
webrtc/video/call_perf_tests.cc
View File

@ -23,6 +23,7 @@
#include "webrtc/system_wrappers/interface/rtp_to_ntp.h"
#include "webrtc/system_wrappers/interface/scoped_ptr.h"
#include "webrtc/system_wrappers/interface/thread_annotations.h"
#include "webrtc/test/call_test.h"
#include "webrtc/test/direct_transport.h"
#include "webrtc/test/encoder_settings.h"
#include "webrtc/test/fake_audio_device.h"
@ -42,61 +43,20 @@
namespace webrtc {
static unsigned int kLongTimeoutMs = 120 * 1000;
static const uint32_t kSendSsrc = 0x654321;
static const uint32_t kReceiverLocalSsrc = 0x123456;
static const uint8_t kSendPayloadType = 125;
class CallPerfTest : public ::testing::Test {
public:
CallPerfTest()
: send_stream_(NULL), fake_encoder_(Clock::GetRealTimeClock()) {}
class CallPerfTest : public test::CallTest {
protected:
void CreateTestConfig(Call* call) {
send_config_ = call->GetDefaultSendConfig();
send_config_.rtp.ssrcs.push_back(kSendSsrc);
send_config_.encoder_settings.encoder = &fake_encoder_;
send_config_.encoder_settings.payload_type = kSendPayloadType;
send_config_.encoder_settings.payload_name = "FAKE";
video_streams_ = test::CreateVideoStreams(1);
}
void RunVideoSendTest(Call* call,
const VideoSendStream::Config& config,
test::RtpRtcpObserver* observer) {
send_stream_ = call->CreateVideoSendStream(config, video_streams_, NULL);
scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer(
test::FrameGeneratorCapturer::Create(
send_stream_->Input(), 320, 240, 30, Clock::GetRealTimeClock()));
send_stream_->Start();
frame_generator_capturer->Start();
EXPECT_EQ(kEventSignaled, observer->Wait());
observer->StopSending();
frame_generator_capturer->Stop();
send_stream_->Stop();
call->DestroyVideoSendStream(send_stream_);
}
void TestMinTransmitBitrate(bool pad_to_min_bitrate);
void TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
int threshold_ms,
int start_time_ms,
int run_time_ms);
VideoSendStream::Config send_config_;
std::vector<VideoStream> video_streams_;
VideoSendStream* send_stream_;
test::FakeEncoder fake_encoder_;
};
class SyncRtcpObserver : public test::RtpRtcpObserver {
public:
explicit SyncRtcpObserver(const FakeNetworkPipe::Config& config)
: test::RtpRtcpObserver(kLongTimeoutMs, config),
: test::RtpRtcpObserver(CallPerfTest::kLongTimeoutMs, config),
crit_(CriticalSectionWrapper::CreateCriticalSection()) {}
virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE {
@ -226,6 +186,31 @@ class VideoRtcpAndSyncObserver : public SyncRtcpObserver, public VideoRenderer {
};
TEST_F(CallPerfTest, PlaysOutAudioAndVideoInSync) {
class AudioPacketReceiver : public PacketReceiver {
public:
AudioPacketReceiver(int channel, VoENetwork* voe_network)
: channel_(channel),
voe_network_(voe_network),
parser_(RtpHeaderParser::Create()) {}
virtual DeliveryStatus DeliverPacket(const uint8_t* packet,
size_t length) OVERRIDE {
int ret;
if (parser_->IsRtcp(packet, static_cast<int>(length))) {
ret = voe_network_->ReceivedRTCPPacket(
channel_, packet, static_cast<unsigned int>(length));
} else {
ret = voe_network_->ReceivedRTPPacket(
channel_, packet, static_cast<unsigned int>(length), PacketTime());
}
return ret == 0 ? DELIVERY_OK : DELIVERY_PACKET_ERROR;
}
private:
int channel_;
VoENetwork* voe_network_;
scoped_ptr<RtpHeaderParser> parser_;
};
VoiceEngine* voice_engine = VoiceEngine::Create();
VoEBase* voe_base = VoEBase::GetInterface(voice_engine);
VoECodec* voe_codec = VoECodec::GetInterface(voice_engine);
@ -249,37 +234,12 @@ TEST_F(CallPerfTest, PlaysOutAudioAndVideoInSync) {
Call::Config receiver_config(observer.ReceiveTransport());
receiver_config.voice_engine = voice_engine;
scoped_ptr<Call> sender_call(
Call::Create(Call::Config(observer.SendTransport())));
scoped_ptr<Call> receiver_call(Call::Create(receiver_config));
CreateCalls(Call::Config(observer.SendTransport()), receiver_config);
CodecInst isac = {103, "ISAC", 16000, 480, 1, 32000};
EXPECT_EQ(0, voe_codec->SetSendCodec(channel, isac));
class VoicePacketReceiver : public PacketReceiver {
public:
VoicePacketReceiver(int channel, VoENetwork* voe_network)
: channel_(channel),
voe_network_(voe_network),
parser_(RtpHeaderParser::Create()) {}
virtual DeliveryStatus DeliverPacket(const uint8_t* packet,
size_t length) OVERRIDE {
int ret;
if (parser_->IsRtcp(packet, static_cast<int>(length))) {
ret = voe_network_->ReceivedRTCPPacket(
channel_, packet, static_cast<unsigned int>(length));
} else {
ret = voe_network_->ReceivedRTPPacket(
channel_, packet, static_cast<unsigned int>(length), PacketTime());
}
return ret == 0 ? DELIVERY_OK : DELIVERY_PACKET_ERROR;
}
private:
int channel_;
VoENetwork* voe_network_;
scoped_ptr<RtpHeaderParser> parser_;
} voe_packet_receiver(channel, voe_network);
AudioPacketReceiver voe_packet_receiver(channel, voe_network);
audio_observer.SetReceivers(&voe_packet_receiver, &voe_packet_receiver);
internal::TransportAdapter transport_adapter(audio_observer.SendTransport());
@ -287,41 +247,21 @@ TEST_F(CallPerfTest, PlaysOutAudioAndVideoInSync) {
EXPECT_EQ(0,
voe_network->RegisterExternalTransport(channel, transport_adapter));
observer.SetReceivers(receiver_call->Receiver(), sender_call->Receiver());
observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
test::FakeDecoder fake_decoder;
CreateTestConfig(sender_call.get());
CreateSendConfig(1);
CreateMatchingReceiveConfigs();
VideoReceiveStream::Config receive_config =
receiver_call->GetDefaultReceiveConfig();
assert(receive_config.codecs.empty());
VideoCodec codec =
test::CreateDecoderVideoCodec(send_config_.encoder_settings);
receive_config.codecs.push_back(codec);
assert(receive_config.external_decoders.empty());
ExternalVideoDecoder decoder;
decoder.decoder = &fake_decoder;
decoder.payload_type = send_config_.encoder_settings.payload_type;
receive_config.external_decoders.push_back(decoder);
receive_config.rtp.remote_ssrc = send_config_.rtp.ssrcs[0];
receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
receive_config.renderer = &observer;
receive_config.audio_channel_id = channel;
receive_config_.renderer = &observer;
receive_config_.audio_channel_id = channel;
VideoSendStream* send_stream =
sender_call->CreateVideoSendStream(send_config_, video_streams_, NULL);
VideoReceiveStream* receive_stream =
receiver_call->CreateVideoReceiveStream(receive_config);
scoped_ptr<test::FrameGeneratorCapturer> capturer(
test::FrameGeneratorCapturer::Create(send_stream->Input(),
video_streams_[0].width,
video_streams_[0].height,
30,
Clock::GetRealTimeClock()));
receive_stream->Start();
send_stream->Start();
capturer->Start();
CreateStreams();
CreateFrameGeneratorCapturer();
Start();
fake_audio_device.Start();
EXPECT_EQ(0, voe_base->StartPlayout(channel));
@ -336,9 +276,7 @@ TEST_F(CallPerfTest, PlaysOutAudioAndVideoInSync) {
EXPECT_EQ(0, voe_base->StopPlayout(channel));
fake_audio_device.Stop();
capturer->Stop();
send_stream->Stop();
receive_stream->Stop();
Stop();
observer.StopSending();
audio_observer.StopSending();
@ -347,174 +285,126 @@ TEST_F(CallPerfTest, PlaysOutAudioAndVideoInSync) {
voe_codec->Release();
voe_network->Release();
voe_sync->Release();
sender_call->DestroyVideoSendStream(send_stream);
receiver_call->DestroyVideoReceiveStream(receive_stream);
DestroyStreams();
VoiceEngine::Delete(voice_engine);
}
class CaptureNtpTimeObserver : public test::RtpRtcpObserver,
public VideoRenderer {
public:
CaptureNtpTimeObserver(Clock* clock,
const FakeNetworkPipe::Config& config,
int threshold_ms,
int start_time_ms,
int run_time_ms)
: RtpRtcpObserver(kLongTimeoutMs, config),
clock_(clock),
threshold_ms_(threshold_ms),
start_time_ms_(start_time_ms),
run_time_ms_(run_time_ms),
creation_time_ms_(clock_->TimeInMilliseconds()),
capturer_(NULL),
rtp_start_timestamp_set_(false),
rtp_start_timestamp_(0) {}
virtual void RenderFrame(const I420VideoFrame& video_frame,
int time_to_render_ms) OVERRIDE {
if (video_frame.ntp_time_ms() <= 0) {
// Haven't got enough RTCP SR in order to calculate the capture ntp time.
return;
}
int64_t now_ms = clock_->TimeInMilliseconds();
int64_t time_since_creation = now_ms - creation_time_ms_;
if (time_since_creation < start_time_ms_) {
// Wait for |start_time_ms_| before start measuring.
return;
}
if (time_since_creation > run_time_ms_) {
observation_complete_->Set();
}
FrameCaptureTimeList::iterator iter =
capture_time_list_.find(video_frame.timestamp());
EXPECT_TRUE(iter != capture_time_list_.end());
// The real capture time has been wrapped to uint32_t before converted
// to rtp timestamp in the sender side. So here we convert the estimated
// capture time to a uint32_t 90k timestamp also for comparing.
uint32_t estimated_capture_timestamp =
90 * static_cast<uint32_t>(video_frame.ntp_time_ms());
uint32_t real_capture_timestamp = iter->second;
int time_offset_ms = real_capture_timestamp - estimated_capture_timestamp;
time_offset_ms = time_offset_ms / 90;
std::stringstream ss;
ss << time_offset_ms;
webrtc::test::PrintResult("capture_ntp_time",
"",
"real - estimated",
ss.str(),
"ms",
true);
EXPECT_TRUE(std::abs(time_offset_ms) < threshold_ms_);
}
virtual Action OnSendRtp(const uint8_t* packet, size_t length) {
RTPHeader header;
EXPECT_TRUE(parser_->Parse(packet, static_cast<int>(length), &header));
if (!rtp_start_timestamp_set_) {
// Calculate the rtp timestamp offset in order to calculate the real
// capture time.
uint32_t first_capture_timestamp =
90 * static_cast<uint32_t>(capturer_->first_frame_capture_time());
rtp_start_timestamp_ = header.timestamp - first_capture_timestamp;
rtp_start_timestamp_set_ = true;
}
uint32_t capture_timestamp = header.timestamp - rtp_start_timestamp_;
capture_time_list_.insert(capture_time_list_.end(),
std::make_pair(header.timestamp,
capture_timestamp));
return SEND_PACKET;
}
void SetCapturer(test::FrameGeneratorCapturer* capturer) {
capturer_ = capturer;
}
private:
Clock* clock_;
int threshold_ms_;
int start_time_ms_;
int run_time_ms_;
int64_t creation_time_ms_;
test::FrameGeneratorCapturer* capturer_;
bool rtp_start_timestamp_set_;
uint32_t rtp_start_timestamp_;
typedef std::map<uint32_t, uint32_t> FrameCaptureTimeList;
FrameCaptureTimeList capture_time_list_;
};
void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
int threshold_ms,
int start_time_ms,
int run_time_ms) {
CaptureNtpTimeObserver observer(Clock::GetRealTimeClock(),
net_config,
threshold_ms,
start_time_ms,
run_time_ms);
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),
clock_(Clock::GetRealTimeClock()),
threshold_ms_(threshold_ms),
start_time_ms_(start_time_ms),
run_time_ms_(run_time_ms),
creation_time_ms_(clock_->TimeInMilliseconds()),
capturer_(NULL),
rtp_start_timestamp_set_(false),
rtp_start_timestamp_(0) {}
// Sender/receiver call.
Call::Config receiver_config(observer.ReceiveTransport());
scoped_ptr<Call> receiver_call(Call::Create(receiver_config));
scoped_ptr<Call> sender_call(
Call::Create(Call::Config(observer.SendTransport())));
observer.SetReceivers(receiver_call->Receiver(), sender_call->Receiver());
private:
virtual void RenderFrame(const I420VideoFrame& video_frame,
int time_to_render_ms) OVERRIDE {
if (video_frame.ntp_time_ms() <= 0) {
// Haven't got enough RTCP SR in order to calculate the capture ntp
// time.
return;
}
// Configure send stream.
CreateTestConfig(sender_call.get());
VideoSendStream* send_stream =
sender_call->CreateVideoSendStream(send_config_, video_streams_, NULL);
scoped_ptr<test::FrameGeneratorCapturer> capturer(
test::FrameGeneratorCapturer::Create(send_stream->Input(),
video_streams_[0].width,
video_streams_[0].height,
30,
Clock::GetRealTimeClock()));
observer.SetCapturer(capturer.get());
int64_t now_ms = clock_->TimeInMilliseconds();
int64_t time_since_creation = now_ms - creation_time_ms_;
if (time_since_creation < start_time_ms_) {
// Wait for |start_time_ms_| before start measuring.
return;
}
// Configure receive stream.
VideoReceiveStream::Config receive_config =
receiver_call->GetDefaultReceiveConfig();
assert(receive_config.codecs.empty());
VideoCodec codec =
test::CreateDecoderVideoCodec(send_config_.encoder_settings);
receive_config.codecs.push_back(codec);
assert(receive_config.external_decoders.empty());
ExternalVideoDecoder decoder;
test::FakeDecoder fake_decoder;
decoder.decoder = &fake_decoder;
decoder.payload_type = send_config_.encoder_settings.payload_type;
receive_config.external_decoders.push_back(decoder);
receive_config.rtp.remote_ssrc = send_config_.rtp.ssrcs[0];
receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
receive_config.renderer = &observer;
// Enable the receiver side rtt calculation.
receive_config.rtp.rtcp_xr.receiver_reference_time_report = true;
VideoReceiveStream* receive_stream =
receiver_call->CreateVideoReceiveStream(receive_config);
if (time_since_creation > run_time_ms_) {
observation_complete_->Set();
}
// Start the test
receive_stream->Start();
send_stream->Start();
capturer->Start();
FrameCaptureTimeList::iterator iter =
capture_time_list_.find(video_frame.timestamp());
EXPECT_TRUE(iter != capture_time_list_.end());
EXPECT_EQ(kEventSignaled, observer.Wait())
<< "Timed out while waiting for estimated capture ntp time to be "
<< "within bounds.";
// The real capture time has been wrapped to uint32_t before converted
// to rtp timestamp in the sender side. So here we convert the estimated
// capture time to a uint32_t 90k timestamp also for comparing.
uint32_t estimated_capture_timestamp =
90 * static_cast<uint32_t>(video_frame.ntp_time_ms());
uint32_t real_capture_timestamp = iter->second;
int time_offset_ms = real_capture_timestamp - estimated_capture_timestamp;
time_offset_ms = time_offset_ms / 90;
std::stringstream ss;
ss << time_offset_ms;
capturer->Stop();
send_stream->Stop();
receive_stream->Stop();
observer.StopSending();
webrtc::test::PrintResult(
"capture_ntp_time", "", "real - estimated", ss.str(), "ms", true);
EXPECT_TRUE(std::abs(time_offset_ms) < threshold_ms_);
}
sender_call->DestroyVideoSendStream(send_stream);
receiver_call->DestroyVideoReceiveStream(receive_stream);
virtual Action OnSendRtp(const uint8_t* packet, size_t length) {
RTPHeader header;
EXPECT_TRUE(parser_->Parse(packet, static_cast<int>(length), &header));
if (!rtp_start_timestamp_set_) {
// Calculate the rtp timestamp offset in order to calculate the real
// capture time.
uint32_t first_capture_timestamp =
90 * static_cast<uint32_t>(capturer_->first_frame_capture_time());
rtp_start_timestamp_ = header.timestamp - first_capture_timestamp;
rtp_start_timestamp_set_ = true;
}
uint32_t capture_timestamp = header.timestamp - rtp_start_timestamp_;
capture_time_list_.insert(
capture_time_list_.end(),
std::make_pair(header.timestamp, capture_timestamp));
return SEND_PACKET;
}
virtual void OnFrameGeneratorCapturerCreated(
test::FrameGeneratorCapturer* frame_generator_capturer) OVERRIDE {
capturer_ = frame_generator_capturer;
}
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
VideoReceiveStream::Config* receive_config,
std::vector<VideoStream>* video_streams) OVERRIDE {
receive_config->renderer = this;
// Enable the receiver side rtt calculation.
receive_config->rtp.rtcp_xr.receiver_reference_time_report = true;
}
virtual void PerformTest() OVERRIDE {
EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for "
"estimated capture NTP time to be "
"within bounds.";
}
Clock* clock_;
int threshold_ms_;
int start_time_ms_;
int run_time_ms_;
int64_t creation_time_ms_;
test::FrameGeneratorCapturer* capturer_;
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);
RunBaseTest(&test);
}
TEST_F(CallPerfTest, CaptureNtpTimeWithNetworkDelay) {
@ -542,26 +432,32 @@ TEST_F(CallPerfTest, CaptureNtpTimeWithNetworkJitter) {
TEST_F(CallPerfTest, RegisterCpuOveruseObserver) {
// Verifies that either a normal or overuse callback is triggered.
class OveruseCallbackObserver : public test::RtpRtcpObserver,
class OveruseCallbackObserver : public test::SendTest,
public webrtc::OveruseCallback {
public:
OveruseCallbackObserver() : RtpRtcpObserver(kLongTimeoutMs) {}
OveruseCallbackObserver() : SendTest(kLongTimeoutMs) {}
virtual void OnOveruse() OVERRIDE {
observation_complete_->Set();
}
virtual void OnNormalUse() OVERRIDE {
observation_complete_->Set();
}
};
OveruseCallbackObserver observer;
Call::Config call_config(observer.SendTransport());
call_config.overuse_callback = &observer;
scoped_ptr<Call> call(Call::Create(call_config));
virtual Call::Config GetSenderCallConfig() OVERRIDE {
Call::Config config(SendTransport());
config.overuse_callback = this;
return config;
}
CreateTestConfig(call.get());
RunVideoSendTest(call.get(), send_config_, &observer);
virtual void PerformTest() OVERRIDE {
EXPECT_EQ(kEventSignaled, Wait())
<< "Timed out before receiving an overuse callback.";
}
} test;
RunBaseTest(&test);
}
void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
@ -570,15 +466,16 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
static const int kMinAcceptableTransmitBitrate = 130;
static const int kMaxAcceptableTransmitBitrate = 170;
static const int kNumBitrateObservationsInRange = 100;
class BitrateObserver : public test::RtpRtcpObserver, public PacketReceiver {
class BitrateObserver : public test::EndToEndTest, public PacketReceiver {
public:
explicit BitrateObserver(bool using_min_transmit_bitrate)
: test::RtpRtcpObserver(kLongTimeoutMs),
: EndToEndTest(kLongTimeoutMs),
send_stream_(NULL),
send_transport_receiver_(NULL),
using_min_transmit_bitrate_(using_min_transmit_bitrate),
pad_to_min_bitrate_(using_min_transmit_bitrate),
num_bitrate_observations_in_range_(0) {}
private:
virtual void SetReceivers(PacketReceiver* send_transport_receiver,
PacketReceiver* receive_transport_receiver)
OVERRIDE {
@ -586,11 +483,6 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
test::RtpRtcpObserver::SetReceivers(this, receive_transport_receiver);
}
void SetSendStream(VideoSendStream* send_stream) {
send_stream_ = send_stream;
}
private:
virtual DeliveryStatus DeliverPacket(const uint8_t* packet,
size_t length) OVERRIDE {
VideoSendStream::Stats stats = send_stream_->GetStats();
@ -600,13 +492,13 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
if (bitrate_kbps > 0) {
test::PrintResult(
"bitrate_stats_",
(using_min_transmit_bitrate_ ? "min_transmit_bitrate"
: "without_min_transmit_bitrate"),
(pad_to_min_bitrate_ ? "min_transmit_bitrate"
: "without_min_transmit_bitrate"),
"bitrate_kbps",
static_cast<size_t>(bitrate_kbps),
"kbps",
false);
if (using_min_transmit_bitrate_) {
if (pad_to_min_bitrate_) {
if (bitrate_kbps > kMinAcceptableTransmitBitrate &&
bitrate_kbps < kMaxAcceptableTransmitBitrate) {
++num_bitrate_observations_in_range_;
@ -626,66 +518,35 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
return send_transport_receiver_->DeliverPacket(packet, length);
}
virtual void OnStreamsCreated(VideoSendStream* send_stream,
VideoReceiveStream* receive_stream) {
send_stream_ = send_stream;
}
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
VideoReceiveStream::Config* receive_config,
std::vector<VideoStream>* video_streams) OVERRIDE {
if (pad_to_min_bitrate_) {
send_config->rtp.min_transmit_bitrate_bps = kMinTransmitBitrateBps;
} else {
assert(send_config->rtp.min_transmit_bitrate_bps == 0);
}
}
virtual void PerformTest() OVERRIDE {
EXPECT_EQ(kEventSignaled, Wait())
<< "Timeout while waiting for send-bitrate stats.";
}
VideoSendStream* send_stream_;
PacketReceiver* send_transport_receiver_;
const bool using_min_transmit_bitrate_;
const bool pad_to_min_bitrate_;
int num_bitrate_observations_in_range_;
} observer(pad_to_min_bitrate);
} test(pad_to_min_bitrate);
scoped_ptr<Call> sender_call(
Call::Create(Call::Config(observer.SendTransport())));
scoped_ptr<Call> receiver_call(
Call::Create(Call::Config(observer.ReceiveTransport())));
CreateTestConfig(sender_call.get());
fake_encoder_.SetMaxBitrate(kMaxEncodeBitrateKbps);
observer.SetReceivers(receiver_call->Receiver(), sender_call->Receiver());
if (pad_to_min_bitrate) {
send_config_.rtp.min_transmit_bitrate_bps = kMinTransmitBitrateBps;
} else {
assert(send_config_.rtp.min_transmit_bitrate_bps == 0);
}
VideoReceiveStream::Config receive_config =
receiver_call->GetDefaultReceiveConfig();
receive_config.codecs.clear();
VideoCodec codec =
test::CreateDecoderVideoCodec(send_config_.encoder_settings);
receive_config.codecs.push_back(codec);
test::FakeDecoder fake_decoder;
ExternalVideoDecoder decoder;
decoder.decoder = &fake_decoder;
decoder.payload_type = send_config_.encoder_settings.payload_type;
receive_config.external_decoders.push_back(decoder);
receive_config.rtp.remote_ssrc = send_config_.rtp.ssrcs[0];
receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
VideoSendStream* send_stream =
sender_call->CreateVideoSendStream(send_config_, video_streams_, NULL);
VideoReceiveStream* receive_stream =
receiver_call->CreateVideoReceiveStream(receive_config);
scoped_ptr<test::FrameGeneratorCapturer> capturer(
test::FrameGeneratorCapturer::Create(send_stream->Input(),
video_streams_[0].width,
video_streams_[0].height,
30,
Clock::GetRealTimeClock()));
observer.SetSendStream(send_stream);
receive_stream->Start();
send_stream->Start();
capturer->Start();
EXPECT_EQ(kEventSignaled, observer.Wait())
<< "Timeout while waiting for send-bitrate stats.";
send_stream->Stop();
receive_stream->Stop();
observer.StopSending();
capturer->Stop();
sender_call->DestroyVideoSendStream(send_stream);
receiver_call->DestroyVideoReceiveStream(receive_stream);
RunBaseTest(&test);
}
TEST_F(CallPerfTest, PadsToMinTransmitBitrate) { TestMinTransmitBitrate(true); }

1217
webrtc/video/call_tests.cc → webrtc/video/end_to_end_tests.cc
View File

File diff suppressed because it is too large Load Diff

106
webrtc/video/full_stack.cc
View File

@ -24,6 +24,7 @@
#include "webrtc/system_wrappers/interface/scoped_ptr.h"
#include "webrtc/system_wrappers/interface/sleep.h"
#include "webrtc/system_wrappers/interface/thread_annotations.h"
#include "webrtc/test/call_test.h"
#include "webrtc/test/direct_transport.h"
#include "webrtc/test/encoder_settings.h"
#include "webrtc/test/fake_encoder.h"
@ -34,7 +35,6 @@
namespace webrtc {
static const uint32_t kSendSsrc = 0x654321;
static const int kFullStackTestDurationSecs = 10;
struct FullStackTestParams {
@ -49,20 +49,9 @@ struct FullStackTestParams {
double avg_ssim_threshold;
};
FullStackTestParams paris_qcif = {
"net_delay_0_0_plr_0", {"paris_qcif", 176, 144, 30}, 300, 36.0, 0.96};
// TODO(pbos): Decide on psnr/ssim thresholds for foreman_cif.
FullStackTestParams foreman_cif = {
"foreman_cif_net_delay_0_0_plr_0",
{"foreman_cif", 352, 288, 30},
700,
0.0,
0.0};
class FullStackTest : public ::testing::TestWithParam<FullStackTestParams> {
class FullStackTest : public test::CallTest {
protected:
std::map<uint32_t, bool> reserved_ssrcs_;
void TestWithoutPacketLoss(const FullStackTestParams& params);
};
class VideoAnalyzer : public PacketReceiver,
@ -200,7 +189,9 @@ class VideoAnalyzer : public PacketReceiver,
last_rendered_frame_.CopyFrame(video_frame);
}
void Wait() { done_->Wait(120 * 1000); }
void Wait() {
EXPECT_EQ(kEventSignaled, done_->Wait(FullStackTest::kLongTimeoutMs));
}
VideoSendStreamInput* input_;
Transport* transport_;
@ -376,10 +367,7 @@ class VideoAnalyzer : public PacketReceiver,
const scoped_ptr<EventWrapper> done_;
};
TEST_P(FullStackTest, NoPacketLoss) {
static const uint32_t kReceiverLocalSsrc = 0x123456;
FullStackTestParams params = GetParam();
void FullStackTest::TestWithoutPacketLoss(const FullStackTestParams& params) {
test::DirectTransport transport;
VideoAnalyzer analyzer(NULL,
&transport,
@ -388,32 +376,32 @@ TEST_P(FullStackTest, NoPacketLoss) {
params.avg_ssim_threshold,
kFullStackTestDurationSecs * params.clip.fps);
Call::Config call_config(&analyzer);
CreateCalls(Call::Config(&analyzer), Call::Config(&analyzer));
scoped_ptr<Call> call(Call::Create(call_config));
analyzer.SetReceiver(call->Receiver());
analyzer.SetReceiver(receiver_call_->Receiver());
transport.SetReceiver(&analyzer);
VideoSendStream::Config send_config = call->GetDefaultSendConfig();
send_config.rtp.ssrcs.push_back(kSendSsrc);
CreateSendConfig(1);
scoped_ptr<VP8Encoder> encoder(VP8Encoder::Create());
send_config.encoder_settings.encoder = encoder.get();
send_config.encoder_settings.payload_name = "VP8";
send_config.encoder_settings.payload_type = 124;
std::vector<VideoStream> video_streams = test::CreateVideoStreams(1);
VideoStream* stream = &video_streams[0];
send_config_.encoder_settings.encoder = encoder.get();
send_config_.encoder_settings.payload_name = "VP8";
send_config_.encoder_settings.payload_type = 124;
VideoStream* stream = &video_streams_[0];
stream->width = params.clip.width;
stream->height = params.clip.height;
stream->min_bitrate_bps = stream->target_bitrate_bps =
stream->max_bitrate_bps = params.bitrate * 1000;
stream->max_framerate = params.clip.fps;
VideoSendStream* send_stream =
call->CreateVideoSendStream(send_config, video_streams, NULL);
analyzer.input_ = send_stream->Input();
CreateMatchingReceiveConfigs();
receive_config_.renderer = &analyzer;
scoped_ptr<test::FrameGeneratorCapturer> file_capturer(
CreateStreams();
analyzer.input_ = send_stream_->Input();
frame_generator_capturer_.reset(
test::FrameGeneratorCapturer::CreateFromYuvFile(
&analyzer,
test::ResourcePath(params.clip.name, "yuv").c_str(),
@ -421,39 +409,41 @@ TEST_P(FullStackTest, NoPacketLoss) {
params.clip.height,
params.clip.fps,
Clock::GetRealTimeClock()));
ASSERT_TRUE(file_capturer.get() != NULL)
ASSERT_TRUE(frame_generator_capturer_.get() != NULL)
<< "Could not create capturer for " << params.clip.name
<< ".yuv. Is this resource file present?";
VideoReceiveStream::Config receive_config = call->GetDefaultReceiveConfig();
VideoCodec codec =
test::CreateDecoderVideoCodec(send_config.encoder_settings);
receive_config.codecs.push_back(codec);
receive_config.rtp.remote_ssrc = send_config.rtp.ssrcs[0];
receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
receive_config.renderer = &analyzer;
VideoReceiveStream* receive_stream =
call->CreateVideoReceiveStream(receive_config);
receive_stream->Start();
send_stream->Start();
file_capturer->Start();
Start();
analyzer.Wait();
file_capturer->Stop();
send_stream->Stop();
receive_stream->Stop();
call->DestroyVideoReceiveStream(receive_stream);
call->DestroyVideoSendStream(send_stream);
transport.StopSending();
Stop();
DestroyStreams();
}
INSTANTIATE_TEST_CASE_P(FullStack,
FullStackTest,
::testing::Values(paris_qcif, foreman_cif));
FullStackTestParams paris_qcif = {"net_delay_0_0_plr_0",
{"paris_qcif", 176, 144, 30},
300,
36.0,
0.96};
// TODO(pbos): Decide on psnr/ssim thresholds for foreman_cif.
FullStackTestParams foreman_cif = {"foreman_cif_net_delay_0_0_plr_0",
{"foreman_cif", 352, 288, 30},
700,
0.0,
0.0};
TEST_F(FullStackTest, ParisQcifWithoutPacketLoss) {
TestWithoutPacketLoss(paris_qcif);
}
TEST_F(FullStackTest, ForemanCifWithoutPacketLoss) {
TestWithoutPacketLoss(foreman_cif);
}
} // namespace webrtc

127
webrtc/video/rampup_tests.cc
View File

@ -27,6 +27,7 @@
#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
#include "webrtc/system_wrappers/interface/event_wrapper.h"
#include "webrtc/system_wrappers/interface/scoped_ptr.h"
#include "webrtc/test/call_test.h"
#include "webrtc/test/direct_transport.h"
#include "webrtc/test/encoder_settings.h"
#include "webrtc/test/fake_decoder.h"
@ -388,7 +389,9 @@ class LowRateStreamObserver : public test::DirectTransport,
}
}
EventTypeWrapper Wait() { return test_done_->Wait(120 * 1000); }
EventTypeWrapper Wait() {
return test_done_->Wait(test::CallTest::kLongTimeoutMs);
}
private:
static const unsigned int kHighBandwidthLimitBps = 80000;
@ -420,10 +423,7 @@ class LowRateStreamObserver : public test::DirectTransport,
};
} // namespace
class RampUpTest : public ::testing::Test {
public:
virtual void SetUp() { reserved_ssrcs_.clear(); }
class RampUpTest : public test::CallTest {
protected:
void RunRampUpTest(bool rtx,
size_t num_streams,
@ -445,33 +445,26 @@ class RampUpTest : public ::testing::Test {
call_config.start_bitrate_bps = start_bitrate_bps;
stream_observer.set_start_bitrate_bps(start_bitrate_bps);
}
scoped_ptr<Call> call(Call::Create(call_config));
VideoSendStream::Config send_config = call->GetDefaultSendConfig();
receiver_transport.SetReceiver(call->Receiver());
CreateSenderCall(call_config);
CreateSendConfig(num_streams);
test::FakeEncoder encoder(Clock::GetRealTimeClock());
send_config.encoder_settings.encoder = &encoder;
send_config.encoder_settings.payload_type = 125;
send_config.encoder_settings.payload_name = "FAKE";
std::vector<VideoStream> video_streams =
test::CreateVideoStreams(num_streams);
receiver_transport.SetReceiver(sender_call_->Receiver());
if (num_streams == 1) {
video_streams[0].target_bitrate_bps = 2000000;
video_streams[0].max_bitrate_bps = 2000000;
video_streams_[0].target_bitrate_bps = 2000000;
video_streams_[0].max_bitrate_bps = 2000000;
}
send_config.rtp.nack.rtp_history_ms = 1000;
send_config.rtp.ssrcs = ssrcs;
send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
send_config_.rtp.ssrcs = ssrcs;
if (rtx) {
send_config.rtp.rtx.payload_type = 96;
send_config.rtp.rtx.ssrcs = rtx_ssrcs;
send_config.rtp.rtx.pad_with_redundant_payloads = true;
send_config_.rtp.rtx.payload_type = kSendRtxPayloadType;
send_config_.rtp.rtx.ssrcs = rtx_ssrcs;
send_config_.rtp.rtx.pad_with_redundant_payloads = true;
}
send_config.rtp.extensions.push_back(
RtpExtension(RtpExtension::kTOffset,
kTransmissionTimeOffsetExtensionId));
send_config_.rtp.extensions.push_back(RtpExtension(
RtpExtension::kTOffset, kTransmissionTimeOffsetExtensionId));
if (num_streams == 1) {
// For single stream rampup until 1mbps
@ -480,32 +473,22 @@ class RampUpTest : public ::testing::Test {
// For multi stream rampup until all streams are being sent. That means
// enough birate to send all the target streams plus the min bitrate of
// the last one.
int expected_bitrate_bps = video_streams.back().min_bitrate_bps;
for (size_t i = 0; i < video_streams.size() - 1; ++i) {
expected_bitrate_bps += video_streams[i].target_bitrate_bps;
int expected_bitrate_bps = video_streams_.back().min_bitrate_bps;
for (size_t i = 0; i < video_streams_.size() - 1; ++i) {
expected_bitrate_bps += video_streams_[i].target_bitrate_bps;
}
stream_observer.set_expected_bitrate_bps(expected_bitrate_bps);
}
VideoSendStream* send_stream =
call->CreateVideoSendStream(send_config, video_streams, NULL);
CreateStreams();
CreateFrameGeneratorCapturer();
scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer(
test::FrameGeneratorCapturer::Create(send_stream->Input(),
video_streams.back().width,
video_streams.back().height,
video_streams.back().max_framerate,
Clock::GetRealTimeClock()));
send_stream->Start();
frame_generator_capturer->Start();
Start();
EXPECT_EQ(kEventSignaled, stream_observer.Wait());
frame_generator_capturer->Stop();
send_stream->Stop();
call->DestroyVideoSendStream(send_stream);
Stop();
DestroyStreams();
}
void RunRampUpDownUpTest(size_t number_of_streams, bool rtx) {
@ -520,59 +503,27 @@ class RampUpTest : public ::testing::Test {
webrtc::Config webrtc_config;
call_config.webrtc_config = &webrtc_config;
webrtc_config.Set<PaddingStrategy>(new PaddingStrategy(rtx));
scoped_ptr<Call> call(Call::Create(call_config));
VideoSendStream::Config send_config = call->GetDefaultSendConfig();
CreateSenderCall(call_config);
receiver_transport.SetReceiver(sender_call_->Receiver());
receiver_transport.SetReceiver(call->Receiver());
CreateSendConfig(number_of_streams);
test::FakeEncoder encoder(Clock::GetRealTimeClock());
send_config.encoder_settings.encoder = &encoder;
send_config.encoder_settings.payload_type = 125;
send_config.encoder_settings.payload_name = "FAKE";
std::vector<VideoStream> video_streams =
test::CreateVideoStreams(number_of_streams);
send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
send_config_.rtp.extensions.push_back(RtpExtension(
RtpExtension::kTOffset, kTransmissionTimeOffsetExtensionId));
send_config_.suspend_below_min_bitrate = true;
send_config.rtp.nack.rtp_history_ms = 1000;
send_config.rtp.ssrcs.insert(
send_config.rtp.ssrcs.begin(), ssrcs.begin(), ssrcs.end());
send_config.rtp.extensions.push_back(
RtpExtension(RtpExtension::kTOffset,
kTransmissionTimeOffsetExtensionId));
send_config.suspend_below_min_bitrate = true;
CreateStreams();
stream_observer.SetSendStream(send_stream_);
VideoSendStream* send_stream =
call->CreateVideoSendStream(send_config, video_streams, NULL);
stream_observer.SetSendStream(send_stream);
CreateFrameGeneratorCapturer();
size_t width = 0;
size_t height = 0;
for (size_t i = 0; i < video_streams.size(); ++i) {
size_t stream_width = video_streams[i].width;
size_t stream_height = video_streams[i].height;
if (stream_width > width)
width = stream_width;
if (stream_height > height)
height = stream_height;
}
scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer(
test::FrameGeneratorCapturer::Create(send_stream->Input(),
width,
height,
30,
Clock::GetRealTimeClock()));
send_stream->Start();
frame_generator_capturer->Start();
Start();
EXPECT_EQ(kEventSignaled, stream_observer.Wait());
stream_observer.StopSending();
receiver_transport.StopSending();
frame_generator_capturer->Stop();
send_stream->Stop();
call->DestroyVideoSendStream(send_stream);
Stop();
DestroyStreams();
}
private:
@ -583,8 +534,6 @@ class RampUpTest : public ::testing::Test {
ssrcs.push_back(static_cast<uint32_t>(ssrc_offset + i));
return ssrcs;
}
std::map<uint32_t, bool> reserved_ssrcs_;
};
TEST_F(RampUpTest, SingleStream) {

767
webrtc/video/video_send_stream_tests.cc
View File

File diff suppressed because it is too large Load Diff

2
webrtc/webrtc_tests.gypi
View File

@ -46,7 +46,7 @@
'type': '<(gtest_target_type)',
'sources': [
'video/bitrate_estimator_tests.cc',
'video/call_tests.cc',
'video/end_to_end_tests.cc',
'video/send_statistics_proxy_unittest.cc',
'video/video_send_stream_tests.cc',
'test/common_unittest.cc',