@editframe/elements 0.18.21-beta.0 → 0.18.22-beta.0

package/src/elements/EFMedia/BufferedSeekingInput.browsertest.ts

@@ -2,11 +2,18 @@ import { test as baseTest, describe } from "vitest";
 import { BufferedSeekingInput, NoSample } from "./BufferedSeekingInput";
 
 const test = baseTest.extend<{
+  barsNtone: BufferedSeekingInput;
   fiveSampleBuffer: BufferedSeekingInput;
   inputAtStart: BufferedSeekingInput;
   inputAtMiddle: BufferedSeekingInput;
   segment2: BufferedSeekingInput;
 }>({
+  barsNtone: async ({}, use) => {
+    const response = await fetch("/bars-n-tone.mp4");
+    const arrayBuffer = await response.arrayBuffer();
+    const input = new BufferedSeekingInput(arrayBuffer);
+    await use(input);
+  },
   fiveSampleBuffer: async ({}, use) => {
     const response = await fetch("/jit-segments/segment-0ms-2s-low.mp4");
     const arrayBuffer = await response.arrayBuffer();
@@ -64,7 +71,7 @@ describe("BufferedSeekingInput", () => {
     test("seeks to frame at 0.04 seconds", async ({ expect, inputAtStart }) => {
       const sample = await inputAtStart.seek(1, 40);
       expect(sample).toBeDefined();
-      expect(sample!.timestamp).toBe(0); // Updated: improved mediabunny processing changed frame timings
+      expect(sample!.timestamp).toBe(0.04);
     });
   });
 
@@ -75,10 +82,10 @@ describe("BufferedSeekingInput", () => {
     }) => {
       // Updated expectations based on improved mediabunny processing
       expect((await inputAtStart.seek(1, 0))!.timestamp).toBe(0);
-      expect((await inputAtStart.seek(1, 40))!.timestamp).toBe(0); // Frame timing shifted due to improvements
-      expect((await inputAtStart.seek(1, 80))!.timestamp).toBe(0.04);
-      expect((await inputAtStart.seek(1, 120))!.timestamp).toBe(0.08);
-      expect((await inputAtStart.seek(1, 160))!.timestamp).toBe(0.12);
+      expect((await inputAtStart.seek(1, 40))!.timestamp).toBe(0.04); // Frame timing shifted due to improvements
+      expect((await inputAtStart.seek(1, 80))!.timestamp).toBe(0.08);
+      expect((await inputAtStart.seek(1, 120))!.timestamp).toBe(0.12);
+      expect((await inputAtStart.seek(1, 160))!.timestamp).toBe(0.16);
     });
 
     test("seeks between samples returns previous sample", async ({
@@ -112,24 +119,27 @@ describe("BufferedSeekingInput", () => {
     });
 
     test("never returns future sample", async ({ expect, inputAtStart }) => {
-      const testCases = [
-        { seekTimeMs: 0, expectedTimestamp: 0 },
-        { seekTimeMs: 10, expectedTimestamp: 0 },
-        { seekTimeMs: 30, expectedTimestamp: 0 },
-        { seekTimeMs: 40, expectedTimestamp: 0 }, // Updated: frame timing shifted due to mediabunny improvements
-        { seekTimeMs: 50, expectedTimestamp: 0.04 }, // Updated: this seek now returns 0.04
-        { seekTimeMs: 70, expectedTimestamp: 0.04 }, // Updated: this seek now returns 0.04
-        { seekTimeMs: 80, expectedTimestamp: 0.04 }, // Updated: frame timing shifted
-        { seekTimeMs: 90, expectedTimestamp: 0.08 }, // Updated: this seek now returns 0.08
-      ];
-
-      for (const { seekTimeMs, expectedTimestamp } of testCases) {
-        const result = await inputAtStart.seek(1, seekTimeMs);
-        expect(result!.timestamp).toBe(expectedTimestamp);
-
-        const resultTimeMs = result!.timestamp! * 1000;
-        expect(resultTimeMs).toBeLessThanOrEqual(seekTimeMs);
-      }
+      const _0 = await inputAtStart.seek(1, 0);
+      const _10 = await inputAtStart.seek(1, 10);
+      const _20 = await inputAtStart.seek(1, 20);
+      const _30 = await inputAtStart.seek(1, 30);
+      const _40 = await inputAtStart.seek(1, 40);
+      const _50 = await inputAtStart.seek(1, 50);
+      const _60 = await inputAtStart.seek(1, 60);
+      const _70 = await inputAtStart.seek(1, 70);
+      const _80 = await inputAtStart.seek(1, 80);
+      const _90 = await inputAtStart.seek(1, 90);
+
+      expect(_0?.timestamp).toBe(0);
+      expect(_10?.timestamp).toBe(0);
+      expect(_20?.timestamp).toBe(0);
+      expect(_30?.timestamp).toBe(0);
+      expect(_40?.timestamp).toBe(0.04);
+      expect(_50?.timestamp).toBe(0.04);
+      expect(_60?.timestamp).toBe(0.04);
+      expect(_70?.timestamp).toBe(0.04);
+      expect(_80?.timestamp).toBe(0.08);
+      expect(_90?.timestamp).toBe(0.08);
     });
   });
 
@@ -178,11 +188,7 @@ describe("BufferedSeekingInput", () => {
     }) => {
       await fiveSampleBuffer.seek(1, 960);
       expect(fiveSampleBuffer.getBufferTimestamps(1)).toEqual([
-        0.76,
-        0.8,
-        0.84,
-        0.88,
-        0.92, // Updated: improved mediabunny shifted timestamps
+        0.8, 0.84, 0.88, 0.92, 0.96,
       ]);
     });
 
@@ -199,29 +205,20 @@ describe("BufferedSeekingInput", () => {
       expect,
       fiveSampleBuffer,
     }) => {
-      await fiveSampleBuffer.seek(1, 960);
+      const sample1 = await fiveSampleBuffer.seek(1, 960);
+      expect(sample1?.timestamp).toBe(0.96);
       expect(fiveSampleBuffer.getBufferTimestamps(1)).toEqual([
-        0.76,
-        0.8,
-        0.84,
-        0.88,
-        0.92, // Updated: improved mediabunny shifted timestamps
+        0.8, 0.84, 0.88, 0.92, 0.96,
       ]);
-      await fiveSampleBuffer.seek(1, 900);
+      const sample2 = await fiveSampleBuffer.seek(1, 900);
+      expect(sample2?.timestamp).toBe(0.88);
       expect(fiveSampleBuffer.getBufferTimestamps(1)).toEqual([
-        0.76,
-        0.8,
-        0.84,
-        0.88,
-        0.92, // Updated: improved mediabunny shifted timestamps
+        0.8, 0.84, 0.88, 0.92, 0.96,
       ]);
-      await fiveSampleBuffer.seek(1, 960);
+      const sample3 = await fiveSampleBuffer.seek(1, 920);
+      expect(sample3?.timestamp).toBe(0.92);
       expect(fiveSampleBuffer.getBufferTimestamps(1)).toEqual([
-        0.76,
-        0.8,
-        0.84,
-        0.88,
-        0.92, // Updated: improved mediabunny shifted timestamps
+        0.8, 0.84, 0.88, 0.92, 0.96,
       ]);
     });
 
@@ -229,21 +226,15 @@ describe("BufferedSeekingInput", () => {
       expect,
       fiveSampleBuffer,
     }) => {
-      await fiveSampleBuffer.seek(1, 960);
+      const sample1 = await fiveSampleBuffer.seek(1, 960);
+      expect(sample1?.timestamp).toBe(0.96);
       expect(fiveSampleBuffer.getBufferTimestamps(1)).toEqual([
-        0.76,
-        0.8,
-        0.84,
-        0.88,
-        0.92, // Updated: improved mediabunny shifted timestamps
+        0.8, 0.84, 0.88, 0.92, 0.96,
       ]);
-      await fiveSampleBuffer.seek(1, 900);
+      const sample2 = await fiveSampleBuffer.seek(1, 900);
+      expect(sample2?.timestamp).toBe(0.88);
       expect(fiveSampleBuffer.getBufferTimestamps(1)).toEqual([
-        0.76,
-        0.8,
-        0.84,
-        0.88,
-        0.92, // Updated: improved mediabunny shifted timestamps
+        0.8, 0.84, 0.88, 0.92, 0.96,
       ]);
     });
 
