mediasoup 3.26.0 → 3.27.1

package/worker/tasks.py

@@ -8,8 +8,11 @@ Usage:
     invoke --list
 """
 
+import glob
 import inspect
+import json
 import os
+import re
 import shutil
 import sys
 from contextlib import contextmanager, suppress
@@ -26,6 +29,22 @@ MEDIASOUP_INSTALL_DIR = (
     os.getenv("MEDIASOUP_INSTALL_DIR") or f"{MEDIASOUP_OUT_DIR}/{MEDIASOUP_BUILDTYPE}"
 )
 BUILD_DIR = os.getenv("BUILD_DIR") or f"{MEDIASOUP_INSTALL_DIR}/build"
+# NOTE: Each set of Meson options gets its own build directory. Meson keeps the
+# options it's not given again, so sharing a single build directory would leak
+# options such as `ms_build_tests` (which adds MS_TEST and MS_LOG_STD to every
+# compiled file) into the next build, and would also rebuild everything on every
+# switch from a task to another.
+TEST_BUILD_DIR = f"{BUILD_DIR}-test"
+TEST_ASAN_ADDRESS_BUILD_DIR = f"{BUILD_DIR}-test-asan-address"
+TEST_ASAN_UNDEFINED_BUILD_DIR = f"{BUILD_DIR}-test-asan-undefined"
+FUZZER_BUILD_DIR = f"{BUILD_DIR}-fuzzer"
+BUILD_DIRS = [
+    BUILD_DIR,
+    TEST_BUILD_DIR,
+    TEST_ASAN_ADDRESS_BUILD_DIR,
+    TEST_ASAN_UNDEFINED_BUILD_DIR,
+    FUZZER_BUILD_DIR,
+]
 # Custom pip folder for invoke package.
 # NOTE: We invoke `pip install` always with `--no-user` to make it not complain
 # about "can not combine --user and --target".
@@ -43,7 +62,7 @@ NUM_CORES = (
 )
 PYTHON = os.getenv("PYTHON") or sys.executable
 MESON = os.getenv("MESON") or f"{PIP_MESON_NINJA_DIR}/bin/meson"
-MESON_VERSION = os.getenv("MESON_VERSION") or "1.11.2"
+MESON_VERSION = os.getenv("MESON_VERSION") or "1.12.0"
 # MESON_ARGS can be used to provide extra configuration parameters to meson,
 # such as adding defines or changing optimization options. For instance, use
 # `MESON_ARGS="-Dms_log_trace=true -Dms_log_file_line=true" npm i` to compile
@@ -57,10 +76,7 @@ MESON_ARGS = (
     if os.name == "nt"
     else ""
 )
-# Let's use a specific version of ninja to avoid buggy version 1.11.1:
-# https://mediasoup.discourse.group/t/partly-solved-could-not-detect-ninja-v1-8-2-or-newer/
-# https://github.com/ninja-build/ninja/issues/2211
-NINJA_VERSION = os.getenv("NINJA_VERSION") or "1.10.2.4"
+NINJA_VERSION = os.getenv("NINJA_VERSION") or "1.13.2"
 RUFF_VERSION = os.getenv("RUFF_VERSION") or "0.15.15"
 NPM = os.getenv("NPM") or "npm"
 DOCKER = os.getenv("DOCKER") or "docker"
@@ -155,16 +171,73 @@ def meson_ninja(ctx):
     )
 
 
+def default_meson_options():
+    """
+    Return every option in meson_options.txt mapped to its default value
+    """
+
+    options = {}
+
+    with open(f"{WORKER_DIR}/meson_options.txt", encoding="utf-8") as options_file:
+        for line in options_file:
+            match = re.match(r"\s*option\('([^']+)'.*value:\s*([^,)]+)", line)
+
+            if match:
+                options[match.group(1)] = match.group(2).strip().strip(chr(39))
+
+    return options
+
+
+def configured_meson_options(build_dir):
+    """
+    Return the name of every option the given build directory is configured with
+    """
+
+    try:
+        with open(
+            f"{build_dir}/meson-info/intro-buildoptions.json", encoding="utf-8"
+        ) as options_file:
+            return {option["name"] for option in json.load(options_file)}
+    except (OSError, ValueError):
+        return set()
+
+
 @task(pre=[meson_ninja])
-def setup(ctx, meson_args=MESON_ARGS):
+def setup(ctx, meson_args=MESON_ARGS, build_dir=BUILD_DIR):
     """
     Run meson setup
     """
 
+    # NOTE: Meson keeps every option of an already configured build directory
+    # that is not given again, so all of them are passed with their default
+    # value before meson_args, which comes later and hence wins. Without this,
+    # removing an option from MESON_ARGS would silently keep the value it was
+    # given the previous time.
+    default_options = default_meson_options()
+    default_options_args = " ".join(
+        f"-D{name}={value}" for name, value in default_options.items()
+    )
+
+    # NOTE: Given an already configured build directory, "meson setup" just
+    # prints "Directory already configured" and exits successfully, silently
+    # ignoring the given options. So it must be told to reconfigure it or
+    # changing MESON_ARGS would have no effect until the directory is removed.
+    reconfigure = ""
+
+    if os.path.isdir(f"{build_dir}/meson-info"):
+        # NOTE: Meson validates the given options against the ones it has cached
+        # before reading meson_options.txt again, so a build directory configured
+        # back when an option didn't exist yet cannot be reconfigured with it.
+        # There is nothing to preserve in that case, so it's built from scratch.
+        if default_options.keys() <= configured_meson_options(build_dir):
+            reconfigure = "--reconfigure"
+        else:
+            shutil.rmtree(build_dir, ignore_errors=True)
+
     if MEDIASOUP_BUILDTYPE == "Release":
         with cd_worker():
             ctx.run(
-                f'"{MESON}" setup --prefix "{MEDIASOUP_INSTALL_DIR}" --bindir "" --libdir "" --buildtype release -Db_ndebug=true {meson_args} "{BUILD_DIR}"',
+                f'"{MESON}" setup {reconfigure} --prefix "{MEDIASOUP_INSTALL_DIR}" --bindir "" --libdir "" --buildtype release -Db_ndebug=true {default_options_args} {meson_args} "{build_dir}"',
                 echo=True,
                 pty=PTY_SUPPORTED,
                 shell=SHELL,
@@ -172,7 +245,7 @@ def setup(ctx, meson_args=MESON_ARGS):
     elif MEDIASOUP_BUILDTYPE == "Debug":
         with cd_worker():
             ctx.run(
-                f'"{MESON}" setup --prefix "{MEDIASOUP_INSTALL_DIR}" --bindir "" --libdir "" --buildtype debug {meson_args} "{BUILD_DIR}"',
+                f'"{MESON}" setup {reconfigure} --prefix "{MEDIASOUP_INSTALL_DIR}" --bindir "" --libdir "" --buildtype debug {default_options_args} {meson_args} "{build_dir}"',
                 echo=True,
                 pty=PTY_SUPPORTED,
                 shell=SHELL,
@@ -180,7 +253,7 @@ def setup(ctx, meson_args=MESON_ARGS):
     else:
         with cd_worker():
             ctx.run(
-                f'"{MESON}" setup --prefix "{MEDIASOUP_INSTALL_DIR}" --bindir "" --libdir "" --buildtype {MEDIASOUP_BUILDTYPE} -Db_ndebug=if-release {meson_args} "{BUILD_DIR}"',
+                f'"{MESON}" setup {reconfigure} --prefix "{MEDIASOUP_INSTALL_DIR}" --bindir "" --libdir "" --buildtype {MEDIASOUP_BUILDTYPE} -Db_ndebug=if-release {default_options_args} {meson_args} "{build_dir}"',
                 echo=True,
                 pty=PTY_SUPPORTED,
                 shell=SHELL,
@@ -190,19 +263,36 @@ def setup(ctx, meson_args=MESON_ARGS):
 @task
 def clean(ctx):
     """
