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

Migrate WebRTC on FrameGeneratorInterface and remove FrameGenerator class

Browse Source 
Bug: webrtc:10138
Change-Id: If85290581a72f81cf60181de7a7134cc9db7716e
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/161327
Reviewed-by: Niels Moller <nisse@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Commit-Queue: Artem Titov <titovartem@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#30033}
This commit is contained in:
Artem Titov 2019-12-05 15:59:00 +01:00 committed by Commit Bot
parent af51be7869
commit 33f9d2b383
43 changed files with 793 additions and 692 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
api/BUILD.gn
View File

@ -449,6 +449,7 @@ if (rtc_include_tests) {
"../test/pc/e2e:peerconnection_quality_test",
]
}
}
rtc_library("create_frame_generator") {
visibility = [ "*" ]
@ -459,13 +460,12 @@ if (rtc_include_tests) {
]
deps = [
":frame_generator_api",
"../rtc_base:checks",
"../system_wrappers",
"../test:video_test_common",
"../test:video_test_support",
"../test:frame_generator_impl",
"//third_party/abseil-cpp/absl/types:optional",
]
}
}
rtc_source_set("libjingle_logging_api") {
visibility = [ "*" ]

40
api/test/create_frame_generator.cc
View File

@ -10,8 +10,10 @@
#include "api/test/create_frame_generator.h"
#include <cstdio>
#include <utility>
#include "rtc_base/checks.h"
#include "test/frame_generator.h"
#include "test/testsupport/ivf_video_frame_generator.h"
@ -23,22 +25,31 @@ std::unique_ptr<FrameGeneratorInterface> CreateSquareFrameGenerator(
int height,
absl::optional<FrameGeneratorInterface::OutputType> type,
absl::optional<int> num_squares) {
return FrameGenerator::CreateSquareGenerator(width, height, type,
num_squares);
return std::make_unique<SquareGenerator>(
width, height, type.value_or(FrameGeneratorInterface::OutputType::kI420),
num_squares.value_or(10));
}
std::unique_ptr<FrameGeneratorInterface> CreateFromYuvFileFrameGenerator(
std::vector<std::string> files,
std::vector<std::string> filenames,
size_t width,
size_t height,
int frame_repeat_count) {
return FrameGenerator::CreateFromYuvFile(std::move(files), width, height,
RTC_DCHECK(!filenames.empty());
std::vector<FILE*> files;
for (const std::string& filename : filenames) {
FILE* file = fopen(filename.c_str(), "rb");
RTC_DCHECK(file != nullptr) << "Failed to open: '" << filename << "'\n";
files.push_back(file);
}
return std::make_unique<YuvFileGenerator>(files, width, height,
frame_repeat_count);
}
std::unique_ptr<FrameGeneratorInterface> CreateFromIvfFileFrameGenerator(
std::string file) {
return std::make_unique<IvfVideoFrameGenerator>(std::move(file));
std::string filename) {
return std::make_unique<IvfVideoFrameGenerator>(std::move(filename));
}
std::unique_ptr<FrameGeneratorInterface>
@ -51,15 +62,22 @@ CreateScrollingInputFromYuvFilesFrameGenerator(
size_t target_height,
int64_t scroll_time_ms,
int64_t pause_time_ms) {
return FrameGenerator::CreateScrollingInputFromYuvFiles(
clock, std::move(filenames), source_width, source_height, target_width,
target_height, scroll_time_ms, pause_time_ms);
RTC_DCHECK(!filenames.empty());
std::vector<FILE*> files;
for (const std::string& filename : filenames) {
FILE* file = fopen(filename.c_str(), "rb");
RTC_DCHECK(file != nullptr);
files.push_back(file);
}
return std::make_unique<ScrollingImageFrameGenerator>(
clock, files, source_width, source_height, target_width, target_height,
scroll_time_ms, pause_time_ms);
}
std::unique_ptr<FrameGeneratorInterface>
CreateSlideFrameGenerator(int width, int height, int frame_repeat_count) {
return FrameGenerator::CreateSlideGenerator(width, height,
frame_repeat_count);
return std::make_unique<SlideGenerator>(width, height, frame_repeat_count);
}
} // namespace test

4
api/test/create_frame_generator.h
View File

@ -36,14 +36,14 @@ std::unique_ptr<FrameGeneratorInterface> CreateSquareFrameGenerator(
// The frame_repeat_count determines how many times each frame is shown,
// with 1 = show each frame once, etc.
std::unique_ptr<FrameGeneratorInterface> CreateFromYuvFileFrameGenerator(
std::vector<std::string> files,
std::vector<std::string> filenames,
size_t width,
size_t height,
int frame_repeat_count);
// Creates a frame generator that repeatedly plays an ivf file.
std::unique_ptr<FrameGeneratorInterface> CreateFromIvfFileFrameGenerator(
std::string file);
std::string filename);
// Creates a frame generator which takes a set of yuv files (wrapping a
// frame generator created by CreateFromYuvFile() above), but outputs frames

1
call/BUILD.gn
View File

@ -382,6 +382,7 @@ if (rtc_include_tests) {
":rtp_sender",
":simulated_network",
"../api:array_view",
"../api:create_frame_generator",
"../api:mock_audio_mixer",
"../api:rtp_headers",
"../api:rtp_parameters",

5
call/bitrate_estimator_tests.cc
View File

@ -12,6 +12,7 @@
#include <memory>
#include <string>
#include "api/test/create_frame_generator.h"
#include "call/call.h"
#include "call/fake_network_pipe.h"
#include "call/simulated_network.h"
@ -180,8 +181,8 @@ class BitrateEstimatorTest : public test::CallTest {
frame_generator_capturer_ =
std::make_unique<test::FrameGeneratorCapturer>(
test->clock_,
test::FrameGenerator::CreateSquareGenerator(
kDefaultWidth, kDefaultHeight, absl::nullopt, absl::nullopt),
test::CreateSquareFrameGenerator(kDefaultWidth, kDefaultHeight,
absl::nullopt, absl::nullopt),
kDefaultFramerate, *test->task_queue_factory_);
frame_generator_capturer_->Init();
send_stream_->SetSource(frame_generator_capturer_.get(),

1
call/call_perf_tests.cc
View File

@ -38,7 +38,6 @@
#include "test/encoder_settings.h"
#include "test/fake_encoder.h"
#include "test/field_trial.h"
#include "test/frame_generator.h"
#include "test/frame_generator_capturer.h"
#include "test/gtest.h"
#include "test/null_transport.h"

1
common_video/BUILD.gn
View File

@ -110,6 +110,7 @@ if (rtc_include_tests) {
"../rtc_base:rtc_base_tests_utils",
"../system_wrappers:system_wrappers",
"../test:fileutils",
"../test:frame_utils",
"../test:test_main",
"../test:test_support",
"../test:video_test_common",

2
media/engine/webrtc_video_engine_unittest.cc
View File

@ -60,7 +60,7 @@
#include "rtc_base/time_utils.h"
#include "test/fake_decoder.h"
#include "test/field_trial.h"
#include "test/frame_generator.h"
#include "test/frame_forwarder.h"
#include "test/gmock.h"
#include "test/rtp_header_parser.h"

1
modules/video_capture/BUILD.gn
View File

@ -132,6 +132,7 @@ if (!build_with_chromium) {
"../../common_video",
"../../rtc_base:rtc_base_approved",
"../../system_wrappers",
"../../test:frame_utils",
"../../test:test_support",
"../../test:video_test_common",
"../utility",

4
modules/video_coding/BUILD.gn
View File

@ -614,6 +614,8 @@ if (rtc_include_tests) {
":videocodec_test_stats_impl",
":webrtc_vp9_helpers",
"..:module_api",
"../../api:create_frame_generator",
"../../api:frame_generator_api",
"../../api:scoped_refptr",
"../../api:videocodec_test_fixture_api",
"../../api/task_queue",
@ -759,7 +761,9 @@ if (rtc_include_tests) {
":webrtc_vp9",
":webrtc_vp9_helpers",
"../..:webrtc_common",
"../../api:create_frame_generator",
"../../api:create_videocodec_test_fixture_api",
"../../api:frame_generator_api",
"../../api:mock_video_codec_factory",
"../../api:mock_video_decoder",
"../../api:mock_video_encoder",

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

@ -12,6 +12,7 @@
#include <utility>
#include "api/test/create_frame_generator.h"
#include "api/video_codecs/video_encoder.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "modules/video_coding/include/video_error_codes.h"
@ -73,9 +74,9 @@ void VideoCodecUnitTest::SetUp() {
ModifyCodecSettings(&codec_settings_);
input_frame_generator_ = test::FrameGenerator::CreateSquareGenerator(
input_frame_generator_ = test::CreateSquareFrameGenerator(
codec_settings_.width, codec_settings_.height,
test::FrameGenerator::OutputType::kI420, absl::optional<int>());
test::FrameGeneratorInterface::OutputType::kI420, absl::optional<int>());
encoder_ = CreateEncoder();
decoder_ = CreateDecoder();
@ -94,7 +95,7 @@ void VideoCodecUnitTest::SetUp() {
void VideoCodecUnitTest::ModifyCodecSettings(VideoCodec* codec_settings) {}
VideoFrame VideoCodecUnitTest::NextInputFrame() {
test::FrameGenerator::VideoFrameData frame_data =
test::FrameGeneratorInterface::VideoFrameData frame_data =
input_frame_generator_->NextFrame();
VideoFrame input_frame = VideoFrame::Builder()
.set_video_frame_buffer(frame_data.buffer)

4
modules/video_coding/codecs/test/video_codec_unittest.h
View File

@ -14,6 +14,7 @@
#include <memory>
#include <vector>
#include "api/test/frame_generator_interface.h"
#include "api/video_codecs/video_decoder.h"
#include "api/video_codecs/video_encoder.h"
#include "modules/video_coding/include/video_codec_interface.h"
@ -22,7 +23,6 @@
#include "rtc_base/critical_section.h"
#include "rtc_base/event.h"
#include "rtc_base/thread_annotations.h"
#include "test/frame_generator.h"
#include "test/gtest.h"
namespace webrtc {
@ -101,7 +101,7 @@ class VideoCodecUnitTest : public ::testing::Test {
std::unique_ptr<VideoEncoder> encoder_;
std::unique_ptr<VideoDecoder> decoder_;
std::unique_ptr<test::FrameGenerator> input_frame_generator_;
std::unique_ptr<test::FrameGeneratorInterface> input_frame_generator_;
private:
FakeEncodeCompleteCallback encode_complete_callback_;

6
modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
View File

@ -12,6 +12,8 @@
#include <memory>
#include "api/test/create_frame_generator.h"
#include "api/test/frame_generator_interface.h"
#include "api/test/mock_video_decoder.h"
#include "api/test/mock_video_encoder.h"
#include "api/video_codecs/video_encoder.h"
@ -487,9 +489,9 @@ TEST_F(TestVp8Impl, DontDropKeyframes) {
// Reset the frame generator with large number of squares, leading to lots of
// details and high probability of overshoot.
input_frame_generator_ = test::FrameGenerator::CreateSquareGenerator(
input_frame_generator_ = test::CreateSquareFrameGenerator(
codec_settings_.width, codec_settings_.height,
test::FrameGenerator::OutputType::kI420,
test::FrameGeneratorInterface::OutputType::kI420,
/* num_squares = */ absl::optional<int>(300));
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,

7
modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
View File

@ -8,6 +8,8 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "api/test/create_frame_generator.h"
#include "api/test/frame_generator_interface.h"
#include "api/video/color_space.h"
#include "api/video/i420_buffer.h"
#include "api/video_codecs/video_encoder.h"
@ -1616,9 +1618,10 @@ class TestVp9ImplProfile2 : public TestVp9Impl {
return;
TestVp9Impl::SetUp();
input_frame_generator_ = test::FrameGenerator::CreateSquareGenerator(
input_frame_generator_ = test::CreateSquareFrameGenerator(
codec_settings_.width, codec_settings_.height,
test::FrameGenerator::OutputType::kI010, absl::optional<int>());
test::FrameGeneratorInterface::OutputType::kI010,
absl::optional<int>());
}
std::unique_ptr<VideoEncoder> CreateEncoder() override {

1
modules/video_processing/BUILD.gn
View File

@ -112,6 +112,7 @@ if (rtc_include_tests) {
"../../api/video:video_rtp_headers",
"../../common_video",
"../../test:fileutils",
"../../test:frame_utils",
"../../test:test_support",
"../../test:video_test_common",
]

1
pc/BUILD.gn
View File

@ -466,6 +466,7 @@ if (rtc_include_tests) {
":peerconnection",
":rtc_pc_base",
"../api:audio_options_api",
"../api:create_frame_generator",
"../api:create_peerconnection_factory",
"../api:libjingle_peerconnection_api",
"../api:media_stream_interface",

5
pc/test/frame_generator_capturer_video_track_source.h
View File

@ -16,6 +16,7 @@
#include "api/task_queue/default_task_queue_factory.h"
#include "api/task_queue/task_queue_factory.h"
#include "api/test/create_frame_generator.h"
#include "pc/video_track_source.h"
#include "test/frame_generator_capturer.h"
@ -47,8 +48,8 @@ class FrameGeneratorCapturerVideoTrackSource : public VideoTrackSource {
is_screencast_(is_screencast) {
video_capturer_ = std::make_unique<test::FrameGeneratorCapturer>(
clock,
test::FrameGenerator::CreateSquareGenerator(
config.width, config.height, absl::nullopt,
test::CreateSquareFrameGenerator(config.width, config.height,
absl::nullopt,
config.num_squares_generated),
config.frames_per_second, *task_queue_factory_);
video_capturer_->Init();

1
rtc_tools/BUILD.gn
View File

@ -153,6 +153,7 @@ if (!build_with_chromium) {
]
deps = [
"../api:create_frame_generator",
"../api:rtp_parameters",
"../api:transport_api",
"../api/rtc_event_log",

5
rtc_tools/rtp_generator/rtp_generator.cc
View File

@ -15,6 +15,7 @@
#include <utility>
#include "api/task_queue/default_task_queue_factory.h"
#include "api/test/create_frame_generator.h"
#include "api/video_codecs/builtin_video_decoder_factory.h"
#include "api/video_codecs/builtin_video_encoder_factory.h"
#include "api/video_codecs/video_encoder.h"
@ -224,8 +225,8 @@ RtpGenerator::RtpGenerator(const RtpGeneratorOptions& options)
std::unique_ptr<test::FrameGeneratorCapturer> frame_generator =
std::make_unique<test::FrameGeneratorCapturer>(
Clock::GetRealTimeClock(),
test::FrameGenerator::CreateSquareGenerator(
send_config.video_width, send_config.video_height,
test::CreateSquareFrameGenerator(send_config.video_width,
send_config.video_height,
absl::nullopt, absl::nullopt),
send_config.video_fps, *task_queue_);
frame_generator->Init();

1
rtc_tools/rtp_generator/rtp_generator.h
View File

@ -28,7 +28,6 @@
#include "call/video_send_stream.h"
#include "media/engine/webrtc_video_engine.h"
#include "rtc_base/constructor_magic.h"
#include "test/frame_generator.h"
#include "test/frame_generator_capturer.h"
#include "test/rtp_file_reader.h"
#include "test/rtp_file_writer.h"

71
test/BUILD.gn
View File

@ -34,18 +34,71 @@ group("test") {
}
}
rtc_library("frame_generator_impl") {
visibility = [
"../api:create_frame_generator",
":*",
]
testonly = true
sources = [
"frame_generator.cc",
"frame_generator.h",
"testsupport/ivf_video_frame_generator.cc",
"testsupport/ivf_video_frame_generator.h",
]
deps = [
":frame_utils",
"../api:frame_generator_api",
"../api:scoped_refptr",
"../api/video:encoded_image",
"../api/video:video_frame",
"../api/video:video_frame_i010",
"../api/video:video_frame_i420",
"../api/video:video_rtp_headers",
"../api/video_codecs:video_codecs_api",
"../common_video",
"../media:rtc_media_base",
"../modules/video_coding:video_codec_interface",
"../modules/video_coding:video_coding_utility",
"../modules/video_coding:webrtc_h264",
"../modules/video_coding:webrtc_vp8",
"../modules/video_coding:webrtc_vp9",
"../rtc_base",
"../rtc_base:checks",
"../rtc_base:criticalsection",
"../rtc_base:rtc_base_approved",
"../rtc_base:rtc_event",
"../rtc_base/synchronization:sequence_checker",
"../rtc_base/system:file_wrapper",
"../system_wrappers",
"//third_party/abseil-cpp/absl/types:optional",
]
}
rtc_library("frame_utils") {
visibility = [ "*" ]
testonly = true
sources = [
"frame_utils.cc",
"frame_utils.h",
]
deps = [
"../api:scoped_refptr",
"../api/video:video_frame",
"../api/video:video_frame_i420",
]
}
rtc_library("video_test_common") {
visibility = [ "*" ]
testonly = true
sources = [
"fake_texture_frame.cc",
"fake_texture_frame.h",
"frame_generator.cc",
"frame_generator.h",
"frame_forwarder.cc",
"frame_forwarder.h",
"frame_generator_capturer.cc",
"frame_generator_capturer.h",
"frame_utils.cc",
"frame_utils.h",
"test_video_capturer.cc",
"test_video_capturer.h",
"video_codec_settings.h",
@ -53,6 +106,8 @@ rtc_library("video_test_common") {
deps = [
":fileutils",
":frame_utils",
"../api:create_frame_generator",
"../api:frame_generator_api",
"../api:scoped_refptr",
"../api/task_queue",
@ -293,8 +348,6 @@ if (rtc_include_tests) {
sources = [
"testsupport/frame_reader.h",
"testsupport/frame_writer.h",
"testsupport/ivf_video_frame_generator.cc",
"testsupport/ivf_video_frame_generator.h",
"testsupport/mock/mock_frame_reader.h",
"testsupport/video_frame_writer.cc",
"testsupport/video_frame_writer.h",
@ -306,6 +359,7 @@ if (rtc_include_tests) {
deps = [
":fileutils",
":frame_utils",
":test_support",
":video_test_common",
"../api:scoped_refptr",
@ -385,6 +439,7 @@ if (rtc_include_tests) {
":fake_video_codecs",
":fileutils",
":fileutils_unittests",
":frame_generator_impl",
":perf_test",
":rtc_expect_death",
":rtp_test_utils",
@ -393,7 +448,9 @@ if (rtc_include_tests) {
":test_support_test_artifacts",
":video_test_common",
":video_test_support",
"../api:create_frame_generator",
"../api:create_simulcast_test_fixture_api",
"../api:frame_generator_api",
"../api:scoped_refptr",
"../api:simulcast_test_fixture_api",
"../api/task_queue:task_queue_test",
@ -764,6 +821,8 @@ rtc_library("test_common") {
":rtp_test_utils",
":test_support",
":video_test_common",
"../api:create_frame_generator",
"../api:frame_generator_api",
"../api:rtp_headers",
"../api:rtp_parameters",
"../api:simulated_network_api",

9
test/call_test.cc
View File

@ -17,6 +17,7 @@
#include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/task_queue/default_task_queue_factory.h"
#include "api/task_queue/task_queue_base.h"
#include "api/test/create_frame_generator.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "api/video_codecs/video_encoder_config.h"
#include "call/fake_network_pipe.h"
@ -468,8 +469,8 @@ void CallTest::CreateFrameGeneratorCapturerWithDrift(Clock* clock,
auto frame_generator_capturer =
std::make_unique<test::FrameGeneratorCapturer>(
clock,
test::FrameGenerator::CreateSquareGenerator(
width, height, absl::nullopt, absl::nullopt),
test::CreateSquareFrameGenerator(width, height, absl::nullopt,
absl::nullopt),
framerate * speed, *task_queue_factory_);
frame_generator_capturer_ = frame_generator_capturer.get();
frame_generator_capturer->Init();
@ -484,8 +485,8 @@ void CallTest::CreateFrameGeneratorCapturer(int framerate,
auto frame_generator_capturer =
std::make_unique<test::FrameGeneratorCapturer>(
clock_,
test::FrameGenerator::CreateSquareGenerator(
width, height, absl::nullopt, absl::nullopt),
test::CreateSquareFrameGenerator(width, height, absl::nullopt,
absl::nullopt),
framerate, *task_queue_factory_);
frame_generator_capturer_ = frame_generator_capturer.get();
frame_generator_capturer->Init();

51
test/frame_forwarder.cc Normal file
View File

@ -0,0 +1,51 @@
/*
* Copyright (c) 2019 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "test/frame_forwarder.h"
#include "rtc_base/checks.h"
namespace webrtc {
namespace test {
FrameForwarder::FrameForwarder() : sink_(nullptr) {}
FrameForwarder::~FrameForwarder() {}
void FrameForwarder::IncomingCapturedFrame(const VideoFrame& video_frame) {
rtc::CritScope lock(&crit_);
if (sink_)
sink_->OnFrame(video_frame);
}
void FrameForwarder::AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
const rtc::VideoSinkWants& wants) {
rtc::CritScope lock(&crit_);
RTC_DCHECK(!sink_ || sink_ == sink);
sink_ = sink;
sink_wants_ = wants;
}
void FrameForwarder::RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) {
rtc::CritScope lock(&crit_);
RTC_DCHECK_EQ(sink, sink_);
sink_ = nullptr;
}
rtc::VideoSinkWants FrameForwarder::sink_wants() const {
rtc::CritScope lock(&crit_);
return sink_wants_;
}
bool FrameForwarder::has_sinks() const {
rtc::CritScope lock(&crit_);
return sink_ != nullptr;
}
} // namespace test
} // namespace webrtc

46
test/frame_forwarder.h Normal file
View File

@ -0,0 +1,46 @@
/*
* Copyright (c) 2019 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef TEST_FRAME_FORWARDER_H_
#define TEST_FRAME_FORWARDER_H_
#include "api/video/video_frame.h"
#include "api/video/video_source_interface.h"
#include "rtc_base/critical_section.h"
namespace webrtc {
namespace test {
// FrameForwarder can be used as an implementation
// of rtc::VideoSourceInterface<VideoFrame> where the caller controls when
// a frame should be forwarded to its sink.
// Currently this implementation only support one sink.
class FrameForwarder : public rtc::VideoSourceInterface<VideoFrame> {
public:
FrameForwarder();
~FrameForwarder() override;
// Forwards |video_frame| to the registered |sink_|.
virtual void IncomingCapturedFrame(const VideoFrame& video_frame);
rtc::VideoSinkWants sink_wants() const;
bool has_sinks() const;
protected:
void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
const rtc::VideoSinkWants& wants) override;
void RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) override;
rtc::CriticalSection crit_;
rtc::VideoSinkInterface<VideoFrame>* sink_ RTC_GUARDED_BY(crit_);
rtc::VideoSinkWants sink_wants_ RTC_GUARDED_BY(crit_);
};
} // namespace test
} // namespace webrtc
#endif // TEST_FRAME_FORWARDER_H_

242
test/frame_generator.cc
View File

@ -15,18 +15,13 @@
#include <cstdio>
#include <memory>
#include "api/scoped_refptr.h"
#include "api/video/i010_buffer.h"
#include "api/video/i420_buffer.h"
#include "api/video/video_frame_buffer.h"
#include "api/video/video_rotation.h"
#include "common_video/include/video_frame_buffer.h"
#include "common_video/libyuv/include/webrtc_libyuv.h"
#include "rtc_base/bind.h"
#include "rtc_base/checks.h"
#include "rtc_base/keep_ref_until_done.h"
#include "rtc_base/random.h"
#include "system_wrappers/include/clock.h"
#include "test/frame_utils.h"
namespace webrtc {
@ -37,12 +32,12 @@ namespace {
void KeepBufferRefs(rtc::scoped_refptr<webrtc::VideoFrameBuffer>,
rtc::scoped_refptr<webrtc::VideoFrameBuffer>) {}
// SquareGenerator is a FrameGenerator that draws a given amount of randomly
// sized and colored squares. Between each new generated frame, the squares
// are moved slightly towards the lower right corner.
class SquareGenerator : public FrameGenerator {
public:
SquareGenerator(int width, int height, OutputType type, int num_squares)
} // namespace
SquareGenerator::SquareGenerator(int width,
int height,
OutputType type,
int num_squares)
: type_(type) {
ChangeResolution(width, height);
for (int i = 0; i < num_squares; ++i) {
@ -50,7 +45,7 @@ class SquareGenerator : public FrameGenerator {
}
}
void ChangeResolution(size_t width, size_t height) override {
void SquareGenerator::ChangeResolution(size_t width, size_t height) {
rtc::CritScope lock(&crit_);
width_ = static_cast<int>(width);
height_ = static_cast<int>(height);
@ -58,7 +53,8 @@ class SquareGenerator : public FrameGenerator {
RTC_CHECK(height_ > 0);
}
rtc::scoped_refptr<I420Buffer> CreateI420Buffer(int width, int height) {
rtc::scoped_refptr<I420Buffer> SquareGenerator::CreateI420Buffer(int width,
int height) {
rtc::scoped_refptr<I420Buffer> buffer(I420Buffer::Create(width, height));
memset(buffer->MutableDataY(), 127, height * buffer->StrideY());
memset(buffer->MutableDataU(), 127,
@ -68,7 +64,7 @@ class SquareGenerator : public FrameGenerator {
return buffer;
}
VideoFrameData NextFrame() override {
FrameGeneratorInterface::VideoFrameData SquareGenerator::NextFrame() {
rtc::CritScope lock(&crit_);
rtc::scoped_refptr<VideoFrameBuffer> buffer = nullptr;
@ -105,10 +101,7 @@ class SquareGenerator : public FrameGenerator {
return VideoFrameData(buffer, absl::nullopt);
}
private:
class Square {
public:
Square(int width, int height, int seed)
SquareGenerator::Square::Square(int width, int height, int seed)
: random_generator_(seed),
x_(random_generator_.Rand(0, width)),
y_(random_generator_.Rand(0, height)),
@ -118,15 +111,16 @@ class SquareGenerator : public FrameGenerator {
yuv_v_(random_generator_.Rand(0, 255)),
yuv_a_(random_generator_.Rand(0, 255)) {}
void Draw(const rtc::scoped_refptr<VideoFrameBuffer>& frame_buffer) {
void SquareGenerator::Square::Draw(
const rtc::scoped_refptr<VideoFrameBuffer>& frame_buffer) {
RTC_DCHECK(frame_buffer->type() == VideoFrameBuffer::Type::kI420 ||
frame_buffer->type() == VideoFrameBuffer::Type::kI420A);
rtc::scoped_refptr<I420BufferInterface> buffer = frame_buffer->ToI420();
x_ = (x_ + random_generator_.Rand(0, 4)) % (buffer->width() - length_);
y_ = (y_ + random_generator_.Rand(0, 4)) % (buffer->height() - length_);
for (int y = y_; y < y_ + length_; ++y) {
uint8_t* pos_y = (const_cast<uint8_t*>(buffer->DataY()) + x_ +
y * buffer->StrideY());
uint8_t* pos_y =
(const_cast<uint8_t*>(buffer->DataY()) + x_ + y * buffer->StrideY());
memset(pos_y, yuv_y_, length_);
}
@ -143,8 +137,7 @@ class SquareGenerator : public FrameGenerator {
return;
// Optionally draw on alpha plane if given.
const webrtc::I420ABufferInterface* yuva_buffer =
frame_buffer->GetI420A();
const webrtc::I420ABufferInterface* yuva_buffer = frame_buffer->GetI420A();
for (int y = y_; y < y_ + length_; ++y) {
uint8_t* pos_y = (const_cast<uint8_t*>(yuva_buffer->DataA()) + x_ +
y * yuva_buffer->StrideA());
@ -152,27 +145,7 @@ class SquareGenerator : public FrameGenerator {
}
}
private:
Random random_generator_;
int x_;
int y_;
const int length_;
const uint8_t yuv_y_;
const uint8_t yuv_u_;
const uint8_t yuv_v_;
const uint8_t yuv_a_;
};
rtc::CriticalSection crit_;
const OutputType type_;
int width_ RTC_GUARDED_BY(&crit_);
int height_ RTC_GUARDED_BY(&crit_);
std::vector<std::unique_ptr<Square>> squares_ RTC_GUARDED_BY(&crit_);
};
class YuvFileGenerator : public FrameGenerator {
public:
YuvFileGenerator(std::vector<FILE*> files,
YuvFileGenerator::YuvFileGenerator(std::vector<FILE*> files,
size_t width,
size_t height,
int frame_repeat_count)
@ -192,12 +165,12 @@ class YuvFileGenerator : public FrameGenerator {
RTC_DCHECK_GT(frame_repeat_count, 0);
}
~YuvFileGenerator() override {
YuvFileGenerator::~YuvFileGenerator() {
for (FILE* file : files_)
fclose(file);
}
VideoFrameData NextFrame() override {
FrameGeneratorInterface::VideoFrameData YuvFileGenerator::NextFrame() {
// Empty update by default.
VideoFrame::UpdateRect update_rect{0, 0, 0, 0};
if (current_display_count_ == 0) {
@ -214,14 +187,11 @@ class YuvFileGenerator : public FrameGenerator {
return VideoFrameData(last_read_buffer_, update_rect);
}
// Returns true if the new frame was loaded.
// False only in case of a single file with a single frame in it.
bool ReadNextFrame() {
bool YuvFileGenerator::ReadNextFrame() {
size_t prev_frame_index = frame_index_;
size_t prev_file_index = file_index_;
last_read_buffer_ =
test::ReadI420Buffer(static_cast<int>(width_),
static_cast<int>(height_), files_[file_index_]);
last_read_buffer_ = test::ReadI420Buffer(
static_cast<int>(width_), static_cast<int>(height_), files_[file_index_]);
++frame_index_;
if (!last_read_buffer_) {
// No more frames to read in this file, rewind and move to next file.
@ -237,25 +207,7 @@ class YuvFileGenerator : public FrameGenerator {
return frame_index_ != prev_frame_index || file_index_ != prev_file_index;
}
private:
size_t file_index_;
size_t frame_index_;
const std::vector<FILE*> files_;
const size_t width_;
const size_t height_;
const size_t frame_size_;
const std::unique_ptr<uint8_t[]> frame_buffer_;
const int frame_display_count_;
int current_display_count_;
rtc::scoped_refptr<I420Buffer> last_read_buffer_;
};
// SlideGenerator works similarly to YuvFileGenerator but it fills the frames
// with randomly sized and colored squares instead of reading their content
// from files.
class SlideGenerator : public FrameGenerator {
public:
SlideGenerator(int width, int height, int frame_repeat_count)
SlideGenerator::SlideGenerator(int width, int height, int frame_repeat_count)
: width_(width),
height_(height),
frame_display_count_(frame_repeat_count),
@ -266,7 +218,7 @@ class SlideGenerator : public FrameGenerator {
RTC_DCHECK_GT(frame_repeat_count, 0);
}
VideoFrameData NextFrame() override {
FrameGeneratorInterface::VideoFrameData SlideGenerator::NextFrame() {
if (current_display_count_ == 0)
GenerateNewFrame();
if (++current_display_count_ >= frame_display_count_)
@ -275,9 +227,7 @@ class SlideGenerator : public FrameGenerator {
return VideoFrameData(buffer_, absl::nullopt);
}
// Generates some randomly sized and colored squares scattered
// over the frame.
void GenerateNewFrame() {
void SlideGenerator::GenerateNewFrame() {
// The squares should have a varying order of magnitude in order
// to simulate variation in the slides' complexity.
const int kSquareNum = 1 << (4 + (random_generator_.Rand(0, 3) * 2));
@ -302,8 +252,7 @@ class SlideGenerator : public FrameGenerator {
uint8_t yuv_v = random_generator_.Rand(0, 255);
for (int yy = y; yy < y + length; ++yy) {
uint8_t* pos_y =
(buffer_->MutableDataY() + x + yy * buffer_->StrideY());
uint8_t* pos_y = (buffer_->MutableDataY() + x + yy * buffer_->StrideY());
memset(pos_y, yuv_y, length);
}
for (int yy = y; yy < y + length; yy += 2) {
@ -317,18 +266,8 @@ class SlideGenerator : public FrameGenerator {
}
}
private:
const int width_;
const int height_;
const int frame_display_count_;
int current_display_count_;
Random random_generator_;
rtc::scoped_refptr<I420Buffer> buffer_;
};
class ScrollingImageFrameGenerator : public FrameGenerator {
public:
ScrollingImageFrameGenerator(Clock* clock,
ScrollingImageFrameGenerator::ScrollingImageFrameGenerator(
Clock* clock,
const std::vector<FILE*>& files,
size_t source_width,
size_t source_height,
@ -357,9 +296,8 @@ class ScrollingImageFrameGenerator : public FrameGenerator {
RTC_DCHECK_GT(scroll_time_ms + pause_time_ms, 0);
}
~ScrollingImageFrameGenerator() override {}
VideoFrameData NextFrame() override {
FrameGeneratorInterface::VideoFrameData
ScrollingImageFrameGenerator::NextFrame() {
const int64_t kFrameDisplayTime = scroll_time_ + pause_time_;
const int64_t now = clock_->TimeInMilliseconds();
int64_t ms_since_start = now - start_time_;
@ -392,7 +330,7 @@ class ScrollingImageFrameGenerator : public FrameGenerator {
return current_frame_;
}
void UpdateSourceFrame(size_t frame_num) {
void ScrollingImageFrameGenerator::UpdateSourceFrame(size_t frame_num) {
VideoFrame::UpdateRect acc_update{0, 0, 0, 0};
while (current_frame_num_ != frame_num) {
current_source_frame_ = file_generator_.NextFrame();
@ -404,12 +342,12 @@ class ScrollingImageFrameGenerator : public FrameGenerator {
current_source_frame_.update_rect = acc_update;
}
void CropSourceToScrolledImage(double scroll_factor) {
void ScrollingImageFrameGenerator::CropSourceToScrolledImage(
double scroll_factor) {
int scroll_margin_x = current_source_frame_.buffer->width() - target_width_;
int pixels_scrolled_x =
static_cast<int>(scroll_margin_x * scroll_factor + 0.5);
int scroll_margin_y =
current_source_frame_.buffer->height() - target_height_;
int scroll_margin_y = current_source_frame_.buffer->height() - target_height_;
int pixels_scrolled_y =
static_cast<int>(scroll_margin_y * scroll_factor + 0.5);
@ -435,117 +373,5 @@ class ScrollingImageFrameGenerator : public FrameGenerator {
update_rect);
}
Clock* const clock_;
const int64_t start_time_;
const int64_t scroll_time_;
const int64_t pause_time_;
const size_t num_frames_;
const int target_width_;
const int target_height_;
size_t current_frame_num_;
bool prev_frame_not_scrolled_;
VideoFrameData current_source_frame_;
VideoFrameData current_frame_;
YuvFileGenerator file_generator_;
};
} // namespace
FrameForwarder::FrameForwarder() : sink_(nullptr) {}
FrameForwarder::~FrameForwarder() {}
void FrameForwarder::IncomingCapturedFrame(const VideoFrame& video_frame) {
rtc::CritScope lock(&crit_);
if (sink_)
sink_->OnFrame(video_frame);
}
void FrameForwarder::AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
const rtc::VideoSinkWants& wants) {
rtc::CritScope lock(&crit_);
RTC_DCHECK(!sink_ || sink_ == sink);
sink_ = sink;
sink_wants_ = wants;
}
void FrameForwarder::RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) {
rtc::CritScope lock(&crit_);
RTC_DCHECK_EQ(sink, sink_);
sink_ = nullptr;
}
rtc::VideoSinkWants FrameForwarder::sink_wants() const {
rtc::CritScope lock(&crit_);
return sink_wants_;
}
bool FrameForwarder::has_sinks() const {
rtc::CritScope lock(&crit_);
return sink_ != nullptr;
}
void FrameGenerator::ChangeResolution(size_t width, size_t height) {
RTC_NOTREACHED();
}
std::unique_ptr<FrameGenerator> FrameGenerator::CreateSquareGenerator(
int width,
int height,
absl::optional<OutputType> type,
absl::optional<int> num_squares) {
return std::unique_ptr<FrameGenerator>(
new SquareGenerator(width, height, type.value_or(OutputType::kI420),
num_squares.value_or(10)));
}
std::unique_ptr<FrameGenerator> FrameGenerator::CreateSlideGenerator(
int width,
int height,
int frame_repeat_count) {
return std::unique_ptr<FrameGenerator>(
new SlideGenerator(width, height, frame_repeat_count));
}
std::unique_ptr<FrameGenerator> FrameGenerator::CreateFromYuvFile(
std::vector<std::string> filenames,
size_t width,
size_t height,
int frame_repeat_count) {
RTC_DCHECK(!filenames.empty());
std::vector<FILE*> files;
for (const std::string& filename : filenames) {
FILE* file = fopen(filename.c_str(), "rb");
RTC_DCHECK(file != nullptr) << "Failed to open: '" << filename << "'\n";
files.push_back(file);
}
return std::unique_ptr<FrameGenerator>(
new YuvFileGenerator(files, width, height, frame_repeat_count));
}
std::unique_ptr<FrameGenerator>
FrameGenerator::CreateScrollingInputFromYuvFiles(
Clock* clock,
std::vector<std::string> filenames,
size_t source_width,
size_t source_height,
size_t target_width,
size_t target_height,
int64_t scroll_time_ms,
int64_t pause_time_ms) {
RTC_DCHECK(!filenames.empty());
std::vector<FILE*> files;
for (const std::string& filename : filenames) {
FILE* file = fopen(filename.c_str(), "rb");
RTC_DCHECK(file != nullptr);
files.push_back(file);
}
return std::unique_ptr<FrameGenerator>(new ScrollingImageFrameGenerator(
clock, files, source_width, source_height, target_width, target_height,
scroll_time_ms, pause_time_ms));
}
} // namespace test
} // namespace webrtc

171
test/frame_generator.h
View File

@ -14,87 +14,148 @@
#include <string>
#include <vector>
#include "api/scoped_refptr.h"
#include "api/test/frame_generator_interface.h"
#include "api/video/i420_buffer.h"
#include "api/video/video_frame.h"
#include "api/video/video_frame_buffer.h"
#include "api/video/video_source_interface.h"
#include "rtc_base/critical_section.h"
#include "rtc_base/random.h"
#include "system_wrappers/include/clock.h"
namespace webrtc {
class Clock;
namespace test {
// FrameForwarder can be used as an implementation
// of rtc::VideoSourceInterface<VideoFrame> where the caller controls when
// a frame should be forwarded to its sink.
// Currently this implementation only support one sink.
class FrameForwarder : public rtc::VideoSourceInterface<VideoFrame> {
// SquareGenerator is a FrameGenerator that draws a given amount of randomly
// sized and colored squares. Between each new generated frame, the squares
// are moved slightly towards the lower right corner.
class SquareGenerator : public FrameGeneratorInterface {
public:
FrameForwarder();
~FrameForwarder() override;
// Forwards |video_frame| to the registered |sink_|.
virtual void IncomingCapturedFrame(const VideoFrame& video_frame);
rtc::VideoSinkWants sink_wants() const;
bool has_sinks() const;
SquareGenerator(int width, int height, OutputType type, int num_squares);
protected:
void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
const rtc::VideoSinkWants& wants) override;
void RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) override;
void ChangeResolution(size_t width, size_t height) override;
VideoFrameData NextFrame() override;
rtc::CriticalSection crit_;
rtc::VideoSinkInterface<VideoFrame>* sink_ RTC_GUARDED_BY(crit_);
rtc::VideoSinkWants sink_wants_ RTC_GUARDED_BY(crit_);
private:
rtc::scoped_refptr<I420Buffer> CreateI420Buffer(int width, int height);
class Square {
public:
Square(int width, int height, int seed);
void Draw(const rtc::scoped_refptr<VideoFrameBuffer>& frame_buffer);
private:
Random random_generator_;
int x_;
int y_;
const int length_;
const uint8_t yuv_y_;
const uint8_t yuv_u_;
const uint8_t yuv_v_;
const uint8_t yuv_a_;
};
class FrameGenerator : public FrameGeneratorInterface {
rtc::CriticalSection crit_;
const OutputType type_;
int width_ RTC_GUARDED_BY(&crit_);
int height_ RTC_GUARDED_BY(&crit_);
std::vector<std::unique_ptr<Square>> squares_ RTC_GUARDED_BY(&crit_);
};
class YuvFileGenerator : public FrameGeneratorInterface {
public:
virtual ~FrameGenerator() = default;
// Change the capture resolution.
void ChangeResolution(size_t width, size_t height) override;
// Creates a frame generator that produces frames with small squares that
// move randomly towards the lower right corner.
// |type| has the default value OutputType::I420. |num_squares| has the
// default value 10.
static std::unique_ptr<FrameGenerator> CreateSquareGenerator(
int width,
int height,
absl::optional<OutputType> type,
absl::optional<int> num_squares);
// Creates a frame generator that repeatedly plays a set of yuv files.
// The frame_repeat_count determines how many times each frame is shown,
// with 1 = show each frame once, etc.
static std::unique_ptr<FrameGenerator> CreateFromYuvFile(
std::vector<std::string> files,
YuvFileGenerator(std::vector<FILE*> files,
size_t width,
size_t height,
int frame_repeat_count);
// Creates a frame generator which takes a set of yuv files (wrapping a
// frame generator created by CreateFromYuvFile() above), but outputs frames
// that have been cropped to specified resolution: source_width/source_height
// is the size of the source images, target_width/target_height is the size of
// the cropped output. For each source image read, the cropped viewport will
// be scrolled top to bottom/left to right for scroll_tim_ms milliseconds.
// After that the image will stay in place for pause_time_ms milliseconds,
// and then this will be repeated with the next file from the input set.
static std::unique_ptr<FrameGenerator> CreateScrollingInputFromYuvFiles(
Clock* clock,
std::vector<std::string> filenames,
~YuvFileGenerator();
VideoFrameData NextFrame() override;
void ChangeResolution(size_t width, size_t height) override {
RTC_NOTREACHED();
}
private:
// Returns true if the new frame was loaded.
// False only in case of a single file with a single frame in it.
bool ReadNextFrame();
size_t file_index_;
size_t frame_index_;
const std::vector<FILE*> files_;
const size_t width_;
const size_t height_;
const size_t frame_size_;
const std::unique_ptr<uint8_t[]> frame_buffer_;
const int frame_display_count_;
int current_display_count_;
rtc::scoped_refptr<I420Buffer> last_read_buffer_;
};
// SlideGenerator works similarly to YuvFileGenerator but it fills the frames
// with randomly sized and colored squares instead of reading their content
// from files.
class SlideGenerator : public FrameGeneratorInterface {
public:
SlideGenerator(int width, int height, int frame_repeat_count);
VideoFrameData NextFrame() override;
void ChangeResolution(size_t width, size_t height) override {
RTC_NOTREACHED();
}
private:
// Generates some randomly sized and colored squares scattered
// over the frame.
void GenerateNewFrame();
const int width_;
const int height_;
const int frame_display_count_;
int current_display_count_;
Random random_generator_;
rtc::scoped_refptr<I420Buffer> buffer_;
};
class ScrollingImageFrameGenerator : public FrameGeneratorInterface {
public:
ScrollingImageFrameGenerator(Clock* clock,
const std::vector<FILE*>& files,
size_t source_width,
size_t source_height,
size_t target_width,
size_t target_height,
int64_t scroll_time_ms,
int64_t pause_time_ms);
~ScrollingImageFrameGenerator() override = default;
// Creates a frame generator that produces randomly generated slides.
// frame_repeat_count determines how many times each slide is shown.
static std::unique_ptr<FrameGenerator>
CreateSlideGenerator(int width, int height, int frame_repeat_count);
VideoFrameData NextFrame() override;
void ChangeResolution(size_t width, size_t height) override {
RTC_NOTREACHED();
}
private:
void UpdateSourceFrame(size_t frame_num);
void CropSourceToScrolledImage(double scroll_factor);
Clock* const clock_;
const int64_t start_time_;
const int64_t scroll_time_;
const int64_t pause_time_;
const size_t num_frames_;
const int target_width_;
const int target_height_;
size_t current_frame_num_;
bool prev_frame_not_scrolled_;
VideoFrameData current_source_frame_;
VideoFrameData current_frame_;
YuvFileGenerator file_generator_;
};
} // namespace test
} // namespace webrtc

18
test/frame_generator_capturer.cc
View File

@ -17,6 +17,7 @@
#include <utility>
#include <vector>
#include "api/test/create_frame_generator.h"
#include "rtc_base/checks.h"
#include "rtc_base/critical_section.h"
#include "rtc_base/logging.h"
@ -71,8 +72,8 @@ std::unique_ptr<FrameGeneratorCapturer> FrameGeneratorCapturer::Create(
FrameGeneratorCapturerConfig::SquaresVideo config) {
return std::make_unique<FrameGeneratorCapturer>(
clock,
FrameGenerator::CreateSquareGenerator(
config.width, config.height, config.pixel_format, config.num_squares),
CreateSquareFrameGenerator(config.width, config.height,
config.pixel_format, config.num_squares),
config.framerate, task_queue_factory);
}
std::unique_ptr<FrameGeneratorCapturer> FrameGeneratorCapturer::Create(
@ -81,7 +82,7 @@ std::unique_ptr<FrameGeneratorCapturer> FrameGeneratorCapturer::Create(
FrameGeneratorCapturerConfig::SquareSlides config) {
return std::make_unique<FrameGeneratorCapturer>(
clock,
FrameGenerator::CreateSlideGenerator(
CreateSlideFrameGenerator(
config.width, config.height,
/*frame_repeat_count*/ config.change_interval.seconds<double>() *
config.framerate),
@ -94,7 +95,7 @@ std::unique_ptr<FrameGeneratorCapturer> FrameGeneratorCapturer::Create(
RTC_CHECK(config.width && config.height);
return std::make_unique<FrameGeneratorCapturer>(
clock,
FrameGenerator::CreateFromYuvFile({TransformFilePath(config.name)},
CreateFromYuvFileFrameGenerator({TransformFilePath(config.name)},
config.width, config.height,
/*frame_repeat_count*/ 1),
config.framerate, task_queue_factory);
@ -104,7 +105,7 @@ std::unique_ptr<FrameGeneratorCapturer> FrameGeneratorCapturer::Create(
Clock* clock,
TaskQueueFactory& task_queue_factory,
FrameGeneratorCapturerConfig::ImageSlides config) {
std::unique_ptr<FrameGenerator> slides_generator;
std::unique_ptr<FrameGeneratorInterface> slides_generator;
std::vector<std::string> paths = config.paths;
for (std::string& path : paths)
path = TransformFilePath(path);
@ -117,11 +118,11 @@ std::unique_ptr<FrameGeneratorCapturer> FrameGeneratorCapturer::Create(
int crop_height = config.crop.height.value_or(config.height);
RTC_CHECK_LE(crop_width, config.width);
RTC_CHECK_LE(crop_height, config.height);
slides_generator = FrameGenerator::CreateScrollingInputFromYuvFiles(
slides_generator = CreateScrollingInputFromYuvFilesFrameGenerator(
clock, paths, config.width, config.height, crop_width, crop_height,
config.crop.scroll_duration.ms(), pause_duration.ms());
} else {
slides_generator = FrameGenerator::CreateFromYuvFile(
slides_generator = CreateFromYuvFileFrameGenerator(
paths, config.width, config.height,
/*frame_repeat_count*/ config.change_interval.seconds<double>() *
config.framerate);
@ -176,7 +177,8 @@ bool FrameGeneratorCapturer::Init() {
void FrameGeneratorCapturer::InsertFrame() {
rtc::CritScope cs(&lock_);
if (sending_) {
FrameGenerator::VideoFrameData frame_data = frame_generator_->NextFrame();
FrameGeneratorInterface::VideoFrameData frame_data =
frame_generator_->NextFrame();
// TODO(srte): Use more advanced frame rate control to allow arbritrary
// fractions.
int decimation =

6
test/frame_generator_capturer.h
View File

@ -14,11 +14,12 @@
#include <string>
#include "api/task_queue/task_queue_factory.h"
#include "api/test/frame_generator_interface.h"
#include "api/video/video_frame.h"
#include "rtc_base/critical_section.h"
#include "rtc_base/task_queue.h"
#include "rtc_base/task_utils/repeating_task.h"
#include "test/frame_generator.h"
#include "system_wrappers/include/clock.h"
#include "test/test_video_capturer.h"
namespace webrtc {
@ -38,7 +39,8 @@ class AutoOpt : public absl::optional<T> {
struct FrameGeneratorCapturerConfig {
struct SquaresVideo {
int framerate = 30;
FrameGenerator::OutputType pixel_format = FrameGenerator::OutputType::kI420;
FrameGeneratorInterface::OutputType pixel_format =
FrameGeneratorInterface::OutputType::kI420;
int width = 320;
int height = 180;
int num_squares = 10;

29
test/frame_generator_unittest.cc
View File

@ -19,6 +19,8 @@
#include <string>
#include "api/scoped_refptr.h"
#include "api/test/create_frame_generator.h"
#include "api/test/frame_generator_interface.h"
#include "api/video/video_frame_buffer.h"
#include "test/gtest.h"
#include "test/testsupport/file_utils.h"
@ -62,7 +64,7 @@ class FrameGeneratorTest : public ::testing::Test {
fwrite(plane_buffer.get(), 1, uv_size, file);
}
void CheckFrameAndMutate(const FrameGenerator::VideoFrameData& frame,
void CheckFrameAndMutate(const FrameGeneratorInterface::VideoFrameData& frame,
uint8_t y,
uint8_t u,
uint8_t v) {
@ -81,7 +83,7 @@ class FrameGeneratorTest : public ::testing::Test {
ASSERT_EQ(v, buffer[i]);
}
uint64_t Hash(const FrameGenerator::VideoFrameData& frame) {
uint64_t Hash(const FrameGeneratorInterface::VideoFrameData& frame) {
// Generate a 64-bit hash from the frame's buffer.
uint64_t hash = 19;
rtc::scoped_refptr<I420BufferInterface> i420_buffer =
@ -108,7 +110,8 @@ class FrameGeneratorTest : public ::testing::Test {
};
TEST_F(FrameGeneratorTest, SingleFrameFile) {
std::unique_ptr<FrameGenerator> generator(FrameGenerator::CreateFromYuvFile(
std::unique_ptr<FrameGeneratorInterface> generator(
CreateFromYuvFileFrameGenerator(
std::vector<std::string>(1, one_frame_filename_), kFrameWidth,
kFrameHeight, 1));
CheckFrameAndMutate(generator->NextFrame(), 255, 255, 255);
@ -116,7 +119,8 @@ TEST_F(FrameGeneratorTest, SingleFrameFile) {
}
TEST_F(FrameGeneratorTest, TwoFrameFile) {
std::unique_ptr<FrameGenerator> generator(FrameGenerator::CreateFromYuvFile(
std::unique_ptr<FrameGeneratorInterface> generator(
CreateFromYuvFileFrameGenerator(
std::vector<std::string>(1, two_frame_filename_), kFrameWidth,
kFrameHeight, 1));
CheckFrameAndMutate(generator->NextFrame(), 0, 0, 0);
@ -129,8 +133,8 @@ TEST_F(FrameGeneratorTest, MultipleFrameFiles) {
files.push_back(two_frame_filename_);
files.push_back(one_frame_filename_);
std::unique_ptr<FrameGenerator> generator(
FrameGenerator::CreateFromYuvFile(files, kFrameWidth, kFrameHeight, 1));
std::unique_ptr<FrameGeneratorInterface> generator(
CreateFromYuvFileFrameGenerator(files, kFrameWidth, kFrameHeight, 1));
CheckFrameAndMutate(generator->NextFrame(), 0, 0, 0);
CheckFrameAndMutate(generator->NextFrame(), 127, 127, 127);
CheckFrameAndMutate(generator->NextFrame(), 255, 255, 255);
@ -139,7 +143,8 @@ TEST_F(FrameGeneratorTest, MultipleFrameFiles) {
TEST_F(FrameGeneratorTest, TwoFrameFileWithRepeat) {
const int kRepeatCount = 3;
std::unique_ptr<FrameGenerator> generator(FrameGenerator::CreateFromYuvFile(
std::unique_ptr<FrameGeneratorInterface> generator(
CreateFromYuvFileFrameGenerator(
std::vector<std::string>(1, two_frame_filename_), kFrameWidth,
kFrameHeight, kRepeatCount));
for (int i = 0; i < kRepeatCount; ++i)
@ -154,8 +159,9 @@ TEST_F(FrameGeneratorTest, MultipleFrameFilesWithRepeat) {
std::vector<std::string> files;
files.push_back(two_frame_filename_);
files.push_back(one_frame_filename_);
std::unique_ptr<FrameGenerator> generator(FrameGenerator::CreateFromYuvFile(
files, kFrameWidth, kFrameHeight, kRepeatCount));
std::unique_ptr<FrameGeneratorInterface> generator(
CreateFromYuvFileFrameGenerator(files, kFrameWidth, kFrameHeight,
kRepeatCount));
for (int i = 0; i < kRepeatCount; ++i)
CheckFrameAndMutate(generator->NextFrame(), 0, 0, 0);
for (int i = 0; i < kRepeatCount; ++i)
@ -168,9 +174,8 @@ TEST_F(FrameGeneratorTest, MultipleFrameFilesWithRepeat) {
TEST_F(FrameGeneratorTest, SlideGenerator) {
const int kGenCount = 9;
const int kRepeatCount = 3;
std::unique_ptr<FrameGenerator> generator(
FrameGenerator::CreateSlideGenerator(kFrameWidth, kFrameHeight,
kRepeatCount));
std::unique_ptr<FrameGeneratorInterface> generator(
CreateSlideFrameGenerator(kFrameWidth, kFrameHeight, kRepeatCount));
uint64_t hashes[kGenCount];
for (int i = 0; i < kGenCount; ++i) {
hashes[i] = Hash(generator->NextFrame());

1
test/pc/e2e/analyzer/video/video_quality_analyzer_injection_helper.h
View File

@ -22,7 +22,6 @@
#include "api/video/video_sink_interface.h"
#include "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_encoder_factory.h"
#include "test/frame_generator.h"
#include "test/pc/e2e/analyzer/video/encoded_image_data_injector.h"
#include "test/pc/e2e/analyzer/video/id_generator.h"
#include "test/test_video_capturer.h"

2
test/scenario/BUILD.gn
View File

@ -80,7 +80,9 @@ if (rtc_include_tests) {
"../:test_common",
"../:test_support",
"../:video_test_common",
"../../api:create_frame_generator",
"../../api:fec_controller_api",
"../../api:frame_generator_api",
"../../api:libjingle_peerconnection_api",
"../../api:rtc_event_log_output_file",
"../../api:rtp_parameters",

4
test/scenario/scenario_config.h
View File

@ -17,12 +17,12 @@
#include "absl/types/optional.h"
#include "api/fec_controller.h"
#include "api/rtp_parameters.h"
#include "api/test/frame_generator_interface.h"
#include "api/transport/network_control.h"
#include "api/units/data_rate.h"
#include "api/units/data_size.h"
#include "api/units/time_delta.h"
#include "api/video/video_codec_type.h"
#include "test/frame_generator.h"
#include "test/scenario/performance_stats.h"
namespace webrtc {
@ -103,7 +103,7 @@ struct VideoStreamConfig {
} images;
} slides;
struct Generator {
using PixelFormat = FrameGenerator::OutputType;
using PixelFormat = FrameGeneratorInterface::OutputType;
PixelFormat pixel_format = PixelFormat::kI420;
int width = 320;
int height = 180;

16
test/scenario/video_stream.cc
View File

@ -13,6 +13,8 @@
#include <memory>
#include <utility>
#include "api/test/create_frame_generator.h"
#include "api/test/frame_generator_interface.h"
#include "api/test/video/function_video_encoder_factory.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "media/base/media_constants.h"
@ -261,7 +263,7 @@ VideoEncoderConfig CreateVideoEncoderConfig(VideoStreamConfig config) {
return encoder_config;
}
std::unique_ptr<FrameGenerator> CreateImageSlideGenerator(
std::unique_ptr<FrameGeneratorInterface> CreateImageSlideGenerator(
Clock* clock,
VideoStreamConfig::Source::Slides slides,
int framerate) {
@ -276,33 +278,33 @@ std::unique_ptr<FrameGenerator> CreateImageSlideGenerator(
int crop_height = slides.images.crop.height.value_or(slides.images.height);
RTC_CHECK_LE(crop_width, slides.images.width);
RTC_CHECK_LE(crop_height, slides.images.height);
return FrameGenerator::CreateScrollingInputFromYuvFiles(
return CreateScrollingInputFromYuvFilesFrameGenerator(
clock, paths, slides.images.width, slides.images.height, crop_width,
crop_height, slides.images.crop.scroll_duration.ms(),
pause_duration.ms());
} else {
return FrameGenerator::CreateFromYuvFile(
return CreateFromYuvFileFrameGenerator(
paths, slides.images.width, slides.images.height,
slides.change_interval.seconds<double>() * framerate);
}
}
std::unique_ptr<FrameGenerator> CreateFrameGenerator(
std::unique_ptr<FrameGeneratorInterface> CreateFrameGenerator(
Clock* clock,
VideoStreamConfig::Source source) {
using Capture = VideoStreamConfig::Source::Capture;
switch (source.capture) {
case Capture::kGenerator:
return FrameGenerator::CreateSquareGenerator(
return CreateSquareFrameGenerator(
source.generator.width, source.generator.height,
source.generator.pixel_format, /*num_squares*/ absl::nullopt);
case Capture::kVideoFile:
RTC_CHECK(source.video_file.width && source.video_file.height);
return FrameGenerator::CreateFromYuvFile(
return CreateFromYuvFileFrameGenerator(
{TransformFilePath(source.video_file.name)}, source.video_file.width,
source.video_file.height, /*frame_repeat_count*/ 1);
case Capture::kGenerateSlides:
return FrameGenerator::CreateSlideGenerator(
return CreateSlideFrameGenerator(
source.slides.generator.width, source.slides.generator.height,
source.slides.change_interval.seconds<double>() * source.framerate);
case Capture::kImageSlides:

2
test/testsupport/ivf_video_frame_generator.cc
View File

@ -64,7 +64,7 @@ IvfVideoFrameGenerator::~IvfVideoFrameGenerator() {
}
}
FrameGenerator::VideoFrameData IvfVideoFrameGenerator::NextFrame() {
FrameGeneratorInterface::VideoFrameData IvfVideoFrameGenerator::NextFrame() {
RTC_DCHECK_RUN_ON(&sequence_checker_);
next_frame_decoded_.Reset();
RTC_CHECK(file_reader_);

4
test/testsupport/ivf_video_frame_generator.h
View File

@ -15,6 +15,7 @@
#include <string>
#include "absl/types/optional.h"
#include "api/test/frame_generator_interface.h"
#include "api/video/video_codec_type.h"
#include "api/video/video_frame.h"
#include "api/video_codecs/video_decoder.h"
@ -22,13 +23,12 @@
#include "rtc_base/critical_section.h"
#include "rtc_base/event.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "test/frame_generator.h"
namespace webrtc {
namespace test {
// All methods except constructor must be used from the same thread.
class IvfVideoFrameGenerator : public FrameGenerator {
class IvfVideoFrameGenerator : public FrameGeneratorInterface {
public:
explicit IvfVideoFrameGenerator(const std::string& file_name);
~IvfVideoFrameGenerator() override;

10
test/testsupport/ivf_video_frame_generator_unittest.cc
View File

@ -12,6 +12,7 @@
#include <vector>
#include "absl/types/optional.h"
#include "api/test/create_frame_generator.h"
#include "api/video/encoded_image.h"
#include "api/video/video_codec_type.h"
#include "api/video_codecs/video_codec.h"
@ -26,7 +27,6 @@
#include "modules/video_coding/utility/ivf_file_writer.h"
#include "rtc_base/critical_section.h"
#include "rtc_base/event.h"
#include "test/frame_generator.h"
#include "test/gtest.h"
#include "test/testsupport/file_utils.h"
#include "test/testsupport/ivf_video_frame_generator.h"
@ -102,7 +102,7 @@ class IvfVideoFrameGeneratorTest : public ::testing::Test {
}
void TearDown() override { webrtc::test::RemoveFile(file_name_); }
VideoFrame BuildFrame(FrameGenerator::VideoFrameData frame_data) {
VideoFrame BuildFrame(FrameGeneratorInterface::VideoFrameData frame_data) {
return VideoFrame::Builder()
.set_video_frame_buffer(frame_data.buffer)
.set_update_rect(frame_data.update_rect)
@ -111,9 +111,9 @@ class IvfVideoFrameGeneratorTest : public ::testing::Test {
void CreateTestVideoFile(VideoCodecType video_codec_type,
std::unique_ptr<VideoEncoder> video_encoder) {
std::unique_ptr<test::FrameGenerator> frame_generator =
test::FrameGenerator::CreateSquareGenerator(
kWidth, kHeight, test::FrameGenerator::OutputType::kI420,
std::unique_ptr<test::FrameGeneratorInterface> frame_generator =
test::CreateSquareFrameGenerator(
kWidth, kHeight, test::FrameGeneratorInterface::OutputType::kI420,
absl::nullopt);
VideoCodec codec_settings;

5
video/BUILD.gn
View File

@ -259,7 +259,9 @@ if (rtc_include_tests) {
]
deps = [
":frame_dumping_decoder",
"../api:create_frame_generator",
"../api:fec_controller_api",
"../api:frame_generator_api",
"../api:libjingle_peerconnection_api",
"../api:rtc_event_log_output_file",
"../api:test_dependency_factory",
@ -563,8 +565,10 @@ if (rtc_include_tests) {
":video",
":video_mocks",
":video_stream_encoder_impl",
"../api:create_frame_generator",
"../api:fake_frame_decryptor",
"../api:fake_frame_encryptor",
"../api:frame_generator_api",
"../api:libjingle_peerconnection_api",
"../api:mock_fec_controller_override",
"../api:mock_frame_decryptor",
@ -641,6 +645,7 @@ if (rtc_include_tests) {
"../test:fake_video_codecs",
"../test:field_trial",
"../test:fileutils",
"../test:frame_utils",
"../test:null_transport",
"../test:perf_test",
"../test:rtp_test_utils",

19
video/end_to_end_tests/call_operation_tests.cc
View File

@ -9,6 +9,9 @@
*/
#include <memory>
#include "api/test/create_frame_generator.h"
#include "api/test/frame_generator_interface.h"
#include "api/test/simulated_network.h"
#include "call/fake_network_pipe.h"
#include "call/simulated_network.h"
@ -16,7 +19,7 @@
#include "system_wrappers/include/sleep.h"
#include "test/call_test.h"
#include "test/field_trial.h"
#include "test/frame_generator.h"
#include "test/frame_forwarder.h"
#include "test/gtest.h"
#include "test/null_transport.h"
@ -125,13 +128,13 @@ TEST_F(CallOperationEndToEndTest, RendersSingleDelayedFrame) {
// Create frames that are smaller than the send width/height, this is
// done to check that the callbacks are done after processing video.
std::unique_ptr<test::FrameGenerator> frame_generator(
test::FrameGenerator::CreateSquareGenerator(
kWidth, kHeight, absl::nullopt, absl::nullopt));
std::unique_ptr<test::FrameGeneratorInterface> frame_generator(
test::CreateSquareFrameGenerator(kWidth, kHeight, absl::nullopt,
absl::nullopt));
GetVideoSendStream()->SetSource(
&frame_forwarder, DegradationPreference::MAINTAIN_FRAMERATE);
test::FrameGenerator::VideoFrameData frame_data =
test::FrameGeneratorInterface::VideoFrameData frame_data =
frame_generator->NextFrame();
VideoFrame frame = VideoFrame::Builder()
.set_video_frame_buffer(frame_data.buffer)
@ -163,7 +166,7 @@ TEST_F(CallOperationEndToEndTest, TransmitsFirstFrame) {
rtc::Event event_;
} renderer;
std::unique_ptr<test::FrameGenerator> frame_generator;
std::unique_ptr<test::FrameGeneratorInterface> frame_generator;
test::FrameForwarder frame_forwarder;
std::unique_ptr<test::DirectTransport> sender_transport;
@ -197,11 +200,11 @@ TEST_F(CallOperationEndToEndTest, TransmitsFirstFrame) {
CreateVideoStreams();
Start();
frame_generator = test::FrameGenerator::CreateSquareGenerator(
frame_generator = test::CreateSquareFrameGenerator(
kDefaultWidth, kDefaultHeight, absl::nullopt, absl::nullopt);
GetVideoSendStream()->SetSource(
&frame_forwarder, DegradationPreference::MAINTAIN_FRAMERATE);
test::FrameGenerator::VideoFrameData frame_data =
test::FrameGeneratorInterface::VideoFrameData frame_data =
frame_generator->NextFrame();
VideoFrame frame = VideoFrame::Builder()
.set_video_frame_buffer(frame_data.buffer)

5
video/end_to_end_tests/multi_stream_tester.cc
View File

@ -18,6 +18,7 @@
#include "api/rtc_event_log/rtc_event_log.h"
#include "api/task_queue/default_task_queue_factory.h"
#include "api/task_queue/task_queue_base.h"
#include "api/test/create_frame_generator.h"
#include "api/test/simulated_network.h"
#include "api/test/video/function_video_encoder_factory.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
@ -114,8 +115,8 @@ void MultiStreamTester::RunTest() {
auto* frame_generator = new test::FrameGeneratorCapturer(
Clock::GetRealTimeClock(),
test::FrameGenerator::CreateSquareGenerator(
width, height, absl::nullopt, absl::nullopt),
test::CreateSquareFrameGenerator(width, height, absl::nullopt,
absl::nullopt),
30, *task_queue_factory);
frame_generators[i] = frame_generator;
send_streams[i]->SetSource(frame_generator,

36
video/video_quality_test.cc
View File

@ -22,6 +22,7 @@
#include "api/rtc_event_log_output_file.h"
#include "api/task_queue/default_task_queue_factory.h"
#include "api/task_queue/task_queue_base.h"
#include "api/test/create_frame_generator.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "api/video_codecs/video_encoder.h"
#include "call/fake_network_pipe.h"
@ -1049,24 +1050,23 @@ void VideoQualityTest::SetupThumbnailCapturers(size_t num_thumbnail_streams) {
auto frame_generator_capturer =
std::make_unique<test::FrameGeneratorCapturer>(
clock_,
test::FrameGenerator::CreateSquareGenerator(
static_cast<int>(thumbnail.width),
static_cast<int>(thumbnail.height), absl::nullopt,
absl::nullopt),
test::CreateSquareFrameGenerator(static_cast<int>(thumbnail.width),
static_cast<int>(thumbnail.height),
absl::nullopt, absl::nullopt),
thumbnail.max_framerate, *task_queue_factory_);
EXPECT_TRUE(frame_generator_capturer->Init());
thumbnail_capturers_.push_back(std::move(frame_generator_capturer));
}
}
std::unique_ptr<test::FrameGenerator> VideoQualityTest::CreateFrameGenerator(
size_t video_idx) {
std::unique_ptr<test::FrameGeneratorInterface>
VideoQualityTest::CreateFrameGenerator(size_t video_idx) {
// Setup frame generator.
const size_t kWidth = 1850;
const size_t kHeight = 1110;
std::unique_ptr<test::FrameGenerator> frame_generator;
std::unique_ptr<test::FrameGeneratorInterface> frame_generator;
if (params_.screenshare[video_idx].generate_slides) {
frame_generator = test::FrameGenerator::CreateSlideGenerator(
frame_generator = test::CreateSlideFrameGenerator(
kWidth, kHeight,
params_.screenshare[video_idx].slide_change_interval *
params_.video[video_idx].fps);
@ -1080,7 +1080,7 @@ std::unique_ptr<test::FrameGenerator> VideoQualityTest::CreateFrameGenerator(
}
if (params_.screenshare[video_idx].scroll_duration == 0) {
// Cycle image every slide_change_interval seconds.
frame_generator = test::FrameGenerator::CreateFromYuvFile(
frame_generator = test::CreateFromYuvFileFrameGenerator(
slides, kWidth, kHeight,
params_.screenshare[video_idx].slide_change_interval *
params_.video[video_idx].fps);
@ -1095,7 +1095,7 @@ std::unique_ptr<test::FrameGenerator> VideoQualityTest::CreateFrameGenerator(
RTC_CHECK_LE(params_.screenshare[video_idx].scroll_duration,
params_.screenshare[video_idx].slide_change_interval);
frame_generator = test::FrameGenerator::CreateScrollingInputFromYuvFiles(
frame_generator = test::CreateScrollingInputFromYuvFilesFrameGenerator(
clock_, slides, kWidth, kHeight, params_.video[video_idx].width,
params_.video[video_idx].height,
params_.screenshare[video_idx].scroll_duration * 1000,
@ -1109,24 +1109,24 @@ void VideoQualityTest::CreateCapturers() {
RTC_DCHECK(video_sources_.empty());
video_sources_.resize(num_video_streams_);
for (size_t video_idx = 0; video_idx < num_video_streams_; ++video_idx) {
std::unique_ptr<test::FrameGenerator> frame_generator;
std::unique_ptr<test::FrameGeneratorInterface> frame_generator;
if (params_.screenshare[video_idx].enabled) {
frame_generator = CreateFrameGenerator(video_idx);
} else if (params_.video[video_idx].clip_path == "Generator") {
frame_generator = test::FrameGenerator::CreateSquareGenerator(
frame_generator = test::CreateSquareFrameGenerator(
static_cast<int>(params_.video[video_idx].width),
static_cast<int>(params_.video[video_idx].height), absl::nullopt,
absl::nullopt);
} else if (params_.video[video_idx].clip_path == "GeneratorI420A") {
frame_generator = test::FrameGenerator::CreateSquareGenerator(
frame_generator = test::CreateSquareFrameGenerator(
static_cast<int>(params_.video[video_idx].width),
static_cast<int>(params_.video[video_idx].height),
test::FrameGenerator::OutputType::kI420A, absl::nullopt);
test::FrameGeneratorInterface::OutputType::kI420A, absl::nullopt);
} else if (params_.video[video_idx].clip_path == "GeneratorI010") {
frame_generator = test::FrameGenerator::CreateSquareGenerator(
frame_generator = test::CreateSquareFrameGenerator(
static_cast<int>(params_.video[video_idx].width),
static_cast<int>(params_.video[video_idx].height),
test::FrameGenerator::OutputType::kI010, absl::nullopt);
test::FrameGeneratorInterface::OutputType::kI010, absl::nullopt);
} else if (params_.video[video_idx].clip_path.empty()) {
video_sources_[video_idx] = test::CreateVideoCapturer(
params_.video[video_idx].width, params_.video[video_idx].height,
@ -1136,13 +1136,13 @@ void VideoQualityTest::CreateCapturers() {
continue;
} else {
// Failed to get actual camera, use chroma generator as backup.
frame_generator = test::FrameGenerator::CreateSquareGenerator(
frame_generator = test::CreateSquareFrameGenerator(
static_cast<int>(params_.video[video_idx].width),
static_cast<int>(params_.video[video_idx].height), absl::nullopt,
absl::nullopt);
}
} else {
frame_generator = test::FrameGenerator::CreateFromYuvFile(
frame_generator = test::CreateFromYuvFileFrameGenerator(
{params_.video[video_idx].clip_path}, params_.video[video_idx].width,
params_.video[video_idx].height, 1);
ASSERT_TRUE(frame_generator) << "Could not create capturer for "

5
video/video_quality_test.h
View File

@ -19,13 +19,13 @@
#include "api/rtc_event_log/rtc_event_log_factory.h"
#include "api/task_queue/task_queue_base.h"
#include "api/task_queue/task_queue_factory.h"
#include "api/test/frame_generator_interface.h"
#include "api/test/video_quality_test_fixture.h"
#include "api/video/video_bitrate_allocator_factory.h"
#include "call/fake_network_pipe.h"
#include "media/engine/internal_decoder_factory.h"
#include "media/engine/internal_encoder_factory.h"
#include "test/call_test.h"
#include "test/frame_generator.h"
#include "test/layer_filtering_transport.h"
#include "video/video_analyzer.h"
#ifdef WEBRTC_WIN
@ -76,7 +76,8 @@ class VideoQualityTest : public test::CallTest,
// Helper methods for setting up the call.
void CreateCapturers();
std::unique_ptr<test::FrameGenerator> CreateFrameGenerator(size_t video_idx);
std::unique_ptr<test::FrameGeneratorInterface> CreateFrameGenerator(
size_t video_idx);
void SetupThumbnailCapturers(size_t num_thumbnail_streams);
std::unique_ptr<VideoDecoder> CreateVideoDecoder(
const SdpVideoFormat& format);

2
video/video_send_stream_tests.cc
View File

@ -50,7 +50,7 @@
#include "test/fake_encoder.h"
#include "test/fake_texture_frame.h"
#include "test/field_trial.h"
#include "test/frame_generator.h"
#include "test/frame_forwarder.h"
#include "test/frame_generator_capturer.h"
#include "test/frame_utils.h"
#include "test/gmock.h"

2
video/video_stream_encoder_unittest.cc
View File

@ -39,7 +39,7 @@
#include "test/encoder_settings.h"
#include "test/fake_encoder.h"
#include "test/field_trial.h"
#include "test/frame_generator.h"
#include "test/frame_forwarder.h"
#include "test/gmock.h"
#include "test/gtest.h"
#include "test/video_encoder_proxy_factory.h"