Implement sequencer instance for worklet

Author: jet2jet

src/main/AudioWorkletNodeSynthesizer.ts

@@ -1,7 +1,10 @@
 
 import { SynthesizerDefaultValues, InterpolationValues } from './Constants';
+import ISequencer from './ISequencer';
 import ISynthesizer from './ISynthesizer';
 
+import WorkletSequencer from './WorkletSequencer';
+
 import * as MethodMessaging from './MethodMessaging';
 
 /** @internal */
@@ -213,4 +216,19 @@ export default class AudioWorkletNodeSynthesizer implements ISynthesizer {
 	public waitForPlayerStopped() {
 		return MethodMessaging.postCallWithPromise<void>(this._messaging!, 'waitForPlayerStopped', []);
 	}
+
+	/**
+	 * Creates a sequencer instance associated with this worklet node.
+	 */
+	public createSequencer(): Promise<ISequencer> {
+		const channel = new MessageChannel();
+		return MethodMessaging.postCallWithPromise<void>(this._messaging!, 'createSequencer', [channel.port2]).then(() => {
+			return new WorkletSequencer(channel.port1);
+		});
+	}
+
+	/** @internal */
+	public _getRawSynthesizer(): Promise<number> {
+		return MethodMessaging.postCallWithPromise<number>(this._messaging!, 'getRawSynthesizer', []);
+	}
 }

src/main/MethodMessaging.ts

@@ -109,20 +109,30 @@ export interface ReturnMessageInstance {
 /** @internal */
 export function initializeReturnPort(
 	port: MessagePort,
-	promiseInitialized: Promise<void>,
+	promiseInitialized: Promise<void> | null,
 	targetObjectHolder: () => any,
 	hookMessage?: HookCallMessageCallback | undefined
 ): ReturnMessageInstance {
 	const instance: ReturnMessageInstance = {
 		port: port
 	};
-	port.addEventListener('message', (e) => {
-		const data = e.data;
-		if (!data) {
-			return;
-		}
-		promiseInitialized.then(() => processCallMessage(instance.port, data, targetObjectHolder, hookMessage));
-	});
+	if (promiseInitialized) {
+		port.addEventListener('message', (e) => {
+			const data = e.data;
+			if (!data) {
+				return;
+			}
+			promiseInitialized.then(() => processCallMessage(instance.port, data, targetObjectHolder, hookMessage));
+		});
+	} else {
+		port.addEventListener('message', (e) => {
+			const data = e.data;
+			if (!data) {
+				return;
+			}
+			processCallMessage(instance.port, data, targetObjectHolder, hookMessage);
+		});
+	}
 	port.start();
 	return instance;
 }

src/main/WorkletSequencer.ts

@@ -0,0 +1,43 @@
+
+import ISequencer from './ISequencer';
+import ISynthesizer from './ISynthesizer';
+import SequencerEvent from './SequencerEvent';
+
+import AudioWorkletNodeSynthesizer from './AudioWorkletNodeSynthesizer';
+
+import * as MethodMessaging from './MethodMessaging';
+
+/** @internal */
+export default class WorkletSequencer implements ISequencer {
+	/** @internal */
+	private _messaging: MethodMessaging.CallMessageInstance | null;
+
+	constructor(port: MessagePort) {
+		this._messaging = MethodMessaging.initializeCallPort(port);
+	}
+
+	public close(): void {
+		MethodMessaging.postCall(this._messaging!, 'close', []);
+	}
+	public registerSynthesizer(synth: ISynthesizer | number): Promise<void> {
+		let val: Promise<number>;
+		if (synth instanceof AudioWorkletNodeSynthesizer) {
+			val = synth._getRawSynthesizer();
+		} else {
+			return Promise.reject(new TypeError('\'synth\' is not a compatible type instance'));
+		}
+		return val.then((v) => MethodMessaging.postCallWithPromise<void>(this._messaging!, 'registerSynthesizer', [v]));
+	}
+	public setTimeScale(scale: number): void {
+		MethodMessaging.postCall(this._messaging!, 'setTimeScale', [scale]);
+	}
+	public getTimeScale(): Promise<number> {
+		return MethodMessaging.postCallWithPromise<number>(this._messaging!, 'getTimeScale', []);
+	}
+	public getTick(): Promise<number> {
+		return MethodMessaging.postCallWithPromise<number>(this._messaging!, 'getTick', []);
+	}
+	public sendEventAt(event: SequencerEvent, tick: number, isAbsolute: boolean): void {
+		MethodMessaging.postCall(this._messaging!, 'sendEventAt', [event, tick, isAbsolute]);
+	}
+}

src/main/registerAudioWorkletProcessor.ts

@@ -45,6 +45,11 @@ export default function registerAudioWorkletProcessor() {
 				if (data.method === 'init') {
 					this.synth!.init(sampleRate);
 					return true;
+				} else if (data.method === 'createSequencer') {
+					this.doCreateSequencer(data.args[0]).then(() => {
+						postReturn(this._messaging!, data.id, data.method, void (0));
+					});
+					return true;
 				}
 				return false;
 			});
@@ -56,6 +61,12 @@ export default function registerAudioWorkletProcessor() {
 			this.synth.init(sampleRate);
 		}
 
+		private doCreateSequencer(port: MessagePort): Promise<void> {
+			return Synthesizer.createSequencer().then((seq) => {
+				initializeReturnPort(port, null, () => seq);
+			});
+		}
+
 		public process(_inputs: Float32Array[][], outputs: Float32Array[][]) {
 			if (!this.synth) {
 				return true;