-    Clean the installation directory
+    Clean the objects and binaries of mediasoup, keeping those of subprojects
     """
 
-    shutil.rmtree(MEDIASOUP_INSTALL_DIR, ignore_errors=True)
+    # NOTE: Meson keeps the objects of each target in a "<target>.p" directory,
+    # and those of the subprojects and the dependencies in their own
+    # subdirectories, so this removes just what belongs to mediasoup itself.
+    # glob.escape() is needed because the path of the build directory may
+    # contain characters that glob would otherwise take as wildcards.
+    for build_dir in BUILD_DIRS:
+        for path in glob.glob(f"{glob.escape(build_dir)}/*.p"):
+            shutil.rmtree(path, ignore_errors=True)
+
+    # NOTE: The installed artifacts are files, while the build directories are
+    # directories.
+    for path in glob.glob(f"{glob.escape(MEDIASOUP_INSTALL_DIR)}/*"):
+        if os.path.isfile(path):
+            # NOTE: Be as tolerant as shutil.rmtree() above, since in Windows
+            # removing a binary that is being run fails.
+            with suppress(OSError):
+                os.remove(path)
 
 
 @task
 def clean_build(ctx):
     """
-    Clean the build directory
+    Clean the build directories
     """
 
-    shutil.rmtree(BUILD_DIR, ignore_errors=True)
+    for build_dir in BUILD_DIRS:
+        shutil.rmtree(build_dir, ignore_errors=True)
 
 
 @task
@@ -246,7 +336,6 @@ def clean_all(ctx):
             )
 
         shutil.rmtree(MEDIASOUP_OUT_DIR, ignore_errors=True)
-        shutil.rmtree("include/FBS", ignore_errors=True)
 
 
 @task(pre=[meson_ninja])
@@ -274,22 +363,29 @@ def update_wrap_file(ctx, subproject):
         )
 
 
-@task(pre=[setup])
-def flatc(ctx):
+@task(pre=[meson_ninja])
+def flatc(ctx, meson_args=MESON_ARGS, build_dir=BUILD_DIR):
     """
     Compile FlatBuffers FBS files
     """
 
+    # NOTE: The generated C++ headers are written into the build directory, so
+    # they must be generated in the very same build directory that compiles them
+    # and with the very same Meson options. setup() is called here instead of
+    # being declared as a pre task because a pre task cannot receive the
+    # parameters given to the task it precedes.
+    setup(ctx, meson_args=meson_args, build_dir=build_dir)
+
     with cd_worker():
         ctx.run(
-            f'"{MESON}" compile -C "{BUILD_DIR}" flatbuffers-generator',
+            f'"{MESON}" compile -C "{build_dir}" flatbuffers-generator',
             echo=True,
             pty=PTY_SUPPORTED,
             shell=SHELL,
         )
 
 
-@task(pre=[setup, flatc], default=True)
+@task(pre=[flatc], default=True)
 def mediasoup_worker(ctx):
     """
     Compile mediasoup-worker binary
