@hyperframes/studio 0.8.210 → 0.8.211
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/assets/{hyperframes-player-DUpxahTX.js → hyperframes-player-CzrqgMUX.js} +1 -1
- package/dist/assets/{index-B4dcZZAm.js → index-B3SPHPi1.js} +1 -1
- package/dist/assets/{index-CtrcjpbM.js → index-k4nVfS2D.js} +123 -123
- package/dist/{chunk-7SREYKIC.js → chunk-HD6NXWGI.js} +6 -0
- package/dist/index.d.ts +4 -0
- package/dist/index.html +1 -1
- package/dist/index.js +484 -240
- package/dist/player.js +1 -1
- package/package.json +8 -8
- package/src/components/DesktopGuideCard.tsx +1 -1
- package/src/player/components/VideoThumbnail.tsx +6 -0
- package/src/player/hooks/previewMessageRouter.test.ts +4 -0
- package/src/player/lib/mediaFetch.test.ts +466 -0
- package/src/player/lib/mediaFetch.ts +133 -26
- package/src/player/lib/thumbnailFrameCache.ts +69 -0
- package/src/player/lib/thumbnailPlaybackHold.test.ts +86 -0
- package/src/player/lib/thumbnailPlaybackHold.ts +15 -0
- package/src/player/lib/thumbnailScheduler.test.ts +49 -0
- package/src/player/lib/thumbnailScheduler.ts +22 -6
- package/src/player/lib/thumbnailSourcePool.ts +163 -0
- package/src/player/lib/thumbnailVideoDecoder.test.ts +492 -8
- package/src/player/lib/thumbnailVideoDecoder.ts +67 -75
- package/src/player/lib/timelineViewportBudgets.test.ts +1 -0
- package/src/player/lib/timelineViewportBudgets.ts +4 -0
- package/src/player/store/previewQualitySlice.ts +11 -0
|
@@ -17,6 +17,7 @@ export class MediaFetchError extends Error {
|
|
|
17
17
|
readonly reader: MediaReader,
|
|
18
18
|
readonly status: number | null,
|
|
19
19
|
readonly code: string | null,
|
|
20
|
+
readonly start: number | null = null,
|
|
20
21
|
) {
|
|
21
22
|
super(describe(reader, status, code, 0));
|
|
22
23
|
}
|
|
@@ -28,6 +29,31 @@ export class MediaFetchError extends Error {
|
|
|
28
29
|
}
|
|
29
30
|
|
|
30
31
|
const MAX_RETRIES = 2;
|
|
32
|
+
// Three silent waits plus the 0.5 s and 1 s retry delays (25.5 s) end inside thumbnailLoadTimeoutMs.
|
|
33
|
+
const SILENT_BODY_STALL_MS = 8_000;
|
|
34
|
+
// mediabunny cancels a `bytes=N-` read at its target, by when a local server has streamed megabytes past it.
|
|
35
|
+
const THUMBNAIL_RANGE_BYTES = 512 * 1024;
|
|
36
|
+
const POOLED_READER_CACHE_BYTES = 16 * 1024 * 1024;
|
|
37
|
+
|
|
38
|
+
const rangeStart = (init: RequestInit | undefined, closed: boolean) =>
|
|
39
|
+
(closed ? /^bytes=(\d+)-\d*$/ : /^bytes=(\d+)-$/).exec(
|
|
40
|
+
new Headers(init?.headers).get("Range") ?? "",
|
|
41
|
+
)?.[1];
|
|
42
|
+
|
|
43
|
+
function boundedRange(init: RequestInit | undefined): RequestInit | undefined {
|
|
44
|
+
const start = rangeStart(init, false);
|
|
45
|
+
if (start === undefined) return init;
|
|
46
|
+
const headers = new Headers(init?.headers);
|
|
47
|
+
headers.set("Range", `bytes=${start}-${Number(start) + THUMBNAIL_RANGE_BYTES - 1}`);
|
|
48
|
+
return { ...init, headers };
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
/** Without a readable Content-Range (hidden cross-origin unless exposed) mediabunny sizes the file from this answer. */
|
|
52
|
+
function rangesReadable(init: RequestInit | undefined, response: Response): boolean {
|
|
53
|
+
const asked = rangeStart(init, true);
|
|
54
|
+
const shown = /^bytes (\d+)-\d+\/\d+$/.exec(response.headers.get("Content-Range") ?? "")?.[1];
|
|
55
|
+
return response.status === 206 && asked !== undefined && shown === asked;
|
|
56
|
+
}
|
|
31
57
|
|
|
32
58
|
const isAbort = (error: unknown) => (error as { name?: unknown } | null)?.name === "AbortError";
|
|
33
59
|
|
|
@@ -38,58 +64,139 @@ function networkCode(error: unknown): string {
|
|
|
38
64
|
return typeof name === "string" ? name : "unknown";
|
|
39
65
|
}
|
|
40
66
|
|
|
41
|
-
const typedFailure = (reader: MediaReader, error: unknown) =>
|
|
42
|
-
isAbort(error) ? error : new MediaFetchError(reader, null, networkCode(error));
|
|
67
|
+
const typedFailure = (reader: MediaReader, error: unknown, start: number) =>
|
|
68
|
+
isAbort(error) ? error : new MediaFetchError(reader, null, networkCode(error), start);
|
|
69
|
+
|
|
70
|
+
/**
|
|
71
|
+
* A stalled body ignores every signal, so a silent one is aborted. The wait for the answer is not
|
|
72
|
+
* timed: it includes Chrome's queue for a connection, which streaming previews can hold for long.
|
|
73
|
+
*/
|
|
74
|
+
function watchedRequest(reader: MediaReader, parents: readonly AbortSignal[]) {
|
|
75
|
+
const controller = new AbortController();
|
|
76
|
+
let stalled = false;
|
|
77
|
+
let timer: ReturnType<typeof setTimeout> | undefined;
|
|
78
|
+
const unlinks = parents.map((parent) => {
|
|
79
|
+
const follow = () => controller.abort(parent.reason);
|
|
80
|
+
parent.addEventListener("abort", follow, { once: true });
|
|
81
|
+
return () => parent.removeEventListener("abort", follow);
|
|
82
|
+
});
|
|
83
|
+
const done = () => {
|
|
84
|
+
clearTimeout(timer);
|
|
85
|
+
for (const unlink of unlinks.splice(0)) unlink();
|
|
86
|
+
};
|
|
87
|
+
controller.signal.addEventListener("abort", done, { once: true });
|
|
88
|
+
for (const parent of parents) if (parent.aborted) controller.abort(parent.reason);
|
|
89
|
+
const wait = <T>(pending: Promise<T>): Promise<T> => {
|
|
90
|
+
if (reader !== "thumbnail") return pending;
|
|
91
|
+
return new Promise<T>((resolve, reject) => {
|
|
92
|
+
timer = setTimeout(() => {
|
|
93
|
+
stalled = true;
|
|
94
|
+
const reason = new DOMException(`No bytes for ${SILENT_BODY_STALL_MS} ms`, "TimeoutError");
|
|
95
|
+
reject(reason);
|
|
96
|
+
controller.abort(reason);
|
|
97
|
+
}, SILENT_BODY_STALL_MS);
|
|
98
|
+
void pending.then(resolve, reject).finally(() => clearTimeout(timer));
|
|
99
|
+
});
|
|
100
|
+
};
|
|
101
|
+
const failure = (error: unknown, start: number) =>
|
|
102
|
+
stalled
|
|
103
|
+
? new MediaFetchError(reader, null, "stalled", start)
|
|
104
|
+
: typedFailure(reader, error, start);
|
|
105
|
+
return { signal: controller.signal, wait, done, failure };
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
type WatchedRequest = ReturnType<typeof watchedRequest>;
|
|
43
109
|
|
|
44
110
|
/** The body, failing a broken read with a MediaFetchError: mediabunny rethrows a body error as-is. */
|
|
45
111
|
function typedBody(
|
|
46
|
-
reader: MediaReader,
|
|
47
112
|
body: ReadableStream<Uint8Array>,
|
|
113
|
+
start: number,
|
|
114
|
+
request: WatchedRequest,
|
|
48
115
|
): ReadableStream<Uint8Array> {
|
|
49
116
|
const source = body.getReader();
|
|
50
117
|
return new ReadableStream<Uint8Array>({
|
|
51
118
|
async pull(controller) {
|
|
52
119
|
try {
|
|
53
|
-
const { done, value } = await source.read();
|
|
54
|
-
if (done) controller.
|
|
55
|
-
|
|
120
|
+
const { done, value } = await request.wait(source.read());
|
|
121
|
+
if (!done) return controller.enqueue(value);
|
|
122
|
+
request.done();
|
|
123
|
+
controller.close();
|
|
56
124
|
} catch (error) {
|
|
57
|
-
|
|
125
|
+
request.done();
|
|
126
|
+
controller.error(request.failure(error, start));
|
|
58
127
|
}
|
|
59
128
|
},
|
|
60
|
-
cancel: (reason) =>
|
|
129
|
+
cancel: (reason) => {
|
|
130
|
+
request.done();
|
|
131
|
+
return source.cancel(reason);
|
|
132
|
+
},
|
|
61
133
|
});
|
|
62
134
|
}
|
|
63
135
|
|
|
136
|
+
async function typedFetch(
|
|
137
|
+
reader: MediaReader,
|
|
138
|
+
input: RequestInfo | URL,
|
|
139
|
+
sent: RequestInit,
|
|
140
|
+
asked: number,
|
|
141
|
+
request: WatchedRequest,
|
|
142
|
+
): Promise<Response> {
|
|
143
|
+
let response: Response;
|
|
144
|
+
try {
|
|
145
|
+
// oxlint-disable-next-line no-restricted-globals -- a media read, on the media's sockets like mediabunny's own
|
|
146
|
+
response = await fetch(input, { ...sent, signal: request.signal });
|
|
147
|
+
} catch (error) {
|
|
148
|
+
request.done();
|
|
149
|
+
throw request.failure(error, asked);
|
|
150
|
+
}
|
|
151
|
+
if (response.ok) return response;
|
|
152
|
+
request.done();
|
|
153
|
+
throw new MediaFetchError(reader, response.status, null, asked);
|
|
154
|
+
}
|
|
155
|
+
|
|
156
|
+
function typedResponse(response: Response, asked: number, request: WatchedRequest): Response {
|
|
157
|
+
if (!response.body) {
|
|
158
|
+
request.done();
|
|
159
|
+
return response;
|
|
160
|
+
}
|
|
161
|
+
const { status, statusText, headers } = response;
|
|
162
|
+
const body = typedBody(response.body, status === 206 ? asked : 0, request);
|
|
163
|
+
return new Response(body, { status, statusText, headers });
|
|
164
|
+
}
|
|
165
|
+
|
|
64
166
|
/**
|
|
65
167
|
* Options for a mediabunny `UrlSource`. Its default retries a same-origin network failure
|
|
66
168
|
* forever and logs a bare `TypeError` each time; these retry twice and fail with a MediaFetchError.
|
|
67
169
|
*/
|
|
68
170
|
export function mediaUrlSourceOptions(reader: MediaReader) {
|
|
69
|
-
|
|
171
|
+
// Per start byte: a resume asks for a new start, while asking for one again uses its budget up.
|
|
172
|
+
const failuresByStart = new Map<number | null, number>();
|
|
173
|
+
const inFlightReads = new AbortController();
|
|
174
|
+
let ranges: "unknown" | "readable" | "hidden" = reader === "thumbnail" ? "unknown" : "hidden";
|
|
70
175
|
const fetchFn = async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
}
|
|
78
|
-
if (
|
|
79
|
-
|
|
80
|
-
const { status, statusText, headers } = response;
|
|
81
|
-
return new Response(typedBody(reader, response.body), { status, statusText, headers });
|
|
176
|
+
const sent = ranges === "readable" ? boundedRange(init) : init;
|
|
177
|
+
const asked = Number(rangeStart(sent, true) ?? 0);
|
|
178
|
+
const request = watchedRequest(
|
|
179
|
+
reader,
|
|
180
|
+
init?.signal ? [inFlightReads.signal, init.signal] : [inFlightReads.signal],
|
|
181
|
+
);
|
|
182
|
+
const response = await typedFetch(reader, input, sent ?? {}, asked, request);
|
|
183
|
+
if (ranges !== "hidden") ranges = rangesReadable(sent, response) ? "readable" : "hidden";
|
|
184
|
+
return typedResponse(response, asked, request);
|
|
82
185
|
};
|
|
83
|
-
// Counted per source: mediabunny passes 1 for every failed mid-stream read.
|
|
84
186
|
const getRetryDelay = (_previousAttempts: number, error: unknown): number | null => {
|
|
187
|
+
const start = error instanceof MediaFetchError ? error.start : null;
|
|
188
|
+
const failed = failuresByStart.get(start) ?? 0;
|
|
85
189
|
const clientError =
|
|
86
190
|
error instanceof MediaFetchError && error.status !== null && error.status < 500;
|
|
87
|
-
if (error instanceof MediaFetchError) error.setRetries(
|
|
88
|
-
if (clientError ||
|
|
89
|
-
|
|
90
|
-
return 0.5 *
|
|
191
|
+
if (error instanceof MediaFetchError) error.setRetries(failed);
|
|
192
|
+
if (clientError || failed >= MAX_RETRIES) return null;
|
|
193
|
+
failuresByStart.set(start, failed + 1);
|
|
194
|
+
return 0.5 * (failed + 1);
|
|
91
195
|
};
|
|
92
|
-
|
|
196
|
+
const cancelReads = () =>
|
|
197
|
+
inFlightReads.abort(new DOMException("Media reads cancelled", "AbortError"));
|
|
198
|
+
if (reader === "probe") return { fetchFn, getRetryDelay, cancelReads };
|
|
199
|
+
return { fetchFn, getRetryDelay, cancelReads, maxCacheSize: POOLED_READER_CACHE_BYTES };
|
|
93
200
|
}
|
|
94
201
|
|
|
95
202
|
export function reportMediaFetchFailure(error: unknown): void {
|
|
@@ -0,0 +1,69 @@
|
|
|
1
|
+
/** One decoded video frame, shared by every strip of its source that accepts it. */
|
|
2
|
+
export interface SharedFrame {
|
|
3
|
+
url: string;
|
|
4
|
+
decodedAt: number;
|
|
5
|
+
bytes: number;
|
|
6
|
+
users: number;
|
|
7
|
+
}
|
|
8
|
+
|
|
9
|
+
export interface HeldFrame {
|
|
10
|
+
key: string;
|
|
11
|
+
frame: SharedFrame;
|
|
12
|
+
}
|
|
13
|
+
|
|
14
|
+
const sharedFrames = new Map<string, SharedFrame[]>();
|
|
15
|
+
// Frames no strip shows, least recently released first; their URLs stay valid until evicted.
|
|
16
|
+
const released = new Map<SharedFrame, string>();
|
|
17
|
+
let releasedBytes = 0;
|
|
18
|
+
|
|
19
|
+
function use(frame: SharedFrame): SharedFrame {
|
|
20
|
+
if (frame.users++ === 0 && released.delete(frame)) releasedBytes -= frame.bytes;
|
|
21
|
+
return frame;
|
|
22
|
+
}
|
|
23
|
+
|
|
24
|
+
export function takeSharedFrame(
|
|
25
|
+
key: string,
|
|
26
|
+
accepts: (decodedAt: number) => boolean,
|
|
27
|
+
): SharedFrame | undefined {
|
|
28
|
+
const frame = sharedFrames.get(key)?.find((shared) => accepts(shared.decodedAt));
|
|
29
|
+
return frame && use(frame);
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
export function shareFrame(
|
|
33
|
+
key: string,
|
|
34
|
+
decodedAt: number,
|
|
35
|
+
url: string,
|
|
36
|
+
bytes: number,
|
|
37
|
+
): SharedFrame {
|
|
38
|
+
const frames = sharedFrames.get(key) ?? [];
|
|
39
|
+
const existing = frames.find((shared) => shared.decodedAt === decodedAt);
|
|
40
|
+
if (existing) {
|
|
41
|
+
URL.revokeObjectURL(url);
|
|
42
|
+
return use(existing);
|
|
43
|
+
}
|
|
44
|
+
const frame = { url, decodedAt, bytes, users: 1 };
|
|
45
|
+
sharedFrames.set(key, [...frames, frame]);
|
|
46
|
+
return frame;
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
function evict(frame: SharedFrame, key: string): void {
|
|
50
|
+
released.delete(frame);
|
|
51
|
+
releasedBytes -= frame.bytes;
|
|
52
|
+
const rest = sharedFrames.get(key)?.filter((shared) => shared !== frame) ?? [];
|
|
53
|
+
if (rest.length > 0) sharedFrames.set(key, rest);
|
|
54
|
+
else sharedFrames.delete(key);
|
|
55
|
+
URL.revokeObjectURL(frame.url);
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
/** Ends these holds; a frame nobody holds stays shared until released frames pass `budgetBytes`. */
|
|
59
|
+
export function releaseSharedFrames(held: HeldFrame[], budgetBytes: number): void {
|
|
60
|
+
for (const { key, frame } of held.splice(0)) {
|
|
61
|
+
if (--frame.users > 0) continue;
|
|
62
|
+
released.set(frame, key);
|
|
63
|
+
releasedBytes += frame.bytes;
|
|
64
|
+
}
|
|
65
|
+
for (const [frame, key] of released) {
|
|
66
|
+
if (releasedBytes <= budgetBytes) break;
|
|
67
|
+
evict(frame, key);
|
|
68
|
+
}
|
|
69
|
+
}
|
|
@@ -0,0 +1,86 @@
|
|
|
1
|
+
import { afterEach, describe, expect, it, vi } from "vitest";
|
|
2
|
+
import { usePlayerStore } from "../store/playerStore";
|
|
3
|
+
import { bindThumbnailPlaybackHold } from "./thumbnailPlaybackHold";
|
|
4
|
+
import {
|
|
5
|
+
ThumbnailScheduler,
|
|
6
|
+
thumbnailScheduler,
|
|
7
|
+
type ThumbnailLoadedResult,
|
|
8
|
+
type ThumbnailRequest,
|
|
9
|
+
} from "./thumbnailScheduler";
|
|
10
|
+
|
|
11
|
+
const decoded = (): ThumbnailLoadedResult => ({
|
|
12
|
+
value: { kind: "image", url: "frame", aspect: 1 },
|
|
13
|
+
weight: 1,
|
|
14
|
+
});
|
|
15
|
+
|
|
16
|
+
let requests = 0;
|
|
17
|
+
function videoRequest(load: ThumbnailRequest["load"]): ThumbnailRequest {
|
|
18
|
+
return {
|
|
19
|
+
key: `video-${++requests}`,
|
|
20
|
+
projectId: "project-a",
|
|
21
|
+
sessionEpoch: 1,
|
|
22
|
+
kind: "video",
|
|
23
|
+
priority: "visible",
|
|
24
|
+
load,
|
|
25
|
+
};
|
|
26
|
+
}
|
|
27
|
+
|
|
28
|
+
const settle = () => new Promise((resolve) => setTimeout(resolve, 0));
|
|
29
|
+
|
|
30
|
+
afterEach(() => usePlayerStore.getState().reset());
|
|
31
|
+
|
|
32
|
+
describe("bindThumbnailPlaybackHold", () => {
|
|
33
|
+
it("holds video decodes while the store plays, and lets them go when a reset stops it", async () => {
|
|
34
|
+
const scheduler = new ThumbnailScheduler();
|
|
35
|
+
const unbind = bindThumbnailPlaybackHold(usePlayerStore, scheduler);
|
|
36
|
+
try {
|
|
37
|
+
usePlayerStore.getState().setIsPlaying(true);
|
|
38
|
+
const held = vi.fn(async () => decoded());
|
|
39
|
+
scheduler.acquire(videoRequest(held), vi.fn());
|
|
40
|
+
await settle();
|
|
41
|
+
expect(held).not.toHaveBeenCalled();
|
|
42
|
+
|
|
43
|
+
// reset() writes isPlaying: false itself, without setIsPlaying.
|
|
44
|
+
usePlayerStore.getState().reset();
|
|
45
|
+
await settle();
|
|
46
|
+
expect(held).toHaveBeenCalledTimes(1);
|
|
47
|
+
|
|
48
|
+
usePlayerStore.getState().setIsPlaying(true);
|
|
49
|
+
const nextProject = vi.fn(async () => decoded());
|
|
50
|
+
scheduler.acquire(videoRequest(nextProject), vi.fn());
|
|
51
|
+
usePlayerStore.getState().beginTimelineSession(`project-${requests}`);
|
|
52
|
+
await settle();
|
|
53
|
+
expect(nextProject).toHaveBeenCalledTimes(1);
|
|
54
|
+
} finally {
|
|
55
|
+
unbind();
|
|
56
|
+
}
|
|
57
|
+
});
|
|
58
|
+
|
|
59
|
+
it("reads the store as it is when bound, and stops following it once unbound", async () => {
|
|
60
|
+
const scheduler = new ThumbnailScheduler();
|
|
61
|
+
usePlayerStore.getState().setIsPlaying(true);
|
|
62
|
+
const unbind = bindThumbnailPlaybackHold(usePlayerStore, scheduler);
|
|
63
|
+
const held = vi.fn(async () => decoded());
|
|
64
|
+
scheduler.acquire(videoRequest(held), vi.fn());
|
|
65
|
+
await settle();
|
|
66
|
+
expect(held).not.toHaveBeenCalled();
|
|
67
|
+
|
|
68
|
+
unbind();
|
|
69
|
+
usePlayerStore.getState().setIsPlaying(false);
|
|
70
|
+
await settle();
|
|
71
|
+
expect(held).not.toHaveBeenCalled();
|
|
72
|
+
});
|
|
73
|
+
|
|
74
|
+
it("holds the app's scheduler once video thumbnails are loaded", async () => {
|
|
75
|
+
await import("../components/VideoThumbnail");
|
|
76
|
+
usePlayerStore.getState().setIsPlaying(true);
|
|
77
|
+
const held = vi.fn(async () => decoded());
|
|
78
|
+
const lease = thumbnailScheduler.acquire(videoRequest(held), vi.fn());
|
|
79
|
+
await settle();
|
|
80
|
+
expect(held).not.toHaveBeenCalled();
|
|
81
|
+
usePlayerStore.getState().setIsPlaying(false);
|
|
82
|
+
await settle();
|
|
83
|
+
expect(held).toHaveBeenCalledTimes(1);
|
|
84
|
+
lease.release();
|
|
85
|
+
});
|
|
86
|
+
});
|
|
@@ -0,0 +1,15 @@
|
|
|
1
|
+
import type { ThumbnailScheduler } from "./thumbnailScheduler";
|
|
2
|
+
|
|
3
|
+
interface PlaybackStore {
|
|
4
|
+
getState(): { isPlaying: boolean };
|
|
5
|
+
subscribe(listener: (state: { isPlaying: boolean }) => void): () => void;
|
|
6
|
+
}
|
|
7
|
+
|
|
8
|
+
/** Subscribed to the state, not to setIsPlaying, so a reset that writes isPlaying: false also lets go. */
|
|
9
|
+
export function bindThumbnailPlaybackHold(
|
|
10
|
+
store: PlaybackStore,
|
|
11
|
+
scheduler: Pick<ThumbnailScheduler, "setPlaybackActive">,
|
|
12
|
+
): () => void {
|
|
13
|
+
scheduler.setPlaybackActive(store.getState().isPlaying);
|
|
14
|
+
return store.subscribe((state) => scheduler.setPlaybackActive(state.isPlaying));
|
|
15
|
+
}
|
|
@@ -153,6 +153,53 @@ describe("ThumbnailScheduler", () => {
|
|
|
153
153
|
expect(richLoad).toHaveBeenCalledTimes(1);
|
|
154
154
|
});
|
|
155
155
|
|
|
156
|
+
it("starts no visible or overscan video decode while the preview plays, but still a scrub's", async () => {
|
|
157
|
+
const scheduler = new ThumbnailScheduler();
|
|
158
|
+
const starts: string[] = [];
|
|
159
|
+
const load = (name: string) =>
|
|
160
|
+
vi.fn(async () => {
|
|
161
|
+
starts.push(name);
|
|
162
|
+
return result(name);
|
|
163
|
+
});
|
|
164
|
+
const video = { kind: "video" as const };
|
|
165
|
+
scheduler.setPlaybackActive(true);
|
|
166
|
+
|
|
167
|
+
const visible = scheduler.acquire(
|
|
168
|
+
request("visible", load("visible"), "visible", video),
|
|
169
|
+
vi.fn(),
|
|
170
|
+
);
|
|
171
|
+
scheduler.acquire(request("overscan", load("overscan"), "overscan", video), vi.fn());
|
|
172
|
+
scheduler.acquire(request("scrub", load("scrub"), "interaction", video), vi.fn());
|
|
173
|
+
scheduler.acquire(request("image", load("image"), "visible"), vi.fn());
|
|
174
|
+
await flush();
|
|
175
|
+
expect(starts).toEqual(["scrub", "image"]);
|
|
176
|
+
|
|
177
|
+
visible.updatePriority("interaction");
|
|
178
|
+
await flush();
|
|
179
|
+
expect(starts).toEqual(["scrub", "image", "visible"]);
|
|
180
|
+
});
|
|
181
|
+
|
|
182
|
+
it("drains the video decodes it held once playback pauses", async () => {
|
|
183
|
+
const scheduler = new ThumbnailScheduler();
|
|
184
|
+
const starts: string[] = [];
|
|
185
|
+
const load = (name: string) =>
|
|
186
|
+
vi.fn(async () => {
|
|
187
|
+
starts.push(name);
|
|
188
|
+
return result(name);
|
|
189
|
+
});
|
|
190
|
+
scheduler.setPlaybackActive(true);
|
|
191
|
+
scheduler.acquire(request("visible", load("visible"), "visible", { kind: "video" }), vi.fn());
|
|
192
|
+
scheduler.acquire(
|
|
193
|
+
request("overscan", load("overscan"), "overscan", { kind: "video" }),
|
|
194
|
+
vi.fn(),
|
|
195
|
+
);
|
|
196
|
+
await flush();
|
|
197
|
+
expect(starts).toEqual([]);
|
|
198
|
+
|
|
199
|
+
scheduler.setPlaybackActive(false);
|
|
200
|
+
await vi.waitFor(() => expect(starts).toEqual(["visible", "overscan"]));
|
|
201
|
+
});
|
|
202
|
+
|
|
156
203
|
it("holds composition renders while the preview reloads and re-runs the ones it preempted", async () => {
|
|
157
204
|
const scheduler = new ThumbnailScheduler();
|
|
158
205
|
const signals: AbortSignal[] = [];
|
|
@@ -336,6 +383,8 @@ describe("ThumbnailScheduler", () => {
|
|
|
336
383
|
await vi.advanceTimersByTimeAsync(11);
|
|
337
384
|
await flush();
|
|
338
385
|
expect(signal?.aborted).toBe(true);
|
|
386
|
+
// Said apart from a cancel: a job that timed out without progress failed its source.
|
|
387
|
+
expect(signal?.reason).toMatchObject({ name: "TimeoutError" });
|
|
339
388
|
expect(nextLoad).toHaveBeenCalledTimes(1);
|
|
340
389
|
expect(scheduler.getSnapshot(hungRequest).status).toBe("error");
|
|
341
390
|
|
|
@@ -117,6 +117,7 @@ export class ThumbnailScheduler {
|
|
|
117
117
|
private nextSequence = 1;
|
|
118
118
|
private scrolling = false;
|
|
119
119
|
private previewReloading = false;
|
|
120
|
+
private playbackActive = false;
|
|
120
121
|
private pageHidden = false;
|
|
121
122
|
private cacheBytes = 0;
|
|
122
123
|
private waveformCacheBytes = 0;
|
|
@@ -231,6 +232,12 @@ export class ThumbnailScheduler {
|
|
|
231
232
|
}
|
|
232
233
|
}
|
|
233
234
|
|
|
235
|
+
setPlaybackActive(active: boolean): void {
|
|
236
|
+
if (this.playbackActive === active) return;
|
|
237
|
+
this.playbackActive = active;
|
|
238
|
+
if (!active) this.pump();
|
|
239
|
+
}
|
|
240
|
+
|
|
234
241
|
setPageHidden(hidden: boolean): void {
|
|
235
242
|
if (this.pageHidden === hidden) return;
|
|
236
243
|
this.pageHidden = hidden;
|
|
@@ -295,14 +302,24 @@ export class ThumbnailScheduler {
|
|
|
295
302
|
});
|
|
296
303
|
|
|
297
304
|
for (const entry of queued) {
|
|
298
|
-
if (this.
|
|
299
|
-
if (this.previewReloading && entry.request.kind === "composition") continue;
|
|
305
|
+
if (this.isHeld(entry)) continue;
|
|
300
306
|
const bucket = concurrencyBucket(entry.request.kind);
|
|
301
307
|
if (this.activeByBucket[bucket] >= this.bucketLimit(bucket)) continue;
|
|
302
308
|
this.start(entry, bucket);
|
|
303
309
|
}
|
|
304
310
|
}
|
|
305
311
|
|
|
312
|
+
private isHeld(entry: ThumbnailEntry): boolean {
|
|
313
|
+
const { kind, rich } = entry.request;
|
|
314
|
+
if (this.scrolling && rich) return true;
|
|
315
|
+
if (this.previewReloading && kind === "composition") return true;
|
|
316
|
+
return (
|
|
317
|
+
this.playbackActive &&
|
|
318
|
+
kind === "video" &&
|
|
319
|
+
this.entryPriority(entry) < PRIORITY_SCORE.interaction
|
|
320
|
+
);
|
|
321
|
+
}
|
|
322
|
+
|
|
306
323
|
private start(entry: ThumbnailEntry, bucket: "video" | "composition" | "general"): void {
|
|
307
324
|
entry.state = "loading";
|
|
308
325
|
entry.snapshot = Object.freeze({ status: "loading" });
|
|
@@ -476,10 +493,9 @@ export class ThumbnailScheduler {
|
|
|
476
493
|
const timeout = setTimeout(() => {
|
|
477
494
|
if (settled) return;
|
|
478
495
|
settled = true;
|
|
479
|
-
|
|
480
|
-
|
|
481
|
-
|
|
482
|
-
);
|
|
496
|
+
const message = `Thumbnail load timed out after ${this.budgets.thumbnailLoadTimeoutMs}ms`;
|
|
497
|
+
controller.abort(new DOMException(message, "TimeoutError"));
|
|
498
|
+
reject(new Error(message));
|
|
483
499
|
}, this.budgets.thumbnailLoadTimeoutMs);
|
|
484
500
|
|
|
485
501
|
load.then(
|
|
@@ -0,0 +1,163 @@
|
|
|
1
|
+
import type { Input, InputVideoTrack } from "mediabunny";
|
|
2
|
+
import { mediaUrlSourceOptions } from "./mediaFetch";
|
|
3
|
+
|
|
4
|
+
export interface SourceInfo {
|
|
5
|
+
aspect: number;
|
|
6
|
+
metadataDuration: number | null;
|
|
7
|
+
}
|
|
8
|
+
|
|
9
|
+
type Mediabunny = typeof import("mediabunny");
|
|
10
|
+
|
|
11
|
+
interface OpenedSource {
|
|
12
|
+
mediabunny: Mediabunny;
|
|
13
|
+
track: InputVideoTrack;
|
|
14
|
+
info: SourceInfo;
|
|
15
|
+
}
|
|
16
|
+
|
|
17
|
+
export interface ThumbnailSource extends OpenedSource {
|
|
18
|
+
/** Ends this job's use. A failed job retires the reader, so the next job opens a fresh one. */
|
|
19
|
+
release(failed: boolean): void;
|
|
20
|
+
/** The job waited for the reader to open: the open finishing was progress the job saw. */
|
|
21
|
+
waitedForOpen: boolean;
|
|
22
|
+
progress: { framesFromAnyJob: number };
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
interface PooledSource {
|
|
26
|
+
version: string | undefined;
|
|
27
|
+
input: Input | null;
|
|
28
|
+
cancelReads: (() => void) | null;
|
|
29
|
+
ready: boolean;
|
|
30
|
+
opened: Promise<OpenedSource>;
|
|
31
|
+
users: number;
|
|
32
|
+
progress: { framesFromAnyJob: number };
|
|
33
|
+
idleTimer: ReturnType<typeof setTimeout> | null;
|
|
34
|
+
disposed: boolean;
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
// One reader per source URL, shared by every clip cut from it: the index is parsed once.
|
|
38
|
+
const pool = new Map<string, PooledSource>();
|
|
39
|
+
let mediabunnyModule: Promise<Mediabunny> | null = null;
|
|
40
|
+
const loadMediabunny = () => (mediabunnyModule ??= import("mediabunny"));
|
|
41
|
+
|
|
42
|
+
const abortError = () => new DOMException("Aborted", "AbortError");
|
|
43
|
+
/** The scheduler's own timeout, as opposed to a cancel. */
|
|
44
|
+
export const timedOut = (signal: AbortSignal) =>
|
|
45
|
+
(signal.reason as { name?: unknown } | null)?.name === "TimeoutError";
|
|
46
|
+
const isAbortError = (error: unknown) =>
|
|
47
|
+
(error as { name?: unknown } | null)?.name === "AbortError";
|
|
48
|
+
|
|
49
|
+
function dispose(source: string, entry: PooledSource): void {
|
|
50
|
+
if (entry.disposed) return;
|
|
51
|
+
entry.disposed = true;
|
|
52
|
+
if (entry.idleTimer !== null) clearTimeout(entry.idleTimer);
|
|
53
|
+
if (pool.get(source) === entry) pool.delete(source);
|
|
54
|
+
entry.input?.dispose();
|
|
55
|
+
entry.cancelReads?.();
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
function retire(source: string, entry: PooledSource): void {
|
|
59
|
+
if (pool.get(source) === entry) pool.delete(source);
|
|
60
|
+
if (entry.users === 0) dispose(source, entry);
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
async function open(source: string, pooled: () => PooledSource): Promise<OpenedSource> {
|
|
64
|
+
const mediabunny = await loadMediabunny();
|
|
65
|
+
const entry = pooled();
|
|
66
|
+
// A reader every job let go of while it opened was disposed: stop before reading more of it.
|
|
67
|
+
const live = () => {
|
|
68
|
+
if (entry.disposed) throw abortError();
|
|
69
|
+
};
|
|
70
|
+
live();
|
|
71
|
+
const options = mediaUrlSourceOptions("thumbnail");
|
|
72
|
+
const input = new mediabunny.Input({
|
|
73
|
+
source: new mediabunny.UrlSource(source, options),
|
|
74
|
+
formats: mediabunny.ALL_FORMATS,
|
|
75
|
+
});
|
|
76
|
+
entry.input = input;
|
|
77
|
+
entry.cancelReads = options.cancelReads;
|
|
78
|
+
const track = await input.getPrimaryVideoTrack();
|
|
79
|
+
live();
|
|
80
|
+
if (!track) throw new Error("Video source has no decodable video track");
|
|
81
|
+
const [displayWidth, displayHeight] = await Promise.all([
|
|
82
|
+
track.getDisplayWidth(),
|
|
83
|
+
track.getDisplayHeight(),
|
|
84
|
+
]);
|
|
85
|
+
live();
|
|
86
|
+
if (!(displayWidth > 0 && displayHeight > 0)) {
|
|
87
|
+
throw new Error("Video source has invalid dimensions");
|
|
88
|
+
}
|
|
89
|
+
const metadataDuration = await track.getDurationFromMetadata({ skipLiveWait: true });
|
|
90
|
+
live();
|
|
91
|
+
return { mediabunny, track, info: { aspect: displayWidth / displayHeight, metadataDuration } };
|
|
92
|
+
}
|
|
93
|
+
|
|
94
|
+
function pooledSource(source: string, version: string | undefined): PooledSource {
|
|
95
|
+
const current = pool.get(source);
|
|
96
|
+
if (current && current.version === version) return current;
|
|
97
|
+
if (current) retire(source, current);
|
|
98
|
+
const entry: PooledSource = {
|
|
99
|
+
version,
|
|
100
|
+
input: null,
|
|
101
|
+
cancelReads: null,
|
|
102
|
+
ready: false,
|
|
103
|
+
opened: open(source, () => entry),
|
|
104
|
+
users: 0,
|
|
105
|
+
progress: { framesFromAnyJob: 0 },
|
|
106
|
+
idleTimer: null,
|
|
107
|
+
disposed: false,
|
|
108
|
+
};
|
|
109
|
+
// A failed open leaves the pool at once; the jobs awaiting it see the failure themselves.
|
|
110
|
+
entry.opened.then(
|
|
111
|
+
() => (entry.ready = true),
|
|
112
|
+
() => retire(source, entry),
|
|
113
|
+
);
|
|
114
|
+
pool.set(source, entry);
|
|
115
|
+
return entry;
|
|
116
|
+
}
|
|
117
|
+
|
|
118
|
+
function untilAborted<T>(pending: Promise<T>, signal: AbortSignal): Promise<T> {
|
|
119
|
+
if (signal.aborted) return Promise.reject(abortError());
|
|
120
|
+
return new Promise<T>((resolve, reject) => {
|
|
121
|
+
const onAbort = () => reject(abortError());
|
|
122
|
+
signal.addEventListener("abort", onAbort, { once: true });
|
|
123
|
+
void pending.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
|
|
124
|
+
});
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
/**
|
|
128
|
+
* The opened reader for `source` at `version`, shared by concurrent jobs and kept for `idleMs`
|
|
129
|
+
* after the last one ends (0 disposes at once). A new version retires the old reader.
|
|
130
|
+
*/
|
|
131
|
+
export async function acquireThumbnailSource(
|
|
132
|
+
source: string,
|
|
133
|
+
version: string | undefined,
|
|
134
|
+
signal: AbortSignal,
|
|
135
|
+
idleMs: number,
|
|
136
|
+
): Promise<ThumbnailSource> {
|
|
137
|
+
const entry = pooledSource(source, version);
|
|
138
|
+
const waitedForOpen = !entry.ready;
|
|
139
|
+
entry.users += 1;
|
|
140
|
+
if (entry.idleTimer !== null) clearTimeout(entry.idleTimer);
|
|
141
|
+
entry.idleTimer = null;
|
|
142
|
+
let released = false;
|
|
143
|
+
const release = (failed: boolean) => {
|
|
144
|
+
if (released) return;
|
|
145
|
+
released = true;
|
|
146
|
+
entry.users -= 1;
|
|
147
|
+
if (failed) retire(source, entry);
|
|
148
|
+
if (entry.users > 0 || entry.disposed) return;
|
|
149
|
+
if (pool.get(source) === entry && idleMs > 0) {
|
|
150
|
+
entry.idleTimer = setTimeout(() => dispose(source, entry), idleMs);
|
|
151
|
+
} else {
|
|
152
|
+
dispose(source, entry);
|
|
153
|
+
}
|
|
154
|
+
};
|
|
155
|
+
try {
|
|
156
|
+
const { progress } = entry;
|
|
157
|
+
return { ...(await untilAborted(entry.opened, signal)), release, waitedForOpen, progress };
|
|
158
|
+
} catch (error) {
|
|
159
|
+
// Timed out still waiting: the open made no progress in the job's whole run.
|
|
160
|
+
release(!isAbortError(error) || timedOut(signal));
|
|
161
|
+
throw error;
|
|
162
|
+
}
|
|
163
|
+
}
|