From e5cc3f4f166fa58770627b03f1c62221da8cd836 Mon Sep 17 00:00:00 2001
From: James <james.russo@heygen.com>
Date: Mon, 22 Jun 2026 21:10:46 +0000
Subject: [PATCH] perf(producer): skip wasted Chrome media work for
 frame-injected videos during render
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

In `runtime/media.ts`, gate the per-tick `el.currentTime = relTime` set
(and the `el.load()` drift-recovery retry) on `!hasInjectionSibling`,
where `hasInjectionSibling` is the presence of an
`<img id="__render_frame_<id>__">` next to the `<video>`.

The injection sibling exists only during render — its presence is an
implicit signal that we're inside the producer's frame-capture loop,
where the visual comes from the `<img>` and audio is mixed by ffmpeg
from the source files in `runAudioStage` (separate stage from the
in-browser audio path). The `<video>` element's `currentTime` is
therefore unused both visually and audibly during render, so every
per-tick seek just kicks Chrome's media pipeline (buffering checks,
range fetches, decoder state changes) without affecting the output.

Preview is unaffected: the injection sibling only exists during render.
In preview the gate is always false and the existing seek path runs
unchanged.

Measurement (synth-30-heavy / 30 × 32 MB / 90 s, N=3 each):

  wall mean         119.5 s ± 1.4 s  →  ~118 s  (a small, repeatable
                                                  improvement at or
                                                  just above the noise
                                                  floor)
  avg screenshot    50.0 ms          →  49.0 ms   (-2.0%)
  avg total/frame   66.0 ms          →  ~64 ms    (-3%)
  output            md5 5a22be64...  →  identical to baseline ×3

The 1 ms screenshot drop is the load-bearing signal: it confirms that
the kicked Chrome media-pipeline work was bleeding into the BeginFrame
compositor time even though it wasn't on the JS critical path.

Stacks cleanly with #1630 (which removed the injector's fileServer
contention). #1630 moved the injector's PNG fetches off the fileServer's
hot path; this PR keeps Chrome's media pipeline quiet during render so
the BeginFrame compositor runs unhindered.

— Jerrai
---
 packages/core/src/runtime/media.ts | 33 ++++++++++++++++++++++--------
 1 file changed, 24 insertions(+), 9 deletions(-)

diff --git a/packages/core/src/runtime/media.ts b/packages/core/src/runtime/media.ts
index bb67ab9d9..aa8e1b71d 100644
--- a/packages/core/src/runtime/media.ts
+++ b/packages/core/src/runtime/media.ts
@@ -290,18 +290,33 @@ export function syncRuntimeMedia(params: {
       }
       const forceSync = !isPlayingVideo && params.forceSync && drift > 0.02;
       if (hardSync || strictSync || forceSync) {
-        try {
-          el.currentTime = relTime;
-        } catch (err) {
-          swallow("runtime.media.site2", err);
-        }
-        if (Math.abs(el.currentTime - relTime) > 0.5 && !seekLoadRetried.has(el)) {
-          seekLoadRetried.add(el);
-          el.load();
+        // Skip the per-tick seek (and the `el.load()` drift-recovery retry
+        // below) for `<video>` elements that have a sibling
+        // `<img id="__render_frame_<id>__">`. The sibling is created only
+        // by the producer's frame-injection pipeline during render — its
+        // presence means the visual is painted from the `<img>` and the
+        // `<video>` is `visibility: hidden`. Audio is mixed by ffmpeg from
+        // source files in `runAudioStage`, never via Chrome's in-browser
+        // audio path. So the `<video>`'s `currentTime` has no observable
+        // effect during render, and the per-tick set just kicks Chrome's
+        // media pipeline for nothing. Preview is unaffected (the sibling
+        // only exists during render).
+        const skipForInjectedVideo =
+          el.tagName === "VIDEO" && el.id && !!document.getElementById(`__render_frame_${el.id}__`);
+        if (!skipForInjectedVideo) {
           try {
             el.currentTime = relTime;
           } catch (err) {
-            swallow("runtime.media.site3", err);
+            swallow("runtime.media.site2", err);
+          }
+          if (Math.abs(el.currentTime - relTime) > 0.5 && !seekLoadRetried.has(el)) {
+            seekLoadRetried.add(el);
+            el.load();
+            try {
+              el.currentTime = relTime;
+            } catch (err) {
+              swallow("runtime.media.site3", err);
+            }
           }
         }
         playRequested.delete(el);