admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Do not transfer ownership of codecs to tester

Browse Source 
Passing of ownership of codecs to tester is not strictly needed. We may need to continue using a codec after test. For example, to check codec state or to use the same codec instance in next test.

Bug: b/261160916, webrtc:14852
Change-Id: I179b262116d7de76b8171f0409f943ad6d87433e
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/291802
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Commit-Queue: Sergey Silkin <ssilkin@webrtc.org>
Reviewed-by: Rasmus Brandt <brandtr@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#39256}
This commit is contained in:
Sergey Silkin 2023-02-03 13:32:24 +01:00 committed by WebRTC LUCI CQ
parent be9b576188
commit c6ff4bc793
5 changed files with 51 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
api/test/video_codec_tester.h
View File

@ -106,25 +106,25 @@ class VideoCodecTester {
// Returns `VideoCodecTestStats` object that contains collected per-frame
// metrics.
virtual std::unique_ptr<VideoCodecStats> RunDecodeTest(
std::unique_ptr<CodedVideoSource> video_source,
std::unique_ptr<Decoder> decoder,
CodedVideoSource* video_source,
Decoder* decoder,
const DecoderSettings& decoder_settings) = 0;
// Pulls raw video frames from `video_source` and passes them to `encoder`.
// Returns `VideoCodecTestStats` object that contains collected per-frame
// metrics.
virtual std::unique_ptr<VideoCodecStats> RunEncodeTest(
std::unique_ptr<RawVideoSource> video_source,
std::unique_ptr<Encoder> encoder,
RawVideoSource* video_source,
Encoder* encoder,
const EncoderSettings& encoder_settings) = 0;
// Pulls raw video frames from `video_source`, passes them to `encoder` and
// then passes encoded frames to `decoder`. Returns `VideoCodecTestStats`
// object that contains collected per-frame metrics.
virtual std::unique_ptr<VideoCodecStats> RunEncodeDecodeTest(
std::unique_ptr<RawVideoSource> video_source,
std::unique_ptr<Encoder> encoder,
std::unique_ptr<Decoder> decoder,
RawVideoSource* video_source,
Encoder* encoder,
Decoder* decoder,
const EncoderSettings& encoder_settings,
const DecoderSettings& decoder_settings) = 0;
};

2
modules/video_coding/codecs/test/video_codec_test.cc
View File

