added encoder unit tests

Author: k9p5

src/encoders/canvas.spec.ts

@@ -0,0 +1,105 @@
+/**
+ * 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 { beforeEach, describe, expect, it, vi } from 'vitest';
+import { OpusEncoder } from './opus';
+import { CanvasEncoder } from './canvas';
+
+const buffer = {
+  sampleRate: 8000,
+  duration: 1,
+  numberOfChannels: 1,
+  length: 8000,
+  getChannelData: vi.fn(() => new Float32Array(8000)),
+} as unknown as AudioBuffer
+
+describe('The CanvasEncoder', () => {
+  const canvas = document.createElement('canvas');
+  canvas.height = 640;
+  canvas.width = 480;
+
+  let encoder: CanvasEncoder;
+
+  const configureSpy = vi.spyOn(VideoEncoder.prototype, 'configure').mockImplementation(vi.fn());
+  const encodeSpy = vi.spyOn(VideoEncoder.prototype, 'encode').mockImplementation(vi.fn());
+
+  beforeEach(() => {
+    encoder = new CanvasEncoder(canvas, {
+      fps: 60,
+      gpuBatchSize: 4,
+      numberOfChannels: 1,
+      sampleRate: 2000,
+      videoBitrate: 1e6,
+    });
+
+    expect(encoder.fps).toBe(60);
+    expect(encoder.height).toBe(640);
+    expect(encoder.width).toBe(480);
+    expect(encoder.sampleRate).toBe(8000);
+    expect(encoder.videoBitrate).toBe(1e6);
+
+    configureSpy.mockClear();
+    encodeSpy.mockClear();
+  });
+
+  it('should encode video', async () => {
+    expect(encoder.frame).toBe(0);
+    expect(configureSpy).toBeCalledTimes(0);
+
+    await encoder.encodeVideo();
+
+    expect(encoder.frame).toBe(1);
+    expect(configureSpy).toBeCalledTimes(1);
+    expect(encodeSpy).toBeCalledTimes(1);
+    expect(encodeSpy.mock.calls[0][1]?.keyFrame).toBe(true);
+
+    await encoder.encodeVideo();
+
+    expect(encoder.frame).toBe(2);
+    expect(configureSpy).toBeCalledTimes(1);
+    expect(encodeSpy).toBeCalledTimes(2);
+    expect(encodeSpy.mock.calls[1][1]?.keyFrame).toBe(false);
+  });
+
+  it('should encode audio', async () => {
+    encoder = new CanvasEncoder(canvas, {
+      numberOfChannels: 1,
+      sampleRate: 2000,
+      audio: true,
+    });
+
+    expect(encoder.sampleRate).toBe(8000)
+
+    const configureSpy = vi.spyOn(OpusEncoder.prototype, 'configure').mockImplementation(vi.fn());
+    const encodeSpy = vi.spyOn(OpusEncoder.prototype, 'encode').mockImplementation(vi.fn());
+
+    await encoder.encodeAudio(buffer);
+
+    expect(configureSpy).toBeCalledTimes(1);
+    expect(encodeSpy).toBeCalledTimes(1);
+
+    expect(configureSpy.mock.calls[0][0]).toStrictEqual({ numberOfChannels: 1, sampleRate: 8000 });
+    expect(encodeSpy.mock.calls[0][0].data.length).toBe(8000);
+    expect(encodeSpy.mock.calls[0][0].numberOfFrames).toBe(8000);
+  });
+
+  it("should not encode audio when it's not enabled", async () => {
+    await expect(encoder.encodeAudio(buffer)).rejects.toThrowError();
+  });
+
+  it('should create a blob', async () => {
+    await encoder.encodeVideo();
+
+    const blob = await encoder.blob();
+
+    expect(blob).toBeInstanceOf(Blob);
+  });
+
+  it('should not create a blob if the buffer is not defined', async () => {
+    await expect(() => encoder.blob()).rejects.toThrowError();
+  });
+});

src/encoders/encoder.spec.ts

@@ -0,0 +1,73 @@
+/**
+ * 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 { beforeEach, describe, expect, it, vi } from 'vitest';
+import { Composition } from '../composition';
+import { Encoder } from './encoder';
+import { Clip } from '../clips';
+
+
+describe('The Encoder', () => {
+  let composition: Composition;
+  let encoder: Encoder;
+
+  const configureSpy = vi.spyOn(VideoEncoder.prototype, 'configure').mockImplementation(vi.fn());
+  const encodeSpy = vi.spyOn(VideoEncoder.prototype, 'encode').mockImplementation(vi.fn());
+
+  beforeEach(() => {
+    composition = new Composition();
+
+    encoder = new Encoder(composition, {
+      audio: false,
+      debug: false,
+      fps: 60,
+      gpuBatchSize: 4,
+      numberOfChannels: 1,
+      resolution: 0.5,
+      sampleRate: 8000,
+      videoBitrate: 1e6,
+    });
+
+    configureSpy.mockClear();
+    encodeSpy.mockClear();
+
+    expect(encoder.audio).toBe(false);
+    expect(encoder.debug).toBe(false);
+    expect(encoder.fps).toBe(60);
+  });
+
+  it('should render the compostion', async () => {
+    await composition.add(new Clip({ stop: 10 }));
+
+    const pauseSpy = vi.spyOn(composition, 'pause').mockImplementation(async () => undefined);
+    const seekSpy = vi.spyOn(composition, 'seek').mockImplementation(async () => undefined);
+
+    await encoder.render();
+
+    expect(pauseSpy).toBeCalledTimes(1);
+    // before and after
+    expect(seekSpy).toBeCalledTimes(2);
+  });
+
+  it('should not render when the composition renderer is not defined', async () => {
+    delete composition.renderer;
+
+    await expect(() => encoder.render()).rejects.toThrowError();
+  });
+
+  it('should debug the render process', async () => {
+    encoder.debug = true;
+
+    await composition.add(new Clip({ stop: 10 }));
+
+    const logSpy = vi.spyOn(console, 'info');
+
+    await encoder.render();
+
+    expect(logSpy).toBeCalledTimes(3);
+  });
+});

src/encoders/encoder.ts

@@ -50,7 +50,7 @@ export class Encoder extends WebcodecsVideoEncoder {
 		const [videoConfig, audioConfig] = await this.getConfigs();
 
 		if (this.debug) {
-			console.log('Hardware Preference', videoConfig.hardwareAcceleration);
+			console.info('Hardware Preference', videoConfig.hardwareAcceleration);
 		}
 
 		const now = performance.now();

src/encoders/opus/opus.utils.spec.ts

@@ -0,0 +1,69 @@
+/**
+ * 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 } from 'vitest';
+import { createOpusHead } from './opus.utils';
+
+describe('createOpusHead', () => {
+  it('should generate a correct Opus header', () => {
+    const sampleRate = 48000;
+    const numberOfChannels = 2;
+    const result = createOpusHead(sampleRate, numberOfChannels);
+
+    // Check that the result is a Uint8Array of length 19
+    expect(result).toBeInstanceOf(Uint8Array);
+    expect(result.length).toBe(19);
+
+    // Check magic signature "OpusHead"
+    expect(result[0]).toBe('O'.charCodeAt(0));
+    expect(result[1]).toBe('p'.charCodeAt(0));
+    expect(result[2]).toBe('u'.charCodeAt(0));
+    expect(result[3]).toBe('s'.charCodeAt(0));
+    expect(result[4]).toBe('H'.charCodeAt(0));
+    expect(result[5]).toBe('e'.charCodeAt(0));
+    expect(result[6]).toBe('a'.charCodeAt(0));
+    expect(result[7]).toBe('d'.charCodeAt(0));
+
+    // Check version is set to 1
+    expect(result[8]).toBe(1);
+
+    // Check number of channels
+    expect(result[9]).toBe(numberOfChannels);
+
+    // Check pre-skip is 0 (bytes 10 and 11)
+    expect(result[10]).toBe(0);
+    expect(result[11]).toBe(0);
+
+    // Check sample rate is correctly encoded (bytes 12-15)
+    expect(result[12]).toBe(sampleRate & 0xFF);
+    expect(result[13]).toBe((sampleRate >> 8) & 0xFF);
+    expect(result[14]).toBe((sampleRate >> 16) & 0xFF);
+    expect(result[15]).toBe((sampleRate >> 24) & 0xFF);
+
+    // Check gain is 0 (bytes 16 and 17)
+    expect(result[16]).toBe(0);
+    expect(result[17]).toBe(0);
+
+    // Check channel mapping is 0
+    expect(result[18]).toBe(0);
+  });
+
+  it('should correctly encode a different sample rate and number of channels', () => {
+    const sampleRate = 44100;
+    const numberOfChannels = 1;
+    const result = createOpusHead(sampleRate, numberOfChannels);
+
+    // Check number of channels
+    expect(result[9]).toBe(numberOfChannels);
+
+    // Check sample rate is correctly encoded (bytes 12-15)
+    expect(result[12]).toBe(sampleRate & 0xFF);
+    expect(result[13]).toBe((sampleRate >> 8) & 0xFF);
+    expect(result[14]).toBe((sampleRate >> 16) & 0xFF);
+    expect(result[15]).toBe((sampleRate >> 24) & 0xFF);
+  });
+});

src/encoders/utils.spec.ts

@@ -0,0 +1,116 @@
+/**
+ * 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, expect, it, vi } from 'vitest';
+
+import { audioClipFilter, createRenderEventDetail, createStreamTarget, toOpusSampleRate, withError } from './utils';
+import { ArrayBufferTarget, FileSystemWritableFileStreamTarget } from 'mp4-muxer';
+import { Clip, MediaClip } from '../clips';
+
+
+describe('createStreamTarget', () => {
+  it('should create a downloadable stream target', async () => {
+    const res = await createStreamTarget('test.mp4');
+
+    expect(res.target).toBeInstanceOf(ArrayBufferTarget);
+    expect(res.fastStart).toBe('in-memory');
+
+    const a = document.createElement('a');
+
+    const clickSpy = vi.spyOn(a, 'click');
+    const createSpy = vi.spyOn(document, 'createElement').mockReturnValue(a);
+
+    await res.close(true);
+
+    expect(clickSpy).toBeCalledTimes(1);
+    expect(createSpy).toBeCalledTimes(1);
+    expect(a.download).toBe('test.mp4');
+  });
+
+  it('should upload the file if the target is an http address', async () => {
+    const res = await createStreamTarget('https://s3.com/test.mp4');
+
+    expect(res.target).toBeInstanceOf(ArrayBufferTarget);
+    expect(res.fastStart).toBe('in-memory');
+
+    const fetchSpy = vi.spyOn(global, 'fetch');
+
+    await res.close(true);
+
+    expect(fetchSpy).toBeCalledTimes(1);
+    expect(fetchSpy.mock.calls[0][0]).toBe('https://s3.com/test.mp4');
+    expect(fetchSpy.mock.calls[0][1]?.method).toBe('PUT');
+  });
+
+  it('should throw an error when using http upload and the response is not ok', async () => {
+    const res = await createStreamTarget('https://s3.com/test.mp4');
+
+    const fetchSpy = vi.spyOn(global, 'fetch').mockReturnValue({
+      ok: false,
+    } as any)
+
+    await expect(() => res.close(true)).rejects.toThrowError();
+
+    fetchSpy.mockRestore();
+  });
+
+  it('should handle the file system access', async () => {
+    const handle = new FileSystemFileHandle();
+    const res = await createStreamTarget(handle);
+
+    expect(res.target).toBeInstanceOf(FileSystemWritableFileStreamTarget);
+    expect(res.fastStart).toBe(false);
+
+    const closeSpy = vi.spyOn(FileSystemWritableFileStream.prototype, 'close');
+
+    await res.close(true);
+
+    expect(closeSpy).toBeCalledTimes(1);
+  });
+});
+
+describe('withError', () => {
+  it('should reject promise all errors', async () => {
+    const promise1 = Promise.resolve(3);
+    const promise2 = new Promise((_, reject) =>
+      setTimeout(reject, 100, 'foo'),
+    );
+
+    const promise = withError(Promise.allSettled([promise1, promise2]));
+
+    await expect(promise).rejects.toThrowError();
+  })
+});
+
+describe('createRenderEventDetail', () => {
+  it('should should calculate the remaining time', async () => {
+    const date = new Date();
+    date.setSeconds(date.getSeconds() - 10);
+    const detail = createRenderEventDetail(50, 100, date.getTime());
+    expect(detail.progress).toBe(50);
+    expect(detail.total).toBe(100);
+    // it took 10 secs for 50% there should be 10 seconds remaining
+    expect(detail.remaining.getSeconds()).toBe(10);
+  });
+});
+
+describe('audioClipFilter', () => {
+  it('should filter clips', async () => {
+    const clips = [new Clip(), new Clip(), new MediaClip({ disabled: true }), new MediaClip()];
+
+    expect(clips.filter(audioClipFilter).length).toBe(1);
+  });
+});
+
+describe('toOpusSampleRate', () => {
+  it('should find the closes available opus sample rate', async () => {
+    expect(toOpusSampleRate(0)).toBe(8000);
+    expect(toOpusSampleRate(10000)).toBe(8000);
+    expect(toOpusSampleRate(10001)).toBe(12000);
+    expect(toOpusSampleRate(50000)).toBe(48000);
+  });
+});