@@ -317,7 +413,7 @@ def mediasoup_worker(ctx):
         )
 
 
-@task(pre=[setup, flatc])
+@task(pre=[flatc])
 def libmediasoup_worker(ctx):
     """
     Compile libmediasoup-worker library
@@ -339,7 +435,7 @@ def libmediasoup_worker(ctx):
         )
 
 
-@task(pre=[setup, flatc])
+@task(pre=[flatc])
 def xcode(ctx):
     """
     Setup Xcode project
@@ -419,7 +515,49 @@ def format(ctx):
         ctx.run(f'"{PYTHON}" -m ruff format', echo=True, pty=PTY_SUPPORTED, shell=SHELL)
 
 
-@task(pre=[call(setup, meson_args=MESON_ARGS + " -Dms_build_tests=true"), flatc])
+@task(
+    pre=[
+        call(
+            flatc,
+            meson_args=MESON_ARGS + " -Dms_build_tests=true",
+            build_dir=TEST_BUILD_DIR,
+        )
+    ]
+)
+def tidy_setup(ctx):
+    """
+    Configure the build directory that `tidy` uses, generating its
+    compile_commands.json
+
+    NOTE: Test files are only given the Catch2 include paths when
+    `ms_build_tests` is enabled, so clang-tidy needs this very build directory to
+    analyze them.
+    """
+
+
+@task(pre=[tidy_setup])
+def tidy_normalize_compile_commands(ctx):
+    """
+    Rewrite the paths of the compile_commands.json that `tidy` uses so that
+    third party clang-tidy runners can resolve them
+
+    NOTE: Just needed by CI, since it doesn't run `tidy` but its own clang-tidy
+    over the files of the pull request.
+    """
+
+    with cd_worker():
+        ctx.run(
+            f'"{NPM}" run normalize-compile-commands --prefix scripts/',
+            echo=True,
+            pty=PTY_SUPPORTED,
+            shell=SHELL,
+            # NOTE: Tell the script which build directory holds the
+            # compile_commands.json to use.
+            env={**os.environ, "BUILD_DIR": TEST_BUILD_DIR},
+        )
+
+
+@task(pre=[tidy_setup])
 def tidy(ctx):
     """
     Performs C++ code checks according to `worker/.clang-tidy` rules
@@ -431,10 +569,13 @@ def tidy(ctx):
             echo=True,
             pty=PTY_SUPPORTED,
             shell=SHELL,
+            # NOTE: Tell the script which build directory holds the
+            # compile_commands.json to use.
+            env={**os.environ, "BUILD_DIR": TEST_BUILD_DIR},
         )
 
 
-@task(pre=[call(setup, meson_args=MESON_ARGS + " -Dms_build_tests=true"), flatc])
+@task(pre=[tidy_setup])
 def tidy_fix(ctx):
     """
     Performs C++ code checks according to `worker/.clang-tidy` rules and applies
