@opendaw/studio-core 0.0.86 → 0.0.88

package/dist/AudioOfflineRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AudioOfflineRenderer.d.ts","sourceRoot":"","sources":["../src/AudioOfflineRenderer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,GAAG,EAAa,MAAM,EAAS,QAAQ,EAAuB,MAAM,kBAAkB,CAAA;AAGtG,OAAO,EAAC,wBAAwB,EAAC,MAAM,0BAA0B,CAAA;AACjE,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAGjC,yBAAiB,oBAAoB,CAAC;IAC3B,MAAM,KAAK,GAAU,QAAQ,OAAO,EACf,wBAAwB,MAAM,CAAC,wBAAwB,CAAC,EACxD,UAAU,QAAQ,CAAC,OAAO,EAC1B,cAAc,WAAW,EACzB,aAAY,GAAY,KAAG,OAAO,CAAC,WAAW,CA+CzE,CAAA;CACJ"}
+{"version":3,"file":"AudioOfflineRenderer.d.ts","sourceRoot":"","sources":["../src/AudioOfflineRenderer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,GAAG,EAAa,MAAM,EAAS,QAAQ,EAAuB,MAAM,kBAAkB,CAAA;AAGtG,OAAO,EAAC,wBAAwB,EAAC,MAAM,0BAA0B,CAAA;AACjE,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAGjC,yBAAiB,oBAAoB,CAAC;IAE3B,MAAM,KAAK,GAAU,QAAQ,OAAO,EACf,wBAAwB,MAAM,CAAC,wBAAwB,CAAC,EACxD,UAAU,QAAQ,CAAC,OAAO,EAC1B,cAAc,WAAW,EACzB,aAAY,GAAY,KAAG,OAAO,CAAC,WAAW,CA+CzE,CAAA;CACJ"}

package/dist/AudioOfflineRenderer.js

@@ -5,6 +5,7 @@ import { ExportStemsConfiguration } from "@opendaw/studio-adapters";
 import { AudioWorklets } from "./AudioWorklets";
 export var AudioOfflineRenderer;
 (function (AudioOfflineRenderer) {
+    /* Deprecated */
     AudioOfflineRenderer.start = async (source, optExportConfiguration, progress, abortSignal, sampleRate = 48_000) => {
         const numStems = ExportStemsConfiguration.countStems(optExportConfiguration);
         if (numStems === 0) {

package/dist/AudioWorklets.d.ts

@@ -1,12 +1,13 @@
 import { int } from "@opendaw/lib-std";
 import { ExportStemsConfiguration, ProcessorOptions } from "@opendaw/studio-adapters";
-import { Project } from "./project/Project";
+import { Project } from "./project";
 import { EngineWorklet } from "./EngineWorklet";
 import { MeterWorklet } from "./MeterWorklet";
 import { RecordingWorklet } from "./RecordingWorklet";
 export declare class AudioWorklets {
     #private;
     static install(url: string): void;
+    static get processorsUrl(): string;
     static createFor(context: BaseAudioContext): Promise<AudioWorklets>;
     static get(context: BaseAudioContext): AudioWorklets;
     constructor(context: BaseAudioContext);
@@ -17,6 +18,6 @@ export declare class AudioWorklets {
         exportConfiguration?: ExportStemsConfiguration;
         options?: ProcessorOptions;
     }): EngineWorklet;
-    createRecording(numberOfChannels: int, numChunks: int, outputLatency: number): RecordingWorklet;
+    createRecording(numberOfChannels: int, numChunks: int): RecordingWorklet;
 }
 //# sourceMappingURL=AudioWorklets.d.ts.map

package/dist/AudioWorklets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AudioWorklets.d.ts","sourceRoot":"","sources":["../src/AudioWorklets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,GAAG,EAAS,MAAM,kBAAkB,CAAA;AACvD,OAAO,EAAC,wBAAwB,EAAE,gBAAgB,EAAa,MAAM,0BAA0B,CAAA;AAC/F,OAAO,EAAC,OAAO,EAAC,MAAM,mBAAmB,CAAA;AACzC,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAA;AAC7C,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAA;AAC3C,OAAO,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAA;AAGnD,qBAAa,aAAa;;IACtB,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;WAOpB,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,aAAa,CAAC;IAQzE,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,gBAAgB,GAAG,aAAa;gBAMxC,OAAO,EAAE,gBAAgB;IAErC,IAAI,OAAO,IAAI,gBAAgB,CAAuB;IAEtD,WAAW,CAAC,gBAAgB,EAAE,GAAG,GAAG,YAAY;IAIhD,YAAY,CAAC,EAAC,OAAO,EAAE,mBAAmB,EAAE,OAAO,EAAC,EAAE;QAClD,OAAO,EAAE,OAAO,CAAC;QACjB,mBAAmB,CAAC,EAAE,wBAAwB,CAAC;QAC/C,OAAO,CAAC,EAAE,gBAAgB,CAAA;KAC7B,GAAG,aAAa;IAIjB,eAAe,CAAC,gBAAgB,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,aAAa,EAAE,MAAM,GAAG,gBAAgB;CAOlG"}
+{"version":3,"file":"AudioWorklets.d.ts","sourceRoot":"","sources":["../src/AudioWorklets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,GAAG,EAAS,MAAM,kBAAkB,CAAA;AACvD,OAAO,EAAC,wBAAwB,EAAE,gBAAgB,EAAa,MAAM,0BAA0B,CAAA;AAC/F,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AACjC,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAA;AAC7C,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAA;AAC3C,OAAO,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAA;AAGnD,qBAAa,aAAa;;IACtB,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAKjC,MAAM,KAAK,aAAa,IAAI,MAAM,CAEjC;WAIY,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,aAAa,CAAC;IAQzE,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,gBAAgB,GAAG,aAAa;gBAMxC,OAAO,EAAE,gBAAgB;IAErC,IAAI,OAAO,IAAI,gBAAgB,CAAuB;IAEtD,WAAW,CAAC,gBAAgB,EAAE,GAAG,GAAG,YAAY;IAIhD,YAAY,CAAC,EAAC,OAAO,EAAE,mBAAmB,EAAE,OAAO,EAAC,EAAE;QAClD,OAAO,EAAE,OAAO,CAAC;QACjB,mBAAmB,CAAC,EAAE,wBAAwB,CAAC;QAC/C,OAAO,CAAC,EAAE,gBAAgB,CAAA;KAC7B,GAAG,aAAa;IAIjB,eAAe,CAAC,gBAAgB,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,GAAG,gBAAgB;CAO3E"}

package/dist/AudioWorklets.js

@@ -8,6 +8,9 @@ export class AudioWorklets {
         console.debug(`WorkletUrl: '${url}'`);
         this.#workletUrl = Option.wrap(url);
     }
+    static get processorsUrl() {
+        return this.#workletUrl.unwrap("WorkletUrl is missing (call 'install' first)");
+    }
     static #workletUrl = Option.None;
     static async createFor(context) {
         return context.audioWorklet.addModule(this.#workletUrl.unwrap("WorkletUrl is missing (call 'install' first)")).then(() => {
@@ -27,11 +30,11 @@ export class AudioWorklets {
     createEngine({ project, exportConfiguration, options }) {
         return new EngineWorklet(this.#context, project, exportConfiguration, options);
     }
-    createRecording(numberOfChannels, numChunks, outputLatency) {
+    createRecording(numberOfChannels, numChunks) {
         const audioBytes = numberOfChannels * numChunks * RenderQuantum * Float32Array.BYTES_PER_ELEMENT;
         const pointerBytes = Int32Array.BYTES_PER_ELEMENT * 2;
         const sab = new SharedArrayBuffer(audioBytes + pointerBytes);
         const buffer = { sab, numChunks, numberOfChannels, bufferSize: RenderQuantum };
-        return new RecordingWorklet(this.#context, buffer, outputLatency);
+        return new RecordingWorklet(this.#context, buffer);
     }
 }

package/dist/OfflineEngineRenderer.d.ts

@@ -0,0 +1,10 @@
+import { int, Option, Progress } from "@opendaw/lib-std";
+import { AudioData } from "@opendaw/lib-dsp";
+import { ExportStemsConfiguration } from "@opendaw/studio-adapters";
+import { Project } from "./project";
+export declare namespace OfflineEngineRenderer {
+    const install: (url: string) => void;
+    const getWorkerUrl: () => string;
+    const start: (source: Project, optExportConfiguration: Option<ExportStemsConfiguration>, progress: Progress.Handler, abortSignal?: AbortSignal, sampleRate?: int) => Promise<AudioData>;
+}
+//# sourceMappingURL=OfflineEngineRenderer.d.ts.map

package/dist/OfflineEngineRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OfflineEngineRenderer.d.ts","sourceRoot":"","sources":["../src/OfflineEngineRenderer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,GAAG,EAAa,MAAM,EAAS,QAAQ,EAAmB,MAAM,kBAAkB,CAAA;AAClG,OAAO,EAAC,SAAS,EAAO,MAAM,kBAAkB,CAAA;AAEhD,OAAO,EAGH,wBAAwB,EAK3B,MAAM,0BAA0B,CAAA;AACjC,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAIjC,yBAAiB,qBAAqB,CAAC;IAG5B,MAAM,OAAO,GAAI,KAAK,MAAM,KAAG,IAGrC,CAAA;IAEM,MAAM,YAAY,QAAO,MAE/B,CAAA;IAEM,MAAM,KAAK,GAAU,QAAQ,OAAO,EACf,wBAAwB,MAAM,CAAC,wBAAwB,CAAC,EACxD,UAAU,QAAQ,CAAC,OAAO,EAC1B,cAAc,WAAW,EACzB,aAAY,GAAY,KAAG,OAAO,CAAC,SAAS,CAuIvE,CAAA;CACJ"}

package/dist/OfflineEngineRenderer.js

@@ -0,0 +1,141 @@
+import { Errors, isDefined, Option, panic, Terminator } from "@opendaw/lib-std";
+import { AudioData } from "@opendaw/lib-dsp";
+import { Communicator, Messenger } from "@opendaw/lib-runtime";
+import { ExportStemsConfiguration } from "@opendaw/studio-adapters";
+import { AudioWorklets } from "./AudioWorklets";
+export var OfflineEngineRenderer;
+(function (OfflineEngineRenderer) {
+    let workerUrl = Option.None;
+    OfflineEngineRenderer.install = (url) => {
+        console.debug(`OfflineEngineWorkerUrl: '${url}'`);
+        workerUrl = Option.wrap(url);
+    };
+    OfflineEngineRenderer.getWorkerUrl = () => {
+        return workerUrl.unwrap("OfflineEngineWorkerUrl is missing (call 'install' first)");
+    };
+    OfflineEngineRenderer.start = async (source, optExportConfiguration, progress, abortSignal, sampleRate = 48_000) => {
+        const numStems = ExportStemsConfiguration.countStems(optExportConfiguration);
+        if (numStems === 0) {
+            return panic("Nothing to export");
+        }
+        const numberOfChannels = numStems * 2;
+        const { promise, reject, resolve } = Promise.withResolvers();
+        const worker = new Worker(OfflineEngineRenderer.getWorkerUrl(), { type: "module" });
+        const messenger = Messenger.for(worker);
+        const protocol = Communicator.sender(messenger.channel("offline-engine"), dispatcher => new class {
+            initialize(enginePort, progressPort, config) {
+                return dispatcher.dispatchAndReturn(this.initialize, enginePort, progressPort, config);
+            }
+            render(config) {
+                return dispatcher.dispatchAndReturn(this.render, config);
+            }
+            step(samples) {
+                return dispatcher.dispatchAndReturn(this.step, samples);
+            }
+            stop() { dispatcher.dispatchAndForget(this.stop); }
+        });
+        const channel = new MessageChannel();
+        const progressChannel = new MessageChannel();
+        const syncStreamBuffer = new SharedArrayBuffer(1024);
+        const controlFlagsBuffer = new SharedArrayBuffer(4);
+        const terminator = new Terminator();
+        const projectCopy = source.copy();
+        const { timelineBox, boxGraph } = projectCopy;
+        boxGraph.beginTransaction();
+        timelineBox.loopArea.enabled.setValue(false);
+        boxGraph.endTransaction();
+        const engineMessenger = Messenger.for(channel.port2);
+        Communicator.executor(engineMessenger.channel("engine-to-client"), {
+            log: (message) => console.log("OFFLINE-ENGINE", message),
+            error: (reason) => console.error("OFFLINE-ENGINE", reason),
+            ready: () => { },
+            fetchAudio: (uuid) => new Promise((resolve, reject) => {
+                const handler = source.sampleManager.getOrCreate(uuid);
+                const subscription = handler.subscribe(state => {
+                    if (state.type === "error") {
+                        reject(new Error(state.reason));
+                        subscription.terminate();
+                    }
+                    else if (state.type === "loaded") {
+                        resolve(handler.data.unwrap());
+                        subscription.terminate();
+                    }
+                });
+            }),
+            fetchSoundfont: (uuid) => new Promise((resolve, reject) => {
+                const handler = source.soundfontManager.getOrCreate(uuid);
+                const subscription = handler.subscribe(state => {
+                    if (state.type === "error") {
+                        reject(new Error(state.reason));
+                        subscription.terminate();
+                    }
+                    else if (state.type === "loaded") {
+                        resolve(handler.soundfont.unwrap());
+                        subscription.terminate();
+                    }
+                });
+            }),
+            notifyClipSequenceChanges: () => { },
+            switchMarkerState: () => { }
+        });
+        const engineCommands = Communicator.sender(engineMessenger.channel("engine-commands"), dispatcher => new class {
+            play() { dispatcher.dispatchAndForget(this.play); }
+            stop(reset) { dispatcher.dispatchAndForget(this.stop, reset); }
+            setPosition(position) { dispatcher.dispatchAndForget(this.setPosition, position); }
+            prepareRecordingState(countIn) { dispatcher.dispatchAndForget(this.prepareRecordingState, countIn); }
+            stopRecording() { dispatcher.dispatchAndForget(this.stopRecording); }
+            queryLoadingComplete() { return dispatcher.dispatchAndReturn(this.queryLoadingComplete); }
+            panic() { dispatcher.dispatchAndForget(this.panic); }
+            noteSignal(signal) { dispatcher.dispatchAndForget(this.noteSignal, signal); }
+            ignoreNoteRegion(uuid) { dispatcher.dispatchAndForget(this.ignoreNoteRegion, uuid); }
+            scheduleClipPlay(clipIds) { dispatcher.dispatchAndForget(this.scheduleClipPlay, clipIds); }
+            scheduleClipStop(trackIds) { dispatcher.dispatchAndForget(this.scheduleClipStop, trackIds); }
+            setupMIDI(port, buffer) { dispatcher.dispatchAndForget(this.setupMIDI, port, buffer); }
+            terminate() { dispatcher.dispatchAndForget(this.terminate); }
+        });
+        channel.port2.start();
+        progressChannel.port2.start();
+        let cancelled = false;
+        if (isDefined(abortSignal)) {
+            abortSignal.onabort = () => {
+                engineCommands.stop(true);
+                protocol.stop();
+                terminator.terminate();
+                worker.terminate();
+                cancelled = true;
+                reject(Errors.AbortError);
+            };
+        }
+        progressChannel.port2.onmessage = (event) => progress(event.data.frames / sampleRate);
+        await protocol.initialize(channel.port1, progressChannel.port1, {
+            sampleRate,
+            numberOfChannels,
+            processorsUrl: AudioWorklets.processorsUrl,
+            syncStreamBuffer,
+            controlFlagsBuffer,
+            project: projectCopy.toArrayBuffer(),
+            exportConfiguration: optExportConfiguration.unwrapOrUndefined()
+        });
+        engineCommands.play();
+        protocol.render({}).then(channels => {
+            if (cancelled) {
+                return;
+            }
+            terminator.terminate();
+            worker.terminate();
+            const numberOfFrames = channels[0].length;
+            const audioData = AudioData.create(sampleRate, numberOfFrames, numberOfChannels);
+            for (let channelIndex = 0; channelIndex < numberOfChannels; channelIndex++) {
+                audioData.frames[channelIndex].set(channels[channelIndex]);
+            }
+            resolve(audioData);
+        }).catch(reason => {
+            if (!cancelled) {
+                terminator.terminate();
+                worker.terminate();
+                reject(reason);
+            }
+        });
+        return promise;
+    };
+})(OfflineEngineRenderer || (OfflineEngineRenderer = {}));

package/dist/RecordingWorklet.d.ts

@@ -5,7 +5,7 @@ import { RingBuffer, SampleLoader, SampleLoaderState } from "@opendaw/studio-ada
 export declare class RecordingWorklet extends AudioWorkletNode implements Terminable, SampleLoader {
     #private;
     readonly uuid: UUID.Bytes;
-    constructor(context: BaseAudioContext, config: RingBuffer.Config, outputLatency: number);
+    constructor(context: BaseAudioContext, config: RingBuffer.Config);
     own<T extends Terminable>(terminable: T): T;
     limit(count: int): void;
     setFillLength(value: int): void;

package/dist/RecordingWorklet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RecordingWorklet.d.ts","sourceRoot":"","sources":["../src/RecordingWorklet.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,GAAG,EAEH,QAAQ,EACR,MAAM,EAGN,YAAY,EACZ,UAAU,EAEV,IAAI,EACP,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAC,SAAS,EAAW,MAAM,kBAAkB,CAAA;AACpD,OAAO,EAAC,KAAK,EAAc,MAAM,qBAAqB,CAAA;AACtD,OAAO,EAEH,UAAU,EACV,YAAY,EACZ,iBAAiB,EAEpB,MAAM,0BAA0B,CAAA;AAMjC,qBAAa,gBAAiB,SAAQ,gBAAiB,YAAW,UAAU,EAAE,YAAY;;IAGtF,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAkB;gBAa/B,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,UAAU,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM;IA2BvF,GAAG,CAAC,CAAC,SAAS,UAAU,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC;IAE3C,KAAK,CAAC,KAAK,EAAE,GAAG,GAAG,IAAI;IAEvB,aAAa,CAAC,KAAK,EAAE,GAAG,GAAG,IAAI;IAE/B,IAAI,cAAc,IAAI,GAAG,CAA6C;IACtE,IAAI,IAAI,IAAI,MAAM,CAAC,SAAS,CAAC,CAAoB;IACjD,IAAI,KAAK,IAAI,MAAM,CAAC,KAAK,CAAC,CAA6E;IACvG,IAAI,KAAK,IAAI,iBAAiB,CAAqB;IAEnD,UAAU,IAAI,IAAI;IAElB,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAC,iBAAiB,CAAC,GAAG,YAAY;IAQ9D,SAAS,IAAI,IAAI;IAOjB,QAAQ,IAAI,MAAM;CAqCrB"}
+{"version":3,"file":"RecordingWorklet.d.ts","sourceRoot":"","sources":["../src/RecordingWorklet.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,GAAG,EAEH,QAAQ,EACR,MAAM,EAGN,YAAY,EACZ,UAAU,EAEV,IAAI,EACP,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAC,SAAS,EAAW,MAAM,kBAAkB,CAAA;AACpD,OAAO,EAAC,KAAK,EAAc,MAAM,qBAAqB,CAAA;AACtD,OAAO,EAEH,UAAU,EACV,YAAY,EACZ,iBAAiB,EAEpB,MAAM,0BAA0B,CAAA;AAMjC,qBAAa,gBAAiB,SAAQ,gBAAiB,YAAW,UAAU,EAAE,YAAY;;IAGtF,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAkB;gBAa/B,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,UAAU,CAAC,MAAM;IAuBhE,GAAG,CAAC,CAAC,SAAS,UAAU,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC;IAE3C,KAAK,CAAC,KAAK,EAAE,GAAG,GAAG,IAAI;IAEvB,aAAa,CAAC,KAAK,EAAE,GAAG,GAAG,IAAI;IAE/B,IAAI,cAAc,IAAI,GAAG,CAA6C;IACtE,IAAI,IAAI,IAAI,MAAM,CAAC,SAAS,CAAC,CAAoB;IACjD,IAAI,KAAK,IAAI,MAAM,CAAC,KAAK,CAAC,CAA6E;IACvG,IAAI,KAAK,IAAI,iBAAiB,CAAqB;IAEnD,UAAU,IAAI,IAAI;IAElB,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAC,iBAAiB,CAAC,GAAG,YAAY;IAQ9D,SAAS,IAAI,IAAI;IAOjB,QAAQ,IAAI,MAAM;CAqCrB"}

package/dist/RecordingWorklet.js

@@ -18,7 +18,7 @@ export class RecordingWorklet extends AudioWorkletNode {
     #isRecording = true;
     #limitSamples = Number.POSITIVE_INFINITY;
     #state = { type: "record" };
-    constructor(context, config, outputLatency) {
+    constructor(context, config) {
         super(context, "recording-processor", {
             numberOfInputs: 1,
             channelCount: config.numberOfChannels,
@@ -32,12 +32,8 @@ export class RecordingWorklet extends AudioWorkletNode {
         this.#reader = RingBuffer.reader(config, array => {
             if (this.#isRecording) {
                 this.#output.push(array);
-                const latencyInSamples = (outputLatency * this.context.sampleRate) | 0;
-                if (this.numberOfFrames >= latencyInSamples) {
-                    this.#peakWriter.append(array);
-                }
-                const need = this.numberOfFrames - latencyInSamples;
-                if (need >= this.#limitSamples) {
+                this.#peakWriter.append(array);
+                if (this.numberOfFrames >= this.#limitSamples) {
                     this.#finalize().catch(error => console.warn(error));
                 }
             }

package/dist/capture/CaptureAudio.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CaptureAudio.d.ts","sourceRoot":"","sources":["../../src/capture/CaptureAudio.ts"],"names":[],"mappings":"AAAA,OAAO,EAKH,uBAAuB,EACvB,MAAM,EAEN,UAAU,EACb,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAC,YAAY,EAAE,eAAe,EAAC,MAAM,uBAAuB,CAAA;AACnE,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AACjC,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAI/C,qBAAa,YAAa,SAAQ,OAAO,CAAC,eAAe,CAAC;;gBAQ1C,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,eAAe;IA4BjG,IAAI,MAAM,IAAI,MAAM,CAAsB;IAE1C,IAAI,MAAM,IAAI,uBAAuB,CAAC,WAAW,CAAC,CAAsB;IAExE,IAAI,cAAc,IAAI,MAAM,CAAC,MAAM,CAAC,CAEnC;IAED,IAAI,KAAK,IAAI,MAAM,CAAsE;IAEzF,IAAI,WAAW,IAAI,MAAM,CAAC,MAAM,CAAC,CAA+D;IAEhG,IAAI,gBAAgB,IAAI,MAAM,CAAC,gBAAgB,CAAC,CAE/C;IAEK,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAiBvC,cAAc,IAAI,UAAU;CA6D/B"}
+{"version":3,"file":"CaptureAudio.d.ts","sourceRoot":"","sources":["../../src/capture/CaptureAudio.ts"],"names":[],"mappings":"AAAA,OAAO,EAKH,uBAAuB,EACvB,MAAM,EAEN,UAAU,EACb,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAC,YAAY,EAAE,eAAe,EAAC,MAAM,uBAAuB,CAAA;AACnE,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AACjC,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAI/C,qBAAa,YAAa,SAAQ,OAAO,CAAC,eAAe,CAAC;;gBAQ1C,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,eAAe;IA4BjG,IAAI,MAAM,IAAI,MAAM,CAAsB;IAE1C,IAAI,MAAM,IAAI,uBAAuB,CAAC,WAAW,CAAC,CAAsB;IAExE,IAAI,cAAc,IAAI,MAAM,CAAC,MAAM,CAAC,CAEnC;IAED,IAAI,KAAK,IAAI,MAAM,CAAsE;IAEzF,IAAI,WAAW,IAAI,MAAM,CAAC,MAAM,CAAC,CAA+D;IAEhG,IAAI,gBAAgB,IAAI,MAAM,CAAC,gBAAgB,CAAC,CAE/C;IAEK,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAiBvC,cAAc,IAAI,UAAU;CA8D/B"}

package/dist/capture/CaptureAudio.js

@@ -66,7 +66,7 @@ export class CaptureAudio extends Capture {
         const mediaStream = streamOption.unwrap();
         const channelCount = mediaStream.getAudioTracks().at(0)?.getSettings().channelCount ?? 1;
         const numChunks = 128;
-        const recordingWorklet = audioWorklets.createRecording(channelCount, numChunks, audioContext.outputLatency);
+        const recordingWorklet = audioWorklets.createRecording(channelCount, numChunks);
         return RecordAudio.start({
             recordingWorklet,
             mediaStream,
@@ -74,7 +74,8 @@ export class CaptureAudio extends Capture {
             audioContext,
             project,
             capture: this,
-            gainDb: this.#gainDb
+            gainDb: this.#gainDb,
+            outputLatency: audioContext.outputLatency ?? 0
         });
     }
     async #updateStream() {

package/dist/capture/RecordAudio.d.ts

@@ -12,8 +12,9 @@ export declare namespace RecordAudio {
         project: Project;
         capture: Capture;
         gainDb: number;
+        outputLatency: number;
     };
-    export const start: ({ recordingWorklet, mediaStream, sampleManager, audioContext, project, capture, gainDb }: RecordAudioContext) => Terminable;
+    export const start: ({ recordingWorklet, mediaStream, sampleManager, audioContext, project, capture, gainDb, outputLatency }: RecordAudioContext) => Terminable;
     export {};
 }
 //# sourceMappingURL=RecordAudio.d.ts.map

package/dist/capture/RecordAudio.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RecordAudio.d.ts","sourceRoot":"","sources":["../../src/capture/RecordAudio.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,UAAU,EAAmB,MAAM,kBAAkB,CAAA;AAUzF,OAAO,EAAa,mBAAmB,EAAY,MAAM,0BAA0B,CAAA;AACnF,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAA;AAClC,OAAO,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAA;AACpD,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAGjC,yBAAiB,WAAW,CAAC;IACzB,KAAK,kBAAkB,GAAG;QACtB,gBAAgB,EAAE,gBAAgB,CAAA;QAClC,WAAW,EAAE,WAAW,CAAA;QACxB,aAAa,EAAE,mBAAmB,CAAA;QAClC,YAAY,EAAE,YAAY,CAAA;QAC1B,OAAO,EAAE,OAAO,CAAA;QAChB,OAAO,EAAE,OAAO,CAAA;QAChB,MAAM,EAAE,MAAM,CAAA;KACjB,CAAA;IAED,MAAM,CAAC,MAAM,KAAK,GACd,0FAAwF,kBAAkB,KACxG,UAyFL,CAAA;;CACJ"}
+{"version":3,"file":"RecordAudio.d.ts","sourceRoot":"","sources":["../../src/capture/RecordAudio.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,UAAU,EAAmB,MAAM,kBAAkB,CAAA;AAUzF,OAAO,EAAa,mBAAmB,EAAY,MAAM,0BAA0B,CAAA;AACnF,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAA;AAClC,OAAO,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAA;AACpD,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAGjC,yBAAiB,WAAW,CAAC;IACzB,KAAK,kBAAkB,GAAG;QACtB,gBAAgB,EAAE,gBAAgB,CAAA;QAClC,WAAW,EAAE,WAAW,CAAA;QACxB,aAAa,EAAE,mBAAmB,CAAA;QAClC,YAAY,EAAE,YAAY,CAAA;QAC1B,OAAO,EAAE,OAAO,CAAA;QAChB,OAAO,EAAE,OAAO,CAAA;QAChB,MAAM,EAAE,MAAM,CAAA;QACd,aAAa,EAAE,MAAM,CAAA;KACxB,CAAA;IAQD,MAAM,CAAC,MAAM,KAAK,GACd,yGASG,kBAAkB,KACnB,UA2IL,CAAA;;CACJ"}

package/dist/capture/RecordAudio.js

@@ -5,12 +5,11 @@ import { ColorCodes, TrackType } from "@opendaw/studio-adapters";
 import { RecordTrack } from "./RecordTrack";
 export var RecordAudio;
 (function (RecordAudio) {
-    RecordAudio.start = ({ recordingWorklet, mediaStream, sampleManager, audioContext, project, capture, gainDb }) => {
+    RecordAudio.start = ({ recordingWorklet, mediaStream, sampleManager, audioContext, project, capture, gainDb, outputLatency }) => {
         const terminator = new Terminator();
         const beats = PPQN.fromSignature(1, project.timelineBox.signature.denominator.getValue());
-        const { editing, engine, boxGraph } = project;
-        const trackBox = RecordTrack.findOrCreate(editing, capture.audioUnitBox, TrackType.Audio);
-        const uuid = recordingWorklet.uuid;
+        const { editing, engine, boxGraph, timelineBox } = project;
+        const originalUuid = recordingWorklet.uuid;
         sampleManager.record(recordingWorklet);
         const streamSource = audioContext.createMediaStreamSource(mediaStream);
         const streamGain = audioContext.createGain();
@@ -20,8 +19,14 @@ export var RecordAudio;
             streamGain.disconnect();
             streamSource.disconnect();
         }));
-        let recordingData = Option.None;
-        const createRecordingData = (position) => editing.modify(() => {
+        let fileBox = Option.None;
+        let currentTake = Option.None;
+        let lastPosition = 0;
+        let currentWaveformOffset = outputLatency;
+        let takeNumber = 0;
+        const { tempoMap, env: { audioContext: { sampleRate } } } = project;
+        const { loopArea } = timelineBox;
+        const createFileBox = () => {
             const fileDateString = new Date()
                 .toISOString()
                 .replaceAll("T", "-")
@@ -29,64 +34,105 @@ export var RecordAudio;
                 .replaceAll(":", "-")
                 .replaceAll("Z", "");
             const fileName = `Recording-${fileDateString}`;
-            const fileBox = AudioFileBox.create(boxGraph, uuid, box => box.fileName.setValue(fileName));
+            return AudioFileBox.create(boxGraph, originalUuid, box => box.fileName.setValue(fileName));
+        };
+        const createTakeRegion = (position, waveformOffset, forceNewTrack) => {
+            takeNumber++;
+            const trackBox = RecordTrack.findOrCreate(editing, capture.audioUnitBox, TrackType.Audio, forceNewTrack);
             const collectionBox = ValueEventCollectionBox.create(boxGraph, UUID.generate());
             const stretchBox = AudioPitchStretchBox.create(boxGraph, UUID.generate());
             WarpMarkerBox.create(boxGraph, UUID.generate(), box => box.owner.refer(stretchBox.warpMarkers));
             const warpMarkerBox = WarpMarkerBox.create(boxGraph, UUID.generate(), box => box.owner.refer(stretchBox.warpMarkers));
             const regionBox = AudioRegionBox.create(boxGraph, UUID.generate(), box => {
-                box.file.refer(fileBox);
+                box.file.refer(fileBox.unwrap());
                 box.events.refer(collectionBox.owners);
                 box.regions.refer(trackBox.regions);
                 box.position.setValue(position);
                 box.hue.setValue(ColorCodes.forTrackType(TrackType.Audio));
                 box.timeBase.setValue(TimeBase.Musical);
-                box.label.setValue("Recording");
+                box.label.setValue(`Take ${takeNumber}`);
                 box.playMode.refer(stretchBox);
+                box.waveformOffset.setValue(waveformOffset);
             });
             capture.addRecordedRegion(regionBox);
             project.selection.select(regionBox);
-            return { fileBox, regionBox, warpMarkerBox };
-        }, false);
-        const { tempoMap, env: { audioContext: { sampleRate } } } = project;
+            return { trackBox, regionBox, warpMarkerBox };
+        };
+        const finalizeTake = (take, loopDurationPPQN) => {
+            const { trackBox, regionBox, warpMarkerBox } = take;
+            if (regionBox.isAttached()) {
+                regionBox.duration.setValue(loopDurationPPQN);
+                regionBox.loopDuration.setValue(loopDurationPPQN);
+                const seconds = tempoMap.intervalToSeconds(0, loopDurationPPQN);
+                warpMarkerBox.position.setValue(loopDurationPPQN);
+                warpMarkerBox.seconds.setValue(seconds);
+            }
+            if (trackBox.isAttached()) {
+                trackBox.enabled.setValue(false);
+            }
+        };
+        const startNewTake = (position) => {
+            currentTake = Option.wrap(createTakeRegion(position, currentWaveformOffset, true));
+        };
         terminator.ownAll(Terminable.create(() => {
-            if (recordingWorklet.numberOfFrames === 0 || recordingData.isEmpty()) {
+            if (recordingWorklet.numberOfFrames === 0 || fileBox.isEmpty()) {
                 console.debug("Abort recording audio.");
-                sampleManager.remove(uuid);
+                sampleManager.remove(originalUuid);
                 recordingWorklet.terminate();
             }
             else {
-                const { regionBox: { duration }, fileBox } = recordingData.unwrap("No recording data available");
-                recordingWorklet.limit(Math.ceil(tempoMap.intervalToSeconds(0, duration.getValue()) * sampleRate));
-                fileBox.endInSeconds.setValue(recordingWorklet.numberOfFrames / sampleRate);
+                currentTake.ifSome(({ regionBox: { duration } }) => {
+                    recordingWorklet.limit(Math.ceil((currentWaveformOffset + tempoMap.intervalToSeconds(0, duration.getValue())) * sampleRate));
+                });
+                fileBox.ifSome(fb => fb.endInSeconds.setValue(recordingWorklet.numberOfFrames / sampleRate));
             }
         }), engine.position.catchupAndSubscribe(owner => {
             if (!engine.isRecording.getValue()) {
                 return;
             }
-            if (recordingData.isEmpty()) {
+            const currentPosition = owner.getValue();
+            const loopEnabled = loopArea.enabled.getValue();
+            const loopFrom = loopArea.from.getValue();
+            const loopTo = loopArea.to.getValue();
+            const loopDurationPPQN = loopTo - loopFrom;
+            const loopDurationSeconds = tempoMap.intervalToSeconds(loopFrom, loopTo);
+            if (loopEnabled && currentTake.nonEmpty() && currentPosition < lastPosition) {
+                editing.modify(() => {
+                    currentTake.ifSome(take => finalizeTake(take, loopDurationPPQN));
+                    currentWaveformOffset += loopDurationSeconds;
+                    startNewTake(loopFrom);
+                }, false);
+            }
+            lastPosition = currentPosition;
+            if (fileBox.isEmpty()) {
                 streamGain.connect(recordingWorklet);
-                recordingData = createRecordingData(quantizeFloor(owner.getValue(), beats));
+                editing.modify(() => {
+                    fileBox = Option.wrap(createFileBox());
+                    const position = quantizeFloor(currentPosition, beats);
+                    currentTake = Option.wrap(createTakeRegion(position, currentWaveformOffset, false));
+                }, false);
             }
-            const { fileBox, regionBox, warpMarkerBox } = recordingData.unwrap();
-            editing.modify(() => {
-                if (regionBox.isAttached()) {
-                    const { duration, loopDuration } = regionBox;
-                    const distanceInPPQN = Math.floor(engine.position.getValue() - regionBox.position.getValue());
-                    duration.setValue(distanceInPPQN);
-                    loopDuration.setValue(distanceInPPQN);
-                    warpMarkerBox.position.setValue(distanceInPPQN);
-                    const seconds = tempoMap.intervalToSeconds(0, distanceInPPQN);
-                    const totalSamples = Math.ceil(seconds * sampleRate);
-                    recordingWorklet.setFillLength(totalSamples);
-                    fileBox.endInSeconds.setValue(seconds);
-                    warpMarkerBox.seconds.setValue(seconds);
-                }
-                else {
-                    terminator.terminate();
-                    recordingData = Option.None;
-                }
-            }, false);
+            currentTake.ifSome(({ regionBox, warpMarkerBox }) => {
+                editing.modify(() => {
+                    if (regionBox.isAttached()) {
+                        const { duration, loopDuration } = regionBox;
+                        const maxDuration = loopEnabled ? loopTo - regionBox.position.getValue() : Infinity;
+                        const distanceInPPQN = Math.min(maxDuration, Math.floor(currentPosition - regionBox.position.getValue()));
+                        duration.setValue(distanceInPPQN);
+                        loopDuration.setValue(distanceInPPQN);
+                        warpMarkerBox.position.setValue(distanceInPPQN);
+                        const seconds = tempoMap.intervalToSeconds(0, distanceInPPQN);
+                        const totalSamples = Math.ceil((currentWaveformOffset + seconds) * sampleRate);
+                        recordingWorklet.setFillLength(totalSamples);
+                        fileBox.ifSome(fb => fb.endInSeconds.setValue(totalSamples / sampleRate));
+                        warpMarkerBox.seconds.setValue(seconds);
+                    }
+                    else {
+                        terminator.terminate();
+                        currentTake = Option.None;
+                    }
+                }, false);
+            });
         }));
         return terminator;
     };

package/dist/capture/RecordMidi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RecordMidi.d.ts","sourceRoot":"","sources":["../../src/capture/RecordMidi.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,QAAQ,EAAuC,UAAU,EAAmB,MAAM,kBAAkB,CAAA;AAGlH,OAAO,EAAa,UAAU,EAAY,MAAM,0BAA0B,CAAA;AAC1E,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAA;AAClC,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAGjC,yBAAiB,UAAU,CAAC;IACxB,KAAK,iBAAiB,GAAG;QACrB,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC;QAC/B,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,EAAE,OAAO,CAAA;KACnB,CAAA;IAID,MAAM,CAAC,MAAM,KAAK,GAAI,gCAA8B,iBAAiB,KAAG,UAyEvE,CAAA;;CACJ"}
+{"version":3,"file":"RecordMidi.d.ts","sourceRoot":"","sources":["../../src/capture/RecordMidi.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,QAAQ,EAAuC,UAAU,EAAmB,MAAM,kBAAkB,CAAA;AAGvH,OAAO,EAAa,UAAU,EAAY,MAAM,0BAA0B,CAAA;AAC1E,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAA;AAClC,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAGjC,yBAAiB,UAAU,CAAC;IACxB,KAAK,iBAAiB,GAAG;QACrB,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC;QAC/B,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,EAAE,OAAO,CAAA;KACnB,CAAA;IAgBD,MAAM,CAAC,MAAM,KAAK,GAAI,gCAA8B,iBAAiB,KAAG,UAmHvE,CAAA;;CACJ"}