@opendaw/studio-core 0.0.130 → 0.0.132

package/dist/capture/CaptureAudio.js

@@ -8,29 +8,45 @@ import { RenderQuantum } from "../RenderQuantum";
 export class CaptureAudio extends Capture {
     #stream;
     #streamGenerator;
+    #monitorGainNode;
+    #monitorPanNode;
     #monitoringMode = "off";
     #requestChannels = Option.None;
     #gainDb = 0.0;
+    #monitorVolumeDb = 0.0;
+    #monitorPan = 0.0;
+    #monitorMuted = false;
     #audioChain = null;
     #preparedWorklet = null;
+    #monitorOutputDeviceId = Option.None;
+    #monitorAudioElement = null;
+    #monitorStreamDest = null;
     constructor(manager, audioUnitBox, captureAudioBox) {
         super(manager, audioUnitBox, captureAudioBox);
+        const { audioContext } = this.manager.project.env;
+        this.#monitorGainNode = audioContext.createGain();
+        this.#monitorGainNode.gain.value = dbToGain(this.#monitorVolumeDb);
+        this.#monitorPanNode = audioContext.createStereoPanner();
+        this.#monitorPanNode.pan.value = this.#monitorPan;
+        this.#monitorGainNode.connect(this.#monitorPanNode);
         this.#stream = new MutableObservableOption();
         this.#streamGenerator = Promises.sequentialize(() => this.#updateStream());
-        this.ownAll(captureAudioBox.requestChannels.catchupAndSubscribe(owner => {
+        this.ownAll(Terminable.create(() => {
+            this.#disconnectMonitoring();
+            if (isDefined(this.#monitorAudioElement)) {
+                this.#monitorAudioElement.pause();
+                this.#monitorAudioElement.srcObject = null;
+            }
+            this.#monitorGainNode.disconnect();
+            this.#monitorPanNode.disconnect();
+        }), 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));
-            // Re-register monitoring if in effects mode (channel count may have changed)
-            if (this.#monitoringMode === "effects" && isDefined(this.#audioChain)) {
-                const engine = this.manager.project.engine;
-                engine.unregisterMonitoringSource(this.audioUnitBox.address.uuid);
-                engine.registerMonitoringSource(this.audioUnitBox.address.uuid, this.#audioChain.gainNode, this.#audioChain.channelCount);
-            }
         }), captureAudioBox.gainDb.catchupAndSubscribe(owner => {
             this.#gainDb = owner.getValue();
             if (isDefined(this.#audioChain)) {
-                this.#audioChain.gainNode.gain.value = dbToGain(this.#gainDb);
+                this.#audioChain.recordGainNode.gain.value = dbToGain(this.#gainDb);
             }
         }), captureAudioBox.deviceId.catchupAndSubscribe(async () => {
             if (this.armed.getValue()) {
@@ -71,8 +87,62 @@ 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 outputNode() { return Option.wrap(this.#audioChain?.recordGainNode); }
     get effectiveChannelCount() { return this.#audioChain?.channelCount ?? 1; }
+    get monitorGainNode() { return this.#monitorGainNode; }
+    get monitorPanNode() { return this.#monitorPanNode; }
+    get monitorVolumeDb() { return this.#monitorVolumeDb; }
+    set monitorVolumeDb(value) {
+        this.#monitorVolumeDb = value;
+        this.#monitorGainNode.gain.value = this.#monitorMuted ? 0 : dbToGain(this.#monitorVolumeDb);
+    }
+    get monitorPan() { return this.#monitorPan; }
+    set monitorPan(value) {
+        this.#monitorPan = value;
+        this.#monitorPanNode.pan.value = value;
+    }
+    get monitorMuted() { return this.#monitorMuted; }
+    set monitorMuted(value) {
+        this.#monitorMuted = value;
+        this.#monitorGainNode.gain.value = value ? 0 : dbToGain(this.#monitorVolumeDb);
+    }
+    get monitorOutputDeviceId() { return this.#monitorOutputDeviceId; }
+    async setMonitorOutputDevice(deviceId) {
+        const oldDestination = this.#monitorDestination();
+        this.#monitorOutputDeviceId = deviceId;
+        if (isDefined(this.#monitorAudioElement)) {
+            this.#monitorAudioElement.pause();
+            this.#monitorAudioElement.srcObject = null;
+            this.#monitorAudioElement = null;
+        }
+        if (isDefined(this.#monitorStreamDest)) {
+            this.#monitorStreamDest.disconnect();
+            this.#monitorStreamDest = null;
+        }
+        if (deviceId.nonEmpty()) {
+            const { audioContext } = this.manager.project.env;
+            this.#monitorStreamDest = audioContext.createMediaStreamDestination();
+            const audio = new Audio();
+            audio.srcObject = this.#monitorStreamDest.stream;
+            try {
+                await audio.setSinkId(deviceId.unwrap());
+                await audio.play();
+                this.#monitorAudioElement = audio;
+            }
+            catch (reason) {
+                audio.srcObject = null;
+                this.#monitorStreamDest.disconnect();
+                this.#monitorStreamDest = null;
+                this.#monitorOutputDeviceId = Option.None;
+                RuntimeNotifier.info({ headline: "Output Device Error", message: `${reason}` });
+                return;
+            }
+        }
+        if (this.#monitoringMode !== "off" && isDefined(this.#audioChain)) {
+            this.#monitorPanNode.disconnect(oldDestination);
+            this.#monitorPanNode.connect(this.#monitorDestination());
+        }
+    }
     async prepareRecording() {
         const { project } = this.manager;
         const { env: { audioContext, audioWorklets, sampleManager, sampleService } } = project;
@@ -92,12 +162,12 @@ export class CaptureAudio extends Capture {
         if (!isDefined(audioChain)) {
             return Promise.reject("No audio chain available for recording.");
         }
-        const { gainNode, channelCount } = audioChain;
+        const { recordGainNode, channelCount } = audioChain;
         const recordingWorklet = audioWorklets.createRecording(channelCount, RenderQuantum);
         recordingWorklet.bpm = project.timelineBox.bpm.getValue();
         recordingWorklet.sampleService = sampleService;
         sampleManager.record(recordingWorklet);
-        gainNode.connect(recordingWorklet);
+        recordGainNode.connect(recordingWorklet);
         this.#preparedWorklet = recordingWorklet;
     }
     startRecording() {
@@ -110,10 +180,10 @@ export class CaptureAudio extends Capture {
             return Terminable.Empty;
         }
         this.#preparedWorklet = null;
-        const { gainNode } = audioChain;
+        const { recordGainNode } = audioChain;
         return RecordAudio.start({
             recordingWorklet,
-            sourceNode: gainNode,
+            sourceNode: recordGainNode,
             sampleManager,
             project,
             capture: this,
@@ -157,47 +227,51 @@ export class CaptureAudio extends Capture {
         });
     }
     #stopStream() {
+        this.#disconnectMonitoring();
         this.#destroyAudioChain();
         this.#stream.clear(stream => stream.getAudioTracks().forEach(track => track.stop()));
     }
     #rebuildAudioChain(stream) {
-        const wasMonitoringMode = this.#monitoringMode !== "off" && isDefined(this.#audioChain) ? this.#monitoringMode : "off";
+        this.#disconnectMonitoring();
         this.#destroyAudioChain();
         const { audioContext } = this.manager.project.env;
         const sourceNode = audioContext.createMediaStreamSource(stream);
-        const gainNode = audioContext.createGain();
-        gainNode.gain.value = dbToGain(this.#gainDb);
+        const recordGainNode = audioContext.createGain();
+        recordGainNode.gain.value = dbToGain(this.#gainDb);
         const streamChannelCount = Math.min(stream.getAudioTracks().at(0)?.getSettings().channelCount ?? 2, 2);
         const channelCount = this.#requestChannels.unwrapOrElse(streamChannelCount);
-        gainNode.channelCount = channelCount;
-        gainNode.channelCountMode = "explicit";
-        sourceNode.connect(gainNode);
-        this.#audioChain = { sourceNode, gainNode, channelCount };
-        if (wasMonitoringMode !== "off" || this.#monitoringMode !== "off") {
-            this.#connectMonitoring();
-        }
+        recordGainNode.channelCount = channelCount;
+        recordGainNode.channelCountMode = "explicit";
+        sourceNode.connect(recordGainNode);
+        this.#audioChain = { sourceNode, recordGainNode, channelCount };
+        this.#connectMonitoring();
     }
     #destroyAudioChain() {
         if (isDefined(this.#audioChain)) {
-            const { sourceNode, gainNode } = this.#audioChain;
+            const { sourceNode, recordGainNode } = this.#audioChain;
             sourceNode.disconnect();
-            gainNode.disconnect();
+            recordGainNode.disconnect();
             this.#audioChain = null;
         }
     }
+    #monitorDestination() {
+        return this.#monitorStreamDest ?? this.manager.project.env.audioContext.destination;
+    }
     #connectMonitoring() {
         if (!isDefined(this.#audioChain)) {
             return;
         }
+        const { sourceNode, channelCount } = this.#audioChain;
         switch (this.#monitoringMode) {
             case "off":
                 break;
             case "direct":
-                this.#audioChain.gainNode.connect(this.manager.project.env.audioContext.destination);
+                sourceNode.connect(this.#monitorGainNode);
+                this.#monitorPanNode.connect(this.#monitorDestination());
                 break;
             case "effects":
-                const engine = this.manager.project.engine;
-                engine.registerMonitoringSource(this.audioUnitBox.address.uuid, this.#audioChain.gainNode, this.#audioChain.channelCount);
+                this.manager.project.engine.registerMonitoringSource(this.audioUnitBox.address.uuid, sourceNode, channelCount, this.#monitorGainNode);
+                this.#monitorPanNode.connect(this.#monitorDestination());
                 break;
         }
     }
@@ -209,11 +283,12 @@ export class CaptureAudio extends Capture {
             case "off":
                 break;
             case "direct":
-                this.#audioChain.gainNode.disconnect(this.manager.project.env.audioContext.destination);
+                this.#audioChain.sourceNode.disconnect(this.#monitorGainNode);
+                this.#monitorPanNode.disconnect(this.#monitorDestination());
                 break;
             case "effects":
-                this.#audioChain.gainNode.disconnect();
                 this.manager.project.engine.unregisterMonitoringSource(this.audioUnitBox.address.uuid);
+                this.#monitorPanNode.disconnect(this.#monitorDestination());
                 break;
         }
     }

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,EAMH,UAAU,EAIb,MAAM,kBAAkB,CAAA;AAGzB,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;AAIjC,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,UA8ML,CAAA;;CACJ"}
+{"version":3,"file":"RecordAudio.d.ts","sourceRoot":"","sources":["../../src/capture/RecordAudio.ts"],"names":[],"mappings":"AAAA,OAAO,EAMH,UAAU,EAIb,MAAM,kBAAkB,CAAA;AAGzB,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;AAIjC,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,UAsNL,CAAA;;CACJ"}

package/dist/capture/RecordAudio.js

@@ -124,8 +124,9 @@ export var RecordAudio;
                         pointer.refer(newFileBox.transientMarkers);
                     }
                     oldFileBox.delete();
-                });
+                }, false);
             });
+            editing.mark();
         };
         terminator.ownAll(Terminable.create(() => {
             tryCatch(() => sourceNode.disconnect(recordingWorklet));
@@ -178,10 +179,17 @@ export var RecordAudio;
                 editing.modify(() => {
                     currentTake.ifSome(take => {
                         const actualDurationInSeconds = take.regionBox.duration.getValue();
+                        if (actualDurationInSeconds <= 0) {
+                            take.regionBox.delete();
+                            currentTake = Option.None;
+                            return;
+                        }
                         finalizeTake(take, actualDurationInSeconds);
                         currentWaveformOffset += actualDurationInSeconds;
                     });
-                    startNewTake(loopFrom);
+                    if (currentTake.nonEmpty()) {
+                        startNewTake(loopFrom);
+                    }
                 }, false);
             }
             lastPosition = currentPosition;

package/dist/capture/Recording.js

@@ -37,7 +37,7 @@ export class Recording {
             if (isRecording.getValue() || isCountingIn.getValue()) {
                 return;
             }
-            editing.modify(() => terminator.terminate()); // finalizes recording
+            editing.modify(() => terminator.terminate(), false); // finalizes recording
             this.#isRecording = false;
         };
         terminator.ownAll(engine.isRecording.subscribe(stop), engine.isCountingIn.subscribe(stop), Terminable.create(() => Recording.#instance = Option.None));