added clip test cases

Author: k9p5

src/clips/clip/clip.deserializer.spec.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import { ClipDeserializer } from './clip.desierializer';
+import { 
+  AudioClip, 
+  VideoClip, 
+  HtmlClip, 
+  ImageClip, 
+  TextClip, 
+  ComplexTextClip, 
+  Clip 
+} from '..';
+import { AudioSource, HtmlSource, ImageSource, VideoSource } from '../../sources';
+import type { Source } from '../../sources';
+
+describe('ClipDeserializer', () => {
+  it('should return correct clip based on type', () => {
+    expect(ClipDeserializer.fromType({ type: 'video' })).toBeInstanceOf(VideoClip);
+    expect(ClipDeserializer.fromType({ type: 'audio' })).toBeInstanceOf(AudioClip);
+    expect(ClipDeserializer.fromType({ type: 'html' })).toBeInstanceOf(HtmlClip);
+    expect(ClipDeserializer.fromType({ type: 'image' })).toBeInstanceOf(ImageClip);
+    expect(ClipDeserializer.fromType({ type: 'text' })).toBeInstanceOf(TextClip);
+    expect(ClipDeserializer.fromType({ type: 'complex_text' })).toBeInstanceOf(ComplexTextClip);
+    expect(ClipDeserializer.fromType({ type: 'unknown' as any })).toBeInstanceOf(Clip); // Default case
+  });
+
+  it('should return correct clip based on source', () => {
+    // Mock instances for different source types
+    const audioSource = new AudioSource();
+    const videoSource = new VideoSource();
+    const imageSource = new ImageSource();
+    const htmlSource = new HtmlSource();
+
+    const res = ClipDeserializer.fromSource(audioSource)
+
+    // Ensure proper class instantiation based on source type
+    expect(res).toBeInstanceOf(AudioClip);
+    expect(ClipDeserializer.fromSource(videoSource)).toBeInstanceOf(VideoClip);
+    expect(ClipDeserializer.fromSource(imageSource)).toBeInstanceOf(ImageClip);
+    expect(ClipDeserializer.fromSource(htmlSource)).toBeInstanceOf(HtmlClip);
+  });
+
+  it('should return undefined if source type does not match', () => {
+    const invalidSourceMock = { type: 'unknown' } as any as Source;
+    expect(ClipDeserializer.fromSource(invalidSourceMock)).toBeUndefined();
+  });
+});

src/clips/video/buffer.spec.ts