@ -423,7 +423,7 @@ class EncodeDecodeTest
TEST_P(EncodeDecodeTest, DISABLED_TestEncodeDecode) {
std::unique_ptr<VideoCodecStats> stats = tester_->RunEncodeDecodeTest(
std::move(video_source_), std::move(encoder_), std::move(decoder_),
video_source_.get(), encoder_.get(), decoder_.get(),
test_params_.encoder_settings, test_params_.decoder_settings);
const auto& frame_settings = test_params_.encoding_settings.frame_settings;

54
modules/video_coding/codecs/test/video_codec_tester_impl.cc
View File

@ -45,8 +45,8 @@ constexpr Frequency k90kHz = Frequency::Hertz(90000);
// that reads reference frames from a separate thread.
class SyncRawVideoSource : public VideoCodecAnalyzer::ReferenceVideoSource {
public:
explicit SyncRawVideoSource(std::unique_ptr<RawVideoSource> video_source)
: video_source_(std::move(video_source)) {}
explicit SyncRawVideoSource(RawVideoSource* video_source)
: video_source_(video_source) {}
absl::optional<VideoFrame> PullFrame() {
MutexLock lock(&mutex_);
@ -59,7 +59,7 @@ class SyncRawVideoSource : public VideoCodecAnalyzer::ReferenceVideoSource {
}
protected:
std::unique_ptr<RawVideoSource> video_source_ RTC_GUARDED_BY(mutex_);
RawVideoSource* const video_source_ RTC_GUARDED_BY(mutex_);
Mutex mutex_;
};
@ -153,11 +153,11 @@ class LimitedTaskQueue {
class TesterDecoder {
public:
TesterDecoder(std::unique_ptr<Decoder> decoder,
TesterDecoder(Decoder* decoder,
VideoCodecAnalyzer* analyzer,
const DecoderSettings& settings,
rtc::TaskQueue& task_queue)
: decoder_(std::move(decoder)),
: decoder_(decoder),
analyzer_(analyzer),
settings_(settings),
pacer_(settings.pacing),
@ -183,7 +183,7 @@ class TesterDecoder {
void Flush() { task_queue_.WaitForPreviouslyPostedTasks(); }
protected:
std::unique_ptr<Decoder> decoder_;
Decoder* const decoder_;
VideoCodecAnalyzer* const analyzer_;
const DecoderSettings& settings_;
Pacer pacer_;
@ -192,12 +192,12 @@ class TesterDecoder {
class TesterEncoder {
public:
TesterEncoder(std::unique_ptr<Encoder> encoder,
TesterEncoder(Encoder* encoder,
TesterDecoder* decoder,
VideoCodecAnalyzer* analyzer,
const EncoderSettings& settings,
rtc::TaskQueue& task_queue)
: encoder_(std::move(encoder)),
: encoder_(encoder),
decoder_(decoder),
analyzer_(analyzer),
settings_(settings),
@ -225,7 +225,7 @@ class TesterEncoder {
void Flush() { task_queue_.WaitForPreviouslyPostedTasks(); }
protected:
std::unique_ptr<Encoder> encoder_;
Encoder* const encoder_;
TesterDecoder* const decoder_;
VideoCodecAnalyzer* const analyzer_;
const EncoderSettings& settings_;
@ -247,8 +247,8 @@ VideoCodecTesterImpl::VideoCodecTesterImpl(TaskQueueFactory* task_queue_factory)
}
std::unique_ptr<VideoCodecStats> VideoCodecTesterImpl::RunDecodeTest(
std::unique_ptr<CodedVideoSource> video_source,
std::unique_ptr<Decoder> decoder,
CodedVideoSource* video_source,
Decoder* decoder,
const DecoderSettings& decoder_settings) {
rtc::TaskQueue analyser_task_queue(task_queue_factory_->CreateTaskQueue(
"Analyzer", TaskQueueFactory::Priority::NORMAL));
@ -256,8 +256,8 @@ std::unique_ptr<VideoCodecStats> VideoCodecTesterImpl::RunDecodeTest(
"Decoder", TaskQueueFactory::Priority::NORMAL));
VideoCodecAnalyzer perf_analyzer(analyser_task_queue);
TesterDecoder tester_decoder(std::move(decoder), &perf_analyzer,
decoder_settings, decoder_task_queue);
TesterDecoder tester_decoder(decoder, &perf_analyzer, decoder_settings,
decoder_task_queue);
while (auto frame = video_source->PullFrame()) {
tester_decoder.Decode(*frame);
@ -269,19 +269,18 @@ std::unique_ptr<VideoCodecStats> VideoCodecTesterImpl::RunDecodeTest(
}
std::unique_ptr<VideoCodecStats> VideoCodecTesterImpl::RunEncodeTest(
std::unique_ptr<RawVideoSource> video_source,
std::unique_ptr<Encoder> encoder,
RawVideoSource* video_source,
Encoder* encoder,
const EncoderSettings& encoder_settings) {
rtc::TaskQueue analyser_task_queue(task_queue_factory_->CreateTaskQueue(
"Analyzer", TaskQueueFactory::Priority::NORMAL));
rtc::TaskQueue encoder_task_queue(task_queue_factory_->CreateTaskQueue(
"Encoder", TaskQueueFactory::Priority::NORMAL));
SyncRawVideoSource sync_source(std::move(video_source));
SyncRawVideoSource sync_source(video_source);
VideoCodecAnalyzer perf_analyzer(analyser_task_queue);
TesterEncoder tester_encoder(std::move(encoder), /*decoder=*/nullptr,
&perf_analyzer, encoder_settings,
encoder_task_queue);
TesterEncoder tester_encoder(encoder, /*decoder=*/nullptr, &perf_analyzer,
encoder_settings, encoder_task_queue);
while (auto frame = sync_source.PullFrame()) {
tester_encoder.Encode(*frame);
@ -293,9 +292,9 @@ std::unique_ptr<VideoCodecStats> VideoCodecTesterImpl::RunEncodeTest(
}
std::unique_ptr<VideoCodecStats> VideoCodecTesterImpl::RunEncodeDecodeTest(
std::unique_ptr<RawVideoSource> video_source,
std::unique_ptr<Encoder> encoder,
std::unique_ptr<Decoder> decoder,
RawVideoSource* video_source,
Encoder* encoder,
Decoder* decoder,
const EncoderSettings& encoder_settings,
const DecoderSettings& decoder_settings) {
rtc::TaskQueue analyser_task_queue(task_queue_factory_->CreateTaskQueue(
@ -305,13 +304,12 @@ std::unique_ptr<VideoCodecStats> VideoCodecTesterImpl::RunEncodeDecodeTest(
rtc::TaskQueue encoder_task_queue(task_queue_factory_->CreateTaskQueue(
"Encoder", TaskQueueFactory::Priority::NORMAL));
SyncRawVideoSource sync_source(std::move(video_source));
SyncRawVideoSource sync_source(video_source);
VideoCodecAnalyzer perf_analyzer(analyser_task_queue, &sync_source);
TesterDecoder tester_decoder(std::move(decoder), &perf_analyzer,
decoder_settings, decoder_task_queue);
TesterEncoder tester_encoder(std::move(encoder), &tester_decoder,
&perf_analyzer, encoder_settings,
encoder_task_queue);
TesterDecoder tester_decoder(decoder, &perf_analyzer, decoder_settings,
decoder_task_queue);
TesterEncoder tester_encoder(encoder, &tester_decoder, &perf_analyzer,
encoder_settings, encoder_task_queue);
while (auto frame = sync_source.PullFrame()) {
tester_encoder.Encode(*frame);

14
modules/video_coding/codecs/test/video_codec_tester_impl.h
View File

@ -26,19 +26,19 @@ class VideoCodecTesterImpl : public VideoCodecTester {
explicit VideoCodecTesterImpl(TaskQueueFactory* task_queue_factory);
std::unique_ptr<VideoCodecStats> RunDecodeTest(
std::unique_ptr<CodedVideoSource> video_source,
std::unique_ptr<Decoder> decoder,
CodedVideoSource* video_source,
Decoder* decoder,
const DecoderSettings& decoder_settings) override;
std::unique_ptr<VideoCodecStats> RunEncodeTest(
std::unique_ptr<RawVideoSource> video_source,
std::unique_ptr<Encoder> encoder,
RawVideoSource* video_source,
Encoder* encoder,
const EncoderSettings& encoder_settings) override;
std::unique_ptr<VideoCodecStats> RunEncodeDecodeTest(
std::unique_ptr<RawVideoSource> video_source,
std::unique_ptr<Encoder> encoder,
std::unique_ptr<Decoder> decoder,
RawVideoSource* video_source,
Encoder* encoder,
Decoder* decoder,
const EncoderSettings& encoder_settings,
const DecoderSettings& decoder_settings) override;

24
modules/video_coding/codecs/test/video_codec_tester_impl_unittest.cc
View File

@ -149,10 +149,10 @@ class VideoCodecTesterImplPacingTest
};
TEST_P(VideoCodecTesterImplPacingTest, PaceEncode) {
auto video_source = std::make_unique<MockRawVideoSource>();
MockRawVideoSource video_source;
size_t frame_num = 0;
EXPECT_CALL(*video_source, PullFrame).WillRepeatedly(Invoke([&]() mutable {
EXPECT_CALL(video_source, PullFrame).WillRepeatedly(Invoke([&]() mutable {
if (frame_num >= num_frames_) {
return absl::optional<VideoFrame>();
}
@ -164,15 +164,13 @@ TEST_P(VideoCodecTesterImplPacingTest, PaceEncode) {
return absl::optional<VideoFrame>(CreateVideoFrame(timestamp_rtp));
}));
auto encoder = std::make_unique<MockEncoder>();
MockEncoder encoder;
EncoderSettings encoder_settings;
encoder_settings.pacing = pacing_settings_;
VideoCodecTesterImpl tester(&task_queue_factory_);
auto fs = tester
.RunEncodeTest(std::move(video_source), std::move(encoder),
encoder_settings)
->Slice();
auto fs =
tester.RunEncodeTest(&video_source, &encoder, encoder_settings)->Slice();
ASSERT_EQ(fs.size(), num_frames_);
for (size_t i = 0; i < fs.size(); ++i) {
@ -182,10 +180,10 @@ TEST_P(VideoCodecTesterImplPacingTest, PaceEncode) {
}
TEST_P(VideoCodecTesterImplPacingTest, PaceDecode) {
auto video_source = std::make_unique<MockCodedVideoSource>();
MockCodedVideoSource video_source;
size_t frame_num = 0;
EXPECT_CALL(*video_source, PullFrame).WillRepeatedly(Invoke([&]() mutable {
EXPECT_CALL(video_source, PullFrame).WillRepeatedly(Invoke([&]() mutable {
if (frame_num >= num_frames_) {
return absl::optional<EncodedImage>();
}
@ -197,15 +195,13 @@ TEST_P(VideoCodecTesterImplPacingTest, PaceDecode) {
return absl::optional<EncodedImage>(CreateEncodedImage(timestamp_rtp));
}));
auto decoder = std::make_unique<MockDecoder>();
MockDecoder decoder;
DecoderSettings decoder_settings;
decoder_settings.pacing = pacing_settings_;
VideoCodecTesterImpl tester(&task_queue_factory_);
auto fs = tester
.RunDecodeTest(std::move(video_source), std::move(decoder),
decoder_settings)
->Slice();
auto fs =
tester.RunDecodeTest(&video_source, &decoder, decoder_settings)->Slice();
ASSERT_EQ(fs.size(), num_frames_);
for (size_t i = 0; i < fs.size(); ++i) {