@opendaw/studio-core 0.0.95 → 0.0.97

package/dist/EffectBox.d.ts

@@ -1,3 +1,3 @@
-import { ArpeggioDeviceBox, MaximizerDeviceBox, CompressorDeviceBox, CrusherDeviceBox, DattorroReverbDeviceBox, DelayDeviceBox, FoldDeviceBox, ModularDeviceBox, PitchDeviceBox, RevampDeviceBox, ReverbDeviceBox, StereoToolDeviceBox, TidalDeviceBox, UnknownAudioEffectDeviceBox, UnknownMidiEffectDeviceBox, VelocityDeviceBox, ZeitgeistDeviceBox } from "@opendaw/studio-boxes";
-export type EffectBox = ArpeggioDeviceBox | PitchDeviceBox | VelocityDeviceBox | ZeitgeistDeviceBox | UnknownMidiEffectDeviceBox | MaximizerDeviceBox | DelayDeviceBox | ReverbDeviceBox | RevampDeviceBox | StereoToolDeviceBox | TidalDeviceBox | ModularDeviceBox | UnknownAudioEffectDeviceBox | CompressorDeviceBox | CrusherDeviceBox | FoldDeviceBox | DattorroReverbDeviceBox;
+import { ArpeggioDeviceBox, MaximizerDeviceBox, CompressorDeviceBox, CrusherDeviceBox, DattorroReverbDeviceBox, DelayDeviceBox, FoldDeviceBox, GateDeviceBox, ModularDeviceBox, PitchDeviceBox, RevampDeviceBox, ReverbDeviceBox, StereoToolDeviceBox, TidalDeviceBox, UnknownAudioEffectDeviceBox, UnknownMidiEffectDeviceBox, VelocityDeviceBox, ZeitgeistDeviceBox } from "@opendaw/studio-boxes";
+export type EffectBox = ArpeggioDeviceBox | PitchDeviceBox | VelocityDeviceBox | ZeitgeistDeviceBox | UnknownMidiEffectDeviceBox | MaximizerDeviceBox | DelayDeviceBox | ReverbDeviceBox | RevampDeviceBox | StereoToolDeviceBox | TidalDeviceBox | ModularDeviceBox | UnknownAudioEffectDeviceBox | CompressorDeviceBox | GateDeviceBox | CrusherDeviceBox | FoldDeviceBox | DattorroReverbDeviceBox;
 //# sourceMappingURL=EffectBox.d.ts.map

