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

Create/destroying codecs on task queue + switch to TaskQueueForTest.

Browse Source 
After https://webrtc-review.googlesource.com/c/src/+/70740, we are
creating/destroying the codecs on a task queue in the VideoStreamEncoder. This
CL updates the VideoCodecTest to do the same.

Also, this CL switches from manually Wait()'ing on the task queue to using
TaskQueueForTest::SendTask.

Bug: None
Change-Id: Ia0398b24e32e9cc5361ba5ee4c08441116def18e
Reviewed-on: https://webrtc-review.googlesource.com/76800
Commit-Queue: Rasmus Brandt <brandtr@webrtc.org>
Reviewed-by: Åsa Persson <asapersson@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23257}
This commit is contained in:
Rasmus Brandt
2018-05-16 09:38:42 +02:00
committed by Commit Bot
parent 59130a11b8
commit 8dd4db49e2
4 changed files with 36 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -160,9 +160,9 @@ void VideoCodecTestFixtureImpl::RunTest(
const VisualizationParams* visualization_params) {
RTC_DCHECK(!rate_profiles.empty());
// The Android HW codec needs to be run on a task queue, so we simply always
// run the test on a task queue.
rtc::TaskQueue task_queue("VidProc TQ");
// To emulate operation on a production VideoStreamEncoder, we call the
// codecs on a task queue.
rtc::test::TaskQueueForTest task_queue("VidProc TQ");
SetUpAndInitObjects(
&task_queue, static_cast<const int>(rate_profiles[0].target_kbps),
@ -212,6 +212,7 @@ void VideoCodecTestFixtureImpl::ProcessAllFrames(
}
}
// Wait until we know that the last frame has been sent for encode.
rtc::Event sync_event(false, false);
task_queue->PostTask([&sync_event] { sync_event.Set(); });
sync_event.Wait(rtc::Event::kForever);
@ -397,12 +398,10 @@ Stats VideoCodecTestFixtureImpl::GetStats() {
}
void VideoCodecTestFixtureImpl::SetUpAndInitObjects(
rtc::TaskQueue* task_queue,
rtc::test::TaskQueueForTest* task_queue,
int initial_bitrate_kbps,
int initial_framerate_fps,
const VisualizationParams* visualization_params) {
CreateEncoderAndDecoder();
config_.codec_settings.minBitrate = 0;
config_.codec_settings.startBitrate = initial_bitrate_kbps;
config_.codec_settings.maxFramerate = initial_framerate_fps;
@ -448,29 +447,23 @@ void VideoCodecTestFixtureImpl::SetUpAndInitObjects(
cpu_process_time_.reset(new CpuProcessTime(config_));
rtc::Event sync_event(false, false);
task_queue->PostTask([this, &sync_event]() {
task_queue->SendTask([this]() {
CreateEncoderAndDecoder();
processor_ = rtc::MakeUnique<VideoProcessor>(
encoder_.get(), &decoders_, source_frame_reader_.get(), config_,
&stats_,
encoded_frame_writers_.empty() ? nullptr : &encoded_frame_writers_,
decoded_frame_writers_.empty() ? nullptr : &decoded_frame_writers_);
sync_event.Set();
});
sync_event.Wait(rtc::Event::kForever);
}
void VideoCodecTestFixtureImpl::ReleaseAndCloseObjects(
rtc::TaskQueue* task_queue) {
rtc::Event sync_event(false, false);
task_queue->PostTask([this, &sync_event]() {
rtc::test::TaskQueueForTest* task_queue) {
task_queue->SendTask([this]() {
processor_.reset();
sync_event.Set();
// The VideoProcessor must be destroyed before the codecs.
DestroyEncoderAndDecoder();
});
sync_event.Wait(rtc::Event::kForever);
// The VideoProcessor must be destroyed before the codecs.
DestroyEncoderAndDecoder();
source_frame_reader_->Close();
@ -486,20 +479,17 @@ void VideoCodecTestFixtureImpl::ReleaseAndCloseObjects(
}
void VideoCodecTestFixtureImpl::PrintSettings(
rtc::TaskQueue* task_queue) const {
rtc::test::TaskQueueForTest* task_queue) const {
printf("==> TestConfig\n");
printf("%s\n", config_.ToString().c_str());
printf("==> Codec names\n");
std::string encoder_name;
std::string decoder_name;
rtc::Event sync_event(false, false);
task_queue->PostTask([this, &encoder_name, &decoder_name, &sync_event] {
task_queue->SendTask([this, &encoder_name, &decoder_name] {
encoder_name = encoder_->ImplementationName();
decoder_name = decoders_.at(0)->ImplementationName();
sync_event.Set();
});
sync_event.Wait(rtc::Event::kForever);
printf("enc_impl_name: %s\n", encoder_name.c_str());
printf("dec_impl_name: %s\n", decoder_name.c_str());
if (encoder_name == decoder_name) {

7
modules/video_coding/codecs/test/videocodec_test_fixture_impl.h
View File

@ -24,6 +24,7 @@
#include "modules/video_coding/codecs/test/test_config.h"
#include "modules/video_coding/codecs/test/videoprocessor.h"
#include "modules/video_coding/utility/ivf_file_writer.h"
#include "rtc_base/task_queue_for_test.h"
#include "test/testsupport/frame_reader.h"
#include "test/testsupport/frame_writer.h"
@ -63,11 +64,11 @@ class VideoCodecTestFixtureImpl : public VideoCodecTestFixture {
void CreateEncoderAndDecoder();
void DestroyEncoderAndDecoder();
void SetUpAndInitObjects(rtc::TaskQueue* task_queue,
void SetUpAndInitObjects(rtc::test::TaskQueueForTest* task_queue,
int initial_bitrate_kbps,
int initial_framerate_fps,
const VisualizationParams* visualization_params);
void ReleaseAndCloseObjects(rtc::TaskQueue* task_queue);
void ReleaseAndCloseObjects(rtc::test::TaskQueueForTest* task_queue);
void ProcessAllFrames(rtc::TaskQueue* task_queue,
const std::vector<RateProfile>& rate_profiles);
@ -84,7 +85,7 @@ class VideoCodecTestFixtureImpl : public VideoCodecTestFixture {
size_t target_bitrate_kbps,
float input_framerate_fps);
void PrintSettings(rtc::TaskQueue* task_queue) const;
void PrintSettings(rtc::test::TaskQueueForTest* task_queue) const;
std::unique_ptr<VideoDecoderFactory> CreateDecoderFactory();
std::unique_ptr<VideoEncoderFactory> CreateEncoderFactory();

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

@ -18,7 +18,7 @@
#include "modules/video_coding/include/video_coding.h"
#include "rtc_base/event.h"
#include "rtc_base/ptr_util.h"
#include "rtc_base/task_queue.h"
#include "rtc_base/task_queue_for_test.h"
#include "test/gmock.h"
#include "test/gtest.h"
#include "test/testsupport/mock/mock_frame_reader.h"
@ -39,16 +39,6 @@ const int kFrameSize = kWidth * kHeight * 3 / 2; // I420.
} // namespace
#define DO_SYNC(q, block) \
{ \
rtc::Event event(false, false); \
q.PostTask([&, this] { \
block; \
event.Set(); \
}); \
RTC_CHECK(event.Wait(rtc::Event::kForever)); \
}
class VideoProcessorTest : public testing::Test {
protected:
VideoProcessorTest() : q_("VP queue") {
@ -61,7 +51,7 @@ class VideoProcessorTest : public testing::Test {
ExpectInit();
EXPECT_CALL(frame_reader_mock_, FrameLength())
.WillRepeatedly(Return(kFrameSize));
DO_SYNC(q_, {
q_.SendTask([this] {
video_processor_ = rtc::MakeUnique<VideoProcessor>(
&encoder_mock_, &decoders_, &frame_reader_mock_, config_, &stats_,
nullptr /* encoded_frame_writer */,
@ -70,7 +60,7 @@ class VideoProcessorTest : public testing::Test {
}
~VideoProcessorTest() {
DO_SYNC(q_, { video_processor_.reset(); });
q_.SendTask([this] { video_processor_.reset(); });
}
void ExpectInit() {
@ -87,7 +77,7 @@ class VideoProcessorTest : public testing::Test {
EXPECT_CALL(*decoder_mock_, RegisterDecodeCompleteCallback(_)).Times(1);
}
rtc::TaskQueue q_;
rtc::test::TaskQueueForTest q_;
TestConfig config_;
@ -109,7 +99,7 @@ TEST_F(VideoProcessorTest, ProcessFrames_FixedFramerate) {
EXPECT_CALL(encoder_mock_, SetRateAllocation(_, kFramerateFps))
.Times(1)
.WillOnce(Return(0));
DO_SYNC(q_, { video_processor_->SetRates(kBitrateKbps, kFramerateFps); });
q_.SendTask([=] { video_processor_->SetRates(kBitrateKbps, kFramerateFps); });
EXPECT_CALL(frame_reader_mock_, ReadFrame())
.WillRepeatedly(Return(I420Buffer::Create(kWidth, kHeight)));
@ -117,13 +107,13 @@ TEST_F(VideoProcessorTest, ProcessFrames_FixedFramerate) {
encoder_mock_,
Encode(Property(&VideoFrame::timestamp, 1 * 90000 / kFramerateFps), _, _))
.Times(1);
DO_SYNC(q_, { video_processor_->ProcessFrame(); });
q_.SendTask([this] { video_processor_->ProcessFrame(); });
EXPECT_CALL(
encoder_mock_,
Encode(Property(&VideoFrame::timestamp, 2 * 90000 / kFramerateFps), _, _))
.Times(1);
DO_SYNC(q_, { video_processor_->ProcessFrame(); });
q_.SendTask([this] { video_processor_->ProcessFrame(); });
ExpectRelease();
}
@ -135,28 +125,29 @@ TEST_F(VideoProcessorTest, ProcessFrames_VariableFramerate) {
EXPECT_CALL(encoder_mock_, SetRateAllocation(_, kStartFramerateFps))
.Times(1)
.WillOnce(Return(0));
DO_SYNC(q_,
{ video_processor_->SetRates(kBitrateKbps, kStartFramerateFps); });
q_.SendTask(
[=] { 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);
DO_SYNC(q_, { video_processor_->ProcessFrame(); });
q_.SendTask([this] { video_processor_->ProcessFrame(); });
const int kNewFramerateFps = 13;
EXPECT_CALL(encoder_mock_, SetRateAllocation(_, kNewFramerateFps))
.Times(1)
.WillOnce(Return(0));
DO_SYNC(q_, { video_processor_->SetRates(kBitrateKbps, kNewFramerateFps); });
q_.SendTask(
[=] { video_processor_->SetRates(kBitrateKbps, kNewFramerateFps); });
EXPECT_CALL(encoder_mock_,
Encode(Property(&VideoFrame::timestamp,
kStartTimestamp + 90000 / kNewFramerateFps),
_, _))
.Times(1);
DO_SYNC(q_, { video_processor_->ProcessFrame(); });
q_.SendTask([this] { video_processor_->ProcessFrame(); });
ExpectRelease();
}
@ -169,7 +160,7 @@ TEST_F(VideoProcessorTest, SetRates) {
Property(&VideoBitrateAllocation::get_sum_kbps, kBitrateKbps),
kFramerateFps))
.Times(1);
DO_SYNC(q_, { video_processor_->SetRates(kBitrateKbps, kFramerateFps); });
q_.SendTask([=] { video_processor_->SetRates(kBitrateKbps, kFramerateFps); });
const int kNewBitrateKbps = 456;
const int kNewFramerateFps = 34;
@ -178,8 +169,8 @@ TEST_F(VideoProcessorTest, SetRates) {
kNewBitrateKbps),
kNewFramerateFps))
.Times(1);
DO_SYNC(q_,
{ video_processor_->SetRates(kNewBitrateKbps, kNewFramerateFps); });
q_.SendTask(
[=] { video_processor_->SetRates(kNewBitrateKbps, kNewFramerateFps); });
ExpectRelease();
}