@@ -251,21 +242,15 @@ describe("BufferedSeekingInput", () => {
       expect,
       fiveSampleBuffer,
     }) => {
-      await fiveSampleBuffer.seek(1, 960);
+      const sample1 = await fiveSampleBuffer.seek(1, 960);
+      expect(sample1?.timestamp).toBe(0.96);
       expect(fiveSampleBuffer.getBufferTimestamps(1)).toEqual([
-        0.76,
-        0.8,
-        0.84,
-        0.88,
-        0.92, // Updated: improved mediabunny shifted timestamps
+        0.8, 0.84, 0.88, 0.92, 0.96,
       ]);
-      await fiveSampleBuffer.seek(1, 800);
+      const sample2 = await fiveSampleBuffer.seek(1, 800);
+      expect(sample2?.timestamp).toBe(0.8);
       expect(fiveSampleBuffer.getBufferTimestamps(1)).toEqual([
-        0.76,
-        0.8,
-        0.84,
-        0.88,
-        0.92, // Updated: improved mediabunny shifted timestamps
+        0.8, 0.84, 0.88, 0.92, 0.96,
       ]);
     });
 
@@ -273,21 +258,16 @@ describe("BufferedSeekingInput", () => {
       expect,
       fiveSampleBuffer,
     }) => {
-      await fiveSampleBuffer.seek(1, 960);
+      const sample1 = await fiveSampleBuffer.seek(1, 960);
+      expect(sample1?.timestamp).toBe(0.96);
       expect(fiveSampleBuffer.getBufferTimestamps(1)).toEqual([
-        0.76,
-        0.8,
-        0.84,
-        0.88,
-        0.92, // Updated: improved mediabunny shifted timestamps
+        0.8, 0.84, 0.88, 0.92, 0.96,
       ]);
-      await fiveSampleBuffer.seek(1, 720);
+
+      const sample2 = await fiveSampleBuffer.seek(1, 720);
+      expect(sample2?.timestamp).toBe(0.72);
       expect(fiveSampleBuffer.getBufferTimestamps(1)).toEqual([
-        0.52,
-        0.56,
-        0.6,
-        0.64,
-        0.68, // Updated: improved mediabunny shifted timestamps
+        0.56, 0.6, 0.64, 0.68, 0.72,
       ]);
     });
 
