Migrate WebRTC on FrameGeneratorInterface and remove FrameGenerator class

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}

api/BUILD.gn

@@ -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:frame_generator_impl",
-      "../test:video_test_support",
     "//third_party/abseil-cpp/absl/types:optional",
   ]
 }
-}
 
 rtc_source_set("libjingle_logging_api") {
   visibility = [ "*" ]

api/test/create_frame_generator.cc

@@ -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,
+  return std::make_unique<SquareGenerator>(
-                                               num_squares);
+      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) {
+    std::string filename) {
-  return std::make_unique<IvfVideoFrameGenerator>(std::move(file));
+  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(
+  RTC_DCHECK(!filenames.empty());
-      clock, std::move(filenames), source_width, source_height, target_width,
+  std::vector<FILE*> files;
-      target_height, scroll_time_ms, pause_time_ms);
+  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,
+  return std::make_unique<SlideGenerator>(width, height, frame_repeat_count);
-                                              frame_repeat_count);
 }
 
 }  // namespace test

api/test/create_frame_generator.h

@@ -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

call/BUILD.gn

@@ -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",

call/bitrate_estimator_tests.cc

@@ -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(
+              test::CreateSquareFrameGenerator(kDefaultWidth, kDefaultHeight,
-                  kDefaultWidth, kDefaultHeight, absl::nullopt, absl::nullopt),
+                                               absl::nullopt, absl::nullopt),
               kDefaultFramerate, *test->task_queue_factory_);
       frame_generator_capturer_->Init();
       send_stream_->SetSource(frame_generator_capturer_.get(),

call/call_perf_tests.cc

@@ -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"

common_video/BUILD.gn

@@ -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",

media/engine/webrtc_video_engine_unittest.cc

@@ -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"
 

modules/video_capture/BUILD.gn

@@ -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",

modules/video_coding/BUILD.gn

@@ -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",

modules/video_coding/codecs/test/video_codec_unittest.cc

@@ -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)

modules/video_coding/codecs/test/video_codec_unittest.h

@@ -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_;

modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc

@@ -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,

modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc

@@ -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 {

modules/video_processing/BUILD.gn

@@ -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",
     ]

pc/BUILD.gn

@@ -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",

pc/test/frame_generator_capturer_video_track_source.h

@@ -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(
+        test::CreateSquareFrameGenerator(config.width, config.height,
-            config.width, config.height, absl::nullopt,
+                                         absl::nullopt,
                                          config.num_squares_generated),
         config.frames_per_second, *task_queue_factory_);
     video_capturer_->Init();

rtc_tools/BUILD.gn

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

rtc_tools/rtp_generator/rtp_generator.cc

@@ -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(
+            test::CreateSquareFrameGenerator(send_config.video_width,
-                send_config.video_width, send_config.video_height,
+                                             send_config.video_height,
                                              absl::nullopt, absl::nullopt),
             send_config.video_fps, *task_queue_);
     frame_generator->Init();

rtc_tools/rtp_generator/rtp_generator.h

@@ -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"

test/BUILD.gn

@@ -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_forwarder.cc",
-    "frame_generator.h",
+    "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",

test/call_test.cc

