fix: coalesce duplicate playback seeks

Author: Priveetee

src/seek-controller.ts

@@ -1,27 +1,44 @@
 export type SeekExecutor = (positionMs: number) => Promise<void>;
 
+type SeekRequest = {
+  key: string;
+  positionMs: number;
+  execute: SeekExecutor;
+};
+
 export class SeekController {
-  private requestedMs: number | null = null;
+  private requested: SeekRequest | null = null;
+  private activeKey: string | null = null;
   private running: Promise<void> | null = null;
 
-  seek(positionMs: number, execute: SeekExecutor): Promise<void> {
-    this.requestedMs = Math.max(0, Math.round(positionMs));
-    if (!this.running) this.running = this.drain(execute).finally(() => (this.running = null));
+  seek(positionMs: number, key: string, execute: SeekExecutor, cancel: () => void): Promise<void> {
+    if (
+      this.running &&
+      (this.requested?.key === key || (!this.requested && this.activeKey === key))
+    ) {
+      return this.running;
+    }
+    this.requested = { key, positionMs: Math.max(0, Math.round(positionMs)), execute };
+    if (this.activeKey !== null) cancel();
+    if (!this.running) this.running = this.drain().finally(() => (this.running = null));
     return this.running;
   }
 
   reset(): void {
-    this.requestedMs = null;
+    this.requested = null;
   }
 
-  private async drain(execute: SeekExecutor): Promise<void> {
-    while (this.requestedMs !== null) {
-      const target = this.requestedMs;
-      this.requestedMs = null;
+  private async drain(): Promise<void> {
+    while (this.requested !== null) {
+      const request = this.requested;
+      this.requested = null;
+      this.activeKey = request.key;
       try {
-        await execute(target);
+        await request.execute(request.positionMs);
       } catch (error) {
-        if (!isAbortError(error) || this.requestedMs === null) throw error;
+        if (!isAbortError(error) || this.requested === null) throw error;
+      } finally {
+        this.activeKey = null;
       }
     }
   }

src/type-type-mse-player.ts

@@ -76,16 +76,23 @@ export class TypeTypeMsePlayer {
   }
   async seek(positionMs: number): Promise<void> {
     const resumePlayback = !this.video.paused;
-    this.operation.abort();
-    return this.seekController.seek(positionMs, (targetMs) =>
-      this.performSeek(targetMs, undefined, resumePlayback),
+    const targetMs = Math.max(0, Math.round(positionMs));
+    return this.seekController.seek(
+      targetMs,
+      `seek:${targetMs}`,
+      (target) => this.performSeek(target, undefined, resumePlayback),
+      () => this.operation.abort(),
     );
   }
 
   async setQuality(quality: TypeTypeMseQuality): Promise<void> {
-    this.operation.abort();
-    return this.seekController.seek(currentTimeMs(this.video), (targetMs) =>
-      this.performSeek(targetMs, quality),
+    const targetMs = currentTimeMs(this.video);
+    const key = `quality:${targetMs}:${quality.videoItag}:${quality.audioItag}:${quality.audioTrackId ?? ""}`;
+    return this.seekController.seek(
+      targetMs,
+      key,
+      (target) => this.performSeek(target, quality),
+      () => this.operation.abort(),
     );
   }
 

tests/seek-controller.test.ts

@@ -14,12 +14,13 @@ test("coalesces seeks to the latest pending position", async () => {
   const controller = new SeekController();
   const first = deferred();
   const positions: number[] = [];
-  const running = controller.seek(10, async (position) => {
+  const execute = async (position: number) => {
     positions.push(position);
     if (position === 10) await first.promise;
-  });
-  controller.seek(20, async () => undefined);
-  controller.seek(30, async () => undefined);
+  };
+  const running = controller.seek(10, "10", execute, () => undefined);
+  controller.seek(20, "20", execute, () => undefined);
+  controller.seek(30, "30", execute, () => undefined);
   first.resolve();
   await running;
   expect(positions).toEqual([10, 30]);
@@ -28,18 +29,72 @@ test("coalesces seeks to the latest pending position", async () => {
 test("continues to the latest seek after an abort", async () => {
   const controller = new SeekController();
   const positions: number[] = [];
-  const running = controller.seek(10, async (position) => {
+  const execute = async (position: number) => {
     positions.push(position);
     if (position === 10) throw new DOMException("aborted", "AbortError");
-  });
-  controller.seek(40, async () => undefined);
+  };
+  const running = controller.seek(10, "10", execute, () => undefined);
+  controller.seek(40, "40", execute, () => undefined);
   await running;
   expect(positions).toEqual([10, 40]);
 });
 
 test("throws non-abort seek errors", async () => {
   const controller = new SeekController();
   await expect(
-    controller.seek(10, async () => Promise.reject(new Error("failed"))),
+    controller.seek(
+      10,
+      "10",
+      async () => Promise.reject(new Error("failed")),
+      () => undefined,
+    ),
   ).rejects.toThrow("failed");
 });
+
+test("uses the latest pending executor", async () => {
+  const controller = new SeekController();
+  const first = deferred();
+  const executions: string[] = [];
+  const running = controller.seek(
+    10,
+    "seek:10",
+    async () => {
+      executions.push("seek");
+      await first.promise;
+    },
+    () => undefined,
+  );
+  controller.seek(
+    20,
+    "quality:20:299",
+    async () => {
+      executions.push("quality");
+    },
+    () => undefined,
+  );
+  first.resolve();
+  await running;
+  expect(executions).toEqual(["seek", "quality"]);
+});
+
+test("deduplicates the active request", async () => {
+  const controller = new SeekController();
+  const first = deferred();
+  let executions = 0;
+  let cancellations = 0;
+  const execute = async () => {
+    executions += 1;
+    await first.promise;
+  };
+  const running = controller.seek(10, "seek:10", execute, () => {
+    cancellations += 1;
+  });
+  const duplicate = controller.seek(10, "seek:10", execute, () => {
+    cancellations += 1;
+  });
+  first.resolve();
+  await running;
+  expect(duplicate).toBe(running);
+  expect(executions).toBe(1);
+  expect(cancellations).toBe(0);
+});