@@ -295,29 +275,19 @@ describe("BufferedSeekingInput", () => {
       expect,
       fiveSampleBuffer,
     }) => {
-      await fiveSampleBuffer.seek(1, 960);
+      const sample1 = await fiveSampleBuffer.seek(1, 960);
+      expect(sample1?.timestamp).toBe(0.96);
       expect(fiveSampleBuffer.getBufferTimestamps(1)).toEqual([
-        0.76,
-        0.8,
-        0.84,
-        0.88,
-        0.92, // Updated: improved mediabunny shifted timestamps
+        0.8, 0.84, 0.88, 0.92, 0.96,
       ]);
-      await fiveSampleBuffer.seek(1, 900);
+      const sample2 = await fiveSampleBuffer.seek(1, 900);
+      expect(sample2?.timestamp).toBe(0.88);
       expect(fiveSampleBuffer.getBufferTimestamps(1)).toEqual([
-        0.76,
-        0.8,
-        0.84,
-        0.88,
-        0.92, // Updated: improved mediabunny shifted timestamps
+        0.8, 0.84, 0.88, 0.92, 0.96,
       ]);
       await fiveSampleBuffer.seek(1, 960);
       expect(fiveSampleBuffer.getBufferTimestamps(1)).toEqual([
-        0.76,
-        0.8,
-        0.84,
-        0.88,
-        0.92, // Updated: improved mediabunny shifted timestamps
+        0.8, 0.84, 0.88, 0.92, 0.96,
       ]);
     });
 
@@ -325,28 +295,22 @@ describe("BufferedSeekingInput", () => {
       expect,
       fiveSampleBuffer,
     }) => {
-      await fiveSampleBuffer.seek(1, 960);
+      const sample1 = await fiveSampleBuffer.seek(1, 960);
+      expect(sample1?.timestamp).toBe(0.96);
       expect(fiveSampleBuffer.getBufferTimestamps(1)).toEqual([
-        0.76,
-        0.8,
-        0.84,
-        0.88,
-        0.92, // Updated: improved mediabunny shifted timestamps
+        0.8, 0.84, 0.88, 0.92, 0.96,
       ]);
-      await fiveSampleBuffer.seek(1, 1000);
+      const sample2 = await fiveSampleBuffer.seek(1, 1000);
+      expect(sample2?.timestamp).toBe(1);
       expect(fiveSampleBuffer.getBufferTimestamps(1)).toEqual([
-        0.8,
-        0.84,
-        0.88,
-        0.92,
-        0.96, // Updated: improved mediabunny shifted timestamps
+        0.84, 0.88, 0.92, 0.96, 1,
       ]);
     });
   });
 
   describe("seeing to time not in buffer (time is before buffer)", () => {
     test("throws error", async ({ expect, segment2 }) => {
-      await expect(segment2.seek(1, 0)).rejects.toThrow(NoSample);
+      await expect(segment2.seek(1, -100)).rejects.toThrow(NoSample);
     });
   });
 
