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

Remove rtc::Location from SendTask test helper

Browse Source 
that rtc::Location parameter was used only as extra information for the
RTC_CHECKs directly in the function, thus call stack of the crash should
provide all the information about the caller.

Bug: webrtc:11318
Change-Id: Iec6dd2c5de547f3e1601647a614be7ce57a55734
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/270920
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#37748}
This commit is contained in:
Danil Chapovalov
2022-08-11 12:26:09 +02:00
committed by WebRTC LUCI CQ
parent e2d829cf77
commit e519f38eaa
37 changed files with 352 additions and 470 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
modules/video_coding/codecs/test/videocodec_test_fixture_impl.cc
View File

@ -503,7 +503,7 @@ void VideoCodecTestFixtureImpl::ProcessAllFrames(
task_queue->PostTask([this] { processor_->Finalize(); });
// Wait until we know that the last frame has been sent for encode.
task_queue->SendTask([] {}, RTC_FROM_HERE);
task_queue->SendTask([] {});
// Give the VideoProcessor pipeline some time to process the last frame,
// and then release the codecs.
@ -720,11 +720,9 @@ bool VideoCodecTestFixtureImpl::SetUpAndInitObjects(
cpu_process_time_.reset(new CpuProcessTime(config_));
bool is_codec_created = false;
task_queue->SendTask(
[this, &is_codec_created]() {
is_codec_created = CreateEncoderAndDecoder();
},
RTC_FROM_HERE);
task_queue->SendTask([this, &is_codec_created]() {
is_codec_created = CreateEncoderAndDecoder();
});
if (!is_codec_created) {
return false;
@ -778,20 +776,17 @@ bool VideoCodecTestFixtureImpl::SetUpAndInitObjects(
encoder_.get(), &decoders_, source_frame_reader_.get(), config_,
&stats_, &encoded_frame_writers_,
decoded_frame_writers_.empty() ? nullptr : &decoded_frame_writers_);
},
RTC_FROM_HERE);
});
return true;
}
void VideoCodecTestFixtureImpl::ReleaseAndCloseObjects(
TaskQueueForTest* task_queue) {
task_queue->SendTask(
[this]() {
processor_.reset();
// The VideoProcessor must be destroyed before the codecs.
DestroyEncoderAndDecoder();
},
RTC_FROM_HERE);
task_queue->SendTask([this]() {
processor_.reset();
// The VideoProcessor must be destroyed before the codecs.
DestroyEncoderAndDecoder();
});
source_frame_reader_->Close();
@ -810,15 +805,13 @@ std::string VideoCodecTestFixtureImpl::GetCodecName(
TaskQueueForTest* task_queue,
bool is_encoder) const {
std::string codec_name;
task_queue->SendTask(
[this, is_encoder, &codec_name] {
if (is_encoder) {
codec_name = encoder_->GetEncoderInfo().implementation_name;
} else {
codec_name = decoders_.at(0)->ImplementationName();
}
},
RTC_FROM_HERE);
task_queue->SendTask([this, is_encoder, &codec_name] {
if (is_encoder) {
codec_name = encoder_->GetEncoderInfo().implementation_name;
} else {
codec_name = decoders_.at(0)->ImplementationName();
}
});
return codec_name;
}

28
modules/video_coding/codecs/test/videoprocessor_unittest.cc
View File

@ -59,12 +59,11 @@ class VideoProcessorTest : public ::testing::Test {
video_processor_ = std::make_unique<VideoProcessor>(
&encoder_mock_, &decoders_, &frame_reader_mock_, config_, &stats_,
&encoded_frame_writers_, /*decoded_frame_writers=*/nullptr);
},
RTC_FROM_HERE);
});
}
~VideoProcessorTest() {
q_.SendTask([this] { video_processor_.reset(); }, RTC_FROM_HERE);
q_.SendTask([this] { video_processor_.reset(); });
}
void ExpectInit() {
@ -106,8 +105,7 @@ TEST_F(VideoProcessorTest, ProcessFrames_FixedFramerate) {
SetRates(Field(&VideoEncoder::RateControlParameters::framerate_fps,
static_cast<double>(kFramerateFps))))
.Times(1);
q_.SendTask([=] { video_processor_->SetRates(kBitrateKbps, kFramerateFps); },
RTC_FROM_HERE);
q_.SendTask([=] { video_processor_->SetRates(kBitrateKbps, kFramerateFps); });
EXPECT_CALL(frame_reader_mock_, ReadFrame())
.WillRepeatedly(Return(I420Buffer::Create(kWidth, kHeight)));
@ -115,13 +113,13 @@ TEST_F(VideoProcessorTest, ProcessFrames_FixedFramerate) {
encoder_mock_,
Encode(Property(&VideoFrame::timestamp, 1 * 90000 / kFramerateFps), _))
.Times(1);
q_.SendTask([this] { video_processor_->ProcessFrame(); }, RTC_FROM_HERE);
q_.SendTask([this] { video_processor_->ProcessFrame(); });
EXPECT_CALL(
encoder_mock_,
Encode(Property(&VideoFrame::timestamp, 2 * 90000 / kFramerateFps), _))
.Times(1);
q_.SendTask([this] { video_processor_->ProcessFrame(); }, RTC_FROM_HERE);
q_.SendTask([this] { video_processor_->ProcessFrame(); });
ExpectRelease();
}
@ -136,15 +134,14 @@ TEST_F(VideoProcessorTest, ProcessFrames_VariableFramerate) {
static_cast<double>(kStartFramerateFps))))
.Times(1);
q_.SendTask(
[=] { video_processor_->SetRates(kBitrateKbps, kStartFramerateFps); },
RTC_FROM_HERE);
[=] { video_processor_->SetRates(kBitrateKbps, kStartFramerateFps); });
EXPECT_CALL(frame_reader_mock_, ReadFrame())
.WillRepeatedly(Return(I420Buffer::Create(kWidth, kHeight)));
EXPECT_CALL(encoder_mock_,
Encode(Property(&VideoFrame::timestamp, kStartTimestamp), _))
.Times(1);
q_.SendTask([this] { video_processor_->ProcessFrame(); }, RTC_FROM_HERE);
q_.SendTask([this] { video_processor_->ProcessFrame(); });
const int kNewFramerateFps = 13;
EXPECT_CALL(
@ -153,15 +150,14 @@ TEST_F(VideoProcessorTest, ProcessFrames_VariableFramerate) {
static_cast<double>(kNewFramerateFps))))
.Times(1);
q_.SendTask(
[=] { video_processor_->SetRates(kBitrateKbps, kNewFramerateFps); },
RTC_FROM_HERE);
[=] { video_processor_->SetRates(kBitrateKbps, kNewFramerateFps); });
EXPECT_CALL(encoder_mock_,
Encode(Property(&VideoFrame::timestamp,
kStartTimestamp + 90000 / kNewFramerateFps),
_))
.Times(1);
q_.SendTask([this] { video_processor_->ProcessFrame(); }, RTC_FROM_HERE);
q_.SendTask([this] { video_processor_->ProcessFrame(); });
ExpectRelease();
}
@ -180,8 +176,7 @@ TEST_F(VideoProcessorTest, SetRates) {
Field(&VideoEncoder::RateControlParameters::framerate_fps,
static_cast<double>(kFramerateFps)))))
.Times(1);
q_.SendTask([=] { video_processor_->SetRates(kBitrateKbps, kFramerateFps); },
RTC_FROM_HERE);
q_.SendTask([=] { video_processor_->SetRates(kBitrateKbps, kFramerateFps); });
const uint32_t kNewBitrateKbps = 456;
const int kNewFramerateFps = 34;
@ -196,8 +191,7 @@ TEST_F(VideoProcessorTest, SetRates) {
static_cast<double>(kNewFramerateFps)))))
.Times(1);
q_.SendTask(
[=] { video_processor_->SetRates(kNewBitrateKbps, kNewFramerateFps); },
RTC_FROM_HERE);
[=] { video_processor_->SetRates(kNewBitrateKbps, kNewFramerateFps); });
ExpectRelease();
}

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