@@ -0,0 +1,101 @@
+/**
+ * Copyright (c) 2024 The Diffusion Studio Authors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla 
+ * Public License, v. 2.0 that can be found in the LICENSE file.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { FrameBuffer } from './buffer';
+
+describe('FrameBuffer', () => {
+  let frameBuffer: FrameBuffer;
+  let mockVideoFrame: any;
+
+  beforeEach(() => {
+    // Mock VideoFrame
+    mockVideoFrame = {
+      close: vi.fn(),
+    };
+
+    frameBuffer = new FrameBuffer();
+  });
+
+  it('should enqueue frames and trigger onenqueue callback', () => {
+    const mockOnEnqueue = vi.fn();
+    frameBuffer.onenqueue = mockOnEnqueue;
+
+    frameBuffer.enqueue(mockVideoFrame);
+
+    expect(frameBuffer['buffer'].length).toBe(1);
+    expect(frameBuffer['buffer'][0]).toBe(mockVideoFrame);
+    expect(mockOnEnqueue).toHaveBeenCalled();
+  });
+
+  it('should dequeue frames in FIFO order', async () => {
+    const frame1 = { ...mockVideoFrame };
+    const frame2 = { ...mockVideoFrame };
+    
+    frameBuffer.enqueue(frame1);
+    frameBuffer.enqueue(frame2);
+
+    const dequeuedFrame1 = await frameBuffer.dequeue();
+    const dequeuedFrame2 = await frameBuffer.dequeue();
+
+    expect(dequeuedFrame1).toBe(frame1);
+    expect(dequeuedFrame2).toBe(frame2);
+    expect(frameBuffer['buffer'].length).toBe(0);
+  });
+
+  it('should wait for a frame to be enqueued if buffer is empty and state is active', async () => {
+    const mockOnEnqueue = vi.fn();
+    const mockWaitFor = vi.spyOn(frameBuffer as any, 'waitFor');
+
+    frameBuffer.onenqueue = mockOnEnqueue;
+    const dequeuePromise = frameBuffer.dequeue();
+
+    // Simulate enqueuing a frame after some delay
+    setTimeout(() => {
+      frameBuffer.enqueue(mockVideoFrame);
+    }, 100);
+
+    const result = await dequeuePromise;
+
+    expect(result).toBe(mockVideoFrame);
+    expect(mockWaitFor).toHaveBeenCalledWith(20000); // 20s timeout
+  });
+
+  it('should resolve immediately if buffer is closed and empty', async () => {
+    frameBuffer.close();
+
+    const result = await frameBuffer.dequeue();
+    expect(result).toBeUndefined();
+  });
+
+  it('should call onclose callback when buffer is closed', () => {
+    const mockOnClose = vi.fn();
+    frameBuffer.onclose = mockOnClose;
+
+    frameBuffer.close();
+
+    expect(frameBuffer['state']).toBe('closed');
+    expect(mockOnClose).toHaveBeenCalled();
+  });
+
+  it('should close all frames when terminate is called', () => {
+    const frame1 = { ...mockVideoFrame, close: vi.fn() };
+    const frame2 = { ...mockVideoFrame, close: vi.fn() };
+
+    frameBuffer.enqueue(frame1);
+    frameBuffer.enqueue(frame2);
+
+    frameBuffer.terminate();
+
+    expect(frame1.close).toHaveBeenCalled();
+    expect(frame2.close).toHaveBeenCalled();
+  });
+
+  it('should reject after timeout if no enqueue or close happens', async () => {
+    await expect((frameBuffer as any).waitFor(50)).rejects.toThrow('Promise timed out after 50 ms');
+  });
+});

src/clips/video/decoder.spec.ts

@@ -0,0 +1,99 @@
+/**
+ * Copyright (c) 2024 The Diffusion Studio Authors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla 
+ * Public License, v. 2.0 that can be found in the LICENSE file.
+ */
+
+import { describe, it, expect, vi, beforeEach, Mock } from 'vitest';
+import { Decoder } from './decoder';
+
+describe('Decoder', () => {
+  let mockPostMessage: Mock<any>
+  let mockVideoDecoder: Mock<any>
+  let mockVideoFrame: any;
+  let decoder: Decoder;
+
+  beforeEach(() => {
+    // Mock postMessage for 'self'
+    mockPostMessage = vi.fn();
+    (global as any).self = {
+      postMessage: mockPostMessage,
+      close: vi.fn(),
+    };
+
+    // Mock VideoDecoder
+    mockVideoDecoder = vi.fn().mockImplementation(({ output, error }) => {
+      return {
+        output,
+        error,
+        decode: vi.fn(),
+        close: vi.fn(),
+      };
+    });
+    (global as any).VideoDecoder = mockVideoDecoder;
+
+    // Mock VideoFrame
+    mockVideoFrame = {
+      timestamp: 0,
+      duration: 1000000, // 1 second in nanoseconds
+      close: vi.fn(),
+    };
+  });
+
+  it('should initialize with correct properties', () => {
+    const range = [0, 5] satisfies [number, number]; // 5 seconds range
+    const fps = 30;
+
+    decoder = new Decoder(range, fps);
+
+    expect(decoder.video).toBeDefined();
+    expect(mockVideoDecoder).toHaveBeenCalled();
+    expect(decoder['currentTime']).toBe(range[0] * 1e6);
+    expect(decoder['firstTimestamp']).toBe(range[0] * 1e6);
+    expect(decoder['totalFrames']).toBe(((range[1] - range[0]) * fps) + 1);
+    expect(decoder['fps']).toBe(fps);
+  });
+
+  it('should post a frame and update current time and count', () => {
+    const range = [0, 5] satisfies [number, number];
+    const fps = 30;
+
+    decoder = new Decoder(range, fps);
+
+    decoder['postFrame'](mockVideoFrame);
+
+    expect(mockPostMessage).toHaveBeenCalledWith({ type: 'frame', frame: mockVideoFrame });
+    expect(decoder['currentTime']).toBeGreaterThan(range[0] * 1e6); // Time should increase
+    expect(decoder['currentFrames']).toBe(1);
+  });
+
+  it('should handle frame output within range and post frames', () => {
+    const range = [0, 5] satisfies [number, number];
+    const fps = 30;
+
+    decoder = new Decoder(range, fps);
+    mockVideoFrame.timestamp = range[0] * 1e6; // Start time
+
+    decoder['handleFrameOutput'](mockVideoFrame);
+
+    expect(mockPostMessage).toHaveBeenCalledWith({ type: 'frame', frame: mockVideoFrame });
+    expect(mockVideoFrame.close).toHaveBeenCalled();
+  });
+
+  it('should handle errors and post error messages', () => {
+    const range = [0, 5] satisfies [number, number];
+    const fps = 30;
+    const mockError = new DOMException('Test Error');
+
+    decoder = new Decoder(range, fps);
+    
+    decoder['handleError'](mockError);
+
+    expect(mockPostMessage).toHaveBeenCalledWith({
+      type: 'error',
+      message: 'Test Error',
+    });
+    expect(self.close).toHaveBeenCalled();
+  });
+});