@@ -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(
+          test::CreateSquareFrameGenerator(width, height, absl::nullopt,
-              width, height, absl::nullopt, 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(
+          test::CreateSquareFrameGenerator(width, height, absl::nullopt,
-              width, height, absl::nullopt, absl::nullopt),
+                                           absl::nullopt),
           framerate, *task_queue_factory_);
   frame_generator_capturer_ = frame_generator_capturer.get();
   frame_generator_capturer->Init();

test/frame_forwarder.cc

@@ -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

test/frame_forwarder.h

@@ -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_

test/frame_generator.cc

@@ -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
+}  // namespace
-// sized and colored squares. Between each new generated frame, the squares
+
-// are moved slightly towards the lower right corner.
+SquareGenerator::SquareGenerator(int width,
-class SquareGenerator : public FrameGenerator {
+                                 int height,
- public:
+                                 OutputType type,
-  SquareGenerator(int width, int height, OutputType type, int num_squares)
+                                 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:
+SquareGenerator::Square::Square(int width, int height, int seed)
-  class Square {
-   public:
-    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_ +
+    uint8_t* pos_y =
-                          y * buffer->StrideY());
+        (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 =
+  const webrtc::I420ABufferInterface* yuva_buffer = frame_buffer->GetI420A();
-          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:
+YuvFileGenerator::YuvFileGenerator(std::vector<FILE*> files,
-    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,
                                    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.
+bool YuvFileGenerator::ReadNextFrame() {
-  // False only in case of a single file with a single frame in it.
-  bool ReadNextFrame() {
   size_t prev_frame_index = frame_index_;
   size_t prev_file_index = file_index_;
-    last_read_buffer_ =
+  last_read_buffer_ = test::ReadI420Buffer(
-        test::ReadI420Buffer(static_cast<int>(width_),
+      static_cast<int>(width_), static_cast<int>(height_), files_[file_index_]);
-                             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:
+SlideGenerator::SlideGenerator(int width, int height, int frame_repeat_count)
-  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)
     : 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
+void SlideGenerator::GenerateNewFrame() {
-  // over the frame.
-  void 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 =
+      uint8_t* pos_y = (buffer_->MutableDataY() + x + yy * buffer_->StrideY());
-            (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:
+ScrollingImageFrameGenerator::ScrollingImageFrameGenerator(
-  const int width_;
+    Clock* clock,
-  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,
     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 {}
+FrameGeneratorInterface::VideoFrameData
-
+ScrollingImageFrameGenerator::NextFrame() {
-  VideoFrameData NextFrame() override {
   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 =
+  int scroll_margin_y = current_source_frame_.buffer->height() - target_height_;
-        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

test/frame_generator.h

@@ -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
+// SquareGenerator is a FrameGenerator that draws a given amount of randomly
-// of rtc::VideoSourceInterface<VideoFrame> where the caller controls when
+// sized and colored squares. Between each new generated frame, the squares
-// a frame should be forwarded to its sink.
+// are moved slightly towards the lower right corner.
-// Currently this implementation only support one sink.
+class SquareGenerator : public FrameGeneratorInterface {
-class FrameForwarder : public rtc::VideoSourceInterface<VideoFrame> {
  public:
-  FrameForwarder();
+  SquareGenerator(int width, int height, OutputType type, int num_squares);
-  ~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 ChangeResolution(size_t width, size_t height) override;
-  void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
+  VideoFrameData NextFrame() override;
-                       const rtc::VideoSinkWants& wants) override;
-  void RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) override;
 
-  rtc::CriticalSection crit_;
+ private:
-  rtc::VideoSinkInterface<VideoFrame>* sink_ RTC_GUARDED_BY(crit_);
+  rtc::scoped_refptr<I420Buffer> CreateI420Buffer(int width, int height);
-  rtc::VideoSinkWants sink_wants_ RTC_GUARDED_BY(crit_);
+
+  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;
+  YuvFileGenerator(std::vector<FILE*> files,
-
-  // 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,
                    size_t width,
                    size_t height,
                    int frame_repeat_count);
 
-  // Creates a frame generator which takes a set of yuv files (wrapping a
+  ~YuvFileGenerator();
-  // frame generator created by CreateFromYuvFile() above), but outputs frames
+
-  // that have been cropped to specified resolution: source_width/source_height
+  VideoFrameData NextFrame() override;
-  // is the size of the source images, target_width/target_height is the size of
+  void ChangeResolution(size_t width, size_t height) override {
-  // the cropped output. For each source image read, the cropped viewport will
+    RTC_NOTREACHED();
-  // 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.
+ private:
-  static std::unique_ptr<FrameGenerator> CreateScrollingInputFromYuvFiles(
+  // Returns true if the new frame was loaded.
-      Clock* clock,
+  // False only in case of a single file with a single frame in it.
-      std::vector<std::string> filenames,
+  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.
+  VideoFrameData NextFrame() override;
-  // frame_repeat_count determines how many times each slide is shown.
+  void ChangeResolution(size_t width, size_t height) override {
-  static std::unique_ptr<FrameGenerator>
+    RTC_NOTREACHED();
-  CreateSlideGenerator(int width, int height, int frame_repeat_count);
+  }
+
+ 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
 

test/frame_generator_capturer.cc

@@ -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(
+      CreateSquareFrameGenerator(config.width, config.height,
-          config.width, config.height, config.pixel_format, config.num_squares),
+                                 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 =

test/frame_generator_capturer.h

@@ -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;

test/frame_generator_unittest.cc

@@ -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(
+  std::unique_ptr<FrameGeneratorInterface> generator(
-      FrameGenerator::CreateFromYuvFile(files, kFrameWidth, kFrameHeight, 1));
+      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(
+  std::unique_ptr<FrameGeneratorInterface> generator(
-      files, kFrameWidth, kFrameHeight, kRepeatCount));
+      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(
+  std::unique_ptr<FrameGeneratorInterface> generator(
-      FrameGenerator::CreateSlideGenerator(kFrameWidth, kFrameHeight,
+      CreateSlideFrameGenerator(kFrameWidth, kFrameHeight, kRepeatCount));
-                                           kRepeatCount));
   uint64_t hashes[kGenCount];
   for (int i = 0; i < kGenCount; ++i) {
     hashes[i] = Hash(generator->NextFrame());

test/pc/e2e/analyzer/video/video_quality_analyzer_injection_helper.h

@@ -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"

test/scenario/BUILD.gn

@@ -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",

test/scenario/scenario_config.h

@@ -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;

test/scenario/video_stream.cc

@@ -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:

test/testsupport/ivf_video_frame_generator.cc

@@ -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_);

test/testsupport/ivf_video_frame_generator.h

@@ -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;

test/testsupport/ivf_video_frame_generator_unittest.cc

@@ -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 =
+    std::unique_ptr<test::FrameGeneratorInterface> frame_generator =
-        test::FrameGenerator::CreateSquareGenerator(
+        test::CreateSquareFrameGenerator(
-            kWidth, kHeight, test::FrameGenerator::OutputType::kI420,
+            kWidth, kHeight, test::FrameGeneratorInterface::OutputType::kI420,
             absl::nullopt);
 
     VideoCodec codec_settings;

video/BUILD.gn

@@ -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",

video/end_to_end_tests/call_operation_tests.cc

@@ -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(
+        std::unique_ptr<test::FrameGeneratorInterface> frame_generator(
-            test::FrameGenerator::CreateSquareGenerator(
+            test::CreateSquareFrameGenerator(kWidth, kHeight, absl::nullopt,
-                kWidth, kHeight, absl::nullopt, 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)

video/end_to_end_tests/multi_stream_tester.cc

@@ -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(
+          test::CreateSquareFrameGenerator(width, height, absl::nullopt,
-              width, height, absl::nullopt, absl::nullopt),
+                                           absl::nullopt),
           30, *task_queue_factory);
       frame_generators[i] = frame_generator;
       send_streams[i]->SetSource(frame_generator,

video/video_quality_test.cc

@@ -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(
+            test::CreateSquareFrameGenerator(static_cast<int>(thumbnail.width),
-                static_cast<int>(thumbnail.width),
+                                             static_cast<int>(thumbnail.height),
-                static_cast<int>(thumbnail.height), absl::nullopt,
+                                             absl::nullopt, 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(
+std::unique_ptr<test::FrameGeneratorInterface>
-    size_t video_idx) {
+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 "

video/video_quality_test.h

@@ -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);

video/video_send_stream_tests.cc

@@ -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"

video/video_stream_encoder_unittest.cc

@@ -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"