@@ -447,10 +588,21 @@ def tidy_fix(ctx):
             echo=True,
             pty=PTY_SUPPORTED,
             shell=SHELL,
+            # NOTE: Tell the script which build directory holds the
+            # compile_commands.json to use.
+            env={**os.environ, "BUILD_DIR": TEST_BUILD_DIR},
         )
 
 
-@task(pre=[call(setup, meson_args=MESON_ARGS + " -Dms_build_tests=true"), flatc])
+@task(
+    pre=[
+        call(
+            flatc,
+            meson_args=MESON_ARGS + " -Dms_build_tests=true",
+            build_dir=TEST_BUILD_DIR,
+        )
+    ]
+)
 def test(ctx):
     """
     Run worker tests
@@ -458,14 +610,14 @@ def test(ctx):
 
     with cd_worker():
         ctx.run(
-            f'"{MESON}" compile -C "{BUILD_DIR}" -j {NUM_CORES} mediasoup-worker-test',
+            f'"{MESON}" compile -C "{TEST_BUILD_DIR}" -j {NUM_CORES} mediasoup-worker-test',
             echo=True,
             pty=PTY_SUPPORTED,
             shell=SHELL,
         )
     with cd_worker():
         ctx.run(
-            f'"{MESON}" install -C "{BUILD_DIR}" --no-rebuild --tags mediasoup-worker-test',
+            f'"{MESON}" install -C "{TEST_BUILD_DIR}" --no-rebuild --tags mediasoup-worker-test',
             echo=True,
             pty=PTY_SUPPORTED,
             shell=SHELL,
@@ -478,7 +630,7 @@ def test(ctx):
 
     with cd_worker():
         ctx.run(
-            f'"{BUILD_DIR}/{mediasoup_worker_test}" --invisibles --colour-mode=ansi {mediasoup_test_tags}',
+            f'"{TEST_BUILD_DIR}/{mediasoup_worker_test}" --invisibles --colour-mode=ansi {mediasoup_test_tags}',
             echo=True,
             pty=PTY_SUPPORTED,
             shell=SHELL,
@@ -488,11 +640,11 @@ def test(ctx):
 @task(
     pre=[
         call(
-            setup,
+            flatc,
             meson_args=MESON_ARGS
             + " -Dms_build_tests=true -Db_sanitize=address -Db_lundef=false",
-        ),
-        flatc,
+            build_dir=TEST_ASAN_ADDRESS_BUILD_DIR,
+        )
     ]
 )
 def test_asan_address(ctx):
@@ -502,14 +654,14 @@ def test_asan_address(ctx):
 
     with cd_worker():
         ctx.run(
-            f'"{MESON}" compile -C "{BUILD_DIR}" -j {NUM_CORES} mediasoup-worker-test-asan-address',
+            f'"{MESON}" compile -C "{TEST_ASAN_ADDRESS_BUILD_DIR}" -j {NUM_CORES} mediasoup-worker-test-asan-address',
             echo=True,
             pty=PTY_SUPPORTED,
             shell=SHELL,
         )
     with cd_worker():
         ctx.run(
-            f'"{MESON}" install -C "{BUILD_DIR}" --no-rebuild --tags mediasoup-worker-test-asan-address',
+            f'"{MESON}" install -C "{TEST_ASAN_ADDRESS_BUILD_DIR}" --no-rebuild --tags mediasoup-worker-test-asan-address',
             echo=True,
             pty=PTY_SUPPORTED,
             shell=SHELL,
@@ -519,7 +671,7 @@ def test_asan_address(ctx):
 
     with cd_worker():
         ctx.run(
-            f'"{BUILD_DIR}/mediasoup-worker-test-asan-address" --invisibles {mediasoup_test_tags}',
+            f'"{TEST_ASAN_ADDRESS_BUILD_DIR}/mediasoup-worker-test-asan-address" --invisibles {mediasoup_test_tags}',
             echo=True,
             pty=PTY_SUPPORTED,
             shell=SHELL,
@@ -533,11 +685,11 @@ def test_asan_address(ctx):
 @task(
     pre=[
         call(
-            setup,
+            flatc,
             meson_args=MESON_ARGS
             + " -Dms_build_tests=true -Db_sanitize=undefined -Db_lundef=false",
-        ),
-        flatc,
+            build_dir=TEST_ASAN_UNDEFINED_BUILD_DIR,
+        )
     ]
 )
 def test_asan_undefined(ctx):
@@ -547,14 +699,14 @@ def test_asan_undefined(ctx):
 
     with cd_worker():
         ctx.run(
-            f'"{MESON}" compile -C "{BUILD_DIR}" -j {NUM_CORES} mediasoup-worker-test-asan-undefined',
+            f'"{MESON}" compile -C "{TEST_ASAN_UNDEFINED_BUILD_DIR}" -j {NUM_CORES} mediasoup-worker-test-asan-undefined',
             echo=True,
             pty=PTY_SUPPORTED,
             shell=SHELL,
         )
     with cd_worker():
         ctx.run(
-            f'"{MESON}" install -C "{BUILD_DIR}" --no-rebuild --tags mediasoup-worker-test-asan-undefined',
+            f'"{MESON}" install -C "{TEST_ASAN_UNDEFINED_BUILD_DIR}" --no-rebuild --tags mediasoup-worker-test-asan-undefined',
             echo=True,
             pty=PTY_SUPPORTED,
             shell=SHELL,
@@ -564,7 +716,7 @@ def test_asan_undefined(ctx):
 
     with cd_worker():
         ctx.run(
-            f'"{BUILD_DIR}/mediasoup-worker-test-asan-undefined" --invisibles {mediasoup_test_tags}',
+            f'"{TEST_ASAN_UNDEFINED_BUILD_DIR}/mediasoup-worker-test-asan-undefined" --invisibles {mediasoup_test_tags}',
             echo=True,
             pty=PTY_SUPPORTED,
             shell=SHELL,
@@ -580,11 +732,11 @@ def test_asan_undefined(ctx):
 @task(
     pre=[
         call(
-            setup,
+            flatc,
             meson_args=MESON_ARGS
             + " -Dms_build_fuzzer=true -Db_sanitize=address -Db_lundef=false",
-        ),
-        flatc,
+            build_dir=FUZZER_BUILD_DIR,
+        )
     ]
 )
 def fuzzer(ctx):
@@ -593,18 +745,18 @@ def fuzzer(ctx):
     """
 
     # NOTE: We need to pass '-Db_sanitize=address' to enable fuzzer in all Meson