package/dist/EffectBox.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EffectBox.d.ts","sourceRoot":"","sources":["../src/EffectBox.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,EAChB,uBAAuB,EACvB,cAAc,EACd,aAAa,EACb,gBAAgB,EAChB,cAAc,EACd,eAAe,EACf,eAAe,EACf,mBAAmB,EACnB,cAAc,EACd,2BAA2B,EAC3B,0BAA0B,EAC1B,iBAAiB,EACjB,kBAAkB,EACrB,MAAM,uBAAuB,CAAA;AAE9B,MAAM,MAAM,SAAS,GACf,iBAAiB,GAAG,cAAc,GAAG,iBAAiB,GAAG,kBAAkB,GAAG,0BAA0B,GACxG,kBAAkB,GAAG,cAAc,GAAG,eAAe,GAAG,eAAe,GAAG,mBAAmB,GAAG,cAAc,GAC9G,gBAAgB,GAAG,2BAA2B,GAAG,mBAAmB,GAAG,gBAAgB,GAAG,aAAa,GACvG,uBAAuB,CAAA"}
+{"version":3,"file":"EffectBox.d.ts","sourceRoot":"","sources":["../src/EffectBox.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,EAChB,uBAAuB,EACvB,cAAc,EACd,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,cAAc,EACd,eAAe,EACf,eAAe,EACf,mBAAmB,EACnB,cAAc,EACd,2BAA2B,EAC3B,0BAA0B,EAC1B,iBAAiB,EACjB,kBAAkB,EACrB,MAAM,uBAAuB,CAAA;AAE9B,MAAM,MAAM,SAAS,GACf,iBAAiB,GAAG,cAAc,GAAG,iBAAiB,GAAG,kBAAkB,GAAG,0BAA0B,GACxG,kBAAkB,GAAG,cAAc,GAAG,eAAe,GAAG,eAAe,GAAG,mBAAmB,GAAG,cAAc,GAC9G,gBAAgB,GAAG,2BAA2B,GAAG,mBAAmB,GAAG,aAAa,GACpF,gBAAgB,GAAG,aAAa,GAAG,uBAAuB,CAAA"}

package/dist/EffectFactories.d.ts

@@ -9,6 +9,7 @@ export declare namespace EffectFactories {
     const DattorroReverb: EffectFactory;
     const Maximizer: EffectFactory;
     const Compressor: EffectFactory;
+    const Gate: EffectFactory;
     const Reverb: EffectFactory;
     const Crusher: EffectFactory;
     const Fold: EffectFactory;
@@ -24,6 +25,7 @@ export declare namespace EffectFactories {
     const AudioNamed: {
         StereoTool: EffectFactory;
         Compressor: EffectFactory;
+        Gate: EffectFactory;
         Delay: EffectFactory;
         Reverb: EffectFactory;
         DattorroReverb: EffectFactory;
@@ -38,6 +40,7 @@ export declare namespace EffectFactories {
     const MergedNamed: {
         StereoTool: EffectFactory;
         Compressor: EffectFactory;
+        Gate: EffectFactory;
         Delay: EffectFactory;
         Reverb: EffectFactory;
         DattorroReverb: EffectFactory;

package/dist/EffectFactories.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EffectFactories.d.ts","sourceRoot":"","sources":["../src/EffectFactories.ts"],"names":[],"mappings":"AAyBA,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAA;AAG7C,yBAAiB,eAAe,CAAC;IACtB,MAAM,QAAQ,EAAE,aAYtB,CAAA;IAEM,MAAM,KAAK,EAAE,aAYnB,CAAA;IAEM,MAAM,QAAQ,EAAE,aAYtB,CAAA;IAEM,MAAM,SAAS,EAAE,aAsBvB,CAAA;IAEM,MAAM,UAAU,EAAE,aAaxB,CAAA;IAEM,MAAM,KAAK,EAAE,aAcnB,CAAA;IAEM,MAAM,cAAc,EAAE,aAa5B,CAAA;IAEM,MAAM,SAAS,EAAE,aAavB,CAAA;IAEM,MAAM,UAAU,EAAE,aAaxB,CAAA;IAEM,MAAM,MAAM,EAAE,aAcpB,CAAA;IAEM,MAAM,OAAO,EAAE,aAarB,CAAA;IAEM,MAAM,IAAI,EAAE,aAalB,CAAA;IAEM,MAAM,KAAK,EAAE,aAcnB,CAAA;IAEM,MAAM,MAAM,EAAE,aAapB,CAAA;IAEM,MAAM,OAAO,EAAE,aAqCrB,CAAA;IAEM,MAAM,SAAS;;;;;KAAyC,CAAA;IACxD,MAAM,UAAU;;;;;;;;;;;KAEtB,CAAA;IACM,MAAM,QAAQ,EAAE,aAAa,CAAC,QAAQ,CAAC,aAAa,CAAC,CAA4B,CAAA;IACjF,MAAM,SAAS,EAAE,aAAa,CAAC,QAAQ,CAAC,aAAa,CAAC,CAA6B,CAAA;IACnF,MAAM,WAAW;;;;;;;;;;;;;;;KAAgC,CAAA;IACxD,KAAY,cAAc,GAAG,MAAM,OAAO,SAAS,CAAA;IACnD,KAAY,eAAe,GAAG,MAAM,OAAO,UAAU,CAAA;CACxD"}
+{"version":3,"file":"EffectFactories.d.ts","sourceRoot":"","sources":["../src/EffectFactories.ts"],"names":[],"mappings":"AA0BA,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAA;AAG7C,yBAAiB,eAAe,CAAC;IACtB,MAAM,QAAQ,EAAE,aAYtB,CAAA;IAEM,MAAM,KAAK,EAAE,aAYnB,CAAA;IAEM,MAAM,QAAQ,EAAE,aAYtB,CAAA;IAEM,MAAM,SAAS,EAAE,aAsBvB,CAAA;IAEM,MAAM,UAAU,EAAE,aAaxB,CAAA;IAEM,MAAM,KAAK,EAAE,aAcnB,CAAA;IAEM,MAAM,cAAc,EAAE,aAa5B,CAAA;IAEM,MAAM,SAAS,EAAE,aAavB,CAAA;IAEM,MAAM,UAAU,EAAE,aAaxB,CAAA;IAEM,MAAM,IAAI,EAAE,aAalB,CAAA;IAEM,MAAM,MAAM,EAAE,aAcpB,CAAA;IAEM,MAAM,OAAO,EAAE,aAarB,CAAA;IAEM,MAAM,IAAI,EAAE,aAalB,CAAA;IAEM,MAAM,KAAK,EAAE,aAcnB,CAAA;IAEM,MAAM,MAAM,EAAE,aAapB,CAAA;IAEM,MAAM,OAAO,EAAE,aAqCrB,CAAA;IAEM,MAAM,SAAS;;;;;KAAyC,CAAA;IACxD,MAAM,UAAU;;;;;;;;;;;;KAEtB,CAAA;IACM,MAAM,QAAQ,EAAE,aAAa,CAAC,QAAQ,CAAC,aAAa,CAAC,CAA4B,CAAA;IACjF,MAAM,SAAS,EAAE,aAAa,CAAC,QAAQ,CAAC,aAAa,CAAC,CAA6B,CAAA;IACnF,MAAM,WAAW;;;;;;;;;;;;;;;;KAAgC,CAAA;IACxD,KAAY,cAAc,GAAG,MAAM,OAAO,SAAS,CAAA;IACnD,KAAY,eAAe,GAAG,MAAM,OAAO,UAAU,CAAA;CACxD"}

package/dist/EffectFactories.js

@@ -1,5 +1,5 @@
 import { UUID } from "@opendaw/lib-std";
-import { ArpeggioDeviceBox, CompressorDeviceBox, CrusherDeviceBox, DattorroReverbDeviceBox, DelayDeviceBox, FoldDeviceBox, GrooveShuffleBox, MaximizerDeviceBox, ModularAudioInputBox, ModularAudioOutputBox, ModularBox, ModularDeviceBox, ModuleConnectionBox, PitchDeviceBox, RevampDeviceBox, ReverbDeviceBox, StereoToolDeviceBox, TidalDeviceBox, VelocityDeviceBox, ZeitgeistDeviceBox } from "@opendaw/studio-boxes";
+import { ArpeggioDeviceBox, CompressorDeviceBox, CrusherDeviceBox, DattorroReverbDeviceBox, DelayDeviceBox, FoldDeviceBox, GateDeviceBox, GrooveShuffleBox, MaximizerDeviceBox, ModularAudioInputBox, ModularAudioOutputBox, ModularBox, ModularDeviceBox, ModuleConnectionBox, PitchDeviceBox, RevampDeviceBox, ReverbDeviceBox, StereoToolDeviceBox, TidalDeviceBox, VelocityDeviceBox, ZeitgeistDeviceBox } from "@opendaw/studio-boxes";
 import { IconSymbol } from "@opendaw/studio-enums";
 import { DeviceManualUrls } from "@opendaw/studio-adapters";
 import { EffectParameterDefaults } from "./EffectParameterDefaults";
@@ -133,6 +133,19 @@ export var EffectFactories;
             box.host.refer(hostField);
         })
     };
+    EffectFactories.Gate = {
+        defaultName: "Gate",
+        defaultIcon: IconSymbol.Gate,
+        description: "Attenuates signals below a threshold to reduce noise",
+        manualPage: DeviceManualUrls.Gate,
+        separatorBefore: false,
+        type: "audio",
+        create: ({ boxGraph }, hostField, index) => GateDeviceBox.create(boxGraph, UUID.generate(), box => {
+            box.label.setValue("Gate");
+            box.index.setValue(index);
+            box.host.refer(hostField);
+        })
+    };
     EffectFactories.Reverb = {
         defaultName: "Cheap Reverb",
         defaultIcon: IconSymbol.Cube,
@@ -240,7 +253,7 @@ export var EffectFactories;
     };
     EffectFactories.MidiNamed = { Arpeggio: EffectFactories.Arpeggio, Pitch: EffectFactories.Pitch, Velocity: EffectFactories.Velocity, Zeitgeist: EffectFactories.Zeitgeist };
     EffectFactories.AudioNamed = {
-        StereoTool: EffectFactories.StereoTool, Compressor: EffectFactories.Compressor, Delay: EffectFactories.Delay, Reverb: EffectFactories.Reverb, DattorroReverb: EffectFactories.DattorroReverb, Revamp: EffectFactories.Revamp, Crusher: EffectFactories.Crusher, Fold: EffectFactories.Fold, Tidal: EffectFactories.Tidal, Maximizer: EffectFactories.Maximizer
+        StereoTool: EffectFactories.StereoTool, Compressor: EffectFactories.Compressor, Gate: EffectFactories.Gate, Delay: EffectFactories.Delay, Reverb: EffectFactories.Reverb, DattorroReverb: EffectFactories.DattorroReverb, Revamp: EffectFactories.Revamp, Crusher: EffectFactories.Crusher, Fold: EffectFactories.Fold, Tidal: EffectFactories.Tidal, Maximizer: EffectFactories.Maximizer
     };
     EffectFactories.MidiList = Object.values(EffectFactories.MidiNamed);
     EffectFactories.AudioList = Object.values(EffectFactories.AudioNamed);

package/dist/Mixer.js

@@ -66,7 +66,7 @@ export class Mixer {
                 return;
             }
             touched.add(adapter);
-            adapter.input.getValue().ifSome(input => {
+            adapter.input.adapter().ifSome(input => {
                 if (input.type === "bus") {
                     input.box.input.pointerHub
                         .filter(Pointers.AudioOutput)

package/dist/capture/CaptureAudio.d.ts

@@ -8,11 +8,15 @@ export declare class CaptureAudio extends Capture<CaptureAudioBox> {
     get isMonitoring(): boolean;
     set isMonitoring(value: boolean);
     get gainDb(): number;
+    get requestChannels(): Option<1 | 2>;
+    set requestChannels(value: 1 | 2);
     get stream(): MutableObservableOption<MediaStream>;
     get streamDeviceId(): Option<string>;
     get label(): string;
     get deviceLabel(): Option<string>;
     get streamMediaTrack(): Option<MediaStreamTrack>;
+    get outputNode(): Option<AudioNode>;
+    get effectiveChannelCount(): number;
     prepareRecording(): Promise<void>;
     startRecording(): Terminable;
 }

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,EAEvB,MAAM,EAEN,UAAU,EACb,MAAM,kBAAkB,CAAA;AAGzB,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;;gBAW1C,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,eAAe;IAiCjG,IAAI,YAAY,IAAI,OAAO,CAA4B;IACvD,IAAI,YAAY,CAAC,KAAK,EAAE,OAAO,EAS9B;IACD,IAAI,MAAM,IAAI,MAAM,CAAsB;IAC1C,IAAI,MAAM,IAAI,uBAAuB,CAAC,WAAW,CAAC,CAAsB;IACxE,IAAI,cAAc,IAAI,MAAM,CAAC,MAAM,CAAC,CAEnC;IACD,IAAI,KAAK,IAAI,MAAM,CAAsE;IACzF,IAAI,WAAW,IAAI,MAAM,CAAC,MAAM,CAAC,CAA+D;IAChG,IAAI,gBAAgB,IAAI,MAAM,CAAC,gBAAgB,CAAC,CAE/C;IAEK,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAiBvC,cAAc,IAAI,UAAU;CAqF/B"}
+{"version":3,"file":"CaptureAudio.d.ts","sourceRoot":"","sources":["../../src/capture/CaptureAudio.ts"],"names":[],"mappings":"AAAA,OAAO,EAKH,uBAAuB,EAEvB,MAAM,EAEN,UAAU,EACb,MAAM,kBAAkB,CAAA;AAGzB,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;;gBAa1C,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,eAAe;IAkCjG,IAAI,YAAY,IAAI,OAAO,CAA4B;IACvD,IAAI,YAAY,CAAC,KAAK,EAAE,OAAO,EAS9B;IACD,IAAI,MAAM,IAAI,MAAM,CAAsB;IAC1C,IAAI,eAAe,IAAI,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAA+B;IACnE,IAAI,eAAe,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,EAAmD;IACnF,IAAI,MAAM,IAAI,uBAAuB,CAAC,WAAW,CAAC,CAAsB;IACxE,IAAI,cAAc,IAAI,MAAM,CAAC,MAAM,CAAC,CAEnC;IACD,IAAI,KAAK,IAAI,MAAM,CAAsE;IACzF,IAAI,WAAW,IAAI,MAAM,CAAC,MAAM,CAAC,CAA+D;IAChG,IAAI,gBAAgB,IAAI,MAAM,CAAC,gBAAgB,CAAC,CAE/C;IACD,IAAI,UAAU,IAAI,MAAM,CAAC,SAAS,CAAC,CAAiD;IACpF,IAAI,qBAAqB,IAAI,MAAM,CAAsD;IAEnF,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAiBvC,cAAc,IAAI,UAAU;CAyG/B"}

package/dist/capture/CaptureAudio.js

@@ -10,7 +10,7 @@ export class CaptureAudio extends Capture {
     #isMonitoring = false;
     #requestChannels = Option.None;
     #gainDb = 0.0;
-    #monitor = null;
+    #audioChain = null;
     constructor(manager, audioUnitBox, captureAudioBox) {
         super(manager, audioUnitBox, captureAudioBox);
         this.#stream = new MutableObservableOption();
@@ -18,10 +18,11 @@ export class CaptureAudio extends Capture {
         this.ownAll(captureAudioBox.requestChannels.catchupAndSubscribe(owner => {
             const channels = owner.getValue();
             this.#requestChannels = channels === 1 || channels === 2 ? Option.wrap(channels) : Option.None;
+            this.#stream.ifSome(stream => this.#rebuildAudioChain(stream));
         }), captureAudioBox.gainDb.catchupAndSubscribe(owner => {
             this.#gainDb = owner.getValue();
-            if (isDefined(this.#monitor)) {
-                this.#monitor.gainNode.gain.value = dbToGain(this.#gainDb);
+            if (isDefined(this.#audioChain)) {
+                this.#audioChain.gainNode.gain.value = dbToGain(this.#gainDb);
             }
         }), captureAudioBox.deviceId.catchupAndSubscribe(async () => {
             if (this.armed.getValue()) {
@@ -45,13 +46,15 @@ export class CaptureAudio extends Capture {
         this.#isMonitoring = value;
         if (this.#isMonitoring) {
             this.armed.setValue(true);
-            this.#stream.ifSome(stream => this.#connectMonitoring(stream));
+            this.#connectMonitoring();
         }
         else {
             this.#disconnectMonitoring();
         }
     }
     get gainDb() { return this.#gainDb; }
+    get requestChannels() { return this.#requestChannels; }
+    set requestChannels(value) { this.captureBox.requestChannels.setValue(value); }
     get stream() { return this.#stream; }
     get streamDeviceId() {
         return this.streamMediaTrack.map(settings => settings.getSettings().deviceId ?? "");
@@ -61,6 +64,8 @@ export class CaptureAudio extends Capture {
     get streamMediaTrack() {
         return this.#stream.flatMap(stream => Option.wrap(stream.getAudioTracks().at(0)));
     }
+    get outputNode() { return Option.wrap(this.#audioChain?.gainNode); }
+    get effectiveChannelCount() { return this.#audioChain?.gainNode.channelCount ?? 1; }
     async prepareRecording() {
         const { project } = this.manager;
         const { env: { audioContext } } = project;
@@ -80,23 +85,21 @@ export class CaptureAudio extends Capture {
     startRecording() {
         const { project } = this.manager;
         const { env: { audioContext, audioWorklets, sampleManager } } = project;
-        const streamOption = this.#stream;
-        if (streamOption.isEmpty()) {
-            console.warn("No audio stream available for recording.");
+        const audioChain = this.#audioChain;
+        if (!isDefined(audioChain)) {
+            console.warn("No audio chain available for recording.");
             return Terminable.Empty;
         }
-        const mediaStream = streamOption.unwrap();
-        const channelCount = mediaStream.getAudioTracks().at(0)?.getSettings().channelCount ?? 1;
+        const { gainNode } = audioChain;
+        const channelCount = gainNode.channelCount;
         const numChunks = 128;
         const recordingWorklet = audioWorklets.createRecording(channelCount, numChunks);
         return RecordAudio.start({
             recordingWorklet,
-            mediaStream,
+            sourceNode: gainNode,
             sampleManager,
-            audioContext,
             project,
             capture: this,
-            gainDb: this.#gainDb,
             outputLatency: audioContext.outputLatency ?? 0
         });
     }
@@ -127,10 +130,8 @@ export class CaptureAudio extends Capture {
             const gotDeviceId = settings?.deviceId;
             console.debug(`new stream. device requested: ${deviceId ?? "default"}, got: ${gotDeviceId ?? "unknown"}. channelCount requested: ${channelCount}, got: ${settings?.channelCount}`);
             if (isUndefined(deviceId) || deviceId === gotDeviceId) {
+                this.#rebuildAudioChain(stream);
                 this.#stream.wrap(stream);
-                if (this.#isMonitoring) {
-                    this.#connectMonitoring(stream);
-                }
             }
             else {
                 stream.getAudioTracks().forEach(track => track.stop());
@@ -139,24 +140,46 @@ export class CaptureAudio extends Capture {
         });
     }
     #stopStream() {
-        this.#disconnectMonitoring();
+        this.#destroyAudioChain();
         this.#stream.clear(stream => stream.getAudioTracks().forEach(track => track.stop()));
     }
-    #connectMonitoring(stream) {
-        this.#disconnectMonitoring();
+    #rebuildAudioChain(stream) {
+        const wasMonitoring = this.#isMonitoring && isDefined(this.#audioChain);
+        this.#destroyAudioChain();
         const { audioContext } = this.manager.project.env;
         const sourceNode = audioContext.createMediaStreamSource(stream);
         const gainNode = audioContext.createGain();
         gainNode.gain.value = dbToGain(this.#gainDb);
+        const streamChannelCount = stream.getAudioTracks().at(0)?.getSettings().channelCount ?? 1;
+        const requestMono = this.#requestChannels.mapOr(channels => channels === 1, false);
+        if (requestMono && streamChannelCount === 2) {
+            gainNode.channelCount = 1;
+            gainNode.channelCountMode = "explicit";
+        }
         sourceNode.connect(gainNode);
-        gainNode.connect(audioContext.destination);
-        this.#monitor = { sourceNode, gainNode };
+        this.#audioChain = { sourceNode, gainNode };
+        if (wasMonitoring || this.#isMonitoring) {
+            this.#connectMonitoring();
+        }
     }
-    #disconnectMonitoring() {
-        if (isDefined(this.#monitor)) {
-            const { sourceNode, gainNode } = this.#monitor;
+    #destroyAudioChain() {
+        if (isDefined(this.#audioChain)) {
+            const { sourceNode, gainNode } = this.#audioChain;
             sourceNode.disconnect();
             gainNode.disconnect();
+            this.#audioChain = null;
+        }
+    }
+    #connectMonitoring() {
+        if (isDefined(this.#audioChain)) {
+            const { audioContext } = this.manager.project.env;
+            this.#audioChain.gainNode.connect(audioContext.destination);
+        }
+    }
+    #disconnectMonitoring() {
+        if (isDefined(this.#audioChain)) {
+            const { audioContext } = this.manager.project.env;
+            this.#audioChain.gainNode.disconnect(audioContext.destination);
         }
     }
 }

package/dist/capture/RecordAudio.d.ts

@@ -6,15 +6,13 @@ import { Capture } from "./Capture";
 export declare namespace RecordAudio {
     type RecordAudioContext = {
         recordingWorklet: RecordingWorklet;
-        mediaStream: MediaStream;
+        sourceNode: AudioNode;
         sampleManager: SampleLoaderManager;
-        audioContext: AudioContext;
         project: Project;
         capture: Capture;
-        gainDb: number;
         outputLatency: number;
     };
-    export const start: ({ recordingWorklet, mediaStream, sampleManager, audioContext, project, capture, gainDb, outputLatency }: RecordAudioContext) => Terminable;
+    export const start: ({ recordingWorklet, sourceNode, sampleManager, project, capture, 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,EAA2C,UAAU,EAAmB,MAAM,kBAAkB,CAAA;AAUvG,OAAO,EAAa,mBAAmB,EAA2B,MAAM,0BAA0B,CAAA;AAClG,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,UAyKL,CAAA;;CACJ"}
+{"version":3,"file":"RecordAudio.d.ts","sourceRoot":"","sources":["../../src/capture/RecordAudio.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2C,UAAU,EAAmB,MAAM,kBAAkB,CAAA;AAGvG,OAAO,EAAa,mBAAmB,EAA2B,MAAM,0BAA0B,CAAA;AAClG,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,UAAU,EAAE,SAAS,CAAA;QACrB,aAAa,EAAE,mBAAmB,CAAA;QAClC,OAAO,EAAE,OAAO,CAAA;QAChB,OAAO,EAAE,OAAO,CAAA;QAChB,aAAa,EAAE,MAAM,CAAA;KACxB,CAAA;IAOD,MAAM,CAAC,MAAM,KAAK,GACd,kFAAgF,kBAAkB,KAChG,UAkJL,CAAA;;CACJ"}

package/dist/capture/RecordAudio.js

@@ -1,30 +1,22 @@
 import { asInstanceOf, Option, quantizeFloor, Terminable, Terminator, UUID } from "@opendaw/lib-std";
-import { dbToGain, PPQN, TimeBase } from "@opendaw/lib-dsp";
-import { AudioFileBox, AudioPitchStretchBox, AudioRegionBox, TrackBox, ValueEventCollectionBox, WarpMarkerBox } from "@opendaw/studio-boxes";
+import { PPQN, TimeBase } from "@opendaw/lib-dsp";
+import { AudioFileBox, AudioRegionBox, TrackBox, ValueEventCollectionBox } from "@opendaw/studio-boxes";
 import { ColorCodes, TrackType, UnionBoxTypes } from "@opendaw/studio-adapters";
 import { RecordTrack } from "./RecordTrack";
 export var RecordAudio;
 (function (RecordAudio) {
-    RecordAudio.start = ({ recordingWorklet, mediaStream, sampleManager, audioContext, project, capture, gainDb, outputLatency }) => {
+    RecordAudio.start = ({ recordingWorklet, sourceNode, sampleManager, project, capture, outputLatency }) => {
         const terminator = new Terminator();
         const beats = PPQN.fromSignature(1, project.timelineBox.signature.denominator.getValue());
         const { editing, engine, boxGraph, timelineBox } = project;
         const originalUuid = recordingWorklet.uuid;
         sampleManager.record(recordingWorklet);
-        const streamSource = audioContext.createMediaStreamSource(mediaStream);
-        const streamGain = audioContext.createGain();
-        streamGain.gain.value = dbToGain(gainDb);
-        streamSource.connect(streamGain);
-        recordingWorklet.own(Terminable.create(() => {
-            streamGain.disconnect();
-            streamSource.disconnect();
-        }));
         let fileBox = Option.None;
         let currentTake = Option.None;
         let lastPosition = 0;
         let currentWaveformOffset = outputLatency;
         let takeNumber = 0;
-        const { tempoMap, env: { audioContext: { sampleRate } }, engine: { preferences: { settings: { recording } } } } = project;
+        const { env: { audioContext: { sampleRate } }, engine: { preferences: { settings: { recording } } } } = project;
         const { loopArea } = timelineBox;
         const createFileBox = () => {
             const fileDateString = new Date()
@@ -40,32 +32,25 @@ export var RecordAudio;
             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.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.timeBase.setValue(TimeBase.Seconds);
                 box.label.setValue(`Take ${takeNumber}`);
-                box.playMode.refer(stretchBox);
                 box.waveformOffset.setValue(waveformOffset);
             });
             capture.addRecordedRegion(regionBox);
             project.selection.select(regionBox);
-            return { trackBox, regionBox, warpMarkerBox };
+            return { trackBox, regionBox };
         };
-        const finalizeTake = (take, loopDurationPPQN) => {
-            const { trackBox, regionBox, warpMarkerBox } = take;
+        const finalizeTake = (take, durationInSeconds) => {
+            const { trackBox, regionBox } = 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);
+                regionBox.duration.setValue(durationInSeconds);
+                regionBox.loopDuration.setValue(durationInSeconds);
             }
             const { olderTakeAction, olderTakeScope } = recording;
             if (olderTakeScope === "all") {
@@ -110,6 +95,7 @@ export var RecordAudio;
             currentTake = Option.wrap(createTakeRegion(position, currentWaveformOffset, true));
         };
         terminator.ownAll(Terminable.create(() => {
+            sourceNode.disconnect(recordingWorklet);
             if (recordingWorklet.numberOfFrames === 0 || fileBox.isEmpty()) {
                 console.debug("Abort recording audio.");
                 sampleManager.remove(originalUuid);
@@ -117,7 +103,7 @@ export var RecordAudio;
             }
             else {
                 currentTake.ifSome(({ regionBox: { duration } }) => {
-                    recordingWorklet.limit(Math.ceil((currentWaveformOffset + tempoMap.intervalToSeconds(0, duration.getValue())) * sampleRate));
+                    recordingWorklet.limit(Math.ceil((currentWaveformOffset + duration.getValue()) * sampleRate));
                 });
                 fileBox.ifSome(fb => fb.endInSeconds.setValue(recordingWorklet.numberOfFrames / sampleRate));
             }
@@ -128,41 +114,36 @@ export var RecordAudio;
             const currentPosition = owner.getValue();
             const loopEnabled = loopArea.enabled.getValue();
             const loopFrom = loopArea.from.getValue();
-            const loopTo = loopArea.to.getValue();
             const allowTakes = project.engine.preferences.settings.recording.allowTakes;
             if (loopEnabled && allowTakes && currentTake.nonEmpty() && currentPosition < lastPosition) {
                 editing.modify(() => {
                     currentTake.ifSome(take => {
-                        const actualDurationPPQN = take.regionBox.duration.getValue();
-                        finalizeTake(take, actualDurationPPQN);
-                        currentWaveformOffset += tempoMap.intervalToSeconds(0, actualDurationPPQN);
+                        const actualDurationInSeconds = take.regionBox.duration.getValue();
+                        finalizeTake(take, actualDurationInSeconds);
+                        currentWaveformOffset += actualDurationInSeconds;
                     });
                     startNewTake(loopFrom);
                 }, false);
             }
             lastPosition = currentPosition;
             if (fileBox.isEmpty()) {
-                streamGain.connect(recordingWorklet);
+                sourceNode.connect(recordingWorklet);
                 editing.modify(() => {
                     fileBox = Option.wrap(createFileBox());
                     const position = quantizeFloor(currentPosition, beats);
                     currentTake = Option.wrap(createTakeRegion(position, currentWaveformOffset, false));
                 }, false);
             }
-            currentTake.ifSome(({ regionBox, warpMarkerBox }) => {
+            currentTake.ifSome(({ regionBox }) => {
                 editing.modify(() => {
                     if (regionBox.isAttached()) {
                         const { duration, loopDuration } = regionBox;
-                        const maxDuration = loopEnabled && allowTakes ? 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);
+                        const totalSeconds = recordingWorklet.numberOfFrames / sampleRate;
+                        const takeSeconds = totalSeconds - currentWaveformOffset;
+                        duration.setValue(takeSeconds);
+                        loopDuration.setValue(takeSeconds);
+                        recordingWorklet.setFillLength(recordingWorklet.numberOfFrames);
+                        fileBox.ifSome(fb => fb.endInSeconds.setValue(totalSeconds));
                     }
                     else {
                         terminator.terminate();