Replace EventWrapper in video/, test/ and call/.
Makes use of rtc::Event which is simpler and can be used without allocating additional objects on the heap. Does not modify test/channel_transport/. BUG= R=mflodman@webrtc.org Review URL: https://codereview.webrtc.org/1487893004 . Cr-Commit-Position: refs/heads/master@{#10968}
This commit is contained in:
Peter Boström
parent
0f2e939a92
commit
5811a39f14
@ -15,12 +15,12 @@
|
||||
|
||||
#include "webrtc/audio_state.h"
|
||||
#include "webrtc/base/checks.h"
|
||||
#include "webrtc/base/event.h"
|
||||
#include "webrtc/base/logging.h"
|
||||
#include "webrtc/base/scoped_ptr.h"
|
||||
#include "webrtc/base/thread_annotations.h"
|
||||
#include "webrtc/call.h"
|
||||
#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
|
||||
#include "webrtc/system_wrappers/include/event_wrapper.h"
|
||||
#include "webrtc/system_wrappers/include/trace.h"
|
||||
#include "webrtc/test/call_test.h"
|
||||
#include "webrtc/test/direct_transport.h"
|
||||
@ -44,12 +44,12 @@ class LogObserver {
|
||||
callback_.PushExpectedLogLine(expected_log_line);
|
||||
}
|
||||
|
||||
EventTypeWrapper Wait() { return callback_.Wait(); }
|
||||
bool Wait() { return callback_.Wait(); }
|
||||
|
||||
private:
|
||||
class Callback : public rtc::LogSink {
|
||||
public:
|
||||
Callback() : done_(EventWrapper::Create()) {}
|
||||
Callback() : done_(false, false) {}
|
||||
|
||||
void OnLogMessage(const std::string& message) override {
|
||||
rtc::CritScope lock(&crit_sect_);
|
||||
@ -72,15 +72,13 @@ class LogObserver {
|
||||
}
|
||||
if (expected_log_lines_.size() <= 0) {
|
||||
if (num_popped > 0) {
|
||||
done_->Set();
|
||||
done_.Set();
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
EventTypeWrapper Wait() {
|
||||
return done_->Wait(test::CallTest::kDefaultTimeoutMs);
|
||||
}
|
||||
bool Wait() { return done_.Wait(test::CallTest::kDefaultTimeoutMs); }
|
||||
|
||||
void PushExpectedLogLine(const std::string& expected_log_line) {
|
||||
rtc::CritScope lock(&crit_sect_);
|
||||
@ -92,7 +90,7 @@ class LogObserver {
|
||||
rtc::CriticalSection crit_sect_;
|
||||
Strings received_log_lines_ GUARDED_BY(crit_sect_);
|
||||
Strings expected_log_lines_ GUARDED_BY(crit_sect_);
|
||||
rtc::scoped_ptr<EventWrapper> done_;
|
||||
rtc::Event done_;
|
||||
};
|
||||
|
||||
Callback callback_;
|
||||
@ -271,7 +269,7 @@ TEST_F(BitrateEstimatorTest, InstantiatesTOFPerDefaultForVideo) {
|
||||
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
|
||||
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
|
||||
streams_.push_back(new Stream(this, false));
|
||||
EXPECT_EQ(kEventSignaled, receiver_log_.Wait());
|
||||
EXPECT_TRUE(receiver_log_.Wait());
|
||||
}
|
||||
|
||||
TEST_F(BitrateEstimatorTest, ImmediatelySwitchToASTForAudio) {
|
||||
@ -282,7 +280,7 @@ TEST_F(BitrateEstimatorTest, ImmediatelySwitchToASTForAudio) {
|
||||
receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE.");
|
||||
receiver_log_.PushExpectedLogLine(kAbsSendTimeLog);
|
||||
streams_.push_back(new Stream(this, true));
|
||||
EXPECT_EQ(kEventSignaled, receiver_log_.Wait());
|
||||
EXPECT_TRUE(receiver_log_.Wait());
|
||||
}
|
||||
|
||||
TEST_F(BitrateEstimatorTest, ImmediatelySwitchToASTForVideo) {
|
||||
@ -293,21 +291,21 @@ TEST_F(BitrateEstimatorTest, ImmediatelySwitchToASTForVideo) {
|
||||
receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE.");
|
||||
receiver_log_.PushExpectedLogLine(kAbsSendTimeLog);
|
||||
streams_.push_back(new Stream(this, false));
|
||||
EXPECT_EQ(kEventSignaled, receiver_log_.Wait());
|
||||
EXPECT_TRUE(receiver_log_.Wait());
|
||||
}
|
||||
|
||||
TEST_F(BitrateEstimatorTest, SwitchesToASTForAudio) {
|
||||
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
|
||||
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
|
||||
streams_.push_back(new Stream(this, true));
|
||||
EXPECT_EQ(kEventSignaled, receiver_log_.Wait());
|
||||
EXPECT_TRUE(receiver_log_.Wait());
|
||||
|
||||
send_config_.rtp.extensions.push_back(
|
||||
RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId));
|
||||
receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE.");
|
||||
receiver_log_.PushExpectedLogLine(kAbsSendTimeLog);
|
||||
streams_.push_back(new Stream(this, true));
|
||||
EXPECT_EQ(kEventSignaled, receiver_log_.Wait());
|
||||
EXPECT_TRUE(receiver_log_.Wait());
|
||||
}
|
||||
|
||||
TEST_F(BitrateEstimatorTest, SwitchesToASTForVideo) {
|
||||
@ -316,14 +314,14 @@ TEST_F(BitrateEstimatorTest, SwitchesToASTForVideo) {
|
||||
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
|
||||
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
|
||||
streams_.push_back(new Stream(this, false));
|
||||
EXPECT_EQ(kEventSignaled, receiver_log_.Wait());
|
||||
EXPECT_TRUE(receiver_log_.Wait());
|
||||
|
||||
send_config_.rtp.extensions[0] =
|
||||
RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId);
|
||||
receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE.");
|
||||
receiver_log_.PushExpectedLogLine(kAbsSendTimeLog);
|
||||
streams_.push_back(new Stream(this, false));
|
||||
EXPECT_EQ(kEventSignaled, receiver_log_.Wait());
|
||||
EXPECT_TRUE(receiver_log_.Wait());
|
||||
}
|
||||
|
||||
TEST_F(BitrateEstimatorTest, SwitchesToASTThenBackToTOFForVideo) {
|
||||
@ -332,14 +330,14 @@ TEST_F(BitrateEstimatorTest, SwitchesToASTThenBackToTOFForVideo) {
|
||||
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
|
||||
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
|
||||
streams_.push_back(new Stream(this, false));
|
||||
EXPECT_EQ(kEventSignaled, receiver_log_.Wait());
|
||||
EXPECT_TRUE(receiver_log_.Wait());
|
||||
|
||||
send_config_.rtp.extensions[0] =
|
||||
RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId);
|
||||
receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE.");
|
||||
receiver_log_.PushExpectedLogLine(kAbsSendTimeLog);
|
||||
streams_.push_back(new Stream(this, false));
|
||||
EXPECT_EQ(kEventSignaled, receiver_log_.Wait());
|
||||
EXPECT_TRUE(receiver_log_.Wait());
|
||||
|
||||
send_config_.rtp.extensions[0] =
|
||||
RtpExtension(RtpExtension::kTOffset, kTOFExtensionId);
|
||||
@ -349,6 +347,6 @@ TEST_F(BitrateEstimatorTest, SwitchesToASTThenBackToTOFForVideo) {
|
||||
streams_.push_back(new Stream(this, false));
|
||||
streams_[0]->StopSending();
|
||||
streams_[1]->StopSending();
|
||||
EXPECT_EQ(kEventSignaled, receiver_log_.Wait());
|
||||
EXPECT_TRUE(receiver_log_.Wait());
|
||||
}
|
||||
} // namespace webrtc
|
||||
|
||||
@ -174,7 +174,7 @@ class VideoRtcpAndSyncObserver : public SyncRtcpObserver, public VideoRenderer {
|
||||
false);
|
||||
}
|
||||
if (time_since_creation > kMinRunTimeMs)
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
}
|
||||
|
||||
@ -334,7 +334,7 @@ void CallPerfTest::TestAudioVideoSync(bool fec, bool create_audio_first) {
|
||||
EXPECT_EQ(0, voe_base->StartReceive(recv_channel_id));
|
||||
EXPECT_EQ(0, voe_base->StartSend(send_channel_id));
|
||||
|
||||
EXPECT_EQ(kEventSignaled, observer.Wait())
|
||||
EXPECT_TRUE(observer.Wait())
|
||||
<< "Timed out while waiting for audio and video to be synchronized.";
|
||||
|
||||
EXPECT_EQ(0, voe_base->StopSend(send_channel_id));
|
||||
@ -413,7 +413,7 @@ void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
|
||||
}
|
||||
|
||||
if (time_since_creation > run_time_ms_) {
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
|
||||
FrameCaptureTimeList::iterator iter =
|
||||
@ -473,9 +473,9 @@ void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for "
|
||||
"estimated capture NTP time to be "
|
||||
"within bounds.";
|
||||
EXPECT_TRUE(Wait()) << "Timed out while waiting for "
|
||||
"estimated capture NTP time to be "
|
||||
"within bounds.";
|
||||
}
|
||||
|
||||
rtc::CriticalSection crit_;
|
||||
@ -528,7 +528,7 @@ void CallPerfTest::TestCpuOveruse(LoadObserver::Load tested_load,
|
||||
|
||||
void OnLoadUpdate(Load load) override {
|
||||
if (load == tested_load_)
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
|
||||
void ModifyConfigs(VideoSendStream::Config* send_config,
|
||||
@ -539,8 +539,7 @@ void CallPerfTest::TestCpuOveruse(LoadObserver::Load tested_load,
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
<< "Timed out before receiving an overuse callback.";
|
||||
EXPECT_TRUE(Wait()) << "Timed out before receiving an overuse callback.";
|
||||
}
|
||||
|
||||
LoadObserver::Load tested_load_;
|
||||
@ -608,7 +607,7 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
|
||||
}
|
||||
if (num_bitrate_observations_in_range_ ==
|
||||
kNumBitrateObservationsInRange)
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
}
|
||||
return SEND_PACKET;
|
||||
@ -631,8 +630,7 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
<< "Timeout while waiting for send-bitrate stats.";
|
||||
EXPECT_TRUE(Wait()) << "Timeout while waiting for send-bitrate stats.";
|
||||
}
|
||||
|
||||
VideoSendStream* send_stream_;
|
||||
@ -660,7 +658,7 @@ TEST_F(CallPerfTest, KeepsHighBitrateWhenReconfiguringSender) {
|
||||
BitrateObserver()
|
||||
: EndToEndTest(kDefaultTimeoutMs),
|
||||
FakeEncoder(Clock::GetRealTimeClock()),
|
||||
time_to_reconfigure_(webrtc::EventWrapper::Create()),
|
||||
time_to_reconfigure_(false, false),
|
||||
encoder_inits_(0),
|
||||
last_set_bitrate_(0),
|
||||
send_stream_(nullptr) {}
|
||||
@ -679,7 +677,7 @@ TEST_F(CallPerfTest, KeepsHighBitrateWhenReconfiguringSender) {
|
||||
last_set_bitrate_,
|
||||
kPermittedReconfiguredBitrateDiffKbps)
|
||||
<< "Encoder reconfigured with bitrate too far away from last set.";
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);
|
||||
}
|
||||
@ -689,7 +687,7 @@ TEST_F(CallPerfTest, KeepsHighBitrateWhenReconfiguringSender) {
|
||||
last_set_bitrate_ = new_target_bitrate_kbps;
|
||||
if (encoder_inits_ == 1 &&
|
||||
new_target_bitrate_kbps > kReconfigureThresholdKbps) {
|
||||
time_to_reconfigure_->Set();
|
||||
time_to_reconfigure_.Set();
|
||||
}
|
||||
return FakeEncoder::SetRates(new_target_bitrate_kbps, framerate);
|
||||
}
|
||||
@ -718,18 +716,18 @@ TEST_F(CallPerfTest, KeepsHighBitrateWhenReconfiguringSender) {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
ASSERT_EQ(kEventSignaled, time_to_reconfigure_->Wait(kDefaultTimeoutMs))
|
||||
ASSERT_TRUE(time_to_reconfigure_.Wait(kDefaultTimeoutMs))
|
||||
<< "Timed out before receiving an initial high bitrate.";
|
||||
encoder_config_.streams[0].width *= 2;
|
||||
encoder_config_.streams[0].height *= 2;
|
||||
EXPECT_TRUE(send_stream_->ReconfigureVideoEncoder(encoder_config_));
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
EXPECT_TRUE(Wait())
|
||||
<< "Timed out while waiting for a couple of high bitrate estimates "
|
||||
"after reconfiguring the send stream.";
|
||||
}
|
||||
|
||||
private:
|
||||
rtc::scoped_ptr<webrtc::EventWrapper> time_to_reconfigure_;
|
||||
rtc::Event time_to_reconfigure_;
|
||||
int encoder_inits_;
|
||||
uint32_t last_set_bitrate_;
|
||||
VideoSendStream* send_stream_;
|
||||
|
||||
@ -173,8 +173,8 @@ void CallTest::DestroyStreams() {
|
||||
allocated_decoders_.clear();
|
||||
}
|
||||
|
||||
const unsigned int CallTest::kDefaultTimeoutMs = 30 * 1000;
|
||||
const unsigned int CallTest::kLongTimeoutMs = 120 * 1000;
|
||||
const int CallTest::kDefaultTimeoutMs = 30 * 1000;
|
||||
const int CallTest::kLongTimeoutMs = 120 * 1000;
|
||||
const uint8_t CallTest::kSendPayloadType = 100;
|
||||
const uint8_t CallTest::kFakeSendPayloadType = 125;
|
||||
const uint8_t CallTest::kSendRtxPayloadType = 98;
|
||||
|
||||
@ -31,8 +31,8 @@ class CallTest : public ::testing::Test {
|
||||
|
||||
static const size_t kNumSsrcs = 3;
|
||||
|
||||
static const unsigned int kDefaultTimeoutMs;
|
||||
static const unsigned int kLongTimeoutMs;
|
||||
static const int kDefaultTimeoutMs;
|
||||
static const int kLongTimeoutMs;
|
||||
static const uint8_t kSendPayloadType;
|
||||
static const uint8_t kSendRtxPayloadType;
|
||||
static const uint8_t kFakeSendPayloadType;
|
||||
|
||||
@ -23,7 +23,7 @@ DirectTransport::DirectTransport(Call* send_call)
|
||||
DirectTransport::DirectTransport(const FakeNetworkPipe::Config& config,
|
||||
Call* send_call)
|
||||
: send_call_(send_call),
|
||||
packet_event_(EventWrapper::Create()),
|
||||
packet_event_(false, false),
|
||||
thread_(NetworkProcess, this, "NetworkProcess"),
|
||||
clock_(Clock::GetRealTimeClock()),
|
||||
shutting_down_(false),
|
||||
@ -43,7 +43,7 @@ void DirectTransport::StopSending() {
|
||||
shutting_down_ = true;
|
||||
}
|
||||
|
||||
packet_event_->Set();
|
||||
packet_event_.Set();
|
||||
thread_.Stop();
|
||||
}
|
||||
|
||||
@ -60,13 +60,13 @@ bool DirectTransport::SendRtp(const uint8_t* data,
|
||||
send_call_->OnSentPacket(sent_packet);
|
||||
}
|
||||
fake_network_.SendPacket(data, length);
|
||||
packet_event_->Set();
|
||||
packet_event_.Set();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool DirectTransport::SendRtcp(const uint8_t* data, size_t length) {
|
||||
fake_network_.SendPacket(data, length);
|
||||
packet_event_->Set();
|
||||
packet_event_.Set();
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -78,15 +78,7 @@ bool DirectTransport::SendPackets() {
|
||||
fake_network_.Process();
|
||||
int64_t wait_time_ms = fake_network_.TimeUntilNextProcess();
|
||||
if (wait_time_ms > 0) {
|
||||
switch (packet_event_->Wait(static_cast<unsigned long>(wait_time_ms))) {
|
||||
case kEventSignaled:
|
||||
break;
|
||||
case kEventTimeout:
|
||||
break;
|
||||
case kEventError:
|
||||
// TODO(pbos): Log a warning here?
|
||||
return true;
|
||||
}
|
||||
packet_event_.Wait(static_cast<int>(wait_time_ms));
|
||||
}
|
||||
rtc::CritScope crit(&lock_);
|
||||
return shutting_down_ ? false : true;
|
||||
|
||||
@ -15,9 +15,9 @@
|
||||
#include <deque>
|
||||
|
||||
#include "webrtc/base/criticalsection.h"
|
||||
#include "webrtc/base/event.h"
|
||||
#include "webrtc/base/platform_thread.h"
|
||||
#include "webrtc/base/scoped_ptr.h"
|
||||
#include "webrtc/system_wrappers/include/event_wrapper.h"
|
||||
#include "webrtc/test/fake_network_pipe.h"
|
||||
#include "webrtc/transport.h"
|
||||
|
||||
@ -52,7 +52,7 @@ class DirectTransport : public Transport {
|
||||
|
||||
rtc::CriticalSection lock_;
|
||||
Call* const send_call_;
|
||||
rtc::scoped_ptr<EventWrapper> packet_event_;
|
||||
rtc::Event packet_event_;
|
||||
rtc::PlatformThread thread_;
|
||||
Clock* const clock_;
|
||||
|
||||
|
||||
@ -16,7 +16,6 @@
|
||||
#include "webrtc/base/constructormagic.h"
|
||||
#include "webrtc/base/criticalsection.h"
|
||||
#include "webrtc/base/scoped_ptr.h"
|
||||
#include "webrtc/system_wrappers/include/event_wrapper.h"
|
||||
#include "webrtc/typedefs.h"
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
@ -16,6 +16,7 @@
|
||||
#include "testing/gtest/include/gtest/gtest.h"
|
||||
|
||||
#include "webrtc/base/criticalsection.h"
|
||||
#include "webrtc/base/event.h"
|
||||
#include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
|
||||
#include "webrtc/test/constants.h"
|
||||
#include "webrtc/test/direct_transport.h"
|
||||
@ -36,10 +37,7 @@ class RtpRtcpObserver {
|
||||
|
||||
virtual ~RtpRtcpObserver() {}
|
||||
|
||||
virtual EventTypeWrapper Wait() {
|
||||
EventTypeWrapper result = observation_complete_->Wait(timeout_ms_);
|
||||
return result;
|
||||
}
|
||||
virtual bool Wait() { return observation_complete_.Wait(timeout_ms_); }
|
||||
|
||||
virtual Action OnSendRtp(const uint8_t* packet, size_t length) {
|
||||
return SEND_PACKET;
|
||||
@ -58,8 +56,8 @@ class RtpRtcpObserver {
|
||||
}
|
||||
|
||||
protected:
|
||||
explicit RtpRtcpObserver(unsigned int event_timeout_ms)
|
||||
: observation_complete_(EventWrapper::Create()),
|
||||
explicit RtpRtcpObserver(int event_timeout_ms)
|
||||
: observation_complete_(false, false),
|
||||
parser_(RtpHeaderParser::Create()),
|
||||
timeout_ms_(event_timeout_ms) {
|
||||
parser_->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
|
||||
@ -70,11 +68,11 @@ class RtpRtcpObserver {
|
||||
kTransportSequenceNumberExtensionId);
|
||||
}
|
||||
|
||||
const rtc::scoped_ptr<EventWrapper> observation_complete_;
|
||||
rtc::Event observation_complete_;
|
||||
const rtc::scoped_ptr<RtpHeaderParser> parser_;
|
||||
|
||||
private:
|
||||
unsigned int timeout_ms_;
|
||||
const int timeout_ms_;
|
||||
};
|
||||
|
||||
class PacketTransport : public test::DirectTransport {
|
||||
|
||||
@ -26,7 +26,6 @@
|
||||
#include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h"
|
||||
#include "webrtc/modules/video_coding/include/video_coding_defines.h"
|
||||
#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
|
||||
#include "webrtc/system_wrappers/include/event_wrapper.h"
|
||||
#include "webrtc/system_wrappers/include/metrics.h"
|
||||
#include "webrtc/system_wrappers/include/sleep.h"
|
||||
#include "webrtc/test/call_test.h"
|
||||
@ -48,7 +47,7 @@
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
static const uint32_t kSilenceTimeoutMs = 2000;
|
||||
static const int kSilenceTimeoutMs = 2000;
|
||||
|
||||
class EndToEndTest : public test::CallTest {
|
||||
public:
|
||||
@ -124,33 +123,33 @@ TEST_F(EndToEndTest, RendersSingleDelayedFrame) {
|
||||
|
||||
class Renderer : public VideoRenderer {
|
||||
public:
|
||||
Renderer() : event_(EventWrapper::Create()) {}
|
||||
Renderer() : event_(false, false) {}
|
||||
|
||||
void RenderFrame(const VideoFrame& video_frame,
|
||||
int /*time_to_render_ms*/) override {
|
||||
event_->Set();
|
||||
event_.Set();
|
||||
}
|
||||
|
||||
bool IsTextureSupported() const override { return false; }
|
||||
|
||||
EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
|
||||
bool Wait() { return event_.Wait(kDefaultTimeoutMs); }
|
||||
|
||||
rtc::scoped_ptr<EventWrapper> event_;
|
||||
rtc::Event event_;
|
||||
} renderer;
|
||||
|
||||
class TestFrameCallback : public I420FrameCallback {
|
||||
public:
|
||||
TestFrameCallback() : event_(EventWrapper::Create()) {}
|
||||
TestFrameCallback() : event_(false, false) {}
|
||||
|
||||
EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
|
||||
bool Wait() { return event_.Wait(kDefaultTimeoutMs); }
|
||||
|
||||
private:
|
||||
void FrameCallback(VideoFrame* frame) override {
|
||||
SleepMs(kDelayRenderCallbackMs);
|
||||
event_->Set();
|
||||
event_.Set();
|
||||
}
|
||||
|
||||
rtc::scoped_ptr<EventWrapper> event_;
|
||||
rtc::Event event_;
|
||||
};
|
||||
|
||||
CreateCalls(Call::Config(), Call::Config());
|
||||
@ -175,9 +174,9 @@ TEST_F(EndToEndTest, RendersSingleDelayedFrame) {
|
||||
rtc::scoped_ptr<test::FrameGenerator> frame_generator(
|
||||
test::FrameGenerator::CreateChromaGenerator(kWidth, kHeight));
|
||||
send_stream_->Input()->IncomingCapturedFrame(*frame_generator->NextFrame());
|
||||
EXPECT_EQ(kEventSignaled, pre_render_callback.Wait())
|
||||
EXPECT_TRUE(pre_render_callback.Wait())
|
||||
<< "Timed out while waiting for pre-render callback.";
|
||||
EXPECT_EQ(kEventSignaled, renderer.Wait())
|
||||
EXPECT_TRUE(renderer.Wait())
|
||||
<< "Timed out while waiting for the frame to render.";
|
||||
|
||||
Stop();
|
||||
@ -191,17 +190,17 @@ TEST_F(EndToEndTest, RendersSingleDelayedFrame) {
|
||||
TEST_F(EndToEndTest, TransmitsFirstFrame) {
|
||||
class Renderer : public VideoRenderer {
|
||||
public:
|
||||
Renderer() : event_(EventWrapper::Create()) {}
|
||||
Renderer() : event_(false, false) {}
|
||||
|
||||
void RenderFrame(const VideoFrame& video_frame,
|
||||
int /*time_to_render_ms*/) override {
|
||||
event_->Set();
|
||||
event_.Set();
|
||||
}
|
||||
bool IsTextureSupported() const override { return false; }
|
||||
|
||||
EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
|
||||
bool Wait() { return event_.Wait(kDefaultTimeoutMs); }
|
||||
|
||||
rtc::scoped_ptr<EventWrapper> event_;
|
||||
rtc::Event event_;
|
||||
} renderer;
|
||||
|
||||
CreateCalls(Call::Config(), Call::Config());
|
||||
@ -223,7 +222,7 @@ TEST_F(EndToEndTest, TransmitsFirstFrame) {
|
||||
encoder_config_.streams[0].width, encoder_config_.streams[0].height));
|
||||
send_stream_->Input()->IncomingCapturedFrame(*frame_generator->NextFrame());
|
||||
|
||||
EXPECT_EQ(kEventSignaled, renderer.Wait())
|
||||
EXPECT_TRUE(renderer.Wait())
|
||||
<< "Timed out while waiting for the frame to render.";
|
||||
|
||||
Stop();
|
||||
@ -244,7 +243,7 @@ TEST_F(EndToEndTest, SendsAndReceivesVP9) {
|
||||
frame_counter_(0) {}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
EXPECT_TRUE(Wait())
|
||||
<< "Timed out while waiting for enough frames to be decoded.";
|
||||
}
|
||||
|
||||
@ -271,7 +270,7 @@ TEST_F(EndToEndTest, SendsAndReceivesVP9) {
|
||||
int time_to_render_ms) override {
|
||||
const int kRequiredFrames = 500;
|
||||
if (++frame_counter_ == kRequiredFrames)
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
|
||||
bool IsTextureSupported() const override { return false; }
|
||||
@ -294,7 +293,7 @@ TEST_F(EndToEndTest, SendsAndReceivesH264) {
|
||||
frame_counter_(0) {}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
EXPECT_TRUE(Wait())
|
||||
<< "Timed out while waiting for enough frames to be decoded.";
|
||||
}
|
||||
|
||||
@ -323,7 +322,7 @@ TEST_F(EndToEndTest, SendsAndReceivesH264) {
|
||||
int time_to_render_ms) override {
|
||||
const int kRequiredFrames = 500;
|
||||
if (++frame_counter_ == kRequiredFrames)
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
|
||||
bool IsTextureSupported() const override { return false; }
|
||||
@ -351,13 +350,13 @@ TEST_F(EndToEndTest, ReceiverUsesLocalSsrc) {
|
||||
ssrc |= static_cast<uint32_t>(packet[6]) << 8;
|
||||
ssrc |= static_cast<uint32_t>(packet[7]) << 0;
|
||||
EXPECT_EQ(kReceiverLocalSsrc, ssrc);
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
|
||||
return SEND_PACKET;
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
EXPECT_TRUE(Wait())
|
||||
<< "Timed out while waiting for a receiver RTCP packet to be sent.";
|
||||
}
|
||||
} test;
|
||||
@ -389,7 +388,7 @@ TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) {
|
||||
retransmitted_packets_.insert(header.sequenceNumber);
|
||||
if (nacks_left_ <= 0 &&
|
||||
retransmitted_packets_.size() == dropped_packets_.size()) {
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
return SEND_PACKET;
|
||||
}
|
||||
@ -438,7 +437,7 @@ TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
EXPECT_TRUE(Wait())
|
||||
<< "Timed out waiting for packets to be NACKed, retransmitted and "
|
||||
"rendered.";
|
||||
}
|
||||
@ -515,7 +514,7 @@ TEST_F(EndToEndTest, CanReceiveFec) {
|
||||
// Rendering frame with timestamp of packet that was dropped -> FEC
|
||||
// protection worked.
|
||||
if (protected_timestamps_.count(video_frame.timestamp()) != 0)
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
|
||||
bool IsTextureSupported() const override { return false; }
|
||||
@ -542,7 +541,7 @@ TEST_F(EndToEndTest, CanReceiveFec) {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
EXPECT_TRUE(Wait())
|
||||
<< "Timed out waiting for dropped frames frames to be rendered.";
|
||||
}
|
||||
|
||||
@ -627,7 +626,7 @@ TEST_F(EndToEndTest, DISABLED_ReceivedFecPacketsNotNacked) {
|
||||
IsNewerSequenceNumber(nacks.back(), fec_sequence_number_)) {
|
||||
EXPECT_TRUE(std::find(
|
||||
nacks.begin(), nacks.end(), fec_sequence_number_) == nacks.end());
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
}
|
||||
return SEND_PACKET;
|
||||
@ -655,7 +654,7 @@ TEST_F(EndToEndTest, DISABLED_ReceivedFecPacketsNotNacked) {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
EXPECT_TRUE(Wait())
|
||||
<< "Timed out while waiting for FEC packets to be received.";
|
||||
}
|
||||
|
||||
@ -737,7 +736,7 @@ void EndToEndTest::DecodesRetransmittedFrame(bool use_rtx, bool use_red) {
|
||||
rtc::CritScope lock(&crit_);
|
||||
if (frame->timestamp() == retransmitted_timestamp_) {
|
||||
EXPECT_TRUE(frame_retransmitted_);
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
}
|
||||
|
||||
@ -766,7 +765,7 @@ void EndToEndTest::DecodesRetransmittedFrame(bool use_rtx, bool use_red) {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
EXPECT_TRUE(Wait())
|
||||
<< "Timed out while waiting for retransmission to render.";
|
||||
}
|
||||
|
||||
@ -810,30 +809,30 @@ TEST_F(EndToEndTest, UsesFrameCallbacks) {
|
||||
|
||||
class Renderer : public VideoRenderer {
|
||||
public:
|
||||
Renderer() : event_(EventWrapper::Create()) {}
|
||||
Renderer() : event_(false, false) {}
|
||||
|
||||
void RenderFrame(const VideoFrame& video_frame,
|
||||
int /*time_to_render_ms*/) override {
|
||||
EXPECT_EQ(0, *video_frame.buffer(kYPlane))
|
||||
<< "Rendered frame should have zero luma which is applied by the "
|
||||
"pre-render callback.";
|
||||
event_->Set();
|
||||
event_.Set();
|
||||
}
|
||||
|
||||
bool IsTextureSupported() const override { return false; }
|
||||
|
||||
EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
|
||||
rtc::scoped_ptr<EventWrapper> event_;
|
||||
bool Wait() { return event_.Wait(kDefaultTimeoutMs); }
|
||||
rtc::Event event_;
|
||||
} renderer;
|
||||
|
||||
class TestFrameCallback : public I420FrameCallback {
|
||||
public:
|
||||
TestFrameCallback(int expected_luma_byte, int next_luma_byte)
|
||||
: event_(EventWrapper::Create()),
|
||||
: event_(false, false),
|
||||
expected_luma_byte_(expected_luma_byte),
|
||||
next_luma_byte_(next_luma_byte) {}
|
||||
|
||||
EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
|
||||
bool Wait() { return event_.Wait(kDefaultTimeoutMs); }
|
||||
|
||||
private:
|
||||
virtual void FrameCallback(VideoFrame* frame) {
|
||||
@ -851,10 +850,10 @@ TEST_F(EndToEndTest, UsesFrameCallbacks) {
|
||||
next_luma_byte_,
|
||||
frame->allocated_size(kYPlane));
|
||||
|
||||
event_->Set();
|
||||
event_.Set();
|
||||
}
|
||||
|
||||
rtc::scoped_ptr<EventWrapper> event_;
|
||||
rtc::Event event_;
|
||||
int expected_luma_byte_;
|
||||
int next_luma_byte_;
|
||||
};
|
||||
@ -892,11 +891,11 @@ TEST_F(EndToEndTest, UsesFrameCallbacks) {
|
||||
test::FrameGenerator::CreateChromaGenerator(kWidth / 2, kHeight / 2));
|
||||
send_stream_->Input()->IncomingCapturedFrame(*frame_generator->NextFrame());
|
||||
|
||||
EXPECT_EQ(kEventSignaled, pre_encode_callback.Wait())
|
||||
EXPECT_TRUE(pre_encode_callback.Wait())
|
||||
<< "Timed out while waiting for pre-encode callback.";
|
||||
EXPECT_EQ(kEventSignaled, pre_render_callback.Wait())
|
||||
EXPECT_TRUE(pre_render_callback.Wait())
|
||||
<< "Timed out while waiting for pre-render callback.";
|
||||
EXPECT_EQ(kEventSignaled, renderer.Wait())
|
||||
EXPECT_TRUE(renderer.Wait())
|
||||
<< "Timed out while waiting for the frame to render.";
|
||||
|
||||
Stop();
|
||||
@ -963,7 +962,7 @@ void EndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) {
|
||||
rtc::CritScope lock(&crit_);
|
||||
if (received_pli_ &&
|
||||
video_frame.timestamp() > highest_dropped_timestamp_) {
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
if (!received_pli_)
|
||||
frames_to_drop_ = kPacketsToDrop;
|
||||
@ -980,9 +979,9 @@ void EndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait()) << "Timed out waiting for PLI to be "
|
||||
"received and a frame to be "
|
||||
"rendered afterwards.";
|
||||
EXPECT_TRUE(Wait()) << "Timed out waiting for PLI to be "
|
||||
"received and a frame to be "
|
||||
"rendered afterwards.";
|
||||
}
|
||||
|
||||
rtc::CriticalSection crit_;
|
||||
@ -1008,11 +1007,9 @@ TEST_F(EndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
|
||||
class PacketInputObserver : public PacketReceiver {
|
||||
public:
|
||||
explicit PacketInputObserver(PacketReceiver* receiver)
|
||||
: receiver_(receiver), delivered_packet_(EventWrapper::Create()) {}
|
||||
: receiver_(receiver), delivered_packet_(false, false) {}
|
||||
|
||||
EventTypeWrapper Wait() {
|
||||
return delivered_packet_->Wait(kDefaultTimeoutMs);
|
||||
}
|
||||
bool Wait() { return delivered_packet_.Wait(kDefaultTimeoutMs); }
|
||||
|
||||
private:
|
||||
DeliveryStatus DeliverPacket(MediaType media_type,
|
||||
@ -1026,13 +1023,13 @@ TEST_F(EndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
|
||||
DeliveryStatus delivery_status =
|
||||
receiver_->DeliverPacket(media_type, packet, length, packet_time);
|
||||
EXPECT_EQ(DELIVERY_UNKNOWN_SSRC, delivery_status);
|
||||
delivered_packet_->Set();
|
||||
delivered_packet_.Set();
|
||||
return delivery_status;
|
||||
}
|
||||
}
|
||||
|
||||
PacketReceiver* receiver_;
|
||||
rtc::scoped_ptr<EventWrapper> delivered_packet_;
|
||||
rtc::Event delivered_packet_;
|
||||
};
|
||||
|
||||
CreateCalls(Call::Config(), Call::Config());
|
||||
@ -1054,7 +1051,7 @@ TEST_F(EndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
|
||||
receive_streams_.clear();
|
||||
|
||||
// Wait() waits for a received packet.
|
||||
EXPECT_EQ(kEventSignaled, input_observer.Wait());
|
||||
EXPECT_TRUE(input_observer.Wait());
|
||||
|
||||
Stop();
|
||||
|
||||
@ -1103,16 +1100,16 @@ void EndToEndTest::RespectsRtcpMode(RtcpMode rtcp_mode) {
|
||||
if (!has_report_block) {
|
||||
ADD_FAILURE() << "Received RTCP packet without receiver report for "
|
||||
"RtcpMode::kCompound.";
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
|
||||
if (sent_rtcp_ >= kNumCompoundRtcpPacketsToObserve)
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
|
||||
break;
|
||||
case RtcpMode::kReducedSize:
|
||||
if (!has_report_block)
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
break;
|
||||
case RtcpMode::kOff:
|
||||
RTC_NOTREACHED();
|
||||
@ -1131,7 +1128,7 @@ void EndToEndTest::RespectsRtcpMode(RtcpMode rtcp_mode) {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
EXPECT_TRUE(Wait())
|
||||
<< (rtcp_mode_ == RtcpMode::kCompound
|
||||
? "Timed out before observing enough compound packets."
|
||||
: "Timed out before receiving a non-compound RTCP packet.");
|
||||
@ -1282,27 +1279,27 @@ TEST_F(EndToEndTest, SendsAndReceivesMultipleStreams) {
|
||||
: settings_(settings),
|
||||
ssrc_(ssrc),
|
||||
frame_generator_(frame_generator),
|
||||
done_(EventWrapper::Create()) {}
|
||||
done_(false, false) {}
|
||||
|
||||
void RenderFrame(const VideoFrame& video_frame,
|
||||
int time_to_render_ms) override {
|
||||
EXPECT_EQ(settings_.width, video_frame.width());
|
||||
EXPECT_EQ(settings_.height, video_frame.height());
|
||||
(*frame_generator_)->Stop();
|
||||
done_->Set();
|
||||
done_.Set();
|
||||
}
|
||||
|
||||
uint32_t Ssrc() { return ssrc_; }
|
||||
|
||||
bool IsTextureSupported() const override { return false; }
|
||||
|
||||
EventTypeWrapper Wait() { return done_->Wait(kDefaultTimeoutMs); }
|
||||
bool Wait() { return done_.Wait(kDefaultTimeoutMs); }
|
||||
|
||||
private:
|
||||
const MultiStreamTest::CodecSettings& settings_;
|
||||
const uint32_t ssrc_;
|
||||
test::FrameGeneratorCapturer** const frame_generator_;
|
||||
rtc::scoped_ptr<EventWrapper> done_;
|
||||
rtc::Event done_;
|
||||
};
|
||||
|
||||
class Tester : public MultiStreamTest {
|
||||
@ -1313,8 +1310,8 @@ TEST_F(EndToEndTest, SendsAndReceivesMultipleStreams) {
|
||||
protected:
|
||||
void Wait() override {
|
||||
for (const auto& observer : observers_) {
|
||||
EXPECT_EQ(EventTypeWrapper::kEventSignaled, observer->Wait())
|
||||
<< "Time out waiting for from on ssrc " << observer->Ssrc();
|
||||
EXPECT_TRUE(observer->Wait()) << "Time out waiting for from on ssrc "
|
||||
<< observer->Ssrc();
|
||||
}
|
||||
}
|
||||
|
||||
@ -1350,7 +1347,7 @@ TEST_F(EndToEndTest, AssignsTransportSequenceNumbers) {
|
||||
const uint32_t& first_media_ssrc,
|
||||
const std::map<uint32_t, uint32_t>& ssrc_map)
|
||||
: DirectTransport(sender_call),
|
||||
done_(EventWrapper::Create()),
|
||||
done_(false, false),
|
||||
parser_(RtpHeaderParser::Create()),
|
||||
first_media_ssrc_(first_media_ssrc),
|
||||
rtx_to_media_ssrcs_(ssrc_map),
|
||||
@ -1419,7 +1416,7 @@ TEST_F(EndToEndTest, AssignsTransportSequenceNumbers) {
|
||||
}
|
||||
|
||||
if (IsDone())
|
||||
done_->Set();
|
||||
done_.Set();
|
||||
|
||||
if (drop_packet)
|
||||
return true;
|
||||
@ -1441,18 +1438,18 @@ TEST_F(EndToEndTest, AssignsTransportSequenceNumbers) {
|
||||
return seqno_range == received_packed_ids_.size();
|
||||
}
|
||||
|
||||
EventTypeWrapper Wait() {
|
||||
bool Wait() {
|
||||
{
|
||||
// Can't be sure until this point that rtx_to_media_ssrcs_ etc have
|
||||
// been initialized and are OK to read.
|
||||
rtc::CritScope cs(&lock_);
|
||||
started_ = true;
|
||||
}
|
||||
return done_->Wait(kDefaultTimeoutMs);
|
||||
return done_.Wait(kDefaultTimeoutMs);
|
||||
}
|
||||
|
||||
rtc::CriticalSection lock_;
|
||||
rtc::scoped_ptr<EventWrapper> done_;
|
||||
rtc::Event done_;
|
||||
rtc::scoped_ptr<RtpHeaderParser> parser_;
|
||||
SequenceNumberUnwrapper unwrapper_;
|
||||
std::set<int64_t> received_packed_ids_;
|
||||
@ -1475,7 +1472,7 @@ TEST_F(EndToEndTest, AssignsTransportSequenceNumbers) {
|
||||
protected:
|
||||
void Wait() override {
|
||||
RTC_DCHECK(observer_ != nullptr);
|
||||
EXPECT_EQ(EventTypeWrapper::kEventSignaled, observer_->Wait());
|
||||
EXPECT_TRUE(observer_->Wait());
|
||||
}
|
||||
|
||||
void UpdateSendConfig(
|
||||
@ -1612,9 +1609,7 @@ TEST_F(EndToEndTest, ObserversEncodedFrames) {
|
||||
class EncodedFrameTestObserver : public EncodedFrameObserver {
|
||||
public:
|
||||
EncodedFrameTestObserver()
|
||||
: length_(0),
|
||||
frame_type_(kEmptyFrame),
|
||||
called_(EventWrapper::Create()) {}
|
||||
: length_(0), frame_type_(kEmptyFrame), called_(false, false) {}
|
||||
virtual ~EncodedFrameTestObserver() {}
|
||||
|
||||
virtual void EncodedFrameCallback(const EncodedFrame& encoded_frame) {
|
||||
@ -1622,10 +1617,10 @@ TEST_F(EndToEndTest, ObserversEncodedFrames) {
|
||||
length_ = encoded_frame.length_;
|
||||
buffer_.reset(new uint8_t[length_]);
|
||||
memcpy(buffer_.get(), encoded_frame.data_, length_);
|
||||
called_->Set();
|
||||
called_.Set();
|
||||
}
|
||||
|
||||
EventTypeWrapper Wait() { return called_->Wait(kDefaultTimeoutMs); }
|
||||
bool Wait() { return called_.Wait(kDefaultTimeoutMs); }
|
||||
|
||||
void ExpectEqualFrames(const EncodedFrameTestObserver& observer) {
|
||||
ASSERT_EQ(length_, observer.length_)
|
||||
@ -1640,7 +1635,7 @@ TEST_F(EndToEndTest, ObserversEncodedFrames) {
|
||||
rtc::scoped_ptr<uint8_t[]> buffer_;
|
||||
size_t length_;
|
||||
FrameType frame_type_;
|
||||
rtc::scoped_ptr<EventWrapper> called_;
|
||||
rtc::Event called_;
|
||||
};
|
||||
|
||||
EncodedFrameTestObserver post_encode_observer;
|
||||
@ -1666,10 +1661,10 @@ TEST_F(EndToEndTest, ObserversEncodedFrames) {
|
||||
encoder_config_.streams[0].width, encoder_config_.streams[0].height));
|
||||
send_stream_->Input()->IncomingCapturedFrame(*frame_generator->NextFrame());
|
||||
|
||||
EXPECT_EQ(kEventSignaled, post_encode_observer.Wait())
|
||||
EXPECT_TRUE(post_encode_observer.Wait())
|
||||
<< "Timed out while waiting for send-side encoded-frame callback.";
|
||||
|
||||
EXPECT_EQ(kEventSignaled, pre_decode_observer.Wait())
|
||||
EXPECT_TRUE(pre_decode_observer.Wait())
|
||||
<< "Timed out while waiting for pre-decode encoded-frame callback.";
|
||||
|
||||
post_encode_observer.ExpectEqualFrames(pre_decode_observer);
|
||||
@ -1709,13 +1704,13 @@ TEST_F(EndToEndTest, ReceiveStreamSendsRemb) {
|
||||
packet_type = parser.Iterate();
|
||||
}
|
||||
if (received_psfb && received_remb)
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
return SEND_PACKET;
|
||||
}
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for a "
|
||||
"receiver RTCP REMB packet to be "
|
||||
"sent.";
|
||||
EXPECT_TRUE(Wait()) << "Timed out while waiting for a "
|
||||
"receiver RTCP REMB packet to be "
|
||||
"sent.";
|
||||
}
|
||||
} test;
|
||||
|
||||
@ -1738,7 +1733,7 @@ TEST_F(EndToEndTest, VerifyBandwidthStats) {
|
||||
has_seen_pacer_delay_ = sender_stats.pacer_delay_ms > 0;
|
||||
if (sender_stats.send_bandwidth_bps > 0 &&
|
||||
receiver_stats.recv_bandwidth_bps > 0 && has_seen_pacer_delay_) {
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
return SEND_PACKET;
|
||||
}
|
||||
@ -1749,8 +1744,8 @@ TEST_F(EndToEndTest, VerifyBandwidthStats) {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for "
|
||||
"non-zero bandwidth stats.";
|
||||
EXPECT_TRUE(Wait()) << "Timed out while waiting for "
|
||||
"non-zero bandwidth stats.";
|
||||
}
|
||||
|
||||
private:
|
||||
@ -1820,7 +1815,7 @@ TEST_F(EndToEndTest, VerifyNackStats) {
|
||||
if (send_stream_nack_packets >= 1 && receive_stream_nack_packets >= 1) {
|
||||
// NACK packet sent on receive stream and received on sent stream.
|
||||
if (MinMetricRunTimePassed())
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
}
|
||||
|
||||
@ -1849,8 +1844,7 @@ TEST_F(EndToEndTest, VerifyNackStats) {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
<< "Timed out waiting for packet to be NACKed.";
|
||||
EXPECT_TRUE(Wait()) << "Timed out waiting for packet to be NACKed.";
|
||||
}
|
||||
|
||||
rtc::CriticalSection crit_;
|
||||
@ -1892,7 +1886,7 @@ void EndToEndTest::VerifyHistogramStats(bool use_rtx,
|
||||
private:
|
||||
Action OnSendRtp(const uint8_t* packet, size_t length) override {
|
||||
if (MinMetricRunTimePassed())
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
|
||||
// GetStats calls GetSendChannelRtcpStatistics
|
||||
// (via VideoSendStream::GetRtt) which updates ReportBlockStats used by
|
||||
@ -1946,8 +1940,7 @@ void EndToEndTest::VerifyHistogramStats(bool use_rtx,
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
<< "Timed out waiting for packet to be NACKed.";
|
||||
EXPECT_TRUE(Wait()) << "Timed out waiting for packet to be NACKed.";
|
||||
}
|
||||
|
||||
const bool use_rtx_;
|
||||
@ -2154,7 +2147,7 @@ void EndToEndTest::TestXrReceiverReferenceTimeReport(bool enable_rrtr) {
|
||||
EXPECT_EQ(0, sent_rtcp_rrtr_);
|
||||
EXPECT_EQ(0, sent_rtcp_dlrr_);
|
||||
}
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
return SEND_PACKET;
|
||||
}
|
||||
@ -2168,7 +2161,7 @@ void EndToEndTest::TestXrReceiverReferenceTimeReport(bool enable_rrtr) {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
EXPECT_TRUE(Wait())
|
||||
<< "Timed out while waiting for RTCP SR/RR packets to be sent.";
|
||||
}
|
||||
|
||||
@ -2209,19 +2202,19 @@ void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
|
||||
<< "Received unknown SSRC: " << header.ssrc;
|
||||
|
||||
if (!valid_ssrcs_[header.ssrc])
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
|
||||
if (!is_observed_[header.ssrc]) {
|
||||
is_observed_[header.ssrc] = true;
|
||||
--ssrcs_to_observe_;
|
||||
if (expect_single_ssrc_) {
|
||||
expect_single_ssrc_ = false;
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
}
|
||||
|
||||
if (ssrcs_to_observe_ == 0)
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
|
||||
return SEND_PACKET;
|
||||
}
|
||||
@ -2252,15 +2245,14 @@ void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
<< "Timed out while waiting for "
|
||||
<< (send_single_ssrc_first_ ? "first SSRC." : "SSRCs.");
|
||||
EXPECT_TRUE(Wait()) << "Timed out while waiting for "
|
||||
<< (send_single_ssrc_first_ ? "first SSRC."
|
||||
: "SSRCs.");
|
||||
|
||||
if (send_single_ssrc_first_) {
|
||||
// Set full simulcast and continue with the rest of the SSRCs.
|
||||
send_stream_->ReconfigureVideoEncoder(encoder_config_all_streams_);
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
<< "Timed out while waiting on additional SSRCs.";
|
||||
EXPECT_TRUE(Wait()) << "Timed out while waiting on additional SSRCs.";
|
||||
}
|
||||
}
|
||||
|
||||
@ -2309,15 +2301,15 @@ TEST_F(EndToEndTest, ReportsSetEncoderRates) {
|
||||
return 0;
|
||||
rtc::CritScope lock(&crit_);
|
||||
bitrate_kbps_ = new_target_bitrate;
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
return 0;
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
ASSERT_EQ(kEventSignaled, Wait())
|
||||
ASSERT_TRUE(Wait())
|
||||
<< "Timed out while waiting for encoder SetRates() call.";
|
||||
// Wait for GetStats to report a corresponding bitrate.
|
||||
for (unsigned int i = 0; i < kDefaultTimeoutMs; ++i) {
|
||||
for (int i = 0; i < kDefaultTimeoutMs; ++i) {
|
||||
VideoSendStream::Stats stats = send_stream_->GetStats();
|
||||
{
|
||||
rtc::CritScope lock(&crit_);
|
||||
@ -2350,26 +2342,26 @@ TEST_F(EndToEndTest, GetStats) {
|
||||
: EndToEndTest(kLongTimeoutMs),
|
||||
send_stream_(nullptr),
|
||||
expected_send_ssrcs_(),
|
||||
check_stats_event_(EventWrapper::Create()) {}
|
||||
check_stats_event_(false, false) {}
|
||||
|
||||
private:
|
||||
Action OnSendRtp(const uint8_t* packet, size_t length) override {
|
||||
check_stats_event_->Set();
|
||||
check_stats_event_.Set();
|
||||
return SEND_PACKET;
|
||||
}
|
||||
|
||||
Action OnSendRtcp(const uint8_t* packet, size_t length) override {
|
||||
check_stats_event_->Set();
|
||||
check_stats_event_.Set();
|
||||
return SEND_PACKET;
|
||||
}
|
||||
|
||||
Action OnReceiveRtp(const uint8_t* packet, size_t length) override {
|
||||
check_stats_event_->Set();
|
||||
check_stats_event_.Set();
|
||||
return SEND_PACKET;
|
||||
}
|
||||
|
||||
Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
|
||||
check_stats_event_->Set();
|
||||
check_stats_event_.Set();
|
||||
return SEND_PACKET;
|
||||
}
|
||||
|
||||
@ -2559,7 +2551,7 @@ TEST_F(EndToEndTest, GetStats) {
|
||||
|
||||
int64_t time_until_timout_ = stop_time - now;
|
||||
if (time_until_timout_ > 0)
|
||||
check_stats_event_->Wait(time_until_timout_);
|
||||
check_stats_event_.Wait(time_until_timout_);
|
||||
now = clock->TimeInMilliseconds();
|
||||
}
|
||||
|
||||
@ -2593,7 +2585,7 @@ TEST_F(EndToEndTest, GetStats) {
|
||||
std::set<uint32_t> expected_send_ssrcs_;
|
||||
std::string expected_cname_;
|
||||
|
||||
rtc::scoped_ptr<EventWrapper> check_stats_event_;
|
||||
rtc::Event check_stats_event_;
|
||||
} test;
|
||||
|
||||
FakeNetworkPipe::Config network_config;
|
||||
@ -2629,7 +2621,7 @@ TEST_F(EndToEndTest, TestReceivedRtpPacketStats) {
|
||||
if (sent_rtp_ >= kNumRtpPacketsToSend) {
|
||||
VideoReceiveStream::Stats stats = receive_stream_->GetStats();
|
||||
if (kNumRtpPacketsToSend == stats.rtp_stats.transmitted.packets) {
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
return DROP_PACKET;
|
||||
}
|
||||
@ -2638,7 +2630,7 @@ TEST_F(EndToEndTest, TestReceivedRtpPacketStats) {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
EXPECT_TRUE(Wait())
|
||||
<< "Timed out while verifying number of received RTP packets.";
|
||||
}
|
||||
|
||||
@ -2687,7 +2679,7 @@ TEST_F(EndToEndTest, DISABLED_RedundantPayloadsTransmittedOnAllSsrcs) {
|
||||
if (!observed_redundant_retransmission_[header.ssrc]) {
|
||||
observed_redundant_retransmission_[header.ssrc] = true;
|
||||
if (--ssrcs_to_observe_ == 0)
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
|
||||
return SEND_PACKET;
|
||||
@ -2716,7 +2708,7 @@ TEST_F(EndToEndTest, DISABLED_RedundantPayloadsTransmittedOnAllSsrcs) {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
EXPECT_TRUE(Wait())
|
||||
<< "Timed out while waiting for redundant payloads on all SSRCs.";
|
||||
}
|
||||
|
||||
@ -2805,7 +2797,7 @@ void EndToEndTest::TestRtpStatePreservation(bool use_rtx) {
|
||||
if (!ssrc_observed_[ssrc] && !only_padding) {
|
||||
ssrc_observed_[ssrc] = true;
|
||||
if (--ssrcs_to_observe_ == 0)
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
|
||||
return SEND_PACKET;
|
||||
@ -2866,7 +2858,7 @@ void EndToEndTest::TestRtpStatePreservation(bool use_rtx) {
|
||||
CreateFrameGeneratorCapturer();
|
||||
|
||||
Start();
|
||||
EXPECT_EQ(kEventSignaled, observer.Wait())
|
||||
EXPECT_TRUE(observer.Wait())
|
||||
<< "Timed out waiting for all SSRCs to send packets.";
|
||||
|
||||
// Test stream resetting more than once to make sure that the state doesn't
|
||||
@ -2883,25 +2875,23 @@ void EndToEndTest::TestRtpStatePreservation(bool use_rtx) {
|
||||
frame_generator_capturer_->Start();
|
||||
|
||||
observer.ResetExpectedSsrcs(1);
|
||||
EXPECT_EQ(kEventSignaled, observer.Wait())
|
||||
<< "Timed out waiting for single RTP packet.";
|
||||
EXPECT_TRUE(observer.Wait()) << "Timed out waiting for single RTP packet.";
|
||||
|
||||
// Reconfigure back to use all streams.
|
||||
send_stream_->ReconfigureVideoEncoder(encoder_config_);
|
||||
observer.ResetExpectedSsrcs(kNumSsrcs);
|
||||
EXPECT_EQ(kEventSignaled, observer.Wait())
|
||||
EXPECT_TRUE(observer.Wait())
|
||||
<< "Timed out waiting for all SSRCs to send packets.";
|
||||
|
||||
// Reconfigure down to one stream.
|
||||
send_stream_->ReconfigureVideoEncoder(one_stream);
|
||||
observer.ResetExpectedSsrcs(1);
|
||||
EXPECT_EQ(kEventSignaled, observer.Wait())
|
||||
<< "Timed out waiting for single RTP packet.";
|
||||
EXPECT_TRUE(observer.Wait()) << "Timed out waiting for single RTP packet.";
|
||||
|
||||
// Reconfigure back to use all streams.
|
||||
send_stream_->ReconfigureVideoEncoder(encoder_config_);
|
||||
observer.ResetExpectedSsrcs(kNumSsrcs);
|
||||
EXPECT_EQ(kEventSignaled, observer.Wait())
|
||||
EXPECT_TRUE(observer.Wait())
|
||||
<< "Timed out waiting for all SSRCs to send packets.";
|
||||
}
|
||||
|
||||
@ -2935,8 +2925,8 @@ TEST_F(EndToEndTest, RespectsNetworkState) {
|
||||
NetworkStateTest()
|
||||
: EndToEndTest(kDefaultTimeoutMs),
|
||||
FakeEncoder(Clock::GetRealTimeClock()),
|
||||
encoded_frames_(EventWrapper::Create()),
|
||||
packet_event_(EventWrapper::Create()),
|
||||
encoded_frames_(false, false),
|
||||
packet_event_(false, false),
|
||||
sender_call_(nullptr),
|
||||
receiver_call_(nullptr),
|
||||
sender_state_(kNetworkUp),
|
||||
@ -2948,14 +2938,14 @@ TEST_F(EndToEndTest, RespectsNetworkState) {
|
||||
Action OnSendRtp(const uint8_t* packet, size_t length) override {
|
||||
rtc::CritScope lock(&test_crit_);
|
||||
++sender_rtp_;
|
||||
packet_event_->Set();
|
||||
packet_event_.Set();
|
||||
return SEND_PACKET;
|
||||
}
|
||||
|
||||
Action OnSendRtcp(const uint8_t* packet, size_t length) override {
|
||||
rtc::CritScope lock(&test_crit_);
|
||||
++sender_rtcp_;
|
||||
packet_event_->Set();
|
||||
packet_event_.Set();
|
||||
return SEND_PACKET;
|
||||
}
|
||||
|
||||
@ -2967,7 +2957,7 @@ TEST_F(EndToEndTest, RespectsNetworkState) {
|
||||
Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
|
||||
rtc::CritScope lock(&test_crit_);
|
||||
++receiver_rtcp_;
|
||||
packet_event_->Set();
|
||||
packet_event_.Set();
|
||||
return SEND_PACKET;
|
||||
}
|
||||
|
||||
@ -2983,7 +2973,7 @@ TEST_F(EndToEndTest, RespectsNetworkState) {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, encoded_frames_->Wait(kDefaultTimeoutMs))
|
||||
EXPECT_TRUE(encoded_frames_.Wait(kDefaultTimeoutMs))
|
||||
<< "No frames received by the encoder.";
|
||||
// Wait for packets from both sender/receiver.
|
||||
WaitForPacketsOrSilence(false, false);
|
||||
@ -3024,9 +3014,9 @@ TEST_F(EndToEndTest, RespectsNetworkState) {
|
||||
EXPECT_LE(down_frames_, 1)
|
||||
<< "Encoding more than one frame while network is down.";
|
||||
if (down_frames_ > 1)
|
||||
encoded_frames_->Set();
|
||||
encoded_frames_.Set();
|
||||
} else {
|
||||
encoded_frames_->Set();
|
||||
encoded_frames_.Set();
|
||||
}
|
||||
}
|
||||
return test::FakeEncoder::Encode(
|
||||
@ -3048,7 +3038,7 @@ TEST_F(EndToEndTest, RespectsNetworkState) {
|
||||
bool sender_done = false;
|
||||
bool receiver_done = false;
|
||||
while (!sender_done || !receiver_done) {
|
||||
packet_event_->Wait(kSilenceTimeoutMs);
|
||||
packet_event_.Wait(kSilenceTimeoutMs);
|
||||
int64_t time_now_ms = clock_->TimeInMilliseconds();
|
||||
rtc::CritScope lock(&test_crit_);
|
||||
if (sender_down) {
|
||||
@ -3081,8 +3071,8 @@ TEST_F(EndToEndTest, RespectsNetworkState) {
|
||||
}
|
||||
|
||||
rtc::CriticalSection test_crit_;
|
||||
const rtc::scoped_ptr<EventWrapper> encoded_frames_;
|
||||
const rtc::scoped_ptr<EventWrapper> packet_event_;
|
||||
rtc::Event encoded_frames_;
|
||||
rtc::Event packet_event_;
|
||||
Call* sender_call_;
|
||||
Call* receiver_call_;
|
||||
NetworkState sender_state_ GUARDED_BY(test_crit_);
|
||||
|
||||
@ -204,7 +204,7 @@ bool RampUpTester::PollStats() {
|
||||
}
|
||||
if (stats.send_bandwidth_bps >= expected_bitrate_bps_) {
|
||||
ramp_up_finished_ms_ = clock_->TimeInMilliseconds();
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
}
|
||||
|
||||
@ -278,8 +278,7 @@ void RampUpTester::TriggerTestDone() {
|
||||
void RampUpTester::PerformTest() {
|
||||
test_start_ms_ = clock_->TimeInMilliseconds();
|
||||
poller_thread_.Start();
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
<< "Timed out while waiting for ramp-up to complete.";
|
||||
EXPECT_TRUE(Wait()) << "Timed out while waiting for ramp-up to complete.";
|
||||
TriggerTestDone();
|
||||
poller_thread_.Stop();
|
||||
}
|
||||
@ -385,7 +384,7 @@ void RampUpDownUpTester::EvolveTestState(int bitrate_bps, bool suspended) {
|
||||
now - state_start_ms_,
|
||||
"ms",
|
||||
false);
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
@ -15,11 +15,11 @@
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "webrtc/base/event.h"
|
||||
#include "webrtc/base/scoped_ptr.h"
|
||||
#include "webrtc/call.h"
|
||||
#include "webrtc/call/transport_adapter.h"
|
||||
#include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
|
||||
#include "webrtc/system_wrappers/include/event_wrapper.h"
|
||||
#include "webrtc/test/call_test.h"
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
@ -20,7 +20,6 @@
|
||||
#include "webrtc/modules/video_render/video_render_defines.h"
|
||||
#include "webrtc/system_wrappers/include/clock.h"
|
||||
#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
|
||||
#include "webrtc/system_wrappers/include/event_wrapper.h"
|
||||
#include "webrtc/system_wrappers/include/tick_util.h"
|
||||
#include "webrtc/video/overuse_frame_detector.h"
|
||||
#include "webrtc/video/send_statistics_proxy.h"
|
||||
@ -43,7 +42,7 @@ VideoCaptureInput::VideoCaptureInput(
|
||||
stats_proxy_(stats_proxy),
|
||||
incoming_frame_cs_(CriticalSectionWrapper::CreateCriticalSection()),
|
||||
encoder_thread_(EncoderThreadFunction, this, "EncoderThread"),
|
||||
capture_event_(EventWrapper::Create()),
|
||||
capture_event_(false, false),
|
||||
stop_(0),
|
||||
last_captured_timestamp_(0),
|
||||
delta_ntp_internal_ms_(
|
||||
@ -64,7 +63,7 @@ VideoCaptureInput::~VideoCaptureInput() {
|
||||
|
||||
// Stop the thread.
|
||||
rtc::AtomicOps::ReleaseStore(&stop_, 1);
|
||||
capture_event_->Set();
|
||||
capture_event_.Set();
|
||||
encoder_thread_.Stop();
|
||||
}
|
||||
|
||||
@ -116,7 +115,7 @@ void VideoCaptureInput::IncomingCapturedFrame(const VideoFrame& video_frame) {
|
||||
TRACE_EVENT_ASYNC_BEGIN1("webrtc", "Video", video_frame.render_time_ms(),
|
||||
"render_time", video_frame.render_time_ms());
|
||||
|
||||
capture_event_->Set();
|
||||
capture_event_.Set();
|
||||
}
|
||||
|
||||
bool VideoCaptureInput::EncoderThreadFunction(void* obj) {
|
||||
@ -126,7 +125,7 @@ bool VideoCaptureInput::EncoderThreadFunction(void* obj) {
|
||||
bool VideoCaptureInput::EncoderProcess() {
|
||||
static const int kThreadWaitTimeMs = 100;
|
||||
int64_t capture_time = -1;
|
||||
if (capture_event_->Wait(kThreadWaitTimeMs) == kEventSignaled) {
|
||||
if (capture_event_.Wait(kThreadWaitTimeMs)) {
|
||||
if (rtc::AtomicOps::AcquireLoad(&stop_))
|
||||
return false;
|
||||
|
||||
|
||||
@ -14,6 +14,7 @@
|
||||
#include <vector>
|
||||
|
||||
#include "webrtc/base/criticalsection.h"
|
||||
#include "webrtc/base/event.h"
|
||||
#include "webrtc/base/platform_thread.h"
|
||||
#include "webrtc/base/scoped_ptr.h"
|
||||
#include "webrtc/base/thread_annotations.h"
|
||||
@ -33,7 +34,6 @@ class Config;
|
||||
class CpuOveruseMetricsObserver;
|
||||
class CpuOveruseObserver;
|
||||
class CriticalSectionWrapper;
|
||||
class EventWrapper;
|
||||
class OveruseFrameDetector;
|
||||
class ProcessThread;
|
||||
class RegistrableCpuOveruseMetricsObserver;
|
||||
@ -79,7 +79,7 @@ class VideoCaptureInput : public webrtc::VideoCaptureInput {
|
||||
VideoFrame incoming_frame_;
|
||||
|
||||
rtc::PlatformThread encoder_thread_;
|
||||
rtc::scoped_ptr<EventWrapper> capture_event_;
|
||||
rtc::Event capture_event_;
|
||||
|
||||
volatile int stop_;
|
||||
|
||||
|
||||
@ -13,11 +13,11 @@
|
||||
|
||||
#include "testing/gmock/include/gmock/gmock.h"
|
||||
#include "testing/gtest/include/gtest/gtest.h"
|
||||
#include "webrtc/base/event.h"
|
||||
#include "webrtc/base/scoped_ptr.h"
|
||||
#include "webrtc/common.h"
|
||||
#include "webrtc/modules/utility/include/mock/mock_process_thread.h"
|
||||
#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
|
||||
#include "webrtc/system_wrappers/include/event_wrapper.h"
|
||||
#include "webrtc/system_wrappers/include/ref_count.h"
|
||||
#include "webrtc/system_wrappers/include/scoped_vector.h"
|
||||
#include "webrtc/test/fake_texture_frame.h"
|
||||
@ -51,7 +51,7 @@ class VideoCaptureInputTest : public ::testing::Test {
|
||||
VideoCaptureInputTest()
|
||||
: mock_process_thread_(new NiceMock<MockProcessThread>),
|
||||
mock_frame_callback_(new NiceMock<MockVideoCaptureCallback>),
|
||||
output_frame_event_(EventWrapper::Create()),
|
||||
output_frame_event_(false, false),
|
||||
stats_proxy_(Clock::GetRealTimeClock(),
|
||||
webrtc::VideoSendStream::Config(nullptr),
|
||||
webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo) {}
|
||||
@ -82,11 +82,11 @@ class VideoCaptureInputTest : public ::testing::Test {
|
||||
if (frame.native_handle() == NULL)
|
||||
output_frame_ybuffers_.push_back(frame.buffer(kYPlane));
|
||||
output_frames_.push_back(new VideoFrame(frame));
|
||||
output_frame_event_->Set();
|
||||
output_frame_event_.Set();
|
||||
}
|
||||
|
||||
void WaitOutputFrame() {
|
||||
EXPECT_EQ(kEventSignaled, output_frame_event_->Wait(FRAME_TIMEOUT_MS));
|
||||
EXPECT_TRUE(output_frame_event_.Wait(FRAME_TIMEOUT_MS));
|
||||
}
|
||||
|
||||
rtc::scoped_ptr<MockProcessThread> mock_process_thread_;
|
||||
@ -99,7 +99,7 @@ class VideoCaptureInputTest : public ::testing::Test {
|
||||
ScopedVector<VideoFrame> input_frames_;
|
||||
|
||||
// Indicate an output frame has arrived.
|
||||
rtc::scoped_ptr<EventWrapper> output_frame_event_;
|
||||
rtc::Event output_frame_event_;
|
||||
|
||||
// Output delivered frames of VideoCaptureInput.
|
||||
ScopedVector<VideoFrame> output_frames_;
|
||||
@ -112,20 +112,19 @@ class VideoCaptureInputTest : public ::testing::Test {
|
||||
|
||||
TEST_F(VideoCaptureInputTest, DoesNotRetainHandleNorCopyBuffer) {
|
||||
// Indicate an output frame has arrived.
|
||||
rtc::scoped_ptr<EventWrapper> frame_destroyed_event(EventWrapper::Create());
|
||||
rtc::Event frame_destroyed_event(false, false);
|
||||
class TestBuffer : public webrtc::I420Buffer {
|
||||
public:
|
||||
explicit TestBuffer(EventWrapper* event)
|
||||
: I420Buffer(5, 5), event_(event) {}
|
||||
explicit TestBuffer(rtc::Event* event) : I420Buffer(5, 5), event_(event) {}
|
||||
|
||||
private:
|
||||
friend class rtc::RefCountedObject<TestBuffer>;
|
||||
~TestBuffer() override { event_->Set(); }
|
||||
EventWrapper* event_;
|
||||
rtc::Event* const event_;
|
||||
};
|
||||
|
||||
VideoFrame frame(
|
||||
new rtc::RefCountedObject<TestBuffer>(frame_destroyed_event.get()), 1, 1,
|
||||
new rtc::RefCountedObject<TestBuffer>(&frame_destroyed_event), 1, 1,
|
||||
kVideoRotation_0);
|
||||
|
||||
AddInputFrame(&frame);
|
||||
@ -135,7 +134,7 @@ TEST_F(VideoCaptureInputTest, DoesNotRetainHandleNorCopyBuffer) {
|
||||
frame.video_frame_buffer().get());
|
||||
output_frames_.clear();
|
||||
frame.Reset();
|
||||
EXPECT_EQ(kEventSignaled, frame_destroyed_event->Wait(FRAME_TIMEOUT_MS));
|
||||
EXPECT_TRUE(frame_destroyed_event.Wait(FRAME_TIMEOUT_MS));
|
||||
}
|
||||
|
||||
TEST_F(VideoCaptureInputTest, TestNtpTimeStampSetIfRenderTimeSet) {
|
||||
@ -172,12 +171,12 @@ TEST_F(VideoCaptureInputTest, DropsFramesWithSameOrOldNtpTimestamp) {
|
||||
|
||||
// Repeat frame with the same NTP timestamp should drop.
|
||||
AddInputFrame(input_frames_[0]);
|
||||
EXPECT_EQ(kEventTimeout, output_frame_event_->Wait(FRAME_TIMEOUT_MS));
|
||||
EXPECT_FALSE(output_frame_event_.Wait(FRAME_TIMEOUT_MS));
|
||||
|
||||
// As should frames with a decreased NTP timestamp.
|
||||
input_frames_[0]->set_ntp_time_ms(input_frames_[0]->ntp_time_ms() - 1);
|
||||
AddInputFrame(input_frames_[0]);
|
||||
EXPECT_EQ(kEventTimeout, output_frame_event_->Wait(FRAME_TIMEOUT_MS));
|
||||
EXPECT_FALSE(output_frame_event_.Wait(FRAME_TIMEOUT_MS));
|
||||
|
||||
// But delivering with an increased NTP timestamp should succeed.
|
||||
input_frames_[0]->set_ntp_time_ms(4711);
|
||||
|
||||
@ -19,6 +19,7 @@
|
||||
#include "testing/gtest/include/gtest/gtest.h"
|
||||
|
||||
#include "webrtc/base/checks.h"
|
||||
#include "webrtc/base/event.h"
|
||||
#include "webrtc/base/format_macros.h"
|
||||
#include "webrtc/base/scoped_ptr.h"
|
||||
#include "webrtc/call.h"
|
||||
@ -71,8 +72,8 @@ class VideoAnalyzer : public PacketReceiver,
|
||||
avg_psnr_threshold_(avg_psnr_threshold),
|
||||
avg_ssim_threshold_(avg_ssim_threshold),
|
||||
stats_polling_thread_(&PollStatsThread, this, "StatsPoller"),
|
||||
comparison_available_event_(EventWrapper::Create()),
|
||||
done_(EventWrapper::Create()) {
|
||||
comparison_available_event_(false, false),
|
||||
done_(false, false) {
|
||||
// Create thread pool for CPU-expensive PSNR/SSIM calculations.
|
||||
|
||||
// Try to use about as many threads as cores, but leave kMinCoresLeft alone,
|
||||
@ -223,10 +224,8 @@ class VideoAnalyzer : public PacketReceiver,
|
||||
stats_polling_thread_.Start();
|
||||
|
||||
int last_frames_processed = -1;
|
||||
EventTypeWrapper eventType;
|
||||
int iteration = 0;
|
||||
while ((eventType = done_->Wait(VideoQualityTest::kDefaultTimeoutMs)) !=
|
||||
kEventSignaled) {
|
||||
while (!done_.Wait(VideoQualityTest::kDefaultTimeoutMs)) {
|
||||
int frames_processed;
|
||||
{
|
||||
rtc::CritScope crit(&comparison_lock_);
|
||||
@ -255,7 +254,7 @@ class VideoAnalyzer : public PacketReceiver,
|
||||
// Signal stats polling thread if that is still waiting and stop it now,
|
||||
// since it uses the send_stream_ reference that might be reclaimed after
|
||||
// returning from this method.
|
||||
done_->Set();
|
||||
done_.Set();
|
||||
stats_polling_thread_.Stop();
|
||||
}
|
||||
|
||||
@ -352,7 +351,7 @@ class VideoAnalyzer : public PacketReceiver,
|
||||
comparisons_.push_back(FrameComparison(reference_copy, render_copy, dropped,
|
||||
send_time_ms, recv_time_ms,
|
||||
render_time_ms, encoded_size));
|
||||
comparison_available_event_->Set();
|
||||
comparison_available_event_.Set();
|
||||
}
|
||||
|
||||
static bool PollStatsThread(void* obj) {
|
||||
@ -360,15 +359,11 @@ class VideoAnalyzer : public PacketReceiver,
|
||||
}
|
||||
|
||||
bool PollStats() {
|
||||
switch (done_->Wait(kSendStatsPollingIntervalMs)) {
|
||||
case kEventSignaled:
|
||||
case kEventError:
|
||||
done_->Set(); // Make sure main thread is also signaled.
|
||||
return false;
|
||||
case kEventTimeout:
|
||||
break;
|
||||
default:
|
||||
RTC_NOTREACHED();
|
||||
if (done_.Wait(kSendStatsPollingIntervalMs)) {
|
||||
// Set event again to make sure main thread is also signaled, then we're
|
||||
// done.
|
||||
done_.Set();
|
||||
return false;
|
||||
}
|
||||
|
||||
VideoSendStream::Stats stats = send_stream_->GetStats();
|
||||
@ -397,9 +392,9 @@ class VideoAnalyzer : public PacketReceiver,
|
||||
if (!PopComparison(&comparison)) {
|
||||
// Wait until new comparison task is available, or test is done.
|
||||
// If done, wake up remaining threads waiting.
|
||||
comparison_available_event_->Wait(1000);
|
||||
comparison_available_event_.Wait(1000);
|
||||
if (AllFramesRecorded()) {
|
||||
comparison_available_event_->Set();
|
||||
comparison_available_event_.Set();
|
||||
return false;
|
||||
}
|
||||
return true; // Try again.
|
||||
@ -411,8 +406,8 @@ class VideoAnalyzer : public PacketReceiver,
|
||||
PrintResults();
|
||||
if (graph_data_output_file_)
|
||||
PrintSamplesToFile();
|
||||
done_->Set();
|
||||
comparison_available_event_->Set();
|
||||
done_.Set();
|
||||
comparison_available_event_.Set();
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -603,9 +598,9 @@ class VideoAnalyzer : public PacketReceiver,
|
||||
rtc::CriticalSection comparison_lock_;
|
||||
std::vector<rtc::PlatformThread*> comparison_thread_pool_;
|
||||
rtc::PlatformThread stats_polling_thread_;
|
||||
const rtc::scoped_ptr<EventWrapper> comparison_available_event_;
|
||||
rtc::Event comparison_available_event_;
|
||||
std::deque<FrameComparison> comparisons_ GUARDED_BY(comparison_lock_);
|
||||
const rtc::scoped_ptr<EventWrapper> done_;
|
||||
rtc::Event done_;
|
||||
};
|
||||
|
||||
VideoQualityTest::VideoQualityTest() : clock_(Clock::GetRealTimeClock()) {}
|
||||
|
||||
@ -15,6 +15,7 @@
|
||||
#include "webrtc/base/bind.h"
|
||||
#include "webrtc/base/checks.h"
|
||||
#include "webrtc/base/criticalsection.h"
|
||||
#include "webrtc/base/event.h"
|
||||
#include "webrtc/base/logging.h"
|
||||
#include "webrtc/base/platform_thread.h"
|
||||
#include "webrtc/base/scoped_ptr.h"
|
||||
@ -28,7 +29,6 @@
|
||||
#include "webrtc/modules/rtp_rtcp/source/rtp_format_vp9.h"
|
||||
#include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h"
|
||||
#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
|
||||
#include "webrtc/system_wrappers/include/event_wrapper.h"
|
||||
#include "webrtc/system_wrappers/include/ref_count.h"
|
||||
#include "webrtc/system_wrappers/include/sleep.h"
|
||||
#include "webrtc/test/call_test.h"
|
||||
@ -102,7 +102,7 @@ TEST_F(VideoSendStreamTest, SupportsCName) {
|
||||
while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
|
||||
if (packet_type == RTCPUtility::RTCPPacketTypes::kSdesChunk) {
|
||||
EXPECT_EQ(parser.Packet().CName.CName, kCName);
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
|
||||
packet_type = parser.Iterate();
|
||||
@ -118,8 +118,7 @@ TEST_F(VideoSendStreamTest, SupportsCName) {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
<< "Timed out while waiting for RTCP with CNAME.";
|
||||
EXPECT_TRUE(Wait()) << "Timed out while waiting for RTCP with CNAME.";
|
||||
}
|
||||
} test;
|
||||
|
||||
@ -142,7 +141,7 @@ TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
|
||||
EXPECT_TRUE(header.extension.hasAbsoluteSendTime);
|
||||
EXPECT_EQ(header.extension.transmissionTimeOffset, 0);
|
||||
EXPECT_GT(header.extension.absoluteSendTime, 0u);
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
|
||||
return SEND_PACKET;
|
||||
}
|
||||
@ -156,8 +155,7 @@ TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
<< "Timed out while waiting for single RTP packet.";
|
||||
EXPECT_TRUE(Wait()) << "Timed out while waiting for single RTP packet.";
|
||||
}
|
||||
} test;
|
||||
|
||||
@ -184,7 +182,7 @@ TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
|
||||
EXPECT_FALSE(header.extension.hasAbsoluteSendTime);
|
||||
EXPECT_GT(header.extension.transmissionTimeOffset, 0);
|
||||
EXPECT_EQ(header.extension.absoluteSendTime, 0u);
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
|
||||
return SEND_PACKET;
|
||||
}
|
||||
@ -199,8 +197,7 @@ TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
<< "Timed out while waiting for a single RTP packet.";
|
||||
EXPECT_TRUE(Wait()) << "Timed out while waiting for a single RTP packet.";
|
||||
}
|
||||
|
||||
test::DelayedEncoder encoder_;
|
||||
@ -228,7 +225,7 @@ TEST_F(VideoSendStreamTest, SupportsTransportWideSequenceNumbers) {
|
||||
EXPECT_FALSE(header.extension.hasTransmissionTimeOffset);
|
||||
EXPECT_FALSE(header.extension.hasAbsoluteSendTime);
|
||||
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
|
||||
return SEND_PACKET;
|
||||
}
|
||||
@ -243,8 +240,7 @@ TEST_F(VideoSendStreamTest, SupportsTransportWideSequenceNumbers) {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
<< "Timed out while waiting for a single RTP packet.";
|
||||
EXPECT_TRUE(Wait()) << "Timed out while waiting for a single RTP packet.";
|
||||
}
|
||||
|
||||
test::FakeEncoder encoder_;
|
||||
@ -380,7 +376,7 @@ class FecObserver : public test::SendTest {
|
||||
}
|
||||
|
||||
if (received_media_ && received_fec_ && send_count_ > 100)
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
|
||||
prev_header_ = header;
|
||||
|
||||
@ -480,7 +476,7 @@ void VideoSendStreamTest::TestNackRetransmission(
|
||||
if (sequence_number == nacked_sequence_number_) {
|
||||
EXPECT_EQ(retransmit_ssrc_, header.ssrc);
|
||||
EXPECT_EQ(retransmit_payload_type_, header.payloadType);
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
|
||||
return SEND_PACKET;
|
||||
@ -499,8 +495,7 @@ void VideoSendStreamTest::TestNackRetransmission(
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
<< "Timed out while waiting for NACK retransmission.";
|
||||
EXPECT_TRUE(Wait()) << "Timed out while waiting for NACK retransmission.";
|
||||
}
|
||||
|
||||
rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_;
|
||||
@ -616,7 +611,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
|
||||
accumulated_payload_ = 0;
|
||||
if (current_size_rtp_ == stop_size_) {
|
||||
// Done! (Don't increase size again, might arrive more @ stop_size).
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
} else {
|
||||
// Increase next expected frame size. If testing with FEC, make sure
|
||||
// a FEC packet has been received for this frame size before
|
||||
@ -695,8 +690,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
<< "Timed out while observing incoming RTP packets.";
|
||||
EXPECT_TRUE(Wait()) << "Timed out while observing incoming RTP packets.";
|
||||
}
|
||||
|
||||
rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_;
|
||||
@ -796,7 +790,7 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
|
||||
VideoSendStream::Stats stats = stream_->GetStats();
|
||||
if (stats.suspended == false) {
|
||||
// Stats flipped to false. Test is complete.
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
SendRtcpFeedback(0); // REMB is only sent if value is > 0.
|
||||
}
|
||||
@ -850,8 +844,7 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
<< "Timed out during suspend-below-min-bitrate test.";
|
||||
EXPECT_TRUE(Wait()) << "Timed out during suspend-below-min-bitrate test.";
|
||||
}
|
||||
|
||||
enum TestState {
|
||||
@ -918,7 +911,7 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
|
||||
if (last_packet_time_ms_ > 0 &&
|
||||
clock_->TimeInMilliseconds() - last_packet_time_ms_ >
|
||||
kVideoMutedThresholdMs)
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
// Receive statistics reporting having lost 50% of the packets.
|
||||
FakeReceiveStatistics receive_stats(kSendSsrcs[0], 1, 1, 0);
|
||||
RTCPSender rtcp_sender(false, Clock::GetRealTimeClock(), &receive_stats,
|
||||
@ -950,7 +943,7 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
EXPECT_TRUE(Wait())
|
||||
<< "Timed out while waiting for RTP packets to stop being sent.";
|
||||
}
|
||||
|
||||
@ -1010,7 +1003,7 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
|
||||
bitrate_capped_ = true;
|
||||
} else if (bitrate_capped_ &&
|
||||
total_bitrate_bps < kRembRespectedBitrateBps) {
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
}
|
||||
// Packets don't have to be delivered since the test is the receiver.
|
||||
@ -1038,7 +1031,7 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
EXPECT_TRUE(Wait())
|
||||
<< "Timeout while waiting for low bitrate stats after REMB.";
|
||||
}
|
||||
|
||||
@ -1114,16 +1107,16 @@ TEST_F(VideoSendStreamTest, CanReconfigureToUseStartBitrateAbovePreviousMax) {
|
||||
TEST_F(VideoSendStreamTest, CapturesTextureAndVideoFrames) {
|
||||
class FrameObserver : public I420FrameCallback {
|
||||
public:
|
||||
FrameObserver() : output_frame_event_(EventWrapper::Create()) {}
|
||||
FrameObserver() : output_frame_event_(false, false) {}
|
||||
|
||||
void FrameCallback(VideoFrame* video_frame) override {
|
||||
output_frames_.push_back(*video_frame);
|
||||
output_frame_event_->Set();
|
||||
output_frame_event_.Set();
|
||||
}
|
||||
|
||||
void WaitOutputFrame() {
|
||||
const uint32_t kWaitFrameTimeoutMs = 3000;
|
||||
EXPECT_EQ(kEventSignaled, output_frame_event_->Wait(kWaitFrameTimeoutMs))
|
||||
const int kWaitFrameTimeoutMs = 3000;
|
||||
EXPECT_TRUE(output_frame_event_.Wait(kWaitFrameTimeoutMs))
|
||||
<< "Timeout while waiting for output frames.";
|
||||
}
|
||||
|
||||
@ -1136,7 +1129,7 @@ TEST_F(VideoSendStreamTest, CapturesTextureAndVideoFrames) {
|
||||
std::vector<VideoFrame> output_frames_;
|
||||
|
||||
// Indicate an output frame has arrived.
|
||||
rtc::scoped_ptr<EventWrapper> output_frame_event_;
|
||||
rtc::Event output_frame_event_;
|
||||
};
|
||||
|
||||
// Initialize send stream.
|
||||
@ -1284,7 +1277,7 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
|
||||
const std::vector<FrameType>* frame_types) override {
|
||||
EXPECT_TRUE(IsReadyForEncode());
|
||||
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1334,8 +1327,7 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
<< "Timed out while waiting for Encode.";
|
||||
EXPECT_TRUE(Wait()) << "Timed out while waiting for Encode.";
|
||||
EXPECT_EQ(0u, num_releases());
|
||||
stream_->ReconfigureVideoEncoder(encoder_config_);
|
||||
EXPECT_EQ(0u, num_releases());
|
||||
@ -1345,8 +1337,7 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
|
||||
EXPECT_TRUE(IsReadyForEncode());
|
||||
stream_->Start();
|
||||
// Sanity check, make sure we still encode frames with this encoder.
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
<< "Timed out while waiting for Encode.";
|
||||
EXPECT_TRUE(Wait()) << "Timed out while waiting for Encode.";
|
||||
}
|
||||
|
||||
rtc::CriticalSection crit_;
|
||||
@ -1587,7 +1578,7 @@ TEST_F(VideoSendStreamTest, RtcpSenderReportContainsMediaBytesSent) {
|
||||
if (parser.Packet().SR.SenderOctetCount > 0 &&
|
||||
parser.Packet().SR.SenderPacketCount == rtp_packets_sent_) {
|
||||
EXPECT_EQ(media_bytes_sent_, parser.Packet().SR.SenderOctetCount);
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
}
|
||||
packet_type = parser.Iterate();
|
||||
@ -1597,8 +1588,7 @@ TEST_F(VideoSendStreamTest, RtcpSenderReportContainsMediaBytesSent) {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
<< "Timed out while waiting for RTCP sender report.";
|
||||
EXPECT_TRUE(Wait()) << "Timed out while waiting for RTCP sender report.";
|
||||
}
|
||||
|
||||
rtc::CriticalSection crit_;
|
||||
@ -1624,7 +1614,7 @@ TEST_F(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) {
|
||||
size_t max_payload_size) override {
|
||||
EXPECT_EQ(static_cast<unsigned int>(kScreencastTargetBitrateKbps),
|
||||
config->targetBitrate);
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
return test::FakeEncoder::InitEncode(
|
||||
config, number_of_cores, max_payload_size);
|
||||
}
|
||||
@ -1641,7 +1631,7 @@ TEST_F(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
EXPECT_TRUE(Wait())
|
||||
<< "Timed out while waiting for the encoder to be initialized.";
|
||||
}
|
||||
} test;
|
||||
@ -1677,7 +1667,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
|
||||
codecSettings->startBitrate);
|
||||
EXPECT_EQ(static_cast<unsigned int>(kMaxBitrateKbps),
|
||||
codecSettings->maxBitrate);
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
} else if (num_initializations_ == 1) {
|
||||
EXPECT_EQ(static_cast<unsigned int>(kLowerMaxBitrateKbps),
|
||||
codecSettings->maxBitrate);
|
||||
@ -1730,7 +1720,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
|
||||
bitrate_config.start_bitrate_bps = kIncreasedStartBitrateKbps * 1000;
|
||||
bitrate_config.max_bitrate_bps = kIncreasedMaxBitrateKbps * 1000;
|
||||
call_->SetBitrateConfig(bitrate_config);
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
EXPECT_TRUE(Wait())
|
||||
<< "Timed out while waiting encoder to be configured.";
|
||||
encoder_config_.streams[0].min_bitrate_bps = 0;
|
||||
encoder_config_.streams[0].max_bitrate_bps = kLowerMaxBitrateKbps * 1000;
|
||||
@ -1793,7 +1783,7 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
return 0;
|
||||
}
|
||||
void ModifyConfigs(VideoSendStream::Config* send_config,
|
||||
@ -1806,7 +1796,7 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) {
|
||||
size_t GetNumStreams() const override { return kNumStreams; }
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
EXPECT_TRUE(Wait())
|
||||
<< "Timed out while waiting for the encoder to send one frame.";
|
||||
VideoSendStream::Stats stats = send_stream_->GetStats();
|
||||
|
||||
@ -1868,8 +1858,8 @@ class Vp9HeaderObserver : public test::SendTest {
|
||||
}
|
||||
|
||||
void PerformTest() override {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
<< "Test timed out waiting for VP9 packet, num frames " << frames_sent_;
|
||||
EXPECT_TRUE(Wait()) << "Test timed out waiting for VP9 packet, num frames "
|
||||
<< frames_sent_;
|
||||
}
|
||||
|
||||
Action OnSendRtp(const uint8_t* packet, size_t length) override {
|
||||
@ -2180,7 +2170,7 @@ void VideoSendStreamTest::TestVp9NonFlexMode(uint8_t num_temporal_layers,
|
||||
l_field_ ? num_temporal_layers_ : 0);
|
||||
|
||||
if (frames_sent_ > kNumFramesToSend)
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
const uint8_t num_temporal_layers_;
|
||||
const uint8_t num_spatial_layers_;
|
||||
@ -2207,7 +2197,7 @@ TEST_F(VideoSendStreamTest, Vp9FlexModeRefCount) {
|
||||
EXPECT_EQ(kNoTl0PicIdx, vp9_header.tl0_pic_idx);
|
||||
if (vp9_header.inter_pic_predicted) {
|
||||
EXPECT_GT(vp9_header.num_ref_pics, 0u);
|
||||
observation_complete_->Set();
|
||||
observation_complete_.Set();
|
||||
}
|
||||
}
|
||||
} test;
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user