-    # subprojects, so we pass it to the setup() task.
+    # subprojects, so we pass it to the setup() task (through the flatc() task).
 
     with cd_worker():
         ctx.run(
-            f'"{MESON}" compile -C "{BUILD_DIR}" -j {NUM_CORES} mediasoup-worker-fuzzer',
+            f'"{MESON}" compile -C "{FUZZER_BUILD_DIR}" -j {NUM_CORES} mediasoup-worker-fuzzer',
             echo=True,
             pty=PTY_SUPPORTED,
             shell=SHELL,
         )
     with cd_worker():
         ctx.run(
-            f'"{MESON}" install -C "{BUILD_DIR}" --no-rebuild --tags mediasoup-worker-fuzzer',
+            f'"{MESON}" install -C "{FUZZER_BUILD_DIR}" --no-rebuild --tags mediasoup-worker-fuzzer',
             echo=True,
             pty=PTY_SUPPORTED,
             shell=SHELL,
@@ -619,7 +771,7 @@ def fuzzer_run_all(ctx):
 
     with cd_worker():
         ctx.run(
-            f'LSAN_OPTIONS=verbosity=1:log_threads=1 "{BUILD_DIR}/mediasoup-worker-fuzzer" -artifact_prefix=fuzzer/reports/ -max_len=1400 fuzzer/new-corpus deps/webrtc-fuzzer-corpora/corpora/stun-corpus deps/webrtc-fuzzer-corpora/corpora/rtp-corpus deps/webrtc-fuzzer-corpora/corpora/rtcp-corpus',
+            f'LSAN_OPTIONS=verbosity=1:log_threads=1 "{FUZZER_BUILD_DIR}/mediasoup-worker-fuzzer" -artifact_prefix=fuzzer/reports/ -max_len=1400 fuzzer/new-corpus deps/webrtc-fuzzer-corpora/corpora/stun-corpus deps/webrtc-fuzzer-corpora/corpora/rtp-corpus deps/webrtc-fuzzer-corpora/corpora/rtcp-corpus',
             echo=True,
             pty=PTY_SUPPORTED,
             shell=SHELL,

package/worker/test/include/RTC/BWE/helpers/LinkSimulator.hpp

@@ -0,0 +1,117 @@
+#ifndef MS_TEST_RTC_BWE_LINK_SIMULATOR_HPP
+#define MS_TEST_RTC_BWE_LINK_SIMULATOR_HPP
+
+#include "common.hpp"
+#include "RTC/BWE/BweTypes.hpp"
+
+namespace bweHelpers
+{
+	/**
+	 * A stream that produces frames at a given frame rate and bitrate, split into
+	 * packets of at most one MTU.
+	 */
+	class RtpStream
+	{
+	public:
+		/**
+		 * Offset added to the send times so that they don't share the origin with
+		 * the arrival ones, which would hide a mistake mixing both references.
+		 */
+		static constexpr int64_t SendSideOffsetUs{ 1000 * 1000 };
+
+	public:
+		RtpStream(int fps, int64_t bitrateBps);
+
+		RtpStream& operator=(const RtpStream&) = delete;
+
+		RtpStream(const RtpStream&) = delete;
+
+		/**
+		 * Generate a frame and split it into packets, appending them to
+		 * `packetResults`. Nothing is generated if it's called before the next frame
+		 * is due.
+		 *
+		 * @returns The send time at which the next frame can be generated.
+		 */
+		int64_t GenerateFrame(
+		  int64_t timeNowUs,
+		  int64_t& nextSequenceNumber,
+		  std::vector<RTC::BWE::Types::PacketResult>& packetResults);
+
+		/**
+		 * Send time at which the next frame can be generated.
+		 */
+		int64_t GetNextRtpTimeUs() const
+		{
+			return this->nextRtpTimeUs;
+		}
+
+		int64_t GetBitrateBps() const
+		{
+			return this->bitrateBps;
+		}
+
+		void SetBitrateBps(int64_t bitrateBps);
+
+		/**
+		 * Orders streams by which one is due to produce a frame first.
+		 */
+		static bool Compare(const std::unique_ptr<RtpStream>& lhs, const std::unique_ptr<RtpStream>& rhs);
+
+	private:
+		const int fps;
+		int64_t bitrateBps;
+		int64_t nextRtpTimeUs{ 0 };
+	};
+
+	/**
+	 * Pushes the frames of several streams through a link of a given capacity and
+	 * decides when each packet arrives.
+	 *
+	 * The link has no queue limit: a packet takes as long to arrive as its size
+	 * divided by the capacity, and packets that don't fit queue up behind the
+	 * previous one for as long as needed.
+	 */
+	class LinkSimulator
+	{
+	public:
+		LinkSimulator(int64_t capacityBps, int64_t timeNowUs);
+
+		LinkSimulator& operator=(const LinkSimulator&) = delete;
+
+		LinkSimulator(const LinkSimulator&) = delete;
+
+		/**
+		 * Add a stream, whose ownership is taken.
+		 */
+		void AddStream(std::unique_ptr<RtpStream> stream);
+
+		void SetCapacityBps(int64_t capacityBps);
+
+		/**
+		 * Divide `bitrateBps` among the streams, keeping the ratios they had.
+		 */
+		void SetBitrateBps(int64_t bitrateBps);
+
+		/**
+		 * Generate a frame of whichever stream is due first and push its packets
+		 * through the link, appending them to `packetResults` with the time at which
+		 * each one arrives.
+		 *
+		 * @returns The send time at which the next frame can be generated.
+		 */
+		int64_t GenerateFrame(
+		  int64_t timeNowUs,
+		  int64_t& nextSequenceNumber,
+		  std::vector<RTC::BWE::Types::PacketResult>& packetResults);
+
+	private:
+		// Capacity of the simulated link (bps).
+		int64_t capacityBps;
+		// Time at which the latest packet arrived.
+		int64_t prevArrivalTimeUs;
+		std::vector<std::unique_ptr<RtpStream>> streams;
+	};
+} // namespace bweHelpers
+
+#endif