@hyperframes/studio 0.9.21 → 0.9.22
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/codec-DLDwVbqW.js +314 -0
- package/dist/assets/{hyperframes-player-DqxUNa9H.js → hyperframes-player-C5DA6O5u.js} +1 -1
- package/dist/assets/index-B6RxZt-8.js +150 -0
- package/dist/assets/{index-Cq43Ovkf.js → index-Buvugo_O.js} +120 -119
- package/dist/assets/pausedVideoDecoder-BGKlQc66.js +1 -0
- package/dist/{chunk-3EAFE522.js → chunk-45KKBU63.js} +1 -1
- package/dist/chunk-4SPHDECE.js +165 -0
- package/dist/{chunk-OGIOFEC7.js → chunk-63DH4LRB.js} +13 -2
- package/dist/{chunk-NUS5R2HO.js → chunk-AX6G6YL5.js} +1 -1
- package/dist/{domEditingLayers-7Z6J4UOK.js → domEditingLayers-7Q56QAU5.js} +2 -2
- package/dist/index.d.ts +5 -1
- package/dist/index.html +1 -1
- package/dist/index.js +104 -195
- package/dist/pausedVideoDecoder-KBQXSWFQ.js +393 -0
- package/dist/player.js +2 -2
- package/package.json +9 -9
- package/src/components/editor/domEditingDom.preview.test.ts +75 -0
- package/src/components/editor/domEditingDom.ts +19 -2
- package/src/components/nle/NLEContext.tsx +4 -1
- package/src/hooks/useElementPicker.test.ts +13 -0
- package/src/hooks/useElementPicker.ts +3 -2
- package/src/player/components/PlayerControls.test.tsx +1 -1
- package/src/player/components/PlayerControls.tsx +1 -1
- package/src/player/components/PreviewSeekBar.test.tsx +42 -0
- package/src/player/components/PreviewSeekBar.tsx +20 -3
- package/src/player/hooks/usePlaybackKeyboard.test.ts +1 -1
- package/src/player/hooks/usePlaybackKeyboard.ts +2 -1
- package/src/player/hooks/useTimelinePlayer.ts +3 -1
- package/src/player/lib/mediaFetch.test.ts +3 -4
- package/src/player/lib/pausedVideoDecoder.test.ts +644 -0
- package/src/player/lib/pausedVideoDecoder.ts +428 -0
- package/src/player/lib/pausedVideoProvider.test.ts +53 -0
- package/src/player/lib/pausedVideoProvider.ts +54 -0
- package/src/player/lib/playbackTypes.ts +8 -2
- package/src/player/lib/previewVideoTime.test.ts +38 -0
- package/src/player/lib/previewVideoTime.ts +39 -0
- package/src/utils/authoredSource.test.ts +11 -0
- package/src/utils/authoredSource.ts +2 -0
- package/dist/assets/index-CFUJyYA1.js +0 -531
|
@@ -0,0 +1,428 @@
|
|
|
1
|
+
import {
|
|
2
|
+
ALL_FORMATS,
|
|
3
|
+
Input,
|
|
4
|
+
UrlSource,
|
|
5
|
+
VideoSampleSink,
|
|
6
|
+
type Rotation,
|
|
7
|
+
type VideoSample,
|
|
8
|
+
} from "mediabunny";
|
|
9
|
+
import type {
|
|
10
|
+
PausedVideoFrame,
|
|
11
|
+
PausedVideoFrameProvider,
|
|
12
|
+
PausedVideoFrameRequest,
|
|
13
|
+
} from "@hyperframes/core";
|
|
14
|
+
import { mediaUrlSourceOptions } from "./mediaFetch";
|
|
15
|
+
import type { IframeWindow } from "./playbackTypes";
|
|
16
|
+
import {
|
|
17
|
+
previewDecodeTime,
|
|
18
|
+
previewPresentationTime,
|
|
19
|
+
type PreviewVideoTiming,
|
|
20
|
+
} from "./previewVideoTime";
|
|
21
|
+
|
|
22
|
+
const FRAME_BUDGET = 64 * 1024 * 1024;
|
|
23
|
+
const MAX_READERS = 4;
|
|
24
|
+
const NEARBY_FORWARD_SECONDS = 0.5;
|
|
25
|
+
|
|
26
|
+
type Cached = {
|
|
27
|
+
image: ImageBitmap;
|
|
28
|
+
timestamp: number;
|
|
29
|
+
duration: number;
|
|
30
|
+
bytes: number;
|
|
31
|
+
pins: number;
|
|
32
|
+
};
|
|
33
|
+
type Reader = {
|
|
34
|
+
key: string;
|
|
35
|
+
input: Input;
|
|
36
|
+
cancelReads(): void;
|
|
37
|
+
sink: VideoSampleSink;
|
|
38
|
+
canvas: HTMLCanvasElement;
|
|
39
|
+
rotation: Rotation;
|
|
40
|
+
flip: boolean;
|
|
41
|
+
width: number;
|
|
42
|
+
height: number;
|
|
43
|
+
lead: number;
|
|
44
|
+
ticks: number;
|
|
45
|
+
transparent: boolean;
|
|
46
|
+
tail: Promise<void>;
|
|
47
|
+
iterator: AsyncGenerator<VideoSample, void, unknown> | null;
|
|
48
|
+
iteratorEnd: number;
|
|
49
|
+
lastTime: number;
|
|
50
|
+
cache: Map<number, Cached>;
|
|
51
|
+
users: number;
|
|
52
|
+
disposed: boolean;
|
|
53
|
+
idleTimer?: ReturnType<typeof setTimeout>;
|
|
54
|
+
};
|
|
55
|
+
|
|
56
|
+
async function readSingleSample(reader: Reader, query: number): Promise<VideoSample | null> {
|
|
57
|
+
if (!reader.transparent) return reader.sink.getSample(query);
|
|
58
|
+
let selected: VideoSample | null = null;
|
|
59
|
+
try {
|
|
60
|
+
for await (const next of reader.sink.samplesAtTimestamps([query])) {
|
|
61
|
+
selected?.close();
|
|
62
|
+
selected = next;
|
|
63
|
+
}
|
|
64
|
+
return selected;
|
|
65
|
+
} catch (error) {
|
|
66
|
+
selected?.close();
|
|
67
|
+
throw error;
|
|
68
|
+
}
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
export function createPausedVideoDecoder(iframe: HTMLIFrameElement): PausedVideoFrameProvider {
|
|
72
|
+
const readers = new Map<string, Promise<Reader>>();
|
|
73
|
+
const opened = new Map<string, Reader>();
|
|
74
|
+
const opening = new Map<Input, () => void>();
|
|
75
|
+
const failed = new Map<string, number>();
|
|
76
|
+
const cacheOrder = new Map<Cached, Reader>();
|
|
77
|
+
let bytes = 0;
|
|
78
|
+
let disposed = false;
|
|
79
|
+
|
|
80
|
+
const sourceFacts = (source: string) => {
|
|
81
|
+
let path = new URL(source, location.href).pathname;
|
|
82
|
+
try {
|
|
83
|
+
path = decodeURIComponent(path);
|
|
84
|
+
} catch {}
|
|
85
|
+
return Object.entries(
|
|
86
|
+
(iframe.contentWindow as IframeWindow | null)?.__HF_MEDIA_SOURCE_FACTS__ ?? {},
|
|
87
|
+
)
|
|
88
|
+
.filter(([suffix]) => path.endsWith(suffix))
|
|
89
|
+
.sort(([a], [b]) => b.length - a.length)[0]?.[1];
|
|
90
|
+
};
|
|
91
|
+
|
|
92
|
+
const trim = (budget = FRAME_BUDGET) => {
|
|
93
|
+
for (const [entry, reader] of cacheOrder) {
|
|
94
|
+
if (bytes <= budget) break;
|
|
95
|
+
if (entry.pins > 0) continue;
|
|
96
|
+
cacheOrder.delete(entry);
|
|
97
|
+
reader.cache.delete(entry.timestamp);
|
|
98
|
+
bytes -= entry.bytes;
|
|
99
|
+
entry.image.close();
|
|
100
|
+
}
|
|
101
|
+
};
|
|
102
|
+
const disposeReader = async (reader: Reader) => {
|
|
103
|
+
if (reader.disposed) return;
|
|
104
|
+
reader.disposed = true;
|
|
105
|
+
clearTimeout(reader.idleTimer);
|
|
106
|
+
if (opened.get(reader.key) === reader) opened.delete(reader.key);
|
|
107
|
+
// Input disposal must not cut off an in-flight alpha merger.
|
|
108
|
+
if (reader.transparent) await reader.tail;
|
|
109
|
+
reader.cancelReads();
|
|
110
|
+
reader.input.dispose();
|
|
111
|
+
await closeIterator(reader).catch(() => {});
|
|
112
|
+
for (const entry of reader.cache.values()) {
|
|
113
|
+
cacheOrder.delete(entry);
|
|
114
|
+
bytes -= entry.bytes;
|
|
115
|
+
entry.image.close();
|
|
116
|
+
}
|
|
117
|
+
reader.cache.clear();
|
|
118
|
+
reader.canvas.width = reader.canvas.height = 0;
|
|
119
|
+
};
|
|
120
|
+
const scheduleIdle = (reader: Reader) => {
|
|
121
|
+
clearTimeout(reader.idleTimer);
|
|
122
|
+
if (
|
|
123
|
+
reader.disposed ||
|
|
124
|
+
reader.users > 0 ||
|
|
125
|
+
[...reader.cache.values()].some((entry) => entry.pins > 0)
|
|
126
|
+
)
|
|
127
|
+
return;
|
|
128
|
+
reader.idleTimer = setTimeout(() => {
|
|
129
|
+
if (reader.users > 0 || [...reader.cache.values()].some((entry) => entry.pins > 0)) return;
|
|
130
|
+
if (opened.get(reader.key) !== reader) return;
|
|
131
|
+
readers.delete(reader.key);
|
|
132
|
+
void disposeReader(reader);
|
|
133
|
+
}, 10000);
|
|
134
|
+
};
|
|
135
|
+
const open = async (source: string): Promise<Reader> => {
|
|
136
|
+
const options = mediaUrlSourceOptions("thumbnail");
|
|
137
|
+
const input = new Input({ source: new UrlSource(source, options), formats: ALL_FORMATS });
|
|
138
|
+
opening.set(input, options.cancelReads);
|
|
139
|
+
try {
|
|
140
|
+
const track = await input.getPrimaryVideoTrack();
|
|
141
|
+
if (!track || disposed) throw new Error("Preview video unavailable");
|
|
142
|
+
const [width, height, lead, ticks, squareWidth, squareHeight, rotation, flip, transparent] =
|
|
143
|
+
await Promise.all([
|
|
144
|
+
track.getDisplayWidth(),
|
|
145
|
+
track.getDisplayHeight(),
|
|
146
|
+
track.getFirstTimestamp(),
|
|
147
|
+
track.getTimeResolution(),
|
|
148
|
+
track.getSquarePixelWidth(),
|
|
149
|
+
track.getSquarePixelHeight(),
|
|
150
|
+
track.getRotation(),
|
|
151
|
+
track.getFlip(),
|
|
152
|
+
track.canBeTransparent(),
|
|
153
|
+
]);
|
|
154
|
+
const canvas = document.createElement("canvas");
|
|
155
|
+
canvas.width = Math.max(1, Math.ceil(width));
|
|
156
|
+
const aspect = rotation % 180 === 0 ? squareWidth / squareHeight : squareHeight / squareWidth;
|
|
157
|
+
canvas.height = Math.max(1, Math.round(canvas.width / aspect));
|
|
158
|
+
return {
|
|
159
|
+
key: source,
|
|
160
|
+
input,
|
|
161
|
+
cancelReads: options.cancelReads,
|
|
162
|
+
sink: new VideoSampleSink(track),
|
|
163
|
+
canvas,
|
|
164
|
+
rotation,
|
|
165
|
+
flip,
|
|
166
|
+
width,
|
|
167
|
+
height,
|
|
168
|
+
lead,
|
|
169
|
+
ticks,
|
|
170
|
+
transparent,
|
|
171
|
+
tail: Promise.resolve(),
|
|
172
|
+
iterator: null,
|
|
173
|
+
iteratorEnd: 0,
|
|
174
|
+
lastTime: -Infinity,
|
|
175
|
+
cache: new Map(),
|
|
176
|
+
users: 0,
|
|
177
|
+
disposed: false,
|
|
178
|
+
};
|
|
179
|
+
} catch (error) {
|
|
180
|
+
input.dispose();
|
|
181
|
+
options.cancelReads();
|
|
182
|
+
throw error;
|
|
183
|
+
} finally {
|
|
184
|
+
opening.delete(input);
|
|
185
|
+
}
|
|
186
|
+
};
|
|
187
|
+
const reserveReader = () => {
|
|
188
|
+
for (const [oldKey] of readers) {
|
|
189
|
+
if (readers.size < MAX_READERS) break;
|
|
190
|
+
const old = opened.get(oldKey);
|
|
191
|
+
if (old && old.users === 0 && ![...old.cache.values()].some((entry) => entry.pins > 0)) {
|
|
192
|
+
readers.delete(oldKey);
|
|
193
|
+
void disposeReader(old);
|
|
194
|
+
}
|
|
195
|
+
}
|
|
196
|
+
if (readers.size >= MAX_READERS) throw new Error("Preview decoder budget reached");
|
|
197
|
+
};
|
|
198
|
+
const readerFor = async (source: string): Promise<Reader> => {
|
|
199
|
+
const key = source;
|
|
200
|
+
if ((failed.get(key) ?? 0) > performance.now()) throw new Error("Preview decoder cooling down");
|
|
201
|
+
let promise = readers.get(key);
|
|
202
|
+
if (!promise) {
|
|
203
|
+
reserveReader();
|
|
204
|
+
promise = open(source);
|
|
205
|
+
readers.set(key, promise);
|
|
206
|
+
}
|
|
207
|
+
readers.delete(key);
|
|
208
|
+
readers.set(key, promise);
|
|
209
|
+
let reader: Reader;
|
|
210
|
+
try {
|
|
211
|
+
reader = await promise;
|
|
212
|
+
} catch (error) {
|
|
213
|
+
if (readers.get(key) === promise) {
|
|
214
|
+
readers.delete(key);
|
|
215
|
+
failed.set(key, performance.now() + 5000);
|
|
216
|
+
}
|
|
217
|
+
throw error;
|
|
218
|
+
}
|
|
219
|
+
if (disposed || reader.disposed) throw new DOMException("Preview disposed", "AbortError");
|
|
220
|
+
opened.set(key, reader);
|
|
221
|
+
reader.users++;
|
|
222
|
+
clearTimeout(reader.idleTimer);
|
|
223
|
+
return reader;
|
|
224
|
+
};
|
|
225
|
+
const closeIterator = async (reader: Reader) => {
|
|
226
|
+
const iterator = reader.iterator;
|
|
227
|
+
reader.iterator = null;
|
|
228
|
+
await iterator?.return();
|
|
229
|
+
};
|
|
230
|
+
const checkActive = (reader: Reader, signal: AbortSignal) => {
|
|
231
|
+
signal.throwIfAborted();
|
|
232
|
+
if (disposed || reader.disposed) throw new Error("Preview disposed");
|
|
233
|
+
};
|
|
234
|
+
const readForward = async (reader: Reader, query: number, signal: AbortSignal) => {
|
|
235
|
+
if (!reader.iterator) {
|
|
236
|
+
reader.iteratorEnd = query + 8;
|
|
237
|
+
reader.iterator = reader.sink.samples(query, reader.iteratorEnd);
|
|
238
|
+
}
|
|
239
|
+
for (;;) {
|
|
240
|
+
checkActive(reader, signal);
|
|
241
|
+
const next = await reader.iterator.next();
|
|
242
|
+
if (next.done) return null;
|
|
243
|
+
const sample = next.value;
|
|
244
|
+
let selected = false;
|
|
245
|
+
try {
|
|
246
|
+
checkActive(reader, signal);
|
|
247
|
+
if (sample.timestamp > query + 1e-6) return null;
|
|
248
|
+
selected = sample.timestamp + sample.duration > query + 1e-6;
|
|
249
|
+
if (selected) return sample;
|
|
250
|
+
} finally {
|
|
251
|
+
if (!selected) sample.close();
|
|
252
|
+
}
|
|
253
|
+
}
|
|
254
|
+
};
|
|
255
|
+
const pin = (reader: Reader, entry: Cached) => {
|
|
256
|
+
entry.pins++;
|
|
257
|
+
cacheOrder.delete(entry);
|
|
258
|
+
cacheOrder.set(entry, reader);
|
|
259
|
+
return entry;
|
|
260
|
+
};
|
|
261
|
+
const cacheFrame = async (
|
|
262
|
+
reader: Reader,
|
|
263
|
+
sample: VideoSample,
|
|
264
|
+
time: number,
|
|
265
|
+
timing: PreviewVideoTiming,
|
|
266
|
+
signal: AbortSignal,
|
|
267
|
+
): Promise<Cached> => {
|
|
268
|
+
const context = reader.canvas.getContext("2d", { alpha: true });
|
|
269
|
+
if (!context) throw new Error("Preview canvas unavailable");
|
|
270
|
+
context.clearRect(0, 0, reader.canvas.width, reader.canvas.height);
|
|
271
|
+
context.imageSmoothingQuality = "high";
|
|
272
|
+
sample.drawWithFit(context, { fit: "fill", rotation: reader.rotation, flip: reader.flip });
|
|
273
|
+
const image = await createImageBitmap(reader.canvas);
|
|
274
|
+
if (signal.aborted || disposed || reader.disposed) {
|
|
275
|
+
image.close();
|
|
276
|
+
signal.throwIfAborted();
|
|
277
|
+
throw new Error("Preview disposed");
|
|
278
|
+
}
|
|
279
|
+
const entry = {
|
|
280
|
+
image,
|
|
281
|
+
...previewPresentationTime(sample.timestamp, time, timing),
|
|
282
|
+
bytes: image.width * image.height * 4,
|
|
283
|
+
pins: 1,
|
|
284
|
+
};
|
|
285
|
+
const previous = reader.cache.get(entry.timestamp);
|
|
286
|
+
if (previous) {
|
|
287
|
+
previous.duration = Math.max(previous.duration, entry.duration);
|
|
288
|
+
image.close();
|
|
289
|
+
return pin(reader, previous);
|
|
290
|
+
}
|
|
291
|
+
trim(FRAME_BUDGET - entry.bytes);
|
|
292
|
+
if (bytes + entry.bytes > FRAME_BUDGET) {
|
|
293
|
+
image.close();
|
|
294
|
+
throw new Error("Preview frame budget reached");
|
|
295
|
+
}
|
|
296
|
+
reader.cache.set(entry.timestamp, entry);
|
|
297
|
+
cacheOrder.set(entry, reader);
|
|
298
|
+
bytes += entry.bytes;
|
|
299
|
+
return entry;
|
|
300
|
+
};
|
|
301
|
+
const nearbyForward = (reader: Reader, time: number, timing: PreviewVideoTiming) =>
|
|
302
|
+
// Mediabunny 1.65.2 can orphan alpha samples when a range is cancelled.
|
|
303
|
+
// Finite timestamp iterators drain the merger before closing it.
|
|
304
|
+
!reader.transparent &&
|
|
305
|
+
!timing.variableFrameRate &&
|
|
306
|
+
(timing.frameRate ?? 0) > 0 &&
|
|
307
|
+
time > reader.lastTime + 1e-6 &&
|
|
308
|
+
time - reader.lastTime <= NEARBY_FORWARD_SECONDS;
|
|
309
|
+
const readFrame = async (
|
|
310
|
+
reader: Reader,
|
|
311
|
+
time: number,
|
|
312
|
+
timing: PreviewVideoTiming,
|
|
313
|
+
signal: AbortSignal,
|
|
314
|
+
): Promise<Cached> => {
|
|
315
|
+
checkActive(reader, signal);
|
|
316
|
+
const cached = [...reader.cache.values()].find(
|
|
317
|
+
(entry) => time >= entry.timestamp - 1e-6 && time < entry.timestamp + entry.duration - 1e-6,
|
|
318
|
+
);
|
|
319
|
+
if (cached) return pin(reader, cached);
|
|
320
|
+
const query = previewDecodeTime(time, timing),
|
|
321
|
+
forward = nearbyForward(reader, time, timing);
|
|
322
|
+
let sample: VideoSample | null = null;
|
|
323
|
+
try {
|
|
324
|
+
if (!forward || query >= reader.iteratorEnd) await closeIterator(reader);
|
|
325
|
+
sample = forward ? await readForward(reader, query, signal) : null;
|
|
326
|
+
if (!sample) {
|
|
327
|
+
await closeIterator(reader);
|
|
328
|
+
sample = await readSingleSample(reader, query);
|
|
329
|
+
}
|
|
330
|
+
if (!sample) throw new Error("No preview frame at requested time");
|
|
331
|
+
checkActive(reader, signal);
|
|
332
|
+
reader.lastTime = time;
|
|
333
|
+
return await cacheFrame(reader, sample, time, timing, signal);
|
|
334
|
+
} finally {
|
|
335
|
+
sample?.close();
|
|
336
|
+
if (signal.aborted || disposed) await closeIterator(reader).catch(() => {});
|
|
337
|
+
}
|
|
338
|
+
};
|
|
339
|
+
const sourceTiming = (request: PausedVideoFrameRequest, reader: Reader) => {
|
|
340
|
+
const facts = sourceFacts(request.source);
|
|
341
|
+
return {
|
|
342
|
+
frameRate: facts?.frameRate,
|
|
343
|
+
variableFrameRate: facts?.variableFrameRate,
|
|
344
|
+
sourceLead: reader.lead,
|
|
345
|
+
inputLead: reader.lead,
|
|
346
|
+
timeResolution: reader.ticks,
|
|
347
|
+
};
|
|
348
|
+
};
|
|
349
|
+
const decodeOne = async (
|
|
350
|
+
request: PausedVideoFrameRequest,
|
|
351
|
+
signal: AbortSignal,
|
|
352
|
+
): Promise<PausedVideoFrame> => {
|
|
353
|
+
signal.throwIfAborted();
|
|
354
|
+
const source = request.source;
|
|
355
|
+
if (!source) throw new Error("Preview source unavailable");
|
|
356
|
+
const reader = await readerFor(source);
|
|
357
|
+
try {
|
|
358
|
+
const timing = sourceTiming(request, reader);
|
|
359
|
+
const job = reader.tail.then(() => readFrame(reader, request.time, timing, signal));
|
|
360
|
+
reader.tail = job.then(
|
|
361
|
+
() => {},
|
|
362
|
+
() => {},
|
|
363
|
+
);
|
|
364
|
+
const entry = await job;
|
|
365
|
+
let released = false;
|
|
366
|
+
trim();
|
|
367
|
+
return {
|
|
368
|
+
source: entry.image,
|
|
369
|
+
timestamp: entry.timestamp,
|
|
370
|
+
duration: entry.duration,
|
|
371
|
+
width: reader.width,
|
|
372
|
+
height: reader.height,
|
|
373
|
+
release() {
|
|
374
|
+
if (released) return;
|
|
375
|
+
released = true;
|
|
376
|
+
entry.pins--;
|
|
377
|
+
trim();
|
|
378
|
+
scheduleIdle(reader);
|
|
379
|
+
},
|
|
380
|
+
};
|
|
381
|
+
} finally {
|
|
382
|
+
reader.users--;
|
|
383
|
+
scheduleIdle(reader);
|
|
384
|
+
}
|
|
385
|
+
};
|
|
386
|
+
return {
|
|
387
|
+
async decode(requests, signal) {
|
|
388
|
+
if (disposed) throw new DOMException("Preview disposed", "AbortError");
|
|
389
|
+
if (new Set(requests.map(({ source }) => source)).size > MAX_READERS)
|
|
390
|
+
throw new Error("Preview decoder budget reached");
|
|
391
|
+
const results = await Promise.allSettled(
|
|
392
|
+
requests.map((request) => decodeOne(request, signal)),
|
|
393
|
+
);
|
|
394
|
+
const failure = results.find((result) => result.status === "rejected");
|
|
395
|
+
const frames = results.flatMap((result) =>
|
|
396
|
+
result.status === "fulfilled" ? [result.value] : [],
|
|
397
|
+
);
|
|
398
|
+
if (failure || disposed || signal.aborted) {
|
|
399
|
+
for (const frame of frames) frame.release();
|
|
400
|
+
if (failure) throw failure.reason;
|
|
401
|
+
throw new DOMException("Preview cancelled", "AbortError");
|
|
402
|
+
}
|
|
403
|
+
return frames;
|
|
404
|
+
},
|
|
405
|
+
async suspend() {
|
|
406
|
+
const closing = [...readers.values()].map((promise) =>
|
|
407
|
+
promise.then(disposeReader).catch(() => {}),
|
|
408
|
+
);
|
|
409
|
+
readers.clear();
|
|
410
|
+
for (const [input, cancel] of opening) {
|
|
411
|
+
cancel();
|
|
412
|
+
input.dispose();
|
|
413
|
+
}
|
|
414
|
+
await Promise.all(closing);
|
|
415
|
+
},
|
|
416
|
+
dispose() {
|
|
417
|
+
if (disposed) return;
|
|
418
|
+
disposed = true;
|
|
419
|
+
for (const [input, cancel] of opening) {
|
|
420
|
+
cancel();
|
|
421
|
+
input.dispose();
|
|
422
|
+
}
|
|
423
|
+
for (const promise of readers.values()) void promise.then(disposeReader).catch(() => {});
|
|
424
|
+
readers.clear();
|
|
425
|
+
failed.clear();
|
|
426
|
+
},
|
|
427
|
+
};
|
|
428
|
+
}
|
|
@@ -0,0 +1,53 @@
|
|
|
1
|
+
// @vitest-environment happy-dom
|
|
2
|
+
import { expect, it, vi } from "vitest";
|
|
3
|
+
import type { PausedVideoFrameProvider } from "@hyperframes/core";
|
|
4
|
+
import { attachPausedVideoProvider } from "./pausedVideoProvider";
|
|
5
|
+
|
|
6
|
+
const decoder = vi.hoisted(() => ({
|
|
7
|
+
decode: vi.fn(async () => []),
|
|
8
|
+
suspend: vi.fn(async () => {}),
|
|
9
|
+
dispose: vi.fn(),
|
|
10
|
+
}));
|
|
11
|
+
vi.mock("./pausedVideoDecoder", () => ({ createPausedVideoDecoder: () => decoder }));
|
|
12
|
+
|
|
13
|
+
it("forwards native-play suspension through the lazy provider facade", async () => {
|
|
14
|
+
const iframe = document.createElement("iframe");
|
|
15
|
+
document.body.append(iframe);
|
|
16
|
+
const install = vi.fn<(provider: PausedVideoFrameProvider) => void>();
|
|
17
|
+
const win = iframe.contentWindow!;
|
|
18
|
+
Object.assign(win, {
|
|
19
|
+
__hf: {
|
|
20
|
+
setPausedVideoFrameProvider: install,
|
|
21
|
+
},
|
|
22
|
+
});
|
|
23
|
+
attachPausedVideoProvider(iframe, win);
|
|
24
|
+
const provider = install.mock.calls[0]![0];
|
|
25
|
+
await provider.decode([], new AbortController().signal);
|
|
26
|
+
await provider.suspend?.();
|
|
27
|
+
expect(decoder.suspend).toHaveBeenCalledOnce();
|
|
28
|
+
await provider.decode([], new AbortController().signal);
|
|
29
|
+
expect(decoder.decode).toHaveBeenCalledTimes(2);
|
|
30
|
+
win.dispatchEvent(new Event("pagehide"));
|
|
31
|
+
await Promise.resolve();
|
|
32
|
+
expect(decoder.dispose).toHaveBeenCalledOnce();
|
|
33
|
+
iframe.remove();
|
|
34
|
+
});
|
|
35
|
+
|
|
36
|
+
it("allows native-play suspension after the lazy decoder chunk rejects", async () => {
|
|
37
|
+
vi.resetModules();
|
|
38
|
+
vi.doMock("./pausedVideoDecoder", () => {
|
|
39
|
+
throw new Error("decoder chunk unavailable");
|
|
40
|
+
});
|
|
41
|
+
const { attachPausedVideoProvider: attach } = await import("./pausedVideoProvider");
|
|
42
|
+
const iframe = document.createElement("iframe");
|
|
43
|
+
document.body.append(iframe);
|
|
44
|
+
const install = vi.fn<(provider: PausedVideoFrameProvider) => void>();
|
|
45
|
+
const win = iframe.contentWindow!;
|
|
46
|
+
Object.assign(win, { __hf: { setPausedVideoFrameProvider: install } });
|
|
47
|
+
attach(iframe, win);
|
|
48
|
+
const provider = install.mock.calls[0]![0];
|
|
49
|
+
await expect(provider.decode([], new AbortController().signal)).rejects.toThrow();
|
|
50
|
+
await expect(provider.suspend!()).resolves.toBeUndefined();
|
|
51
|
+
win.dispatchEvent(new Event("pagehide"));
|
|
52
|
+
iframe.remove();
|
|
53
|
+
});
|
|
@@ -0,0 +1,54 @@
|
|
|
1
|
+
import type { PausedVideoFrameProvider } from "@hyperframes/core";
|
|
2
|
+
import type { IframeWindow } from "./playbackTypes";
|
|
3
|
+
|
|
4
|
+
const installed = new WeakMap<
|
|
5
|
+
HTMLIFrameElement,
|
|
6
|
+
{
|
|
7
|
+
document: Document;
|
|
8
|
+
provider: PausedVideoFrameProvider;
|
|
9
|
+
setter: (provider: PausedVideoFrameProvider | null) => void;
|
|
10
|
+
}
|
|
11
|
+
>();
|
|
12
|
+
|
|
13
|
+
/** A lazy facade also installs in Studio's hidden reload frame before its first seek. */
|
|
14
|
+
export function attachPausedVideoProvider(iframe: HTMLIFrameElement, win: IframeWindow): void {
|
|
15
|
+
if (!win.__hf?.setPausedVideoFrameProvider || !iframe.contentDocument) return;
|
|
16
|
+
const previous = installed.get(iframe);
|
|
17
|
+
const setter = win.__hf.setPausedVideoFrameProvider;
|
|
18
|
+
if (previous?.document === iframe.contentDocument && previous.setter === setter) return;
|
|
19
|
+
previous?.provider.dispose();
|
|
20
|
+
let disposed = false;
|
|
21
|
+
let decoder: Promise<PausedVideoFrameProvider> | null = null;
|
|
22
|
+
const provider: PausedVideoFrameProvider = {
|
|
23
|
+
async decode(requests, signal) {
|
|
24
|
+
signal.throwIfAborted();
|
|
25
|
+
if (disposed) throw new DOMException("Preview disposed", "AbortError");
|
|
26
|
+
decoder ??= import("./pausedVideoDecoder").then(({ createPausedVideoDecoder }) =>
|
|
27
|
+
createPausedVideoDecoder(iframe),
|
|
28
|
+
);
|
|
29
|
+
const actual = await decoder;
|
|
30
|
+
if (disposed) {
|
|
31
|
+
actual.dispose();
|
|
32
|
+
throw new DOMException("Preview disposed", "AbortError");
|
|
33
|
+
}
|
|
34
|
+
return actual.decode(requests, signal);
|
|
35
|
+
},
|
|
36
|
+
async suspend() {
|
|
37
|
+
const actual = await decoder?.catch(() => null);
|
|
38
|
+
await actual?.suspend?.();
|
|
39
|
+
},
|
|
40
|
+
dispose() {
|
|
41
|
+
if (disposed) return;
|
|
42
|
+
disposed = true;
|
|
43
|
+
void decoder?.then((actual) => actual.dispose()).catch(() => {});
|
|
44
|
+
win.removeEventListener("pagehide", onPageHide);
|
|
45
|
+
},
|
|
46
|
+
};
|
|
47
|
+
const onPageHide = () => {
|
|
48
|
+
provider.dispose();
|
|
49
|
+
installed.delete(iframe);
|
|
50
|
+
};
|
|
51
|
+
win.addEventListener("pagehide", onPageHide, { once: true });
|
|
52
|
+
installed.set(iframe, { document: iframe.contentDocument, provider, setter });
|
|
53
|
+
setter(provider);
|
|
54
|
+
}
|
|
@@ -4,12 +4,16 @@
|
|
|
4
4
|
* from here without creating circular dependencies.
|
|
5
5
|
*/
|
|
6
6
|
|
|
7
|
-
import type {
|
|
7
|
+
import type {
|
|
8
|
+
RuntimeTimelineClipIdentity,
|
|
9
|
+
PausedVideoFrameProvider,
|
|
10
|
+
PreviewSourceFacts,
|
|
11
|
+
} from "@hyperframes/core";
|
|
8
12
|
|
|
9
13
|
export interface PlaybackAdapter {
|
|
10
14
|
play: () => void;
|
|
11
15
|
pause: () => void;
|
|
12
|
-
seek: (time: number, options?: { keepPlaying?: boolean }) => void;
|
|
16
|
+
seek: (time: number, options?: { keepPlaying?: boolean; settled?: boolean }) => void;
|
|
13
17
|
getTime: () => number;
|
|
14
18
|
getDuration: () => number;
|
|
15
19
|
isPlaying: () => boolean;
|
|
@@ -58,6 +62,7 @@ export interface ClipManifest {
|
|
|
58
62
|
}
|
|
59
63
|
|
|
60
64
|
export type IframeWindow = Window & {
|
|
65
|
+
__HF_MEDIA_SOURCE_FACTS__?: Record<string, PreviewSourceFacts>;
|
|
61
66
|
__player?: RuntimePlaybackAdapter;
|
|
62
67
|
__playerReady?: boolean;
|
|
63
68
|
__timeline?: TimelineLike;
|
|
@@ -70,6 +75,7 @@ export type IframeWindow = Window & {
|
|
|
70
75
|
__hf?: {
|
|
71
76
|
leasePausedMedia?: (el: HTMLMediaElement) => void;
|
|
72
77
|
releasePausedMedia?: (el: HTMLMediaElement) => void;
|
|
78
|
+
setPausedVideoFrameProvider?: (provider: PausedVideoFrameProvider | null) => void;
|
|
73
79
|
setLoopStart?: (seconds: number | null) => void;
|
|
74
80
|
};
|
|
75
81
|
};
|
|
@@ -0,0 +1,38 @@
|
|
|
1
|
+
import { expect, it } from "vitest";
|
|
2
|
+
import { previewDecodeTime, previewPresentationTime } from "./previewVideoTime";
|
|
3
|
+
|
|
4
|
+
const cfr = {
|
|
5
|
+
frameRate: 30,
|
|
6
|
+
variableFrameRate: false,
|
|
7
|
+
sourceLead: 0,
|
|
8
|
+
inputLead: 0,
|
|
9
|
+
timeResolution: 1000,
|
|
10
|
+
};
|
|
11
|
+
it("matches export at rounded WebM ticks without selecting the nearest future frame", () => {
|
|
12
|
+
expect(previewDecodeTime(2 / 30, cfr)).toBeCloseTo(0.06701, 8);
|
|
13
|
+
expect(previewPresentationTime(0.067, 2 / 30, cfr).timestamp).toBeCloseTo(2 / 30, 8);
|
|
14
|
+
expect(previewDecodeTime(3.33, cfr)).toBeCloseTo(3.30001, 8);
|
|
15
|
+
expect(previewDecodeTime(0.0666, cfr)).toBeCloseTo(0.03301, 8);
|
|
16
|
+
});
|
|
17
|
+
it("preserves a nonzero source lead when a prepared file starts at zero", () => {
|
|
18
|
+
const timing = { ...cfr, sourceLead: 5, inputLead: 0 };
|
|
19
|
+
expect(previewDecodeTime(5 + 2 / 30, timing)).toBeCloseTo(0.06701, 8);
|
|
20
|
+
expect(previewPresentationTime(0.067, 5 + 2 / 30, timing).timestamp).toBeCloseTo(5 + 2 / 30, 8);
|
|
21
|
+
});
|
|
22
|
+
it("retains raw VFR times and holds a prior frame through a timestamp gap", () => {
|
|
23
|
+
const timing = { ...cfr, variableFrameRate: true };
|
|
24
|
+
expect(previewDecodeTime(0.1, timing)).toBeCloseTo(0.1, 8);
|
|
25
|
+
const held = previewPresentationTime(0.04, 0.1, timing);
|
|
26
|
+
expect(held.timestamp).toBe(0.04);
|
|
27
|
+
expect(held.timestamp + held.duration).toBeGreaterThan(0.1);
|
|
28
|
+
expect(held.timestamp + held.duration).toBeLessThan(0.101);
|
|
29
|
+
});
|
|
30
|
+
it("does not advance to the next CFR frame just before its boundary", () => {
|
|
31
|
+
expect(previewDecodeTime(2 / 30 - 0.000005, cfr)).toBeCloseTo(0.03301, 8);
|
|
32
|
+
const timing = { ...cfr, frameRate: 30000 / 1001, sourceLead: 5 };
|
|
33
|
+
expect(previewDecodeTime(5 + (2 * 1001) / 30000 - 0.000005, timing)).toBeCloseTo(0.03301, 8);
|
|
34
|
+
});
|
|
35
|
+
it("does not cross a real VFR timestamp when querying just before it", () => {
|
|
36
|
+
const timing = { ...cfr, variableFrameRate: true, sourceLead: 5, inputLead: 2 };
|
|
37
|
+
expect(previewDecodeTime(5.1 - 0.000005, timing)).toBeLessThan(2.1);
|
|
38
|
+
});
|
|
@@ -0,0 +1,39 @@
|
|
|
1
|
+
export interface PreviewVideoTiming {
|
|
2
|
+
frameRate?: number;
|
|
3
|
+
variableFrameRate?: boolean;
|
|
4
|
+
sourceLead: number;
|
|
5
|
+
inputLead: number;
|
|
6
|
+
timeResolution: number;
|
|
7
|
+
}
|
|
8
|
+
|
|
9
|
+
const LEAD = 1e-5;
|
|
10
|
+
const FRAME_EPSILON = 1e-9;
|
|
11
|
+
const constantRate = (timing: PreviewVideoTiming) =>
|
|
12
|
+
!timing.variableFrameRate && (timing.frameRate ?? 0) > 0;
|
|
13
|
+
|
|
14
|
+
/** Match export: floor the source-frame grid, then undo container tick rounding. */
|
|
15
|
+
export function previewDecodeTime(time: number, timing: PreviewVideoTiming): number {
|
|
16
|
+
const { sourceLead, inputLead, timeResolution, frameRate = 0 } = timing;
|
|
17
|
+
if (!constantRate(timing))
|
|
18
|
+
return Math.max(inputLead, time - sourceLead + inputLead) + FRAME_EPSILON;
|
|
19
|
+
const index = Math.max(0, Math.floor((time - sourceLead) * frameRate + FRAME_EPSILON));
|
|
20
|
+
const ideal = inputLead + index / frameRate;
|
|
21
|
+
return (timeResolution > 0 ? Math.round(ideal * timeResolution) / timeResolution : ideal) + LEAD;
|
|
22
|
+
}
|
|
23
|
+
|
|
24
|
+
export function previewPresentationTime(
|
|
25
|
+
timestamp: number,
|
|
26
|
+
requested: number,
|
|
27
|
+
timing: PreviewVideoTiming,
|
|
28
|
+
) {
|
|
29
|
+
const { frameRate = 0, sourceLead, inputLead } = timing;
|
|
30
|
+
const logical = constantRate(timing)
|
|
31
|
+
? Math.round((timestamp - inputLead) * frameRate) / frameRate + sourceLead
|
|
32
|
+
: timestamp - inputLead + sourceLead;
|
|
33
|
+
const start = Math.min(requested, logical);
|
|
34
|
+
// A decoded prior frame proves its coverage through this query, including a VFR gap.
|
|
35
|
+
return {
|
|
36
|
+
timestamp: start,
|
|
37
|
+
duration: Math.max(constantRate(timing) ? 1 / frameRate : 0, requested - start + LEAD),
|
|
38
|
+
};
|
|
39
|
+
}
|
|
@@ -4,10 +4,21 @@ import {
|
|
|
4
4
|
PREVIEW_RASTER_ATTR,
|
|
5
5
|
RUNTIME_STAMPED_ATTR,
|
|
6
6
|
STUDIO_PREVIEW_LAZY_ATTR,
|
|
7
|
+
PREVIEW_VIDEO_CANVAS_ATTR,
|
|
8
|
+
PREVIEW_VIDEO_FRAME_ATTR,
|
|
9
|
+
PREVIEW_VIDEO_SOURCE_ATTR,
|
|
7
10
|
} from "@hyperframes/core/studio-preview-mark";
|
|
8
11
|
import { liveMarkupWithoutPreviewMarks } from "./authoredSource";
|
|
9
12
|
|
|
10
13
|
describe("liveMarkupWithoutPreviewMarks", () => {
|
|
14
|
+
it("omits generated video surfaces and their hiding marks from copied composition markup", () => {
|
|
15
|
+
const live = document.createElement("div");
|
|
16
|
+
live.innerHTML = `<canvas ${PREVIEW_VIDEO_CANVAS_ATTR}></canvas><video src="original.webm" ${PREVIEW_VIDEO_FRAME_ATTR} ${PREVIEW_VIDEO_SOURCE_ATTR}></video><canvas id="authored"></canvas>`;
|
|
17
|
+
expect(liveMarkupWithoutPreviewMarks(live)).toBe(
|
|
18
|
+
'<div><video src="original.webm"></video><canvas id="authored"></canvas></div>',
|
|
19
|
+
);
|
|
20
|
+
expect(live.querySelectorAll("canvas")).toHaveLength(2);
|
|
21
|
+
});
|
|
11
22
|
it("drops the preview's raster mark from an element and its descendants", () => {
|
|
12
23
|
const live = document.createElement("div");
|
|
13
24
|
live.innerHTML = `<div class="line" ${PREVIEW_RASTER_ATTR}><span class="word">LOUD</span></div>`;
|
|
@@ -1,6 +1,7 @@
|
|
|
1
1
|
import { ensureHfIds, isCompositionTemplate } from "@hyperframes/parsers/hf-ids";
|
|
2
2
|
import {
|
|
3
3
|
PREVIEW_ONLY_ATTRS,
|
|
4
|
+
PREVIEW_VIDEO_CANVAS_ATTR,
|
|
4
5
|
STUDIO_PREVIEW_LAZY_ATTR,
|
|
5
6
|
} from "@hyperframes/core/studio-preview-mark";
|
|
6
7
|
|
|
@@ -97,6 +98,7 @@ export function authoredMarkup(authored: Element, live: Element, sourceFile: str
|
|
|
97
98
|
|
|
98
99
|
export function liveMarkupWithoutPreviewMarks(live: Element): string {
|
|
99
100
|
const copy = live.cloneNode(true) as Element;
|
|
101
|
+
for (const canvas of copy.querySelectorAll(`[${PREVIEW_VIDEO_CANVAS_ATTR}]`)) canvas.remove();
|
|
100
102
|
for (const el of [copy, ...Array.from(copy.querySelectorAll("*"))]) {
|
|
101
103
|
if (el.hasAttribute(STUDIO_PREVIEW_LAZY_ATTR)) el.removeAttribute("loading");
|
|
102
104
|
for (const attr of PREVIEW_ONLY_ATTRS) el.removeAttribute(attr);
|