src/clips/video/video.spec.ts

@@ -11,6 +11,8 @@ import { Source, VideoSource } from '../../sources';
 import { VideoClip } from './video';
 import { Composition } from '../../composition';
 import { Keyframe, Timestamp } from '../../models';
+import { sleep } from '../../utils';
+import { FrameBuffer } from './buffer';
 
 import type { MockInstance } from 'vitest';
 
@@ -24,7 +26,7 @@ describe('The Video Clip', () => {
 
 	let playFn: MockInstance<() => Promise<void>>;
 	let pauseFn: MockInstance<() => Promise<void>>;
-	let seekFn: MockInstance<(time: Timestamp) => Promise<void>>;
+	let seekFn: MockInstance<(arg: number) => void>;
 
 	const createObjectUrlSpy = vi.spyOn(Source.prototype as any, 'createObjectURL');
 
@@ -95,8 +97,8 @@ describe('The Video Clip', () => {
 
 	it('should connect to a track', async () => {
 		clip
-			.set({ offset: 10, height: '100%' })
-			.subclip(10, 80);
+			.set({ offset: 6, height: '100%' })
+			.subclip(6, 80);
 
 		const composition = new Composition();
 		const track = composition.createTrack('video');
@@ -106,17 +108,18 @@ describe('The Video Clip', () => {
 		await track.add(clip);
 
 		expect(seekFn).toHaveBeenCalledTimes(1);
-		expect(seekFn.mock.calls[0][0].seconds).toBe(1);
+		// composition.frame - offset = 24; 24 / 30fps = 0.8
+		expect(seekFn.mock.calls[0][0]).toBe(0.8);
 
 		expect(clip.state).toBe('ATTACHED');
-		expect(clip.offset.frames).toBe(10);
+		expect(clip.offset.frames).toBe(6);
 		expect(clip.duration.seconds).toBe(30);
 		expect(clip.height).toBe('100%');
-		expect(clip.range[0].frames).toBe(10);
+		expect(clip.range[0].frames).toBe(6);
 		expect(clip.range[1].frames).toBe(80);
 
-		expect(clip.start.frames).toBe(20);
-		expect(clip.stop.frames).toBe(90);
+		expect(clip.start.frames).toBe(12);
+		expect(clip.stop.frames).toBe(86);
 
 		expect(track.clips.findIndex((n) => n.id == clip.id)).toBe(0);
 		expect(attachFn).toBeCalledTimes(1);
@@ -151,6 +154,7 @@ describe('The Video Clip', () => {
 		expect(updateSpy).toHaveBeenCalledTimes(1);
 		expect(exitSpy).toHaveBeenCalledTimes(0);
 
+		pauseFn.mockClear();
 		composition.state = 'IDLE';
 		composition.frame = 60;
 		composition.computeFrame();
@@ -255,6 +259,60 @@ describe('The Video Clip', () => {
 
 		expect(clip.sprite.texture.uid).toBe(clip.textrues.html5.uid);
 	});
+
+	it('should start decoding the video when the seek method is called and the composition is rendering', async () => {
+		const composition = new Composition();
+		await composition.add(clip);
+
+		const buffer = new FrameBuffer();
+
+		Object.defineProperty(buffer, 'onenqueue', {
+			set: (fn: () => void) => fn()
+		});
+
+		//@ts-ignore
+		const decodeSpy = vi.spyOn(clip, 'decodeVideo').mockReturnValueOnce(buffer);
+		composition.state = 'RENDER';
+
+		await clip.seek(new Timestamp());
+
+		expect(decodeSpy).toBeCalledTimes(1);
+		expect(seekFn.mock.calls[0][0]).toBe(0);
+	});
+
+	it('should calculate the correct demux range', async () => {
+		const composition = new Composition();
+		await composition.add(clip);
+
+		clip.subclip(6, 63);
+
+		let [start, stop] = (clip as any).demuxRange;
+		expect(start).toBe(0.2);
+		expect(stop).toBe(2.1);
+
+		clip.offsetBy(-12)
+
+		composition.duration = 30;
+
+		[start, stop] = (clip as any).demuxRange;
+		expect(start).toBe(0.4);
+		expect(stop).toBe(1.4);
+	});
+
+	it('should be able to cancel decoding', async () => {
+		const workerSpy = vi.fn();
+		const bufferSpy = vi.fn();
+
+		// @ts-ignore
+		clip.worker = { terminate: workerSpy };
+		// @ts-ignore
+		clip.buffer = { terminate: bufferSpy };
+
+		clip.cancelDecoding();
+
+		expect(workerSpy).toBeCalledTimes(1);
+		expect(bufferSpy).toBeCalledTimes(1);
+	});
 });
 
 // Blend of different test files
@@ -382,5 +440,9 @@ function mockDimensions(clip: VideoClip, width = 540, height = 680) {
 }
 
 function mockSeek(clip: VideoClip) {
-	return vi.spyOn(clip, 'seek').mockImplementation(async () => { });
+	return vi.spyOn(clip.element, 'currentTime', 'set')
+		.mockImplementation(async function (this: HTMLVideoElement) {
+			await sleep(1);
+			this.dispatchEvent(new Event('seeked'));
+		});
 }

src/sources/audio.ts

@@ -11,7 +11,7 @@ import type { ClipType } from '../clips';
 import type { ArgumentTypes } from '../types';
 
 export class AudioSource extends Source {
-	public readonly type: ClipType = 'base';
+	public readonly type: ClipType = 'audio';
 	public audioBuffer?: AudioBuffer;
 
 	public async decode(

src/sources/html.ts

@@ -11,7 +11,7 @@ import { documentToSvgImageUrl } from './html.utils';
 import type { ClipType } from '../clips';
 
 export class HtmlSource extends Source {
-	public readonly type: ClipType = 'base';
+	public readonly type: ClipType = 'html';
 	/**
 	 * Access to the iframe that is required
 	 * for extracting the html's dimensions