@ -106,13 +106,11 @@ class BandwidthQualityScalerTest
GetDefaultSinglecastBitrateLimitsWhenQpIsUntrusted());
// Only for testing. Set first_timestamp_ in RateStatistics to 0.
bandwidth_quality_scaler_->ReportEncodeInfo(0, 0, 0, 0);
},
RTC_FROM_HERE);
});
}
~BandwidthQualityScalerTest() {
task_queue_.SendTask([this] { bandwidth_quality_scaler_ = nullptr; },
RTC_FROM_HERE);
task_queue_.SendTask([this] { bandwidth_quality_scaler_ = nullptr; });
}
int GetFrameSizeBytes(
@ -180,8 +178,7 @@ class BandwidthQualityScalerTest
config.actual_width, config.actual_height);
}
}
},
RTC_FROM_HERE);
});
}
test::ScopedFieldTrials scoped_field_trial_;

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

@ -75,12 +75,11 @@ class QualityScalerTest : public ::testing::Test,
[this] {
qs_ = std::unique_ptr<QualityScaler>(new QualityScalerUnderTest(
handler_.get(), VideoEncoder::QpThresholds(kLowQp, kHighQp)));
},
RTC_FROM_HERE);
});
}
~QualityScalerTest() override {
task_queue_.SendTask([this] { qs_ = nullptr; }, RTC_FROM_HERE);
task_queue_.SendTask([this] { qs_ = nullptr; });
}
void TriggerScale(ScaleDirection scale_direction) {
@ -119,52 +118,46 @@ INSTANTIATE_TEST_SUITE_P(
"WebRTC-Video-QualityScaling/Disabled/"));
TEST_P(QualityScalerTest, DownscalesAfterContinuousFramedrop) {
task_queue_.SendTask([this] { TriggerScale(kScaleDown); }, RTC_FROM_HERE);
task_queue_.SendTask([this] { TriggerScale(kScaleDown); });
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
}
TEST_P(QualityScalerTest, KeepsScaleAtHighQp) {
task_queue_.SendTask([this] { TriggerScale(kKeepScaleAtHighQp); },
RTC_FROM_HERE);
task_queue_.SendTask([this] { TriggerScale(kKeepScaleAtHighQp); });
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(0, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
}
TEST_P(QualityScalerTest, DownscalesAboveHighQp) {
task_queue_.SendTask([this] { TriggerScale(kScaleDownAboveHighQp); },
RTC_FROM_HERE);
task_queue_.SendTask([this] { TriggerScale(kScaleDownAboveHighQp); });
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
}
TEST_P(QualityScalerTest, DownscalesAfterTwoThirdsFramedrop) {
task_queue_.SendTask(
[this] {
for (int i = 0; i < kFramerate * 5; ++i) {
qs_->ReportDroppedFrameByMediaOpt();
qs_->ReportDroppedFrameByMediaOpt();
qs_->ReportQp(kHighQp, 0);
}
},
RTC_FROM_HERE);
task_queue_.SendTask([this] {
for (int i = 0; i < kFramerate * 5; ++i) {
qs_->ReportDroppedFrameByMediaOpt();
qs_->ReportDroppedFrameByMediaOpt();
qs_->ReportQp(kHighQp, 0);
}
});
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
}
TEST_P(QualityScalerTest, DoesNotDownscaleAfterHalfFramedrop) {
task_queue_.SendTask(
[this] {
for (int i = 0; i < kFramerate * 5; ++i) {
qs_->ReportDroppedFrameByMediaOpt();
qs_->ReportQp(kHighQp, 0);
}
},
RTC_FROM_HERE);
task_queue_.SendTask([this] {
for (int i = 0; i < kFramerate * 5; ++i) {
qs_->ReportDroppedFrameByMediaOpt();
qs_->ReportQp(kHighQp, 0);
}
});
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(0, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
@ -173,98 +166,85 @@ TEST_P(QualityScalerTest, DoesNotDownscaleAfterHalfFramedrop) {
TEST_P(QualityScalerTest, DownscalesAfterTwoThirdsIfFieldTrialEnabled) {
const bool kDownScaleExpected =
GetParam().find("Enabled") != std::string::npos;
task_queue_.SendTask(
[this] {
for (int i = 0; i < kFramerate * 5; ++i) {
qs_->ReportDroppedFrameByMediaOpt();
qs_->ReportDroppedFrameByEncoder();
qs_->ReportQp(kHighQp, 0);
}
},
RTC_FROM_HERE);
task_queue_.SendTask([this] {
for (int i = 0; i < kFramerate * 5; ++i) {
qs_->ReportDroppedFrameByMediaOpt();
qs_->ReportDroppedFrameByEncoder();
qs_->ReportQp(kHighQp, 0);
}
});
EXPECT_EQ(kDownScaleExpected, handler_->event.Wait(kDefaultTimeoutMs));
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); },
RTC_FROM_HERE);
task_queue_.SendTask([this] { TriggerScale(kKeepScaleAboveLowQp); });
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(0, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
}
TEST_P(QualityScalerTest, UpscalesAfterLowQp) {
task_queue_.SendTask([this] { TriggerScale(kScaleUp); }, RTC_FROM_HERE);
task_queue_.SendTask([this] { TriggerScale(kScaleUp); });
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(0, handler_->adapt_down_events_);
EXPECT_EQ(1, handler_->adapt_up_events_);
}
TEST_P(QualityScalerTest, ScalesDownAndBackUp) {
task_queue_.SendTask([this] { TriggerScale(kScaleDown); }, RTC_FROM_HERE);
task_queue_.SendTask([this] { TriggerScale(kScaleDown); });
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
task_queue_.SendTask([this] { TriggerScale(kScaleUp); }, RTC_FROM_HERE);
task_queue_.SendTask([this] { TriggerScale(kScaleUp); });
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(1, handler_->adapt_up_events_);
}
TEST_P(QualityScalerTest, DoesNotScaleUntilEnoughFramesObserved) {
task_queue_.SendTask(
[this] {
// Not enough frames to make a decision.
for (int i = 0; i < kMinFramesNeededToScale - 1; ++i) {
qs_->ReportQp(kLowQp, 0);
}
},
RTC_FROM_HERE);
task_queue_.SendTask([this] {
// Not enough frames to make a decision.
for (int i = 0; i < kMinFramesNeededToScale - 1; ++i) {
qs_->ReportQp(kLowQp, 0);
}
});
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs));
task_queue_.SendTask(
[this] {
// Send 1 more. Enough frames observed, should result in an adapt
// request.
qs_->ReportQp(kLowQp, 0);
},
RTC_FROM_HERE);
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_EQ(0, handler_->adapt_down_events_);
EXPECT_EQ(1, handler_->adapt_up_events_);
// Samples should be cleared after an adapt request.
task_queue_.SendTask(
[this] {
// Not enough frames to make a decision.
qs_->ReportQp(kLowQp, 0);
},
RTC_FROM_HERE);
task_queue_.SendTask([this] {
// Not enough frames to make a decision.
qs_->ReportQp(kLowQp, 0);
});
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(0, handler_->adapt_down_events_);
EXPECT_EQ(1, handler_->adapt_up_events_);
}
TEST_P(QualityScalerTest, ScalesDownAndBackUpWithMinFramesNeeded) {
task_queue_.SendTask(
[this] {
for (int i = 0; i < kMinFramesNeededToScale; ++i) {
qs_->ReportQp(kHighQp + 1, 0);
}
},
RTC_FROM_HERE);
task_queue_.SendTask([this] {
for (int i = 0; i < kMinFramesNeededToScale; ++i) {
qs_->ReportQp(kHighQp + 1, 0);
}
});
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
// Samples cleared.
task_queue_.SendTask(
[this] {
for (int i = 0; i < kMinFramesNeededToScale; ++i) {
qs_->ReportQp(kLowQp, 0);
}
},
RTC_FROM_HERE);
task_queue_.SendTask([this] {
for (int i = 0; i < kMinFramesNeededToScale; ++i) {
qs_->ReportQp(kLowQp, 0);
}
});
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(1, handler_->adapt_up_events_);