test/testsupport/pendulum_frame_generator.cc - src.git - Git at Google

 /*
  *  Copyright (c) 2026 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/testsupport/pendulum_frame_generator.h"

 #include <algorithm>
 #include <cmath>
 #include <cstdint>
 #include <cstdio>
 #include <memory>
 #include <numbers>
 #include <optional>
 #include <span>
 #include <string>
 #include <utility>

 #include "api/scoped_refptr.h"
 #include "api/test/frame_generator_interface.h"
 #include "api/video/resolution.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "test/frame_utils.h"
 #include "test/testsupport/file_utils.h"
 #include "test/testsupport/frame_reader.h"

 namespace webrtc {
 namespace test {
 namespace {

 scoped_refptr<I420Buffer> ReadI420BufferFromFile(const std::string& filepath,
                                                  int width,
                                                  int height) {
   FILE* file = fopen(filepath.c_str(), "rb");
   if (file == nullptr) {
     return nullptr;
   }
   scoped_refptr<I420Buffer> buffer = ReadI420Buffer(width, height, file);
   fclose(file);
   return buffer;
 }

 class PendulumFrameReader : public FrameReader {
  public:
   explicit PendulumFrameReader(
       std::unique_ptr<PendulumFrameGenerator> generator)
       : generator_(std::move(generator)) {}

   scoped_refptr<I420Buffer> PullFrame() override {
     RTC_CHECK(generator_);
     ++frame_num_;
     return generator_->NextI420Frame();
   }

   scoped_refptr<I420Buffer> PullFrame(int* frame_num) override {
     *frame_num = frame_num_;
     return PullFrame();
   }

   scoped_refptr<I420Buffer> ReadFrame(int frame_num) override {
     return PullFrame();
   }

   scoped_refptr<I420Buffer> PullFrame(int* frame_num,
                                       Resolution resolution,
                                       Ratio framerate_scale) override {
     generator_->ChangeResolution(resolution.width, resolution.height);
     *frame_num = frame_num_;
     return PullFrame();
   }

   scoped_refptr<I420Buffer> ReadFrame(int frame_num,
                                       Resolution resolution) override {
     generator_->ChangeResolution(resolution.width, resolution.height);
     return PullFrame();
   }

   int num_frames() const override { return 1000000; }

  private:
   std::unique_ptr<PendulumFrameGenerator> generator_;
   int frame_num_ = 0;
 };

 }  // namespace

 PendulumFrameGenerator::PendulumFrameGenerator(Config config)
     : config_(config) {
   Reset();
   LoadOrGenerateSourceImage();
 }

 void PendulumFrameGenerator::Reset() {
   th1_ = 0.5;
   th2_ = 0.5;
   w1_ = 0.0;
   w2_ = 0.0;
   sim_time_ = 0.0;
   zoom_phase_ = 0.0;
   prng_state_ = 123456789;
 }

 void PendulumFrameGenerator::ChangeResolution(size_t width, size_t height) {
   config_.target_resolution.width = static_cast<int>(width);
   config_.target_resolution.height = static_cast<int>(height);
 }

 FrameGeneratorInterface::Resolution PendulumFrameGenerator::GetResolution()
     const {
   return {.width = static_cast<size_t>(config_.target_resolution.width),
           .height = static_cast<size_t>(config_.target_resolution.height)};
 }

 void PendulumFrameGenerator::StepPhysics(double dt) {
   constexpr double g = 9.81;
   constexpr double gamma = 0.08;
   constexpr double drive1_amp = 5.0;
   constexpr double drive1_freq = 2.4;
   constexpr double drive2_amp = 3.5;
   constexpr double drive2_freq = 1.7;

   auto derivs = [&](double t1, double t2, double v1, double v2, double t,
                     double& dt1, double& dt2, double& dv1, double& dv2) {
     double delta = t1 - t2;
     double den = 2.0 - std::cos(2.0 * delta);
     double num1 = -g * 3.0 * std::sin(t1) - g * std::sin(t1 - 2.0 * t2) -
                   2.0 * std::sin(delta) * (v2 * v2 + v1 * v1 * std::cos(delta));
     double num2 =
         2.0 * std::sin(delta) *
         (2.0 * v1 * v1 + 2.0 * g * std::cos(t1) + v2 * v2 * std::cos(delta));
     dt1 = v1;
     dt2 = v2;
     dv1 = (num1 / den) - gamma * v1 + drive1_amp * std::cos(drive1_freq * t);
     dv2 = (num2 / den) - gamma * v2 + drive2_amp * std::cos(drive2_freq * t);
   };

   double k1_t1, k1_t2, k1_v1, k1_v2;
   derivs(th1_, th2_, w1_, w2_, sim_time_, k1_t1, k1_t2, k1_v1, k1_v2);

   double k2_t1, k2_t2, k2_v1, k2_v2;
   derivs(th1_ + 0.5 * dt * k1_t1, th2_ + 0.5 * dt * k1_t2,
          w1_ + 0.5 * dt * k1_v1, w2_ + 0.5 * dt * k1_v2, sim_time_ + 0.5 * dt,
          k2_t1, k2_t2, k2_v1, k2_v2);

   double k3_t1, k3_t2, k3_v1, k3_v2;
   derivs(th1_ + 0.5 * dt * k2_t1, th2_ + 0.5 * dt * k2_t2,
          w1_ + 0.5 * dt * k2_v1, w2_ + 0.5 * dt * k2_v2, sim_time_ + 0.5 * dt,
          k3_t1, k3_t2, k3_v1, k3_v2);

   double k4_t1, k4_t2, k4_v1, k4_v2;
   derivs(th1_ + dt * k3_t1, th2_ + dt * k3_t2, w1_ + dt * k3_v1,
          w2_ + dt * k3_v2, sim_time_ + dt, k4_t1, k4_t2, k4_v1, k4_v2);

   th1_ += (dt / 6.0) * (k1_t1 + 2.0 * k2_t1 + 2.0 * k3_t1 + k4_t1);
   th2_ += (dt / 6.0) * (k1_t2 + 2.0 * k2_t2 + 2.0 * k3_t2 + k4_t2);
   w1_ += (dt / 6.0) * (k1_v1 + 2.0 * k2_v1 + 2.0 * k3_v1 + k4_v1);
   w2_ += (dt / 6.0) * (k1_v2 + 2.0 * k2_v2 + 2.0 * k3_v2 + k4_v2);
   sim_time_ += dt;
 }

 void PendulumFrameGenerator::LoadOrGenerateSourceImage() {
   const std::string& path =
       config_.source_image_path.empty()
           ? ResourcePath("difficult_photo_1850_1110", "yuv")
           : config_.source_image_path;

   FrameGeneratorInterface::Resolution res = config_.source_resolution;
   if (std::optional<webrtc::Resolution> parsed_res =
           ParseResolutionFromFileName(path)) {
     res.width = static_cast<size_t>(parsed_res->width);
     res.height = static_cast<size_t>(parsed_res->height);
   }

   source_image_ = ReadI420BufferFromFile(path, static_cast<int>(res.width),
                                          static_cast<int>(res.height));

   if (!source_image_) {
     RTC_LOG(LS_WARNING) << "Failed to read " << path
                         << ", trying photo_1850_1110.yuv";
     const std::string fallback_path = ResourcePath("photo_1850_1110", "yuv");
     const std::optional<webrtc::Resolution> fallback_res =
         ParseResolutionFromFileName(fallback_path);
     const int fallback_width = fallback_res ? fallback_res->width : 1850;
     const int fallback_height = fallback_res ? fallback_res->height : 1110;
     source_image_ =
         ReadI420BufferFromFile(fallback_path, fallback_width, fallback_height);
   }

   if (!source_image_) {
     RTC_LOG(LS_WARNING)
         << "Generating synthetic test pattern for pendulum generator";
     const int w = res.width > 0 ? static_cast<int>(res.width) : 1850;
     const int h = res.height > 0 ? static_cast<int>(res.height) : 1110;
     source_image_ = I420Buffer::Create(w, h);
     std::span<uint8_t> py(source_image_->MutableDataY(),
                           static_cast<size_t>(h * source_image_->StrideY()));
     for (int y = 0; y < h; ++y) {
       const int row = y * source_image_->StrideY();
       for (int x = 0; x < w; ++x) {
         const int pattern = ((x / 16) ^ (y / 16)) & 1 ? 200 : 40;
         const int fine_pattern = ((x / 2) ^ (y / 2)) & 1 ? 20 : -20;
         py[row + x] = static_cast<uint8_t>(
             std::clamp(pattern + fine_pattern + (x % 64), 16, 235));
       }
     }
     std::span<uint8_t> pu(
         source_image_->MutableDataU(),
         static_cast<size_t>((h / 2) * source_image_->StrideU()));
     std::span<uint8_t> pv(
         source_image_->MutableDataV(),
         static_cast<size_t>((h / 2) * source_image_->StrideV()));
     for (int y = 0; y < h / 2; ++y) {
       const int row_u = y * source_image_->StrideU();
       const int row_v = y * source_image_->StrideV();
       for (int x = 0; x < w / 2; ++x) {
         pu[row_u + x] = static_cast<uint8_t>(128 + ((x * 4) % 100) - 50);
         pv[row_v + x] = static_cast<uint8_t>(128 + ((y * 4) % 100) - 50);
       }
     }
   }
 }

 void PendulumFrameGenerator::ApplyNoise(I420Buffer* buffer) {
   const int width = buffer->width();
   const int height = buffer->height();
   const int stride_y = buffer->StrideY();
   std::span<uint8_t> plane(buffer->MutableDataY(),
                            static_cast<size_t>(stride_y * height));
   const int noise_range = 2 * config_.noise_level + 1;

   for (int y = 0; y < height; ++y) {
     const int row_offset = y * stride_y;
     for (int x = 0; x < width; ++x) {
       prng_state_ ^= prng_state_ << 13;
       prng_state_ ^= prng_state_ >> 17;
       prng_state_ ^= prng_state_ << 5;
       const int noise =
           static_cast<int>(prng_state_ % noise_range) - config_.noise_level;
       plane[row_offset + x] = static_cast<uint8_t>(
           std::clamp(static_cast<int>(plane[row_offset + x]) + noise, 0, 255));
     }
   }
 }

 FrameGeneratorInterface::VideoFrameData PendulumFrameGenerator::NextFrame() {
   return VideoFrameData(NextI420Frame(), std::nullopt);
 }

 scoped_refptr<I420Buffer> PendulumFrameGenerator::NextI420Frame() {
   RTC_CHECK(source_image_);
   const double dt = 1.0 / std::max(1, config_.fps);
   for (int i = 0; i < 4; ++i) {
     StepPhysics(dt / 4.0);
   }

   // Smoothly map angles to [0, 1] normalized coordinates
   const double norm_x = 0.5 + 0.5 * std::clamp(std::sin(th1_), -1.0, 1.0);
   const double norm_y = 0.5 + 0.5 * std::clamp(std::sin(th2_), -1.0, 1.0);

   // Dynamic zoom factor
   zoom_phase_ += (2.0 * std::numbers::pi * config_.zoom_speed * dt) +
                  0.02 * (std::abs(w1_) + std::abs(w2_));
   const double norm_z = 0.5 + 0.5 * std::sin(zoom_phase_);
   double zoom =
       config_.min_zoom + norm_z * (config_.max_zoom - config_.min_zoom);
   zoom = std::max(1.0, zoom);

   const int src_w = source_image_->width();
   const int src_h = source_image_->height();
   const int tgt_w = config_.target_resolution.width;
   const int tgt_h = config_.target_resolution.height;

   int max_crop_w, max_crop_h;
   if (static_cast<int64_t>(src_w) * tgt_h >
       static_cast<int64_t>(src_h) * tgt_w) {
     max_crop_h = src_h;
     max_crop_w =
         static_cast<int>((static_cast<int64_t>(src_h) * tgt_w) / tgt_h);
   } else {
     max_crop_w = src_w;
     max_crop_h =
         static_cast<int>((static_cast<int64_t>(src_w) * tgt_h) / tgt_w);
   }

   int crop_w = static_cast<int>(max_crop_w / zoom);
   int crop_h = static_cast<int>(max_crop_h / zoom);
   crop_w = std::clamp(crop_w & ~1, 2, src_w & ~1);
   crop_h = std::clamp(crop_h & ~1, 2, src_h & ~1);

   const int max_offset_x = (src_w - crop_w) & ~1;
   const int max_offset_y = (src_h - crop_h) & ~1;

   const int offset_x =
       std::clamp(static_cast<int>(norm_x * max_offset_x) & ~1, 0, max_offset_x);
   const int offset_y =
       std::clamp(static_cast<int>(norm_y * max_offset_y) & ~1, 0, max_offset_y);

   scoped_refptr<I420Buffer> target_buffer = I420Buffer::Create(tgt_w, tgt_h);
   target_buffer->CropAndScaleFrom(*source_image_, offset_x, offset_y, crop_w,
                                   crop_h);

   if (config_.noise_level > 0) {
     ApplyNoise(target_buffer.get());
   }

   return target_buffer;
 }

 std::unique_ptr<PendulumFrameGenerator> CreatePendulumFrameGenerator(
     const PendulumFrameGenerator::Config& config) {
   return std::make_unique<PendulumFrameGenerator>(config);
 }

 std::unique_ptr<FrameReader> CreatePendulumFrameReader(
     const PendulumFrameGenerator::Config& config) {
   return std::make_unique<PendulumFrameReader>(
       CreatePendulumFrameGenerator(config));
 }

 }  // namespace test
 }  // namespace webrtc
	/*
	* Copyright (c) 2026 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/testsupport/pendulum_frame_generator.h"

	#include <algorithm>
	#include <cmath>
	#include <cstdint>
	#include <cstdio>
	#include <memory>
	#include <numbers>
	#include <optional>
	#include <span>
	#include <string>
	#include <utility>

	#include "api/scoped_refptr.h"
	#include "api/test/frame_generator_interface.h"
	#include "api/video/resolution.h"
	#include "rtc_base/checks.h"
	#include "rtc_base/logging.h"
	#include "test/frame_utils.h"
	#include "test/testsupport/file_utils.h"
	#include "test/testsupport/frame_reader.h"

	namespace webrtc {
	namespace test {
	namespace {

	scoped_refptr<I420Buffer> ReadI420BufferFromFile(const std::string& filepath,
	int width,
	int height) {
	FILE* file = fopen(filepath.c_str(), "rb");
	if (file == nullptr) {
	return nullptr;
	}
	scoped_refptr<I420Buffer> buffer = ReadI420Buffer(width, height, file);
	fclose(file);
	return buffer;
	}

	class PendulumFrameReader : public FrameReader {
	public:
	explicit PendulumFrameReader(
	std::unique_ptr<PendulumFrameGenerator> generator)
	: generator_(std::move(generator)) {}

	scoped_refptr<I420Buffer> PullFrame() override {
	RTC_CHECK(generator_);
	++frame_num_;
	return generator_->NextI420Frame();
	}

	scoped_refptr<I420Buffer> PullFrame(int* frame_num) override {
	*frame_num = frame_num_;
	return PullFrame();
	}

	scoped_refptr<I420Buffer> ReadFrame(int frame_num) override {
	return PullFrame();
	}

	scoped_refptr<I420Buffer> PullFrame(int* frame_num,
	Resolution resolution,
	Ratio framerate_scale) override {
	generator_->ChangeResolution(resolution.width, resolution.height);
	*frame_num = frame_num_;
	return PullFrame();
	}

	scoped_refptr<I420Buffer> ReadFrame(int frame_num,
	Resolution resolution) override {
	generator_->ChangeResolution(resolution.width, resolution.height);
	return PullFrame();
	}

	int num_frames() const override { return 1000000; }

	private:
	std::unique_ptr<PendulumFrameGenerator> generator_;
	int frame_num_ = 0;
	};

	} // namespace

	PendulumFrameGenerator::PendulumFrameGenerator(Config config)
	: config_(config) {
	Reset();
	LoadOrGenerateSourceImage();
	}

	void PendulumFrameGenerator::Reset() {
	th1_ = 0.5;
	th2_ = 0.5;
	w1_ = 0.0;
	w2_ = 0.0;
	sim_time_ = 0.0;
	zoom_phase_ = 0.0;
	prng_state_ = 123456789;
	}

	void PendulumFrameGenerator::ChangeResolution(size_t width, size_t height) {
	config_.target_resolution.width = static_cast<int>(width);
	config_.target_resolution.height = static_cast<int>(height);
	}

	FrameGeneratorInterface::Resolution PendulumFrameGenerator::GetResolution()
	const {
	return {.width = static_cast<size_t>(config_.target_resolution.width),
	.height = static_cast<size_t>(config_.target_resolution.height)};
	}

	void PendulumFrameGenerator::StepPhysics(double dt) {
	constexpr double g = 9.81;
	constexpr double gamma = 0.08;
	constexpr double drive1_amp = 5.0;
	constexpr double drive1_freq = 2.4;
	constexpr double drive2_amp = 3.5;
	constexpr double drive2_freq = 1.7;

	auto derivs = [&](double t1, double t2, double v1, double v2, double t,
	double& dt1, double& dt2, double& dv1, double& dv2) {
	double delta = t1 - t2;
	double den = 2.0 - std::cos(2.0 * delta);
	double num1 = -g * 3.0 * std::sin(t1) - g * std::sin(t1 - 2.0 * t2) -
	2.0 * std::sin(delta) * (v2 * v2 + v1 * v1 * std::cos(delta));
	double num2 =
	2.0 * std::sin(delta) *
	(2.0 * v1 * v1 + 2.0 * g * std::cos(t1) + v2 * v2 * std::cos(delta));
	dt1 = v1;
	dt2 = v2;
	dv1 = (num1 / den) - gamma * v1 + drive1_amp * std::cos(drive1_freq * t);
	dv2 = (num2 / den) - gamma * v2 + drive2_amp * std::cos(drive2_freq * t);
	};

	double k1_t1, k1_t2, k1_v1, k1_v2;
	derivs(th1_, th2_, w1_, w2_, sim_time_, k1_t1, k1_t2, k1_v1, k1_v2);

	double k2_t1, k2_t2, k2_v1, k2_v2;
	derivs(th1_ + 0.5 * dt * k1_t1, th2_ + 0.5 * dt * k1_t2,
	w1_ + 0.5 * dt * k1_v1, w2_ + 0.5 * dt * k1_v2, sim_time_ + 0.5 * dt,
	k2_t1, k2_t2, k2_v1, k2_v2);

	double k3_t1, k3_t2, k3_v1, k3_v2;
	derivs(th1_ + 0.5 * dt * k2_t1, th2_ + 0.5 * dt * k2_t2,
	w1_ + 0.5 * dt * k2_v1, w2_ + 0.5 * dt * k2_v2, sim_time_ + 0.5 * dt,
	k3_t1, k3_t2, k3_v1, k3_v2);

	double k4_t1, k4_t2, k4_v1, k4_v2;
	derivs(th1_ + dt * k3_t1, th2_ + dt * k3_t2, w1_ + dt * k3_v1,
	w2_ + dt * k3_v2, sim_time_ + dt, k4_t1, k4_t2, k4_v1, k4_v2);

	th1_ += (dt / 6.0) * (k1_t1 + 2.0 * k2_t1 + 2.0 * k3_t1 + k4_t1);
	th2_ += (dt / 6.0) * (k1_t2 + 2.0 * k2_t2 + 2.0 * k3_t2 + k4_t2);
	w1_ += (dt / 6.0) * (k1_v1 + 2.0 * k2_v1 + 2.0 * k3_v1 + k4_v1);
	w2_ += (dt / 6.0) * (k1_v2 + 2.0 * k2_v2 + 2.0 * k3_v2 + k4_v2);
	sim_time_ += dt;
	}

	void PendulumFrameGenerator::LoadOrGenerateSourceImage() {
	const std::string& path =
	config_.source_image_path.empty()
	? ResourcePath("difficult_photo_1850_1110", "yuv")
	: config_.source_image_path;

	FrameGeneratorInterface::Resolution res = config_.source_resolution;
	if (std::optional<webrtc::Resolution> parsed_res =
	ParseResolutionFromFileName(path)) {
	res.width = static_cast<size_t>(parsed_res->width);
	res.height = static_cast<size_t>(parsed_res->height);
	}

	source_image_ = ReadI420BufferFromFile(path, static_cast<int>(res.width),
	static_cast<int>(res.height));

	if (!source_image_) {
	RTC_LOG(LS_WARNING) << "Failed to read " << path
	<< ", trying photo_1850_1110.yuv";
	const std::string fallback_path = ResourcePath("photo_1850_1110", "yuv");
	const std::optional<webrtc::Resolution> fallback_res =
	ParseResolutionFromFileName(fallback_path);
	const int fallback_width = fallback_res ? fallback_res->width : 1850;
	const int fallback_height = fallback_res ? fallback_res->height : 1110;
	source_image_ =
	ReadI420BufferFromFile(fallback_path, fallback_width, fallback_height);
	}

	if (!source_image_) {
	RTC_LOG(LS_WARNING)
	<< "Generating synthetic test pattern for pendulum generator";
	const int w = res.width > 0 ? static_cast<int>(res.width) : 1850;
	const int h = res.height > 0 ? static_cast<int>(res.height) : 1110;
	source_image_ = I420Buffer::Create(w, h);
	std::span<uint8_t> py(source_image_->MutableDataY(),
	static_cast<size_t>(h * source_image_->StrideY()));
	for (int y = 0; y < h; ++y) {
	const int row = y * source_image_->StrideY();
	for (int x = 0; x < w; ++x) {
	const int pattern = ((x / 16) ^ (y / 16)) & 1 ? 200 : 40;
	const int fine_pattern = ((x / 2) ^ (y / 2)) & 1 ? 20 : -20;
	py[row + x] = static_cast<uint8_t>(
	std::clamp(pattern + fine_pattern + (x % 64), 16, 235));
	}
	}
	std::span<uint8_t> pu(
	source_image_->MutableDataU(),
	static_cast<size_t>((h / 2) * source_image_->StrideU()));
	std::span<uint8_t> pv(
	source_image_->MutableDataV(),
	static_cast<size_t>((h / 2) * source_image_->StrideV()));
	for (int y = 0; y < h / 2; ++y) {
	const int row_u = y * source_image_->StrideU();
	const int row_v = y * source_image_->StrideV();
	for (int x = 0; x < w / 2; ++x) {
	pu[row_u + x] = static_cast<uint8_t>(128 + ((x * 4) % 100) - 50);
	pv[row_v + x] = static_cast<uint8_t>(128 + ((y * 4) % 100) - 50);
	}
	}
	}
	}

	void PendulumFrameGenerator::ApplyNoise(I420Buffer* buffer) {
	const int width = buffer->width();
	const int height = buffer->height();
	const int stride_y = buffer->StrideY();
	std::span<uint8_t> plane(buffer->MutableDataY(),
	static_cast<size_t>(stride_y * height));
	const int noise_range = 2 * config_.noise_level + 1;

	for (int y = 0; y < height; ++y) {
	const int row_offset = y * stride_y;
	for (int x = 0; x < width; ++x) {
	prng_state_ ^= prng_state_ << 13;
	prng_state_ ^= prng_state_ >> 17;
	prng_state_ ^= prng_state_ << 5;
	const int noise =
	static_cast<int>(prng_state_ % noise_range) - config_.noise_level;
	plane[row_offset + x] = static_cast<uint8_t>(
	std::clamp(static_cast<int>(plane[row_offset + x]) + noise, 0, 255));
	}
	}
	}

	FrameGeneratorInterface::VideoFrameData PendulumFrameGenerator::NextFrame() {
	return VideoFrameData(NextI420Frame(), std::nullopt);
	}

	scoped_refptr<I420Buffer> PendulumFrameGenerator::NextI420Frame() {
	RTC_CHECK(source_image_);
	const double dt = 1.0 / std::max(1, config_.fps);
	for (int i = 0; i < 4; ++i) {
	StepPhysics(dt / 4.0);
	}

	// Smoothly map angles to [0, 1] normalized coordinates
	const double norm_x = 0.5 + 0.5 * std::clamp(std::sin(th1_), -1.0, 1.0);
	const double norm_y = 0.5 + 0.5 * std::clamp(std::sin(th2_), -1.0, 1.0);

	// Dynamic zoom factor
	zoom_phase_ += (2.0 * std::numbers::pi * config_.zoom_speed * dt) +
	0.02 * (std::abs(w1_) + std::abs(w2_));
	const double norm_z = 0.5 + 0.5 * std::sin(zoom_phase_);
	double zoom =
	config_.min_zoom + norm_z * (config_.max_zoom - config_.min_zoom);
	zoom = std::max(1.0, zoom);

	const int src_w = source_image_->width();
	const int src_h = source_image_->height();
	const int tgt_w = config_.target_resolution.width;
	const int tgt_h = config_.target_resolution.height;

	int max_crop_w, max_crop_h;
	if (static_cast<int64_t>(src_w) * tgt_h >
	static_cast<int64_t>(src_h) * tgt_w) {
	max_crop_h = src_h;
	max_crop_w =
	static_cast<int>((static_cast<int64_t>(src_h) * tgt_w) / tgt_h);
	} else {
	max_crop_w = src_w;
	max_crop_h =
	static_cast<int>((static_cast<int64_t>(src_w) * tgt_h) / tgt_w);
	}

	int crop_w = static_cast<int>(max_crop_w / zoom);
	int crop_h = static_cast<int>(max_crop_h / zoom);
	crop_w = std::clamp(crop_w & ~1, 2, src_w & ~1);
	crop_h = std::clamp(crop_h & ~1, 2, src_h & ~1);

	const int max_offset_x = (src_w - crop_w) & ~1;
	const int max_offset_y = (src_h - crop_h) & ~1;

	const int offset_x =
	std::clamp(static_cast<int>(norm_x * max_offset_x) & ~1, 0, max_offset_x);
	const int offset_y =
	std::clamp(static_cast<int>(norm_y * max_offset_y) & ~1, 0, max_offset_y);

	scoped_refptr<I420Buffer> target_buffer = I420Buffer::Create(tgt_w, tgt_h);
	target_buffer->CropAndScaleFrom(*source_image_, offset_x, offset_y, crop_w,
	crop_h);

	if (config_.noise_level > 0) {
	ApplyNoise(target_buffer.get());
	}

	return target_buffer;
	}

	std::unique_ptr<PendulumFrameGenerator> CreatePendulumFrameGenerator(
	const PendulumFrameGenerator::Config& config) {
	return std::make_unique<PendulumFrameGenerator>(config);
	}

	std::unique_ptr<FrameReader> CreatePendulumFrameReader(
	const PendulumFrameGenerator::Config& config) {
	return std::make_unique<PendulumFrameReader>(
	CreatePendulumFrameGenerator(config));
	}

	} // namespace test
	} // namespace webrtc