Merge pull request #33 from diffusionstudio/konstantin/fix/split-stacked-mode

k9p5 · web-flow · commit 7349986cd917 · 2024-10-29T11:41:24.000-07:00
Konstantin/fix/split stacked mode
diff --git a/package.json b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@diffusionstudio/core",
   "private": false,
-  "version": "1.1.0",
+  "version": "1.1.1",
   "type": "module",
   "description": "Build bleeding edge video processing applications",
   "files": [
diff --git a/src/clips/audio/audio.spec.ts b/src/clips/audio/audio.spec.ts
@@ -6,9 +6,10 @@
  */
 
 import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { captions } from '../../test/captions';
 import { Composition } from '../../composition';
 import { AudioClip } from './audio';
-import { Timestamp } from '../../models';
+import { Timestamp, Transcript } from '../../models';
 import { AudioSource } from '../../sources';
 
 import type { MockInstance } from 'vitest';
@@ -197,6 +198,7 @@ describe('Copying the AudioClip', () => {
 		clip.duration.frames = 100;
 		clip.muted = true;
 		clip.volume = 0.2;
+		clip.transcript = Transcript.fromJSON(captions);
 
 		const copy = clip.copy();
 
@@ -208,6 +210,7 @@ describe('Copying the AudioClip', () => {
 		expect(copy.muted).toBe(true);
 		expect(copy.source).toBeInstanceOf(AudioSource);
 		expect(copy.source.id).toBe(clip.source.id);
+		expect(copy.transcript?.id).toBe(clip.transcript.id);
 	});
 
 	it('should transfer base properties', () => {
diff --git a/src/clips/audio/audio.ts b/src/clips/audio/audio.ts
@@ -86,6 +86,7 @@ export class AudioClip extends MediaClip<AudioClipProps> {
 
 	public copy(): AudioClip {
 		const clip = AudioClip.fromJSON(JSON.parse(JSON.stringify(this)));
+		clip.transcript = this.transcript;
 		clip.source = this.source;
 
 		return clip;
diff --git a/src/clips/clip/clip.ts b/src/clips/clip/clip.ts
@@ -230,7 +230,8 @@ export class Clip<Props extends ClipProps = ClipProps> extends EventEmitterMixin
 
 		replaceKeyframes(copy, copy.start.subtract(this.start));
 
-		await this.track.add(copy);
+		const index = this.track.clips.findIndex((c) => c.id == this.id);
+		await this.track.add(copy, index + 1);
 
 		return copy;
 	}
diff --git a/src/clips/media/media.spec.ts b/src/clips/media/media.spec.ts
@@ -285,6 +285,7 @@ describe('The Media Clip', () => {
 		expect(copy.range[0].frames).toBe(10);
 		expect(copy.range[1]).toBeInstanceOf(Timestamp);
 		expect(copy.range[1].frames).toBe(80);
+		expect(copy.transcript?.id).toBe(clip.transcript.id);
 	});
 
 	it('should generate a caption track using a transcript', async () => {
@@ -295,7 +296,7 @@ describe('The Media Clip', () => {
 		const composition = new Composition();
 		await composition.add(clip);
 
-		const track = await clip.generateCaptions();
+		const track = await clip.addCaptions();
 
 		expect(composition.tracks.length).toBe(2);
 
@@ -420,6 +421,48 @@ describe('Split tests - the Media Clip object', () => {
 		await expect(() => clip.split()).rejects.toThrowError();
 	});
 
+	it('should split the clip in place when the track is set to stacked', async () => {
+		const clip1 = new MediaClip({
+			offset: new Timestamp(1000),
+			name: 'foo',
+		});
+
+		const clip2 = new MediaClip({
+			offset: new Timestamp(500),
+			name: 'bar',
+		});
+
+		clip1.duration.millis = 3000;
+		clip2.duration.millis = 2000;
+
+		const track = new MediaTrack().stacked();
+
+		await track.add(clip1);
+		await track.add(clip2);
+
+		expect(track.clips.length).toBe(2);
+
+		expect(track.clips[0].name).toBe('foo');
+		expect(track.clips[0].start.millis).toBe(0);
+		expect(track.clips[0].stop.millis).toBe(3000);
+
+		expect(track.clips[1].name).toBe('bar');
+		expect(track.clips[1].start.millis).toBe(3001);
+		expect(track.clips[1].stop.millis).toBe(5001);
+
+		await clip1.split(new Timestamp(2000));
+
+		expect(track.clips.length).toBe(3);
+		expect(track.clips[0].start.millis).toBe(0);
+		expect(track.clips[0].stop.millis).toBe(2000);
+
+		expect(track.clips[1].start.millis).toBe(2001);
+		expect(track.clips[1].stop.millis).toBe(3000);
+
+		expect(track.clips[2].start.millis).toBe(3001);
+		expect(track.clips[2].stop.millis).toBe(5001);
+	});
+
 	it('should not split the clip when no track is provided', async () => {
 		const clip = new MediaClip({
 			offset: new Timestamp(1000),
diff --git a/src/clips/media/media.ts b/src/clips/media/media.ts
@@ -233,7 +233,9 @@ export class MediaClip<Props extends MediaClipProps = MediaClipProps> extends Cl
 	}
 
 	public copy(): MediaClip {
-		return MediaClip.fromJSON(JSON.parse(JSON.stringify(this)));
+		const clip = MediaClip.fromJSON(JSON.parse(JSON.stringify(this)));
+		clip.transcript = this.transcript;
+		return clip;
 	}
 
 	public async split(time?: frame | Timestamp): Promise<this> {
@@ -267,7 +269,8 @@ export class MediaClip<Props extends MediaClipProps = MediaClipProps> extends Cl
 
 		replaceKeyframes(copy, copy.start.subtract(this.start));
 
-		await this.track.add(copy);
+		const index = this.track.clips.findIndex((c) => c.id == this.id);
+		await this.track.add(copy, index + 1);
 
 		return copy;
 	}
diff --git a/src/clips/video/video.spec.ts b/src/clips/video/video.spec.ts
@@ -10,11 +10,12 @@ import { BlurFilter } from 'pixi.js';
 import { Source, VideoSource } from '../../sources';
 import { VideoClip } from './video';
 import { Composition } from '../../composition';
-import { Keyframe, Timestamp } from '../../models';
+import { Keyframe, Timestamp, Transcript } from '../../models';
 import { sleep } from '../../utils';
 import { FrameBuffer } from './buffer';
 
 import type { MockInstance } from 'vitest';
+import { captions } from '../../test/captions';
 
 
 const file = new File([], 'video.mp4', { type: 'video/mp4' });
@@ -346,6 +347,7 @@ describe('Copying the VidoClip', () => {
 		clip.duration.frames = 100;
 		clip.muted = true;
 		clip.volume = 0.2;
+		clip.transcript = Transcript.fromJSON(captions);
 
 		const copy = clip.copy();
 
@@ -358,6 +360,7 @@ describe('Copying the VidoClip', () => {
 		expect(copy.muted).toBe(true);
 		expect(copy.source).toBeInstanceOf(VideoSource);
 		expect(copy.source.id).toBe(clip.source.id);
+		expect(copy.transcript?.id).toBe(clip.transcript.id);
 	});
 
 	it('should transfer visual properties', async () => {
diff --git a/src/clips/video/video.ts b/src/clips/video/video.ts
@@ -142,6 +142,7 @@ export class VideoClip extends VisualMixin(MediaClip<VideoClipProps>) {
 		const clip = VideoClip.fromJSON(JSON.parse(JSON.stringify(this)));
 		clip.filters = this.filters;
 		clip.source = this.source;
+		clip.transcript = this.transcript;
 
 		return clip;
 	}
diff --git a/src/tracks/track/track.interfaces.ts b/src/tracks/track/track.interfaces.ts
@@ -12,7 +12,7 @@ import type { Timestamp } from '../../models';
 
 export interface InsertStrategy<T extends InsertMode> {
 	readonly mode: T;
-	add(clip: Clip, track: Track<Clip>): void;
+	add(clip: Clip, track: Track<Clip>, index?: number): void;
 	update(clip: Clip, track: Track<Clip>): void;
 	offset(time: Timestamp, track: Track<Clip>): void;
 }
diff --git a/src/tracks/track/track.spec.ts b/src/tracks/track/track.spec.ts
@@ -57,6 +57,45 @@ describe('The Track Object', () => {
 		expect(track.clips.at(2)?.stop.frames).toBe(12);
 	});
 
+	it('should be able to add clips at an index, if stacked', async () => {
+		track.stacked();
+
+		await track.add(new Clip({ stop: 10, start: 0 }));
+		await track.add(new Clip({ stop: 10, start: 0 }));
+		await track.add(new Clip({ stop: 10, start: 0 }));
+
+		expect(track.clips.length).toBe(3);
+		expect(track.start.frames).toBe(0);
+		expect(track.stop.frames).toBe(30);
+
+		await track.add(new Clip({ stop: 2, start: 0 }), 1);
+
+		expect(track.clips[0].start.frames).toBe(0);
+		expect(track.clips[0].stop.frames).toBe(10);
+
+		expect(track.clips[1].start.frames).toBe(10);
+		expect(track.clips[1].stop.frames).toBe(12);
+
+		expect(track.clips[2].start.frames).toBe(12);
+		expect(track.clips[2].stop.frames).toBe(22);
+
+		await track.add(new Clip({ stop: 15, start: 10 }), 4);
+
+		expect(track.clips[0].start.frames).toBe(0);
+		expect(track.clips[0].stop.frames).toBe(10);
+		
+		expect(track.clips[4].start.frames).toBe(32);
+		expect(track.clips[4].stop.frames).toBe(37);
+
+		await track.clips[0].split(5);
+
+		expect(track.clips[0].start.frames).toBe(0);
+		expect(track.clips[0].stop.frames).toBe(5);
+
+		expect(track.clips[1].start.frames).toBe(5);
+		expect(track.clips[1].stop.frames).toBe(10);
+	});
+
 	it('should snap the clip when it overlaps with the end of another clip', async () => {
 		const clip0 = new Clip({ stop: 20, start: 0 });
 		const clip1 = new Clip({ stop: 30, start: 11 });
diff --git a/src/tracks/track/track.strategies.spec.ts b/src/tracks/track/track.strategies.spec.ts
@@ -244,6 +244,23 @@ describe('The Track Strategy Object (stack mode)', () => {
 		expect(track.clips[2].start.frames).toBe(30);
 		expect(track.clips[2].stop.frames).toBe(39);
 	});
+
+	it('should insert clips a specified index', () => {
+		const track = createDefaultTrack();
+		track.stacked();
+
+		expect(track.clips[0].stop.frames).toBe(10);
+		expect(track.clips[1].stop.frames).toBe(30);
+		expect(track.clips[2].stop.frames).toBe(39);
+
+		strategy.add(new Clip({ start: 20, stop: 25 }), track, 1);
+
+		expect(track.clips[0].stop.frames).toBe(10);
+		expect(track.clips[1].start.frames).toBe(10);
+		expect(track.clips[1].stop.frames).toBe(15);
+		expect(track.clips[2].start.frames).toBe(15);
+		expect(track.clips[2].stop.frames).toBe(35);
+	});
 });
 
 function createDefaultTrack(): Track<Clip> {
diff --git a/src/tracks/track/track.strategies.ts b/src/tracks/track/track.strategies.ts
@@ -62,13 +62,21 @@ export class DefaultInsertStrategy implements InsertStrategy<'DEFAULT'> {
 export class StackInsertStrategy implements InsertStrategy<'STACK'> {
 	public mode = insertModes[1];
 
-	public add(clip: Clip, track: Track<Clip>): void {
+	public add(clip: Clip, track: Track<Clip>, index: number = 0): void {
 		// fallback is -1 because one frame will be added
-		const stop = track.clips.at(-1)?.stop.millis ?? -1;
+		const stop = track.clips.at(index - 1)?.stop.millis ?? -1;
 		const offset = stop - clip.start.millis + 1;
 
 		clip.offsetBy(new Timestamp(offset));
-		track.clips.push(clip);
+
+		if (index == 0) {
+			track.clips.push(clip);
+		} else {
+			track.clips.splice(index, 0, clip);
+			track.clips.slice(index + 1).forEach((c) => {
+				c.offsetBy(clip.stop.subtract(clip.start));
+			});
+		}
 	}
 
 	public update(_: Clip, track: Track<Clip>): void {
diff --git a/src/tracks/track/track.ts b/src/tracks/track/track.ts
@@ -190,17 +190,19 @@ export class Track<Clp extends Clip> extends EventEmitterMixin<Events, typeof Se
 
 	/**
 	 * Adds a new clip to the track
+	 * @param clip The clip to add
+	 * @param index The index to insert the clip at, will be ignored if track is not stacked
 	 * @throws Error if the clip can't be added
 	 */
-	public async add(clip: Clp): Promise<Clp> {
+	public async add(clip: Clp, index?: number): Promise<Clp> {
 		// only append clip if composition is initialized
 		if (this.composition && !this.composition.renderer) {
 			await new Promise(this.composition.resolve('init'));
 		}
 
 		await clip.init();
 		await clip.connect(this);
-		await this.strategy.add(clip, this);
+		await this.strategy.add(clip, this, index);
 
 		clip.on('frame', () => {
 			this.strategy.update(clip, this);

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "@diffusionstudio/core",`
`3`	`3`	`"private": false,`
`4`		`- "version": "1.1.0",`
	`4`	`+ "version": "1.1.1",`
`5`	`5`	`"type": "module",`
`6`	`6`	`"description": "Build bleeding edge video processing applications",`
`7`	`7`	`"files": [`
Original file line number	Diff line number	Diff line change
`@@ -230,7 +230,8 @@ export class Clip<Props extends ClipProps = ClipProps> extends EventEmitterMixin`
`230`	`230`
`231`	`231`	`replaceKeyframes(copy, copy.start.subtract(this.start));`
`232`	`232`
`233`		`- await this.track.add(copy);`
	`233`	`+ const index = this.track.clips.findIndex((c) => c.id == this.id);`
	`234`	`+ await this.track.add(copy, index + 1);`
`234`	`235`
`235`	`236`	`return copy;`
`236`	`237`	`}`
Original file line number	Diff line number	Diff line change
`@@ -233,7 +233,9 @@ export class MediaClip<Props extends MediaClipProps = MediaClipProps> extends Cl`
`233`	`233`	`}`
`234`	`234`
`235`	`235`	`public copy(): MediaClip {`
`236`		`- return MediaClip.fromJSON(JSON.parse(JSON.stringify(this)));`
	`236`	`+ const clip = MediaClip.fromJSON(JSON.parse(JSON.stringify(this)));`
	`237`	`+ clip.transcript = this.transcript;`
	`238`	`+ return clip;`
`237`	`239`	`}`
`238`	`240`
`239`	`241`	`public async split(time?: frame \| Timestamp): Promise<this> {`
`@@ -267,7 +269,8 @@ export class MediaClip<Props extends MediaClipProps = MediaClipProps> extends Cl`
`267`	`269`
`268`	`270`	`replaceKeyframes(copy, copy.start.subtract(this.start));`
`269`	`271`
`270`		`- await this.track.add(copy);`
	`272`	`+ const index = this.track.clips.findIndex((c) => c.id == this.id);`
	`273`	`+ await this.track.add(copy, index + 1);`
`271`	`274`
`272`	`275`	`return copy;`
`273`	`276`	`}`
Original file line number	Diff line number	Diff line change
`@@ -142,6 +142,7 @@ export class VideoClip extends VisualMixin(MediaClip<VideoClipProps>) {`
`142`	`142`	`const clip = VideoClip.fromJSON(JSON.parse(JSON.stringify(this)));`
`143`	`143`	`clip.filters = this.filters;`
`144`	`144`	`clip.source = this.source;`
	`145`	`+ clip.transcript = this.transcript;`
`145`	`146`
`146`	`147`	`return clip;`
`147`	`148`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ import type { Timestamp } from '../../models';`
`12`	`12`
`13`	`13`	`export interface InsertStrategy<T extends InsertMode> {`
`14`	`14`	`readonly mode: T;`
`15`		`- add(clip: Clip, track: Track<Clip>): void;`
	`15`	`+ add(clip: Clip, track: Track<Clip>, index?: number): void;`
`16`	`16`	`update(clip: Clip, track: Track<Clip>): void;`
`17`	`17`	`offset(time: Timestamp, track: Track<Clip>): void;`
`18`	`18`	`}`