@@ -369,7 +333,7 @@ describe("BufferedSeekingInput", () => {
     });
   });
 
-  describe("edge case: seeking to exact end of last sample", () => {
+  describe("seeking to exact end of last sample", () => {
     test("returns last sample when seeking to 10000ms in bars-n-tone.mp4", async ({
       expect,
     }) => {
@@ -397,85 +361,26 @@ describe("BufferedSeekingInput", () => {
   });
 
   describe("concurrency handling", () => {
-    test("handles concurrent seeking operations safely", async ({
-      expect,
-      inputAtStart,
-    }) => {
-      const seek1 = inputAtStart.seek(1, 0);
-      const seek2 = inputAtStart.seek(1, 40);
-      const seek3 = inputAtStart.seek(1, 80);
-      // Updated: removed seek4 due to inconsistent sample availability in test media
-
-      const [sample1, sample2, sample3] = await Promise.all([
-        seek1,
-        seek2,
-        seek3,
+    test("seeks are serialized", async ({ expect, inputAtStart }) => {
+      const samples = await Promise.all([
+        inputAtStart.seek(1, 0),
+        inputAtStart.seek(1, 40),
+        inputAtStart.seek(1, 80),
       ]);
 
-      expect(sample1!.timestamp).toBe(0);
-      expect(sample2!.timestamp).toBe(0); // Updated: frame timing shifted
-      expect(sample3!.timestamp).toBe(0.04); // Updated: frame timing shifted
-
-      const bufferTimestamps = inputAtStart.getBufferTimestamps(1);
-      expect(bufferTimestamps.length).toBeGreaterThan(0);
-      for (let i = 1; i < bufferTimestamps.length; i++) {
-        expect(bufferTimestamps[i]).toBeGreaterThanOrEqual(
-          bufferTimestamps[i - 1]!,
-        );
-      }
-    });
-
-    test("handles concurrent seeks with backward jumps", async ({
-      expect,
-      inputAtStart,
-    }) => {
-      await inputAtStart.seek(1, 200);
-
-      const seek1 = inputAtStart.seek(1, 40);
-      const seek2 = inputAtStart.seek(1, 160);
-      const seek3 = inputAtStart.seek(1, 0);
-
-      const [sample1, sample2, sample3] = await Promise.all([
-        seek1,
-        seek2,
-        seek3,
+      expect(samples.map((sample) => sample?.timestamp)).toEqual([
+        0, 0.04, 0.08,
       ]);
-
-      expect(sample1!.timestamp).toBe(0); // Updated: frame timing shifted
-      expect(sample2!.timestamp).toBe(0.12); // Updated: frame timing shifted
-      expect(sample3!.timestamp).toBe(0);
-      expect(inputAtStart.getBufferSize(1)).toBeGreaterThan(0);
-    });
-
-    test("handles concurrent seeks to same time", async ({
-      expect,
-      inputAtStart,
-    }) => {
-      const seeks = Array(5)
-        .fill(null)
-        .map(() => inputAtStart.seek(1, 80));
-      const results = await Promise.all(seeks);
-
-      for (const result of results) {
-        expect(result!.timestamp).toBe(0.04); // Updated: frame timing shifted
-      }
-      expect(inputAtStart.getBufferSize(1)).toBeGreaterThan(0);
     });
+  });
 
-    test("handles mixed concurrent operations across different tracks", async ({
+  describe("regression tests", () => {
+    test("seeks to 7975ms in bars-n-tone.mp4", async ({
       expect,
-      inputAtStart,
+      barsNtone,
     }) => {
-      const track1Seek1 = inputAtStart.seek(1, 40);
-      const track1Seek2 = inputAtStart.seek(1, 80);
-
-      const [result1, result2] = await Promise.all([track1Seek1, track1Seek2]);
-
-      expect(result1!.timestamp).toBe(0); // Updated: frame timing shifted
-      expect(result2!.timestamp).toBe(0.04); // Updated: frame timing shifted
-
-      const track1Buffer = inputAtStart.getBufferTimestamps(1);
-      expect(track1Buffer.length).toBeGreaterThan(0);
+      const sample = await barsNtone.seek(1, 7975);
+      expect(sample?.timestamp).toBeCloseTo(7.966);
     });
   });
 });