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

Update rtc::Event::Wait call sites to use TimeDelta.

Browse Source 
Bug: webrtc:14366
Change-Id: I949c1d26f030696b18153afef977633c9a5bd4cf
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/272003
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Commit-Queue: Markus Handell <handellm@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#37835}
This commit is contained in:
Markus Handell
2022-08-19 08:16:48 +00:00
committed by WebRTC LUCI CQ
parent 4d715385e1
commit 2cfc1af78a
62 changed files with 302 additions and 297 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
modules/video_coding/codecs/test/video_codec_unittest.cc
View File

@ -18,8 +18,10 @@
#include "modules/video_coding/include/video_error_codes.h"
#include "test/video_codec_settings.h"
static const int kEncodeTimeoutMs = 100;
static const int kDecodeTimeoutMs = 25;
static constexpr webrtc::TimeDelta kEncodeTimeout =
webrtc::TimeDelta::Millis(100);
static constexpr webrtc::TimeDelta kDecodeTimeout =
webrtc::TimeDelta::Millis(25);
// Set bitrate to get higher quality.
static const int kStartBitrate = 300;
static const int kMaxBitrate = 4000;
@ -136,7 +138,7 @@ void VideoCodecUnitTest::SetWaitForEncodedFramesThreshold(size_t num_frames) {
bool VideoCodecUnitTest::WaitForEncodedFrames(
std::vector<EncodedImage>* frames,
std::vector<CodecSpecificInfo>* codec_specific_info) {
EXPECT_TRUE(encoded_frame_event_.Wait(kEncodeTimeoutMs))
EXPECT_TRUE(encoded_frame_event_.Wait(kEncodeTimeout))
<< "Timed out while waiting for encoded frame.";
// This becomes unsafe if there are multiple threads waiting for frames.
MutexLock lock(&encoded_frame_section_);
@ -157,7 +159,7 @@ bool VideoCodecUnitTest::WaitForEncodedFrames(
bool VideoCodecUnitTest::WaitForDecodedFrame(std::unique_ptr<VideoFrame>* frame,
absl::optional<uint8_t>* qp) {
bool ret = decoded_frame_event_.Wait(kDecodeTimeoutMs);
bool ret = decoded_frame_event_.Wait(kDecodeTimeout);
EXPECT_TRUE(ret) << "Timed out while waiting for a decoded frame.";
// This becomes unsafe if there are multiple threads waiting for frames.
MutexLock lock(&decoded_frame_section_);

4
modules/video_coding/event_wrapper.cc
View File

@ -23,8 +23,10 @@ class EventWrapperImpl : public EventWrapper {
return true;
}
// TODO(bugs.webrtc.org/14366): Migrate to TimeDelta.
EventTypeWrapper Wait(int max_time_ms) override {
return event_.Wait(max_time_ms) ? kEventSignaled : kEventTimeout;
return event_.Wait(TimeDelta::Millis(max_time_ms)) ? kEventSignaled
: kEventTimeout;
}
private:

1
modules/video_coding/event_wrapper.h
View File

@ -38,6 +38,7 @@ class EventWrapper {
// Depending on timing.
//
// `max_time_ms` is the maximum time to wait in milliseconds.
// TODO(bugs.webrtc.org/14366): Migrate to TimeDelta.
virtual EventTypeWrapper Wait(int max_time_ms) = 0;
};

32
modules/video_coding/utility/bandwidth_quality_scaler_unittest.cc
View File

@ -13,6 +13,7 @@
#include <memory>
#include <string>
#include "api/units/time_delta.h"
#include "rtc_base/checks.h"
#include "rtc_base/event.h"
#include "rtc_base/experiments/encoder_info_settings.h"
@ -25,8 +26,8 @@ namespace webrtc {
namespace {
constexpr int kFramerateFps = 30;
constexpr int kDefaultBitrateStateUpdateIntervalSeconds = 5;
constexpr int kDefaultEncodeDeltaTimeMs = 33; // 1/30(s) => 33(ms)
constexpr TimeDelta kDefaultBitrateStateUpdateInterval = TimeDelta::Seconds(5);
constexpr TimeDelta kDefaultEncodeTime = TimeDelta::Seconds(1) / kFramerateFps;
} // namespace
@ -158,8 +159,9 @@ class BandwidthQualityScalerTest
total_frame_nums += frame_config.frame_num;
}
EXPECT_EQ(kFramerateFps * kDefaultBitrateStateUpdateIntervalSeconds,
total_frame_nums);
EXPECT_EQ(
kFramerateFps * kDefaultBitrateStateUpdateInterval.seconds(),
total_frame_nums);
uint32_t time_send_to_scaler_ms_ = rtc::TimeMillis();
for (size_t i = 0; i < frame_configs.size(); ++i) {
@ -169,7 +171,7 @@ class BandwidthQualityScalerTest
config.actual_width * config.actual_height);
EXPECT_TRUE(suitable_bitrate);
for (int j = 0; j <= config.frame_num; ++j) {
time_send_to_scaler_ms_ += kDefaultEncodeDeltaTimeMs;
time_send_to_scaler_ms_ += kDefaultEncodeTime.ms();
int frame_size_bytes =
GetFrameSizeBytes(config, suitable_bitrate.value());
RTC_CHECK(frame_size_bytes > 0);
@ -203,8 +205,8 @@ TEST_P(BandwidthQualityScalerTest, AllNormalFrame_640x360) {
// When resolution is 640*360, experimental working bitrate range is
// [500000,800000] bps. Encoded bitrate is 654253, so it falls in the range
// without any operation(up/down).
EXPECT_FALSE(handler_->event_.Wait(
bandwidth_quality_scaler_->GetBitrateStateUpdateIntervalMs()));
EXPECT_FALSE(handler_->event_.Wait(TimeDelta::Millis(
bandwidth_quality_scaler_->GetBitrateStateUpdateIntervalMs())));
EXPECT_EQ(0, handler_->adapt_down_event_count_);
EXPECT_EQ(0, handler_->adapt_up_event_count_);
}
@ -217,8 +219,8 @@ TEST_P(BandwidthQualityScalerTest, AllNoramlFrame_AboveMaxBandwidth_640x360) {
// When resolution is 640*360, experimental working bitrate range is
// [500000,800000] bps. Encoded bitrate is 1208000 > 800000 * 0.95, so it
// triggers adapt_up_event_count_.
EXPECT_TRUE(handler_->event_.Wait(
bandwidth_quality_scaler_->GetBitrateStateUpdateIntervalMs()));
EXPECT_TRUE(handler_->event_.Wait(TimeDelta::Millis(
bandwidth_quality_scaler_->GetBitrateStateUpdateIntervalMs())));
EXPECT_EQ(0, handler_->adapt_down_event_count_);
EXPECT_EQ(1, handler_->adapt_up_event_count_);
}
@ -231,8 +233,8 @@ TEST_P(BandwidthQualityScalerTest, AllNormalFrame_Underuse_640x360) {
// When resolution is 640*360, experimental working bitrate range is
// [500000,800000] bps. Encoded bitrate is 377379 < 500000 * 0.8, so it
// triggers adapt_down_event_count_.
EXPECT_TRUE(handler_->event_.Wait(
bandwidth_quality_scaler_->GetBitrateStateUpdateIntervalMs()));
EXPECT_TRUE(handler_->event_.Wait(TimeDelta::Millis(
bandwidth_quality_scaler_->GetBitrateStateUpdateIntervalMs())));
EXPECT_EQ(1, handler_->adapt_down_event_count_);
EXPECT_EQ(0, handler_->adapt_up_event_count_);
}
@ -249,8 +251,8 @@ TEST_P(BandwidthQualityScalerTest, FixedFrameTypeTest1_640x360) {
// When resolution is 640*360, experimental working bitrate range is
// [500000,800000] bps. Encoded bitrate is 1059462 > 800000 * 0.95, so it
// triggers adapt_up_event_count_.
EXPECT_TRUE(handler_->event_.Wait(
bandwidth_quality_scaler_->GetBitrateStateUpdateIntervalMs()));
EXPECT_TRUE(handler_->event_.Wait(TimeDelta::Millis(
bandwidth_quality_scaler_->GetBitrateStateUpdateIntervalMs())));
EXPECT_EQ(0, handler_->adapt_down_event_count_);
EXPECT_EQ(1, handler_->adapt_up_event_count_);
}
@ -267,8 +269,8 @@ TEST_P(BandwidthQualityScalerTest, FixedFrameTypeTest2_640x360) {
// When resolution is 640*360, experimental working bitrate range is
// [500000,800000] bps. Encoded bitrate is 1059462 > 800000 * 0.95, so it
// triggers adapt_up_event_count_.
EXPECT_TRUE(handler_->event_.Wait(
bandwidth_quality_scaler_->GetBitrateStateUpdateIntervalMs()));
EXPECT_TRUE(handler_->event_.Wait(TimeDelta::Millis(
bandwidth_quality_scaler_->GetBitrateStateUpdateIntervalMs())));
EXPECT_EQ(0, handler_->adapt_down_event_count_);
EXPECT_EQ(1, handler_->adapt_up_event_count_);
}

33
modules/video_coding/utility/quality_scaler_unittest.cc
View File

@ -13,6 +13,7 @@
#include <memory>
#include <string>
#include "api/units/time_delta.h"
#include "rtc_base/checks.h"
#include "rtc_base/event.h"
#include "rtc_base/task_queue_for_test.h"
@ -25,7 +26,7 @@ static const int kFramerate = 30;
static const int kLowQp = 15;
static const int kHighQp = 40;
static const int kMinFramesNeededToScale = 60; // From quality_scaler.cc.
static const size_t kDefaultTimeoutMs = 150;
static constexpr TimeDelta kDefaultTimeout = TimeDelta::Millis(150);
} // namespace
class FakeQpUsageHandler : public QualityScalerQpUsageHandlerInterface {
@ -119,21 +120,21 @@ INSTANTIATE_TEST_SUITE_P(
TEST_P(QualityScalerTest, DownscalesAfterContinuousFramedrop) {
task_queue_.SendTask([this] { TriggerScale(kScaleDown); });
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeout));
EXPECT_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
}
TEST_P(QualityScalerTest, KeepsScaleAtHighQp) {
task_queue_.SendTask([this] { TriggerScale(kKeepScaleAtHighQp); });
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeout));
EXPECT_EQ(0, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
}
TEST_P(QualityScalerTest, DownscalesAboveHighQp) {
task_queue_.SendTask([this] { TriggerScale(kScaleDownAboveHighQp); });
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeout));
EXPECT_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
}
@ -146,7 +147,7 @@ TEST_P(QualityScalerTest, DownscalesAfterTwoThirdsFramedrop) {
qs_->ReportQp(kHighQp, 0);
}
});
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeout));
EXPECT_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
}
@ -158,7 +159,7 @@ TEST_P(QualityScalerTest, DoesNotDownscaleAfterHalfFramedrop) {
qs_->ReportQp(kHighQp, 0);
}
});
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeout));
EXPECT_EQ(0, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
}
@ -173,32 +174,32 @@ TEST_P(QualityScalerTest, DownscalesAfterTwoThirdsIfFieldTrialEnabled) {
qs_->ReportQp(kHighQp, 0);
}
});
EXPECT_EQ(kDownScaleExpected, handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(kDownScaleExpected, handler_->event.Wait(kDefaultTimeout));
EXPECT_EQ(kDownScaleExpected ? 1 : 0, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
}
TEST_P(QualityScalerTest, KeepsScaleOnNormalQp) {
task_queue_.SendTask([this] { TriggerScale(kKeepScaleAboveLowQp); });
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeout));
EXPECT_EQ(0, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
}
TEST_P(QualityScalerTest, UpscalesAfterLowQp) {
task_queue_.SendTask([this] { TriggerScale(kScaleUp); });
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeout));
EXPECT_EQ(0, handler_->adapt_down_events_);
EXPECT_EQ(1, handler_->adapt_up_events_);
}
TEST_P(QualityScalerTest, ScalesDownAndBackUp) {
task_queue_.SendTask([this] { TriggerScale(kScaleDown); });
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeout));
EXPECT_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
task_queue_.SendTask([this] { TriggerScale(kScaleUp); });
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeout));
EXPECT_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(1, handler_->adapt_up_events_);
}
@ -210,13 +211,13 @@ TEST_P(QualityScalerTest, DoesNotScaleUntilEnoughFramesObserved) {
qs_->ReportQp(kLowQp, 0);
}
});
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeout));
task_queue_.SendTask([this] {
// Send 1 more. Enough frames observed, should result in an adapt
// request.
qs_->ReportQp(kLowQp, 0);
});
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeout));
EXPECT_EQ(0, handler_->adapt_down_events_);
EXPECT_EQ(1, handler_->adapt_up_events_);
@ -225,7 +226,7 @@ TEST_P(QualityScalerTest, DoesNotScaleUntilEnoughFramesObserved) {
// Not enough frames to make a decision.
qs_->ReportQp(kLowQp, 0);
});
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeout));
EXPECT_EQ(0, handler_->adapt_down_events_);
EXPECT_EQ(1, handler_->adapt_up_events_);
}
@ -236,7 +237,7 @@ TEST_P(QualityScalerTest, ScalesDownAndBackUpWithMinFramesNeeded) {
qs_->ReportQp(kHighQp + 1, 0);
}
});
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeout));
EXPECT_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
// Samples cleared.
@ -245,7 +246,7 @@ TEST_P(QualityScalerTest, ScalesDownAndBackUpWithMinFramesNeeded) {
qs_->ReportQp(kLowQp, 0);
}
});
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeout));
EXPECT_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(1, handler_->adapt_up_events_);
}