Merge pull request #22 from diffusionstudio/konstantin/fix/large-vide…

…o-handling

Konstantin/fix/large video handling

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@diffusionstudio/core",
   "private": false,
-  "version": "1.0.0-rc.8",
+  "version": "1.0.0",
   "type": "module",
   "description": "Build bleeding edge video processing applications",
   "files": [

src/clips/video/buffer.spec.ts

@@ -27,8 +27,8 @@ describe('FrameBuffer', () => {
 
     frameBuffer.enqueue(mockVideoFrame);
 
-    expect(frameBuffer['buffer'].length).toBe(1);
-    expect(frameBuffer['buffer'][0]).toBe(mockVideoFrame);
+    expect(frameBuffer.frames.length).toBe(1);
+    expect(frameBuffer.frames[0]).toBe(mockVideoFrame);
     expect(mockOnEnqueue).toHaveBeenCalled();
   });
 
@@ -44,7 +44,7 @@ describe('FrameBuffer', () => {
 
     expect(dequeuedFrame1).toBe(frame1);
     expect(dequeuedFrame2).toBe(frame2);
-    expect(frameBuffer['buffer'].length).toBe(0);
+    expect(frameBuffer.frames.length).toBe(0);
   });
 
   it('should wait for a frame to be enqueued if buffer is empty and state is active', async () => {

src/clips/video/buffer.ts

@@ -6,27 +6,27 @@
  */
 
 export class FrameBuffer {
-	private buffer: Array<VideoFrame> = [];
-	private state: 'active' | 'closed' = 'active';
+	public frames: Array<VideoFrame> = [];
+	public state: 'active' | 'closed' = 'active';
 
 	public onenqueue?: () => void;
 	public onclose?: () => void;
 
 	public enqueue(data: VideoFrame) {
-		this.buffer.unshift(data);
+		this.frames.unshift(data);
 		this.onenqueue?.();
 	}
 
 	public async dequeue() {
-		if (this.buffer.length == 0 && this.state == 'active') {
+		if (this.frames.length == 0 && this.state == 'active') {
 			await this.waitFor(20e3);
 		}
 
-		if (this.buffer.length == 0 && this.state == 'closed') {
+		if (this.frames.length == 0 && this.state == 'closed') {
 			return;
 		}
 
-		return this.buffer.pop();
+		return this.frames.pop();
 	}
 
 	public close() {
@@ -35,7 +35,7 @@ export class FrameBuffer {
 	}
 
 	public terminate() {
-		for (const frame of this.buffer) {
+		for (const frame of this.frames) {
 			frame.close();
 		}
 	}

src/clips/video/video.spec.ts

@@ -264,6 +264,10 @@ describe('The Video Clip', () => {
 		const composition = new Composition();
 		await composition.add(clip);
 
+		composition.computeFrame();
+
+		expect(clip.track?.view.children.length).toBe(1);
+
 		const buffer = new FrameBuffer();
 
 		Object.defineProperty(buffer, 'onenqueue', {
@@ -274,8 +278,13 @@ describe('The Video Clip', () => {
 		const decodeSpy = vi.spyOn(clip, 'decodeVideo').mockReturnValueOnce(buffer);
 		composition.state = 'RENDER';
 
-		await clip.seek(new Timestamp());
+		await composition.seek(0);
+
+		expect(clip.track?.view.children.length).toBe(0);
+
+		await composition.computeFrame();
 
+		expect(clip.track?.view.children.length).toBe(1);
 		expect(decodeSpy).toBeCalledTimes(1);
 		expect(seekFn.mock.calls[0][0]).toBe(0);
 	});

src/clips/video/video.ts

@@ -110,6 +110,13 @@ export class VideoClip extends VisualMixin(MediaClip<VideoClipProps>) {
 		await this.seek(Timestamp.fromFrames(frame));
 	}
 
+	public enter() {
+		super.enter();
+		if (this.track?.composition?.rendering && this.buffer?.state != 'active') {
+			this.decodeVideo();
+		}
+	}
+
 	@visualize
 	@textureSwap
 	public update(_: Timestamp): void | Promise<void> {
@@ -139,17 +146,6 @@ export class VideoClip extends VisualMixin(MediaClip<VideoClipProps>) {
 		return clip;
 	}
 
-	public async seek(time: Timestamp): Promise<void> {
-		if (this.track?.composition?.rendering) {
-			const buffer = await this.decodeVideo();
-			return new Promise<void>((resolve) => {
-				buffer.onenqueue = () => resolve();
-			});
-		}
-
-		return super.seek(time);
-	}
-
 	private async decodeVideo() {
 		this.buffer = new FrameBuffer();
 		this.worker = new DecodeWorker();

src/encoders/encoder.spec.ts

@@ -49,8 +49,7 @@ describe('The Encoder', () => {
     await encoder.render();
 
     expect(pauseSpy).toBeCalledTimes(1);
-    // before and after
-    expect(seekSpy).toBeCalledTimes(2);
+    expect(seekSpy).toBeCalledTimes(1);
   });
 
   it('should not render when the composition renderer is not defined', async () => {

src/encoders/encoder.ts

@@ -96,7 +96,6 @@ export class Encoder extends WebcodecsVideoEncoder {
 			this.composition.state = 'IDLE';
 			this.composition.renderer.resolution = 1;
 			this.composition.fps = FPS_DEFAULT;
-			this.composition.seek(0);
 		}
 	}
 

src/models/transcript.ts

@@ -17,7 +17,7 @@ import type { Captions } from '../types';
 import type { Serializer } from '../services';
 
 export class Transcript implements Serializer {
-	public readonly id = crypto.randomUUID();
+	public id = crypto.randomUUID();
 	public language: Language = Language.en;
 	public groups: WordGroup[] = [];
 

src/services/serializer.ts

@@ -4,7 +4,7 @@ export class Serializer {
 	/**
 	 * Unique identifier of the object
 	 */
-	public readonly id = crypto.randomUUID();
+	public id = crypto.randomUUID();
 
 	toJSON(): any {
 		const obj: any = {};

src/tracks/video/video.ts

@@ -6,8 +6,19 @@
  */
 
 import { MediaTrack } from '../media';
+import { Timestamp } from '../../models';
+
 import type { VideoClip } from '../../clips';
 
 export class VideoTrack extends MediaTrack<VideoClip> {
 	public readonly type = 'video';
+
+	public async seek(time: Timestamp): Promise<void> {
+		if (this.composition?.rendering) {
+			// ensures that 'enter' method will be called again
+			this.view.removeChildren();
+		} else {
+			super.seek(time);
+		}
+	}
 }